![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_w1.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_w1.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.82 bertrand 3: RPL/2 (R) version 4.1.14
1.71 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:
1.20 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'while'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_while(struct_processus *s_etat_processus)
40: {
41: (*s_etat_processus).erreur_execution = d_ex;
42:
43: if ((*s_etat_processus).affichage_arguments == 'Y')
44: {
45: printf("\n WHILE ");
46:
47: if ((*s_etat_processus).langue == 'F')
48: {
49: printf("(structure de contrôle)\n\n");
50: printf(" Utilisation :\n\n");
51: }
52: else
53: {
54: printf("(control statement)\n\n");
55: printf(" Usage:\n\n");
56: }
57:
58: printf(" WHILE\n");
59: printf(" (clause)\n");
60: printf(" REPEAT\n");
61: printf(" (expression 1)\n");
62: printf(" EXIT\n");
63: printf(" (expression 2)\n");
64: printf(" END\n\n");
65:
66: printf(" WHILE\n");
67: printf(" (clause)\n");
68: printf(" REPEAT\n");
69: printf(" (expression)\n");
70: printf(" END\n");
71:
72: return;
73: }
74: else if ((*s_etat_processus).test_instruction == 'Y')
75: {
76: (*s_etat_processus).nombre_arguments = -1;
77: return;
78: }
79:
80: empilement_pile_systeme(s_etat_processus);
81:
82: if ((*s_etat_processus).erreur_systeme != d_es)
83: {
84: return;
85: }
86:
87: (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'W';
88: (*(*s_etat_processus).l_base_pile_systeme).clause = 'W';
89:
90: if ((*s_etat_processus).mode_execution_programme == 'Y')
91: {
92: (*(*s_etat_processus).l_base_pile_systeme).adresse_retour =
93: (*s_etat_processus).position_courante;
94: }
95: else
96: {
97: if ((*s_etat_processus).expression_courante == NULL)
98: {
99: (*s_etat_processus).erreur_execution =
100: d_ex_erreur_traitement_boucle;
101: return;
102: }
103:
104: (*(*s_etat_processus).l_base_pile_systeme).pointeur_objet_retour =
105: (*s_etat_processus).expression_courante;
106: }
107:
108: return;
109: }
110:
111:
112: /*
113: ================================================================================
114: Fonction 'warranty'
115: ================================================================================
116: Entrées :
117: --------------------------------------------------------------------------------
118: Sorties :
119: --------------------------------------------------------------------------------
120: Effets de bord : néant
121: ================================================================================
122: */
123:
124: void
125: instruction_warranty(struct_processus *s_etat_processus)
126: {
1.20 bertrand 127: # include "garanties-conv.h"
1.1 bertrand 128:
129: (*s_etat_processus).erreur_execution = d_ex;
130:
131: if ((*s_etat_processus).affichage_arguments == 'Y')
132: {
133: printf("\n WARRANTY ");
134:
135: if ((*s_etat_processus).langue == 'F')
136: {
137: printf("(garantie)\n\n");
138: printf(" Aucun argument\n");
139: }
140: else
141: {
142: printf("(warranty)\n\n");
143: printf(" No argument\n");
144: }
145:
146: return;
147: }
148: else if ((*s_etat_processus).test_instruction == 'Y')
149: {
150: (*s_etat_processus).nombre_arguments = -1;
151: return;
152: }
153:
154: printf("%s\n", warranty);
155:
156: if ((*s_etat_processus).hauteur_pile_operationnelle == 0)
157: {
158: printf("\n");
159: }
160:
161: return;
162: }
163:
164:
165: /*
166: ================================================================================
167: Fonction 'wait'
168: ================================================================================
169: Entrées :
170: --------------------------------------------------------------------------------
171: Sorties :
172: --------------------------------------------------------------------------------
173: Effets de bord : néant
174: ================================================================================
175: */
176:
177: void
178: instruction_wait(struct_processus *s_etat_processus)
179: {
180: int code_retour;
181: int erreur;
182:
183: real8 attente;
184:
185: struct_objet *s_objet;
186:
187: struct timespec temporisation;
188:
189: (*s_etat_processus).erreur_execution = d_ex;
190:
191: if ((*s_etat_processus).affichage_arguments == 'Y')
192: {
193: printf("\n WAIT ");
194:
195: if ((*s_etat_processus).langue == 'F')
196: {
197: printf("(attente exprimée en secondes)\n\n");
198: }
199: else
200: {
201: printf("(wait a number of seconds)\n\n");
202: }
203:
204: printf(" 1: %s, %s\n", d_INT, d_REL);
205:
206: return;
207: }
208: else if ((*s_etat_processus).test_instruction == 'Y')
209: {
210: (*s_etat_processus).nombre_arguments = -1;
211: return;
212: }
213:
214: if (test_cfsf(s_etat_processus, 31) == d_vrai)
215: {
216: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
217: {
218: return;
219: }
220: }
221:
222: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
223: &s_objet) == d_erreur)
224: {
225: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
226: return;
227: }
228:
1.30 bertrand 229: if (((*s_objet).type == INT) || ((*s_objet).type == REL))
1.1 bertrand 230: {
231: if ((*s_objet).type == INT)
232: {
233: attente = (real8) (*((integer8 *) (*s_objet).objet));
234: }
235: else
236: {
237: attente = (*((real8 *) (*s_objet).objet));
238: }
239:
240: if (attente < 0)
241: {
242: liberation(s_etat_processus, s_objet);
243:
244: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
245: return;
246: }
247:
1.80 bertrand 248: temporisation.tv_sec = (time_t) floor((double) attente);
1.79 bertrand 249: temporisation.tv_nsec = (long) ((attente -
250: ((real8) temporisation.tv_sec)) * (integer8) 1000000000);
1.1 bertrand 251:
252: if ((*s_etat_processus).profilage == d_vrai)
253: {
254: profilage(s_etat_processus, "Sleep function (WAIT)");
255:
256: if ((*s_etat_processus).erreur_systeme != d_es)
257: {
258: return;
259: }
260: }
261:
262: do
263: {
1.51 bertrand 264: # ifndef SEMAPHORES_NOMMES
265: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
266: # else
267: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
268: # endif
1.1 bertrand 269: {
270: (*s_etat_processus).erreur_systeme = d_es_processus;
271: return;
272: }
273:
274: code_retour = nanosleep(&temporisation, &temporisation);
275: erreur = errno;
276:
1.51 bertrand 277: # ifndef SEMAPHORES_NOMMES
278: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
279: # else
280: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
281: # endif
1.1 bertrand 282: {
1.50 bertrand 283: if (errno != EINTR)
284: {
285: (*s_etat_processus).erreur_systeme = d_es_processus;
286: return;
287: }
1.1 bertrand 288: }
1.28 bertrand 289:
290: scrutation_injection(s_etat_processus);
291:
1.84 ! bertrand 292: if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
! 293: != 0)
1.83 bertrand 294: {
295: (*s_etat_processus).erreur_systeme = d_es_processus;
296: return;
297: }
298:
1.28 bertrand 299: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
300: {
301: affectation_interruptions_logicielles(s_etat_processus);
302: }
303:
1.84 ! bertrand 304: if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions)
! 305: != 0)
1.83 bertrand 306: {
307: (*s_etat_processus).erreur_systeme = d_es_processus;
308: return;
309: }
310:
1.28 bertrand 311: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
312: {
313: traitement_interruptions_logicielles(s_etat_processus);
314: }
1.1 bertrand 315: } while(((code_retour == -1) && (erreur == EINTR))
316: && ((*s_etat_processus).var_volatile_requete_arret == 0));
317:
318: if ((*s_etat_processus).profilage == d_vrai)
319: {
320: profilage(s_etat_processus, NULL);
321: }
322: }
323: else
324: {
325: liberation(s_etat_processus, s_objet);
326:
327: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
328: return;
329: }
330:
331: liberation(s_etat_processus, s_objet);
332:
333: return;
334: }
335:
336:
337: /*
338: ================================================================================
339: Fonction 'wireframe' (passe en mode d'affichage échantillonné)
340: ================================================================================
341: Entrées : structure processus
342: --------------------------------------------------------------------------------
343: Sorties :
344: --------------------------------------------------------------------------------
345: Effets de bord : néant
346: ================================================================================
347: */
348:
349: void
350: instruction_wireframe(struct_processus *s_etat_processus)
351: {
352: (*s_etat_processus).erreur_execution = d_ex;
353:
354: if ((*s_etat_processus).affichage_arguments == 'Y')
355: {
356: printf("\n WIREFRAME ");
357:
358: if ((*s_etat_processus).langue == 'F')
359: {
360: printf("(graphique tridimensionnel grillagé)\n\n");
361: printf(" Aucun argument\n");
362: }
363: else
364: {
365: printf("(wireframe 3D graph)\n\n");
366: printf(" No argument\n");
367: }
368:
369: return;
370: }
371: else if ((*s_etat_processus).test_instruction == 'Y')
372: {
373: (*s_etat_processus).nombre_arguments = -1;
374: return;
375: }
376:
377: strcpy((*s_etat_processus).type_trace_eq, "GRILLE 3D");
378:
379: return;
380: }
381:
382:
383: /*
384: ================================================================================
385: Fonction 'write'
386: ================================================================================
387: Entrées : structure processus
388: --------------------------------------------------------------------------------
389: Sorties :
390: --------------------------------------------------------------------------------
391: Effets de bord : néant
392: ================================================================================
393: */
394:
395: void
396: instruction_write(struct_processus *s_etat_processus)
397: {
1.6 bertrand 398: const char *queue;
399:
1.1 bertrand 400: int adresse[16];
401: int port;
1.70 bertrand 402: int sqlite_status;
1.1 bertrand 403:
1.8 bertrand 404: integer8 clef;
405: integer8 compteur;
406: integer8 id;
1.79 bertrand 407: integer8 longueur;
1.78 bertrand 408: integer8 longueur_effective;
1.8 bertrand 409: integer8 ordre;
1.79 bertrand 410: integer8 recursivite;
1.8 bertrand 411:
1.64 bertrand 412: logical1 format_degenere;
1.8 bertrand 413: logical1 mise_a_jour;
414:
1.1 bertrand 415:
1.6 bertrand 416: sqlite3_stmt *ppStmt;
417:
1.1 bertrand 418: ssize_t ios;
419:
1.5 bertrand 420: struct_descripteur_fichier *descripteur;
421:
1.8 bertrand 422: struct_liste_chainee *l_element_courant;
423: struct_liste_chainee *l_element_courant_format;
424:
425: struct_objet *s_format;
426: struct_objet *s_element;
1.6 bertrand 427: struct_objet *s_objet_argument_1;
1.1 bertrand 428: struct_objet *s_objet_argument_2;
1.6 bertrand 429: struct_objet *s_objet_argument_3;
1.1 bertrand 430:
431: struct sigaction action;
432: struct sigaction registre;
433:
434: struct sockaddr_in adresse_ipv4;
1.20 bertrand 435: # ifdef IPV6
1.1 bertrand 436: struct sockaddr_in6 adresse_ipv6;
1.20 bertrand 437: # endif
1.1 bertrand 438: struct sockaddr_un adresse_unix;
439:
440: struct flock lock;
441:
1.70 bertrand 442: struct timespec attente;
443:
1.1 bertrand 444: uint32_t calcul_adresse;
445:
446: unsigned char *chaine;
1.5 bertrand 447: unsigned char *chaine_utf8;
1.8 bertrand 448: unsigned char *clef_utf8;
1.6 bertrand 449: unsigned char *commande;
1.64 bertrand 450: unsigned char *format_chaine;
1.1 bertrand 451:
452: unsigned long i;
453:
454: (*s_etat_processus).erreur_execution = d_ex;
455:
456: if ((*s_etat_processus).affichage_arguments == 'Y')
457: {
458: printf("\n WRITE ");
459:
460: if ((*s_etat_processus).langue == 'F')
461: {
462: printf("(écriture d'un enregistrement d'un fichier)\n\n");
463: }
464: else
465: {
466: printf("(write a record of a file)\n\n");
467: }
468:
469: printf(" 2: %s\n", d_LST);
1.6 bertrand 470: printf(" 1: %s, %s\n\n", d_FCH, d_SCK);
1.1 bertrand 471:
1.6 bertrand 472: printf(" 3: %s\n", d_LST);
1.8 bertrand 473: printf(" 2: %s\n", d_INT);
1.6 bertrand 474: printf(" 1: %s\n", d_FCH);
1.1 bertrand 475: return;
476: }
477: else if ((*s_etat_processus).test_instruction == 'Y')
478: {
479: (*s_etat_processus).nombre_arguments = -1;
480: return;
481: }
482:
483: if (test_cfsf(s_etat_processus, 31) == d_vrai)
484: {
1.6 bertrand 485: if ((*s_etat_processus).l_base_pile == NULL)
1.1 bertrand 486: {
1.6 bertrand 487: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1.1 bertrand 488: return;
489: }
1.6 bertrand 490:
491: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
492: {
493: if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
1.9 bertrand 494: .donnee).objet)).acces == 'D')
1.6 bertrand 495: {
1.9 bertrand 496: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
1.6 bertrand 497: {
498: return;
499: }
500: }
501: else
502: {
1.9 bertrand 503: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1.6 bertrand 504: {
505: return;
506: }
507: }
508: }
509: else
510: {
511: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
512: {
513: return;
514: }
515: }
1.1 bertrand 516: }
517:
518: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
519: &s_objet_argument_1) == d_erreur)
520: {
521: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
522: return;
523: }
524:
525: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
526: &s_objet_argument_2) == d_erreur)
527: {
528: liberation(s_etat_processus, s_objet_argument_1);
529:
530: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
531: return;
532: }
533:
1.6 bertrand 534: if ((*s_objet_argument_1).type == FCH)
1.1 bertrand 535: {
1.5 bertrand 536: if ((descripteur = descripteur_fichier(s_etat_processus,
537: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
538: {
539: return;
540: }
541:
1.1 bertrand 542: /*
543: * Vérification des verrous
544: */
545:
546: lock.l_type = F_WRLCK;
547: lock.l_whence = SEEK_SET;
548: lock.l_start = 0;
549: lock.l_len = 0;
550: lock.l_pid = getpid();
551: recursivite = 0;
552:
1.5 bertrand 553: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
554: == -1)
1.1 bertrand 555: {
556: liberation(s_etat_processus, s_objet_argument_2);
557: liberation(s_etat_processus, s_objet_argument_1);
558:
559: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
560: return;
561: }
562:
563: if (lock.l_type != F_UNLCK)
564: {
565: liberation(s_etat_processus, s_objet_argument_2);
566: liberation(s_etat_processus, s_objet_argument_1);
567:
568: (*s_etat_processus).erreur_execution =
569: d_ex_fichier_verrouille;
570: return;
571: }
572:
573: /*
574: * Vérification de l'autorisation d'écriture
575: */
576:
577: if ((*((struct_fichier *) (*s_objet_argument_1).objet))
578: .protection == 'R')
579: {
580: liberation(s_etat_processus, s_objet_argument_2);
581: liberation(s_etat_processus, s_objet_argument_1);
582:
583: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
584: return;
585: }
586:
587: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
588: {
589: /*
590: * Fichiers formatés
591: */
592:
1.6 bertrand 593: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
594: == 'S')
1.1 bertrand 595: {
1.6 bertrand 596: if ((*s_objet_argument_2).type != LST)
597: {
598: liberation(s_etat_processus, s_objet_argument_2);
599: liberation(s_etat_processus, s_objet_argument_1);
600:
601: (*s_etat_processus).erreur_execution =
602: d_ex_erreur_type_argument;
603: return;
604: }
605:
606: if ((chaine = formateur_fichier(s_etat_processus,
607: s_objet_argument_2, (*((struct_fichier *)
608: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
1.75 bertrand 609: &longueur_effective, &recursivite, d_vrai)) == NULL)
1.6 bertrand 610: {
611: liberation(s_etat_processus, s_objet_argument_2);
612: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 613:
1.6 bertrand 614: return;
615: }
1.1 bertrand 616:
1.5 bertrand 617: BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
618:
619: if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
620: != 0)
1.1 bertrand 621: {
622: liberation(s_etat_processus, s_objet_argument_2);
623: liberation(s_etat_processus, s_objet_argument_1);
624:
625: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
626: return;
627: }
628:
1.5 bertrand 629: if ((chaine_utf8 = transliteration(s_etat_processus,
630: chaine, d_locale, "UTF-8")) == NULL)
631: {
1.6 bertrand 632: free(chaine);
633:
1.5 bertrand 634: liberation(s_etat_processus, s_objet_argument_2);
635: liberation(s_etat_processus, s_objet_argument_1);
636:
637: return;
638: }
639:
1.6 bertrand 640: free(chaine);
641:
1.7 bertrand 642: if (fprintf((*descripteur).descripteur_c, "%s\n", chaine_utf8)
643: < 0)
1.1 bertrand 644: {
1.5 bertrand 645: free(chaine_utf8);
646:
1.1 bertrand 647: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
648: return;
649: }
1.5 bertrand 650:
651: free(chaine_utf8);
1.1 bertrand 652: }
653: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
654: == 'D')
655: {
1.6 bertrand 656: BUG(((*descripteur).type != 'S'), uprintf("Bad filetype !\n"));
657:
658: if ((*s_objet_argument_2).type != INT)
659: {
660: liberation(s_etat_processus, s_objet_argument_2);
661: liberation(s_etat_processus, s_objet_argument_1);
662:
663: (*s_etat_processus).erreur_execution =
664: d_ex_erreur_type_argument;
665: return;
666: }
667:
668: if (depilement(s_etat_processus, &((*s_etat_processus)
669: .l_base_pile), &s_objet_argument_3) == d_erreur)
670: {
671: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
672: return;
673: }
674:
675: if ((*s_objet_argument_3).type != LST)
676: {
677: liberation(s_etat_processus, s_objet_argument_3);
678: liberation(s_etat_processus, s_objet_argument_2);
679: liberation(s_etat_processus, s_objet_argument_1);
680:
681: (*s_etat_processus).erreur_execution =
682: d_ex_erreur_type_argument;
683: return;
684: }
685:
1.8 bertrand 686: // Modification ou création d'un nouvel enregistrement
687:
688: if ((chaine = formateur_fichier(s_etat_processus,
689: s_objet_argument_3, (*((struct_fichier *)
690: (*s_objet_argument_1).objet)).format, 0, 0, ' ',
1.75 bertrand 691: 'F', &longueur_effective, &recursivite, d_vrai))
692: == NULL)
1.8 bertrand 693: {
694: liberation(s_etat_processus, s_objet_argument_3);
695: liberation(s_etat_processus, s_objet_argument_2);
696: liberation(s_etat_processus, s_objet_argument_1);
697:
698: return;
699: }
700:
701: if ((chaine_utf8 = transliteration(s_etat_processus,
702: chaine, d_locale, "UTF-8")) == NULL)
703: {
704: free(chaine);
705:
706: liberation(s_etat_processus, s_objet_argument_3);
707: liberation(s_etat_processus, s_objet_argument_2);
708: liberation(s_etat_processus, s_objet_argument_1);
709:
710: return;
711: }
712:
713: free(chaine);
714:
715: if (alsprintf(&commande, "insert or replace into data "
716: "(id, data) values (%lld, '%s')", (*((integer8 *)
717: (*s_objet_argument_2).objet)), chaine_utf8) < 0)
718: {
1.9 bertrand 719: (*s_etat_processus).erreur_systeme =
720: d_es_allocation_memoire;
1.8 bertrand 721: return;
722: }
723:
724: free(chaine_utf8);
725:
726: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1.79 bertrand 727: commande, (int) strlen(commande), &ppStmt, &queue)
1.8 bertrand 728: != SQLITE_OK)
729: {
730: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
731: return;
732: }
733:
734: if (sqlite3_step(ppStmt) != SQLITE_DONE)
735: {
736: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
737: return;
738: }
739:
740: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
741: {
742: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
743: return;
744: }
745:
746: liberation(s_etat_processus, s_objet_argument_3);
747: free(commande);
748: }
749: else // Fichiers indexés
750: {
751: BUG(((*descripteur).type != 'S'), uprintf("Bad filetype !\n"));
752:
753: if ((*s_objet_argument_2).type != LST)
754: {
755: liberation(s_etat_processus, s_objet_argument_2);
756: liberation(s_etat_processus, s_objet_argument_1);
757:
758: (*s_etat_processus).erreur_execution =
759: d_ex_erreur_type_argument;
760: return;
761: }
762:
1.9 bertrand 763: // Récupération de la position de la clef
1.8 bertrand 764:
765: if (alsprintf(&commande, "select key from control "
766: "where id = 1") < 0)
767: {
1.9 bertrand 768: (*s_etat_processus).erreur_systeme =
769: d_es_allocation_memoire;
1.8 bertrand 770: return;
771: }
772:
773: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1.79 bertrand 774: commande, (int) strlen(commande), &ppStmt, &queue)
1.8 bertrand 775: != SQLITE_OK)
776: {
1.9 bertrand 777: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 778: return;
779: }
780:
1.70 bertrand 781: attente.tv_sec = 0;
782: attente.tv_nsec = GRANULARITE_us * 1000;
783:
784: do
1.8 bertrand 785: {
1.70 bertrand 786: sqlite_status = sqlite3_step(ppStmt);
787:
788: if (sqlite_status == SQLITE_ROW)
789: {
790: break;
791: }
792: else if ((sqlite_status == SQLITE_BUSY) ||
793: (sqlite_status == SQLITE_LOCKED))
794: {
795: nanosleep(&attente, NULL);
796: INCR_GRANULARITE(attente.tv_nsec);
797: }
798: else
799: {
800: (*s_etat_processus).erreur_systeme =
801: d_es_erreur_fichier;
802: return;
803: }
804: } while(sqlite_status != SQLITE_ROW);
1.8 bertrand 805:
806: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
807: {
1.9 bertrand 808: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 809: return;
810: }
811:
812: clef = sqlite3_column_int64(ppStmt, 0);
813:
814: if (sqlite3_step(ppStmt) != SQLITE_DONE)
815: {
1.9 bertrand 816: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 817: return;
818: }
819:
820: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
821: {
1.9 bertrand 822: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 823: return;
824: }
825:
826: free(commande);
827:
828: l_element_courant = (struct_liste_chainee *)
829: (*s_objet_argument_2).objet;
830: l_element_courant_format = (struct_liste_chainee *)
831: (*(*((struct_fichier *) (*s_objet_argument_1).objet))
832: .format).objet;
833: compteur = 1;
834:
835: while((l_element_courant != NULL) &&
836: (l_element_courant_format != NULL))
837: {
838: if (compteur == clef)
839: {
840: break;
841: }
842:
843: l_element_courant = (*l_element_courant).suivant;
844: l_element_courant_format = (*l_element_courant_format)
845: .suivant;
846: compteur++;
847: }
848:
849: if ((l_element_courant == NULL) ||
850: (l_element_courant_format == NULL))
851: {
852: (*s_etat_processus).erreur_execution =
853: d_ex_clef_inexistante;
854:
855: liberation(s_etat_processus, s_objet_argument_2);
856: liberation(s_etat_processus, s_objet_argument_1);
857:
858: return;
859: }
860:
861: if ((s_element = allocation(s_etat_processus, LST)) == NULL)
862: {
863: (*s_etat_processus).erreur_systeme =
864: d_es_allocation_memoire;
865: return;
866: }
867:
868: if (((*s_element).objet = allocation_maillon(s_etat_processus))
869: == NULL)
870: {
871: (*s_etat_processus).erreur_systeme =
872: d_es_allocation_memoire;
873: return;
874: }
875:
876: (*((struct_liste_chainee *) (*s_element).objet)).suivant = NULL;
877:
878: if (((*((struct_liste_chainee *) (*s_element).objet))
879: .donnee = copie_objet(s_etat_processus,
880: (*l_element_courant).donnee, 'N')) == NULL)
881: {
882: (*s_etat_processus).erreur_systeme =
883: d_es_allocation_memoire;
884: return;
885: }
886:
887: if ((s_format = allocation(s_etat_processus, LST)) == NULL)
888: {
889: (*s_etat_processus).erreur_systeme =
890: d_es_allocation_memoire;
891: return;
892: }
893:
894: if (((*s_format).objet = allocation_maillon(s_etat_processus))
895: == NULL)
896: {
897: (*s_etat_processus).erreur_systeme =
898: d_es_allocation_memoire;
899: return;
900: }
901:
902: (*((struct_liste_chainee *) (*s_format).objet)).suivant = NULL;
903:
904: if (((*((struct_liste_chainee *) (*s_format).objet))
905: .donnee = copie_objet(s_etat_processus,
906: (*l_element_courant_format).donnee, 'N')) == NULL)
907: {
908: (*s_etat_processus).erreur_systeme =
909: d_es_allocation_memoire;
910: return;
911: }
912:
913: if ((chaine = formateur_fichier(s_etat_processus,
914: s_element, s_format, 0, 0, ' ',
1.75 bertrand 915: 'F', &longueur_effective, &recursivite, d_vrai))
916: == NULL)
1.8 bertrand 917: {
918: liberation(s_etat_processus, s_element);
919: liberation(s_etat_processus, s_format);
920: liberation(s_etat_processus, s_objet_argument_2);
921: liberation(s_etat_processus, s_objet_argument_1);
922:
923: return;
924: }
925:
926: liberation(s_etat_processus, s_element);
927: liberation(s_etat_processus, s_format);
928:
929: if ((clef_utf8 = transliteration(s_etat_processus,
930: chaine, d_locale, "UTF-8")) == NULL)
931: {
932: liberation(s_etat_processus, s_objet_argument_2);
933: liberation(s_etat_processus, s_objet_argument_1);
934:
935: return;
936: }
937:
938: free(chaine);
939:
940: // Récupération de l'identifiant de la clef
941:
942: if (alsprintf(&commande, "select id from key where key = "
943: "'%s'", clef_utf8) < 0)
944: {
1.9 bertrand 945: (*s_etat_processus).erreur_systeme =
946: d_es_allocation_memoire;
1.8 bertrand 947: return;
948: }
949:
950: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1.79 bertrand 951: commande, (int) strlen(commande), &ppStmt, &queue)
1.8 bertrand 952: != SQLITE_OK)
953: {
1.9 bertrand 954: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 955: return;
956: }
957:
1.70 bertrand 958: attente.tv_sec = 0;
959: attente.tv_nsec = GRANULARITE_us * 1000;
960:
961: do
1.8 bertrand 962: {
1.70 bertrand 963: switch(sqlite_status = sqlite3_step(ppStmt))
1.8 bertrand 964: {
1.70 bertrand 965: case SQLITE_ROW:
966: {
967: // Une clef existe.
968:
969: mise_a_jour = d_vrai;
970: break;
971: }
1.8 bertrand 972:
1.70 bertrand 973: case SQLITE_DONE:
974: {
975: // Aucune clef n'existe.
976:
977: mise_a_jour = d_faux;
1.8 bertrand 978:
1.70 bertrand 979: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
980: {
981: (*s_etat_processus).erreur_systeme =
982: d_es_erreur_fichier;
983: return;
984: }
1.8 bertrand 985:
1.70 bertrand 986: free(commande);
1.8 bertrand 987:
1.70 bertrand 988: if (alsprintf(&commande, "insert into key "
989: "(key) values ('%s')", clef_utf8) < 0)
990: {
991: (*s_etat_processus).erreur_systeme =
992: d_es_allocation_memoire;
993: return;
994: }
1.8 bertrand 995:
1.70 bertrand 996: if (sqlite3_prepare_v2((*descripteur)
1.79 bertrand 997: .descripteur_sqlite, commande,
998: (int) strlen(commande), &ppStmt, &queue)
1.70 bertrand 999: != SQLITE_OK)
1000: {
1001: (*s_etat_processus).erreur_systeme =
1002: d_es_erreur_fichier;
1003: return;
1004: }
1.8 bertrand 1005:
1.70 bertrand 1006: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1007: {
1008: (*s_etat_processus).erreur_systeme =
1009: d_es_erreur_fichier;
1010: return;
1011: }
1.8 bertrand 1012:
1.70 bertrand 1013: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1014: {
1015: (*s_etat_processus).erreur_systeme =
1016: d_es_erreur_fichier;
1017: return;
1018: }
1.8 bertrand 1019:
1.70 bertrand 1020: free(commande);
1.8 bertrand 1021:
1.70 bertrand 1022: if (alsprintf(&commande, "select id from key "
1023: "where key = '%s'", clef_utf8) < 0)
1024: {
1025: (*s_etat_processus).erreur_systeme =
1026: d_es_allocation_memoire;
1027: return;
1028: }
1.8 bertrand 1029:
1.70 bertrand 1030: if (sqlite3_prepare_v2((*descripteur)
1.79 bertrand 1031: .descripteur_sqlite, commande,
1032: (int) strlen(commande), &ppStmt, &queue)
1.70 bertrand 1033: != SQLITE_OK)
1034: {
1035: (*s_etat_processus).erreur_systeme =
1036: d_es_erreur_fichier;
1037: return;
1038: }
1.8 bertrand 1039:
1.70 bertrand 1040: break;
1.8 bertrand 1041: }
1042:
1.70 bertrand 1043: case SQLITE_BUSY:
1044: case SQLITE_LOCKED:
1.8 bertrand 1045: {
1.70 bertrand 1046: nanosleep(&attente, NULL);
1047: INCR_GRANULARITE(attente.tv_nsec);
1048: break;
1.8 bertrand 1049: }
1050:
1.70 bertrand 1051: default:
1.8 bertrand 1052: {
1053: (*s_etat_processus).erreur_systeme =
1054: d_es_erreur_fichier;
1055: return;
1056: }
1057: }
1.70 bertrand 1058: } while(sqlite_status != SQLITE_ROW);
1.8 bertrand 1059:
1060: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
1061: {
1.9 bertrand 1062: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 1063: return;
1064: }
1065:
1066: id = sqlite3_column_int64(ppStmt, 0);
1067:
1068: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1.6 bertrand 1069: {
1.9 bertrand 1070: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 1071: return;
1072: }
1.6 bertrand 1073:
1.8 bertrand 1074: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1075: {
1.9 bertrand 1076: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 1077: return;
1078: }
1079:
1080: free(commande);
1081:
1082: // Modification de la clef
1083:
1084: if (mise_a_jour == d_vrai)
1085: {
1086: if (alsprintf(&commande, "update key set key = '%s' where "
1087: "id = %lld", clef_utf8, id) < 0)
1.6 bertrand 1088: {
1.9 bertrand 1089: (*s_etat_processus).erreur_systeme =
1090: d_es_allocation_memoire;
1.6 bertrand 1091: return;
1092: }
1.8 bertrand 1093:
1094: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1.79 bertrand 1095: commande, (int) strlen(commande), &ppStmt, &queue)
1.8 bertrand 1096: != SQLITE_OK)
1097: {
1098: (*s_etat_processus).erreur_systeme =
1099: d_es_erreur_fichier;
1100: return;
1101: }
1102:
1103: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1104: {
1105: (*s_etat_processus).erreur_systeme =
1106: d_es_erreur_fichier;
1107: return;
1108: }
1109:
1110: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1111: {
1112: (*s_etat_processus).erreur_systeme =
1113: d_es_erreur_fichier;
1114: return;
1115: }
1116:
1117: free(commande);
1.6 bertrand 1118: }
1.8 bertrand 1119:
1120: // Effacement de l'enregistrement existant
1121:
1122: if (alsprintf(&commande, "delete from data where "
1123: "key_id = %lld", id) < 0)
1124: {
1.9 bertrand 1125: (*s_etat_processus).erreur_systeme =
1126: d_es_allocation_memoire;
1.8 bertrand 1127: return;
1128: }
1129:
1130: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1.79 bertrand 1131: commande, (int) strlen(commande), &ppStmt, &queue)
1.8 bertrand 1132: != SQLITE_OK)
1133: {
1.9 bertrand 1134: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 1135: return;
1136: }
1137:
1138: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1139: {
1.9 bertrand 1140: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 1141: return;
1142: }
1143:
1144: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1145: {
1.9 bertrand 1146: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.8 bertrand 1147: return;
1148: }
1149:
1150: free(commande);
1151:
1152: // Modification ou création d'un nouvel enregistrement
1153:
1154: l_element_courant = (struct_liste_chainee *)
1155: (*s_objet_argument_2).objet;
1156: l_element_courant_format = (struct_liste_chainee *)
1157: (*(*((struct_fichier *) (*s_objet_argument_1).objet))
1158: .format).objet;
1159: compteur = 1;
1160: ordre = 1;
1161:
1162: while((l_element_courant != NULL) &&
1163: (l_element_courant_format != NULL))
1.6 bertrand 1164: {
1.8 bertrand 1165: if (compteur == clef)
1166: {
1167: l_element_courant = (*l_element_courant).suivant;
1168: l_element_courant_format = (*l_element_courant_format)
1169: .suivant;
1170: compteur++;
1171: continue;
1172: }
1173:
1174: if ((s_element = allocation(s_etat_processus, LST)) == NULL)
1175: {
1176: (*s_etat_processus).erreur_systeme =
1177: d_es_allocation_memoire;
1178: return;
1179: }
1180:
1181: if (((*s_element).objet =
1182: allocation_maillon(s_etat_processus)) == NULL)
1183: {
1184: (*s_etat_processus).erreur_systeme =
1185: d_es_allocation_memoire;
1186: return;
1187: }
1188:
1189: (*((struct_liste_chainee *) (*s_element).objet)).suivant
1190: = NULL;
1191:
1192: if ((s_format = allocation(s_etat_processus, LST)) == NULL)
1193: {
1194: (*s_etat_processus).erreur_systeme =
1195: d_es_allocation_memoire;
1196: return;
1197: }
1198:
1199: if (((*s_format).objet =
1200: allocation_maillon(s_etat_processus)) == NULL)
1201: {
1202: (*s_etat_processus).erreur_systeme =
1203: d_es_allocation_memoire;
1204: return;
1205: }
1206:
1207: (*((struct_liste_chainee *) (*s_format).objet)).suivant
1208: = NULL;
1209:
1210: if (((*((struct_liste_chainee *) (*s_element).objet))
1211: .donnee = copie_objet(s_etat_processus,
1212: (*l_element_courant).donnee, 'N')) == NULL)
1213: {
1214: (*s_etat_processus).erreur_systeme =
1215: d_es_allocation_memoire;
1216: return;
1217: }
1218:
1219: if (((*((struct_liste_chainee *) (*s_format).objet))
1220: .donnee = copie_objet(s_etat_processus,
1221: (*l_element_courant_format).donnee, 'N')) == NULL)
1222: {
1223: (*s_etat_processus).erreur_systeme =
1224: d_es_allocation_memoire;
1225: return;
1226: }
1.6 bertrand 1227:
1228: if ((chaine = formateur_fichier(s_etat_processus,
1.8 bertrand 1229: s_element, s_format, 0, 0, ' ',
1.75 bertrand 1230: 'F', &longueur_effective, &recursivite, d_vrai))
1231: == NULL)
1.6 bertrand 1232: {
1.8 bertrand 1233: free(clef_utf8);
1.9 bertrand 1234:
1.8 bertrand 1235: liberation(s_etat_processus, s_element);
1236: liberation(s_etat_processus, s_format);
1.6 bertrand 1237: liberation(s_etat_processus, s_objet_argument_2);
1238: liberation(s_etat_processus, s_objet_argument_1);
1239:
1240: return;
1241: }
1242:
1243: if ((chaine_utf8 = transliteration(s_etat_processus,
1244: chaine, d_locale, "UTF-8")) == NULL)
1245: {
1.8 bertrand 1246: free(clef_utf8);
1.6 bertrand 1247: free(chaine);
1248:
1249: liberation(s_etat_processus, s_objet_argument_2);
1250: liberation(s_etat_processus, s_objet_argument_1);
1251:
1252: return;
1253: }
1254:
1255: free(chaine);
1256:
1.8 bertrand 1257: if (alsprintf(&commande, "insert into data "
1258: "(data, key_id, sequence) values "
1259: "('%s', %lld, %lld)", chaine_utf8, id, ordre) < 0)
1.6 bertrand 1260: {
1.9 bertrand 1261: (*s_etat_processus).erreur_systeme =
1262: d_es_allocation_memoire;
1.6 bertrand 1263: return;
1264: }
1265:
1.8 bertrand 1266: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
1.79 bertrand 1267: commande, (int) strlen(commande), &ppStmt, &queue)
1.8 bertrand 1268: != SQLITE_OK)
1269: {
1270: (*s_etat_processus).erreur_systeme =
1271: d_es_erreur_fichier;
1272: return;
1273: }
1274:
1275: if (sqlite3_step(ppStmt) != SQLITE_DONE)
1276: {
1277: (*s_etat_processus).erreur_systeme =
1278: d_es_erreur_fichier;
1279: return;
1280: }
1281:
1282: if (sqlite3_finalize(ppStmt) != SQLITE_OK)
1283: {
1284: (*s_etat_processus).erreur_systeme =
1285: d_es_erreur_fichier;
1286: return;
1287: }
1288:
1289: free(commande);
1.6 bertrand 1290: free(chaine_utf8);
1.8 bertrand 1291:
1292: liberation(s_etat_processus, s_element);
1293: liberation(s_etat_processus, s_format);
1294:
1295: l_element_courant = (*l_element_courant).suivant;
1296: l_element_courant_format = (*l_element_courant_format)
1297: .suivant;
1298:
1299: compteur++;
1300: ordre++;
1.6 bertrand 1301: }
1302:
1.8 bertrand 1303: free(clef_utf8);
1.6 bertrand 1304:
1.8 bertrand 1305: if ((l_element_courant != NULL) ||
1306: (l_element_courant_format != NULL))
1.6 bertrand 1307: {
1.8 bertrand 1308: liberation(s_etat_processus, s_objet_argument_1);
1309: liberation(s_etat_processus, s_objet_argument_2);
1.6 bertrand 1310:
1.8 bertrand 1311: (*s_etat_processus).erreur_execution =
1312: d_ex_erreur_format_fichier;
1.6 bertrand 1313: return;
1314: }
1.1 bertrand 1315: }
1316: }
1317: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
1318: == 'Y')
1319: {
1320: /*
1321: * Fichiers non formatés
1322: */
1323:
1.75 bertrand 1324: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1325: == 'S')
1.1 bertrand 1326: {
1.76 bertrand 1327: if ((*s_objet_argument_2).type != LST)
1328: {
1329: liberation(s_etat_processus, s_objet_argument_2);
1330: liberation(s_etat_processus, s_objet_argument_1);
1331:
1332: (*s_etat_processus).erreur_execution =
1333: d_ex_erreur_type_argument;
1334: return;
1335: }
1336:
1.75 bertrand 1337: if ((chaine = formateur_fichier(s_etat_processus,
1338: s_objet_argument_2, (*((struct_fichier *)
1339: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
1340: &longueur_effective, &recursivite, d_vrai)) == NULL)
1341: {
1342: liberation(s_etat_processus, s_objet_argument_2);
1343: liberation(s_etat_processus, s_objet_argument_1);
1.1 bertrand 1344:
1.75 bertrand 1345: return;
1346: }
1.1 bertrand 1347:
1.5 bertrand 1348: BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
1349:
1350: if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
1351: != 0)
1.1 bertrand 1352: {
1353: liberation(s_etat_processus, s_objet_argument_2);
1354: liberation(s_etat_processus, s_objet_argument_1);
1355:
1356: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1357: return;
1358: }
1359:
1.79 bertrand 1360: if (fwrite(chaine, sizeof(unsigned char),
1361: (size_t) longueur_effective,
1.5 bertrand 1362: (*descripteur).descripteur_c) !=
1363: (size_t) longueur_effective)
1.1 bertrand 1364: {
1365: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1366: return;
1367: }
1368: }
1369: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1370: == 'D')
1371: {
1.76 bertrand 1372: if ((*s_objet_argument_2).type != INT)
1373: {
1374: liberation(s_etat_processus, s_objet_argument_2);
1375: liberation(s_etat_processus, s_objet_argument_1);
1376:
1377: (*s_etat_processus).erreur_execution =
1378: d_ex_erreur_type_argument;
1379: return;
1380: }
1381:
1382: if (depilement(s_etat_processus, &((*s_etat_processus)
1383: .l_base_pile), &s_objet_argument_3) == d_erreur)
1384: {
1385: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1386: return;
1387: }
1388:
1389: if ((*s_objet_argument_3).type != LST)
1390: {
1391: liberation(s_etat_processus, s_objet_argument_3);
1392: liberation(s_etat_processus, s_objet_argument_2);
1393: liberation(s_etat_processus, s_objet_argument_1);
1394:
1395: (*s_etat_processus).erreur_execution =
1396: d_ex_erreur_type_argument;
1397: return;
1398: }
1399:
1.75 bertrand 1400: if ((chaine = formateur_fichier(s_etat_processus,
1401: s_objet_argument_2, (*((struct_fichier *)
1402: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
1403: &longueur_effective, &recursivite, d_faux)) == NULL)
1404: {
1405: liberation(s_etat_processus, s_objet_argument_2);
1406: liberation(s_etat_processus, s_objet_argument_1);
1407:
1408: return;
1409: }
1.1 bertrand 1410: }
1.75 bertrand 1411: else // Fichiers indexés
1.1 bertrand 1412: {
1.76 bertrand 1413: if ((*s_objet_argument_2).type != LST)
1414: {
1415: liberation(s_etat_processus, s_objet_argument_2);
1416: liberation(s_etat_processus, s_objet_argument_1);
1417:
1418: (*s_etat_processus).erreur_execution =
1419: d_ex_erreur_type_argument;
1420: return;
1421: }
1422:
1.75 bertrand 1423: if ((chaine = formateur_fichier(s_etat_processus,
1424: s_objet_argument_2, (*((struct_fichier *)
1425: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
1426: &longueur_effective, &recursivite, d_faux)) == NULL)
1427: {
1428: liberation(s_etat_processus, s_objet_argument_2);
1429: liberation(s_etat_processus, s_objet_argument_1);
1430:
1431: return;
1432: }
1.1 bertrand 1433: }
1434:
1435: free(chaine);
1436: }
1437: else
1438: {
1439: /*
1440: * Fichiers de type FLOW
1441: */
1.33 bertrand 1442:
1443: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
1444: == 'S')
1445: {
1446: BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
1447:
1.56 bertrand 1448: if ((*s_objet_argument_2).type != LST)
1449: {
1450: liberation(s_etat_processus, s_objet_argument_2);
1451: liberation(s_etat_processus, s_objet_argument_1);
1452:
1453: (*s_etat_processus).erreur_execution =
1454: d_ex_erreur_type_argument;
1455: return;
1456: }
1457:
1458: if ((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
1459: .donnee == NULL)
1460: {
1461: liberation(s_etat_processus, s_objet_argument_2);
1462: liberation(s_etat_processus, s_objet_argument_1);
1463:
1464: (*s_etat_processus).erreur_execution =
1465: d_ex_erreur_type_argument;
1466: return;
1467: }
1468:
1.64 bertrand 1469: l_element_courant = (*s_objet_argument_2).objet;
1470: l_element_courant_format = (struct_liste_chainee *)
1471: (*(*((struct_fichier *) (*s_objet_argument_1).objet))
1472: .format).objet;
1473:
1474: while((l_element_courant != NULL) &&
1475: (l_element_courant_format != NULL))
1.33 bertrand 1476: {
1.64 bertrand 1477: if ((*(*l_element_courant).donnee).type != CHN)
1478: {
1479: liberation(s_etat_processus, s_objet_argument_2);
1480: liberation(s_etat_processus, s_objet_argument_1);
1481:
1482: (*s_etat_processus).erreur_execution =
1483: d_ex_erreur_type_argument;
1484: return;
1485: }
1486:
1487: if ((*(*l_element_courant_format).donnee).type != CHN)
1488: {
1489: liberation(s_etat_processus, s_objet_argument_2);
1490: liberation(s_etat_processus, s_objet_argument_1);
1491:
1492: (*s_etat_processus).erreur_execution =
1493: d_ex_erreur_type_argument;
1494: return;
1495: }
1496:
1497: if ((format_chaine = conversion_majuscule((unsigned char *)
1498: (*(*l_element_courant_format).donnee).objet))
1499: == NULL)
1500: {
1501: (*s_etat_processus).erreur_systeme =
1502: d_es_allocation_memoire;
1503: return;
1504: }
1505:
1506: if (strncmp("LENGTH*(", format_chaine, 8) != 0)
1507: {
1508: free(format_chaine);
1509:
1510: liberation(s_etat_processus, s_objet_argument_2);
1511: liberation(s_etat_processus, s_objet_argument_1);
1512:
1513: (*s_etat_processus).erreur_execution =
1514: d_ex_erreur_format_fichier;
1515: return;
1516: }
1517:
1.79 bertrand 1518: longueur = (integer8) strlen(format_chaine);
1.64 bertrand 1519:
1.65 bertrand 1520: if (format_chaine[longueur - 1] != ')')
1.64 bertrand 1521: {
1522: free(format_chaine);
1523:
1524: liberation(s_etat_processus, s_objet_argument_2);
1525: liberation(s_etat_processus, s_objet_argument_1);
1526:
1527: (*s_etat_processus).erreur_execution =
1528: d_ex_erreur_format_fichier;
1529: return;
1530: }
1531:
1532: format_chaine[longueur] = d_code_fin_chaine;
1533:
1534: if (format_chaine[8] == '*')
1535: {
1536: format_degenere = d_vrai;
1537: }
1538: else
1539: {
1540: // Détermination de la longueur
1541: format_degenere = d_faux;
1542:
1.79 bertrand 1543: if (sscanf(&(format_chaine[8]), "%lld", &longueur) != 1)
1.64 bertrand 1544: {
1545: free(format_chaine);
1546:
1547: liberation(s_etat_processus, s_objet_argument_2);
1548: liberation(s_etat_processus, s_objet_argument_1);
1.33 bertrand 1549:
1.64 bertrand 1550: (*s_etat_processus).erreur_execution =
1551: d_ex_erreur_format_fichier;
1552: return;
1553: }
1554: }
1.33 bertrand 1555:
1.64 bertrand 1556: free(format_chaine);
1.33 bertrand 1557:
1.64 bertrand 1558: if ((chaine = formateur_flux(s_etat_processus,
1559: (unsigned char *) (*(*l_element_courant).donnee)
1560: .objet, &longueur_effective)) == NULL)
1561: {
1562: (*s_etat_processus).erreur_systeme =
1563: d_es_allocation_memoire;
1564: return;
1565: }
1.33 bertrand 1566:
1.64 bertrand 1567: if ((format_degenere == d_vrai) ||
1568: (longueur_effective < longueur))
1569: {
1570: if (fwrite(chaine, sizeof(unsigned char),
1.79 bertrand 1571: (size_t) longueur_effective,
1.64 bertrand 1572: (*descripteur).descripteur_c) !=
1573: (size_t) longueur_effective)
1574: {
1575: (*s_etat_processus).erreur_systeme =
1576: d_es_erreur_fichier;
1577: return;
1578: }
1579: }
1580: else
1581: {
1582: if (fwrite(chaine, sizeof(unsigned char),
1.79 bertrand 1583: (size_t) longueur_effective,
1.64 bertrand 1584: (*descripteur).descripteur_c) !=
1585: (size_t) longueur)
1586: {
1587: (*s_etat_processus).erreur_systeme =
1588: d_es_erreur_fichier;
1589: return;
1590: }
1591: }
1.63 bertrand 1592:
1.64 bertrand 1593: free(chaine);
1.63 bertrand 1594:
1.64 bertrand 1595: l_element_courant = (*l_element_courant).suivant;
1596: l_element_courant_format = (*l_element_courant_format)
1597: .suivant;
1598: }
1.63 bertrand 1599:
1.64 bertrand 1600: if ((l_element_courant_format != NULL) ||
1601: (l_element_courant != NULL))
1.63 bertrand 1602: {
1.64 bertrand 1603: liberation(s_etat_processus, s_objet_argument_2);
1604: liberation(s_etat_processus, s_objet_argument_1);
1605:
1606: (*s_etat_processus).erreur_execution =
1607: d_ex_erreur_format_fichier;
1.63 bertrand 1608: return;
1609: }
1.33 bertrand 1610: }
1611: else
1612: {
1613: liberation(s_etat_processus, s_objet_argument_1);
1614: liberation(s_etat_processus, s_objet_argument_2);
1615:
1616: (*s_etat_processus).erreur_execution =
1617: d_ex_erreur_type_fichier;
1618: return;
1619: }
1.1 bertrand 1620: }
1621: }
1622: else if (((*s_objet_argument_2).type == LST) &&
1623: ((*s_objet_argument_1).type == SCK))
1624: {
1625: /*
1626: * Vérification de l'autorisation d'écriture
1627: */
1628:
1629: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1630: .protection == 'R')
1631: {
1632: liberation(s_etat_processus, s_objet_argument_2);
1633: liberation(s_etat_processus, s_objet_argument_1);
1634:
1635: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
1636: return;
1637: }
1638:
1639: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
1640: {
1641: /*
1642: * Sockets formatées
1643: */
1644:
1645: if ((chaine = formateur_fichier(s_etat_processus,
1646: s_objet_argument_2, (*((struct_socket *)
1647: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
1.75 bertrand 1648: &longueur_effective, &recursivite, d_faux)) == NULL)
1.1 bertrand 1649: {
1650: liberation(s_etat_processus, s_objet_argument_2);
1651: liberation(s_etat_processus, s_objet_argument_1);
1652:
1653: return;
1654: }
1.33 bertrand 1655: }
1656: else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
1657: == 'Y')
1658: {
1659: /*
1660: * Sockets non formatées
1661: */
1.38 bertrand 1662:
1.77 bertrand 1663: if ((chaine = formateur_fichier(s_etat_processus,
1664: s_objet_argument_2, (*((struct_socket *)
1665: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
1666: &longueur_effective, &recursivite, d_faux)) == NULL)
1667: {
1668: liberation(s_etat_processus, s_objet_argument_2);
1669: liberation(s_etat_processus, s_objet_argument_1);
1670:
1671: return;
1672: }
1.33 bertrand 1673: }
1674: else
1675: {
1676: /*
1677: * Sockets de type FLOW
1678: */
1679:
1680: if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
1681: .donnee)).type != CHN)
1682: {
1683: liberation(s_etat_processus, s_objet_argument_2);
1684: liberation(s_etat_processus, s_objet_argument_1);
1685:
1686: (*s_etat_processus).erreur_execution =
1687: d_ex_erreur_type_argument;
1688: return;
1689: }
1690:
1691: if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
1692: (*((*((struct_liste_chainee *) (*s_objet_argument_2)
1693: .objet)).donnee)).objet, &longueur_effective)) == NULL)
1694: {
1695: liberation(s_etat_processus, s_objet_argument_2);
1696: liberation(s_etat_processus, s_objet_argument_1);
1697:
1698: return;
1699: }
1700: }
1.1 bertrand 1701:
1.33 bertrand 1702: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
1703: "STREAM") == 0) || (strcmp((*((struct_socket *)
1704: (*s_objet_argument_1).objet)).type,
1705: "SEQUENTIAL DATAGRAM") == 0))
1706: { // Sockets connectées
1707:
1708: action.sa_handler = SIG_IGN;
1709: action.sa_flags = SA_ONSTACK;
1710:
1711: if (sigaction(SIGPIPE, &action, ®istre) != 0)
1712: {
1713: (*s_etat_processus).erreur_systeme = d_es_signal;
1714: return;
1715: }
1716:
1.51 bertrand 1717: # ifndef SEMAPHORES_NOMMES
1718: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1719: # else
1720: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1721: # endif
1.33 bertrand 1722: {
1723: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1724: {
1725: (*s_etat_processus).erreur_systeme = d_es_signal;
1726: return;
1727: }
1728:
1729: (*s_etat_processus).erreur_systeme = d_es_processus;
1730: return;
1731: }
1.1 bertrand 1732:
1.33 bertrand 1733: if (send((*((struct_socket *) (*s_objet_argument_1).objet))
1.79 bertrand 1734: .socket, chaine, (size_t) longueur_effective, 0) < 0)
1.33 bertrand 1735: {
1736: ios = errno;
1.1 bertrand 1737:
1.33 bertrand 1738: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1.1 bertrand 1739: {
1740: (*s_etat_processus).erreur_systeme = d_es_signal;
1741: return;
1742: }
1743:
1.51 bertrand 1744: # ifndef SEMAPHORES_NOMMES
1745: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1746: # else
1747: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1748: # endif
1.1 bertrand 1749: {
1.50 bertrand 1750: if (errno != EINTR)
1751: {
1752: (*s_etat_processus).erreur_systeme = d_es_processus;
1753: return;
1754: }
1.33 bertrand 1755: }
1.1 bertrand 1756:
1.33 bertrand 1757: if ((ios == EPIPE) || (ios == ECONNRESET))
1758: {
1759: (*s_etat_processus).erreur_execution =
1760: d_ex_erreur_acces_fichier;
1.1 bertrand 1761: return;
1762: }
1763:
1.33 bertrand 1764: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1765: return;
1766: }
1767:
1.51 bertrand 1768: # ifndef SEMAPHORES_NOMMES
1769: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1770: # else
1771: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1772: # endif
1.33 bertrand 1773: {
1774: if (errno != EINTR)
1.1 bertrand 1775: {
1776: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1777: {
1778: (*s_etat_processus).erreur_systeme = d_es_signal;
1779: return;
1780: }
1781:
1.33 bertrand 1782: (*s_etat_processus).erreur_systeme = d_es_processus;
1783: return;
1784: }
1785: }
1786:
1787: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
1788: {
1789: (*s_etat_processus).erreur_systeme = d_es_signal;
1790: return;
1791: }
1792: }
1793: else
1794: { // Sockets non connectées
1795:
1796: /*
1797: * Vérification de l'adresse distante
1798: */
1799:
1800: if (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
1801: .adresse_distante, "") == 0)
1802: {
1803: liberation(s_etat_processus, s_objet_argument_1);
1804: liberation(s_etat_processus, s_objet_argument_2);
1805:
1806: (*s_etat_processus).erreur_execution =
1807: d_ex_erreur_acces_fichier;
1808: return;
1809: }
1810:
1811: /*
1812: * Création de l'adresse logique
1813: */
1814:
1815: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1816: .domaine == PF_UNIX)
1817: {
1818: adresse_unix.sun_family = AF_UNIX;
1819: strncpy(adresse_unix.sun_path, (*((struct_socket *)
1820: (*s_objet_argument_1).objet)).adresse_distante,
1821: UNIX_PATH_MAX);
1822: adresse_unix.sun_path[UNIX_PATH_MAX - 1] =
1823: d_code_fin_chaine;
1824:
1.51 bertrand 1825: # ifndef SEMAPHORES_NOMMES
1826: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1827: # else
1828: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1829: # endif
1.33 bertrand 1830: {
1831: (*s_etat_processus).erreur_systeme = d_es_processus;
1832: return;
1833: }
1834:
1835: if (sendto((*((struct_socket *)
1836: (*s_objet_argument_1).objet)).socket, chaine,
1.79 bertrand 1837: (size_t) longueur_effective, 0, (struct sockaddr *)
1.33 bertrand 1838: &adresse_unix, sizeof(adresse_unix)) < 0)
1839: {
1.38 bertrand 1840: ios = errno;
1841:
1.51 bertrand 1842: # ifndef SEMAPHORES_NOMMES
1843: while(sem_wait(&((*s_etat_processus).semaphore_fork))
1844: != 0)
1845: # else
1846: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1847: # endif
1.1 bertrand 1848: {
1.50 bertrand 1849: if (errno != EINTR)
1850: {
1851: (*s_etat_processus).erreur_systeme = d_es_processus;
1852: return;
1853: }
1.1 bertrand 1854: }
1855:
1.34 bertrand 1856: if ((ios == EPIPE) || (ios == ECONNRESET))
1857: {
1858: (*s_etat_processus).erreur_execution =
1859: d_ex_erreur_acces_fichier;
1860: return;
1861: }
1862:
1.73 bertrand 1863: if (ios == EMSGSIZE)
1864: {
1865: (*s_etat_processus).erreur_execution =
1866: d_ex_taille_message;
1.74 bertrand 1867: return;
1.73 bertrand 1868: }
1.34 bertrand 1869:
1870: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1.1 bertrand 1871: return;
1872: }
1873:
1.51 bertrand 1874: # ifndef SEMAPHORES_NOMMES
1875: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1876: # else
1877: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1878: # endif
1.1 bertrand 1879: {
1.50 bertrand 1880: if (errno != EINTR)
1881: {
1882: (*s_etat_processus).erreur_systeme = d_es_processus;
1883: return;
1884: }
1.1 bertrand 1885: }
1886: }
1.33 bertrand 1887: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1888: .domaine == PF_INET)
1889: {
1890: if (sscanf((*((struct_socket *)
1891: (*s_objet_argument_1).objet))
1892: .adresse_distante, "%d.%d.%d.%d(%d)",
1893: &(adresse[0]), &(adresse[1]), &(adresse[2]),
1894: &(adresse[3]), &port) == 5)
1895: { // Adresse IPv4
1896: calcul_adresse = 0;
1897: for(i = 0; i < 4; calcul_adresse =
1.79 bertrand 1898: (256 * calcul_adresse) +
1899: ((unsigned char) adresse[i++]));
1.33 bertrand 1900:
1901: memset(&adresse_ipv4, 0, sizeof(adresse_ipv4));
1902: adresse_ipv4.sin_family = AF_INET;
1.81 bertrand 1903: adresse_ipv4.sin_port = htons((uint16_t) port);
1.33 bertrand 1904: adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
1.1 bertrand 1905:
1.51 bertrand 1906: # ifndef SEMAPHORES_NOMMES
1907: if (sem_post(&((*s_etat_processus).semaphore_fork))
1908: != 0)
1909: # else
1910: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1911: # endif
1.1 bertrand 1912: {
1913: (*s_etat_processus).erreur_systeme = d_es_processus;
1914: return;
1915: }
1916:
1917: if (sendto((*((struct_socket *)
1918: (*s_objet_argument_1).objet)).socket, chaine,
1.79 bertrand 1919: (size_t) longueur_effective, 0, (struct sockaddr *)
1.33 bertrand 1920: &adresse_ipv4, sizeof(adresse_ipv4)) < 0)
1.1 bertrand 1921: {
1.74 bertrand 1922: ios = errno;
1923:
1.51 bertrand 1924: # ifndef SEMAPHORES_NOMMES
1925: while(sem_wait(&((*s_etat_processus)
1926: .semaphore_fork)) != 0)
1927: # else
1928: while(sem_wait((*s_etat_processus)
1929: .semaphore_fork) != 0)
1930: # endif
1.1 bertrand 1931: {
1.50 bertrand 1932: if (errno != EINTR)
1933: {
1934: (*s_etat_processus).erreur_systeme =
1935: d_es_processus;
1936: return;
1937: }
1.1 bertrand 1938: }
1939:
1.74 bertrand 1940: if ((ios == EPIPE) || (ios == ECONNRESET))
1941: {
1942: (*s_etat_processus).erreur_execution =
1943: d_ex_erreur_acces_fichier;
1944: return;
1945: }
1946:
1947: if (ios == EMSGSIZE)
1948: {
1949: (*s_etat_processus).erreur_execution =
1950: d_ex_taille_message;
1951: return;
1952: }
1953:
1.1 bertrand 1954: (*s_etat_processus).erreur_systeme =
1955: d_es_erreur_fichier;
1956: return;
1957: }
1958:
1.51 bertrand 1959: # ifndef SEMAPHORES_NOMMES
1960: while(sem_wait(&((*s_etat_processus).semaphore_fork))
1961: != 0)
1962: # else
1963: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1964: # endif
1.1 bertrand 1965: {
1.50 bertrand 1966: if (errno != EINTR)
1967: {
1968: (*s_etat_processus).erreur_systeme = d_es_processus;
1969: return;
1970: }
1.1 bertrand 1971: }
1972: }
1.33 bertrand 1973: else
1.1 bertrand 1974: {
1.33 bertrand 1975: liberation(s_etat_processus, s_objet_argument_1);
1976: liberation(s_etat_processus, s_objet_argument_2);
1.1 bertrand 1977:
1.33 bertrand 1978: (*s_etat_processus).erreur_execution =
1979: d_ex_erreur_parametre_fichier;
1980: return;
1981: }
1982: }
1983: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
1984: .domaine == PF_INET6)
1985: {
1986: if (sscanf((*((struct_socket *) (*s_objet_argument_1)
1987: .objet)).adresse_distante, "%X:%X:%X:%X:%X:"
1988: "%X:%X:%X:%X:%X:%X:%X:%X:%X:%X:%X(%d)",
1989: &(adresse[0]), &(adresse[1]), &(adresse[2]),
1990: &(adresse[3]), &(adresse[4]), &(adresse[5]),
1991: &(adresse[6]), &(adresse[7]), &(adresse[8]),
1992: &(adresse[9]), &(adresse[10]), &(adresse[11]),
1993: &(adresse[12]), &(adresse[13]), &(adresse[14]),
1994: &(adresse[15]), &port)== 17)
1995: { // Adresse IPv6
1996: # ifdef IPV6
1997: memset(&adresse_ipv6, 0, sizeof(adresse_ipv6));
1998: adresse_ipv6.sin6_family = AF_INET6;
1999: adresse_ipv6.sin6_port = htons((uint16_t) port);
2000:
2001: for(i = 0; i < 16;
2002: adresse_ipv6.sin6_addr.s6_addr[i] =
1.79 bertrand 2003: (unsigned char) adresse[i], i++);
1.1 bertrand 2004:
1.51 bertrand 2005: # ifndef SEMAPHORES_NOMMES
2006: if (sem_post(&((*s_etat_processus).semaphore_fork))
2007: != 0)
2008: # else
2009: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
2010: # endif
1.33 bertrand 2011: {
2012: (*s_etat_processus).erreur_systeme = d_es_processus;
2013: return;
2014: }
1.1 bertrand 2015:
1.33 bertrand 2016: if (sendto((*((struct_socket *)
2017: (*s_objet_argument_1).objet)).socket, chaine,
1.79 bertrand 2018: (size_t) longueur_effective, 0, (struct sockaddr *)
1.33 bertrand 2019: &adresse_ipv6, sizeof(adresse_ipv6)) < 0)
2020: {
1.74 bertrand 2021: ios = errno;
2022:
1.51 bertrand 2023: # ifndef SEMAPHORES_NOMMES
2024: while(sem_wait(&((*s_etat_processus)
2025: .semaphore_fork)) != 0)
2026: # else
2027: while(sem_wait((*s_etat_processus)
2028: .semaphore_fork) != 0)
2029: # endif
1.1 bertrand 2030: {
1.50 bertrand 2031: if (errno != EINTR)
2032: {
2033: (*s_etat_processus).erreur_systeme =
2034: d_es_processus;
2035: return;
2036: }
1.1 bertrand 2037: }
2038:
1.74 bertrand 2039: if ((ios == EPIPE) || (ios == ECONNRESET))
2040: {
2041: (*s_etat_processus).erreur_execution =
2042: d_ex_erreur_acces_fichier;
2043: return;
2044: }
2045:
2046: if (ios == EMSGSIZE)
2047: {
2048: (*s_etat_processus).erreur_execution =
2049: d_ex_taille_message;
2050: return;
2051: }
2052:
1.33 bertrand 2053: (*s_etat_processus).erreur_systeme =
2054: d_es_erreur_fichier;
1.1 bertrand 2055: return;
2056: }
2057:
1.51 bertrand 2058: # ifndef SEMAPHORES_NOMMES
2059: while(sem_wait(&((*s_etat_processus).semaphore_fork))
2060: != 0)
2061: # else
2062: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
2063: # endif
1.33 bertrand 2064: {
1.50 bertrand 2065: if (errno != EINTR)
2066: {
2067: (*s_etat_processus).erreur_systeme =
2068: d_es_processus;
2069: return;
2070: }
1.33 bertrand 2071: }
2072: # else
2073: if ((*s_etat_processus).langue == 'F')
2074: {
2075: printf("+++Attention : Support du protocole"
2076: " IPv6 indisponible\n");
1.1 bertrand 2077: }
2078: else
2079: {
1.33 bertrand 2080: printf("+++Warning : IPv6 support "
2081: "unavailable\n");
1.1 bertrand 2082: }
1.33 bertrand 2083: # endif
1.1 bertrand 2084: }
1.33 bertrand 2085: else
1.1 bertrand 2086: {
2087: liberation(s_etat_processus, s_objet_argument_1);
2088: liberation(s_etat_processus, s_objet_argument_2);
2089:
2090: (*s_etat_processus).erreur_execution =
2091: d_ex_erreur_parametre_fichier;
2092: return;
2093: }
2094: }
1.33 bertrand 2095: else
2096: {
2097: liberation(s_etat_processus, s_objet_argument_1);
2098: liberation(s_etat_processus, s_objet_argument_2);
1.1 bertrand 2099:
1.33 bertrand 2100: (*s_etat_processus).erreur_execution =
2101: d_ex_erreur_parametre_fichier;
2102: return;
2103: }
1.1 bertrand 2104: }
1.33 bertrand 2105:
2106: free(chaine);
1.1 bertrand 2107: }
2108: else
2109: {
2110: liberation(s_etat_processus, s_objet_argument_2);
2111: liberation(s_etat_processus, s_objet_argument_1);
2112:
2113: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2114: return;
2115: }
2116:
2117: liberation(s_etat_processus, s_objet_argument_2);
2118: liberation(s_etat_processus, s_objet_argument_1);
2119:
2120: return;
2121: }
2122:
2123:
2124: /*
2125: ================================================================================
2126: Fonction 'wflock'
2127: ================================================================================
2128: Entrées : pointeur sur une structure struct_processus
2129: --------------------------------------------------------------------------------
2130: Sorties :
2131: --------------------------------------------------------------------------------
2132: Effets de bord : néant
2133: ================================================================================
2134: */
2135:
2136: void
2137: instruction_wflock(struct_processus *s_etat_processus)
2138: {
2139: logical1 drapeau;
2140:
2141: struct flock lock;
2142:
2143: struct timespec attente;
2144:
1.5 bertrand 2145: struct_descripteur_fichier *descripteur;
2146:
1.1 bertrand 2147: struct_objet *s_objet_argument_1;
2148: struct_objet *s_objet_argument_2;
2149:
2150: unsigned char *chaine;
2151: unsigned char registre_instruction_valide;
2152:
2153: attente.tv_sec = 0;
2154: attente.tv_nsec = GRANULARITE_us * 1000;
2155:
2156: (*s_etat_processus).erreur_execution = d_ex;
2157:
2158: if ((*s_etat_processus).affichage_arguments == 'Y')
2159: {
2160: printf("\n WFLOCK ");
2161:
2162: if ((*s_etat_processus).langue == 'F')
2163: {
2164: printf("(attente du positionnement d'un verrou sur un fichier)"
2165: "\n\n");
2166: }
2167: else
2168: {
2169: printf("(wait for file lock)\n\n");
2170: }
2171:
2172: printf(" 2: %s\n", d_FCH);
2173: printf(" 1: %s (READ/WRITE/NONE)\n", d_CHN);
2174:
2175: return;
2176: }
2177: else if ((*s_etat_processus).test_instruction == 'Y')
2178: {
2179: (*s_etat_processus).nombre_arguments = -1;
2180: return;
2181: }
2182:
2183: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2184: {
2185: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
2186: {
2187: return;
2188: }
2189: }
2190:
2191: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2192: &s_objet_argument_1) == d_erreur)
2193: {
2194: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2195: return;
2196: }
2197:
2198: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2199: &s_objet_argument_2) == d_erreur)
2200: {
2201: liberation(s_etat_processus, s_objet_argument_1);
2202:
2203: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2204: return;
2205: }
2206:
2207: if (((*s_objet_argument_2).type == FCH) &&
2208: ((*s_objet_argument_1).type == CHN))
2209: {
2210: drapeau = d_faux;
2211:
2212: do
2213: {
2214: if ((chaine = conversion_majuscule((unsigned char *)
2215: (*s_objet_argument_1).objet)) == NULL)
2216: {
2217: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2218: return;
2219: }
2220:
2221: if (strcmp(chaine, "WRITE") == 0)
2222: {
2223: lock.l_type = F_WRLCK;
2224: }
2225: else if (strcmp(chaine, "READ") == 0)
2226: {
2227: lock.l_type = F_RDLCK;
2228: }
2229: else if (strcmp(chaine, "NONE") == 0)
2230: {
2231: lock.l_type = F_UNLCK;
2232: }
2233: else
2234: {
2235: free(chaine);
2236:
2237: liberation(s_etat_processus, s_objet_argument_1);
2238: liberation(s_etat_processus, s_objet_argument_2);
2239:
2240: (*s_etat_processus).erreur_execution = d_ex_verrou_indefini;
2241: return;
2242: }
2243:
2244: free(chaine);
2245:
2246: lock.l_whence = SEEK_SET;
2247: lock.l_start = 0;
2248: lock.l_len = 0;
2249: lock.l_pid = getpid();
2250:
2251: if ((descripteur = descripteur_fichier(s_etat_processus,
2252: (struct_fichier *) (*s_objet_argument_2).objet)) == NULL)
2253: {
2254: return;
2255: }
2256:
1.5 bertrand 2257: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
2258: == -1)
1.1 bertrand 2259: {
2260: liberation(s_etat_processus, s_objet_argument_1);
2261: liberation(s_etat_processus, s_objet_argument_2);
2262:
2263: (*s_etat_processus).erreur_execution = d_ex_fichier_verrouille;
2264: return;
2265: }
2266:
1.51 bertrand 2267: # ifndef SEMAPHORES_NOMMES
2268: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
2269: # else
2270: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
2271: # endif
1.1 bertrand 2272: {
2273: (*s_etat_processus).erreur_systeme = d_es_processus;
2274: return;
2275: }
1.47 bertrand 2276:
1.51 bertrand 2277: # ifndef SEMAPHORES_NOMMES
2278: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
2279: # else
2280: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
2281: # endif
1.12 bertrand 2282: {
1.50 bertrand 2283: if (errno != EINTR)
2284: {
2285: (*s_etat_processus).erreur_systeme = d_es_processus;
2286: return;
2287: }
1.12 bertrand 2288: }
1.1 bertrand 2289:
2290: if (lock.l_type == F_UNLCK)
2291: {
2292: drapeau = d_vrai;
2293: }
2294: else
2295: {
1.84 ! bertrand 2296: if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
! 2297: != 0)
1.83 bertrand 2298: {
2299: (*s_etat_processus).erreur_systeme = d_es_processus;
2300: return;
2301: }
2302:
1.1 bertrand 2303: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
2304: {
2305: affectation_interruptions_logicielles(s_etat_processus);
2306: }
2307:
1.84 ! bertrand 2308: if (pthread_mutex_unlock(&(*s_etat_processus)
! 2309: .mutex_interruptions) != 0)
1.83 bertrand 2310: {
2311: (*s_etat_processus).erreur_systeme = d_es_processus;
2312: return;
2313: }
2314:
2315: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
1.1 bertrand 2316: {
2317: registre_instruction_valide =
2318: (*s_etat_processus).instruction_valide;
2319: traitement_interruptions_logicielles(
2320: s_etat_processus);
2321: (*s_etat_processus).instruction_valide =
2322: registre_instruction_valide;
2323: }
2324:
2325: nanosleep(&attente, NULL);
2326: scrutation_injection(s_etat_processus);
2327:
2328: INCR_GRANULARITE(attente.tv_nsec);
2329: }
2330: } while((drapeau == d_faux) && ((*s_etat_processus)
2331: .var_volatile_requete_arret != -1));
2332: }
2333: else
2334: {
2335: liberation(s_etat_processus, s_objet_argument_1);
2336: liberation(s_etat_processus, s_objet_argument_2);
2337:
2338: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2339: return;
2340: }
2341:
2342: return;
2343: }
2344:
2345:
2346: /*
2347: ================================================================================
2348: Fonction 'wfproc'
2349: ================================================================================
2350: Entrées : pointeur sur une structure struct_processus
2351: --------------------------------------------------------------------------------
2352: Sorties :
2353: --------------------------------------------------------------------------------
2354: Effets de bord : néant
2355: ================================================================================
2356: */
2357:
2358: void
2359: instruction_wfproc(struct_processus *s_etat_processus)
2360: {
2361: logical1 drapeau_fin;
2362:
2363: struct_liste_chainee *l_element_courant;
2364:
2365: struct_objet *s_objet_argument;
2366:
2367: struct timespec attente;
2368:
2369: unsigned char registre_instruction_valide;
2370:
2371: (*s_etat_processus).erreur_execution = d_ex;
2372:
2373: attente.tv_sec = 0;
2374: attente.tv_nsec = GRANULARITE_us * 1000;
2375:
2376: if ((*s_etat_processus).affichage_arguments == 'Y')
2377: {
2378: printf("\n WFPROC ");
2379:
2380: if ((*s_etat_processus).langue == 'F')
2381: {
2382: printf("(attente de la fin d'un processus fils)\n\n");
2383: }
2384: else
2385: {
2386: printf("(wait for child process end)\n\n");
2387: }
2388:
2389: printf(" 1: %s\n", d_PRC);
2390:
2391: return;
2392: }
2393: else if ((*s_etat_processus).test_instruction == 'Y')
2394: {
2395: (*s_etat_processus).nombre_arguments = -1;
2396: return;
2397: }
2398:
2399: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2400: {
2401: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2402: {
2403: return;
2404: }
2405: }
2406:
2407: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2408: &s_objet_argument) == d_erreur)
2409: {
2410: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2411: return;
2412: }
2413:
2414: if ((*s_objet_argument).type == PRC)
2415: {
2416: drapeau_fin = d_faux;
2417:
2418: if ((*s_etat_processus).profilage == d_vrai)
2419: {
2420: profilage(s_etat_processus, "Interprocess or interthread "
2421: "communications (WFPROC)");
2422:
2423: if ((*s_etat_processus).erreur_systeme != d_es)
2424: {
2425: return;
2426: }
2427: }
2428:
2429: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2430: {
2431: if ((*s_etat_processus).profilage == d_vrai)
2432: {
2433: profilage(s_etat_processus, NULL);
2434: }
2435:
2436: (*s_etat_processus).erreur_systeme = d_es_processus;
2437: return;
2438: }
2439:
2440: while(drapeau_fin == d_faux)
2441: {
2442: l_element_courant = (struct_liste_chainee *)
2443: (*s_etat_processus).l_base_pile_processus;
2444:
2445: while(l_element_courant != NULL)
2446: {
2447: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
2448: .donnee).objet)).thread).processus_detache == d_vrai)
2449: {
2450: if ((*(*((struct_processus_fils *)
2451: (*s_objet_argument).objet)).thread)
2452: .processus_detache == d_vrai)
2453: {
2454: if ((*(*((struct_processus_fils *)
2455: (*(*l_element_courant)
2456: .donnee).objet)).thread).pid ==
2457: (*(*((struct_processus_fils *)
2458: (*s_objet_argument).objet)).thread).pid)
2459: {
2460: break;
2461: }
2462: }
2463: }
2464: else
2465: {
2466: if ((*(*((struct_processus_fils *)
2467: (*s_objet_argument).objet)).thread)
2468: .processus_detache == d_faux)
2469: {
2470: if ((pthread_equal((*(*((struct_processus_fils *)
2471: (*(*l_element_courant).donnee).objet)).thread)
2472: .tid, (*(*((struct_processus_fils *)
2473: (*s_objet_argument).objet)).thread).tid) != 0)
2474: && ((*(*((struct_processus_fils *)
2475: (*(*l_element_courant).donnee).objet)).thread)
2476: .pid == (*(*((struct_processus_fils *)
2477: (*s_objet_argument).objet)).thread).pid))
2478: {
2479: break;
2480: }
2481: }
2482: }
2483:
2484: l_element_courant = (*l_element_courant).suivant;
2485: }
2486:
2487: if ((*s_etat_processus).var_volatile_requete_arret != 0)
2488: {
2489: if ((*s_etat_processus).profilage == d_vrai)
2490: {
2491: profilage(s_etat_processus, NULL);
2492: }
2493:
2494: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2495: {
2496: (*s_etat_processus).erreur_systeme = d_es_processus;
2497: return;
2498: }
2499:
2500: liberation(s_etat_processus, s_objet_argument);
2501: return;
2502: }
2503:
2504: if (l_element_courant == NULL)
2505: {
2506: /*
2507: * Si l_element_courant vaut NULL, le processus n'existe plus.
2508: */
2509:
2510: drapeau_fin = d_vrai;
2511: }
2512: else
2513: {
2514: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
2515: .donnee).objet)).thread).processus_detache == d_vrai)
2516: {
1.48 bertrand 2517: if (envoi_signal_processus((*(*((struct_processus_fils *)
1.1 bertrand 2518: (*(*l_element_courant).donnee).objet)).thread).pid,
1.48 bertrand 2519: rpl_signull) != 0)
1.1 bertrand 2520: {
2521: drapeau_fin = d_vrai;
2522: }
2523: else
2524: {
2525: drapeau_fin = d_faux;
2526: }
2527: }
2528: else
2529: {
2530: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
2531: (*(*l_element_courant).donnee).objet)).thread)
2532: .mutex)) != 0)
2533: {
2534: if ((*s_etat_processus).profilage == d_vrai)
2535: {
2536: profilage(s_etat_processus, NULL);
2537: }
2538:
2539: (*s_etat_processus).erreur_systeme = d_es_processus;
2540: return;
2541: }
2542:
2543: if ((*(*((struct_processus_fils *)
2544: (*(*l_element_courant).donnee).objet)).thread)
2545: .thread_actif == d_faux)
2546: {
2547: drapeau_fin = d_vrai;
2548: }
2549: else
2550: {
2551: drapeau_fin = d_faux;
2552: }
2553:
2554: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
2555: (*(*l_element_courant).donnee).objet)).thread)
2556: .mutex)) != 0)
2557: {
2558: if ((*s_etat_processus).profilage == d_vrai)
2559: {
2560: profilage(s_etat_processus, NULL);
2561: }
2562:
2563: (*s_etat_processus).erreur_systeme = d_es_processus;
2564: return;
2565: }
2566: }
2567:
2568: if (drapeau_fin == d_faux)
2569: {
2570: /*
2571: * Le processus n'est pas terminé
2572: */
2573:
1.84 ! bertrand 2574: if (pthread_mutex_lock(&((*s_etat_processus)
! 2575: .mutex_interruptions)) != 0)
! 2576: {
! 2577: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2578:
! 2579: if ((*s_etat_processus).profilage == d_vrai)
! 2580: {
! 2581: profilage(s_etat_processus, NULL);
! 2582: }
! 2583:
! 2584: (*s_etat_processus).erreur_systeme =
! 2585: d_es_processus;
! 2586: return;
! 2587: }
! 2588:
1.83 bertrand 2589: if ((*s_etat_processus).nombre_interruptions_non_affectees
2590: != 0)
2591: {
2592: affectation_interruptions_logicielles(s_etat_processus);
2593: }
2594:
1.84 ! bertrand 2595: if (pthread_mutex_unlock(&((*s_etat_processus)
! 2596: .mutex_interruptions)) != 0)
! 2597: {
! 2598: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 2599:
! 2600: if ((*s_etat_processus).profilage == d_vrai)
! 2601: {
! 2602: profilage(s_etat_processus, NULL);
! 2603: }
! 2604:
! 2605: (*s_etat_processus).erreur_systeme =
! 2606: d_es_processus;
! 2607: return;
! 2608: }
! 2609:
1.1 bertrand 2610: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2611: {
2612: if ((*s_etat_processus).profilage == d_vrai)
2613: {
2614: profilage(s_etat_processus, NULL);
2615: }
2616:
2617: (*s_etat_processus).erreur_systeme =
2618: d_es_processus;
2619: return;
2620: }
2621:
1.83 bertrand 2622: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
1.1 bertrand 2623: {
2624: registre_instruction_valide =
2625: (*s_etat_processus).instruction_valide;
2626: traitement_interruptions_logicielles(
2627: s_etat_processus);
2628: (*s_etat_processus).instruction_valide =
2629: registre_instruction_valide;
2630: }
2631:
1.51 bertrand 2632: # ifndef SEMAPHORES_NOMMES
2633: if (sem_post(&((*s_etat_processus).semaphore_fork))
2634: != 0)
2635: # else
2636: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
2637: # endif
1.1 bertrand 2638: {
2639: (*s_etat_processus).erreur_systeme = d_es_processus;
2640: return;
2641: }
2642:
2643: nanosleep(&attente, NULL);
2644:
1.51 bertrand 2645: # ifndef SEMAPHORES_NOMMES
2646: while(sem_wait(&((*s_etat_processus).semaphore_fork))
2647: != 0)
2648: # else
2649: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
2650: # endif
1.1 bertrand 2651: {
1.50 bertrand 2652: if (errno != EINTR)
2653: {
2654: (*s_etat_processus).erreur_systeme = d_es_processus;
2655: return;
2656: }
1.1 bertrand 2657: }
2658:
2659: scrutation_injection(s_etat_processus);
2660:
2661: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2662: {
2663: if ((*s_etat_processus).profilage == d_vrai)
2664: {
2665: profilage(s_etat_processus, NULL);
2666: }
2667:
2668: (*s_etat_processus).erreur_systeme =
2669: d_es_processus;
2670: return;
2671: }
2672: }
2673: }
2674:
2675: INCR_GRANULARITE(attente.tv_nsec);
2676: }
2677:
2678: if ((*s_etat_processus).profilage == d_vrai)
2679: {
2680: profilage(s_etat_processus, NULL);
2681: }
2682:
2683: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2684: {
2685: (*s_etat_processus).erreur_systeme = d_es_processus;
2686: return;
2687: }
2688: }
2689: else
2690: {
2691: liberation(s_etat_processus, s_objet_argument);
2692:
2693: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2694: return;
2695: }
2696:
2697: liberation(s_etat_processus, s_objet_argument);
2698:
2699: return;
2700: }
2701:
2702:
2703: /*
2704: ================================================================================
2705: Fonction 'wfdata'
2706: ================================================================================
2707: Entrées : pointeur sur une structure struct_processus
2708: --------------------------------------------------------------------------------
2709: Sorties :
2710: --------------------------------------------------------------------------------
2711: Effets de bord : néant
2712: ================================================================================
2713: */
2714:
2715: void
2716: instruction_wfdata(struct_processus *s_etat_processus)
2717: {
2718: logical1 drapeau_fin;
2719:
2720: struct_liste_chainee *l_element_courant;
2721:
2722: struct_objet *s_objet_argument;
2723:
2724: struct timespec attente;
2725:
2726: unsigned char registre_instruction_valide;
2727:
2728: (*s_etat_processus).erreur_execution = d_ex;
2729:
2730: attente.tv_sec = 0;
2731: attente.tv_nsec = GRANULARITE_us * 1000;
2732:
2733: if ((*s_etat_processus).affichage_arguments == 'Y')
2734: {
2735: printf("\n WFDATA ");
2736:
2737: if ((*s_etat_processus).langue == 'F')
2738: {
2739: printf("(attente de données d'un processus fils)\n\n");
2740: }
2741: else
2742: {
2743: printf("(wait for data from child process)\n\n");
2744: }
2745:
2746: printf(" 1: %s\n", d_PRC);
2747:
2748: return;
2749: }
2750: else if ((*s_etat_processus).test_instruction == 'Y')
2751: {
2752: (*s_etat_processus).nombre_arguments = -1;
2753: return;
2754: }
2755:
2756: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2757: {
2758: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2759: {
2760: return;
2761: }
2762: }
2763:
2764: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2765: &s_objet_argument) == d_erreur)
2766: {
2767: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2768: return;
2769: }
2770:
2771: if ((*s_objet_argument).type == PRC)
2772: {
2773: drapeau_fin = d_faux;
2774:
2775: if ((*s_etat_processus).profilage == d_vrai)
2776: {
2777: profilage(s_etat_processus, "Interprocess or interthread "
2778: "communications (WFDATA)");
2779:
2780: if ((*s_etat_processus).erreur_systeme != d_es)
2781: {
2782: return;
2783: }
2784: }
2785:
2786: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2787: {
2788: if ((*s_etat_processus).profilage == d_vrai)
2789: {
2790: profilage(s_etat_processus, NULL);
2791: }
2792:
2793: (*s_etat_processus).erreur_systeme = d_es_processus;
2794: return;
2795: }
2796:
2797: while(drapeau_fin == d_faux)
2798: {
2799: l_element_courant = (struct_liste_chainee *)
2800: (*s_etat_processus).l_base_pile_processus;
2801:
2802: while(l_element_courant != NULL)
2803: {
2804: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
2805: .donnee).objet)).thread).processus_detache == d_vrai)
2806: {
2807: if (((*(*((struct_processus_fils *) (*(*l_element_courant)
2808: .donnee).objet)).thread).pid ==
2809: (*(*((struct_processus_fils *)
2810: (*s_objet_argument).objet)).thread).pid)
2811: && ((*(*((struct_processus_fils *)
2812: (*s_objet_argument).objet)).thread)
2813: .processus_detache == d_vrai))
2814: {
2815: break;
2816: }
2817: }
2818: else
2819: {
2820: if ((pthread_equal((*(*((struct_processus_fils *)
2821: (*(*l_element_courant).donnee).objet)).thread).tid,
2822: (*(*((struct_processus_fils *) (*s_objet_argument)
2823: .objet)).thread).tid) != 0) &&
2824: ((*(*((struct_processus_fils *)
2825: (*(*l_element_courant).donnee).objet)).thread).pid
2826: == (*(*((struct_processus_fils *)
2827: (*s_objet_argument).objet)).thread).pid) &&
2828: ((*(*((struct_processus_fils *)
2829: (*s_objet_argument).objet)).thread)
2830: .processus_detache == d_faux))
2831: {
2832: break;
2833: }
2834: }
2835:
2836: l_element_courant = (*l_element_courant).suivant;
2837: }
2838:
2839: if ((*s_etat_processus).var_volatile_requete_arret != 0)
2840: {
2841: if ((*s_etat_processus).profilage == d_vrai)
2842: {
2843: profilage(s_etat_processus, NULL);
2844: }
2845:
2846: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2847: {
2848: (*s_etat_processus).erreur_systeme = d_es_processus;
2849: return;
2850: }
2851:
2852: liberation(s_etat_processus, s_objet_argument);
2853: return;
2854: }
2855:
2856: if (l_element_courant != NULL)
2857: {
2858: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
2859: (*(*l_element_courant).donnee).objet)).thread).mutex))
2860: != 0)
2861: {
2862: (*s_etat_processus).erreur_systeme = d_es_processus;
2863: return;
2864: }
2865:
2866: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
2867: .donnee).objet)).thread).nombre_objets_dans_pipe != 0)
2868: {
2869: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
2870: (*(*l_element_courant).donnee).objet)).thread)
2871: .mutex)) != 0)
2872: {
2873: (*s_etat_processus).erreur_systeme = d_es_processus;
2874: return;
2875: }
2876:
2877: drapeau_fin = d_vrai;
2878: }
2879: else
2880: {
2881: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
2882: (*(*l_element_courant).donnee).objet)).thread)
2883: .mutex)) != 0)
2884: {
2885: (*s_etat_processus).erreur_systeme = d_es_processus;
2886: return;
2887: }
2888:
2889: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2890: {
2891: if ((*s_etat_processus).profilage == d_vrai)
2892: {
2893: profilage(s_etat_processus, NULL);
2894: }
2895:
2896: (*s_etat_processus).erreur_systeme =
2897: d_es_processus;
2898: return;
2899: }
2900:
1.51 bertrand 2901: # ifndef SEMAPHORES_NOMMES
2902: if (sem_post(&((*s_etat_processus).semaphore_fork))
2903: != 0)
2904: # else
2905: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
2906: # endif
1.12 bertrand 2907: {
2908: (*s_etat_processus).erreur_systeme = d_es_processus;
2909: return;
2910: }
1.1 bertrand 2911:
2912: nanosleep(&attente, NULL);
2913:
1.51 bertrand 2914: # ifndef SEMAPHORES_NOMMES
2915: while(sem_wait(&((*s_etat_processus).semaphore_fork))
2916: != 0)
2917: # else
2918: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
2919: # endif
1.1 bertrand 2920: {
1.50 bertrand 2921: if (errno != EINTR)
2922: {
2923: (*s_etat_processus).erreur_systeme = d_es_processus;
2924: return;
2925: }
1.1 bertrand 2926: }
2927:
2928: scrutation_injection(s_etat_processus);
2929:
1.84 ! bertrand 2930: if (pthread_mutex_lock(&(*s_etat_processus)
! 2931: .mutex_interruptions) != 0)
1.83 bertrand 2932: {
2933: (*s_etat_processus).erreur_systeme = d_es_processus;
2934: return;
2935: }
2936:
1.1 bertrand 2937: if ((*s_etat_processus).nombre_interruptions_non_affectees
2938: != 0)
2939: {
2940: affectation_interruptions_logicielles(s_etat_processus);
2941: }
2942:
1.84 ! bertrand 2943: if (pthread_mutex_unlock(&(*s_etat_processus)
! 2944: .mutex_interruptions) != 0)
1.83 bertrand 2945: {
2946: (*s_etat_processus).erreur_systeme = d_es_processus;
2947: return;
2948: }
2949:
1.1 bertrand 2950: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
2951: {
2952: registre_instruction_valide =
2953: (*s_etat_processus).instruction_valide;
2954: traitement_interruptions_logicielles(s_etat_processus);
2955: (*s_etat_processus).instruction_valide =
2956: registre_instruction_valide;
2957: }
2958:
2959: if ((*s_etat_processus).var_volatile_requete_arret != 0)
2960: {
2961: if ((*s_etat_processus).profilage == d_vrai)
2962: {
2963: profilage(s_etat_processus, NULL);
2964: }
2965:
2966: return;
2967: }
2968:
2969: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2970: {
2971: if ((*s_etat_processus).profilage == d_vrai)
2972: {
2973: profilage(s_etat_processus, NULL);
2974: }
2975:
2976: (*s_etat_processus).erreur_systeme =
2977: d_es_processus;
2978: return;
2979: }
2980: }
2981: }
2982: else
2983: {
2984: drapeau_fin = d_vrai;
2985: (*s_etat_processus).erreur_execution = d_ex_processus;
2986: }
2987:
2988: INCR_GRANULARITE(attente.tv_nsec);
2989: }
2990:
2991: if ((*s_etat_processus).profilage == d_vrai)
2992: {
2993: profilage(s_etat_processus, NULL);
2994: }
2995:
2996: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2997: {
2998: (*s_etat_processus).erreur_systeme = d_es_processus;
2999: return;
3000: }
3001: }
3002: else
3003: {
3004: liberation(s_etat_processus, s_objet_argument);
3005:
3006: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3007: return;
3008: }
3009:
3010: liberation(s_etat_processus, s_objet_argument);
3011:
3012: return;
3013: }
3014:
3015:
3016: /*
3017: ================================================================================
3018: Fonction 'wfsock'
3019: ================================================================================
3020: Entrées : pointeur sur une structure struct_processus
3021: --------------------------------------------------------------------------------
3022: Sorties :
3023: --------------------------------------------------------------------------------
3024: Effets de bord : néant
3025: ================================================================================
3026: */
3027:
3028: void
3029: instruction_wfsock(struct_processus *s_etat_processus)
3030: {
3031: int erreur;
3032:
3033: logical1 drapeau;
3034:
3035: socklen_t longueur;
3036:
3037: struct_liste_chainee *l_element_courant;
3038:
3039: struct_objet *s_objet_argument;
3040: struct_objet *s_objet_resultat;
3041:
1.54 bertrand 3042: struct pollfd s_poll;
3043:
1.1 bertrand 3044: struct sockaddr_in adresse_ipv4;
1.20 bertrand 3045: # ifdef IPV6
1.1 bertrand 3046: struct sockaddr_in6 adresse_ipv6;
1.20 bertrand 3047: # endif
1.1 bertrand 3048:
3049: unsigned long i;
3050:
3051: if ((*s_etat_processus).affichage_arguments == 'Y')
3052: {
3053: printf("\n WFSOCK ");
3054:
3055: if ((*s_etat_processus).langue == 'F')
3056: {
3057: printf("(attente d'une connexion sur une socket)\n\n");
3058: }
3059: else
3060: {
3061: printf("(wait for connection on a socket)\n\n");
3062: }
3063:
3064: printf(" 1: %s\n", d_SCK);
3065: printf("-> 2: %s\n", d_SCK);
3066: printf(" 1: %s\n", d_SCK);
3067:
3068: return;
3069: }
3070: else if ((*s_etat_processus).test_instruction == 'Y')
3071: {
3072: (*s_etat_processus).nombre_arguments = -1;
3073: return;
3074: }
3075:
3076: if (test_cfsf(s_etat_processus, 31) == d_vrai)
3077: {
3078: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
3079: {
3080: return;
3081: }
3082: }
3083:
3084: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3085: &s_objet_argument) == d_erreur)
3086: {
3087: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
3088: return;
3089: }
3090:
3091: if ((*s_objet_argument).type == SCK)
3092: {
3093: if ((strcmp((*((struct_socket *) (*s_objet_argument).objet)).type,
3094: "STREAM") != 0) && (strcmp((*((struct_socket *)
3095: (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") != 0))
3096: {
1.54 bertrand 3097: // Mode non connecté : l'attente se fait sur un poll()
3098:
3099: if ((s_objet_resultat = copie_objet(s_etat_processus,
3100: s_objet_argument, 'P')) == NULL)
3101: {
3102: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3103: return;
3104: }
3105:
3106: s_poll.fd = (*((struct_socket *) (*s_objet_argument).objet)).socket;
3107: s_poll.events = POLLIN;
3108: s_poll.revents = 0;
3109:
1.55 bertrand 3110: do
1.54 bertrand 3111: {
1.55 bertrand 3112: drapeau = d_vrai;
3113:
3114: # ifndef SEMAPHORES_NOMMES
3115: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
3116: # else
3117: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
3118: # endif
3119: {
3120: (*s_etat_processus).erreur_systeme = d_es_processus;
3121: return;
3122: }
3123:
3124: if (poll(&s_poll, 1, -1) < 0)
3125: {
3126: erreur = errno;
3127:
3128: # ifndef SEMAPHORES_NOMMES
3129: while(sem_wait(&((*s_etat_processus)
3130: .semaphore_fork)) != 0)
3131: # else
3132: while(sem_wait((*s_etat_processus).semaphore_fork)
3133: != 0)
3134: # endif
3135:
3136: if (erreur != EINTR)
3137: {
3138: liberation(s_etat_processus, s_objet_argument);
3139: liberation(s_etat_processus, s_objet_resultat);
3140:
3141: (*s_etat_processus).erreur_execution =
3142: d_ex_erreur_acces_fichier;
3143: return;
3144: }
3145:
3146: scrutation_injection(s_etat_processus);
3147:
3148: if ((*s_etat_processus).var_volatile_requete_arret != 0)
3149: {
3150: drapeau = d_vrai;
3151: }
3152: else
3153: {
3154: drapeau = d_faux;
3155: }
3156: }
3157: else
1.54 bertrand 3158: {
1.55 bertrand 3159: # ifndef SEMAPHORES_NOMMES
3160: while(sem_wait(&((*s_etat_processus)
3161: .semaphore_fork)) != 0)
3162: # else
3163: while(sem_wait((*s_etat_processus).semaphore_fork)
3164: != 0)
3165: # endif
3166: {
3167: if (errno != EINTR)
3168: {
3169: (*s_etat_processus).erreur_systeme =
3170: d_es_processus;
3171: return;
3172: }
3173: }
1.54 bertrand 3174: }
1.55 bertrand 3175: } while(drapeau == d_faux);
1.54 bertrand 3176:
3177: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3178: s_objet_argument) == d_erreur)
3179: {
3180: return;
3181: }
1.1 bertrand 3182:
1.54 bertrand 3183: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3184: s_objet_resultat) == d_erreur)
3185: {
3186: return;
3187: }
1.1 bertrand 3188: }
1.54 bertrand 3189: else
1.1 bertrand 3190: {
1.54 bertrand 3191: // Mode connecté
1.1 bertrand 3192:
1.54 bertrand 3193: if ((s_objet_resultat = copie_objet(s_etat_processus,
3194: s_objet_argument, 'O')) == NULL)
3195: {
3196: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3197: return;
3198: }
1.1 bertrand 3199:
1.54 bertrand 3200: (*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';
3201: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
3202: = 'N';
1.1 bertrand 3203:
1.54 bertrand 3204: if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
3205: PF_INET)
1.1 bertrand 3206: {
1.54 bertrand 3207: longueur = sizeof(adresse_ipv4);
3208:
3209: do
3210: {
3211: drapeau = d_vrai;
1.1 bertrand 3212:
1.51 bertrand 3213: # ifndef SEMAPHORES_NOMMES
1.54 bertrand 3214: if (sem_post(&((*s_etat_processus).semaphore_fork))
3215: != 0)
1.51 bertrand 3216: # else
1.54 bertrand 3217: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1.51 bertrand 3218: # endif
1.54 bertrand 3219: {
3220: (*s_etat_processus).erreur_systeme = d_es_processus;
3221: return;
3222: }
1.1 bertrand 3223:
1.54 bertrand 3224: if (((*((struct_socket *) (*s_objet_resultat).objet))
3225: .socket = accept((*((struct_socket *)
3226: (*s_objet_argument).objet)).socket,
3227: (struct sockaddr *) &adresse_ipv4, &longueur))
3228: < 0)
3229: {
3230: erreur = errno;
1.1 bertrand 3231:
1.55 bertrand 3232: # ifndef SEMAPHORES_NOMMES
3233: while(sem_wait(&((*s_etat_processus)
3234: .semaphore_fork)) != 0)
3235: # else
3236: while(sem_wait((*s_etat_processus).semaphore_fork)
3237: != 0)
3238: # endif
1.50 bertrand 3239: {
1.54 bertrand 3240: if (errno != EINTR)
3241: {
3242: (*s_etat_processus).erreur_systeme =
3243: d_es_processus;
3244: return;
3245: }
1.50 bertrand 3246: }
1.1 bertrand 3247:
1.54 bertrand 3248: if (erreur != EINTR)
3249: {
3250: liberation(s_etat_processus, s_objet_argument);
3251: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 3252:
1.54 bertrand 3253: (*s_etat_processus).erreur_execution =
3254: d_ex_erreur_acces_fichier;
3255: return;
3256: }
1.1 bertrand 3257:
1.54 bertrand 3258: scrutation_injection(s_etat_processus);
1.1 bertrand 3259:
1.54 bertrand 3260: if ((*s_etat_processus).var_volatile_requete_arret != 0)
3261: {
3262: drapeau = d_vrai;
3263: }
3264: else
3265: {
3266: drapeau = d_faux;
3267: }
1.1 bertrand 3268: }
3269: else
3270: {
1.51 bertrand 3271: # ifndef SEMAPHORES_NOMMES
1.54 bertrand 3272: while(sem_wait(&((*s_etat_processus)
3273: .semaphore_fork)) != 0)
1.51 bertrand 3274: # else
1.54 bertrand 3275: while(sem_wait((*s_etat_processus).semaphore_fork)
3276: != 0)
1.51 bertrand 3277: # endif
1.50 bertrand 3278: {
1.54 bertrand 3279: if (errno != EINTR)
3280: {
3281: (*s_etat_processus).erreur_systeme =
3282: d_es_processus;
3283: return;
3284: }
1.50 bertrand 3285: }
1.1 bertrand 3286: }
1.54 bertrand 3287: } while(drapeau == d_faux);
3288:
3289: if (((*((struct_socket *) (*s_objet_resultat).objet))
3290: .adresse_distante = malloc(22 *
3291: sizeof(unsigned char))) == NULL)
3292: {
3293: (*s_etat_processus).erreur_systeme =
3294: d_es_allocation_memoire;
3295: return;
1.1 bertrand 3296: }
3297:
1.54 bertrand 3298: sprintf((*((struct_socket *) (*s_objet_resultat).objet))
3299: .adresse_distante, "%d.%d.%d.%d(%d)",
3300: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF,
3301: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF,
3302: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF,
3303: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF,
3304: ntohs(adresse_ipv4.sin_port));
3305: }
3306: else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
3307: PF_INET6)
1.1 bertrand 3308: {
1.20 bertrand 3309: # ifdef IPV6
1.54 bertrand 3310: longueur = sizeof(adresse_ipv6);
1.1 bertrand 3311:
1.54 bertrand 3312: do
3313: {
3314: drapeau = d_vrai;
1.1 bertrand 3315:
1.51 bertrand 3316: # ifndef SEMAPHORES_NOMMES
1.54 bertrand 3317: if (sem_post(&((*s_etat_processus).semaphore_fork))
3318: != 0)
1.51 bertrand 3319: # else
1.54 bertrand 3320: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1.51 bertrand 3321: # endif
1.54 bertrand 3322: {
3323: (*s_etat_processus).erreur_systeme = d_es_processus;
3324: return;
3325: }
1.1 bertrand 3326:
1.54 bertrand 3327: if (((*((struct_socket *) (*s_objet_resultat).objet))
3328: .socket = accept((*((struct_socket *)
3329: (*s_objet_argument).objet)).socket,
3330: (struct sockaddr *) &adresse_ipv6, &longueur)) < 0)
3331: {
3332: erreur = errno;
1.1 bertrand 3333:
1.51 bertrand 3334: # ifndef SEMAPHORES_NOMMES
1.54 bertrand 3335: while(sem_wait(&((*s_etat_processus)
3336: .semaphore_fork)) != 0)
1.51 bertrand 3337: # else
1.54 bertrand 3338: while(sem_wait((*s_etat_processus).semaphore_fork)
3339: != 0)
1.51 bertrand 3340: # endif
1.50 bertrand 3341: {
1.54 bertrand 3342: if (errno != EINTR)
3343: {
3344: (*s_etat_processus).erreur_systeme =
3345: d_es_processus;
3346: return;
3347: }
1.50 bertrand 3348: }
1.1 bertrand 3349:
1.54 bertrand 3350: if (erreur != EINTR)
3351: {
3352: liberation(s_etat_processus, s_objet_argument);
3353: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 3354:
1.54 bertrand 3355: (*s_etat_processus).erreur_execution =
3356: d_ex_erreur_acces_fichier;
3357: return;
3358: }
1.1 bertrand 3359:
1.54 bertrand 3360: scrutation_injection(s_etat_processus);
1.1 bertrand 3361:
1.54 bertrand 3362: if ((*s_etat_processus).var_volatile_requete_arret != 0)
3363: {
3364: drapeau = d_vrai;
3365: }
3366: else
3367: {
3368: drapeau = d_faux;
3369: }
1.1 bertrand 3370: }
3371: else
3372: {
1.51 bertrand 3373: # ifndef SEMAPHORES_NOMMES
1.54 bertrand 3374: while(sem_wait(&((*s_etat_processus)
3375: .semaphore_fork)) != 0)
1.51 bertrand 3376: # else
1.54 bertrand 3377: while(sem_wait((*s_etat_processus).semaphore_fork)
3378: != 0)
1.51 bertrand 3379: # endif
1.50 bertrand 3380: {
1.54 bertrand 3381: if (errno != EINTR)
3382: {
3383: (*s_etat_processus).erreur_systeme =
3384: d_es_processus;
3385: return;
3386: }
1.50 bertrand 3387: }
1.1 bertrand 3388: }
1.54 bertrand 3389: } while(drapeau == d_faux);
3390:
3391: if (((*((struct_socket *) (*s_objet_resultat).objet))
3392: .adresse_distante = malloc(55 *
3393: sizeof(unsigned char))) == NULL)
3394: {
3395: (*s_etat_processus).erreur_systeme =
3396: d_es_allocation_memoire;
3397: return;
1.1 bertrand 3398: }
3399:
1.54 bertrand 3400: (*((struct_socket *) (*s_objet_resultat).objet))
3401: .adresse_distante = d_code_fin_chaine;
1.1 bertrand 3402:
1.54 bertrand 3403: for(i = 0; i < 16; i++)
3404: {
3405: sprintf((*((struct_socket *) (*s_objet_resultat)
3406: .objet)).adresse_distante, (i == 0) ? "%s%X"
3407: : "%s:%X", (*((struct_socket *) (*s_objet_resultat)
3408: .objet)).adresse_distante,
3409: adresse_ipv6.sin6_addr.s6_addr[i]);
3410: }
1.1 bertrand 3411:
3412: sprintf((*((struct_socket *) (*s_objet_resultat)
1.54 bertrand 3413: .objet)).adresse_distante, "%s(%u)",
1.1 bertrand 3414: (*((struct_socket *) (*s_objet_resultat)
3415: .objet)).adresse_distante,
1.54 bertrand 3416: ntohs(adresse_ipv6.sin6_port));
1.20 bertrand 3417: # else
1.54 bertrand 3418: if ((*s_etat_processus).langue == 'F')
3419: {
3420: printf("+++Attention : Support du protocole"
3421: " IPv6 indisponible\n");
3422: }
3423: else
3424: {
3425: printf("+++Warning : IPv6 support "
3426: "unavailable\n");
3427: }
3428: # endif
1.22 bertrand 3429: }
3430: else
3431: {
1.54 bertrand 3432: longueur = 0;
1.1 bertrand 3433:
1.54 bertrand 3434: do
3435: {
3436: drapeau = d_vrai;
1.1 bertrand 3437:
1.51 bertrand 3438: # ifndef SEMAPHORES_NOMMES
1.54 bertrand 3439: if (sem_post(&((*s_etat_processus).semaphore_fork))
3440: != 0)
1.51 bertrand 3441: # else
1.54 bertrand 3442: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1.51 bertrand 3443: # endif
1.54 bertrand 3444: {
3445: (*s_etat_processus).erreur_systeme = d_es_processus;
3446: return;
3447: }
1.1 bertrand 3448:
1.54 bertrand 3449: if (((*((struct_socket *) (*s_objet_resultat).objet))
3450: .socket = accept((*((struct_socket *)
3451: (*s_objet_argument).objet)).socket, NULL,
3452: &longueur)) < 0)
3453: {
3454: erreur = errno;
1.1 bertrand 3455:
1.51 bertrand 3456: # ifndef SEMAPHORES_NOMMES
1.54 bertrand 3457: while(sem_wait(&((*s_etat_processus)
3458: .semaphore_fork)) != 0)
1.51 bertrand 3459: # else
1.54 bertrand 3460: while(sem_wait((*s_etat_processus).semaphore_fork)
3461: != 0)
1.51 bertrand 3462: # endif
1.50 bertrand 3463: {
1.54 bertrand 3464: if (errno != EINTR)
3465: {
3466: (*s_etat_processus).erreur_systeme =
3467: d_es_processus;
3468: return;
3469: }
1.50 bertrand 3470: }
1.1 bertrand 3471:
1.54 bertrand 3472: if (erreur != EINTR)
3473: {
3474: liberation(s_etat_processus, s_objet_argument);
3475: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 3476:
1.54 bertrand 3477: (*s_etat_processus).erreur_execution =
3478: d_ex_erreur_acces_fichier;
3479: return;
3480: }
1.1 bertrand 3481:
1.54 bertrand 3482: scrutation_injection(s_etat_processus);
1.1 bertrand 3483:
1.54 bertrand 3484: if ((*s_etat_processus).var_volatile_requete_arret != 0)
3485: {
3486: drapeau = d_vrai;
3487: }
3488: else
3489: {
3490: drapeau = d_faux;
3491: }
1.1 bertrand 3492: }
3493: else
3494: {
1.51 bertrand 3495: # ifndef SEMAPHORES_NOMMES
1.54 bertrand 3496: while(sem_wait(&((*s_etat_processus)
3497: .semaphore_fork)) != 0)
1.51 bertrand 3498: # else
1.54 bertrand 3499: while(sem_wait((*s_etat_processus).semaphore_fork)
3500: != 0)
1.51 bertrand 3501: # endif
1.50 bertrand 3502: {
1.54 bertrand 3503: if (errno != EINTR)
3504: {
3505: (*s_etat_processus).erreur_systeme =
3506: d_es_processus;
3507: return;
3508: }
1.50 bertrand 3509: }
1.1 bertrand 3510: }
1.54 bertrand 3511: } while(drapeau == d_faux);
3512: }
1.1 bertrand 3513:
1.54 bertrand 3514: // Si accept() renvoie une erreur non récupérée, il ne peut s'agir
3515: // que de EINTR sachant qu'une requête d'arrêt est en court de
3516: // traitement.
1.1 bertrand 3517:
1.54 bertrand 3518: if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)
3519: {
3520: l_element_courant = (*s_etat_processus).s_sockets;
1.1 bertrand 3521:
1.54 bertrand 3522: if (l_element_courant == NULL)
1.1 bertrand 3523: {
1.54 bertrand 3524: if (((*s_etat_processus).s_sockets =
3525: allocation_maillon(s_etat_processus)) == NULL)
3526: {
3527: (*s_etat_processus).erreur_systeme =
3528: d_es_allocation_memoire;
3529: return;
3530: }
3531:
3532: (*(*s_etat_processus).s_sockets).suivant = NULL;
3533: l_element_courant = (*s_etat_processus).s_sockets;
1.1 bertrand 3534: }
1.54 bertrand 3535: else
3536: {
3537: /*
3538: * Ajout d'un élément à la fin de la liste chaînée
3539: */
1.1 bertrand 3540:
1.54 bertrand 3541: while((*l_element_courant).suivant != NULL)
3542: {
3543: l_element_courant = (*l_element_courant).suivant;
3544: }
3545:
3546: if (((*l_element_courant).suivant =
3547: allocation_maillon(s_etat_processus)) == NULL)
3548: {
3549: (*s_etat_processus).erreur_systeme =
3550: d_es_allocation_memoire;
3551: return;
3552: }
1.1 bertrand 3553:
3554: l_element_courant = (*l_element_courant).suivant;
1.54 bertrand 3555: (*l_element_courant).suivant = NULL;
1.1 bertrand 3556: }
3557:
1.54 bertrand 3558: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
3559: s_objet_resultat, 'O')) == NULL)
1.1 bertrand 3560: {
3561: (*s_etat_processus).erreur_systeme =
3562: d_es_allocation_memoire;
3563: return;
3564: }
1.54 bertrand 3565: }
1.1 bertrand 3566:
1.54 bertrand 3567: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3568: s_objet_argument) == d_erreur)
3569: {
3570: return;
1.1 bertrand 3571: }
3572:
1.54 bertrand 3573: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3574: s_objet_resultat) == d_erreur)
1.1 bertrand 3575: {
3576: return;
3577: }
3578: }
3579: }
3580: else
3581: {
3582: liberation(s_etat_processus, s_objet_argument);
3583:
3584: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3585: return;
3586: }
3587:
3588: return;
3589: }
3590:
3591:
3592: /*
3593: ================================================================================
3594: Fonction 'wfswi'
3595: ================================================================================
3596: Entrées : pointeur sur une structure struct_processus
3597: --------------------------------------------------------------------------------
3598: Sorties :
3599: --------------------------------------------------------------------------------
3600: Effets de bord : néant
3601: ================================================================================
3602: */
3603:
3604: void
3605: instruction_wfswi(struct_processus *s_etat_processus)
3606: {
3607: integer8 interruption;
3608:
3609: logical1 drapeau_fin;
3610:
3611: struct_objet *s_objet_argument;
3612:
3613: struct timespec attente;
3614:
3615: (*s_etat_processus).erreur_execution = d_ex;
3616:
3617: attente.tv_sec = 0;
3618: attente.tv_nsec = GRANULARITE_us * 1000;
3619:
3620: if ((*s_etat_processus).affichage_arguments == 'Y')
3621: {
3622: printf("\n WFSWI ");
3623:
3624: if ((*s_etat_processus).langue == 'F')
3625: {
3626: printf("(attente d'une interruption)\n\n");
3627: }
3628: else
3629: {
3630: printf("(wait for interrupt)\n\n");
3631: }
3632:
3633: printf(" 1: %s\n", d_INT);
3634:
3635: return;
3636: }
3637: else if ((*s_etat_processus).test_instruction == 'Y')
3638: {
3639: (*s_etat_processus).nombre_arguments = -1;
3640: return;
3641: }
3642:
3643: if (test_cfsf(s_etat_processus, 31) == d_vrai)
3644: {
3645: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
3646: {
3647: return;
3648: }
3649: }
3650:
3651: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3652: &s_objet_argument) == d_erreur)
3653: {
3654: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
3655: return;
3656: }
3657:
3658: if ((*s_objet_argument).type == INT)
3659: {
3660: drapeau_fin = d_faux;
3661:
3662: interruption = (*((integer8 *) (*s_objet_argument).objet));
3663:
3664: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
3665: {
3666: liberation(s_etat_processus, s_objet_argument);
3667:
3668: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
3669: return;
3670: }
3671:
3672: while(drapeau_fin == d_faux)
3673: {
3674: if ((*s_etat_processus).var_volatile_requete_arret != 0)
3675: {
3676: liberation(s_etat_processus, s_objet_argument);
3677: return;
3678: }
3679:
1.84 ! bertrand 3680: if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
! 3681: != 0)
1.83 bertrand 3682: {
3683: (*s_etat_processus).erreur_systeme = d_es_processus;
3684: return;
3685: }
3686:
1.1 bertrand 3687: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
3688: {
3689: affectation_interruptions_logicielles(s_etat_processus);
3690: }
3691:
1.84 ! bertrand 3692: if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions)
! 3693: != 0)
1.83 bertrand 3694: {
3695: (*s_etat_processus).erreur_systeme = d_es_processus;
3696: return;
3697: }
3698:
1.1 bertrand 3699: if ((*s_etat_processus).queue_interruptions[interruption - 1] > 0)
3700: {
3701: drapeau_fin = d_vrai;
3702: }
3703: else
3704: {
3705: nanosleep(&attente, NULL);
3706: scrutation_injection(s_etat_processus);
3707: INCR_GRANULARITE(attente.tv_nsec);
3708: }
3709: }
3710: }
3711: else
3712: {
3713: liberation(s_etat_processus, s_objet_argument);
3714:
3715: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
3716: return;
3717: }
3718:
3719: liberation(s_etat_processus, s_objet_argument);
3720:
3721: return;
3722: }
3723:
3724:
3725: /*
3726: ================================================================================
3727: Fonction 'wfpoke'
3728: ================================================================================
3729: Entrées : pointeur sur une structure struct_processus
3730: --------------------------------------------------------------------------------
3731: Sorties :
3732: --------------------------------------------------------------------------------
3733: Effets de bord : néant
3734: ================================================================================
3735: */
3736:
3737: void
3738: instruction_wfpoke(struct_processus *s_etat_processus)
3739: {
3740: struct timespec attente;
3741:
3742: unsigned char registre_instruction_valide;
3743:
3744: (*s_etat_processus).erreur_execution = d_ex;
3745:
3746: attente.tv_sec = 0;
3747: attente.tv_nsec = GRANULARITE_us * 1000;
3748:
3749: if ((*s_etat_processus).affichage_arguments == 'Y')
3750: {
3751: printf("\n WFPOKE ");
3752:
3753: if ((*s_etat_processus).langue == 'F')
3754: {
3755: printf("(attente de données en provenance du processus père)\n\n");
3756: printf(" Aucun argument\n");
3757: }
3758: else
3759: {
3760: printf("(wait for data from parent process)\n\n");
3761: printf(" No argument\n");
3762: }
3763:
3764: return;
3765: }
3766: else if ((*s_etat_processus).test_instruction == 'Y')
3767: {
3768: (*s_etat_processus).nombre_arguments = -1;
3769: return;
3770: }
3771:
3772: if (test_cfsf(s_etat_processus, 31) == d_vrai)
3773: {
3774: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
3775: {
3776: return;
3777: }
3778: }
3779:
3780: if ((*s_etat_processus).presence_pipes == d_faux)
3781: {
3782: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
3783: return;
3784: }
3785:
3786: if ((*s_etat_processus).nombre_objets_injectes > 0)
3787: {
3788: return;
3789: }
3790:
3791: if ((*s_etat_processus).profilage == d_vrai)
3792: {
3793: profilage(s_etat_processus, "Interprocess or interthread "
3794: "communications (WFPOKE)");
3795:
3796: if ((*s_etat_processus).erreur_systeme != d_es)
3797: {
3798: return;
3799: }
3800: }
3801:
3802: do
3803: {
1.51 bertrand 3804: # ifndef SEMAPHORES_NOMMES
3805: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
3806: # else
3807: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
3808: # endif
1.1 bertrand 3809: {
3810: (*s_etat_processus).erreur_systeme = d_es_processus;
3811: return;
3812: }
3813:
3814: nanosleep(&attente, NULL);
3815:
1.51 bertrand 3816: # ifndef SEMAPHORES_NOMMES
3817: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
3818: # else
3819: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
3820: # endif
1.1 bertrand 3821: {
1.50 bertrand 3822: if (errno != EINTR)
3823: {
3824: (*s_etat_processus).erreur_systeme = d_es_processus;
3825: return;
3826: }
1.1 bertrand 3827: }
3828:
3829: scrutation_injection(s_etat_processus);
3830:
1.84 ! bertrand 3831: if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) != 0)
1.83 bertrand 3832: {
3833: (*s_etat_processus).erreur_systeme = d_es_processus;
3834: return;
3835: }
3836:
1.1 bertrand 3837: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
3838: {
3839: affectation_interruptions_logicielles(s_etat_processus);
3840: }
3841:
1.84 ! bertrand 3842: if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions) != 0)
1.83 bertrand 3843: {
3844: (*s_etat_processus).erreur_systeme = d_es_processus;
3845: return;
3846: }
3847:
1.1 bertrand 3848: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
3849: {
3850: registre_instruction_valide =
3851: (*s_etat_processus).instruction_valide;
3852: traitement_interruptions_logicielles(s_etat_processus);
3853: (*s_etat_processus).instruction_valide =
3854: registre_instruction_valide;
3855: }
3856:
3857: if ((*s_etat_processus).var_volatile_requete_arret != 0)
3858: {
3859: if ((*s_etat_processus).profilage == d_vrai)
3860: {
3861: profilage(s_etat_processus, NULL);
3862: }
3863:
3864: return;
3865: }
3866:
3867: INCR_GRANULARITE(attente.tv_nsec);
3868: } while((*s_etat_processus).nombre_objets_injectes == 0);
3869:
3870: return;
3871: }
3872:
3873:
3874: /*
3875: ================================================================================
3876: Fonction 'wfack'
3877: ================================================================================
3878: Entrées : pointeur sur une structure struct_processus
3879: --------------------------------------------------------------------------------
3880: Sorties :
3881: --------------------------------------------------------------------------------
3882: Effets de bord : néant
3883: ================================================================================
3884: */
3885:
3886: void
3887: instruction_wfack(struct_processus *s_etat_processus)
3888: {
3889: struct timespec attente;
3890:
3891: unsigned char registre_instruction_valide;
3892:
3893: (*s_etat_processus).erreur_execution = d_ex;
3894:
3895: attente.tv_sec = 0;
3896: attente.tv_nsec = GRANULARITE_us * 1000;
3897:
3898: if ((*s_etat_processus).affichage_arguments == 'Y')
3899: {
3900: printf("\n WFACK ");
3901:
3902: if ((*s_etat_processus).langue == 'F')
3903: {
3904: printf("(attente des acquittements de lecture)\n\n");
3905: printf(" Aucun argument\n");
3906: }
3907: else
3908: {
3909: printf("(wait for reading of data acknowledgement)\n\n");
3910: printf(" No argument\n");
3911: }
3912:
3913: return;
3914: }
3915: else if ((*s_etat_processus).test_instruction == 'Y')
3916: {
3917: (*s_etat_processus).nombre_arguments = -1;
3918: return;
3919: }
3920:
3921: if (test_cfsf(s_etat_processus, 31) == d_vrai)
3922: {
3923: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
3924: {
3925: return;
3926: }
3927: }
3928:
3929: if ((*s_etat_processus).presence_pipes == d_faux)
3930: {
3931: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
3932: return;
3933: }
3934:
3935: if ((*s_etat_processus).profilage == d_vrai)
3936: {
3937: profilage(s_etat_processus, "Interprocess or interthread communications"
3938: " (WFACK)");
3939:
3940: if ((*s_etat_processus).erreur_systeme != d_es)
3941: {
3942: return;
3943: }
3944: }
3945:
3946: while((*s_etat_processus).nombre_objets_envoyes_non_lus != 0)
3947: {
3948: scrutation_injection(s_etat_processus);
3949:
1.84 ! bertrand 3950: if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) != 0)
1.83 bertrand 3951: {
3952: (*s_etat_processus).erreur_systeme = d_es_processus;
3953: return;
3954: }
3955:
1.1 bertrand 3956: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
3957: {
3958: affectation_interruptions_logicielles(s_etat_processus);
3959: }
3960:
1.84 ! bertrand 3961: if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions) != 0)
1.83 bertrand 3962: {
3963: (*s_etat_processus).erreur_systeme = d_es_processus;
3964: return;
3965: }
3966:
1.1 bertrand 3967: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
3968: {
3969: registre_instruction_valide =
3970: (*s_etat_processus).instruction_valide;
3971: traitement_interruptions_logicielles(s_etat_processus);
3972: (*s_etat_processus).instruction_valide =
3973: registre_instruction_valide;
3974: }
3975:
3976: if ((*s_etat_processus).var_volatile_requete_arret != 0)
3977: {
3978: if ((*s_etat_processus).profilage == d_vrai)
3979: {
3980: profilage(s_etat_processus, NULL);
3981: }
3982:
3983: return;
3984: }
3985:
1.51 bertrand 3986: # ifndef SEMAPHORES_NOMMES
3987: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
3988: # else
3989: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
3990: # endif
1.12 bertrand 3991: {
3992: (*s_etat_processus).erreur_systeme = d_es_processus;
3993: return;
3994: }
1.1 bertrand 3995:
3996: nanosleep(&attente, NULL);
3997: INCR_GRANULARITE(attente.tv_nsec);
3998:
1.51 bertrand 3999: # ifndef SEMAPHORES_NOMMES
4000: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
4001: # else
4002: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
4003: # endif
1.1 bertrand 4004: {
1.50 bertrand 4005: if (errno != EINTR)
4006: {
4007: (*s_etat_processus).erreur_systeme = d_es_processus;
4008: return;
4009: }
1.1 bertrand 4010: }
4011: }
4012:
4013: if ((*s_etat_processus).profilage == d_vrai)
4014: {
4015: profilage(s_etat_processus, NULL);
4016: }
4017:
4018: return;
4019: }
4020:
4021: // vim: ts=4