![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_p8.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_p8.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.13 bertrand 3: RPL/2 (R) version 4.1.12
1.15 ! bertrand 4: Copyright (C) 1989-2013 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'poll'
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_poll(struct_processus *s_etat_processus)
40: {
1.2 bertrand 41: int erreur;
1.9 bertrand 42: int i;
1.1 bertrand 43: int ios;
1.9 bertrand 44: int nombre_descripteurs;
1.1 bertrand 45: int timeout;
46:
47: logical1 drapeau;
48:
1.9 bertrand 49: short masque;
50:
1.1 bertrand 51: struct_liste_chainee *l_element_courant;
1.9 bertrand 52: struct_liste_chainee *l_element_courant_2;
1.1 bertrand 53:
54: struct_objet *s_objet_argument_1;
55: struct_objet *s_objet_argument_2;
1.9 bertrand 56: struct_objet *s_objet_liste;
1.1 bertrand 57: struct_objet *s_objet_resultat;
1.9 bertrand 58: struct_objet **s_objet_tmp;
1.1 bertrand 59:
1.9 bertrand 60: struct pollfd *s_poll;
1.1 bertrand 61:
62: unsigned char *registre;
63:
64: if ((*s_etat_processus).affichage_arguments == 'Y')
65: {
66: printf("\n POLL ");
67:
68: if ((*s_etat_processus).langue == 'F')
69: {
1.9 bertrand 70: printf("(attente d'un événement sur une liste de fichiers ou "
71: "de sockets)\n\n");
1.1 bertrand 72: }
73: else
74: {
1.9 bertrand 75: printf("(wait for event on files or sockets list)\n\n");
1.1 bertrand 76: }
77:
1.9 bertrand 78: printf(" 2: %s\n", d_LST);
79: printf(" 1: %s, %s\n", d_INT, d_REL);
80: printf("-> 1: %s\n\n", d_LST);
81:
1.1 bertrand 82: if ((*s_etat_processus).langue == 'F')
83: {
84: printf(" Utilisation :\n\n");
85: }
86: else
87: {
88: printf(" Usage:\n\n");
89: }
90:
1.9 bertrand 91: printf(" { { FILE_1 \"POLLIN\" \"POLLOUT\" }\n"
92: " { FILE_2 \"POLLPRI\" } } TIMEOUT POLL\n");
93: printf(" Input : POLLIN/POLLPRI/POLLOUT\n");
94: printf(" Output : POLLIN/POLLPRI/POLLOUT/POLLERR/POLLHUP/POLLNVAL"
95: "\n\n");
1.1 bertrand 96:
97: return;
98: }
99: else if ((*s_etat_processus).test_instruction == 'Y')
100: {
101: (*s_etat_processus).nombre_arguments = -1;
102: return;
103: }
104:
105: if (test_cfsf(s_etat_processus, 31) == d_vrai)
106: {
107: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
108: {
109: return;
110: }
111: }
112:
113: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
114: &s_objet_argument_1) == d_erreur)
115: {
116: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
117: return;
118: }
119:
120: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
121: &s_objet_argument_2) == d_erreur)
122: {
1.2 bertrand 123: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 124:
125: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
126: return;
127: }
128:
1.9 bertrand 129: if (((*s_objet_argument_2).type == LST) && (((*s_objet_argument_1).type ==
130: INT) || ((*s_objet_argument_1).type == REL)))
1.1 bertrand 131: {
1.9 bertrand 132: l_element_courant = (*s_objet_argument_2).objet;
133: nombre_descripteurs = 0;
1.1 bertrand 134:
1.9 bertrand 135: while(l_element_courant != NULL)
1.1 bertrand 136: {
1.9 bertrand 137: nombre_descripteurs++;
138: l_element_courant = (*l_element_courant).suivant;
1.1 bertrand 139: }
1.9 bertrand 140:
141: if ((s_poll = malloc(nombre_descripteurs * sizeof(struct pollfd)))
142: == NULL)
1.1 bertrand 143: {
1.9 bertrand 144: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
145: return;
1.1 bertrand 146: }
147:
1.9 bertrand 148: if ((s_objet_tmp = malloc(nombre_descripteurs *
149: sizeof(struct_objet *))) == NULL)
1.1 bertrand 150: {
1.9 bertrand 151: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1.1 bertrand 152: return;
153: }
154:
155: l_element_courant = (*s_objet_argument_2).objet;
1.9 bertrand 156: i = 0;
1.1 bertrand 157:
158: while(l_element_courant != NULL)
159: {
1.9 bertrand 160: if ((*(*l_element_courant).donnee).type != LST)
1.1 bertrand 161: {
162: liberation(s_etat_processus, s_objet_argument_1);
163: liberation(s_etat_processus, s_objet_argument_2);
1.9 bertrand 164: free(s_poll);
165: free(s_objet_tmp);
1.1 bertrand 166:
167: (*s_etat_processus).erreur_execution =
168: d_ex_erreur_type_argument;
169: return;
170: }
171:
1.9 bertrand 172: l_element_courant_2 = (*(*l_element_courant).donnee).objet;
173: s_poll[i].events = 0;
174: s_poll[i].revents = 0;
175: drapeau = d_faux;
176:
177: while(l_element_courant_2 != NULL)
1.1 bertrand 178: {
1.9 bertrand 179: switch((*(*l_element_courant_2).donnee).type)
180: {
181: case SCK:
182: {
183: if (drapeau == d_vrai)
184: {
185: liberation(s_etat_processus, s_objet_argument_1);
186: liberation(s_etat_processus, s_objet_argument_2);
187: free(s_poll);
188: free(s_objet_tmp);
189:
190: (*s_etat_processus).erreur_execution =
191: d_ex_argument_invalide;
192: return;
193: }
194:
195: s_poll[i].fd = (*((struct_socket *)
196: (*(*l_element_courant_2).donnee).objet)).socket;
197: s_objet_tmp[i] = (*l_element_courant_2).donnee;
198: drapeau = d_vrai;
199: break;
200: }
201:
202: case FCH:
203: {
204: if (drapeau == d_vrai)
205: {
206: liberation(s_etat_processus, s_objet_argument_1);
207: liberation(s_etat_processus, s_objet_argument_2);
208: free(s_poll);
209: free(s_objet_tmp);
210:
211: (*s_etat_processus).erreur_execution =
212: d_ex_argument_invalide;
213: return;
214: }
215:
216: s_poll[i].fd = (*((struct_fichier *)
217: (*(*l_element_courant_2).donnee).objet))
218: .descripteur;
219: s_objet_tmp[i] = (*l_element_courant_2).donnee;
220: drapeau = d_vrai;
221: break;
222: }
223:
224: case CHN:
225: {
226: if ((registre = conversion_majuscule((unsigned char *)
227: (*(*l_element_courant_2).donnee).objet))
228: == NULL)
229: {
230: (*s_etat_processus).erreur_systeme =
231: d_es_allocation_memoire;
232: return;
233: }
234:
235: if (strcmp(registre, "POLLIN") == 0)
236: {
237: s_poll[i].events |= POLLIN;
238: }
239: else if (strcmp(registre, "POLLOUT") == 0)
240: {
241: s_poll[i].events |= POLLOUT;
242: }
243: else if (strcmp(registre, "POLLERR") == 0)
244: {
245: s_poll[i].events |= POLLERR;
246: }
247: else
248: {
249: liberation(s_etat_processus, s_objet_argument_1);
250: liberation(s_etat_processus, s_objet_argument_2);
251: free(registre);
252: free(s_poll);
253: free(s_objet_tmp);
254:
255: (*s_etat_processus).erreur_execution =
256: d_ex_erreur_parametre_fichier;
257: return;
258: }
259:
260: free(registre);
261: break;
262: }
263:
264: default:
265: {
266: liberation(s_etat_processus, s_objet_argument_1);
267: liberation(s_etat_processus, s_objet_argument_2);
268: free(s_poll);
269: free(s_objet_tmp);
270:
271: (*s_etat_processus).erreur_execution =
272: d_ex_erreur_type_argument;
273: return;
274: }
275: }
276:
277: l_element_courant_2 = (*l_element_courant_2).suivant;
1.1 bertrand 278: }
279:
1.9 bertrand 280: if (drapeau == d_faux)
1.1 bertrand 281: {
282: liberation(s_etat_processus, s_objet_argument_1);
283: liberation(s_etat_processus, s_objet_argument_2);
1.9 bertrand 284: free(s_poll);
285: free(s_objet_tmp);
1.1 bertrand 286:
287: (*s_etat_processus).erreur_execution =
1.9 bertrand 288: d_ex_erreur_type_argument;
1.1 bertrand 289: return;
290: }
291:
292: l_element_courant = (*l_element_courant).suivant;
1.9 bertrand 293: i++;
1.1 bertrand 294: }
295:
296: if ((*s_objet_argument_1).type == INT)
297: {
298: timeout = (*((integer8 *) (*s_objet_argument_1).objet)) * 1000L;
299: }
1.9 bertrand 300: else
1.1 bertrand 301: {
302: timeout = (int) ((*((real8 *) (*s_objet_argument_1).objet))
303: * 1000L);
304: }
305:
306: do
307: {
308: drapeau = d_vrai;
309:
310: # ifndef SEMAPHORES_NOMMES
311: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
312: # else
313: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
314: # endif
315: {
316: (*s_etat_processus).erreur_systeme = d_es_processus;
317: return;
318: }
319:
1.9 bertrand 320: if ((ios = poll(s_poll, nombre_descripteurs, timeout)) < 0)
1.1 bertrand 321: {
322: erreur = errno;
323:
324: # ifndef SEMAPHORES_NOMMES
325: while(sem_wait(&((*s_etat_processus)
326: .semaphore_fork)) != 0)
327: # else
328: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
329: # endif
330:
331: if (erreur != EINTR)
332: {
333: liberation(s_etat_processus, s_objet_argument_1);
334: liberation(s_etat_processus, s_objet_argument_2);
1.9 bertrand 335: free(s_poll);
336: free(s_objet_tmp);
1.1 bertrand 337:
338: (*s_etat_processus).erreur_execution =
339: d_ex_erreur_acces_fichier;
340: return;
341: }
342:
343: scrutation_injection(s_etat_processus);
344:
345: if ((*s_etat_processus).var_volatile_requete_arret != 0)
346: {
347: drapeau = d_vrai;
348: }
349: else
350: {
351: drapeau = d_faux;
352: }
353: }
354: else
355: {
356: # ifndef SEMAPHORES_NOMMES
357: while(sem_wait(&((*s_etat_processus)
358: .semaphore_fork)) != 0)
359: # else
360: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
361: # endif
362: {
363: if (errno != EINTR)
364: {
365: (*s_etat_processus).erreur_systeme =
366: d_es_processus;
367: return;
368: }
369: }
370: }
371: } while(drapeau == d_faux);
372:
1.9 bertrand 373: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
1.4 bertrand 374: {
375: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
376: return;
377: }
378:
1.1 bertrand 379: if (ios > 0)
380: {
381: // Sortie sur un événement
1.9 bertrand 382:
383: masque = POLLIN | POLLPRI | POLLOUT | POLLERR | POLLHUP | POLLNVAL;
384:
385: for(i = nombre_descripteurs - 1; i >= 0; i--)
386: {
387: if ((s_poll[i].revents & masque) != 0)
388: {
389: if ((s_objet_liste = allocation(s_etat_processus, LST))
390: == NULL)
391: {
392: (*s_etat_processus).erreur_systeme =
393: d_es_allocation_memoire;
394: return;
395: }
396:
397: if ((s_poll[i].revents & POLLNVAL) != 0)
398: {
399: l_element_courant = (*s_objet_liste).objet;
400:
401: if (((*s_objet_liste).objet = allocation_maillon(
402: s_etat_processus)) == NULL)
403: {
404: (*s_etat_processus).erreur_systeme =
405: d_es_allocation_memoire;
406: return;
407: }
408:
409: if (((*((struct_liste_chainee *) (*s_objet_liste)
410: .objet)).donnee = allocation(s_etat_processus,
411: CHN)) == NULL)
412: {
413: (*s_etat_processus).erreur_systeme =
414: d_es_allocation_memoire;
415: return;
416: }
417:
418: if (((*(*((struct_liste_chainee *) (*s_objet_liste)
419: .objet)).donnee).objet = malloc(9 *
420: sizeof(unsigned char))) == NULL)
421: {
422: (*s_etat_processus).erreur_systeme =
423: d_es_allocation_memoire;
424: return;
425: }
426:
427: strcpy((unsigned char *) (*(*((struct_liste_chainee *)
428: (*s_objet_liste).objet)).donnee).objet,
429: "POLLNVAL");
430: (*((struct_liste_chainee *) (*s_objet_liste).objet))
431: .suivant = l_element_courant;
432: }
433: else if ((s_poll[i].revents & POLLHUP) != 0)
434: {
435: l_element_courant = (*s_objet_liste).objet;
436:
437: if (((*s_objet_liste).objet = allocation_maillon(
438: s_etat_processus)) == NULL)
439: {
440: (*s_etat_processus).erreur_systeme =
441: d_es_allocation_memoire;
442: return;
443: }
444:
445: if (((*((struct_liste_chainee *) (*s_objet_liste)
446: .objet)).donnee = allocation(s_etat_processus,
447: CHN)) == NULL)
448: {
449: (*s_etat_processus).erreur_systeme =
450: d_es_allocation_memoire;
451: return;
452: }
453:
454: if (((*(*((struct_liste_chainee *) (*s_objet_liste)
455: .objet)).donnee).objet = malloc(8 *
456: sizeof(unsigned char))) == NULL)
457: {
458: (*s_etat_processus).erreur_systeme =
459: d_es_allocation_memoire;
460: return;
461: }
462:
463: strcpy((unsigned char *) (*(*((struct_liste_chainee *)
464: (*s_objet_liste).objet)).donnee).objet,
465: "POLLHUP");
466: (*((struct_liste_chainee *) (*s_objet_liste).objet))
467: .suivant = l_element_courant;
468: }
469: else if ((s_poll[i].revents & POLLERR) != 0)
470: {
471: l_element_courant = (*s_objet_liste).objet;
472:
473: if (((*s_objet_liste).objet = allocation_maillon(
474: s_etat_processus)) == NULL)
475: {
476: (*s_etat_processus).erreur_systeme =
477: d_es_allocation_memoire;
478: return;
479: }
480:
481: if (((*((struct_liste_chainee *) (*s_objet_liste)
482: .objet)).donnee = allocation(s_etat_processus,
483: CHN)) == NULL)
484: {
485: (*s_etat_processus).erreur_systeme =
486: d_es_allocation_memoire;
487: return;
488: }
489:
490: if (((*(*((struct_liste_chainee *) (*s_objet_liste)
491: .objet)).donnee).objet = malloc(8 *
492: sizeof(unsigned char))) == NULL)
493: {
494: (*s_etat_processus).erreur_systeme =
495: d_es_allocation_memoire;
496: return;
497: }
498:
499: strcpy((unsigned char *) (*(*((struct_liste_chainee *)
500: (*s_objet_liste).objet)).donnee).objet,
501: "POLLERR");
502: (*((struct_liste_chainee *) (*s_objet_liste).objet))
503: .suivant = l_element_courant;
504: }
505: else if ((s_poll[i].revents & POLLOUT) != 0)
506: {
507: l_element_courant = (*s_objet_liste).objet;
508:
509: if (((*s_objet_liste).objet = allocation_maillon(
510: s_etat_processus)) == NULL)
511: {
512: (*s_etat_processus).erreur_systeme =
513: d_es_allocation_memoire;
514: return;
515: }
516:
517: if (((*((struct_liste_chainee *) (*s_objet_liste)
518: .objet)).donnee = allocation(s_etat_processus,
519: CHN)) == NULL)
520: {
521: (*s_etat_processus).erreur_systeme =
522: d_es_allocation_memoire;
523: return;
524: }
525:
526: if (((*(*((struct_liste_chainee *) (*s_objet_liste)
527: .objet)).donnee).objet = malloc(8 *
528: sizeof(unsigned char))) == NULL)
529: {
530: (*s_etat_processus).erreur_systeme =
531: d_es_allocation_memoire;
532: return;
533: }
534:
535: strcpy((unsigned char *) (*(*((struct_liste_chainee *)
536: (*s_objet_liste).objet)).donnee).objet,
537: "POLLOUT");
538: (*((struct_liste_chainee *) (*s_objet_liste).objet))
539: .suivant = l_element_courant;
540: }
541: else if ((s_poll[i].revents & POLLPRI) != 0)
542: {
543: l_element_courant = (*s_objet_liste).objet;
544:
545: if (((*s_objet_liste).objet = allocation_maillon(
546: s_etat_processus)) == NULL)
547: {
548: (*s_etat_processus).erreur_systeme =
549: d_es_allocation_memoire;
550: return;
551: }
552:
553: if (((*((struct_liste_chainee *) (*s_objet_liste)
554: .objet)).donnee = allocation(s_etat_processus,
555: CHN)) == NULL)
556: {
557: (*s_etat_processus).erreur_systeme =
558: d_es_allocation_memoire;
559: return;
560: }
561:
562: if (((*(*((struct_liste_chainee *) (*s_objet_liste)
563: .objet)).donnee).objet = malloc(8 *
564: sizeof(unsigned char))) == NULL)
565: {
566: (*s_etat_processus).erreur_systeme =
567: d_es_allocation_memoire;
568: return;
569: }
570:
571: strcpy((unsigned char *) (*(*((struct_liste_chainee *)
572: (*s_objet_liste).objet)).donnee).objet,
573: "POLLPRI");
574: (*((struct_liste_chainee *) (*s_objet_liste).objet))
575: .suivant = l_element_courant;
576: }
577: else if ((s_poll[i].revents & POLLIN) != 0)
578: {
579: l_element_courant = (*s_objet_liste).objet;
580:
581: if (((*s_objet_liste).objet = allocation_maillon(
582: s_etat_processus)) == NULL)
583: {
584: (*s_etat_processus).erreur_systeme =
585: d_es_allocation_memoire;
586: return;
587: }
588:
589: if (((*((struct_liste_chainee *) (*s_objet_liste)
590: .objet)).donnee = allocation(s_etat_processus,
591: CHN)) == NULL)
592: {
593: (*s_etat_processus).erreur_systeme =
594: d_es_allocation_memoire;
595: return;
596: }
597:
598: if (((*(*((struct_liste_chainee *) (*s_objet_liste)
599: .objet)).donnee).objet = malloc(7 *
600: sizeof(unsigned char))) == NULL)
601: {
602: (*s_etat_processus).erreur_systeme =
603: d_es_allocation_memoire;
604: return;
605: }
606:
607: strcpy((unsigned char *) (*(*((struct_liste_chainee *)
608: (*s_objet_liste).objet)).donnee).objet,
609: "POLLIN");
610: (*((struct_liste_chainee *) (*s_objet_liste).objet))
611: .suivant = l_element_courant;
612: }
613:
614: l_element_courant = (*s_objet_liste).objet;
615:
616: if (((*s_objet_liste).objet = allocation_maillon(
617: s_etat_processus)) == NULL)
618: {
619: (*s_etat_processus).erreur_systeme =
620: d_es_allocation_memoire;
621: return;
622: }
623:
624: if (((*((struct_liste_chainee *) (*s_objet_liste)
625: .objet)).donnee = copie_objet(s_etat_processus,
626: s_objet_tmp[i], 'P')) == NULL)
627: {
628: (*s_etat_processus).erreur_systeme =
629: d_es_allocation_memoire;
630: return;
631: }
632:
633: (*((struct_liste_chainee *) (*s_objet_liste).objet))
634: .suivant = l_element_courant;
635:
636: // Ajout de la liste fille au résultat.
637:
638: l_element_courant = (*s_objet_resultat).objet;
639:
640: if (((*s_objet_resultat).objet = allocation_maillon(
641: s_etat_processus)) == NULL)
642: {
643: (*s_etat_processus).erreur_systeme =
644: d_es_allocation_memoire;
645: return;
646: }
647:
648: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
649: .donnee = s_objet_liste;
650: (*((struct_liste_chainee *) (*s_objet_resultat).objet))
651: .suivant = l_element_courant;
652: }
653: }
1.1 bertrand 654: }
655: else
656: {
1.9 bertrand 657: // Sortie sur timeout : on renvoit une liste vide.
658: (*s_objet_resultat).objet = NULL;
1.1 bertrand 659: }
660:
661: liberation(s_etat_processus, s_objet_argument_1);
662: liberation(s_etat_processus, s_objet_argument_2);
1.9 bertrand 663: free(s_poll);
664: free(s_objet_tmp);
1.1 bertrand 665:
666: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
667: s_objet_resultat) == d_erreur)
668: {
669: return;
670: }
671: }
672: else
673: {
674: liberation(s_etat_processus, s_objet_argument_1);
675: liberation(s_etat_processus, s_objet_argument_2);
676:
677: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
678: return;
679: }
680:
681: return;
682: }
683:
684: // vim: ts=4