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