1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.12
4: Copyright (C) 1989-2010 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: logical1 indicateur_48;
852: logical1 presence_chaine;
853: logical1 presence_indicateur;
854:
855: long longueur_effective;
856: long longueur_enregistrement;
857: long longueur_questure;
858: long niveau;
859: long pointeur;
860: long position_finale;
861: long position_initiale;
862:
863: socklen_t longueur_adresse;
864:
865: sqlite3_stmt *ppStmt;
866:
867: struct flock lock;
868:
869: struct sockaddr_un adresse_unix;
870: struct sockaddr_in adresse_ipv4;
871: struct sockaddr_in6 adresse_ipv6;
872:
873: struct timespec attente;
874:
875: struct_descripteur_fichier *descripteur;
876:
877: struct_objet *s_objet_adresse;
878: struct_objet *s_objet_argument_1;
879: struct_objet *s_objet_argument_2;
880: struct_objet *s_objet_resultat;
881: struct_objet *s_objet_type;
882:
883: unsigned char caractere;
884: unsigned char *commande;
885: unsigned char *tampon_lecture;
886: unsigned char *tampon;
887:
888: unsigned long i;
889:
890: (*s_etat_processus).erreur_execution = d_ex;
891:
892: attente.tv_sec = 0;
893: attente.tv_nsec = GRANULARITE_us * 1000;
894:
895: if ((*s_etat_processus).affichage_arguments == 'Y')
896: {
897: printf("\n READ ");
898:
899: if ((*s_etat_processus).langue == 'F')
900: {
901: printf("(lecture d'un enregistrement d'un fichier)\n\n");
902: }
903: else
904: {
905: printf("(read a record of a file)\n\n");
906: }
907:
908: printf(" 1: %s, %s\n\n", d_FCH, d_SCK);
909:
910: printf(" 1: %s, %s\n", d_INT, d_CHN);
911: printf(" 1: %s\n", d_FCH);
912: return;
913: }
914: else if ((*s_etat_processus).test_instruction == 'Y')
915: {
916: (*s_etat_processus).nombre_arguments = -1;
917: return;
918: }
919:
920: if (test_cfsf(s_etat_processus, 31) == d_vrai)
921: {
922: if ((*s_etat_processus).l_base_pile == NULL)
923: {
924: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
925: return;
926: }
927:
928: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
929: {
930: if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
931: .donnee).objet)).acces == 'S')
932: {
933: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
934: {
935: return;
936: }
937: }
938: else
939: {
940: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
941: {
942: return;
943: }
944: }
945: }
946: else
947: {
948: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
949: {
950: return;
951: }
952: }
953: }
954:
955: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
956: &s_objet_argument_1) == d_erreur)
957: {
958: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
959: return;
960: }
961:
962: if ((*s_objet_argument_1).type == FCH)
963: {
964: if ((descripteur = descripteur_fichier(s_etat_processus,
965: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
966: {
967: return;
968: }
969:
970: /*
971: * Vérification des verrous
972: */
973:
974: lock.l_type = F_RDLCK;
975: lock.l_whence = SEEK_SET;
976: lock.l_start = 0;
977: lock.l_len = 0;
978: lock.l_pid = getpid();
979:
980: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
981: == -1)
982: {
983: liberation(s_etat_processus, s_objet_argument_1);
984:
985: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
986: return;
987: }
988:
989: if (lock.l_type != F_UNLCK)
990: {
991: liberation(s_etat_processus, s_objet_argument_1);
992:
993: (*s_etat_processus).erreur_execution =
994: d_ex_fichier_verrouille;
995: return;
996: }
997:
998: /*
999: * Vérification de l'autorisation de lecture
1000: */
1001:
1002: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1003: == 'W')
1004: {
1005: liberation(s_etat_processus, s_objet_argument_1);
1006:
1007: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1008: return;
1009: }
1010: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
1011: == 'N')
1012: {
1013: if ((*descripteur).type == 'C')
1014: {
1015: if (fflush((*descripteur).descripteur_c) != 0)
1016: {
1017: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1018: return;
1019: }
1020: }
1021: }
1022:
1023: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
1024: {
1025: /*
1026: * Fichiers formatés
1027: */
1028:
1029: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1030: == 'S')
1031: {
1032: /*
1033: * Fichiers séquentiels
1034: */
1035:
1036: longueur_questure = 256;
1037:
1038: if ((tampon_lecture = malloc(longueur_questure *
1039: sizeof(unsigned char))) == NULL)
1040: {
1041: (*s_etat_processus).erreur_systeme =
1042: d_es_allocation_memoire;
1043: return;
1044: }
1045:
1046: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
1047:
1048: if ((position_initiale = ftell((*descripteur).descripteur_c))
1049: == -1)
1050: {
1051: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1052: return;
1053: }
1054:
1055: do
1056: {
1057: longueur_effective = fread(tampon_lecture,
1058: (size_t) sizeof(unsigned char), longueur_questure,
1059: (*descripteur).descripteur_c);
1060:
1061: pointeur = 0;
1062: presence_indicateur = d_faux;
1063:
1064: while(pointeur < longueur_effective)
1065: {
1066: if (tampon_lecture[pointeur] == '{')
1067: {
1068: presence_indicateur = d_vrai;
1069: break;
1070: }
1071:
1072: position_initiale++;
1073: pointeur++;
1074: }
1075:
1076: if (presence_indicateur == d_vrai)
1077: {
1078: break;
1079: }
1080: } while(longueur_effective == longueur_questure);
1081:
1082: if (presence_indicateur == d_faux)
1083: {
1084: liberation(s_etat_processus, s_objet_argument_1);
1085: free(tampon_lecture);
1086:
1087: (*s_etat_processus).erreur_execution =
1088: d_ex_fin_de_fichier_atteinte;
1089: return;
1090: }
1091:
1092: position_finale = position_initiale + 1;
1093: presence_chaine = d_faux;
1094: niveau = 1;
1095:
1096: if (fseek((*descripteur).descripteur_c, position_finale,
1097: SEEK_SET) != 0)
1098: {
1099: liberation(s_etat_processus, s_objet_argument_1);
1100: free(tampon_lecture);
1101:
1102: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1103: return;
1104: }
1105:
1106: do
1107: {
1108: longueur_effective = fread(tampon_lecture,
1109: (size_t) sizeof(unsigned char), longueur_questure,
1110: (*descripteur).descripteur_c);
1111:
1112: pointeur = 0;
1113: presence_indicateur = d_faux;
1114:
1115: while(pointeur < longueur_effective)
1116: {
1117: if (tampon_lecture[pointeur] == '"')
1118: {
1119: presence_chaine = (presence_chaine == d_vrai)
1120: ? d_faux : d_vrai;
1121: }
1122: else
1123: {
1124: if (presence_chaine == d_faux)
1125: {
1126: if (tampon_lecture[pointeur] == '{')
1127: {
1128: niveau++;
1129: }
1130: else if (tampon_lecture[pointeur] == '}')
1131: {
1132: niveau--;
1133: }
1134: }
1135: }
1136:
1137: position_finale++;
1138: pointeur++;
1139:
1140: if (niveau == 0)
1141: {
1142: presence_indicateur = d_vrai;
1143: break;
1144: }
1145: }
1146:
1147: if (presence_indicateur == d_vrai)
1148: {
1149: break;
1150: }
1151: } while(longueur_effective == longueur_questure);
1152:
1153: if (presence_indicateur == d_faux)
1154: {
1155: liberation(s_etat_processus, s_objet_argument_1);
1156: free(tampon_lecture);
1157:
1158: (*s_etat_processus).erreur_execution =
1159: d_ex_fin_de_fichier_atteinte;
1160: return;
1161: }
1162:
1163: free(tampon_lecture);
1164: longueur_enregistrement = position_finale - position_initiale;
1165:
1166: if ((tampon_lecture = malloc((longueur_enregistrement + 1) *
1167: sizeof(unsigned char))) == NULL)
1168: {
1169: (*s_etat_processus).erreur_systeme =
1170: d_es_allocation_memoire;
1171: return;
1172: }
1173:
1174: if (fseek((*descripteur).descripteur_c, position_initiale,
1175: SEEK_SET) != 0)
1176: {
1177: liberation(s_etat_processus, s_objet_argument_1);
1178: free(tampon_lecture);
1179:
1180: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1181: return;
1182: }
1183:
1184: longueur_effective = fread(tampon_lecture,
1185: (size_t) sizeof(unsigned char),
1186: (size_t) longueur_enregistrement,
1187: (*descripteur).descripteur_c);
1188:
1189: if (longueur_effective != longueur_enregistrement)
1190: {
1191: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1192: return;
1193: }
1194:
1195: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
1196: tampon = (*s_etat_processus).instruction_courante;
1197:
1198: if (((*s_etat_processus).instruction_courante =
1199: transliteration(s_etat_processus, tampon_lecture,
1200: "UTF-8", d_locale)) == NULL)
1201: {
1202: (*s_etat_processus).instruction_courante = tampon;
1203: liberation(s_etat_processus, s_objet_argument_1);
1204: free(tampon_lecture);
1205: return;
1206: }
1207:
1208: indicateur_48 = test_cfsf(s_etat_processus, 48);
1209: cf(s_etat_processus, 48);
1210:
1211: recherche_type(s_etat_processus);
1212: free((*s_etat_processus).instruction_courante);
1213:
1214: if ((*s_etat_processus).erreur_execution != d_ex)
1215: {
1216: if (indicateur_48 == d_vrai)
1217: {
1218: sf(s_etat_processus, 48);
1219: }
1220: else
1221: {
1222: cf(s_etat_processus, 48);
1223: }
1224:
1225: (*s_etat_processus).instruction_courante = tampon;
1226: free(tampon_lecture);
1227:
1228: liberation(s_etat_processus, s_objet_argument_1);
1229: return;
1230: }
1231:
1232: if (indicateur_48 == d_vrai)
1233: {
1234: sf(s_etat_processus, 48);
1235: }
1236: else
1237: {
1238: cf(s_etat_processus, 48);
1239: }
1240:
1241: (*s_etat_processus).instruction_courante = tampon;
1242: free(tampon_lecture);
1243: }
1244: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1245: == 'D')
1246: {
1247: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1248:
1249: if (depilement(s_etat_processus, &((*s_etat_processus)
1250: .l_base_pile), &s_objet_argument_2) == d_erreur)
1251: {
1252: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1253: return;
1254: }
1255:
1256: if ((*s_objet_argument_2).type != INT)
1257: {
1258: liberation(s_etat_processus, s_objet_argument_1);
1259: liberation(s_etat_processus, s_objet_argument_2);
1260:
1261: (*s_etat_processus).erreur_execution =
1262: d_ex_erreur_type_argument;
1263: return;
1264: }
1265:
1266: if (alsprintf(&commande, "select data from data where "
1267: "id = %lld", (*((integer8 *) (*s_objet_argument_2)
1268: .objet))) < 0)
1269: {
1270: (*s_etat_processus).erreur_systeme =
1271: d_es_allocation_memoire;
1272: return;
1273: }
1274:
1275: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1276: commande, strlen(commande), &ppStmt, &queue)
1277: != SQLITE_OK)
1278: {
1279: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1280: return;
1281: }
1282:
1283:
1284: switch(sqlite3_step(ppStmt))
1285: {
1286: case SQLITE_ROW:
1287: {
1288: // Résultat attendu
1289: break;
1290: }
1291:
1292: case SQLITE_DONE:
1293: {
1294: // Aucun enregistrement
1295: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1296: {
1297: (*s_etat_processus).erreur_systeme =
1298: d_es_erreur_fichier;
1299: return;
1300: }
1301:
1302: free(commande);
1303:
1304: liberation(s_etat_processus, s_objet_argument_1);
1305: liberation(s_etat_processus, s_objet_argument_2);
1306:
1307: (*s_etat_processus).erreur_execution =
1308: d_ex_enregistrement_inexistant;
1309: return;
1310: }
1311:
1312: default:
1313: {
1314: (*s_etat_processus).erreur_systeme =
1315: d_es_erreur_fichier;
1316: return;
1317: }
1318: }
1319:
1320: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1321: {
1322: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1323: return;
1324: }
1325:
1326: tampon = (*s_etat_processus).instruction_courante;
1327:
1328: if ((tampon_lecture = (unsigned char *)
1329: sqlite3_column_text(ppStmt, 0)) == NULL)
1330: {
1331: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1332: return;
1333: }
1334:
1335: if (((*s_etat_processus).instruction_courante =
1336: transliteration(s_etat_processus, tampon_lecture,
1337: "UTF-8", d_locale)) == NULL)
1338: {
1339: (*s_etat_processus).instruction_courante = tampon;
1340:
1341: liberation(s_etat_processus, s_objet_argument_1);
1342: liberation(s_etat_processus, s_objet_argument_2);
1343: free(commande);
1344: return;
1345: }
1346:
1347: indicateur_48 = test_cfsf(s_etat_processus, 48);
1348: cf(s_etat_processus, 48);
1349:
1350: recherche_type(s_etat_processus);
1351:
1352: if ((*s_etat_processus).erreur_execution != d_ex)
1353: {
1354: if (indicateur_48 == d_vrai)
1355: {
1356: sf(s_etat_processus, 48);
1357: }
1358: else
1359: {
1360: cf(s_etat_processus, 48);
1361: }
1362:
1363: (*s_etat_processus).instruction_courante = tampon;
1364:
1365: liberation(s_etat_processus, s_objet_argument_1);
1366: liberation(s_etat_processus, s_objet_argument_2);
1367:
1368: free((*s_etat_processus).instruction_courante);
1369: free(commande);
1370: return;
1371: }
1372:
1373: if (indicateur_48 == d_vrai)
1374: {
1375: sf(s_etat_processus, 48);
1376: }
1377: else
1378: {
1379: cf(s_etat_processus, 48);
1380: }
1381:
1382: free((*s_etat_processus).instruction_courante);
1383: liberation(s_etat_processus, s_objet_argument_2);
1384: (*s_etat_processus).instruction_courante = tampon;
1385:
1386: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1387: {
1388: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1389: return;
1390: }
1391:
1392: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1393: {
1394: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1395: return;
1396: }
1397:
1398: free(commande);
1399: }
1400: else
1401: {
1402: }
1403: }
1404: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
1405: == 'Y')
1406: {
1407: /*
1408: * Fichiers non formatés
1409: */
1410: }
1411: else
1412: {
1413: /*
1414: * Fichiers de type FLOW
1415: */
1416: }
1417: }
1418: else if ((*s_objet_argument_1).type == SCK)
1419: {
1420: /*
1421: * Vérification de l'autorisation de lecture
1422: */
1423:
1424: if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection
1425: == 'W')
1426: {
1427: liberation(s_etat_processus, s_objet_argument_1);
1428:
1429: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1430: return;
1431: }
1432:
1433: /*
1434: * Vérification de l'écoute de la socket si celle-ci est connectée
1435: */
1436:
1437: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
1438: "STREAM") == 0) || (strcmp((*((struct_socket *)
1439: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
1440: == 0))
1441: {
1442: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1443: .socket_en_ecoute == 'Y')
1444: {
1445: liberation(s_etat_processus, s_objet_argument_1);
1446:
1447: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
1448: return;
1449: }
1450: }
1451:
1452: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
1453: { // Socket formatée
1454: longueur_questure = 256;
1455:
1456: do
1457: {
1458: if ((tampon_lecture = malloc((longueur_questure + 1) *
1459: sizeof(unsigned char))) == NULL)
1460: {
1461: (*s_etat_processus).erreur_systeme =
1462: d_es_allocation_memoire;
1463: return;
1464: }
1465:
1466: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1467: {
1468: (*s_etat_processus).erreur_systeme = d_es_processus;
1469: return;
1470: }
1471:
1472: for(;;)
1473: {
1474: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1475: .domaine == PF_UNIX)
1476: {
1477: longueur_adresse = sizeof(adresse_unix);
1478: longueur_effective = recvfrom((*((struct_socket *)
1479: (*s_objet_argument_1).objet)).socket,
1480: tampon_lecture, longueur_questure,
1481: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1482: &adresse_unix, &longueur_adresse);
1483: }
1484: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1485: .domaine == PF_INET)
1486: {
1487: longueur_adresse = sizeof(adresse_ipv4);
1488: longueur_effective = recvfrom((*((struct_socket *)
1489: (*s_objet_argument_1).objet)).socket,
1490: tampon_lecture, longueur_questure,
1491: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1492: &adresse_ipv4, &longueur_adresse);
1493: }
1494: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1495: .domaine == PF_INET6)
1496: {
1497: longueur_adresse = sizeof(adresse_ipv6);
1498: longueur_effective = recvfrom((*((struct_socket *)
1499: (*s_objet_argument_1).objet)).socket,
1500: tampon_lecture, longueur_questure,
1501: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1502: &adresse_ipv6, &longueur_adresse);
1503: }
1504: else
1505: {
1506: free(tampon_lecture);
1507: liberation(s_etat_processus, s_objet_argument_1);
1508:
1509: while(sem_wait(&((*s_etat_processus)
1510: .semaphore_fork)) == -1)
1511: {
1512: if (errno != EINTR)
1513: {
1514: (*s_etat_processus).erreur_systeme =
1515: d_es_processus;
1516: return;
1517: }
1518: }
1519:
1520: (*s_etat_processus).erreur_execution =
1521: d_ex_erreur_acces_fichier;
1522: return;
1523: }
1524:
1525: if (longueur_effective < 0)
1526: {
1527: nanosleep(&attente, NULL);
1528: scrutation_injection(s_etat_processus);
1529: }
1530:
1531: if (((*s_etat_processus).var_volatile_requete_arret == -1)
1532: || (longueur_effective >= 0))
1533: {
1534: break;
1535: }
1536: }
1537:
1538: while(sem_wait(&((*s_etat_processus).semaphore_fork))
1539: == -1)
1540: {
1541: if (errno != EINTR)
1542: {
1543: (*s_etat_processus).erreur_systeme = d_es_processus;
1544: return;
1545: }
1546: }
1547:
1548: if ((*s_etat_processus).var_volatile_requete_arret == -1)
1549: {
1550:
1551: /*
1552: * Si le père tue le processus courant grâce au signal
1553: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
1554: * correspond à l'utilisation de STOP sur le processus
1555: * en cours. La variable longueur_effective vaut '-1'.
1556: */
1557:
1558: free(tampon_lecture);
1559: liberation(s_etat_processus, s_objet_argument_1);
1560: return;
1561: }
1562:
1563: if (longueur_effective == -1)
1564: {
1565: free(tampon_lecture);
1566: liberation(s_etat_processus, s_objet_argument_1);
1567:
1568: (*s_etat_processus).erreur_execution =
1569: d_ex_erreur_acces_fichier;
1570: return;
1571: }
1572:
1573: position_initiale = 0;
1574: presence_indicateur = d_faux;
1575:
1576: do
1577: {
1578: if (tampon_lecture[position_initiale] == '{')
1579: {
1580: presence_indicateur = d_vrai;
1581: break;
1582: }
1583:
1584: position_initiale++;
1585: } while(position_initiale < longueur_effective);
1586:
1587:
1588: if (presence_indicateur == d_vrai)
1589: {
1590: position_finale = position_initiale + 1;
1591: presence_chaine = d_faux;
1592: presence_indicateur = d_faux;
1593: niveau = 1;
1594:
1595: while(position_finale < longueur_effective)
1596: {
1597: caractere = tampon_lecture[position_finale];
1598:
1599: if (caractere == '"')
1600: {
1601: presence_chaine = (presence_chaine == d_vrai)
1602: ? d_faux : d_vrai;
1603: }
1604: else
1605: {
1606: if (presence_chaine == d_faux)
1607: {
1608: if (caractere == '{')
1609: {
1610: niveau++;
1611: }
1612: else if (caractere == '}')
1613: {
1614: niveau--;
1615: }
1616: }
1617: }
1618:
1619: if (niveau == 0)
1620: {
1621: presence_indicateur = d_vrai;
1622: break;
1623: }
1624:
1625: position_finale++;
1626: }
1627: }
1628:
1629: if (presence_indicateur == d_faux)
1630: {
1631: if (longueur_effective < longueur_questure)
1632: {
1633: liberation(s_etat_processus, s_objet_argument_1);
1634: free(tampon_lecture);
1635:
1636: (*s_etat_processus).erreur_execution =
1637: d_ex_fin_de_fichier_atteinte;
1638: return;
1639: }
1640:
1641: free(tampon_lecture);
1642: longueur_questure *= 2;
1643: }
1644: } while(presence_indicateur == d_faux);
1645:
1646: tampon_lecture[++position_finale] = d_code_fin_chaine;
1647: tampon = (*s_etat_processus).instruction_courante;
1648: (*s_etat_processus).instruction_courante = &(tampon_lecture
1649: [position_initiale]);
1650:
1651: indicateur_48 = test_cfsf(s_etat_processus, 48);
1652: cf(s_etat_processus, 48);
1653:
1654: recherche_type(s_etat_processus);
1655:
1656: if ((*s_etat_processus).erreur_execution != d_ex)
1657: {
1658: (*s_etat_processus).instruction_courante = tampon;
1659: free(tampon_lecture);
1660:
1661: liberation(s_etat_processus, s_objet_argument_1);
1662: return;
1663: }
1664:
1665: if (indicateur_48 == d_vrai)
1666: {
1667: sf(s_etat_processus, 48);
1668: }
1669: else
1670: {
1671: cf(s_etat_processus, 48);
1672: }
1673:
1674: (*s_etat_processus).instruction_courante = tampon;
1675:
1676: /*
1677: * Création de la liste de sortie
1678: */
1679:
1680: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1681: &s_objet_type) == d_erreur)
1682: {
1683: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1684: return;
1685: }
1686:
1687: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1688: == NULL)
1689: {
1690: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1691: return;
1692: }
1693:
1694: if (((*s_objet_resultat).objet =
1695: allocation_maillon(s_etat_processus)) == NULL)
1696: {
1697: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1698: return;
1699: }
1700:
1701: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
1702: .donnee = s_objet_type;
1703:
1704: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
1705: .suivant = allocation_maillon(s_etat_processus)) == NULL)
1706: {
1707: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1708: return;
1709: }
1710:
1711: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
1712: .suivant = NULL;
1713:
1714: if ((s_objet_adresse = allocation(s_etat_processus, LST))
1715: == NULL)
1716: {
1717: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1718: return;
1719: }
1720:
1721: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
1722: .donnee = s_objet_adresse;
1723:
1724: /*
1725: * Les informations concernant la cible sont valides si
1726: * la socket est non connectée et des domaines INET ou INET6.
1727: * Dans tous les autres cas, on renvoie une liste vide.
1728: */
1729:
1730: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
1731: == PF_UNIX) || (strcmp((*((struct_socket *)
1732: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
1733: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
1734: .type, "SEQUENTIAL DATAGRAM") == 0))
1735: {
1736: longueur_adresse = 0;
1737: recvfrom((*((struct_socket *)
1738: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1739: position_finale, MSG_DONTWAIT,
1740: NULL, &longueur_adresse);
1741:
1742: (*s_objet_adresse).objet = NULL;
1743: }
1744: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1745: .domaine == PF_INET)
1746: {
1747: longueur_adresse = sizeof(adresse_ipv4);
1748: recvfrom((*((struct_socket *)
1749: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1750: position_finale, MSG_DONTWAIT,
1751: (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
1752:
1753: if (((*s_objet_adresse).objet =
1754: allocation_maillon(s_etat_processus)) == NULL)
1755: {
1756: (*s_etat_processus).erreur_systeme =
1757: d_es_allocation_memoire;
1758: return;
1759: }
1760:
1761: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1762: .donnee = allocation(s_etat_processus, VIN)) == NULL)
1763: {
1764: (*s_etat_processus).erreur_systeme =
1765: d_es_allocation_memoire;
1766: return;
1767: }
1768:
1769: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
1770: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
1771:
1772: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
1773: (*s_objet_adresse).objet)).donnee).objet)).tableau =
1774: malloc(4 * sizeof(integer8))) == NULL)
1775: {
1776: (*s_etat_processus).erreur_systeme =
1777: d_es_allocation_memoire;
1778: return;
1779: }
1780:
1781: ((integer8 *) (*((struct_vecteur *)
1782: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1783: .objet)).donnee).objet)).tableau)[0] =
1784: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
1785: ((integer8 *) (*((struct_vecteur *)
1786: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1787: .objet)).donnee).objet)).tableau)[1] =
1788: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
1789: ((integer8 *) (*((struct_vecteur *)
1790: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1791: .objet)).donnee).objet)).tableau)[2] =
1792: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
1793: ((integer8 *) (*((struct_vecteur *)
1794: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1795: .objet)).donnee).objet)).tableau)[3] =
1796: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
1797:
1798: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1799: .suivant = allocation_maillon(s_etat_processus))
1800: == NULL)
1801: {
1802: (*s_etat_processus).erreur_systeme =
1803: d_es_allocation_memoire;
1804: return;
1805: }
1806:
1807: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1808: .suivant).donnee = allocation(s_etat_processus, INT))
1809: == NULL)
1810: {
1811: (*s_etat_processus).erreur_systeme =
1812: d_es_allocation_memoire;
1813: return;
1814: }
1815:
1816: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1817: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
1818: (integer8) ntohs(adresse_ipv4.sin_port);
1819:
1820: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1821: .suivant).suivant = NULL;
1822: }
1823: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1824: .domaine == PF_INET6)
1825: {
1826: longueur_adresse = sizeof(adresse_ipv6);
1827: recvfrom((*((struct_socket *)
1828: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1829: position_finale, MSG_DONTWAIT,
1830: (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
1831:
1832: if (((*s_objet_adresse).objet =
1833: allocation_maillon(s_etat_processus)) == NULL)
1834: {
1835: (*s_etat_processus).erreur_systeme =
1836: d_es_allocation_memoire;
1837: return;
1838: }
1839:
1840: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1841: .donnee = allocation(s_etat_processus, VIN)) == NULL)
1842: {
1843: (*s_etat_processus).erreur_systeme =
1844: d_es_allocation_memoire;
1845: return;
1846: }
1847:
1848: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
1849: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
1850:
1851: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
1852: (*s_objet_adresse).objet)).donnee).objet)).tableau =
1853: malloc(16 * sizeof(integer8))) == NULL)
1854: {
1855: (*s_etat_processus).erreur_systeme =
1856: d_es_allocation_memoire;
1857: return;
1858: }
1859:
1860: for(i = 0; i < 16; i++)
1861: {
1862: ((integer8 *) (*((struct_vecteur *)
1863: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1864: .objet)).donnee).objet)).tableau)[0] =
1865: adresse_ipv6.sin6_addr.s6_addr[i];
1866: }
1867:
1868: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1869: .suivant = allocation_maillon(s_etat_processus))
1870: == NULL)
1871: {
1872: (*s_etat_processus).erreur_systeme =
1873: d_es_allocation_memoire;
1874: return;
1875: }
1876:
1877: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1878: .suivant).donnee = allocation(s_etat_processus, INT))
1879: == NULL)
1880: {
1881: (*s_etat_processus).erreur_systeme =
1882: d_es_allocation_memoire;
1883: return;
1884: }
1885:
1886: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1887: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
1888: (integer8) ntohs(adresse_ipv6.sin6_port);
1889:
1890: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1891: .suivant).suivant = NULL;
1892: }
1893: else
1894: {
1895: longueur_adresse = 0;
1896: recvfrom((*((struct_socket *)
1897: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1898: position_finale, MSG_DONTWAIT,
1899: NULL, &longueur_adresse);
1900: }
1901:
1902: free(tampon_lecture);
1903:
1904: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1905: s_objet_resultat) == d_erreur)
1906: {
1907: return;
1908: }
1909: }
1910: else
1911: {
1912: /* FLOW ou UNFORMATTED */
1913: }
1914: }
1915: else
1916: {
1917: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1918: return;
1919: }
1920:
1921: liberation(s_etat_processus, s_objet_argument_1);
1922:
1923: return;
1924: }
1925:
1926: // 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