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