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: if (pointeur > 0)
1120: {
1121: if (tampon_lecture[pointeur - 1] != '\\')
1122: {
1123: presence_chaine = (presence_chaine ==
1124: d_vrai) ? d_faux : d_vrai;
1125: }
1126: }
1127: else
1128: {
1129: presence_chaine = (presence_chaine == d_vrai)
1130: ? d_faux : d_vrai;
1131: }
1132: }
1133: else
1134: {
1135: if (presence_chaine == d_faux)
1136: {
1137: if (tampon_lecture[pointeur] == '{')
1138: {
1139: niveau++;
1140: }
1141: else if (tampon_lecture[pointeur] == '}')
1142: {
1143: niveau--;
1144: }
1145: }
1146: }
1147:
1148: position_finale++;
1149: pointeur++;
1150:
1151: if (niveau == 0)
1152: {
1153: presence_indicateur = d_vrai;
1154: break;
1155: }
1156: }
1157:
1158: if (presence_indicateur == d_vrai)
1159: {
1160: break;
1161: }
1162: } while(longueur_effective == longueur_questure);
1163:
1164: if (presence_indicateur == d_faux)
1165: {
1166: liberation(s_etat_processus, s_objet_argument_1);
1167: free(tampon_lecture);
1168:
1169: (*s_etat_processus).erreur_execution =
1170: d_ex_fin_de_fichier_atteinte;
1171: return;
1172: }
1173:
1174: free(tampon_lecture);
1175: longueur_enregistrement = position_finale - position_initiale;
1176:
1177: if ((tampon_lecture = malloc((longueur_enregistrement + 1) *
1178: sizeof(unsigned char))) == NULL)
1179: {
1180: (*s_etat_processus).erreur_systeme =
1181: d_es_allocation_memoire;
1182: return;
1183: }
1184:
1185: if (fseek((*descripteur).descripteur_c, position_initiale,
1186: SEEK_SET) != 0)
1187: {
1188: liberation(s_etat_processus, s_objet_argument_1);
1189: free(tampon_lecture);
1190:
1191: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1192: return;
1193: }
1194:
1195: longueur_effective = fread(tampon_lecture,
1196: (size_t) sizeof(unsigned char),
1197: (size_t) longueur_enregistrement,
1198: (*descripteur).descripteur_c);
1199:
1200: if (longueur_effective != longueur_enregistrement)
1201: {
1202: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1203: return;
1204: }
1205:
1206: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
1207: tampon = (*s_etat_processus).instruction_courante;
1208:
1209: if (((*s_etat_processus).instruction_courante =
1210: transliteration(s_etat_processus, tampon_lecture,
1211: "UTF-8", d_locale)) == NULL)
1212: {
1213: (*s_etat_processus).instruction_courante = tampon;
1214: liberation(s_etat_processus, s_objet_argument_1);
1215: free(tampon_lecture);
1216: return;
1217: }
1218:
1219: indicateur_48 = test_cfsf(s_etat_processus, 48);
1220: cf(s_etat_processus, 48);
1221:
1222: recherche_type(s_etat_processus);
1223: free((*s_etat_processus).instruction_courante);
1224:
1225: if ((*s_etat_processus).erreur_execution != d_ex)
1226: {
1227: if (indicateur_48 == d_vrai)
1228: {
1229: sf(s_etat_processus, 48);
1230: }
1231: else
1232: {
1233: cf(s_etat_processus, 48);
1234: }
1235:
1236: (*s_etat_processus).instruction_courante = tampon;
1237: free(tampon_lecture);
1238:
1239: liberation(s_etat_processus, s_objet_argument_1);
1240: return;
1241: }
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: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1256: == 'D')
1257: {
1258: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
1259:
1260: if (depilement(s_etat_processus, &((*s_etat_processus)
1261: .l_base_pile), &s_objet_argument_2) == d_erreur)
1262: {
1263: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1264: return;
1265: }
1266:
1267: if ((*s_objet_argument_2).type != INT)
1268: {
1269: liberation(s_etat_processus, s_objet_argument_1);
1270: liberation(s_etat_processus, s_objet_argument_2);
1271:
1272: (*s_etat_processus).erreur_execution =
1273: d_ex_erreur_type_argument;
1274: return;
1275: }
1276:
1277: if (alsprintf(&commande, "select data from data where "
1278: "id = %lld", (*((integer8 *) (*s_objet_argument_2)
1279: .objet))) < 0)
1280: {
1281: (*s_etat_processus).erreur_systeme =
1282: d_es_allocation_memoire;
1283: return;
1284: }
1285:
1286: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1287: commande, strlen(commande), &ppStmt, &queue)
1288: != SQLITE_OK)
1289: {
1290: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1291: return;
1292: }
1293:
1294:
1295: switch(sqlite3_step(ppStmt))
1296: {
1297: case SQLITE_ROW:
1298: {
1299: // Résultat attendu
1300: break;
1301: }
1302:
1303: case SQLITE_DONE:
1304: {
1305: // Aucun enregistrement
1306: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1307: {
1308: (*s_etat_processus).erreur_systeme =
1309: d_es_erreur_fichier;
1310: return;
1311: }
1312:
1313: free(commande);
1314:
1315: liberation(s_etat_processus, s_objet_argument_1);
1316: liberation(s_etat_processus, s_objet_argument_2);
1317:
1318: (*s_etat_processus).erreur_execution =
1319: d_ex_enregistrement_inexistant;
1320: return;
1321: }
1322:
1323: default:
1324: {
1325: (*s_etat_processus).erreur_systeme =
1326: d_es_erreur_fichier;
1327: return;
1328: }
1329: }
1330:
1331: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
1332: {
1333: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1334: return;
1335: }
1336:
1337: tampon = (*s_etat_processus).instruction_courante;
1338:
1339: if ((tampon_lecture = (unsigned char *)
1340: sqlite3_column_text(ppStmt, 0)) == NULL)
1341: {
1342: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1343: return;
1344: }
1345:
1346: if (((*s_etat_processus).instruction_courante =
1347: transliteration(s_etat_processus, tampon_lecture,
1348: "UTF-8", d_locale)) == NULL)
1349: {
1350: (*s_etat_processus).instruction_courante = tampon;
1351:
1352: liberation(s_etat_processus, s_objet_argument_1);
1353: liberation(s_etat_processus, s_objet_argument_2);
1354: free(commande);
1355: return;
1356: }
1357:
1358: indicateur_48 = test_cfsf(s_etat_processus, 48);
1359: cf(s_etat_processus, 48);
1360:
1361: recherche_type(s_etat_processus);
1362:
1363: if ((*s_etat_processus).erreur_execution != d_ex)
1364: {
1365: if (indicateur_48 == d_vrai)
1366: {
1367: sf(s_etat_processus, 48);
1368: }
1369: else
1370: {
1371: cf(s_etat_processus, 48);
1372: }
1373:
1374: (*s_etat_processus).instruction_courante = tampon;
1375:
1376: liberation(s_etat_processus, s_objet_argument_1);
1377: liberation(s_etat_processus, s_objet_argument_2);
1378:
1379: free((*s_etat_processus).instruction_courante);
1380: free(commande);
1381: return;
1382: }
1383:
1384: if (indicateur_48 == d_vrai)
1385: {
1386: sf(s_etat_processus, 48);
1387: }
1388: else
1389: {
1390: cf(s_etat_processus, 48);
1391: }
1392:
1393: free((*s_etat_processus).instruction_courante);
1394: liberation(s_etat_processus, s_objet_argument_2);
1395: (*s_etat_processus).instruction_courante = tampon;
1396:
1397: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1398: {
1399: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1400: return;
1401: }
1402:
1403: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1404: {
1405: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1406: return;
1407: }
1408:
1409: free(commande);
1410: }
1411: else
1412: {
1413: }
1414: }
1415: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
1416: == 'Y')
1417: {
1418: /*
1419: * Fichiers non formatés
1420: */
1421: }
1422: else
1423: {
1424: /*
1425: * Fichiers de type FLOW
1426: */
1427: }
1428: }
1429: else if ((*s_objet_argument_1).type == SCK)
1430: {
1431: /*
1432: * Vérification de l'autorisation de lecture
1433: */
1434:
1435: if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection
1436: == 'W')
1437: {
1438: liberation(s_etat_processus, s_objet_argument_1);
1439:
1440: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1441: return;
1442: }
1443:
1444: /*
1445: * Vérification de l'écoute de la socket si celle-ci est connectée
1446: */
1447:
1448: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
1449: "STREAM") == 0) || (strcmp((*((struct_socket *)
1450: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
1451: == 0))
1452: {
1453: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1454: .socket_en_ecoute == 'Y')
1455: {
1456: liberation(s_etat_processus, s_objet_argument_1);
1457:
1458: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
1459: return;
1460: }
1461: }
1462:
1463: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
1464: { // Socket formatée
1465: longueur_questure = 256;
1466:
1467: do
1468: {
1469: if ((tampon_lecture = malloc((longueur_questure + 1) *
1470: sizeof(unsigned char))) == NULL)
1471: {
1472: (*s_etat_processus).erreur_systeme =
1473: d_es_allocation_memoire;
1474: return;
1475: }
1476:
1477: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1478: {
1479: (*s_etat_processus).erreur_systeme = d_es_processus;
1480: return;
1481: }
1482:
1483: for(;;)
1484: {
1485: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1486: .domaine == PF_UNIX)
1487: {
1488: longueur_adresse = sizeof(adresse_unix);
1489: longueur_effective = recvfrom((*((struct_socket *)
1490: (*s_objet_argument_1).objet)).socket,
1491: tampon_lecture, longueur_questure,
1492: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1493: &adresse_unix, &longueur_adresse);
1494: }
1495: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1496: .domaine == PF_INET)
1497: {
1498: longueur_adresse = sizeof(adresse_ipv4);
1499: longueur_effective = recvfrom((*((struct_socket *)
1500: (*s_objet_argument_1).objet)).socket,
1501: tampon_lecture, longueur_questure,
1502: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1503: &adresse_ipv4, &longueur_adresse);
1504: }
1505: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1506: .domaine == PF_INET6)
1507: {
1508: longueur_adresse = sizeof(adresse_ipv6);
1509: longueur_effective = recvfrom((*((struct_socket *)
1510: (*s_objet_argument_1).objet)).socket,
1511: tampon_lecture, longueur_questure,
1512: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
1513: &adresse_ipv6, &longueur_adresse);
1514: }
1515: else
1516: {
1517: free(tampon_lecture);
1518: liberation(s_etat_processus, s_objet_argument_1);
1519:
1520: while(sem_wait(&((*s_etat_processus)
1521: .semaphore_fork)) == -1)
1522: {
1523: if (errno != EINTR)
1524: {
1525: (*s_etat_processus).erreur_systeme =
1526: d_es_processus;
1527: return;
1528: }
1529: }
1530:
1531: (*s_etat_processus).erreur_execution =
1532: d_ex_erreur_acces_fichier;
1533: return;
1534: }
1535:
1536: if (longueur_effective < 0)
1537: {
1538: nanosleep(&attente, NULL);
1539: scrutation_injection(s_etat_processus);
1540: }
1541:
1542: if (((*s_etat_processus).var_volatile_requete_arret == -1)
1543: || (longueur_effective >= 0))
1544: {
1545: break;
1546: }
1547: }
1548:
1549: while(sem_wait(&((*s_etat_processus).semaphore_fork))
1550: == -1)
1551: {
1552: if (errno != EINTR)
1553: {
1554: (*s_etat_processus).erreur_systeme = d_es_processus;
1555: return;
1556: }
1557: }
1558:
1559: if ((*s_etat_processus).var_volatile_requete_arret == -1)
1560: {
1561:
1562: /*
1563: * Si le père tue le processus courant grâce au signal
1564: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
1565: * correspond à l'utilisation de STOP sur le processus
1566: * en cours. La variable longueur_effective vaut '-1'.
1567: */
1568:
1569: free(tampon_lecture);
1570: liberation(s_etat_processus, s_objet_argument_1);
1571: return;
1572: }
1573:
1574: if (longueur_effective == -1)
1575: {
1576: free(tampon_lecture);
1577: liberation(s_etat_processus, s_objet_argument_1);
1578:
1579: (*s_etat_processus).erreur_execution =
1580: d_ex_erreur_acces_fichier;
1581: return;
1582: }
1583:
1584: position_initiale = 0;
1585: presence_indicateur = d_faux;
1586:
1587: do
1588: {
1589: if (tampon_lecture[position_initiale] == '{')
1590: {
1591: presence_indicateur = d_vrai;
1592: break;
1593: }
1594:
1595: position_initiale++;
1596: } while(position_initiale < longueur_effective);
1597:
1598:
1599: if (presence_indicateur == d_vrai)
1600: {
1601: position_finale = position_initiale + 1;
1602: presence_chaine = d_faux;
1603: presence_indicateur = d_faux;
1604: niveau = 1;
1605:
1606: while(position_finale < longueur_effective)
1607: {
1608: caractere = tampon_lecture[position_finale];
1609:
1610: if (caractere == '"')
1611: {
1612: presence_chaine = (presence_chaine == d_vrai)
1613: ? d_faux : d_vrai;
1614: }
1615: else
1616: {
1617: if (presence_chaine == d_faux)
1618: {
1619: if (caractere == '{')
1620: {
1621: niveau++;
1622: }
1623: else if (caractere == '}')
1624: {
1625: niveau--;
1626: }
1627: }
1628: }
1629:
1630: if (niveau == 0)
1631: {
1632: presence_indicateur = d_vrai;
1633: break;
1634: }
1635:
1636: position_finale++;
1637: }
1638: }
1639:
1640: if (presence_indicateur == d_faux)
1641: {
1642: if (longueur_effective < longueur_questure)
1643: {
1644: liberation(s_etat_processus, s_objet_argument_1);
1645: free(tampon_lecture);
1646:
1647: (*s_etat_processus).erreur_execution =
1648: d_ex_fin_de_fichier_atteinte;
1649: return;
1650: }
1651:
1652: free(tampon_lecture);
1653: longueur_questure *= 2;
1654: }
1655: } while(presence_indicateur == d_faux);
1656:
1657: tampon_lecture[++position_finale] = d_code_fin_chaine;
1658: tampon = (*s_etat_processus).instruction_courante;
1659: (*s_etat_processus).instruction_courante = &(tampon_lecture
1660: [position_initiale]);
1661:
1662: indicateur_48 = test_cfsf(s_etat_processus, 48);
1663: cf(s_etat_processus, 48);
1664:
1665: recherche_type(s_etat_processus);
1666:
1667: if ((*s_etat_processus).erreur_execution != d_ex)
1668: {
1669: (*s_etat_processus).instruction_courante = tampon;
1670: free(tampon_lecture);
1671:
1672: liberation(s_etat_processus, s_objet_argument_1);
1673: return;
1674: }
1675:
1676: if (indicateur_48 == d_vrai)
1677: {
1678: sf(s_etat_processus, 48);
1679: }
1680: else
1681: {
1682: cf(s_etat_processus, 48);
1683: }
1684:
1685: (*s_etat_processus).instruction_courante = tampon;
1686:
1687: /*
1688: * Création de la liste de sortie
1689: */
1690:
1691: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1692: &s_objet_type) == d_erreur)
1693: {
1694: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1695: return;
1696: }
1697:
1698: if ((s_objet_resultat = allocation(s_etat_processus, LST))
1699: == NULL)
1700: {
1701: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1702: return;
1703: }
1704:
1705: if (((*s_objet_resultat).objet =
1706: allocation_maillon(s_etat_processus)) == NULL)
1707: {
1708: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1709: return;
1710: }
1711:
1712: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
1713: .donnee = s_objet_type;
1714:
1715: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
1716: .suivant = allocation_maillon(s_etat_processus)) == NULL)
1717: {
1718: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1719: return;
1720: }
1721:
1722: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
1723: .suivant = NULL;
1724:
1725: if ((s_objet_adresse = allocation(s_etat_processus, LST))
1726: == NULL)
1727: {
1728: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1729: return;
1730: }
1731:
1732: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
1733: .donnee = s_objet_adresse;
1734:
1735: /*
1736: * Les informations concernant la cible sont valides si
1737: * la socket est non connectée et des domaines INET ou INET6.
1738: * Dans tous les autres cas, on renvoie une liste vide.
1739: */
1740:
1741: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
1742: == PF_UNIX) || (strcmp((*((struct_socket *)
1743: (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
1744: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
1745: .type, "SEQUENTIAL DATAGRAM") == 0))
1746: {
1747: longueur_adresse = 0;
1748: recvfrom((*((struct_socket *)
1749: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1750: position_finale, MSG_DONTWAIT,
1751: NULL, &longueur_adresse);
1752:
1753: (*s_objet_adresse).objet = NULL;
1754: }
1755: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1756: .domaine == PF_INET)
1757: {
1758: longueur_adresse = sizeof(adresse_ipv4);
1759: recvfrom((*((struct_socket *)
1760: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1761: position_finale, MSG_DONTWAIT,
1762: (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
1763:
1764: if (((*s_objet_adresse).objet =
1765: allocation_maillon(s_etat_processus)) == NULL)
1766: {
1767: (*s_etat_processus).erreur_systeme =
1768: d_es_allocation_memoire;
1769: return;
1770: }
1771:
1772: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1773: .donnee = allocation(s_etat_processus, VIN)) == NULL)
1774: {
1775: (*s_etat_processus).erreur_systeme =
1776: d_es_allocation_memoire;
1777: return;
1778: }
1779:
1780: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
1781: (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
1782:
1783: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
1784: (*s_objet_adresse).objet)).donnee).objet)).tableau =
1785: malloc(4 * sizeof(integer8))) == NULL)
1786: {
1787: (*s_etat_processus).erreur_systeme =
1788: d_es_allocation_memoire;
1789: return;
1790: }
1791:
1792: ((integer8 *) (*((struct_vecteur *)
1793: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1794: .objet)).donnee).objet)).tableau)[0] =
1795: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
1796: ((integer8 *) (*((struct_vecteur *)
1797: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1798: .objet)).donnee).objet)).tableau)[1] =
1799: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
1800: ((integer8 *) (*((struct_vecteur *)
1801: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1802: .objet)).donnee).objet)).tableau)[2] =
1803: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
1804: ((integer8 *) (*((struct_vecteur *)
1805: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1806: .objet)).donnee).objet)).tableau)[3] =
1807: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
1808:
1809: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1810: .suivant = allocation_maillon(s_etat_processus))
1811: == NULL)
1812: {
1813: (*s_etat_processus).erreur_systeme =
1814: d_es_allocation_memoire;
1815: return;
1816: }
1817:
1818: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1819: .suivant).donnee = allocation(s_etat_processus, INT))
1820: == NULL)
1821: {
1822: (*s_etat_processus).erreur_systeme =
1823: d_es_allocation_memoire;
1824: return;
1825: }
1826:
1827: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1828: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
1829: (integer8) ntohs(adresse_ipv4.sin_port);
1830:
1831: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1832: .suivant).suivant = NULL;
1833: }
1834: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1835: .domaine == PF_INET6)
1836: {
1837: longueur_adresse = sizeof(adresse_ipv6);
1838: recvfrom((*((struct_socket *)
1839: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1840: position_finale, MSG_DONTWAIT,
1841: (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
1842:
1843: if (((*s_objet_adresse).objet =
1844: allocation_maillon(s_etat_processus)) == NULL)
1845: {
1846: (*s_etat_processus).erreur_systeme =
1847: d_es_allocation_memoire;
1848: return;
1849: }
1850:
1851: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1852: .donnee = allocation(s_etat_processus, VIN)) == NULL)
1853: {
1854: (*s_etat_processus).erreur_systeme =
1855: d_es_allocation_memoire;
1856: return;
1857: }
1858:
1859: (*((struct_vecteur *) (*(*((struct_liste_chainee *)
1860: (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
1861:
1862: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
1863: (*s_objet_adresse).objet)).donnee).objet)).tableau =
1864: malloc(16 * sizeof(integer8))) == NULL)
1865: {
1866: (*s_etat_processus).erreur_systeme =
1867: d_es_allocation_memoire;
1868: return;
1869: }
1870:
1871: for(i = 0; i < 16; i++)
1872: {
1873: ((integer8 *) (*((struct_vecteur *)
1874: (*(*((struct_liste_chainee *) (*s_objet_adresse)
1875: .objet)).donnee).objet)).tableau)[0] =
1876: adresse_ipv6.sin6_addr.s6_addr[i];
1877: }
1878:
1879: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
1880: .suivant = allocation_maillon(s_etat_processus))
1881: == NULL)
1882: {
1883: (*s_etat_processus).erreur_systeme =
1884: d_es_allocation_memoire;
1885: return;
1886: }
1887:
1888: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1889: .suivant).donnee = allocation(s_etat_processus, INT))
1890: == NULL)
1891: {
1892: (*s_etat_processus).erreur_systeme =
1893: d_es_allocation_memoire;
1894: return;
1895: }
1896:
1897: (*((integer8 *) (*(*(*((struct_liste_chainee *)
1898: (*s_objet_adresse).objet)).suivant).donnee).objet)) =
1899: (integer8) ntohs(adresse_ipv6.sin6_port);
1900:
1901: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
1902: .suivant).suivant = NULL;
1903: }
1904: else
1905: {
1906: longueur_adresse = 0;
1907: recvfrom((*((struct_socket *)
1908: (*s_objet_argument_1).objet)).socket, tampon_lecture,
1909: position_finale, MSG_DONTWAIT,
1910: NULL, &longueur_adresse);
1911: }
1912:
1913: free(tampon_lecture);
1914:
1915: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1916: s_objet_resultat) == d_erreur)
1917: {
1918: return;
1919: }
1920: }
1921: else
1922: {
1923: /* FLOW ou UNFORMATTED */
1924: }
1925: }
1926: else
1927: {
1928: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1929: return;
1930: }
1931:
1932: liberation(s_etat_processus, s_objet_argument_1);
1933:
1934: return;
1935: }
1936:
1937: // 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