![[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.61 bertrand 3: RPL/2 (R) version 4.1.10
1.48 bertrand 4: Copyright (C) 1989-2012 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
1.19 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'r->b'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_r_vers_b(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_argument;
42: struct_objet *s_objet_resultat;
43:
44: (*s_etat_processus).erreur_execution = d_ex;
45:
46: if ((*s_etat_processus).affichage_arguments == 'Y')
47: {
48: printf("\n R->B ");
49:
50: if ((*s_etat_processus).langue == 'F')
51: {
52: printf("(réel vers binaire)\n\n");
53: }
54: else
55: {
56: printf("(real to binary)\n\n");
57: }
58:
59: printf(" 1: %s\n", d_INT);
60: printf("-> 1: %s\n", d_BIN);
61:
62: return;
63: }
64: else if ((*s_etat_processus).test_instruction == 'Y')
65: {
66: (*s_etat_processus).nombre_arguments = -1;
67: return;
68: }
69:
70: if (test_cfsf(s_etat_processus, 31) == d_vrai)
71: {
72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
73: {
74: return;
75: }
76: }
77:
78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
79: &s_objet_argument) == d_erreur)
80: {
81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
82: return;
83: }
84:
85: if ((*s_objet_argument).type == INT)
86: {
87: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
88: {
89: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
90: return;
91: }
92:
93: if ((*((integer8 *) (*s_objet_argument).objet)) < 0)
94: {
95: (*((logical8 *) (*s_objet_resultat).objet)) = 0;
96: }
97: else
98: {
99: (*((logical8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
100: (*s_objet_argument).objet));
101: }
102: }
103: else
104: {
105: liberation(s_etat_processus, s_objet_argument);
106:
107: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
108: return;
109: }
110:
111: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
112: s_objet_resultat) == d_erreur)
113: {
114: return;
115: }
116:
117: liberation(s_etat_processus, s_objet_argument);
118: return;
119: }
120:
121:
122: /*
123: ================================================================================
124: Fonction 'rl'
125: ================================================================================
126: Entrées : pointeur sur une structure struct_processus
127: --------------------------------------------------------------------------------
128: Sorties :
129: --------------------------------------------------------------------------------
130: Effets de bord : néant
131: ================================================================================
132: */
133:
134: void
135: instruction_rl(struct_processus *s_etat_processus)
136: {
137: logical8 masque;
138: logical8 tampon;
139:
140: struct_objet *s_copie;
141: struct_objet *s_objet;
142:
143: unsigned long i;
144: unsigned long j;
145: unsigned long longueur;
146:
147: (*s_etat_processus).erreur_execution = d_ex;
148:
149: if ((*s_etat_processus).affichage_arguments == 'Y')
150: {
151: printf("\n RL ");
152:
153: if ((*s_etat_processus).langue == 'F')
154: {
155: printf("(rotation à gauche)\n\n");
156: }
157: else
158: {
159: printf("(rotate left)\n\n");
160: }
161:
162: printf(" 1: %s\n", d_BIN);
163: printf("-> 1: %s\n", d_BIN);
164:
165: return;
166: }
167: else if ((*s_etat_processus).test_instruction == 'Y')
168: {
169: (*s_etat_processus).nombre_arguments = -1;
170: return;
171: }
172:
173: if (test_cfsf(s_etat_processus, 31) == d_vrai)
174: {
175: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
176: {
177: return;
178: }
179: }
180:
181: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
182: &s_objet) == d_erreur)
183: {
184: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
185: return;
186: }
187:
188: if ((*s_objet).type == BIN)
189: {
190: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
191: {
192: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
193: return;
194: }
195:
196: longueur = 1;
197: j = 1;
198:
199: for(i = 37; i <= 42; i++)
200: {
201: longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
202: == d_vrai) ? j : 0;
203: j *= 2;
204: }
205:
206: tampon = (*((logical8 *) (*s_copie).objet));
207: masque = ((logical8) 1) << (longueur - 1);
208:
209: if ((tampon & masque) == 0)
210: {
211: tampon <<= 1;
212: }
213: else
214: {
215: tampon <<= 1;
216: tampon |= (logical8) 1;
217: }
218:
219: for(masque = 0, i = 0; i < longueur; i++)
220: {
221: masque <<= 1;
222: masque |= (logical8) 1;
223: }
224:
225: tampon &= masque;
226: (*((logical8 *) (*s_copie).objet)) = tampon;
227:
228: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
229: s_copie) == d_erreur)
230: {
231: return;
232: }
233: }
234: else
235: {
236: liberation(s_etat_processus, s_objet);
237:
238: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
239: return;
240: }
241:
242: liberation(s_etat_processus, s_objet);
243:
244: return;
245: }
246:
247:
248: /*
249: ================================================================================
250: Fonction 'rlb'
251: ================================================================================
252: Entrées : pointeur sur une structure struct_processus
253: --------------------------------------------------------------------------------
254: Sorties :
255: --------------------------------------------------------------------------------
256: Effets de bord : néant
257: ================================================================================
258: */
259:
260: void
261: instruction_rlb(struct_processus *s_etat_processus)
262: {
263: struct_liste_chainee *l_base_pile;
264:
265: unsigned long i;
266:
267: (*s_etat_processus).erreur_execution = d_ex;
268:
269: if ((*s_etat_processus).affichage_arguments == 'Y')
270: {
271: printf("\n RLB ");
272:
273: if ((*s_etat_processus).langue == 'F')
274: {
275: printf("(rotation d'un octet vers la gauche)\n\n");
276: }
277: else
278: {
279: printf("(rotate left byte)\n\n");
280: }
281:
282: printf(" 1: %s\n", d_BIN);
283: printf("-> 1: %s\n", d_BIN);
284:
285: return;
286: }
287: else if ((*s_etat_processus).test_instruction == 'Y')
288: {
289: (*s_etat_processus).nombre_arguments = -1;
290: return;
291: }
292:
293: if (test_cfsf(s_etat_processus, 31) == d_vrai)
294: {
295: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
296: {
297: return;
298: }
299: }
300:
301: l_base_pile = (*s_etat_processus).l_base_pile_last;
302: (*s_etat_processus).l_base_pile_last = NULL;
303:
304: for(i = 0; i < 8; i++)
305: {
306: instruction_rl(s_etat_processus);
307:
308: if (((*s_etat_processus).erreur_systeme != d_es) ||
309: ((*s_etat_processus).erreur_execution != d_ex))
310: {
311: break;
312: }
313: }
314:
315: if (test_cfsf(s_etat_processus, 31) == d_vrai)
316: {
317: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
318: {
319: return;
320: }
321: }
322:
323: (*s_etat_processus).l_base_pile_last = l_base_pile;
324: return;
325: }
326:
327:
328: /*
329: ================================================================================
330: Fonction 'rr'
331: ================================================================================
332: Entrées : pointeur sur une structure struct_processus
333: --------------------------------------------------------------------------------
334: Sorties :
335: --------------------------------------------------------------------------------
336: Effets de bord : néant
337: ================================================================================
338: */
339:
340: void
341: instruction_rr(struct_processus *s_etat_processus)
342: {
343: logical8 masque;
344: logical8 tampon;
345:
346: struct_objet *s_copie;
347: struct_objet *s_objet;
348:
349: unsigned long i;
350: unsigned long j;
351: unsigned long longueur;
352:
353: (*s_etat_processus).erreur_execution = d_ex;
354:
355: if ((*s_etat_processus).affichage_arguments == 'Y')
356: {
357: printf("\n RR ");
358:
359: if ((*s_etat_processus).langue == 'F')
360: {
361: printf("(rotation à droite)\n\n");
362: }
363: else
364: {
365: printf("(rotate right)\n\n");
366: }
367:
368: printf(" 1: %s\n", d_BIN);
369: printf("-> 1: %s\n", d_BIN);
370:
371: return;
372: }
373: else if ((*s_etat_processus).test_instruction == 'Y')
374: {
375: (*s_etat_processus).nombre_arguments = -1;
376: return;
377: }
378:
379: if (test_cfsf(s_etat_processus, 31) == d_vrai)
380: {
381: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
382: {
383: return;
384: }
385: }
386:
387: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
388: &s_objet) == d_erreur)
389: {
390: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
391: return;
392: }
393:
394: if ((*s_objet).type == BIN)
395: {
396: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
397: {
398: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
399: return;
400: }
401:
402: longueur = 1;
403: j = 1;
404:
405: for(i = 37; i <= 42; i++)
406: {
407: longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
408: == d_vrai) ? j : 0;
409: j *= 2;
410: }
411:
412: tampon = (*((logical8 *) (*s_copie).objet));
413: masque = (logical8) 1;
414:
415: if ((tampon & masque) == 0)
416: {
417: tampon >>= 1;
418: }
419: else
420: {
421: tampon >>= 1;
422: tampon |= (((logical8) 1) << (longueur - 1));
423: }
424:
425: for(masque = 0, i = 0; i < longueur; i++)
426: {
427: masque <<= 1;
428: masque |= 1;
429: }
430:
431: tampon &= masque;
432: (*((logical8 *) (*s_copie).objet)) = tampon;
433:
434: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
435: s_copie) == d_erreur)
436: {
437: return;
438: }
439: }
440: else
441: {
442: liberation(s_etat_processus, s_objet);
443:
444: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
445: return;
446: }
447:
448: liberation(s_etat_processus, s_objet);
449:
450: return;
451: }
452:
453:
454: /*
455: ================================================================================
456: Fonction 'rrb'
457: ================================================================================
458: Entrées : pointeur sur une structure struct_processus
459: --------------------------------------------------------------------------------
460: Sorties :
461: --------------------------------------------------------------------------------
462: Effets de bord : néant
463: ================================================================================
464: */
465:
466: void
467: instruction_rrb(struct_processus *s_etat_processus)
468: {
469: struct_liste_chainee *l_base_pile;
470:
471: unsigned long i;
472:
473: (*s_etat_processus).erreur_execution = d_ex;
474:
475: if ((*s_etat_processus).affichage_arguments == 'Y')
476: {
477: printf("\n RRB ");
478:
479: if ((*s_etat_processus).langue == 'F')
480: {
481: printf("(rotation d'un octet vers la droite)\n\n");
482: }
483: else
484: {
485: printf("(rotate right byte)\n\n");
486: }
487:
488: printf(" 1: %s\n", d_BIN);
489: printf("-> 1: %s\n", d_BIN);
490:
491: return;
492: }
493: else if ((*s_etat_processus).test_instruction == 'Y')
494: {
495: (*s_etat_processus).nombre_arguments = -1;
496: return;
497: }
498:
499: if (test_cfsf(s_etat_processus, 31) == d_vrai)
500: {
501: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
502: {
503: return;
504: }
505: }
506:
507: l_base_pile = (*s_etat_processus).l_base_pile_last;
508: (*s_etat_processus).l_base_pile_last = NULL;
509:
510: for(i = 0; i < 8; i++)
511: {
512: instruction_rr(s_etat_processus);
513:
514: if (((*s_etat_processus).erreur_systeme != d_es) ||
515: ((*s_etat_processus).erreur_execution != d_ex))
516: {
517: break;
518: }
519: }
520:
521: if (test_cfsf(s_etat_processus, 31) == d_vrai)
522: {
523: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
524: {
525: return;
526: }
527: }
528:
529: (*s_etat_processus).l_base_pile_last = l_base_pile;
530: return;
531: }
532:
533:
534: /*
535: ================================================================================
536: Fonction 'redraw'
537: ================================================================================
538: Entrées : pointeur sur une structure struct_processus
539: --------------------------------------------------------------------------------
540: Sorties :
541: --------------------------------------------------------------------------------
542: Effets de bord : néant
543: ================================================================================
544: */
545:
546: void
547: instruction_redraw(struct_processus *s_etat_processus)
548: {
549: (*s_etat_processus).erreur_execution = d_ex;
550:
551: if ((*s_etat_processus).affichage_arguments == 'Y')
552: {
553: printf("\n REDRAW ");
554:
555: if ((*s_etat_processus).langue == 'F')
556: {
557: printf("(redessine une courbe)\n\n");
558: printf(" Aucun argument\n");
559: }
560: else
561: {
562: printf("(redraw a graphic)\n\n");
563: printf(" No argument\n");
564: }
565:
566: return;
567: }
568: else if ((*s_etat_processus).test_instruction == 'Y')
569: {
570: (*s_etat_processus).nombre_arguments = -1;
571: return;
572: }
573:
574: if (test_cfsf(s_etat_processus, 31) == d_vrai)
575: {
576: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
577: {
578: return;
579: }
580: }
581:
582: if ((*s_etat_processus).mise_a_jour_trace_requise == d_vrai)
583: {
584: (*s_etat_processus).erreur_execution = d_ex_graphique_memorise;
585: return;
586: }
587:
588: if ((*s_etat_processus).fichiers_graphiques != NULL)
589: {
590: appel_gnuplot(s_etat_processus, 'N');
591: }
592:
593: return;
594: }
595:
596:
597: /*
598: ================================================================================
599: Fonction 'remove'
600: ================================================================================
601: Entrées : pointeur sur une structure struct_processus
602: --------------------------------------------------------------------------------
603: Sorties :
604: --------------------------------------------------------------------------------
605: Effets de bord : néant
606: ================================================================================
607: */
608:
609: void
610: instruction_remove(struct_processus *s_etat_processus)
611: {
612: struct_objet *s_objet_argument;
613:
614: (*s_etat_processus).erreur_execution = d_ex;
615:
616: if ((*s_etat_processus).affichage_arguments == 'Y')
617: {
618: printf("\n REMOVE ");
619:
620: if ((*s_etat_processus).langue == 'F')
621: {
622: printf("(retrait d'une bibliothèque dynamique)\n\n");
623: }
624: else
625: {
626: printf("(remove a shared library)\n\n");
627: }
628:
629: printf(" 1: %s\n", d_SLB);
630:
631: return;
632: }
633: else if ((*s_etat_processus).test_instruction == 'Y')
634: {
635: (*s_etat_processus).nombre_arguments = -1;
636: return;
637: }
638:
639: if (test_cfsf(s_etat_processus, 31) == d_vrai)
640: {
641: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
642: {
643: return;
644: }
645: }
646:
647: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
648: &s_objet_argument) == d_erreur)
649: {
650: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
651: return;
652: }
653:
654: if ((*s_objet_argument).type == SLB)
655: {
656: /*
657: * On ne décharge que les bibliothèques qui ont été chargées dans
658: * le couple pid/tid courant.
659: */
660:
661: if (((*((struct_bibliotheque *) (*s_objet_argument).objet)).pid ==
662: getpid()) && (pthread_equal((*((struct_bibliotheque *)
663: (*s_objet_argument).objet)).tid, pthread_self()) != 0))
664: {
665: if (retrait_bibliotheque(s_etat_processus,
666: (*s_objet_argument).objet) == d_erreur)
667: {
668: liberation(s_etat_processus, s_objet_argument);
669:
670: return;
671: }
672: }
673: }
674: else
675: {
676: liberation(s_etat_processus, s_objet_argument);
677:
678: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
679: return;
680: }
681:
682: liberation(s_etat_processus, s_objet_argument);
683:
684: return;
685: }
686:
687:
688: /*
689: ================================================================================
690: Fonction 'relax'
691: ================================================================================
692: Entrées : pointeur sur une structure struct_processus
693: --------------------------------------------------------------------------------
694: Sorties :
695: --------------------------------------------------------------------------------
696: Effets de bord : néant
697: ================================================================================
698: */
699:
700: void
701: instruction_relax(struct_processus *s_etat_processus)
702: {
703: (*s_etat_processus).erreur_execution = d_ex;
704:
705: if ((*s_etat_processus).affichage_arguments == 'Y')
706: {
707: printf("\n RELAX ");
708:
709: if ((*s_etat_processus).langue == 'F')
710: {
711: printf("(ne fait rien)\n\n");
712: printf(" Aucun argument\n");
713: }
714: else
715: {
716: printf("(do nothing)\n\n");
717: printf(" No argument\n");
718: }
719:
720: return;
721: }
722: else if ((*s_etat_processus).test_instruction == 'Y')
723: {
724: (*s_etat_processus).nombre_arguments = 1;
725: return;
726: }
727:
728: /*
729: * Cette instruction ne fait rien. Elle existe pour être symétrique
730: * à l'instruction CHS et permet de traiter les équations de façon
731: * simple (Ex : '+pi'). En principe, elle n'a pas a être appelée
732: * directement par l'utilisateur.
733: */
734:
735: return;
736: }
737:
738:
739: /*
740: ================================================================================
741: Fonction 'rewind'
742: ================================================================================
743: Entrées : pointeur sur une structure struct_processus
744: --------------------------------------------------------------------------------
745: Sorties :
746: --------------------------------------------------------------------------------
747: Effets de bord : néant
748: ================================================================================
749: */
750:
751: void
752: instruction_rewind(struct_processus *s_etat_processus)
753: {
1.5 bertrand 754: struct_descripteur_fichier *descripteur;
1.1 bertrand 755:
756: struct_objet *s_objet_argument;
757:
758: (*s_etat_processus).erreur_execution = d_ex;
759:
760: if ((*s_etat_processus).affichage_arguments == 'Y')
761: {
762: printf("\n REWIND ");
763:
764: if ((*s_etat_processus).langue == 'F')
765: {
766: printf("(retour au début d'un fichier)\n\n");
767: }
768: else
769: {
770: printf("(rewind a file)\n\n");
771: }
772:
773: printf(" 1: %s\n", d_FCH);
774:
775: return;
776: }
777: else if ((*s_etat_processus).test_instruction == 'Y')
778: {
779: (*s_etat_processus).nombre_arguments = -1;
780: return;
781: }
782:
783: if (test_cfsf(s_etat_processus, 31) == d_vrai)
784: {
785: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
786: {
787: return;
788: }
789: }
790:
791: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
792: &s_objet_argument) == d_erreur)
793: {
794: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
795: return;
796: }
797:
798: if ((*s_objet_argument).type == FCH)
799: {
800: if ((descripteur = descripteur_fichier(s_etat_processus,
801: (struct_fichier *) (*s_objet_argument).objet)) == NULL)
802: {
803: return;
804: }
805:
1.5 bertrand 806: if ((*descripteur).type == 'C')
807: {
808: if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_SET) != 0)
809: {
810: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
811: return;
812: }
813: }
814: else
1.1 bertrand 815: {
816: liberation(s_etat_processus, s_objet_argument);
817:
1.5 bertrand 818: (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
1.1 bertrand 819: return;
820: }
821: }
822: else
823: {
824: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
825: return;
826: }
827:
828: liberation(s_etat_processus, s_objet_argument);
829:
830: return;
831: }
832:
833:
834: /*
835: ================================================================================
836: Fonction 'read'
837: ================================================================================
838: Entrées : pointeur sur une structure struct_processus
839: --------------------------------------------------------------------------------
840: Sorties :
841: --------------------------------------------------------------------------------
842: Effets de bord : néant
843: ================================================================================
844: */
845:
846: void
847: instruction_read(struct_processus *s_etat_processus)
848: {
1.6 bertrand 849: const char *queue;
850:
1.28 bertrand 851: int c;
1.8 bertrand 852: int ios;
853:
1.55 bertrand 854: integer8 ancienne_longueur_effective;
1.8 bertrand 855: integer8 element;
1.46 bertrand 856: integer8 i;
1.8 bertrand 857: integer8 id;
858: integer8 position_clef;
1.46 bertrand 859: integer8 longueur_effective;
860: integer8 longueur_enregistrement;
861: integer8 longueur_questure;
862: integer8 niveau;
863: integer8 pointeur;
864: integer8 position_finale;
865: integer8 position_initiale;
866:
1.59 bertrand 867: logical1 format_degenere;
1.1 bertrand 868: logical1 indicateur_48;
869: logical1 presence_chaine;
870: logical1 presence_indicateur;
1.57 bertrand 871: logical1 trame_complete;
1.1 bertrand 872:
1.59 bertrand 873: long longueur;
874:
1.1 bertrand 875: socklen_t longueur_adresse;
876:
1.6 bertrand 877: sqlite3_stmt *ppStmt;
878:
1.1 bertrand 879: struct flock lock;
880:
1.54 bertrand 881: struct pollfd poll_fd;
882:
1.1 bertrand 883: struct sockaddr_un adresse_unix;
884: struct sockaddr_in adresse_ipv4;
1.19 bertrand 885: # ifdef IPV6
1.1 bertrand 886: struct sockaddr_in6 adresse_ipv6;
1.19 bertrand 887: # endif
1.1 bertrand 888:
889: struct timespec attente;
890:
1.5 bertrand 891: struct_descripteur_fichier *descripteur;
892:
1.8 bertrand 893: struct_liste_chainee *l_element_courant;
1.59 bertrand 894: struct_liste_chainee *l_element_courant_format;
1.8 bertrand 895: struct_liste_chainee *l_element_inclus;
1.46 bertrand 896: struct_liste_chainee *l_element_suivant;
1.8 bertrand 897:
1.1 bertrand 898: struct_objet *s_objet_adresse;
1.6 bertrand 899: struct_objet *s_objet_argument_1;
900: struct_objet *s_objet_argument_2;
1.46 bertrand 901: struct_objet *s_objet_element;
1.1 bertrand 902: struct_objet *s_objet_resultat;
903: struct_objet *s_objet_type;
904:
905: unsigned char caractere;
1.8 bertrand 906: unsigned char *clef_utf8;
1.6 bertrand 907: unsigned char *commande;
1.59 bertrand 908: unsigned char *format_chaine;
1.55 bertrand 909: unsigned char poubelle[256];
1.28 bertrand 910: unsigned char *ptr;
1.1 bertrand 911: unsigned char *tampon_lecture;
912: unsigned char *tampon;
1.8 bertrand 913: unsigned char *tampon2;
1.46 bertrand 914: unsigned char type_enregistrement;
1.1 bertrand 915:
916: (*s_etat_processus).erreur_execution = d_ex;
917:
918: if ((*s_etat_processus).affichage_arguments == 'Y')
919: {
920: printf("\n READ ");
921:
922: if ((*s_etat_processus).langue == 'F')
923: {
924: printf("(lecture d'un enregistrement d'un fichier)\n\n");
925: }
926: else
927: {
928: printf("(read a record of a file)\n\n");
929: }
930:
1.6 bertrand 931: printf(" 1: %s, %s\n\n", d_FCH, d_SCK);
1.1 bertrand 932:
1.8 bertrand 933: printf(" 2: %s, %s\n", d_INT, d_CHN);
1.6 bertrand 934: printf(" 1: %s\n", d_FCH);
1.1 bertrand 935: return;
936: }
937: else if ((*s_etat_processus).test_instruction == 'Y')
938: {
939: (*s_etat_processus).nombre_arguments = -1;
940: return;
941: }
942:
943: if (test_cfsf(s_etat_processus, 31) == d_vrai)
944: {
1.6 bertrand 945: if ((*s_etat_processus).l_base_pile == NULL)
1.1 bertrand 946: {
1.6 bertrand 947: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1.1 bertrand 948: return;
949: }
1.6 bertrand 950:
951: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
952: {
953: if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
954: .donnee).objet)).acces == 'S')
955: {
956: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
957: {
958: return;
959: }
960: }
961: else
962: {
963: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
964: {
965: return;
966: }
967: }
968: }
969: else
970: {
971: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
972: {
973: return;
974: }
975: }
1.1 bertrand 976: }
977:
978: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1.6 bertrand 979: &s_objet_argument_1) == d_erreur)
1.1 bertrand 980: {
981: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
982: return;
983: }
984:
1.6 bertrand 985: if ((*s_objet_argument_1).type == FCH)
1.1 bertrand 986: {
1.5 bertrand 987: if ((descripteur = descripteur_fichier(s_etat_processus,
1.6 bertrand 988: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
1.5 bertrand 989: {
990: return;
991: }
992:
1.1 bertrand 993: /*
994: * Vérification des verrous
995: */
996:
997: lock.l_type = F_RDLCK;
998: lock.l_whence = SEEK_SET;
999: lock.l_start = 0;
1000: lock.l_len = 0;
1001: lock.l_pid = getpid();
1002:
1.5 bertrand 1003: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
1004: == -1)
1.1 bertrand 1005: {
1.6 bertrand 1006: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1007:
1008: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1009: return;
1010: }
1011:
1012: if (lock.l_type != F_UNLCK)
1013: {
1.6 bertrand 1014: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1015:
1016: (*s_etat_processus).erreur_execution =
1017: d_ex_fichier_verrouille;
1018: return;
1019: }
1020:
1021: /*
1022: * Vérification de l'autorisation de lecture
1023: */
1024:
1.6 bertrand 1025: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1026: == 'W')
1.1 bertrand 1027: {
1.6 bertrand 1028: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1029:
1030: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1031: return;
1032: }
1.6 bertrand 1033: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1.1 bertrand 1034: == 'N')
1035: {
1.5 bertrand 1036: if ((*descripteur).type == 'C')
1.1 bertrand 1037: {
1.5 bertrand 1038: if (fflush((*descripteur).descripteur_c) != 0)
1039: {
1040: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1041: return;
1042: }
1.1 bertrand 1043: }
1044: }
1045:
1.6 bertrand 1046: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
1.1 bertrand 1047: {
1048: /*
1049: * Fichiers formatés
1050: */
1051:
1.6 bertrand 1052: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1053: == 'S')
1.1 bertrand 1054: {
1055: /*
1056: * Fichiers séquentiels
1057: */
1058:
1059: longueur_questure = 256;
1060:
1061: if ((tampon_lecture = malloc(longueur_questure *
1062: sizeof(unsigned char))) == NULL)
1063: {
1064: (*s_etat_processus).erreur_systeme =
1065: d_es_allocation_memoire;
1066: return;
1067: }
1068:
1.5 bertrand 1069: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1070:
1071: if ((position_initiale = ftell((*descripteur).descripteur_c))
1072: == -1)
1.1 bertrand 1073: {
1074: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1075: return;
1076: }
1077:
1078: do
1079: {
1080: longueur_effective = fread(tampon_lecture,
1081: (size_t) sizeof(unsigned char), longueur_questure,
1.5 bertrand 1082: (*descripteur).descripteur_c);
1.1 bertrand 1083:
1084: pointeur = 0;
1085: presence_indicateur = d_faux;
1086:
1087: while(pointeur < longueur_effective)
1088: {
1089: if (tampon_lecture[pointeur] == '{')
1090: {
1091: presence_indicateur = d_vrai;
1092: break;
1093: }
1094:
1095: position_initiale++;
1096: pointeur++;
1097: }
1098:
1099: if (presence_indicateur == d_vrai)
1100: {
1101: break;
1102: }
1103: } while(longueur_effective == longueur_questure);
1104:
1105: if (presence_indicateur == d_faux)
1106: {
1.6 bertrand 1107: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1108: free(tampon_lecture);
1109:
1110: (*s_etat_processus).erreur_execution =
1111: d_ex_fin_de_fichier_atteinte;
1112: return;
1113: }
1114:
1115: position_finale = position_initiale + 1;
1116: presence_chaine = d_faux;
1117: niveau = 1;
1118:
1.5 bertrand 1119: if (fseek((*descripteur).descripteur_c, position_finale,
1120: SEEK_SET) != 0)
1.1 bertrand 1121: {
1.6 bertrand 1122: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1123: free(tampon_lecture);
1124:
1125: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1126: return;
1127: }
1128:
1129: do
1130: {
1131: longueur_effective = fread(tampon_lecture,
1132: (size_t) sizeof(unsigned char), longueur_questure,
1.5 bertrand 1133: (*descripteur).descripteur_c);
1.1 bertrand 1134:
1135: pointeur = 0;
1136: presence_indicateur = d_faux;
1137:
1138: while(pointeur < longueur_effective)
1139: {
1140: if (tampon_lecture[pointeur] == '"')
1141: {
1.7 bertrand 1142: if (pointeur > 0)
1143: {
1144: if (tampon_lecture[pointeur - 1] != '\\')
1145: {
1146: presence_chaine = (presence_chaine ==
1147: d_vrai) ? d_faux : d_vrai;
1148: }
1149: }
1150: else
1151: {
1152: presence_chaine = (presence_chaine == d_vrai)
1153: ? d_faux : d_vrai;
1154: }
1.1 bertrand 1155: }
1156: else
1157: {
1158: if (presence_chaine == d_faux)
1159: {
1160: if (tampon_lecture[pointeur] == '{')
1161: {
1162: niveau++;
1163: }
1164: else if (tampon_lecture[pointeur] == '}')
1165: {
1166: niveau--;
1167: }
1168: }
1169: }
1170:
1171: position_finale++;
1172: pointeur++;
1173:
1174: if (niveau == 0)
1175: {
1176: presence_indicateur = d_vrai;
1177: break;
1178: }
1179: }
1180:
1181: if (presence_indicateur == d_vrai)
1182: {
1183: break;
1184: }
1185: } while(longueur_effective == longueur_questure);
1186:
1187: if (presence_indicateur == d_faux)
1188: {
1.6 bertrand 1189: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1190: free(tampon_lecture);
1191:
1192: (*s_etat_processus).erreur_execution =
1193: d_ex_fin_de_fichier_atteinte;
1194: return;
1195: }
1196:
1197: free(tampon_lecture);
1198: longueur_enregistrement = position_finale - position_initiale;
1199:
1200: if ((tampon_lecture = malloc((longueur_enregistrement + 1) *
1201: sizeof(unsigned char))) == NULL)
1202: {
1203: (*s_etat_processus).erreur_systeme =
1204: d_es_allocation_memoire;
1205: return;
1206: }
1207:
1.5 bertrand 1208: if (fseek((*descripteur).descripteur_c, position_initiale,
1209: SEEK_SET) != 0)
1.1 bertrand 1210: {
1.6 bertrand 1211: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1212: free(tampon_lecture);
1213:
1214: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1215: return;
1216: }
1217:
1218: longueur_effective = fread(tampon_lecture,
1219: (size_t) sizeof(unsigned char),
1220: (size_t) longueur_enregistrement,
1.5 bertrand 1221: (*descripteur).descripteur_c);
1.1 bertrand 1222:
1223: if (longueur_effective != longueur_enregistrement)
1224: {
1225: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1226: return;
1227: }
1228:
1229: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
1230: tampon = (*s_etat_processus).instruction_courante;
1.5 bertrand 1231:
1232: if (((*s_etat_processus).instruction_courante =
1233: transliteration(s_etat_processus, tampon_lecture,
1234: "UTF-8", d_locale)) == NULL)
1235: {
1.6 bertrand 1236: (*s_etat_processus).instruction_courante = tampon;
1237: liberation(s_etat_processus, s_objet_argument_1);
1.5 bertrand 1238: free(tampon_lecture);
1239: return;
1240: }
1.1 bertrand 1241:
1242: indicateur_48 = test_cfsf(s_etat_processus, 48);
1243: cf(s_etat_processus, 48);
1244:
1245: recherche_type(s_etat_processus);
1.5 bertrand 1246: free((*s_etat_processus).instruction_courante);
1.1 bertrand 1247:
1248: if ((*s_etat_processus).erreur_execution != d_ex)
1249: {
1.6 bertrand 1250: if (indicateur_48 == d_vrai)
1251: {
1252: sf(s_etat_processus, 48);
1253: }
1254: else
1255: {
1256: cf(s_etat_processus, 48);
1257: }
1258:
1.1 bertrand 1259: (*s_etat_processus).instruction_courante = tampon;
1260: free(tampon_lecture);
1261:
1.6 bertrand 1262: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1263: return;
1264: }
1265:
1266: if (indicateur_48 == d_vrai)
1267: {
1268: sf(s_etat_processus, 48);
1269: }
1270: else
1271: {
1272: cf(s_etat_processus, 48);
1273: }
1274:
1275: (*s_etat_processus).instruction_courante = tampon;
1276: free(tampon_lecture);
1277: }
1.6 bertrand 1278: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1.1 bertrand 1279: == 'D')
1280: {
1.6 bertrand 1281: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1282:
1283: if (depilement(s_etat_processus, &((*s_etat_processus)
1284: .l_base_pile), &s_objet_argument_2) == d_erreur)
1285: {
1286: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1287: return;
1288: }
1289:
1290: if ((*s_objet_argument_2).type != INT)
1291: {
1292: liberation(s_etat_processus, s_objet_argument_1);
1293: liberation(s_etat_processus, s_objet_argument_2);
1294:
1295: (*s_etat_processus).erreur_execution =
1296: d_ex_erreur_type_argument;
1297: return;
1298: }
1299:
1300: if (alsprintf(&commande, "select data from data where "
1301: "id = %lld", (*((integer8 *) (*s_objet_argument_2)
1302: .objet))) < 0)
1303: {
1304: (*s_etat_processus).erreur_systeme =
1305: d_es_allocation_memoire;
1306: return;
1307: }
1308:
1309: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1310: commande, strlen(commande), &ppStmt, &queue)
1311: != SQLITE_OK)
1312: {
1313: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1314: return;
1315: }
1316:
1317: switch(sqlite3_step(ppStmt))
1318: {
1319: case SQLITE_ROW:
1320: {
1321: // Résultat attendu
1322: break;
1323: }
1324:
1325: case SQLITE_DONE:
1326: {
1327: // Aucun enregistrement
1328: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1329: {
1330: (*s_etat_processus).erreur_systeme =
1331: d_es_erreur_fichier;
1332: return;
1333: }
1334:
1335: free(commande);
1336:
1337: liberation(s_etat_processus, s_objet_argument_1);
1338: liberation(s_etat_processus, s_objet_argument_2);
1339:
1340: (*s_etat_processus).erreur_execution =
1341: d_ex_enregistrement_inexistant;
1342: return;
1343: }
1344:
1345: default:
1346: {
1347: (*s_etat_processus).erreur_systeme =
1348: d_es_erreur_fichier;
1349: return;
1350: }
1351: }
1352:
1353: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1354: {
1355: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1356: return;
1357: }
1358:
1359: tampon = (*s_etat_processus).instruction_courante;
1360:
1361: if ((tampon_lecture = (unsigned char *)
1362: sqlite3_column_text(ppStmt, 0)) == NULL)
1363: {
1364: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1365: return;
1366: }
1367:
1368: if (((*s_etat_processus).instruction_courante =
1369: transliteration(s_etat_processus, tampon_lecture,
1370: "UTF-8", d_locale)) == NULL)
1371: {
1372: (*s_etat_processus).instruction_courante = tampon;
1373:
1374: liberation(s_etat_processus, s_objet_argument_1);
1375: liberation(s_etat_processus, s_objet_argument_2);
1376: free(commande);
1377: return;
1378: }
1379:
1380: indicateur_48 = test_cfsf(s_etat_processus, 48);
1381: cf(s_etat_processus, 48);
1382:
1383: recherche_type(s_etat_processus);
1384:
1385: if ((*s_etat_processus).erreur_execution != d_ex)
1386: {
1387: if (indicateur_48 == d_vrai)
1388: {
1389: sf(s_etat_processus, 48);
1390: }
1391: else
1392: {
1393: cf(s_etat_processus, 48);
1394: }
1395:
1396: liberation(s_etat_processus, s_objet_argument_1);
1397: liberation(s_etat_processus, s_objet_argument_2);
1398:
1399: free((*s_etat_processus).instruction_courante);
1400: free(commande);
1.8 bertrand 1401:
1402: (*s_etat_processus).instruction_courante = tampon;
1.6 bertrand 1403: return;
1404: }
1405:
1406: if (indicateur_48 == d_vrai)
1407: {
1408: sf(s_etat_processus, 48);
1409: }
1410: else
1411: {
1412: cf(s_etat_processus, 48);
1413: }
1414:
1415: free((*s_etat_processus).instruction_courante);
1416: liberation(s_etat_processus, s_objet_argument_2);
1417: (*s_etat_processus).instruction_courante = tampon;
1418:
1419: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1420: {
1421: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1422: return;
1423: }
1424:
1425: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1426: {
1427: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1428: return;
1429: }
1430:
1431: free(commande);
1.1 bertrand 1432: }
1433: else
1434: {
1.8 bertrand 1435: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1436:
1437: if (depilement(s_etat_processus, &((*s_etat_processus)
1438: .l_base_pile), &s_objet_argument_2) == d_erreur)
1439: {
1440: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1441: return;
1442: }
1443:
1444: if ((*s_objet_argument_2).type != CHN)
1445: {
1446: liberation(s_etat_processus, s_objet_argument_1);
1447: liberation(s_etat_processus, s_objet_argument_2);
1448:
1449: (*s_etat_processus).erreur_execution =
1450: d_ex_erreur_type_argument;
1451: return;
1452: }
1453:
1454: // Récupération de la position de la clef
1455:
1456: if (alsprintf(&commande, "select key from control "
1457: "where id = 1") < 0)
1458: {
1459: (*s_etat_processus).erreur_systeme =
1460: d_es_allocation_memoire;
1461: return;
1462: }
1463:
1464: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1465: commande, strlen(commande), &ppStmt, &queue)
1466: != SQLITE_OK)
1467: {
1468: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1469: return;
1470: }
1471:
1472: if (sqlite3_step(ppStmt) != SQLITE_ROW)
1473: {
1474: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1475: return;
1476: }
1477:
1478: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1479: {
1480: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1481: return;
1482: }
1483:
1484: position_clef = sqlite3_column_int64(ppStmt, 0);
1485:
1486: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1487: {
1488: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1489: return;
1490: }
1491:
1492: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1493: {
1494: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1495: return;
1496: }
1497:
1498: free(commande);
1499:
1500: if ((clef_utf8 = transliteration(s_etat_processus,
1501: (unsigned char *) (*s_objet_argument_2).objet,
1502: d_locale, "UTF-8")) == NULL)
1503: {
1504: liberation(s_etat_processus, s_objet_argument_1);
1505: liberation(s_etat_processus, s_objet_argument_2);
1506:
1507: return;
1508: }
1509:
1510: // Récupération de l'identifiant de la clef
1511:
1512: if (alsprintf(&commande, "select id from key where key = "
1513: "'{ \"%s\" }'", clef_utf8) < 0)
1514: {
1515: (*s_etat_processus).erreur_systeme =
1516: d_es_allocation_memoire;
1517: return;
1518: }
1519:
1520: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1521: commande, strlen(commande), &ppStmt, &queue)
1522: != SQLITE_OK)
1523: {
1524: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1525: return;
1526: }
1527:
1528: switch(sqlite3_step(ppStmt))
1529: {
1530: case SQLITE_ROW:
1531: {
1532: // Résultat attendu : une clef correspond.
1533: break;
1534: }
1535:
1536: case SQLITE_DONE:
1537: {
1538: // Aucun enregistrement
1539: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1540: {
1541: (*s_etat_processus).erreur_systeme =
1542: d_es_erreur_fichier;
1543: return;
1544: }
1545:
1546: free(clef_utf8);
1547: free(commande);
1548:
1549: liberation(s_etat_processus, s_objet_argument_1);
1550: liberation(s_etat_processus, s_objet_argument_2);
1551:
1552: (*s_etat_processus).erreur_execution =
1553: d_ex_enregistrement_inexistant;
1554: return;
1555: }
1556:
1557: default:
1558: {
1559: (*s_etat_processus).erreur_systeme =
1560: d_es_erreur_fichier;
1561: return;
1562: }
1563: }
1564:
1565: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1566: {
1567: free(clef_utf8);
1568: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1569: return;
1570: }
1571:
1572: id = sqlite3_column_int64(ppStmt, 0);
1573:
1574: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1575: {
1576: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1577: return;
1578: }
1579:
1580: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1581: {
1582: (*s_etat_processus).erreur_systeme =
1583: d_es_erreur_fichier;
1584: return;
1585: }
1586:
1587: free(commande);
1588:
1589: if (alsprintf(&commande, "select data from data where "
1590: "key_id = %lld order by sequence asc", id) < 0)
1591: {
1592: (*s_etat_processus).erreur_systeme =
1593: d_es_allocation_memoire;
1594: return;
1595: }
1596:
1597: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1598: commande, strlen(commande), &ppStmt, &queue)
1599: != SQLITE_OK)
1600: {
1601: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1602: return;
1603: }
1604:
1605: element = 1;
1606:
1607: do
1608: {
1609: switch(ios = sqlite3_step(ppStmt))
1610: {
1611: case SQLITE_ROW:
1612: {
1613: // Donnée supplémentaire
1614:
1615: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1616: {
1617: (*s_etat_processus).erreur_systeme =
1618: d_es_erreur_fichier;
1619: return;
1620: }
1621:
1622: tampon = (*s_etat_processus).instruction_courante;
1623:
1624: if ((tampon_lecture = (unsigned char *)
1625: sqlite3_column_text(ppStmt, 0)) == NULL)
1626: {
1627: (*s_etat_processus).erreur_systeme =
1628: d_es_erreur_fichier;
1629: return;
1630: }
1631:
1632: if (((*s_etat_processus).instruction_courante =
1633: transliteration(s_etat_processus,
1634: tampon_lecture,
1635: "UTF-8", d_locale)) == NULL)
1636: {
1637: (*s_etat_processus).instruction_courante =
1638: tampon;
1639:
1640: liberation(s_etat_processus,
1641: s_objet_argument_1);
1642: liberation(s_etat_processus,
1643: s_objet_argument_2);
1644:
1645: free(commande);
1646: free(clef_utf8);
1647: return;
1648: }
1649:
1650: indicateur_48 = test_cfsf(s_etat_processus, 48);
1651: cf(s_etat_processus, 48);
1652:
1653: recherche_type(s_etat_processus);
1654:
1655: if ((*s_etat_processus).erreur_execution != d_ex)
1656: {
1657: if (indicateur_48 == d_vrai)
1658: {
1659: sf(s_etat_processus, 48);
1660: }
1661: else
1662: {
1663: cf(s_etat_processus, 48);
1664: }
1665:
1666: liberation(s_etat_processus,
1667: s_objet_argument_1);
1668: liberation(s_etat_processus,
1669: s_objet_argument_2);
1670:
1671: free((*s_etat_processus).instruction_courante);
1672: free(commande);
1673: free(clef_utf8);
1674:
1675: (*s_etat_processus).instruction_courante =
1676: tampon;
1677: return;
1678: }
1679:
1680: if (indicateur_48 == d_vrai)
1681: {
1682: sf(s_etat_processus, 48);
1683: }
1684: else
1685: {
1686: cf(s_etat_processus, 48);
1687: }
1688:
1689: free((*s_etat_processus).instruction_courante);
1690: (*s_etat_processus).instruction_courante = tampon;
1691:
1692: element++;
1693:
1694: // Inscription de la clef
1695:
1696: if (element == position_clef)
1697: {
1698: if (((*s_etat_processus).instruction_courante =
1699: transliteration(s_etat_processus,
1700: clef_utf8, "UTF-8", d_locale)) == NULL)
1701: {
1702: (*s_etat_processus).instruction_courante =
1703: tampon;
1704:
1705: liberation(s_etat_processus,
1706: s_objet_argument_1);
1707: liberation(s_etat_processus,
1708: s_objet_argument_2);
1709:
1710: free(commande);
1711: free(clef_utf8);
1712: return;
1713: }
1714:
1715: if (alsprintf(&tampon2, "{ \"%s\" }",
1716: (*s_etat_processus)
1717: .instruction_courante) < 0)
1718: {
1719: (*s_etat_processus).erreur_systeme =
1720: d_es_allocation_memoire;
1721: return;
1722: }
1723:
1724: free((*s_etat_processus).instruction_courante);
1725: (*s_etat_processus).instruction_courante
1726: = tampon2;
1727:
1728: indicateur_48 = test_cfsf(s_etat_processus, 48);
1729: cf(s_etat_processus, 48);
1730:
1731: recherche_type(s_etat_processus);
1732:
1733: if ((*s_etat_processus).erreur_execution
1734: != d_ex)
1735: {
1736: if (indicateur_48 == d_vrai)
1737: {
1738: sf(s_etat_processus, 48);
1739: }
1740: else
1741: {
1742: cf(s_etat_processus, 48);
1743: }
1744:
1745: liberation(s_etat_processus,
1746: s_objet_argument_1);
1747: liberation(s_etat_processus,
1748: s_objet_argument_2);
1749:
1750: free((*s_etat_processus)
1751: .instruction_courante);
1752: free(commande);
1753: free(clef_utf8);
1754:
1755: (*s_etat_processus).instruction_courante =
1756: tampon;
1757: return;
1758: }
1759:
1760: if (indicateur_48 == d_vrai)
1761: {
1762: sf(s_etat_processus, 48);
1763: }
1764: else
1765: {
1766: cf(s_etat_processus, 48);
1767: }
1768:
1769: free((*s_etat_processus).instruction_courante);
1770: (*s_etat_processus).instruction_courante =
1771: tampon;
1772:
1773: element++;
1774: }
1775:
1776: break;
1777: }
1778:
1779: case SQLITE_DONE:
1780: {
1781: // Fin de la liste
1782: break;
1783: }
1784:
1785: default:
1786: {
1787: (*s_etat_processus).erreur_systeme =
1788: d_es_erreur_fichier;
1789: return;
1790: }
1791: }
1792:
1793: } while(ios != SQLITE_DONE);
1794:
1795: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1796: {
1797: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1798: return;
1799: }
1800:
1801: free(commande);
1802: free(clef_utf8);
1803:
1804: liberation(s_etat_processus, s_objet_argument_2);
1805:
1806: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1807: == NULL)
1808: {
1809: (*s_etat_processus).erreur_systeme =
1810: d_es_allocation_memoire;
1811: return;
1812: }
1813:
1814: l_element_courant = NULL;
1.9 bertrand 1815: l_element_inclus = NULL;
1.8 bertrand 1816:
1817: for(element--; element > 0; element--)
1818: {
1819: if (depilement(s_etat_processus, &((*s_etat_processus)
1820: .l_base_pile), &s_objet_argument_2) == d_erreur)
1821: {
1822: (*s_etat_processus).erreur_systeme =
1823: d_es_erreur_fichier;
1824: return;
1825: }
1826:
1827: if ((*s_objet_argument_2).type != LST)
1828: {
1829: (*s_etat_processus).erreur_systeme =
1830: d_es_erreur_fichier;
1831: return;
1832: }
1833:
1834: l_element_inclus = (*s_objet_argument_2).objet;
1835:
1836: if (l_element_inclus != NULL)
1837: {
1838: while(l_element_inclus != NULL)
1839: {
1840: if ((*l_element_inclus).suivant == NULL)
1841: {
1842: (*l_element_inclus).suivant = l_element_courant;
1843: break;
1844: }
1845:
1846: l_element_inclus = (*l_element_inclus).suivant;
1847: }
1848:
1849: l_element_courant = (*s_objet_argument_2).objet;
1850: (*s_objet_argument_2).objet = NULL;
1851: }
1852:
1853: liberation(s_etat_processus, s_objet_argument_2);
1854: }
1855:
1856: (*s_objet_resultat).objet = l_element_inclus;
1857:
1858: if (empilement(s_etat_processus,
1859: &((*s_etat_processus).l_base_pile),
1860: s_objet_resultat) == d_erreur)
1861: {
1862: return;
1863: }
1.1 bertrand 1864: }
1865: }
1.6 bertrand 1866: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
1.1 bertrand 1867: == 'Y')
1868: {
1869: /*
1870: * Fichiers non formatés
1871: */
1.46 bertrand 1872:
1873: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1874: == 'S')
1875: {
1876: /*
1877: * Fichiers séquentiels
1878: *
1879: * Les fichiers séquentiels non formatés contiennent comme
1880: * les fichiers séquentiels formatés leurs enregistrements
1881: * sous la forme de listes les unes derrières les autres.
1882: *
1883: * Le quartet de poids fort du premier octet à lire
1884: * doit donc être égal à 0100. Si ce n'est pas le cas,
1885: * il sera impossible de lire le fichier et on renvoie
1886: * immédiatement une erreur. Si on lit dans le fichier
1887: * la valeur attendue, on récupère la longueur en octet
1888: * de l'enregistrement puis on le lit.
1889: */
1890:
1891: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1892:
1893: if (fread(&type_enregistrement, (size_t) sizeof(unsigned char),
1894: 1, (*descripteur).descripteur_c) != 1)
1895: {
1896: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1897: return;
1898: }
1899:
1900: if ((type_enregistrement & 0xF0) != 0x40)
1901: {
1902: // L'enregistrement trouvé n'est pas une liste.
1903: // Tout porte à croire que le fichier est corrompu.
1904: (*s_etat_processus).erreur_execution =
1905: d_ex_fichier_corrompu;
1906: return;
1907: }
1908:
1909: switch(type_enregistrement)
1910: {
1911: unsigned char taille_enregistrement[8];
1912:
1913: case 0x48:
1914: {
1915: if (fread(taille_enregistrement,
1916: (size_t) sizeof(unsigned char),
1917: 1, (*descripteur).descripteur_c) != 1)
1918: {
1919: (*s_etat_processus).erreur_systeme =
1920: d_es_erreur_fichier;
1921: return;
1922: }
1923:
1924: longueur_enregistrement = taille_enregistrement[0];
1925: break;
1926: }
1927:
1928: case 0x49:
1929: {
1930: if (fread(taille_enregistrement,
1931: (size_t) sizeof(unsigned char),
1932: 2, (*descripteur).descripteur_c) != 2)
1933: {
1934: (*s_etat_processus).erreur_systeme =
1935: d_es_erreur_fichier;
1936: return;
1937: }
1938:
1939: // A FAIRE conversion de taille_enregistrement en longueur_enregistrement
1940: break;
1941: }
1942:
1943: case 0x4A:
1944: {
1945: if (fread(taille_enregistrement,
1946: (size_t) sizeof(unsigned char),
1947: 4, (*descripteur).descripteur_c) != 4)
1948: {
1949: (*s_etat_processus).erreur_systeme =
1950: d_es_erreur_fichier;
1951: return;
1952: }
1953:
1954: // A FAIRE conversion de taille_enregistrement en longueur_enregistrement
1955: break;
1956: }
1957:
1958: case 0x4B:
1959: {
1960: if (fread(taille_enregistrement,
1961: (size_t) sizeof(unsigned char),
1962: 8, (*descripteur).descripteur_c) != 8)
1963: {
1964: (*s_etat_processus).erreur_systeme =
1965: d_es_erreur_fichier;
1966: return;
1967: }
1968:
1969: // A FAIRE conversion de taille_enregistrement en longueur_enregistrement
1970: break;
1971: }
1972:
1973: default:
1974: {
1975: longueur_enregistrement = type_enregistrement & 0x07;
1976: }
1977: }
1978:
1979: printf("L=%d\n", longueur_enregistrement);
1980: // La variable longueur_enregistrement contient le nombre
1981: // d'éléments à lire dans le fichier pour générer la liste
1982: // contenant l'enregistrement.
1983:
1984: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1985: == NULL)
1986: {
1987: (*s_etat_processus).erreur_systeme =
1988: d_es_allocation_memoire;
1989: return;
1990: }
1991:
1992: for(i = 0; i < longueur_enregistrement; i++)
1993: {
1994: /* A FAIRE
1995: s_objet_element = decodage_enregistrement(s_etat_processus,
1996: (*descripteur).descripteur_c);
1997: */
1998: s_objet_element = NULL;
1999:
2000: if (s_objet_element == NULL)
2001: {
2002: liberation(s_etat_processus, s_objet_resultat);
2003: return;
2004: }
2005:
2006: if ((*s_objet_resultat).objet == NULL)
2007: {
2008: if (((*s_objet_resultat).objet = allocation_maillon(
2009: s_etat_processus)) == NULL)
2010: {
2011: (*s_etat_processus).erreur_systeme =
2012: d_es_allocation_memoire;
2013: return;
2014: }
2015:
2016: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
2017: .donnee = s_objet_element;
2018: l_element_courant = (*s_objet_resultat).objet;
2019: }
2020: else
2021: {
2022: if ((l_element_suivant = allocation_maillon(
2023: s_etat_processus)) == NULL)
2024: {
2025: (*s_etat_processus).erreur_systeme =
2026: d_es_allocation_memoire;
2027: return;
2028: }
2029:
2030: (*l_element_courant).suivant = l_element_suivant;
2031: (*l_element_suivant).donnee = s_objet_element;
2032: l_element_courant = l_element_suivant;
2033: }
2034: }
2035:
2036: // On saute les caractère des gestion de la commande
2037: // BACKSPACE.
2038: // A FAIRE
2039: }
1.1 bertrand 2040: }
2041: else
2042: {
2043: /*
2044: * Fichiers de type FLOW
2045: */
1.28 bertrand 2046:
2047: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
2048: == 'S')
2049: {
2050: /*
2051: * Fichiers séquentiels
2052: */
2053:
2054: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
2055: longueur_enregistrement = 0;
2056:
2057: if ((position_initiale = ftell((*descripteur).descripteur_c))
2058: == -1)
2059: {
2060: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2061: return;
2062: }
2063:
1.59 bertrand 2064: l_element_courant_format = (struct_liste_chainee *)
2065: (*(*((struct_fichier *) (*s_objet_argument_1).objet))
2066: .format).objet;
2067: l_element_courant = NULL;
1.28 bertrand 2068:
2069: if ((s_objet_resultat = allocation(s_etat_processus, LST))
2070: == NULL)
2071: {
2072: (*s_etat_processus).erreur_systeme =
2073: d_es_allocation_memoire;
2074: return;
2075: }
2076:
1.59 bertrand 2077: while(l_element_courant_format != NULL)
1.28 bertrand 2078: {
1.59 bertrand 2079: if ((*(*l_element_courant_format).donnee).type != CHN)
2080: {
2081: liberation(s_etat_processus, s_objet_argument_1);
2082: liberation(s_etat_processus, s_objet_resultat);
2083:
2084: (*s_etat_processus).erreur_execution =
2085: d_ex_erreur_type_argument;
2086: return;
2087: }
2088:
2089: if ((format_chaine = conversion_majuscule((unsigned char *)
2090: (*(*l_element_courant_format).donnee).objet))
2091: == NULL)
2092: {
2093: (*s_etat_processus).erreur_systeme =
2094: d_es_allocation_memoire;
2095: return;
2096: }
2097:
2098: if (strncmp("LENGTH*(", format_chaine, 8) != 0)
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: }
2108:
2109: longueur = strlen(format_chaine);
2110:
1.60 bertrand 2111: if (format_chaine[longueur - 1] != ')')
1.59 bertrand 2112: {
2113: liberation(s_etat_processus, s_objet_argument_1);
2114: liberation(s_etat_processus, s_objet_resultat);
2115: free(format_chaine);
2116:
2117: (*s_etat_processus).erreur_execution =
2118: d_ex_erreur_format_fichier;
2119: return;
2120: }
2121:
2122: format_chaine[longueur] = d_code_fin_chaine;
2123:
2124: if (format_chaine[8] == '*')
2125: {
2126: format_degenere = d_vrai;
2127: }
2128: else
2129: {
2130: // Détermination de la longueur
2131: format_degenere = d_faux;
2132:
2133: if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)
2134: {
2135: liberation(s_etat_processus, s_objet_argument_1);
2136: liberation(s_etat_processus, s_objet_resultat);
2137: free(format_chaine);
2138:
2139: (*s_etat_processus).erreur_execution =
2140: d_ex_erreur_format_fichier;
2141: return;
2142: }
2143: }
2144:
2145: free(format_chaine);
2146:
2147: if (format_degenere == d_vrai)
2148: {
2149: do
2150: {
2151: c = getc((*descripteur).descripteur_c);
2152: longueur_enregistrement++;
2153: } while((c != '\n') && (c != EOF));
2154:
2155: if (fseek((*descripteur).descripteur_c,
2156: position_initiale, SEEK_SET) != 0)
2157: {
2158: liberation(s_etat_processus, s_objet_argument_1);
2159: liberation(s_etat_processus, s_objet_resultat);
2160:
2161: (*s_etat_processus).erreur_systeme =
2162: d_es_erreur_fichier;
2163: return;
2164: }
2165: }
2166: else
2167: {
2168: longueur_enregistrement = longueur;
2169: }
2170:
2171: if ((tampon_lecture = malloc((longueur_enregistrement)
2172: * sizeof(unsigned char))) == NULL)
2173: {
2174: (*s_etat_processus).erreur_systeme =
2175: d_es_allocation_memoire;
2176: return;
2177: }
2178:
2179: longueur_effective = fread(tampon_lecture,
2180: (size_t) sizeof(unsigned char),
2181: (size_t) longueur_enregistrement,
2182: (*descripteur).descripteur_c);
2183:
2184: if (l_element_courant == NULL)
2185: {
2186: // Premier maillon de la liste
2187: if (((*s_objet_resultat).objet =
2188: allocation_maillon(s_etat_processus)) == NULL)
2189: {
2190: (*s_etat_processus).erreur_systeme =
2191: d_es_allocation_memoire;
2192: return;
2193: }
2194:
2195: l_element_courant = (*s_objet_resultat).objet;
2196: }
2197: else
2198: {
2199: if (((*l_element_courant).suivant =
2200: allocation_maillon(s_etat_processus)) == NULL)
2201: {
2202: (*s_etat_processus).erreur_systeme =
2203: d_es_allocation_memoire;
2204: return;
2205: }
2206:
2207: l_element_courant = (*l_element_courant).suivant;
2208: }
2209:
2210: (*l_element_courant).suivant = NULL;
2211:
2212: if (((*l_element_courant).donnee =
2213: allocation(s_etat_processus, CHN)) == NULL)
2214: {
2215: (*s_etat_processus).erreur_systeme =
2216: d_es_allocation_memoire;
2217: return;
2218: }
1.28 bertrand 2219:
1.59 bertrand 2220: if (format_degenere == d_vrai)
2221: {
2222: if (((*(*l_element_courant).donnee).objet =
2223: analyse_flux(s_etat_processus, tampon_lecture,
2224: longueur_enregistrement - 1)) == NULL)
2225: {
2226: return;
2227: }
2228: }
2229: else
2230: {
2231: if (((*(*l_element_courant).donnee).objet =
2232: analyse_flux(s_etat_processus, tampon_lecture,
2233: longueur_enregistrement)) == NULL)
2234: {
2235: return;
2236: }
2237: }
1.28 bertrand 2238:
1.59 bertrand 2239: free(tampon_lecture);
1.28 bertrand 2240:
1.59 bertrand 2241: l_element_courant_format =
2242: (*l_element_courant_format).suivant;
1.28 bertrand 2243: }
2244:
2245: if (empilement(s_etat_processus,
2246: &((*s_etat_processus).l_base_pile),
2247: s_objet_resultat) == d_erreur)
2248: {
2249: return;
2250: }
2251: }
2252: else
2253: {
2254: liberation(s_etat_processus, s_objet_argument_1);
2255:
2256: (*s_etat_processus).erreur_execution =
2257: d_ex_erreur_type_fichier;
2258: return;
2259: }
1.1 bertrand 2260: }
2261: }
1.6 bertrand 2262: else if ((*s_objet_argument_1).type == SCK)
1.1 bertrand 2263: {
2264: /*
2265: * Vérification de l'autorisation de lecture
2266: */
2267:
1.6 bertrand 2268: if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection
2269: == 'W')
1.1 bertrand 2270: {
1.6 bertrand 2271: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2272:
2273: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
2274: return;
2275: }
2276:
2277: /*
2278: * Vérification de l'écoute de la socket si celle-ci est connectée
2279: */
2280:
1.6 bertrand 2281: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
1.1 bertrand 2282: "STREAM") == 0) || (strcmp((*((struct_socket *)
1.6 bertrand 2283: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
2284: == 0))
1.1 bertrand 2285: {
1.6 bertrand 2286: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2287: .socket_en_ecoute == 'Y')
2288: {
1.6 bertrand 2289: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2290:
2291: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
2292: return;
2293: }
2294: }
2295:
1.6 bertrand 2296: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
1.1 bertrand 2297: { // Socket formatée
2298: longueur_questure = 256;
1.55 bertrand 2299: longueur_effective = 0;
2300: tampon_lecture = NULL;
1.1 bertrand 2301:
1.56 bertrand 2302: attente.tv_sec = 0;
2303: attente.tv_nsec = GRANULARITE_us * 1000;
2304:
1.57 bertrand 2305: trame_complete = d_faux;
2306: position_initiale = 0;
2307: position_finale = 0;
2308:
1.1 bertrand 2309: do
2310: {
1.55 bertrand 2311: presence_indicateur = d_faux;
2312:
2313: if ((tampon_lecture = realloc(tampon_lecture,
1.57 bertrand 2314: (longueur_effective + longueur_questure + 1)
1.55 bertrand 2315: * sizeof(unsigned char))) == NULL)
1.1 bertrand 2316: {
2317: (*s_etat_processus).erreur_systeme =
2318: d_es_allocation_memoire;
2319: return;
2320: }
2321:
1.44 bertrand 2322: # ifndef SEMAPHORES_NOMMES
2323: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
2324: # else
2325: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
2326: # endif
1.1 bertrand 2327: {
2328: (*s_etat_processus).erreur_systeme = d_es_processus;
2329: return;
2330: }
2331:
1.55 bertrand 2332: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2333: .domaine == PF_UNIX)
2334: {
2335: longueur_adresse = sizeof(adresse_unix);
1.57 bertrand 2336:
2337: do
2338: {
2339: ios = recvfrom((*((struct_socket *)
2340: (*s_objet_argument_1).objet)).socket,
2341: tampon_lecture + longueur_effective,
2342: longueur_questure,
2343: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2344: &adresse_unix, &longueur_adresse);
2345: } while((ios == -1) && (errno == EINTR));
1.55 bertrand 2346: }
2347: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2348: .domaine == PF_INET)
2349: {
2350: longueur_adresse = sizeof(adresse_ipv4);
1.57 bertrand 2351:
2352: do
2353: {
2354: ios = recvfrom((*((struct_socket *)
2355: (*s_objet_argument_1).objet)).socket,
2356: tampon_lecture + longueur_effective,
2357: longueur_questure,
2358: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2359: &adresse_ipv4, &longueur_adresse);
2360: } while((ios == -1) && (errno == EINTR));
1.55 bertrand 2361: }
2362: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2363: .domaine == PF_INET6)
2364: {
2365: # ifdef IPV6
2366: longueur_adresse = sizeof(adresse_ipv6);
1.57 bertrand 2367:
2368: do
2369: {
2370: ios = recvfrom((*((struct_socket *)
2371: (*s_objet_argument_1).objet)).socket,
2372: tampon_lecture + longueur_effective,
2373: longueur_questure,
2374: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2375: &adresse_ipv6, &longueur_adresse);
2376: } while((ios == -1) && (errno == EINTR));
1.55 bertrand 2377: # else
2378: if ((*s_etat_processus).langue == 'F')
2379: {
2380: printf("+++Attention : Support du protocole"
2381: " IPv6 indisponible\n");
2382: }
2383: else
2384: {
2385: printf("+++Warning : IPv6 support "
2386: "unavailable\n");
2387: }
2388:
2389: longueur_adresse = 0;
2390: longueur_effective = 0;
2391: ios = 0;
2392: # endif
2393: }
2394: else
2395: {
2396: free(tampon_lecture);
2397: liberation(s_etat_processus, s_objet_argument_1);
2398:
2399: # ifndef SEMAPHORES_NOMMES
2400: while(sem_wait(&((*s_etat_processus)
2401: .semaphore_fork)) != 0)
2402: # else
2403: while(sem_wait((*s_etat_processus)
2404: .semaphore_fork) != 0)
2405: # endif
2406: {
2407: (*s_etat_processus).erreur_systeme =
2408: d_es_processus;
2409: }
2410:
2411: (*s_etat_processus).erreur_execution =
2412: d_ex_erreur_acces_fichier;
2413: return;
2414: }
2415:
2416: if (ios < 0)
2417: {
2418: nanosleep(&attente, NULL);
2419: INCR_GRANULARITE(attente.tv_nsec);
2420: scrutation_injection(s_etat_processus);
2421: }
1.56 bertrand 2422: else
2423: {
2424: attente.tv_sec = 0;
2425: attente.tv_nsec = GRANULARITE_us * 1000;
2426: }
1.55 bertrand 2427:
2428: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2429: {
1.62 bertrand 2430: if (ios >= 0)
2431: {
2432: longueur_effective += ios;
2433: }
2434:
1.55 bertrand 2435: break;
2436: }
2437:
2438: // Une donnée a été reçue.
2439:
2440: if (ios >= 0)
1.1 bertrand 2441: {
1.55 bertrand 2442: ancienne_longueur_effective = longueur_effective;
2443: longueur_effective += ios;
2444: position_initiale = 0;
2445: presence_indicateur = d_faux;
2446:
2447: do
2448: {
2449: if (tampon_lecture[position_initiale] == '{')
2450: {
2451: presence_indicateur = d_vrai;
2452: break;
2453: }
2454:
2455: position_initiale++;
2456: } while(position_initiale < longueur_effective);
2457:
2458: if (presence_indicateur == d_vrai)
2459: {
2460: position_finale = position_initiale + 1;
2461: presence_chaine = d_faux;
2462: presence_indicateur = d_faux;
2463: niveau = 1;
2464:
2465: while(position_finale < longueur_effective)
2466: {
2467: caractere = tampon_lecture[position_finale];
2468:
2469: if (caractere == '"')
2470: {
1.59 bertrand 2471: if (position_finale > 0)
2472: {
2473: if (tampon_lecture[position_finale - 1]
2474: != '\\')
2475: {
2476: presence_chaine = (presence_chaine ==
2477: d_vrai) ? d_faux : d_vrai;
2478: }
2479: }
2480: else
2481: {
2482: presence_chaine =
2483: (presence_chaine == d_vrai)
2484: ? d_faux : d_vrai;
2485: }
1.55 bertrand 2486: }
2487: else
2488: {
2489: if (presence_chaine == d_faux)
2490: {
2491: if (caractere == '{')
2492: {
2493: niveau++;
2494: }
2495: else if (caractere == '}')
2496: {
2497: niveau--;
2498: }
2499: }
2500: }
2501:
2502: if (niveau == 0)
2503: {
2504: presence_indicateur = d_vrai;
1.57 bertrand 2505: trame_complete = d_vrai;
1.55 bertrand 2506: break;
2507: }
2508:
2509: position_finale++;
2510: }
2511: }
2512:
2513: // On retire du buffer position_finale -
2514: // ancienne_longueur_effective octets.
2515:
1.6 bertrand 2516: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2517: .domaine == PF_UNIX)
1.1 bertrand 2518: {
2519: longueur_adresse = sizeof(adresse_unix);
1.57 bertrand 2520:
2521: do
2522: {
2523: ios = recvfrom((*((struct_socket *)
2524: (*s_objet_argument_1).objet)).socket,
2525: poubelle, position_finale
2526: - ancienne_longueur_effective,
2527: MSG_DONTWAIT, (struct sockaddr *)
2528: &adresse_unix, &longueur_adresse);
1.62 bertrand 2529: } while((ios == -1) && (errno == EINTR));
1.1 bertrand 2530: }
1.55 bertrand 2531: else if ((*((struct_socket *) (*s_objet_argument_1)
2532: .objet)).domaine == PF_INET)
1.1 bertrand 2533: {
2534: longueur_adresse = sizeof(adresse_ipv4);
1.57 bertrand 2535:
2536: do
2537: {
2538: ios = recvfrom((*((struct_socket *)
2539: (*s_objet_argument_1).objet)).socket,
2540: poubelle, position_finale
2541: - ancienne_longueur_effective,
2542: MSG_DONTWAIT, (struct sockaddr *)
2543: &adresse_ipv4, &longueur_adresse);
1.62 bertrand 2544: } while((ios == -1) && (errno == EINTR));
1.1 bertrand 2545: }
1.55 bertrand 2546: else if ((*((struct_socket *) (*s_objet_argument_1)
2547: .objet)) .domaine == PF_INET6)
1.1 bertrand 2548: {
1.19 bertrand 2549: # ifdef IPV6
1.1 bertrand 2550: longueur_adresse = sizeof(adresse_ipv6);
1.57 bertrand 2551:
2552: do
2553: {
2554: ios = recvfrom((*((struct_socket *)
2555: (*s_objet_argument_1).objet)).socket,
2556: poubelle, position_finale
2557: - ancienne_longueur_effective,
2558: MSG_DONTWAIT, (struct sockaddr *)
2559: &adresse_ipv6, &longueur_adresse);
1.62 bertrand 2560: } while((ios == -1) && (errno == EINTR));
1.19 bertrand 2561: # else
1.21 bertrand 2562: if ((*s_etat_processus).langue == 'F')
2563: {
2564: printf("+++Attention : Support du protocole"
1.22 bertrand 2565: " IPv6 indisponible\n");
1.21 bertrand 2566: }
2567: else
2568: {
1.23 bertrand 2569: printf("+++Warning : IPv6 support "
1.21 bertrand 2570: "unavailable\n");
2571: }
1.51 bertrand 2572:
2573: longueur_adresse = 0;
1.19 bertrand 2574: # endif
1.1 bertrand 2575: }
1.55 bertrand 2576:
2577: if (presence_indicateur == d_faux)
1.1 bertrand 2578: {
1.55 bertrand 2579: poll_fd.fd = (*((struct_socket *)
2580: (*s_objet_argument_1).objet)).socket;
2581: poll_fd.events = POLLIN;
1.1 bertrand 2582:
1.63 ! bertrand 2583: while((ios = poll(&poll_fd, 1, 10000)) <= 0)
1.1 bertrand 2584: {
1.55 bertrand 2585: // La fin de la trame n'est pas atteinte
2586: // et il reste quelque chose à lire.
1.1 bertrand 2587:
1.55 bertrand 2588: switch(ios)
2589: {
2590: case EINTR:
2591: {
1.62 bertrand 2592: if ((*s_etat_processus)
2593: .var_volatile_requete_arret == -1)
2594: {
2595: liberation(s_etat_processus,
2596: s_objet_argument_1);
2597: free(tampon_lecture);
2598: return;
2599: }
2600:
1.55 bertrand 2601: break;
2602: }
1.1 bertrand 2603:
1.55 bertrand 2604: case 0:
2605: {
2606: liberation(s_etat_processus,
2607: s_objet_argument_1);
2608: free(tampon_lecture);
1.1 bertrand 2609:
1.55 bertrand 2610: (*s_etat_processus).erreur_execution =
2611: d_ex_fin_de_fichier_atteinte;
2612: return;
2613: }
2614: }
2615: }
1.1 bertrand 2616: }
2617: }
2618:
1.44 bertrand 2619: # ifndef SEMAPHORES_NOMMES
2620: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
2621: # else
2622: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
2623: # endif
1.1 bertrand 2624: {
1.44 bertrand 2625: if (errno == EINTR)
1.43 bertrand 2626: {
2627: (*s_etat_processus).erreur_systeme = d_es_processus;
2628: return;
2629: }
1.1 bertrand 2630: }
2631:
2632: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2633: {
2634:
2635: /*
2636: * Si le père tue le processus courant grâce au signal
2637: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
2638: * correspond à l'utilisation de STOP sur le processus
2639: * en cours. La variable longueur_effective vaut '-1'.
2640: */
2641:
2642: free(tampon_lecture);
1.6 bertrand 2643: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2644: return;
2645: }
2646:
2647: if (longueur_effective == -1)
2648: {
2649: free(tampon_lecture);
1.6 bertrand 2650: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2651:
2652: (*s_etat_processus).erreur_execution =
2653: d_ex_erreur_acces_fichier;
2654: return;
2655: }
1.57 bertrand 2656: } while(trame_complete == d_faux);
1.1 bertrand 2657:
2658: tampon_lecture[++position_finale] = d_code_fin_chaine;
2659: tampon = (*s_etat_processus).instruction_courante;
2660: (*s_etat_processus).instruction_courante = &(tampon_lecture
2661: [position_initiale]);
2662:
2663: indicateur_48 = test_cfsf(s_etat_processus, 48);
2664: cf(s_etat_processus, 48);
2665:
2666: recherche_type(s_etat_processus);
2667:
2668: if ((*s_etat_processus).erreur_execution != d_ex)
2669: {
2670: (*s_etat_processus).instruction_courante = tampon;
2671: free(tampon_lecture);
2672:
1.57 bertrand 2673: if (indicateur_48 == d_vrai)
2674: {
2675: sf(s_etat_processus, 48);
2676: }
2677: else
2678: {
2679: cf(s_etat_processus, 48);
2680: }
2681:
2682: if ((*s_etat_processus).var_volatile_requete_arret == -1)
2683: {
2684: (*s_etat_processus).erreur_execution = d_ex;
2685: }
2686:
1.6 bertrand 2687: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 2688: return;
2689: }
2690:
2691: if (indicateur_48 == d_vrai)
2692: {
2693: sf(s_etat_processus, 48);
2694: }
2695: else
2696: {
2697: cf(s_etat_processus, 48);
2698: }
2699:
2700: (*s_etat_processus).instruction_courante = tampon;
2701:
2702: /*
2703: * Création de la liste de sortie
2704: */
2705:
2706: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2707: &s_objet_type) == d_erreur)
2708: {
2709: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2710: return;
2711: }
2712:
2713: if ((s_objet_resultat = allocation(s_etat_processus, LST))
2714: == NULL)
2715: {
2716: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2717: return;
2718: }
2719:
2720: if (((*s_objet_resultat).objet =
2721: allocation_maillon(s_etat_processus)) == NULL)
2722: {
2723: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2724: return;
2725: }
2726:
2727: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
2728: .donnee = s_objet_type;
2729:
2730: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
2731: .suivant = allocation_maillon(s_etat_processus)) == NULL)
2732: {
2733: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2734: return;
2735: }
2736:
2737: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
2738: .suivant = NULL;
2739:
2740: if ((s_objet_adresse = allocation(s_etat_processus, LST))
2741: == NULL)
2742: {
2743: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2744: return;
2745: }
2746:
2747: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
2748: .donnee = s_objet_adresse;
2749:
2750: /*
2751: * Les informations concernant la cible sont valides si
2752: * la socket est non connectée et des domaines INET ou INET6.
2753: * Dans tous les autres cas, on renvoie une liste vide.
2754: */
2755:
1.6 bertrand 2756: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
1.1 bertrand 2757: == PF_UNIX) || (strcmp((*((struct_socket *)
1.6 bertrand 2758: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
2759: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2760: .type, "SEQUENTIAL DATAGRAM") == 0))
2761: {
2762: (*s_objet_adresse).objet = NULL;
2763: }
1.6 bertrand 2764: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2765: .domaine == PF_INET)
2766: {
2767: if (((*s_objet_adresse).objet =
2768: allocation_maillon(s_etat_processus)) == NULL)
2769: {
2770: (*s_etat_processus).erreur_systeme =
2771: d_es_allocation_memoire;
2772: return;
2773: }
2774:
2775: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2776: .donnee = allocation(s_etat_processus, VIN)) == NULL)
2777: {
2778: (*s_etat_processus).erreur_systeme =
2779: d_es_allocation_memoire;
2780: return;
2781: }
2782:
2783: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
2784: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
2785:
2786: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
2787: (*s_objet_adresse).objet)).donnee).objet)).tableau =
2788: malloc(4 * sizeof(integer8))) == NULL)
2789: {
2790: (*s_etat_processus).erreur_systeme =
2791: d_es_allocation_memoire;
2792: return;
2793: }
2794:
2795: ((integer8 *) (*((struct_vecteur *)
2796: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2797: .objet)).donnee).objet)).tableau)[0] =
2798: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
2799: ((integer8 *) (*((struct_vecteur *)
2800: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2801: .objet)).donnee).objet)).tableau)[1] =
2802: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
2803: ((integer8 *) (*((struct_vecteur *)
2804: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2805: .objet)).donnee).objet)).tableau)[2] =
2806: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
2807: ((integer8 *) (*((struct_vecteur *)
2808: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2809: .objet)).donnee).objet)).tableau)[3] =
2810: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
2811:
2812: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2813: .suivant = allocation_maillon(s_etat_processus))
2814: == NULL)
2815: {
2816: (*s_etat_processus).erreur_systeme =
2817: d_es_allocation_memoire;
2818: return;
2819: }
2820:
2821: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2822: .suivant).donnee = allocation(s_etat_processus, INT))
2823: == NULL)
2824: {
2825: (*s_etat_processus).erreur_systeme =
2826: d_es_allocation_memoire;
2827: return;
2828: }
2829:
2830: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1.6 bertrand 2831: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
1.1 bertrand 2832: (integer8) ntohs(adresse_ipv4.sin_port);
2833:
2834: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2835: .suivant).suivant = NULL;
2836: }
1.6 bertrand 2837: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1.1 bertrand 2838: .domaine == PF_INET6)
2839: {
1.19 bertrand 2840: # ifdef IPV6
1.1 bertrand 2841: if (((*s_objet_adresse).objet =
2842: allocation_maillon(s_etat_processus)) == NULL)
2843: {
2844: (*s_etat_processus).erreur_systeme =
2845: d_es_allocation_memoire;
2846: return;
2847: }
2848:
2849: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2850: .donnee = allocation(s_etat_processus, VIN)) == NULL)
2851: {
2852: (*s_etat_processus).erreur_systeme =
2853: d_es_allocation_memoire;
2854: return;
2855: }
2856:
2857: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
2858: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
2859:
2860: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
2861: (*s_objet_adresse).objet)).donnee).objet)).tableau =
2862: malloc(16 * sizeof(integer8))) == NULL)
2863: {
2864: (*s_etat_processus).erreur_systeme =
2865: d_es_allocation_memoire;
2866: return;
2867: }
2868:
2869: for(i = 0; i < 16; i++)
2870: {
2871: ((integer8 *) (*((struct_vecteur *)
2872: (*(*((struct_liste_chainee *) (*s_objet_adresse)
2873: .objet)).donnee).objet)).tableau)[0] =
2874: adresse_ipv6.sin6_addr.s6_addr[i];
2875: }
2876:
2877: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
2878: .suivant = allocation_maillon(s_etat_processus))
2879: == NULL)
2880: {
2881: (*s_etat_processus).erreur_systeme =
2882: d_es_allocation_memoire;
2883: return;
2884: }
2885:
2886: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2887: .suivant).donnee = allocation(s_etat_processus, INT))
2888: == NULL)
2889: {
2890: (*s_etat_processus).erreur_systeme =
2891: d_es_allocation_memoire;
2892: return;
2893: }
2894:
2895: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1.6 bertrand 2896: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
1.1 bertrand 2897: (integer8) ntohs(adresse_ipv6.sin6_port);
2898:
2899: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
2900: .suivant).suivant = NULL;
1.19 bertrand 2901: # else
1.21 bertrand 2902: if ((*s_etat_processus).langue == 'F')
2903: {
2904: printf("+++Attention : Support du protocole"
1.22 bertrand 2905: " IPv6 indisponible\n");
1.21 bertrand 2906: }
2907: else
2908: {
1.23 bertrand 2909: printf("+++Warning : IPv6 support "
1.21 bertrand 2910: "unavailable\n");
2911: }
1.19 bertrand 2912: # endif
1.1 bertrand 2913: }
2914: else
2915: {
2916: longueur_adresse = 0;
2917: recvfrom((*((struct_socket *)
1.6 bertrand 2918: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1.1 bertrand 2919: position_finale, MSG_DONTWAIT,
2920: NULL, &longueur_adresse);
2921: }
2922:
2923: free(tampon_lecture);
2924:
2925: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2926: s_objet_resultat) == d_erreur)
2927: {
2928: return;
2929: }
2930: }
1.28 bertrand 2931: else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
2932: == 'Y')
2933: { // UNFORMATTED
2934: }
1.1 bertrand 2935: else
1.28 bertrand 2936: { // FLOW
2937: longueur_questure = 256;
2938:
2939: do
2940: {
2941: if ((tampon_lecture = malloc((longueur_questure + 1) *
2942: sizeof(unsigned char))) == NULL)
2943: {
2944: (*s_etat_processus).erreur_systeme =
2945: d_es_allocation_memoire;
2946: return;
2947: }
2948:
1.44 bertrand 2949: # ifndef SEMAPHORES_NOMMES
2950: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
2951: # else
2952: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
2953: # endif
1.28 bertrand 2954: {
2955: (*s_etat_processus).erreur_systeme = d_es_processus;
2956: return;
2957: }
2958:
1.30 bertrand 2959: attente.tv_sec = 0;
2960: attente.tv_nsec = GRANULARITE_us * 1000;
2961:
1.28 bertrand 2962: for(;;)
2963: {
2964: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2965: .domaine == PF_UNIX)
2966: {
2967: longueur_adresse = sizeof(adresse_unix);
2968: longueur_effective = recvfrom((*((struct_socket *)
2969: (*s_objet_argument_1).objet)).socket,
2970: tampon_lecture, longueur_questure,
2971: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2972: &adresse_unix, &longueur_adresse);
2973: }
2974: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2975: .domaine == PF_INET)
2976: {
2977: longueur_adresse = sizeof(adresse_ipv4);
2978: longueur_effective = recvfrom((*((struct_socket *)
2979: (*s_objet_argument_1).objet)).socket,
2980: tampon_lecture, longueur_questure,
2981: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2982: &adresse_ipv4, &longueur_adresse);
2983: }
2984: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2985: .domaine == PF_INET6)
2986: {
2987: # ifdef IPV6
2988: longueur_adresse = sizeof(adresse_ipv6);
2989: longueur_effective = recvfrom((*((struct_socket *)
2990: (*s_objet_argument_1).objet)).socket,
2991: tampon_lecture, longueur_questure,
2992: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
2993: &adresse_ipv6, &longueur_adresse);
2994: # else
2995: if ((*s_etat_processus).langue == 'F')
2996: {
2997: printf("+++Attention : Support du protocole"
2998: " IPv6 indisponible\n");
2999: }
3000: else
3001: {
3002: printf("+++Warning : IPv6 support "
3003: "unavailable\n");
3004: }
1.51 bertrand 3005:
3006: longueur_adresse = 0;
3007: longueur_effective = 0;
1.28 bertrand 3008: # endif
3009: }
3010: else
3011: {
3012: free(tampon_lecture);
3013: liberation(s_etat_processus, s_objet_argument_1);
3014:
1.44 bertrand 3015: # ifndef SEMAPHORES_NOMMES
3016: while(sem_wait(&((*s_etat_processus)
3017: .semaphore_fork)) != 0)
3018: # else
3019: while(sem_wait((*s_etat_processus)
3020: .semaphore_fork) != 0)
3021: # endif
1.28 bertrand 3022: {
1.43 bertrand 3023: if (errno != EINTR)
3024: {
3025: (*s_etat_processus).erreur_systeme =
3026: d_es_processus;
3027: return;
3028: }
1.28 bertrand 3029: }
3030:
3031: (*s_etat_processus).erreur_execution =
3032: d_ex_erreur_acces_fichier;
3033: return;
3034: }
3035:
3036: if (longueur_effective < 0)
3037: {
3038: nanosleep(&attente, NULL);
1.30 bertrand 3039: INCR_GRANULARITE(attente.tv_nsec);
1.28 bertrand 3040: scrutation_injection(s_etat_processus);
3041: }
3042:
3043: if (((*s_etat_processus).var_volatile_requete_arret == -1)
3044: || (longueur_effective >= 0))
3045: {
3046: break;
3047: }
3048: }
3049:
1.44 bertrand 3050: # ifndef SEMAPHORES_NOMMES
3051: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
3052: # else
3053: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
3054: # endif
1.28 bertrand 3055: {
1.43 bertrand 3056: if (errno != EINTR)
3057: {
3058: (*s_etat_processus).erreur_systeme = d_es_processus;
3059: return;
3060: }
1.28 bertrand 3061: }
3062:
3063: if ((*s_etat_processus).var_volatile_requete_arret == -1)
3064: {
3065:
3066: /*
3067: * Si le père tue le processus courant grâce au signal
3068: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
3069: * correspond à l'utilisation de STOP sur le processus
3070: * en cours. La variable longueur_effective vaut '-1'.
3071: */
3072:
3073: free(tampon_lecture);
3074: liberation(s_etat_processus, s_objet_argument_1);
3075: return;
3076: }
3077:
3078: if (longueur_effective == -1)
3079: {
3080: free(tampon_lecture);
3081: liberation(s_etat_processus, s_objet_argument_1);
3082:
3083: (*s_etat_processus).erreur_execution =
3084: d_ex_erreur_acces_fichier;
3085: return;
3086: }
3087:
3088: if (longueur_effective == longueur_questure)
3089: {
3090: free(tampon_lecture);
3091: longueur_questure *= 2;
3092: }
3093: } while(longueur_effective == longueur_questure);
3094:
3095: longueur_enregistrement = 1;
3096:
3097: for(i = 0; i < longueur_effective; i++)
3098: {
3099: if (isprint(tampon_lecture[i]) != 0)
3100: {
3101: longueur_enregistrement += 4;
3102: }
3103: else
3104: {
3105: longueur_enregistrement++;
3106: }
3107: }
3108:
3109: /*
3110: * Création de la liste de sortie
3111: */
3112:
3113: if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL)
3114: {
3115: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3116: return;
3117: }
3118:
3119: if (((*s_objet_type).objet = malloc(longueur_enregistrement *
3120: sizeof(unsigned char))) == NULL)
3121: {
3122: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3123: return;
3124: }
3125:
3126: ptr = (*s_objet_type).objet;
3127:
3128: for(i = 0; i < longueur_effective; i++)
3129: {
3130: if (isprint(tampon_lecture[i]) != 0)
3131: {
3132: (*ptr) = tampon_lecture[i];
3133: ptr++;
3134: }
3135: else
3136: {
3137: (*ptr) = '\\';
3138: ptr++;
3139: (*ptr) = 'x';
3140: ptr++;
3141: sprintf(ptr, "%02X", tampon_lecture[i]);
3142: ptr += 2;
3143: }
3144: }
3145:
3146: (*ptr) = d_code_fin_chaine;
3147:
3148: if ((s_objet_resultat = allocation(s_etat_processus, LST))
3149: == NULL)
3150: {
3151: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3152: return;
3153: }
3154:
3155: if (((*s_objet_resultat).objet =
3156: allocation_maillon(s_etat_processus)) == NULL)
3157: {
3158: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3159: return;
3160: }
3161:
3162: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
3163: .donnee = s_objet_type;
3164:
3165: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
3166: .suivant = allocation_maillon(s_etat_processus)) == NULL)
3167: {
3168: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3169: return;
3170: }
3171:
3172: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3173: .suivant = NULL;
3174:
3175: if ((s_objet_adresse = allocation(s_etat_processus, LST))
3176: == NULL)
3177: {
3178: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3179: return;
3180: }
3181:
3182: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
3183: .donnee = s_objet_adresse;
3184:
3185: /*
3186: * Les informations concernant la cible sont valides si
1.30 bertrand 3187: * la socket est non connectée et que les domaines sont
3188: * INET ou INET6.
1.28 bertrand 3189: * Dans tous les autres cas, on renvoie une liste vide.
3190: */
3191:
3192: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
3193: == PF_UNIX) || (strcmp((*((struct_socket *)
3194: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
3195: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
3196: .type, "SEQUENTIAL DATAGRAM") == 0))
3197: {
1.30 bertrand 3198: // POSITION_FINALE peut être utilisée sans être initialisée !
3199: // virer position_finale pour longueur_effective
1.28 bertrand 3200: longueur_adresse = 0;
3201: recvfrom((*((struct_socket *)
3202: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3203: position_finale, MSG_DONTWAIT,
3204: NULL, &longueur_adresse);
3205:
3206: (*s_objet_adresse).objet = NULL;
3207: }
3208: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3209: .domaine == PF_INET)
3210: {
3211: longueur_adresse = sizeof(adresse_ipv4);
3212: recvfrom((*((struct_socket *)
3213: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3214: position_finale, MSG_DONTWAIT,
3215: (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
3216:
3217: if (((*s_objet_adresse).objet =
3218: allocation_maillon(s_etat_processus)) == NULL)
3219: {
3220: (*s_etat_processus).erreur_systeme =
3221: d_es_allocation_memoire;
3222: return;
3223: }
3224:
3225: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3226: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3227: {
3228: (*s_etat_processus).erreur_systeme =
3229: d_es_allocation_memoire;
3230: return;
3231: }
3232:
3233: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3234: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
3235:
3236: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3237: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3238: malloc(4 * sizeof(integer8))) == NULL)
3239: {
3240: (*s_etat_processus).erreur_systeme =
3241: d_es_allocation_memoire;
3242: return;
3243: }
3244:
3245: ((integer8 *) (*((struct_vecteur *)
3246: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3247: .objet)).donnee).objet)).tableau)[0] =
3248: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
3249: ((integer8 *) (*((struct_vecteur *)
3250: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3251: .objet)).donnee).objet)).tableau)[1] =
3252: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
3253: ((integer8 *) (*((struct_vecteur *)
3254: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3255: .objet)).donnee).objet)).tableau)[2] =
3256: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
3257: ((integer8 *) (*((struct_vecteur *)
3258: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3259: .objet)).donnee).objet)).tableau)[3] =
3260: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
3261:
3262: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3263: .suivant = allocation_maillon(s_etat_processus))
3264: == NULL)
3265: {
3266: (*s_etat_processus).erreur_systeme =
3267: d_es_allocation_memoire;
3268: return;
3269: }
3270:
3271: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3272: .suivant).donnee = allocation(s_etat_processus, INT))
3273: == NULL)
3274: {
3275: (*s_etat_processus).erreur_systeme =
3276: d_es_allocation_memoire;
3277: return;
3278: }
3279:
3280: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3281: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3282: (integer8) ntohs(adresse_ipv4.sin_port);
3283:
3284: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3285: .suivant).suivant = NULL;
3286: }
3287: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
3288: .domaine == PF_INET6)
3289: {
3290: # ifdef IPV6
3291: longueur_adresse = sizeof(adresse_ipv6);
3292: recvfrom((*((struct_socket *)
3293: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3294: position_finale, MSG_DONTWAIT,
3295: (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
3296:
3297: if (((*s_objet_adresse).objet =
3298: allocation_maillon(s_etat_processus)) == NULL)
3299: {
3300: (*s_etat_processus).erreur_systeme =
3301: d_es_allocation_memoire;
3302: return;
3303: }
3304:
3305: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3306: .donnee = allocation(s_etat_processus, VIN)) == NULL)
3307: {
3308: (*s_etat_processus).erreur_systeme =
3309: d_es_allocation_memoire;
3310: return;
3311: }
3312:
3313: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
3314: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
3315:
3316: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
3317: (*s_objet_adresse).objet)).donnee).objet)).tableau =
3318: malloc(16 * sizeof(integer8))) == NULL)
3319: {
3320: (*s_etat_processus).erreur_systeme =
3321: d_es_allocation_memoire;
3322: return;
3323: }
3324:
3325: for(i = 0; i < 16; i++)
3326: {
3327: ((integer8 *) (*((struct_vecteur *)
3328: (*(*((struct_liste_chainee *) (*s_objet_adresse)
3329: .objet)).donnee).objet)).tableau)[0] =
3330: adresse_ipv6.sin6_addr.s6_addr[i];
3331: }
3332:
3333: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
3334: .suivant = allocation_maillon(s_etat_processus))
3335: == NULL)
3336: {
3337: (*s_etat_processus).erreur_systeme =
3338: d_es_allocation_memoire;
3339: return;
3340: }
3341:
3342: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3343: .suivant).donnee = allocation(s_etat_processus, INT))
3344: == NULL)
3345: {
3346: (*s_etat_processus).erreur_systeme =
3347: d_es_allocation_memoire;
3348: return;
3349: }
3350:
3351: (*((integer8 *) (*(*(*((struct_liste_chainee *)
3352: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
3353: (integer8) ntohs(adresse_ipv6.sin6_port);
3354:
3355: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
3356: .suivant).suivant = NULL;
3357: # else
3358: if ((*s_etat_processus).langue == 'F')
3359: {
3360: printf("+++Attention : Support du protocole"
3361: " IPv6 indisponible\n");
3362: }
3363: else
3364: {
3365: printf("+++Warning : IPv6 support "
3366: "unavailable\n");
3367: }
3368: # endif
3369: }
3370: else
3371: {
3372: longueur_adresse = 0;
3373: recvfrom((*((struct_socket *)
3374: (*s_objet_argument_1).objet)).socket, tampon_lecture,
3375: position_finale, MSG_DONTWAIT,
3376: NULL, &longueur_adresse);
3377: }
3378:
3379: free(tampon_lecture);
3380:
3381: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3382: s_objet_resultat) == d_erreur)
3383: {
3384: return;
3385: }
1.1 bertrand 3386: }
3387: }
3388: else
3389: {
3390: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3391: return;
3392: }
3393:
1.6 bertrand 3394: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 3395:
3396: return;
3397: }
3398:
3399: // vim: ts=4