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