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