1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.20
4: Copyright (C) 1989-2011 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'oct'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_oct(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 OCT ");
46:
47: if ((*s_etat_processus).langue == 'F')
48: {
49: printf("(base octale)\n\n");
50: printf(" Aucun argument\n");
51: }
52: else
53: {
54: printf("(octal base)\n\n");
55: printf(" No argument\n");
56: }
57:
58: return;
59: }
60: else if ((*s_etat_processus).test_instruction == 'Y')
61: {
62: (*s_etat_processus).nombre_arguments = -1;
63: return;
64: }
65:
66: if (test_cfsf(s_etat_processus, 31) == d_vrai)
67: {
68: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
69: {
70: return;
71: }
72: }
73:
74: sf(s_etat_processus, 43);
75: cf(s_etat_processus, 44);
76:
77: return;
78: }
79:
80:
81: /*
82: ================================================================================
83: Fonction 'over'
84: ================================================================================
85: Entrées :
86: --------------------------------------------------------------------------------
87: Sorties :
88: --------------------------------------------------------------------------------
89: Effets de bord : néant
90: ================================================================================
91: */
92:
93: void
94: instruction_over(struct_processus *s_etat_processus)
95: {
96: struct_objet *s_objet;
97:
98: (*s_etat_processus).erreur_execution = d_ex;
99:
100: if ((*s_etat_processus).affichage_arguments == 'Y')
101: {
102: printf("\n OVER ");
103:
104: if ((*s_etat_processus).langue == 'F')
105: {
106: printf("(duplication de l'objet de niveau 2)\n\n");
107: }
108: else
109: {
110: printf("(duplication of level 2 object)\n\n");
111: }
112:
113: printf(" 2: %s, %s, %s, %s, %s, %s,\n"
114: " %s, %s, %s, %s, %s,\n"
115: " %s, %s, %s, %s, %s,\n"
116: " %s, %s, %s, %s,\n"
117: " %s, %s\n",
118: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
119: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
120: d_SQL, d_SLB, d_PRC, d_MTX);
121: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
122: " %s, %s, %s, %s, %s,\n"
123: " %s, %s, %s, %s, %s,\n"
124: " %s, %s, %s, %s,\n"
125: " %s, %s\n",
126: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
127: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
128: d_SQL, d_SLB, d_PRC, d_MTX);
129: printf("-> 3: %s, %s, %s, %s, %s, %s,\n"
130: " %s, %s, %s, %s, %s,\n"
131: " %s, %s, %s, %s, %s,\n"
132: " %s, %s, %s, %s,\n"
133: " %s, %s\n",
134: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
135: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
136: d_SQL, d_SLB, d_PRC, d_MTX);
137: printf(" ...\n");
138: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
139: " %s, %s, %s, %s, %s,\n"
140: " %s, %s, %s, %s, %s,\n"
141: " %s, %s, %s, %s,\n"
142: " %s, %s\n",
143: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
144: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
145: d_SQL, d_SLB, d_PRC, d_MTX);
146:
147: return;
148: }
149: else if ((*s_etat_processus).test_instruction == 'Y')
150: {
151: (*s_etat_processus).nombre_arguments = -1;
152: return;
153: }
154:
155: if (test_cfsf(s_etat_processus, 31) == d_vrai)
156: {
157: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
158: {
159: return;
160: }
161: }
162:
163: if ((*s_etat_processus).hauteur_pile_operationnelle < 2)
164: {
165: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
166: return;
167: }
168:
169: s_objet = copie_objet(s_etat_processus,
170: (*(*(*s_etat_processus).l_base_pile).suivant).donnee, 'P');
171:
172: if (s_objet == NULL)
173: {
174: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
175: return;
176: }
177:
178: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
179: s_objet) == d_erreur)
180: {
181: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
182: return;
183: }
184:
185: return;
186: }
187:
188:
189: /*
190: ================================================================================
191: Fonction 'or'
192: ================================================================================
193: Entrées : pointeur sur une structure struct_processus
194: --------------------------------------------------------------------------------
195: Sorties :
196: --------------------------------------------------------------------------------
197: Effets de bord : néant
198: ================================================================================
199: */
200:
201: void
202: instruction_or(struct_processus *s_etat_processus)
203: {
204: struct_liste_chainee *l_element_courant;
205: struct_liste_chainee *l_element_precedent;
206:
207: struct_objet *s_copie_argument_1;
208: struct_objet *s_copie_argument_2;
209: struct_objet *s_objet_argument_1;
210: struct_objet *s_objet_argument_2;
211: struct_objet *s_objet_resultat;
212:
213: unsigned long nombre_elements;
214:
215: (*s_etat_processus).erreur_execution = d_ex;
216:
217: if ((*s_etat_processus).affichage_arguments == 'Y')
218: {
219: printf("\n OR ");
220:
221: if ((*s_etat_processus).langue == 'F')
222: {
223: printf("(opérateur ou)\n\n");
224: }
225: else
226: {
227: printf("(or operator)\n\n");
228: }
229:
230: printf(" 2: %s, %s\n", d_INT, d_REL);
231: printf(" 1: %s, %s\n", d_INT, d_REL);
232: printf("-> 1: %s\n\n", d_INT);
233:
234: printf(" 2: %s\n", d_BIN);
235: printf(" 1: %s\n", d_BIN);
236: printf("-> 1: %s\n\n", d_BIN);
237:
238: printf(" 2: %s\n", d_NOM);
239: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
240: printf("-> 1: %s\n\n", d_ALG);
241:
242: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
243: printf(" 1: %s\n", d_NOM);
244: printf("-> 1: %s\n\n", d_ALG);
245:
246: printf(" 2: %s\n", d_ALG);
247: printf(" 1: %s\n", d_ALG);
248: printf("-> 1: %s\n\n", d_ALG);
249:
250: printf(" 2: %s\n", d_RPN);
251: printf(" 1: %s\n", d_RPN);
252: printf("-> 1: %s\n", d_RPN);
253:
254: return;
255: }
256: else if ((*s_etat_processus).test_instruction == 'Y')
257: {
258: (*s_etat_processus).nombre_arguments = 0;
259: return;
260: }
261:
262: if (test_cfsf(s_etat_processus, 31) == d_vrai)
263: {
264: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
265: {
266: return;
267: }
268: }
269:
270: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
271: &s_objet_argument_1) == d_erreur)
272: {
273: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
274: return;
275: }
276:
277: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
278: &s_objet_argument_2) == d_erreur)
279: {
280: liberation(s_etat_processus, s_objet_argument_1);
281:
282: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
283: return;
284: }
285:
286: /*
287: --------------------------------------------------------------------------------
288: OR logique
289: --------------------------------------------------------------------------------
290: */
291:
292: if ((((*s_objet_argument_1).type == INT) ||
293: ((*s_objet_argument_1).type == REL)) &&
294: (((*s_objet_argument_2).type == INT) ||
295: ((*s_objet_argument_2).type == REL)))
296: {
297: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
298: {
299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
300: return;
301: }
302:
303: if ((*s_objet_argument_1).type == INT)
304: {
305: if ((*s_objet_argument_2).type == INT)
306: {
307: if (((*((integer8 *) (*s_objet_argument_1).objet)) != 0) ||
308: ((*((integer8 *) (*s_objet_argument_2).objet)) != 0))
309: {
310: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
311: }
312: else
313: {
314: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
315: }
316: }
317: else
318: {
319: if (((*((integer8 *) (*s_objet_argument_1).objet)) != 0) ||
320: ((*((real8 *) (*s_objet_argument_2).objet)) != 0))
321: {
322: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
323: }
324: else
325: {
326: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
327: }
328: }
329: }
330: else
331: {
332: if ((*s_objet_argument_2).type == INT)
333: {
334: if (((*((real8 *) (*s_objet_argument_1).objet)) != 0) ||
335: ((*((integer8 *) (*s_objet_argument_2).objet)) != 0))
336: {
337: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
338: }
339: else
340: {
341: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
342: }
343: }
344: else
345: {
346: if (((*((real8 *) (*s_objet_argument_1).objet)) != 0) ||
347: ((*((real8 *) (*s_objet_argument_2).objet)) != 0))
348: {
349: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
350: }
351: else
352: {
353: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
354: }
355: }
356: }
357: }
358:
359: /*
360: --------------------------------------------------------------------------------
361: OR binaire
362: --------------------------------------------------------------------------------
363: */
364:
365: else if (((*s_objet_argument_1).type == BIN) &&
366: ((*s_objet_argument_2).type == BIN))
367: {
368: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
369: {
370: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
371: return;
372: }
373:
374: (*((logical8 *) (*s_objet_resultat).objet)) =
375: (*((logical8 *) (*s_objet_argument_1).objet)) |
376: (*((logical8 *) (*s_objet_argument_2).objet));
377: }
378:
379: /*
380: --------------------------------------------------------------------------------
381: OR entre des arguments complexes
382: --------------------------------------------------------------------------------
383: */
384:
385: /*
386: * Nom ou valeur numérique / Nom ou valeur numérique
387: */
388:
389: else if ((((*s_objet_argument_1).type == NOM) &&
390: (((*s_objet_argument_2).type == NOM) ||
391: ((*s_objet_argument_2).type == INT) ||
392: ((*s_objet_argument_2).type == REL))) ||
393: (((*s_objet_argument_2).type == NOM) &&
394: (((*s_objet_argument_1).type == INT) ||
395: ((*s_objet_argument_1).type == REL))))
396: {
397: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
398: {
399: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
400: return;
401: }
402:
403: if (((*s_objet_resultat).objet =
404: allocation_maillon(s_etat_processus)) == NULL)
405: {
406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
407: return;
408: }
409:
410: l_element_courant = (*s_objet_resultat).objet;
411:
412: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
413: == NULL)
414: {
415: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
416: return;
417: }
418:
419: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
420: .nombre_arguments = 0;
421: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
422: .fonction = instruction_vers_niveau_superieur;
423:
424: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
425: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
426: {
427: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
428: return;
429: }
430:
431: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
432: .nom_fonction, "<<");
433:
434: if (((*l_element_courant).suivant =
435: allocation_maillon(s_etat_processus)) == NULL)
436: {
437: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
438: return;
439: }
440:
441: l_element_courant = (*l_element_courant).suivant;
442: (*l_element_courant).donnee = s_objet_argument_2;
443:
444: if (((*l_element_courant).suivant =
445: allocation_maillon(s_etat_processus)) == NULL)
446: {
447: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
448: return;
449: }
450:
451: l_element_courant = (*l_element_courant).suivant;
452: (*l_element_courant).donnee = s_objet_argument_1;
453:
454: if (((*l_element_courant).suivant =
455: allocation_maillon(s_etat_processus)) == NULL)
456: {
457: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
458: return;
459: }
460:
461: l_element_courant = (*l_element_courant).suivant;
462:
463: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
464: == NULL)
465: {
466: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
467: return;
468: }
469:
470: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
471: .nombre_arguments = 0;
472: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
473: .fonction = instruction_or;
474:
475: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
476: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
477: {
478: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
479: return;
480: }
481:
482: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
483: .nom_fonction, "OR");
484:
485: if (((*l_element_courant).suivant =
486: allocation_maillon(s_etat_processus)) == NULL)
487: {
488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
489: return;
490: }
491:
492: l_element_courant = (*l_element_courant).suivant;
493:
494: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
495: == NULL)
496: {
497: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
498: return;
499: }
500:
501: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
502: .nombre_arguments = 0;
503: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
504: .fonction = instruction_vers_niveau_inferieur;
505:
506: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
507: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
508: {
509: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
510: return;
511: }
512:
513: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
514: .nom_fonction, ">>");
515:
516: (*l_element_courant).suivant = NULL;
517:
518: s_objet_argument_1 = NULL;
519: s_objet_argument_2 = NULL;
520: }
521:
522: /*
523: * Nom ou valeur numérique / Expression
524: */
525:
526: else if ((((*s_objet_argument_1).type == ALG) ||
527: ((*s_objet_argument_1).type == RPN)) &&
528: (((*s_objet_argument_2).type == NOM) ||
529: ((*s_objet_argument_2).type == INT) ||
530: ((*s_objet_argument_2).type == REL)))
531: {
532: nombre_elements = 0;
533: l_element_courant = (struct_liste_chainee *)
534: (*s_objet_argument_1).objet;
535:
536: while(l_element_courant != NULL)
537: {
538: nombre_elements++;
539: l_element_courant = (*l_element_courant).suivant;
540: }
541:
542: if (nombre_elements == 2)
543: {
544: liberation(s_etat_processus, s_objet_argument_1);
545: liberation(s_etat_processus, s_objet_argument_2);
546:
547: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
548: return;
549: }
550:
551: if ((s_objet_resultat = copie_objet(s_etat_processus,
552: s_objet_argument_1, 'N')) == NULL)
553: {
554: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
555: return;
556: }
557:
558: l_element_courant = (struct_liste_chainee *)
559: (*s_objet_resultat).objet;
560: l_element_precedent = l_element_courant;
561: l_element_courant = (*l_element_courant).suivant;
562:
563: if (((*l_element_precedent).suivant =
564: allocation_maillon(s_etat_processus)) == NULL)
565: {
566: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
567: return;
568: }
569:
570: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
571: (*(*l_element_precedent).suivant).suivant = l_element_courant;
572:
573: while((*l_element_courant).suivant != NULL)
574: {
575: l_element_precedent = l_element_courant;
576: l_element_courant = (*l_element_courant).suivant;
577: }
578:
579: if (((*l_element_precedent).suivant =
580: allocation_maillon(s_etat_processus)) == NULL)
581: {
582: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
583: return;
584: }
585:
586: if (((*(*l_element_precedent).suivant).donnee =
587: allocation(s_etat_processus, FCT)) == NULL)
588: {
589: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
590: return;
591: }
592:
593: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
594: .donnee).objet)).nombre_arguments = 0;
595: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
596: .donnee).objet)).fonction = instruction_or;
597:
598: if (((*((struct_fonction *) (*(*(*l_element_precedent)
599: .suivant).donnee).objet)).nom_fonction =
600: malloc(3 * sizeof(unsigned char))) == NULL)
601: {
602: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
603: return;
604: }
605:
606: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
607: .suivant).donnee).objet)).nom_fonction, "OR");
608:
609: (*(*l_element_precedent).suivant).suivant = l_element_courant;
610:
611: s_objet_argument_2 = NULL;
612: }
613:
614: /*
615: * Expression / Nom ou valeur numérique
616: */
617:
618: else if ((((*s_objet_argument_1).type == NOM) ||
619: ((*s_objet_argument_1).type == INT) ||
620: ((*s_objet_argument_1).type == REL)) &&
621: (((*s_objet_argument_2).type == ALG) ||
622: ((*s_objet_argument_2).type == RPN)))
623: {
624: nombre_elements = 0;
625: l_element_courant = (struct_liste_chainee *)
626: (*s_objet_argument_2).objet;
627:
628: while(l_element_courant != NULL)
629: {
630: nombre_elements++;
631: l_element_courant = (*l_element_courant).suivant;
632: }
633:
634: if (nombre_elements == 2)
635: {
636: liberation(s_etat_processus, s_objet_argument_1);
637: liberation(s_etat_processus, s_objet_argument_2);
638:
639: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
640: return;
641: }
642:
643: if ((s_objet_resultat = copie_objet(s_etat_processus,
644: s_objet_argument_2, 'N')) == NULL)
645: {
646: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
647: return;
648: }
649:
650: l_element_courant = (struct_liste_chainee *)
651: (*s_objet_resultat).objet;
652: l_element_precedent = l_element_courant;
653:
654: while((*l_element_courant).suivant != NULL)
655: {
656: l_element_precedent = l_element_courant;
657: l_element_courant = (*l_element_courant).suivant;
658: }
659:
660: if (((*l_element_precedent).suivant =
661: allocation_maillon(s_etat_processus)) == NULL)
662: {
663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
664: return;
665: }
666:
667: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
668: l_element_precedent = (*l_element_precedent).suivant;
669:
670: if (((*l_element_precedent).suivant =
671: allocation_maillon(s_etat_processus)) == NULL)
672: {
673: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
674: return;
675: }
676:
677: if (((*(*l_element_precedent).suivant).donnee =
678: allocation(s_etat_processus, FCT)) == NULL)
679: {
680: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
681: return;
682: }
683:
684: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
685: .donnee).objet)).nombre_arguments = 0;
686: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
687: .donnee).objet)).fonction = instruction_or;
688:
689: if (((*((struct_fonction *) (*(*(*l_element_precedent)
690: .suivant).donnee).objet)).nom_fonction =
691: malloc(3 * sizeof(unsigned char))) == NULL)
692: {
693: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
694: return;
695: }
696:
697: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
698: .suivant).donnee).objet)).nom_fonction, "OR");
699:
700: (*(*l_element_precedent).suivant).suivant = l_element_courant;
701:
702: s_objet_argument_1 = NULL;
703: }
704:
705: /*
706: * Expression / Expression
707: */
708:
709: else if ((((*s_objet_argument_1).type == ALG) &&
710: ((*s_objet_argument_2).type == ALG)) ||
711: (((*s_objet_argument_1).type == RPN) &&
712: ((*s_objet_argument_2).type == RPN)))
713: {
714: nombre_elements = 0;
715: l_element_courant = (struct_liste_chainee *)
716: (*s_objet_argument_1).objet;
717:
718: while(l_element_courant != NULL)
719: {
720: nombre_elements++;
721: l_element_courant = (*l_element_courant).suivant;
722: }
723:
724: if (nombre_elements == 2)
725: {
726: liberation(s_etat_processus, s_objet_argument_1);
727: liberation(s_etat_processus, s_objet_argument_2);
728:
729: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
730: return;
731: }
732:
733: nombre_elements = 0;
734: l_element_courant = (struct_liste_chainee *)
735: (*s_objet_argument_2).objet;
736:
737: while(l_element_courant != NULL)
738: {
739: nombre_elements++;
740: l_element_courant = (*l_element_courant).suivant;
741: }
742:
743: if (nombre_elements == 2)
744: {
745: liberation(s_etat_processus, s_objet_argument_1);
746: liberation(s_etat_processus, s_objet_argument_2);
747:
748: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
749: return;
750: }
751:
752: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
753: s_objet_argument_1, 'N')) == NULL)
754: {
755: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
756: return;
757: }
758:
759: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
760: s_objet_argument_2, 'N')) == NULL)
761: {
762: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
763: return;
764: }
765:
766: l_element_courant = (struct_liste_chainee *)
767: (*s_copie_argument_1).objet;
768: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
769: (*s_copie_argument_1).objet)).suivant;
770:
771: liberation(s_etat_processus, (*l_element_courant).donnee);
772: free(l_element_courant);
773:
774: l_element_courant = (struct_liste_chainee *)
775: (*s_copie_argument_2).objet;
776: l_element_precedent = l_element_courant;
777: s_objet_resultat = s_copie_argument_2;
778:
779: while((*l_element_courant).suivant != NULL)
780: {
781: l_element_precedent = l_element_courant;
782: l_element_courant = (*l_element_courant).suivant;
783: }
784:
785: liberation(s_etat_processus, (*l_element_courant).donnee);
786: free(l_element_courant);
787:
788: (*l_element_precedent).suivant = (struct_liste_chainee *)
789: (*s_copie_argument_1).objet;
790: free(s_copie_argument_1);
791:
792: l_element_courant = (*l_element_precedent).suivant;
793: while((*l_element_courant).suivant != NULL)
794: {
795: l_element_precedent = l_element_courant;
796: l_element_courant = (*l_element_courant).suivant;
797: }
798:
799: if (((*l_element_precedent).suivant =
800: allocation_maillon(s_etat_processus)) == NULL)
801: {
802: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
803: return;
804: }
805:
806: (*(*l_element_precedent).suivant).suivant = l_element_courant;
807: l_element_courant = (*l_element_precedent).suivant;
808:
809: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
810: == NULL)
811: {
812: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
813: return;
814: }
815:
816: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
817: .nombre_arguments = 0;
818: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
819: .fonction = instruction_or;
820:
821: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
822: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
823: {
824: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
825: return;
826: }
827:
828: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
829: .nom_fonction, "OR");
830: }
831:
832: /*
833: --------------------------------------------------------------------------------
834: OR impossible
835: --------------------------------------------------------------------------------
836: */
837:
838: else
839: {
840: liberation(s_etat_processus, s_objet_argument_1);
841: liberation(s_etat_processus, s_objet_argument_2);
842:
843: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
844: return;
845: }
846:
847: liberation(s_etat_processus, s_objet_argument_1);
848: liberation(s_etat_processus, s_objet_argument_2);
849:
850: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
851: s_objet_resultat) == d_erreur)
852: {
853: return;
854: }
855:
856: return;
857: }
858:
859:
860: /*
861: ================================================================================
862: Fonction 'open'
863: ================================================================================
864: Entrées : pointeur sur une structure struct_processus
865: --------------------------------------------------------------------------------
866: Sorties :
867: --------------------------------------------------------------------------------
868: Effets de bord : néant
869: ================================================================================
870: */
871:
872: void
873: instruction_open(struct_processus *s_etat_processus)
874: {
875: /*
876: * Type d'ouverture :
877: * NEW : crée un nouveau fichier, retourne une erreur si un fichier
878: * préexiste ;
879: * OLD : ouvre un fichier existant, retourne une erreur si le fichier
880: * n'existe pas ;
881: * REPLACE : remplace un fichier existant, retourne une erreur s'il n'y
882: * a aucun fichier à effacer ;
883: * UNKNOWN : ouvre un fichier existant ou crée un nouveau fichier ;
884: * SCRATCH : crée un fichier temporaire automatiquement effacé lors
885: * de sa fermeture (protection automatique 'readwrite');
886: *
887: * Type d'accès :
888: * SEQUENTIAL : accès séquentiel ;
889: * DIRECT : accès direct ;
890: * KEYED : accès indexé.
891: *
892: * Protection :
893: * READONLY : lecture seule ;
894: * WRITEONLY : écriture seule ;
895: * READWRITE : lecture et écriture autorisées.
896: *
897: * Format :
898: * FORMATTED : fichier texte ;
899: * UNFORMATTED : fichier binaire.
900: */
901:
902: file *descripteur;
903:
904: int buffer_emission;
905: int buffer_reception;
906: int drapeau;
907: int priorite;
908: int protocole_numerique;
909: int timeout_emission;
910: int timeout_reception;
911: int type;
912:
913: integer8 adresse[16];
914: integer8 nombre_maximal_connexions;
915: integer8 port;
916: integer8 position_clef;
917:
918: logical1 erreur;
919: logical1 existence;
920: logical1 ouverture;
921: logical1 presence_port;
922:
923: sqlite3 *sqlite;
924:
925: struct_liste_chainee *l_element_courant;
926: struct_liste_chainee *l_element_courant_sous_objet;
927:
928: struct flock lock;
929:
930: struct addrinfo *resolution;
931: struct addrinfo *resolution_courante;
932:
933: struct protoent *s_protocole;
934:
935: struct sockaddr_un socket_unix;
936: struct sockaddr_in socket_ipv4;
937: # ifdef IPV6
938: struct sockaddr_in6 socket_ipv6;
939: # endif
940:
941: struct_objet *s_objet_argument;
942: struct_objet *s_objet_resultat;
943:
944: uint32_t adresse_ipv4;
945:
946: unsigned char *argument_majuscule;
947: unsigned char *chaine_descripteurs;
948: unsigned char format;
949: unsigned char *hote;
950: unsigned char *nom;
951: unsigned char *nom_temporaire;
952: unsigned char options[12];
953: unsigned char *peripherique;
954: unsigned char *pointeur;
955: unsigned char protection;
956: unsigned char protocole[16 + 1];
957: unsigned char *protocole_socket;
958: unsigned char type_acces;
959: unsigned char type_adresse;
960: unsigned char type_arguments;
961: unsigned char type_domaine;
962: unsigned char type_ouverture;
963: unsigned char type_socket;
964:
965: unsigned long i;
966: unsigned long nombre_elements;
967: unsigned long prochain_descripteur;
968: unsigned long unite;
969:
970: # define d_BIND_TO_DEVICE 0
971: # define d_BROADCAST 1
972: # define d_DONT_ROUTE 2
973: # define d_KEEP_ALIVE 3
974: # define d_PRIORITY 4
975: # define d_RECEIVE_BUFFER 5
976: # define d_FORCE_RECEIVE_BUFFER 6
977: # define d_SEND_BUFFER 7
978: # define d_FORCE_SEND_BUFFER 8
979: # define d_RECEIVING_TIMEOUT 9
980: # define d_SENDING_TIMEOUT 10
981: # define d_REUSE_ADDRESS 11
982:
983: /*
984: * Argument : { "ouverture" "accès" "format" [ { "nom" } 'protection' ] }
985: */
986:
987: (*s_etat_processus).erreur_execution = d_ex;
988:
989: if ((*s_etat_processus).affichage_arguments == 'Y')
990: {
991: printf("\n OPEN ");
992:
993: if ((*s_etat_processus).langue == 'F')
994: {
995: printf("(ouverture d'un fichier, d'une socket ou d'un sémaphore)"
996: "\n\n");
997: }
998: else
999: {
1000: printf("(open file, socket or semaphore)\n\n");
1001: }
1002:
1003: printf(" 1: %s\n", d_LST);
1004: printf("-> 1: %s, %s\n\n", d_FCH, d_SCK);
1005:
1006: printf(" 1: %s\n", d_CHN);
1007: printf("-> 1: %s\n\n", d_SPH);
1008:
1009: if ((*s_etat_processus).langue == 'F')
1010: {
1011: printf(" Utilisation :\n\n");
1012: }
1013: else
1014: {
1015: printf(" Usage:\n\n");
1016: }
1017:
1018: printf(" { \"filetype\" \"access\" \"format\" { \"name\" "
1019: "\"file name\" } \"protection\" } OPEN\n");
1020: printf(" { \"sockettype\" { \"name\" \"local name\" } } OPEN\n");
1021: printf(" { \"sockettype\" \"socketdomain\" \"protection\" } OPEN\n");
1022: printf(" \"/semaphore\" OPEN\n");
1023:
1024: printf(" File type : NEW/OLD/REPLACE/UNKNOWN/SCRATCH\n");
1025: printf(" File access : SEQUENTIAL/DIRECT/KEYED\n");
1026: printf(" Socket type : STREAM/DATAGRAM/RAW/"
1027: "ROBUST DATAGRAM/SEQUENTIAL DATAGRAM\n");
1028: printf(" Socket domain : LOCAL/FOREIGN\n");
1029: printf(" Socket protocol : IPV4/IPV6/UNIX\n");
1030: printf(" Format : FORMATTED/UNFORMATTED/FLOW\n");
1031: printf(" Protection : READONLY/WRITEONLY/READWRITE\n\n");
1032:
1033: printf(" Address : { \"ADDRESS\" [ 127 0 0 1 ] }\n");
1034: printf(" { \"HOST\" \"hostname\" }\n");
1035: printf(" Connections : { \"LISTEN\" amount of connections }\n");
1036: printf(" Name : { \"NAME\" \"filename\" }\n");
1037: printf(" Options : { \"OPTION\" \"option\" argument }\n");
1038: printf(" \"BIND TO DEVICE\" \"device\"\n");
1039: printf(" \"BROADCAST\"\n");
1040: printf(" \"DO NOT ROUTE\"\n");
1041: printf(" \"KEEP ALIVE\"\n");
1042: printf(" \"PRIORITY\" integer\n");
1043: printf(" \"RECEIVE BUFFER\" integer\n");
1044: printf(" \"FORCE RECEIVE BUFFER\" integer\n");
1045: printf(" \"SEND BUFFER\" integer\n");
1046: printf(" \"FORCE SEND BUFFER\" integer\n");
1047: printf(" \"RECEIVING TIMEOUT\" integer\n");
1048: printf(" \"SENDING TIMEOUT\" integer\n");
1049: printf(" \"REUSE ADDRESS\"\n");
1050: printf(" Port : { \"PORT\" port number }\n");
1051: printf(" Protocol : { \"PROTOCOL\" \"protocol\" }\n\n");
1052:
1053: printf(" { { \"NAME\" \"filename\" } } OPEN\n");
1054: printf(" { \"SCRATCH\" } OPEN\n");
1055: printf(" { { \"NAME\" \"filename\" } \"UNKNOWN\" \"FORMATTED\" "
1056: "\"DIRECT\" } OPEN\n");
1057: printf(" { { \"NAME\" \"filename\" } \"OLD\" \"FORMATTED\" "
1058: "\"KEYED\" { \"KEY\" 2 } } OPEN\n");
1059: printf(" { \"STREAM\" \"READWRITE\" } OPEN\n");
1060: printf(" { \"FOREIGN\" \"DATAGRAM\" } OPEN\n");
1061: printf(" { \"LOCAL\" { \"NAME\" \"socket.sock\" } } OPEN\n");
1062:
1063: return;
1064: }
1065: else if ((*s_etat_processus).test_instruction == 'Y')
1066: {
1067: (*s_etat_processus).nombre_arguments = -1;
1068: return;
1069: }
1070:
1071: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1072: {
1073: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1074: {
1075: return;
1076: }
1077: }
1078:
1079: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1080: &s_objet_argument) == d_erreur)
1081: {
1082: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1083: return;
1084: }
1085:
1086: if ((*s_objet_argument).type == LST)
1087: {
1088: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
1089:
1090: if (l_element_courant == NULL)
1091: {
1092: liberation(s_etat_processus, s_objet_argument);
1093:
1094: (*s_etat_processus).erreur_execution =
1095: d_ex_erreur_parametre_fichier;
1096: return;
1097: }
1098:
1099: format = ' ';
1100: type_domaine = ' ';
1101: type_ouverture = ' ';
1102: protection = ' ';
1103: type_acces = ' ';
1104: type_socket = ' ';
1105: nom = NULL;
1106: position_clef = 0;
1107: port = 0;
1108: type_arguments = ' ';
1109: nombre_maximal_connexions = 0;
1110: hote = NULL;
1111: type_adresse = ' ';
1112: protocole[0] = d_code_fin_chaine;
1113: protocole_socket = NULL;
1114: presence_port = d_faux;
1115: peripherique = NULL;
1116: priorite = 0;
1117: buffer_emission = 0;
1118: buffer_reception = 0;
1119: timeout_emission = 0;
1120: timeout_reception = 0;
1121: drapeau = -1;
1122:
1123: for(i = 0; i < 12; options[i++] = 'N');
1124:
1125: while(l_element_courant != NULL)
1126: {
1127: if ((*(*l_element_courant).donnee).type == CHN)
1128: {
1129: if ((argument_majuscule = conversion_majuscule((unsigned char *)
1130: (*(*l_element_courant).donnee).objet)) == NULL)
1131: {
1132: (*s_etat_processus).erreur_systeme =
1133: d_es_allocation_memoire;
1134: return;
1135: }
1136:
1137: if (strcmp(argument_majuscule, "NEW") == 0)
1138: {
1139: if (type_ouverture != ' ')
1140: {
1141: liberation(s_etat_processus, s_objet_argument);
1142: free(argument_majuscule);
1143:
1144: (*s_etat_processus).erreur_execution =
1145: d_ex_erreur_parametre_fichier;
1146: return;
1147: }
1148:
1149: if (type_arguments == ' ')
1150: {
1151: type_arguments = 'F';
1152: }
1153: else if (type_arguments == 'S')
1154: {
1155: liberation(s_etat_processus, s_objet_argument);
1156: free(argument_majuscule);
1157:
1158: (*s_etat_processus).erreur_execution =
1159: d_ex_erreur_parametre_fichier;
1160: return;
1161: }
1162:
1163: type_ouverture = 'N';
1164: }
1165: else if (strcmp(argument_majuscule, "REPLACE") == 0)
1166: {
1167: if (type_ouverture != ' ')
1168: {
1169: liberation(s_etat_processus, s_objet_argument);
1170: free(argument_majuscule);
1171:
1172: (*s_etat_processus).erreur_execution =
1173: d_ex_erreur_parametre_fichier;
1174: return;
1175: }
1176:
1177: if (type_arguments == ' ')
1178: {
1179: type_arguments = 'F';
1180: }
1181: else if (type_arguments == 'S')
1182: {
1183: liberation(s_etat_processus, s_objet_argument);
1184: free(argument_majuscule);
1185:
1186: (*s_etat_processus).erreur_execution =
1187: d_ex_erreur_parametre_fichier;
1188: return;
1189: }
1190:
1191: type_ouverture = 'R';
1192: }
1193: else if (strcmp(argument_majuscule, "UNKNOWN") == 0)
1194: {
1195: if (type_ouverture != ' ')
1196: {
1197: liberation(s_etat_processus, s_objet_argument);
1198: free(argument_majuscule);
1199:
1200: (*s_etat_processus).erreur_execution =
1201: d_ex_erreur_parametre_fichier;
1202: return;
1203: }
1204:
1205: if (type_arguments == ' ')
1206: {
1207: type_arguments = 'F';
1208: }
1209: else if (type_arguments == 'S')
1210: {
1211: liberation(s_etat_processus, s_objet_argument);
1212: free(argument_majuscule);
1213:
1214: (*s_etat_processus).erreur_execution =
1215: d_ex_erreur_parametre_fichier;
1216: return;
1217: }
1218:
1219: type_ouverture = 'U';
1220: }
1221: else if (strcmp(argument_majuscule, "SCRATCH") == 0)
1222: {
1223: if (type_ouverture != ' ')
1224: {
1225: liberation(s_etat_processus, s_objet_argument);
1226: free(argument_majuscule);
1227:
1228: (*s_etat_processus).erreur_execution =
1229: d_ex_erreur_parametre_fichier;
1230: return;
1231: }
1232:
1233: if (type_arguments == ' ')
1234: {
1235: type_arguments = 'F';
1236: }
1237: else if (type_arguments == 'S')
1238: {
1239: liberation(s_etat_processus, s_objet_argument);
1240: free(argument_majuscule);
1241:
1242: (*s_etat_processus).erreur_execution =
1243: d_ex_erreur_parametre_fichier;
1244: return;
1245: }
1246:
1247: type_ouverture = 'S';
1248: }
1249: else if (strcmp(argument_majuscule, "SEQUENTIAL") == 0)
1250: {
1251: if (type_acces != ' ')
1252: {
1253: liberation(s_etat_processus, s_objet_argument);
1254: free(argument_majuscule);
1255:
1256: (*s_etat_processus).erreur_execution =
1257: d_ex_erreur_parametre_fichier;
1258: return;
1259: }
1260:
1261: if (type_arguments == ' ')
1262: {
1263: type_arguments = 'F';
1264: }
1265: else if (type_arguments == 'S')
1266: {
1267: liberation(s_etat_processus, s_objet_argument);
1268: free(argument_majuscule);
1269:
1270: (*s_etat_processus).erreur_execution =
1271: d_ex_erreur_parametre_fichier;
1272: return;
1273: }
1274:
1275: type_acces = 'S';
1276: }
1277: else if (strcmp(argument_majuscule, "DIRECT") == 0)
1278: {
1279: if (type_acces != ' ')
1280: {
1281: liberation(s_etat_processus, s_objet_argument);
1282: free(argument_majuscule);
1283:
1284: (*s_etat_processus).erreur_execution =
1285: d_ex_erreur_parametre_fichier;
1286: return;
1287: }
1288:
1289: if (type_arguments == ' ')
1290: {
1291: type_arguments = 'F';
1292: }
1293: else if (type_arguments == 'S')
1294: {
1295: liberation(s_etat_processus, s_objet_argument);
1296: free(argument_majuscule);
1297:
1298: (*s_etat_processus).erreur_execution =
1299: d_ex_erreur_parametre_fichier;
1300: return;
1301: }
1302:
1303: type_acces = 'D';
1304: }
1305: else if (strcmp(argument_majuscule, "KEYED") == 0)
1306: {
1307: if (type_acces != ' ')
1308: {
1309: liberation(s_etat_processus, s_objet_argument);
1310: free(argument_majuscule);
1311:
1312: (*s_etat_processus).erreur_execution =
1313: d_ex_erreur_parametre_fichier;
1314: return;
1315: }
1316:
1317: if (type_arguments == ' ')
1318: {
1319: type_arguments = 'F';
1320: }
1321: else if (type_arguments == 'S')
1322: {
1323: liberation(s_etat_processus, s_objet_argument);
1324: free(argument_majuscule);
1325:
1326: (*s_etat_processus).erreur_execution =
1327: d_ex_erreur_parametre_fichier;
1328: return;
1329: }
1330:
1331: type_acces = 'I';
1332: }
1333: else if (strcmp(argument_majuscule, "READONLY") == 0)
1334: {
1335: if (protection != ' ')
1336: {
1337: liberation(s_etat_processus, s_objet_argument);
1338: free(argument_majuscule);
1339:
1340: (*s_etat_processus).erreur_execution =
1341: d_ex_erreur_parametre_fichier;
1342: return;
1343: }
1344:
1345: protection = 'R';
1346: }
1347: else if (strcmp(argument_majuscule, "WRITEONLY") == 0)
1348: {
1349: if (protection != ' ')
1350: {
1351: liberation(s_etat_processus, s_objet_argument);
1352: free(argument_majuscule);
1353:
1354: (*s_etat_processus).erreur_execution =
1355: d_ex_erreur_parametre_fichier;
1356: return;
1357: }
1358:
1359: protection = 'W';
1360: }
1361: else if (strcmp(argument_majuscule, "READWRITE") == 0)
1362: {
1363: if (protection != ' ')
1364: {
1365: liberation(s_etat_processus, s_objet_argument);
1366: free(argument_majuscule);
1367:
1368: (*s_etat_processus).erreur_execution =
1369: d_ex_erreur_parametre_fichier;
1370: return;
1371: }
1372:
1373: protection = 'N';
1374: }
1375: else if (strcmp(argument_majuscule, "FORMATTED") == 0)
1376: {
1377: if (format != ' ')
1378: {
1379: liberation(s_etat_processus, s_objet_argument);
1380: free(argument_majuscule);
1381:
1382: (*s_etat_processus).erreur_execution =
1383: d_ex_erreur_parametre_fichier;
1384: return;
1385: }
1386:
1387: format = 'N';
1388: }
1389: else if (strcmp(argument_majuscule, "UNFORMATTED") == 0)
1390: {
1391: if (format != ' ')
1392: {
1393: liberation(s_etat_processus, s_objet_argument);
1394: free(argument_majuscule);
1395:
1396: (*s_etat_processus).erreur_execution =
1397: d_ex_erreur_parametre_fichier;
1398: return;
1399: }
1400:
1401: format = 'Y';
1402: }
1403: else if (strcmp(argument_majuscule, "FLOW") == 0)
1404: {
1405: if (format != ' ')
1406: {
1407: liberation(s_etat_processus, s_objet_argument);
1408: free(argument_majuscule);
1409:
1410: (*s_etat_processus).erreur_execution =
1411: d_ex_erreur_parametre_fichier;
1412: return;
1413: }
1414:
1415: format = 'F';
1416: }
1417: else if (strcmp(argument_majuscule, "STREAM") == 0)
1418: {
1419: if (type_socket != ' ')
1420: {
1421: liberation(s_etat_processus, s_objet_argument);
1422: free(argument_majuscule);
1423:
1424: (*s_etat_processus).erreur_execution =
1425: d_ex_erreur_parametre_fichier;
1426: return;
1427: }
1428:
1429: if (type_arguments == ' ')
1430: {
1431: type_arguments = 'S';
1432: }
1433: else if (type_arguments == 'F')
1434: {
1435: liberation(s_etat_processus, s_objet_argument);
1436: free(argument_majuscule);
1437:
1438: (*s_etat_processus).erreur_execution =
1439: d_ex_erreur_parametre_fichier;
1440: return;
1441: }
1442:
1443: type_socket = 'S';
1444: }
1445: else if (strcmp(argument_majuscule, "DATAGRAM") == 0)
1446: {
1447: if (type_socket != ' ')
1448: {
1449: liberation(s_etat_processus, s_objet_argument);
1450: free(argument_majuscule);
1451:
1452: (*s_etat_processus).erreur_execution =
1453: d_ex_erreur_parametre_fichier;
1454: return;
1455: }
1456:
1457: type_socket = 'D';
1458: }
1459: else if (strcmp(argument_majuscule, "SEQUENTIAL DATAGRAM") == 0)
1460: {
1461: if (type_socket != ' ')
1462: {
1463: liberation(s_etat_processus, s_objet_argument);
1464: free(argument_majuscule);
1465:
1466: (*s_etat_processus).erreur_execution =
1467: d_ex_erreur_parametre_fichier;
1468: return;
1469: }
1470:
1471: if (type_arguments == ' ')
1472: {
1473: type_arguments = 'S';
1474: }
1475: else if (type_arguments == 'F')
1476: {
1477: liberation(s_etat_processus, s_objet_argument);
1478: free(argument_majuscule);
1479:
1480: (*s_etat_processus).erreur_execution =
1481: d_ex_erreur_parametre_fichier;
1482: return;
1483: }
1484:
1485: type_socket = 'Q';
1486: }
1487: else if (strcmp(argument_majuscule, "RAW") == 0)
1488: {
1489: if (type_socket != ' ')
1490: {
1491: liberation(s_etat_processus, s_objet_argument);
1492: free(argument_majuscule);
1493:
1494: (*s_etat_processus).erreur_execution =
1495: d_ex_erreur_parametre_fichier;
1496: return;
1497: }
1498:
1499: if (type_arguments == ' ')
1500: {
1501: type_arguments = 'S';
1502: }
1503: else if (type_arguments == 'F')
1504: {
1505: liberation(s_etat_processus, s_objet_argument);
1506: free(argument_majuscule);
1507:
1508: (*s_etat_processus).erreur_execution =
1509: d_ex_erreur_parametre_fichier;
1510: return;
1511: }
1512:
1513: type_socket = 'R';
1514: }
1515: else if (strcmp(argument_majuscule, "ROBUST DATAGRAM") == 0)
1516: {
1517: if (type_socket != ' ')
1518: {
1519: liberation(s_etat_processus, s_objet_argument);
1520: free(argument_majuscule);
1521:
1522: (*s_etat_processus).erreur_execution =
1523: d_ex_erreur_parametre_fichier;
1524: return;
1525: }
1526:
1527: if (type_arguments == ' ')
1528: {
1529: type_arguments = 'S';
1530: }
1531: else if (type_arguments == 'F')
1532: {
1533: liberation(s_etat_processus, s_objet_argument);
1534: free(argument_majuscule);
1535:
1536: (*s_etat_processus).erreur_execution =
1537: d_ex_erreur_parametre_fichier;
1538: return;
1539: }
1540:
1541: type_socket = 'M';
1542: }
1543: else if (strcmp(argument_majuscule, "LOCAL") == 0)
1544: {
1545: if (type_domaine != ' ')
1546: {
1547: liberation(s_etat_processus, s_objet_argument);
1548: free(argument_majuscule);
1549:
1550: (*s_etat_processus).erreur_execution =
1551: d_ex_erreur_parametre_fichier;
1552: return;
1553: }
1554:
1555: if (type_arguments == ' ')
1556: {
1557: type_arguments = 'S';
1558: }
1559: else if (type_arguments == 'F')
1560: {
1561: liberation(s_etat_processus, s_objet_argument);
1562: free(argument_majuscule);
1563:
1564: (*s_etat_processus).erreur_execution =
1565: d_ex_erreur_parametre_fichier;
1566: return;
1567: }
1568:
1569: type_domaine = 'L';
1570: }
1571: else if (strcmp(argument_majuscule, "FOREIGN") == 0)
1572: {
1573: if (type_domaine != ' ')
1574: {
1575: liberation(s_etat_processus, s_objet_argument);
1576: free(argument_majuscule);
1577:
1578: (*s_etat_processus).erreur_execution =
1579: d_ex_erreur_parametre_fichier;
1580: return;
1581: }
1582:
1583: if (type_arguments == ' ')
1584: {
1585: type_arguments = 'S';
1586: }
1587: else if (type_arguments == 'F')
1588: {
1589: liberation(s_etat_processus, s_objet_argument);
1590: free(argument_majuscule);
1591:
1592: (*s_etat_processus).erreur_execution =
1593: d_ex_erreur_parametre_fichier;
1594: return;
1595: }
1596:
1597: type_domaine = 'F';
1598: }
1599: else if (strcmp(argument_majuscule, "IPV4") == 0)
1600: {
1601: if (strcmp(protocole, "") != 0)
1602: {
1603: liberation(s_etat_processus, s_objet_argument);
1604: free(argument_majuscule);
1605:
1606: (*s_etat_processus).erreur_execution =
1607: d_ex_erreur_parametre_fichier;
1608: return;
1609: }
1610:
1611: if (type_arguments == ' ')
1612: {
1613: type_arguments = 'S';
1614: }
1615: else if (type_arguments == 'F')
1616: {
1617: liberation(s_etat_processus, s_objet_argument);
1618: free(argument_majuscule);
1619:
1620: (*s_etat_processus).erreur_execution =
1621: d_ex_erreur_parametre_fichier;
1622: return;
1623: }
1624:
1625: strcpy(protocole, "IPV4");
1626: }
1627: else if (strcmp(argument_majuscule, "IPV6") == 0)
1628: {
1629: if (strcmp(protocole, "") != 0)
1630: {
1631: liberation(s_etat_processus, s_objet_argument);
1632: free(argument_majuscule);
1633:
1634: (*s_etat_processus).erreur_execution =
1635: d_ex_erreur_parametre_fichier;
1636: return;
1637: }
1638:
1639: if (type_arguments == ' ')
1640: {
1641: type_arguments = 'S';
1642: }
1643: else if (type_arguments == 'F')
1644: {
1645: liberation(s_etat_processus, s_objet_argument);
1646: free(argument_majuscule);
1647:
1648: (*s_etat_processus).erreur_execution =
1649: d_ex_erreur_parametre_fichier;
1650: return;
1651: }
1652:
1653: strcpy(protocole, "IPV6");
1654: }
1655: else if (strcmp(argument_majuscule, "UNIX") == 0)
1656: {
1657: if (strcmp(protocole, "") != 0)
1658: {
1659: liberation(s_etat_processus, s_objet_argument);
1660: free(argument_majuscule);
1661:
1662: (*s_etat_processus).erreur_execution =
1663: d_ex_erreur_parametre_fichier;
1664: return;
1665: }
1666:
1667: if (type_arguments == ' ')
1668: {
1669: type_arguments = 'S';
1670: }
1671: else if (type_arguments == 'F')
1672: {
1673: liberation(s_etat_processus, s_objet_argument);
1674: free(argument_majuscule);
1675:
1676: (*s_etat_processus).erreur_execution =
1677: d_ex_erreur_parametre_fichier;
1678: return;
1679: }
1680:
1681: strcpy(protocole, "UNIX");
1682: }
1683: else
1684: {
1685: liberation(s_etat_processus, s_objet_argument);
1686: free(argument_majuscule);
1687:
1688: (*s_etat_processus).erreur_execution =
1689: d_ex_erreur_parametre_fichier;
1690: return;
1691: }
1692:
1693: free(argument_majuscule);
1694: }
1695: else if ((*(*l_element_courant).donnee).type == LST)
1696: {
1697: l_element_courant_sous_objet =
1698: (*(*l_element_courant).donnee).objet;
1699:
1700: nombre_elements = 0;
1701: while(l_element_courant_sous_objet != NULL)
1702: {
1703: nombre_elements++;
1704: l_element_courant_sous_objet =
1705: (*l_element_courant_sous_objet).suivant;
1706: }
1707:
1708: l_element_courant_sous_objet =
1709: (*(*l_element_courant).donnee).objet;
1710:
1711: if (nombre_elements == 2)
1712: {
1713: if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
1714: {
1715: if ((argument_majuscule = conversion_majuscule(
1716: (unsigned char *)
1717: (*(*l_element_courant_sous_objet)
1718: .donnee).objet)) == NULL)
1719: {
1720: (*s_etat_processus).erreur_systeme =
1721: d_es_allocation_memoire;
1722: return;
1723: }
1724:
1725: l_element_courant_sous_objet =
1726: (*l_element_courant_sous_objet).suivant;
1727:
1728: if (strcmp(argument_majuscule, "NAME") == 0)
1729: {
1730: if ((*(*l_element_courant_sous_objet).donnee).type
1731: == CHN)
1732: {
1733: if (nom != NULL)
1734: {
1735: liberation(s_etat_processus,
1736: s_objet_argument);
1737: free(argument_majuscule);
1738:
1739: (*s_etat_processus).erreur_execution =
1740: d_ex_erreur_parametre_fichier;
1741: return;
1742: }
1743:
1744: nom = (unsigned char *)
1745: (*(*l_element_courant_sous_objet)
1746: .donnee).objet;
1747: }
1748: else
1749: {
1750: liberation(s_etat_processus, s_objet_argument);
1751: free(argument_majuscule);
1752:
1753: (*s_etat_processus).erreur_execution =
1754: d_ex_erreur_parametre_fichier;
1755: return;
1756: }
1757: }
1758: else if (strcmp(argument_majuscule, "OPTION") == 0)
1759: {
1760: if ((*(*l_element_courant_sous_objet).donnee).type
1761: == CHN)
1762: {
1763: if (type_arguments == ' ')
1764: {
1765: type_arguments = 'S';
1766: }
1767: else if (type_arguments == 'F')
1768: {
1769: liberation(s_etat_processus,
1770: s_objet_argument);
1771: free(argument_majuscule);
1772:
1773: (*s_etat_processus).erreur_execution =
1774: d_ex_erreur_parametre_fichier;
1775: return;
1776: }
1777: }
1778:
1779: free(argument_majuscule);
1780:
1781: if ((argument_majuscule = conversion_majuscule(
1782: (unsigned char *)
1783: (*(*l_element_courant_sous_objet)
1784: .donnee).objet)) == NULL)
1785: {
1786: (*s_etat_processus).erreur_systeme =
1787: d_es_allocation_memoire;
1788: return;
1789: }
1790:
1791: if (strcmp(argument_majuscule, "BROADCAST") == 0)
1792: {
1793: if (options[d_BROADCAST] == 'Y')
1794: {
1795: liberation(s_etat_processus,
1796: s_objet_argument);
1797: free(argument_majuscule);
1798:
1799: (*s_etat_processus).erreur_execution =
1800: d_ex_erreur_parametre_fichier;
1801: return;
1802: }
1803:
1804: options[d_BROADCAST] = 'Y';
1805: }
1806: else if (strcmp(argument_majuscule, "DO NOT ROUTE")
1807: == 0)
1808: {
1809: if (options[d_DONT_ROUTE] == 'Y')
1810: {
1811: liberation(s_etat_processus,
1812: s_objet_argument);
1813: free(argument_majuscule);
1814:
1815: (*s_etat_processus).erreur_execution =
1816: d_ex_erreur_parametre_fichier;
1817: return;
1818: }
1819:
1820: options[d_DONT_ROUTE] = 'Y';
1821: }
1822: else if (strcmp(argument_majuscule, "KEEP ALIVE")
1823: == 0)
1824: {
1825: if (options[d_KEEP_ALIVE] == 'Y')
1826: {
1827: liberation(s_etat_processus,
1828: s_objet_argument);
1829: free(argument_majuscule);
1830:
1831: (*s_etat_processus).erreur_execution =
1832: d_ex_erreur_parametre_fichier;
1833: return;
1834: }
1835:
1836: options[d_KEEP_ALIVE] = 'Y';
1837: }
1838: else if (strcmp(argument_majuscule, "REUSE ADDRESS")
1839: == 0)
1840: {
1841: if (options[d_REUSE_ADDRESS] == 'Y')
1842: {
1843: liberation(s_etat_processus,
1844: s_objet_argument);
1845: free(argument_majuscule);
1846:
1847: (*s_etat_processus).erreur_execution =
1848: d_ex_erreur_parametre_fichier;
1849: return;
1850: }
1851:
1852: options[d_REUSE_ADDRESS] = 'Y';
1853: }
1854: else
1855: {
1856: liberation(s_etat_processus,
1857: s_objet_argument);
1858: free(argument_majuscule);
1859:
1860: (*s_etat_processus).erreur_execution =
1861: d_ex_erreur_parametre_fichier;
1862: return;
1863: }
1864: }
1865: else if (strcmp(argument_majuscule, "HOST") == 0)
1866: {
1867: if ((*(*l_element_courant_sous_objet).donnee).type
1868: == CHN)
1869: {
1870: if (type_arguments == ' ')
1871: {
1872: type_arguments = 'S';
1873: }
1874: else if (type_arguments == 'F')
1875: {
1876: liberation(s_etat_processus,
1877: s_objet_argument);
1878: free(argument_majuscule);
1879:
1880: (*s_etat_processus).erreur_execution =
1881: d_ex_erreur_parametre_fichier;
1882: return;
1883: }
1884:
1885: if (hote != NULL)
1886: {
1887: liberation(s_etat_processus,
1888: s_objet_argument);
1889: free(argument_majuscule);
1890:
1891: (*s_etat_processus).erreur_execution =
1892: d_ex_erreur_parametre_fichier;
1893: return;
1894: }
1895:
1896: hote = (unsigned char *)
1897: (*(*l_element_courant_sous_objet)
1898: .donnee).objet;
1899: }
1900: else
1901: {
1902: liberation(s_etat_processus,
1903: s_objet_argument);
1904: free(argument_majuscule);
1905:
1906: (*s_etat_processus).erreur_execution =
1907: d_ex_erreur_parametre_fichier;
1908: return;
1909: }
1910: }
1911: else if (strcmp(argument_majuscule, "PROTOCOL") == 0)
1912: {
1913: if ((*(*l_element_courant_sous_objet).donnee).type
1914: == CHN)
1915: {
1916: if (type_arguments == ' ')
1917: {
1918: type_arguments = 'S';
1919: }
1920: else if (type_arguments == 'F')
1921: {
1922: liberation(s_etat_processus,
1923: s_objet_argument);
1924: free(argument_majuscule);
1925:
1926: (*s_etat_processus).erreur_execution =
1927: d_ex_erreur_parametre_fichier;
1928: return;
1929: }
1930:
1931: if (protocole_socket != NULL)
1932: {
1933: liberation(s_etat_processus,
1934: s_objet_argument);
1935: free(argument_majuscule);
1936:
1937: (*s_etat_processus).erreur_execution =
1938: d_ex_erreur_parametre_fichier;
1939: return;
1940: }
1941:
1942: protocole_socket = (unsigned char *)
1943: (*(*l_element_courant_sous_objet)
1944: .donnee).objet;
1945: }
1946: else
1947: {
1948: liberation(s_etat_processus, s_objet_argument);
1949: free(argument_majuscule);
1950:
1951: (*s_etat_processus).erreur_execution =
1952: d_ex_erreur_parametre_fichier;
1953: return;
1954: }
1955: }
1956: else if (strcmp(argument_majuscule, "KEY") == 0)
1957: {
1958: if ((*(*l_element_courant_sous_objet).donnee).type
1959: == INT)
1960: {
1961: if (type_arguments == ' ')
1962: {
1963: type_arguments = 'F';
1964: }
1965: else if (type_arguments == 'S')
1966: {
1967: liberation(s_etat_processus,
1968: s_objet_argument);
1969: free(argument_majuscule);
1970:
1971: (*s_etat_processus).erreur_execution =
1972: d_ex_erreur_parametre_fichier;
1973: return;
1974: }
1975:
1976: if (position_clef != 0)
1977: {
1978: liberation(s_etat_processus,
1979: s_objet_argument);
1980:
1981: (*s_etat_processus).erreur_execution =
1982: d_ex_erreur_parametre_fichier;
1983: return;
1984: }
1985: else
1986: {
1987: if ((position_clef = (*((integer8 *)
1988: (*(*l_element_courant_sous_objet)
1989: .donnee).objet))) <= 0)
1990: {
1991: liberation(s_etat_processus,
1992: s_objet_argument);
1993:
1994: (*s_etat_processus).erreur_execution =
1995: d_ex_erreur_parametre_fichier;
1996: return;
1997: }
1998: }
1999: }
2000: else
2001: {
2002: liberation(s_etat_processus, s_objet_argument);
2003: free(argument_majuscule);
2004:
2005: (*s_etat_processus).erreur_execution =
2006: d_ex_erreur_parametre_fichier;
2007: return;
2008: }
2009: }
2010: else if (strcmp(argument_majuscule, "PORT") == 0)
2011: {
2012: if ((*(*l_element_courant_sous_objet)
2013: .donnee).type == INT)
2014: {
2015: if (type_arguments == ' ')
2016: {
2017: type_arguments = 'S';
2018: }
2019: else if (type_arguments == 'F')
2020: {
2021: liberation(s_etat_processus,
2022: s_objet_argument);
2023: free(argument_majuscule);
2024:
2025: (*s_etat_processus).erreur_execution =
2026: d_ex_erreur_parametre_fichier;
2027: return;
2028: }
2029:
2030: if (presence_port == d_vrai)
2031: {
2032: liberation(s_etat_processus,
2033: s_objet_argument);
2034:
2035: (*s_etat_processus).erreur_execution =
2036: d_ex_erreur_parametre_fichier;
2037: return;
2038: }
2039: else
2040: {
2041: presence_port = d_vrai;
2042:
2043: if ((port = (*((integer8 *)
2044: (*(*l_element_courant_sous_objet)
2045: .donnee).objet))) < 0)
2046: {
2047: liberation(s_etat_processus,
2048: s_objet_argument);
2049:
2050: (*s_etat_processus).erreur_execution =
2051: d_ex_erreur_parametre_fichier;
2052: return;
2053: }
2054:
2055: if (port > 65535)
2056: {
2057: liberation(s_etat_processus,
2058: s_objet_argument);
2059:
2060: (*s_etat_processus).erreur_execution =
2061: d_ex_erreur_parametre_fichier;
2062: return;
2063: }
2064: }
2065: }
2066: else
2067: {
2068: liberation(s_etat_processus, s_objet_argument);
2069: free(argument_majuscule);
2070:
2071: (*s_etat_processus).erreur_execution =
2072: d_ex_erreur_parametre_fichier;
2073: return;
2074: }
2075: }
2076: else if (strcmp(argument_majuscule, "LISTEN") == 0)
2077: {
2078: if ((*(*l_element_courant_sous_objet).donnee).type
2079: == INT)
2080: {
2081: if (type_arguments == ' ')
2082: {
2083: type_arguments = 'S';
2084: }
2085: else if (type_arguments == 'F')
2086: {
2087: liberation(s_etat_processus,
2088: s_objet_argument);
2089: free(argument_majuscule);
2090:
2091: (*s_etat_processus).erreur_execution =
2092: d_ex_erreur_parametre_fichier;
2093: return;
2094: }
2095:
2096: if (nombre_maximal_connexions != 0)
2097: {
2098: liberation(s_etat_processus,
2099: s_objet_argument);
2100:
2101: (*s_etat_processus).erreur_execution =
2102: d_ex_erreur_parametre_fichier;
2103: return;
2104: }
2105: else
2106: {
2107: if ((nombre_maximal_connexions =
2108: (*((integer8 *)
2109: (*(*l_element_courant_sous_objet)
2110: .donnee).objet))) <= 0)
2111: {
2112: liberation(s_etat_processus,
2113: s_objet_argument);
2114:
2115: (*s_etat_processus).erreur_execution =
2116: d_ex_erreur_parametre_fichier;
2117: return;
2118: }
2119: }
2120: }
2121: }
2122: else if (strcmp(argument_majuscule, "ADDRESS") == 0)
2123: {
2124: if ((*(*l_element_courant_sous_objet)
2125: .donnee).type == VIN)
2126: {
2127: if (type_arguments == ' ')
2128: {
2129: type_arguments = 'S';
2130: }
2131: else if (type_arguments == 'F')
2132: {
2133: liberation(s_etat_processus,
2134: s_objet_argument);
2135: free(argument_majuscule);
2136:
2137: (*s_etat_processus).erreur_execution =
2138: d_ex_erreur_parametre_fichier;
2139: return;
2140: }
2141:
2142: if (type_adresse != ' ')
2143: {
2144: liberation(s_etat_processus,
2145: s_objet_argument);
2146:
2147: (*s_etat_processus).erreur_execution =
2148: d_ex_erreur_parametre_fichier;
2149: return;
2150: }
2151:
2152: if ((*((struct_vecteur *)
2153: (*(*l_element_courant_sous_objet)
2154: .donnee).objet)).taille == 4)
2155: { // Adresse IPv4
2156: type_adresse = '4';
2157:
2158: for(i = 0; i < 4; i++)
2159: {
2160: adresse[i] = ((integer8 *)
2161: (*((struct_vecteur *) (*
2162: (*l_element_courant_sous_objet)
2163: .donnee).objet)).tableau)[i];
2164:
2165: if ((adresse[i] < 0) || (adresse[i] >
2166: 255))
2167: {
2168: liberation(s_etat_processus,
2169: s_objet_argument);
2170:
2171: (*s_etat_processus).erreur_execution
2172: = d_ex_erreur_parametre_fichier;
2173: return;
2174: }
2175: }
2176: }
2177: else if ((*((struct_vecteur *)
2178: (*(*l_element_courant_sous_objet)
2179: .donnee).objet)).taille == 16)
2180: { // Adresse IPv6
2181: type_adresse = '6';
2182:
2183: for(i = 0; i < 16; i++)
2184: {
2185: adresse[i] = ((integer8 *)
2186: (*((struct_vecteur *) (*
2187: (*l_element_courant_sous_objet)
2188: .donnee).objet)).tableau)[i];
2189:
2190: if ((adresse[i] < 0) || (adresse[i] >
2191: 255))
2192: {
2193: liberation(s_etat_processus,
2194: s_objet_argument);
2195:
2196: (*s_etat_processus).erreur_execution
2197: = d_ex_erreur_parametre_fichier;
2198: return;
2199: }
2200: }
2201: }
2202: else
2203: { // Adresse non supportée
2204: liberation(s_etat_processus,
2205: s_objet_argument);
2206:
2207: (*s_etat_processus).erreur_execution =
2208: d_ex_erreur_parametre_fichier;
2209: return;
2210: }
2211: }
2212: }
2213: else
2214: {
2215: liberation(s_etat_processus, s_objet_argument);
2216: free(argument_majuscule);
2217:
2218: (*s_etat_processus).erreur_execution =
2219: d_ex_erreur_parametre_fichier;
2220: return;
2221: }
2222:
2223: free(argument_majuscule);
2224: }
2225: else
2226: {
2227: liberation(s_etat_processus, s_objet_argument);
2228: (*s_etat_processus).erreur_execution =
2229: d_ex_erreur_parametre_fichier;
2230:
2231: return;
2232: }
2233: }
2234: else if (nombre_elements == 3)
2235: {
2236: if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
2237: {
2238: if ((argument_majuscule = conversion_majuscule(
2239: (unsigned char *)
2240: (*(*l_element_courant_sous_objet)
2241: .donnee).objet)) == NULL)
2242: {
2243: (*s_etat_processus).erreur_systeme =
2244: d_es_allocation_memoire;
2245: return;
2246: }
2247:
2248: if (strcmp(argument_majuscule, "OPTION") == 0)
2249: {
2250: if (type_arguments == ' ')
2251: {
2252: type_arguments = 'S';
2253: }
2254: else if (type_arguments == 'F')
2255: {
2256: liberation(s_etat_processus, s_objet_argument);
2257: free(argument_majuscule);
2258:
2259: (*s_etat_processus).erreur_execution =
2260: d_ex_erreur_parametre_fichier;
2261: return;
2262: }
2263:
2264: free(argument_majuscule);
2265:
2266: l_element_courant_sous_objet =
2267: (*l_element_courant_sous_objet).suivant;
2268:
2269: if ((*(*l_element_courant_sous_objet)
2270: .donnee).type != CHN)
2271: {
2272: liberation(s_etat_processus, s_objet_argument);
2273:
2274: (*s_etat_processus).erreur_execution =
2275: d_ex_erreur_parametre_fichier;
2276: return;
2277: }
2278:
2279: if ((argument_majuscule = conversion_majuscule(
2280: (unsigned char *)
2281: (*(*l_element_courant_sous_objet)
2282: .donnee).objet)) == NULL)
2283: {
2284: (*s_etat_processus).erreur_systeme =
2285: d_es_allocation_memoire;
2286: return;
2287: }
2288:
2289: l_element_courant_sous_objet =
2290: (*l_element_courant_sous_objet).suivant;
2291:
2292: if (strcmp(argument_majuscule, "BIND TO DEVICE")
2293: == 0)
2294: {
2295: if ((*(*l_element_courant_sous_objet)
2296: .donnee).type != CHN)
2297: {
2298: liberation(s_etat_processus,
2299: s_objet_argument);
2300: free(argument_majuscule);
2301:
2302: (*s_etat_processus).erreur_execution =
2303: d_ex_erreur_parametre_fichier;
2304: return;
2305: }
2306:
2307: if (options[d_BIND_TO_DEVICE] == 'Y')
2308: {
2309: liberation(s_etat_processus,
2310: s_objet_argument);
2311: free(argument_majuscule);
2312:
2313: (*s_etat_processus).erreur_execution =
2314: d_ex_erreur_parametre_fichier;
2315: return;
2316: }
2317:
2318: options[d_BIND_TO_DEVICE] = 'Y';
2319:
2320: peripherique = (unsigned char *)
2321: (*(*l_element_courant_sous_objet)
2322: .donnee).objet;
2323: }
2324: else if (strcmp(argument_majuscule, "PRIORITY")
2325: == 0)
2326: {
2327: if ((*(*l_element_courant_sous_objet)
2328: .donnee).type != INT)
2329: {
2330: liberation(s_etat_processus,
2331: s_objet_argument);
2332: free(argument_majuscule);
2333:
2334: (*s_etat_processus).erreur_execution =
2335: d_ex_erreur_parametre_fichier;
2336: return;
2337: }
2338:
2339: if (options[d_PRIORITY] == 'Y')
2340: {
2341: liberation(s_etat_processus,
2342: s_objet_argument);
2343: free(argument_majuscule);
2344:
2345: (*s_etat_processus).erreur_execution =
2346: d_ex_erreur_parametre_fichier;
2347: return;
2348: }
2349:
2350: options[d_PRIORITY] = 'Y';
2351:
2352: priorite = (int) (*((integer8 *)
2353: (*(*l_element_courant_sous_objet)
2354: .donnee).objet));
2355: }
2356: else if (strcmp(argument_majuscule,
2357: "RECEIVE BUFFER") == 0)
2358: {
2359: if ((*(*l_element_courant_sous_objet)
2360: .donnee).type != INT)
2361: {
2362: liberation(s_etat_processus,
2363: s_objet_argument);
2364: free(argument_majuscule);
2365:
2366: (*s_etat_processus).erreur_execution =
2367: d_ex_erreur_parametre_fichier;
2368: return;
2369: }
2370:
2371: if ((options[d_RECEIVE_BUFFER] == 'Y') ||
2372: (options[d_FORCE_RECEIVE_BUFFER]
2373: == 'Y'))
2374: {
2375: liberation(s_etat_processus,
2376: s_objet_argument);
2377: free(argument_majuscule);
2378:
2379: (*s_etat_processus).erreur_execution =
2380: d_ex_erreur_parametre_fichier;
2381: return;
2382: }
2383:
2384: options[d_RECEIVE_BUFFER] = 'Y';
2385:
2386: buffer_reception = (int) (*((integer8 *)
2387: (*(*l_element_courant_sous_objet)
2388: .donnee).objet));
2389: }
2390: else if (strcmp(argument_majuscule,
2391: "FORCE RECEIVE BUFFER") == 0)
2392: {
2393: if ((*(*l_element_courant_sous_objet)
2394: .donnee).type != INT)
2395: {
2396: liberation(s_etat_processus,
2397: s_objet_argument);
2398: free(argument_majuscule);
2399:
2400: (*s_etat_processus).erreur_execution =
2401: d_ex_erreur_parametre_fichier;
2402: return;
2403: }
2404:
2405: if ((options[d_RECEIVE_BUFFER] == 'Y') ||
2406: (options[d_FORCE_RECEIVE_BUFFER]
2407: == 'Y'))
2408: {
2409: liberation(s_etat_processus,
2410: s_objet_argument);
2411: free(argument_majuscule);
2412:
2413: (*s_etat_processus).erreur_execution =
2414: d_ex_erreur_parametre_fichier;
2415: return;
2416: }
2417:
2418: options[d_FORCE_RECEIVE_BUFFER] = 'Y';
2419:
2420: buffer_reception = (int) (*((integer8 *)
2421: (*(*l_element_courant_sous_objet)
2422: .donnee).objet));
2423: }
2424: else if (strcmp(argument_majuscule,
2425: "SEND BUFFER") == 0)
2426: {
2427: if ((*(*l_element_courant_sous_objet)
2428: .donnee).type != INT)
2429: {
2430: liberation(s_etat_processus,
2431: s_objet_argument);
2432: free(argument_majuscule);
2433:
2434: (*s_etat_processus).erreur_execution =
2435: d_ex_erreur_parametre_fichier;
2436: return;
2437: }
2438:
2439: if ((options[d_SEND_BUFFER] == 'Y') ||
2440: (options[d_FORCE_SEND_BUFFER] == 'Y'))
2441: {
2442: liberation(s_etat_processus,
2443: s_objet_argument);
2444: free(argument_majuscule);
2445:
2446: (*s_etat_processus).erreur_execution =
2447: d_ex_erreur_parametre_fichier;
2448: return;
2449: }
2450:
2451: options[d_SEND_BUFFER] = 'Y';
2452:
2453: buffer_emission = (int) (*((integer8 *)
2454: (*(*l_element_courant_sous_objet)
2455: .donnee).objet));
2456: }
2457: else if (strcmp(argument_majuscule,
2458: "FORCE SEND BUFFER") == 0)
2459: {
2460: if ((*(*l_element_courant_sous_objet)
2461: .donnee).type != INT)
2462: {
2463: liberation(s_etat_processus,
2464: s_objet_argument);
2465: free(argument_majuscule);
2466:
2467: (*s_etat_processus).erreur_execution =
2468: d_ex_erreur_parametre_fichier;
2469: return;
2470: }
2471:
2472: if ((options[d_SEND_BUFFER] == 'Y') ||
2473: (options[d_FORCE_SEND_BUFFER] == 'Y'))
2474: {
2475: liberation(s_etat_processus,
2476: s_objet_argument);
2477: free(argument_majuscule);
2478:
2479: (*s_etat_processus).erreur_execution =
2480: d_ex_erreur_parametre_fichier;
2481: return;
2482: }
2483:
2484: options[d_FORCE_SEND_BUFFER] = 'Y';
2485:
2486: buffer_emission = (int) (*((integer8 *)
2487: (*(*l_element_courant_sous_objet)
2488: .donnee).objet));
2489: }
2490: else if (strcmp(argument_majuscule,
2491: "RECEIVING TIMEOUT") == 0)
2492: {
2493: if ((*(*l_element_courant_sous_objet)
2494: .donnee).type != INT)
2495: {
2496: liberation(s_etat_processus,
2497: s_objet_argument);
2498: free(argument_majuscule);
2499:
2500: (*s_etat_processus).erreur_execution =
2501: d_ex_erreur_parametre_fichier;
2502: return;
2503: }
2504:
2505: if (options[d_RECEIVING_TIMEOUT] == 'Y')
2506: {
2507: liberation(s_etat_processus,
2508: s_objet_argument);
2509: free(argument_majuscule);
2510:
2511: (*s_etat_processus).erreur_execution =
2512: d_ex_erreur_parametre_fichier;
2513: return;
2514: }
2515:
2516: options[d_RECEIVING_TIMEOUT] = 'Y';
2517:
2518: timeout_reception = (int) (*((integer8 *)
2519: (*(*l_element_courant_sous_objet)
2520: .donnee).objet));
2521: }
2522: else if (strcmp(argument_majuscule,
2523: "SENDING TIMEOUT") == 0)
2524: {
2525: if ((*(*l_element_courant_sous_objet)
2526: .donnee).type != INT)
2527: {
2528: liberation(s_etat_processus,
2529: s_objet_argument);
2530: free(argument_majuscule);
2531:
2532: (*s_etat_processus).erreur_execution =
2533: d_ex_erreur_parametre_fichier;
2534: return;
2535: }
2536:
2537: if (options[d_SENDING_TIMEOUT] == 'Y')
2538: {
2539: liberation(s_etat_processus,
2540: s_objet_argument);
2541: free(argument_majuscule);
2542:
2543: (*s_etat_processus).erreur_execution =
2544: d_ex_erreur_parametre_fichier;
2545: return;
2546: }
2547:
2548: options[d_SENDING_TIMEOUT] = 'Y';
2549:
2550: timeout_emission = (int) (*((integer8 *)
2551: (*(*l_element_courant_sous_objet)
2552: .donnee).objet));
2553: }
2554: else
2555: {
2556: liberation(s_etat_processus, s_objet_argument);
2557: free(argument_majuscule);
2558:
2559: (*s_etat_processus).erreur_execution =
2560: d_ex_erreur_parametre_fichier;
2561: return;
2562: }
2563:
2564: free(argument_majuscule);
2565: }
2566: else
2567: {
2568: liberation(s_etat_processus, s_objet_argument);
2569: free(argument_majuscule);
2570:
2571: (*s_etat_processus).erreur_execution =
2572: d_ex_erreur_parametre_fichier;
2573: return;
2574: }
2575: }
2576: else
2577: {
2578: liberation(s_etat_processus, s_objet_argument);
2579: (*s_etat_processus).erreur_execution =
2580: d_ex_erreur_parametre_fichier;
2581:
2582: return;
2583: }
2584: }
2585: else
2586: {
2587: liberation(s_etat_processus, s_objet_argument);
2588: (*s_etat_processus).erreur_execution =
2589: d_ex_erreur_parametre_fichier;
2590:
2591: return;
2592: }
2593: }
2594: else
2595: {
2596: liberation(s_etat_processus, s_objet_argument);
2597:
2598: (*s_etat_processus).erreur_execution =
2599: d_ex_erreur_parametre_fichier;
2600: return;
2601: }
2602:
2603: l_element_courant = (*l_element_courant).suivant;
2604: }
2605:
2606: if (type_arguments == 'F')
2607: {
2608: /*
2609: * Traitement des fichiers
2610: */
2611:
2612: /*
2613: * Vérification de la cohérence et comportement par défaut
2614: */
2615:
2616: if (type_ouverture == ' ')
2617: {
2618: type_ouverture = 'U';
2619: }
2620:
2621: if (type_acces == ' ')
2622: {
2623: type_acces = 'S';
2624: }
2625:
2626: if (format == ' ')
2627: {
2628: format = 'N';
2629: }
2630:
2631: if (protection == ' ')
2632: {
2633: protection = 'N';
2634: }
2635:
2636: if ((type_ouverture == 'S') && (protection != 'N'))
2637: {
2638: liberation(s_etat_processus, s_objet_argument);
2639:
2640: (*s_etat_processus).erreur_execution =
2641: d_ex_erreur_parametre_fichier;
2642: return;
2643: }
2644:
2645: if ((type_ouverture != 'S') && (nom == NULL))
2646: {
2647: liberation(s_etat_processus, s_objet_argument);
2648:
2649: (*s_etat_processus).erreur_execution =
2650: d_ex_erreur_parametre_fichier;
2651: return;
2652: }
2653:
2654: if (((type_acces != 'I') && (position_clef != 0)) ||
2655: ((type_acces == 'I') && (position_clef == 0) &&
2656: ((type_ouverture == 'N') || (type_ouverture == 'R') ||
2657: (type_ouverture == 'S'))))
2658: {
2659: liberation(s_etat_processus, s_objet_argument);
2660:
2661: (*s_etat_processus).erreur_execution =
2662: d_ex_erreur_parametre_fichier;
2663: return;
2664: }
2665:
2666: if ((s_objet_resultat = allocation(s_etat_processus, FCH))
2667: == NULL)
2668: {
2669: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2670: return;
2671: }
2672:
2673: if (nom == NULL)
2674: {
2675: if ((nom_temporaire = creation_nom_fichier(s_etat_processus,
2676: (*s_etat_processus).chemin_fichiers_temporaires))
2677: == NULL)
2678: {
2679: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2680: return;
2681: }
2682:
2683: if ((nom = malloc((strlen(nom_temporaire)
2684: + 5) * sizeof(unsigned char))) == NULL)
2685: {
2686: (*s_etat_processus).erreur_systeme =
2687: d_es_allocation_memoire;
2688: return;
2689: }
2690:
2691: sprintf(nom, "%s.rpl", nom_temporaire);
2692: free(nom_temporaire);
2693: }
2694: else
2695: {
2696: if ((nom = transliteration(s_etat_processus, nom,
2697: d_locale, "UTF-8")) == NULL)
2698: {
2699: liberation(s_etat_processus, s_objet_argument);
2700: liberation(s_etat_processus, s_objet_resultat);
2701: return;
2702: }
2703: }
2704:
2705: /*
2706: * Ouverture du fichier
2707: */
2708:
2709: (*((struct_fichier *) (*s_objet_resultat).objet))
2710: .nom = NULL;
2711: (*((struct_fichier *) (*s_objet_resultat).objet))
2712: .acces = type_acces;
2713: (*((struct_fichier *) (*s_objet_resultat).objet))
2714: .binaire = format;
2715: (*((struct_fichier *) (*s_objet_resultat).objet))
2716: .ouverture = type_ouverture;
2717: (*((struct_fichier *) (*s_objet_resultat).objet)).pid
2718: = getpid();
2719: (*((struct_fichier *) (*s_objet_resultat).objet)).tid
2720: = pthread_self();
2721:
2722: if (((*((struct_fichier *) (*s_objet_resultat).objet)).format =
2723: allocation(s_etat_processus, LST)) == NULL)
2724: {
2725: free(nom);
2726:
2727: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2728: return;
2729: }
2730:
2731: (*(*((struct_fichier *) (*s_objet_resultat).objet))
2732: .format).objet = NULL;
2733:
2734: descripteur = NULL;
2735:
2736: switch(type_ouverture)
2737: {
2738: case 'N' :
2739: {
2740: erreur = caracteristiques_fichier(s_etat_processus,
2741: nom, &existence, &ouverture, &unite);
2742:
2743: if ((erreur != 0) || (unite != 0))
2744: {
2745: free(nom);
2746:
2747: liberation(s_etat_processus, s_objet_argument);
2748: liberation(s_etat_processus, s_objet_resultat);
2749:
2750: (*s_etat_processus).erreur_execution =
2751: d_ex_erreur_acces_fichier;
2752: return;
2753: }
2754:
2755: if (type_acces == 'S')
2756: {
2757: if ((descripteur = fopen(nom, "w+")) == NULL)
2758: {
2759: free(nom);
2760:
2761: liberation(s_etat_processus, s_objet_argument);
2762: liberation(s_etat_processus, s_objet_resultat);
2763:
2764: (*s_etat_processus).erreur_execution =
2765: d_ex_erreur_acces_fichier;
2766: return;
2767: }
2768: }
2769: else
2770: {
2771: // Si le fichier existe, on le supprime.
2772:
2773: if (unlink(nom) != 0)
2774: {
2775: free(nom);
2776:
2777: liberation(s_etat_processus, s_objet_argument);
2778: liberation(s_etat_processus, s_objet_resultat);
2779:
2780: (*s_etat_processus).erreur_execution =
2781: d_ex_erreur_acces_fichier;
2782: return;
2783: }
2784:
2785: if (sqlite3_open_v2(nom, &sqlite,
2786: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
2787: NULL) != SQLITE_OK)
2788: {
2789: free(nom);
2790:
2791: liberation(s_etat_processus, s_objet_argument);
2792: liberation(s_etat_processus, s_objet_resultat);
2793:
2794: (*s_etat_processus).erreur_execution =
2795: d_ex_erreur_acces_fichier;
2796: return;
2797: }
2798:
2799: if ((descripteur = fopen(nom, "a+")) == NULL)
2800: {
2801: free(nom);
2802:
2803: liberation(s_etat_processus, s_objet_argument);
2804: liberation(s_etat_processus, s_objet_resultat);
2805:
2806: (*s_etat_processus).erreur_execution =
2807: d_ex_erreur_acces_fichier;
2808: return;
2809: }
2810:
2811: if (type_acces == 'D')
2812: {
2813: if (initialisation_fichier_acces_direct(
2814: s_etat_processus, sqlite,
2815: (format == 'N') ? d_faux : d_vrai)
2816: != d_absence_erreur)
2817: {
2818: free(nom);
2819:
2820: liberation(s_etat_processus, s_objet_argument);
2821: liberation(s_etat_processus, s_objet_resultat);
2822:
2823: return;
2824: }
2825: }
2826: else
2827: {
2828: if (position_clef == 0)
2829: {
2830: free(nom);
2831:
2832: liberation(s_etat_processus, s_objet_argument);
2833: liberation(s_etat_processus, s_objet_resultat);
2834:
2835: (*s_etat_processus).erreur_execution =
2836: d_ex_erreur_parametre_fichier;
2837: return;
2838: }
2839:
2840: if (initialisation_fichier_acces_indexe(
2841: s_etat_processus, sqlite, position_clef,
2842: (format == 'N') ? d_faux : d_vrai)
2843: != d_absence_erreur)
2844: {
2845: free(nom);
2846:
2847: liberation(s_etat_processus, s_objet_argument);
2848: liberation(s_etat_processus, s_objet_resultat);
2849:
2850: return;
2851: }
2852: }
2853: }
2854:
2855: break;
2856: }
2857:
2858: case 'O' :
2859: {
2860: erreur = caracteristiques_fichier(s_etat_processus, nom,
2861: &existence, &ouverture, &unite);
2862:
2863: if ((erreur != d_absence_erreur) || (existence == d_faux))
2864: {
2865: free(nom);
2866:
2867: liberation(s_etat_processus, s_objet_argument);
2868: liberation(s_etat_processus, s_objet_resultat);
2869:
2870: (*s_etat_processus).erreur_execution =
2871: d_ex_erreur_acces_fichier;
2872: return;
2873: }
2874:
2875: if (type_acces == 'S')
2876: {
2877: if ((descripteur = fopen(nom, "r+")) == NULL)
2878: {
2879: free(nom);
2880:
2881: liberation(s_etat_processus, s_objet_argument);
2882: liberation(s_etat_processus, s_objet_resultat);
2883:
2884: (*s_etat_processus).erreur_execution =
2885: d_ex_erreur_acces_fichier;
2886: return;
2887: }
2888: }
2889: else
2890: {
2891: if (sqlite3_open_v2(nom, &sqlite,
2892: SQLITE_OPEN_READWRITE,
2893: NULL) != SQLITE_OK)
2894: {
2895: free(nom);
2896:
2897: liberation(s_etat_processus, s_objet_argument);
2898: liberation(s_etat_processus, s_objet_resultat);
2899:
2900: (*s_etat_processus).erreur_execution =
2901: d_ex_erreur_acces_fichier;
2902: return;
2903: }
2904:
2905: if ((descripteur = fopen(nom, "a+")) == NULL)
2906: {
2907: free(nom);
2908:
2909: liberation(s_etat_processus, s_objet_argument);
2910: liberation(s_etat_processus, s_objet_resultat);
2911:
2912: (*s_etat_processus).erreur_execution =
2913: d_ex_erreur_acces_fichier;
2914: return;
2915: }
2916: }
2917:
2918: break;
2919: }
2920:
2921: case 'R' :
2922: {
2923: erreur = caracteristiques_fichier(s_etat_processus,
2924: nom, &existence, &ouverture, &unite);
2925:
2926: if ((erreur != d_absence_erreur) || (existence == d_faux))
2927: {
2928: free(nom);
2929:
2930: liberation(s_etat_processus, s_objet_argument);
2931: liberation(s_etat_processus, s_objet_resultat);
2932:
2933: (*s_etat_processus).erreur_execution =
2934: d_ex_erreur_acces_fichier;
2935: return;
2936: }
2937:
2938: /* Test du verrou */
2939:
2940: if ((descripteur = fopen(nom, "r")) == NULL)
2941: {
2942: free(nom);
2943:
2944: liberation(s_etat_processus, s_objet_argument);
2945: liberation(s_etat_processus, s_objet_resultat);
2946:
2947: (*s_etat_processus).erreur_execution =
2948: d_ex_erreur_acces_fichier;
2949: return;
2950: }
2951:
2952: lock.l_type = F_WRLCK;
2953: lock.l_whence = SEEK_SET;
2954: lock.l_start = 0;
2955: lock.l_len = 0;
2956: lock.l_pid = getpid();
2957:
2958: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
2959: {
2960: free(nom);
2961:
2962: if (fclose(descripteur) != 0)
2963: {
2964: liberation(s_etat_processus, s_objet_argument);
2965: liberation(s_etat_processus, s_objet_resultat);
2966:
2967: (*s_etat_processus).erreur_systeme =
2968: d_es_erreur_fichier;
2969: return;
2970: }
2971:
2972: liberation(s_etat_processus, s_objet_argument);
2973: liberation(s_etat_processus, s_objet_resultat);
2974:
2975: (*s_etat_processus).erreur_systeme =
2976: d_es_erreur_fichier;
2977: return;
2978: }
2979:
2980: if (lock.l_type != F_UNLCK)
2981: {
2982: free(nom);
2983:
2984: if (fclose(descripteur) != 0)
2985: {
2986: liberation(s_etat_processus, s_objet_argument);
2987: liberation(s_etat_processus, s_objet_resultat);
2988:
2989: (*s_etat_processus).erreur_systeme =
2990: d_es_erreur_fichier;
2991: return;
2992: }
2993:
2994: liberation(s_etat_processus, s_objet_argument);
2995: liberation(s_etat_processus, s_objet_resultat);
2996:
2997: (*s_etat_processus).erreur_execution =
2998: d_ex_fichier_verrouille;
2999: return;
3000: }
3001:
3002: if (fclose(descripteur) != 0)
3003: {
3004: free(nom);
3005:
3006: liberation(s_etat_processus, s_objet_argument);
3007: liberation(s_etat_processus, s_objet_resultat);
3008:
3009: (*s_etat_processus).erreur_systeme =
3010: d_es_erreur_fichier;
3011: return;
3012: }
3013:
3014: if (type_acces == 'S')
3015: {
3016: if ((descripteur = fopen(nom, "w+")) == NULL)
3017: {
3018: free(nom);
3019:
3020: liberation(s_etat_processus, s_objet_argument);
3021: liberation(s_etat_processus, s_objet_resultat);
3022:
3023: (*s_etat_processus).erreur_execution =
3024: d_ex_erreur_acces_fichier;
3025: return;
3026: }
3027: }
3028: else
3029: {
3030: if (sqlite3_open_v2(nom, &sqlite,
3031: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3032: NULL) != SQLITE_OK)
3033: {
3034: free(nom);
3035:
3036: liberation(s_etat_processus, s_objet_argument);
3037: liberation(s_etat_processus, s_objet_resultat);
3038:
3039: (*s_etat_processus).erreur_execution =
3040: d_ex_erreur_acces_fichier;
3041: return;
3042: }
3043:
3044: // Ouverture du fichier pour pouvoir gérer les
3045: // verrous à la façon des fichiers séquentiels.
3046:
3047: if ((descripteur = fopen(nom, "a+")) == NULL)
3048: {
3049: free(nom);
3050:
3051: liberation(s_etat_processus, s_objet_argument);
3052: liberation(s_etat_processus, s_objet_resultat);
3053:
3054: (*s_etat_processus).erreur_execution =
3055: d_ex_erreur_acces_fichier;
3056: return;
3057: }
3058:
3059: if (type_acces == 'D')
3060: {
3061: if (initialisation_fichier_acces_direct(
3062: s_etat_processus, sqlite,
3063: (format == 'N') ? d_faux : d_vrai)
3064: != d_absence_erreur)
3065: {
3066: free(nom);
3067:
3068: liberation(s_etat_processus, s_objet_argument);
3069: liberation(s_etat_processus, s_objet_resultat);
3070:
3071: return;
3072: }
3073: }
3074: else
3075: {
3076: if (position_clef == 0)
3077: {
3078: free(nom);
3079:
3080: liberation(s_etat_processus, s_objet_argument);
3081: liberation(s_etat_processus, s_objet_resultat);
3082:
3083: (*s_etat_processus).erreur_execution =
3084: d_ex_erreur_parametre_fichier;
3085: return;
3086: }
3087:
3088: if (initialisation_fichier_acces_indexe(
3089: s_etat_processus, sqlite, position_clef,
3090: (format == 'N') ? d_faux : d_vrai)
3091: != d_absence_erreur)
3092: {
3093: free(nom);
3094:
3095: liberation(s_etat_processus, s_objet_argument);
3096: liberation(s_etat_processus, s_objet_resultat);
3097:
3098: return;
3099: }
3100: }
3101: }
3102:
3103: break;
3104: }
3105:
3106: case 'U' :
3107: {
3108: erreur = caracteristiques_fichier(s_etat_processus,
3109: nom, &existence, &ouverture, &unite);
3110:
3111: if (erreur == d_erreur)
3112: {
3113: free(nom);
3114:
3115: liberation(s_etat_processus, s_objet_argument);
3116: liberation(s_etat_processus, s_objet_resultat);
3117:
3118: (*s_etat_processus).erreur_execution =
3119: d_ex_erreur_acces_fichier;
3120: return;
3121: }
3122:
3123: if (existence == d_faux)
3124: {
3125: if (type_acces == 'S')
3126: {
3127: if ((descripteur = fopen(nom, "w+")) == NULL)
3128: {
3129: free(nom);
3130:
3131: liberation(s_etat_processus, s_objet_argument);
3132: liberation(s_etat_processus, s_objet_resultat);
3133:
3134: (*s_etat_processus).erreur_execution =
3135: d_ex_erreur_acces_fichier;
3136: return;
3137: }
3138: }
3139: else
3140: {
3141: if (sqlite3_open_v2(nom, &sqlite,
3142: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3143: NULL) != SQLITE_OK)
3144: {
3145: free(nom);
3146:
3147: liberation(s_etat_processus, s_objet_argument);
3148: liberation(s_etat_processus, s_objet_resultat);
3149:
3150: (*s_etat_processus).erreur_execution =
3151: d_ex_erreur_acces_fichier;
3152: return;
3153: }
3154:
3155: if ((descripteur = fopen(nom, "a+")) == NULL)
3156: {
3157: free(nom);
3158:
3159: liberation(s_etat_processus, s_objet_argument);
3160: liberation(s_etat_processus, s_objet_resultat);
3161:
3162: (*s_etat_processus).erreur_execution =
3163: d_ex_erreur_acces_fichier;
3164: return;
3165: }
3166:
3167: if (type_acces == 'D')
3168: {
3169: if (initialisation_fichier_acces_direct(
3170: s_etat_processus, sqlite,
3171: (format == 'N') ? d_faux : d_vrai)
3172: != d_absence_erreur)
3173: {
3174: free(nom);
3175:
3176: liberation(s_etat_processus,
3177: s_objet_argument);
3178: liberation(s_etat_processus,
3179: s_objet_resultat);
3180:
3181: return;
3182: }
3183: }
3184: else
3185: {
3186: if (position_clef == 0)
3187: {
3188: free(nom);
3189:
3190: liberation(s_etat_processus,
3191: s_objet_argument);
3192: liberation(s_etat_processus,
3193: s_objet_resultat);
3194:
3195: (*s_etat_processus).erreur_execution =
3196: d_ex_erreur_parametre_fichier;
3197: return;
3198: }
3199:
3200: if (initialisation_fichier_acces_indexe(
3201: s_etat_processus, sqlite, position_clef,
3202: (format == 'N') ? d_faux : d_vrai)
3203: != d_absence_erreur)
3204: {
3205: free(nom);
3206:
3207: liberation(s_etat_processus,
3208: s_objet_argument);
3209: liberation(s_etat_processus,
3210: s_objet_resultat);
3211:
3212: return;
3213: }
3214: }
3215: }
3216: }
3217: else
3218: {
3219: if (type_acces == 'S')
3220: {
3221: if ((descripteur = fopen(nom, "r+")) == NULL)
3222: {
3223: free(nom);
3224:
3225: liberation(s_etat_processus, s_objet_argument);
3226: liberation(s_etat_processus, s_objet_resultat);
3227:
3228: (*s_etat_processus).erreur_execution =
3229: d_ex_erreur_acces_fichier;
3230: return;
3231: }
3232: }
3233: else
3234: {
3235: if (sqlite3_open_v2(nom, &sqlite,
3236: SQLITE_OPEN_READWRITE,
3237: NULL) != SQLITE_OK)
3238: {
3239: free(nom);
3240:
3241: liberation(s_etat_processus, s_objet_argument);
3242: liberation(s_etat_processus, s_objet_resultat);
3243:
3244: (*s_etat_processus).erreur_execution =
3245: d_ex_erreur_acces_fichier;
3246: return;
3247: }
3248:
3249: if ((descripteur = fopen(nom, "a+")) == NULL)
3250: {
3251: free(nom);
3252:
3253: liberation(s_etat_processus, s_objet_argument);
3254: liberation(s_etat_processus, s_objet_resultat);
3255:
3256: (*s_etat_processus).erreur_execution =
3257: d_ex_erreur_acces_fichier;
3258: return;
3259: }
3260: }
3261: }
3262:
3263: break;
3264: }
3265:
3266: case 'S' :
3267: {
3268: erreur = caracteristiques_fichier(s_etat_processus,
3269: nom, &existence, &ouverture, &unite);
3270:
3271: if ((erreur != d_absence_erreur) || (existence != d_faux))
3272: {
3273: free(nom);
3274:
3275: liberation(s_etat_processus, s_objet_argument);
3276: liberation(s_etat_processus, s_objet_resultat);
3277:
3278: (*s_etat_processus).erreur_execution =
3279: d_ex_erreur_acces_fichier;
3280: return;
3281: }
3282:
3283: if (type_acces == 'S')
3284: {
3285: if ((descripteur = fopen(nom, "w+")) == NULL)
3286: {
3287: free(nom);
3288:
3289: liberation(s_etat_processus, s_objet_argument);
3290: liberation(s_etat_processus, s_objet_resultat);
3291:
3292: (*s_etat_processus).erreur_execution =
3293: d_ex_erreur_acces_fichier;
3294: return;
3295: }
3296: }
3297: else
3298: {
3299: // Si le fichier existe, on le supprime.
3300:
3301: if (unlink(nom) != 0)
3302: {
3303: free(nom);
3304:
3305: liberation(s_etat_processus, s_objet_argument);
3306: liberation(s_etat_processus, s_objet_resultat);
3307:
3308: (*s_etat_processus).erreur_execution =
3309: d_ex_erreur_acces_fichier;
3310: return;
3311: }
3312:
3313: if (sqlite3_open_v2(nom, &sqlite,
3314: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3315: NULL) != SQLITE_OK)
3316: {
3317: free(nom);
3318:
3319: liberation(s_etat_processus, s_objet_argument);
3320: liberation(s_etat_processus, s_objet_resultat);
3321:
3322: (*s_etat_processus).erreur_execution =
3323: d_ex_erreur_acces_fichier;
3324: return;
3325: }
3326:
3327: if ((descripteur = fopen(nom, "a+")) == NULL)
3328: {
3329: free(nom);
3330:
3331: liberation(s_etat_processus, s_objet_argument);
3332: liberation(s_etat_processus, s_objet_resultat);
3333:
3334: (*s_etat_processus).erreur_execution =
3335: d_ex_erreur_acces_fichier;
3336: return;
3337: }
3338:
3339: if (type_acces == 'D')
3340: {
3341: if (initialisation_fichier_acces_direct(
3342: s_etat_processus, sqlite,
3343: (format == 'N') ? d_faux : d_vrai)
3344: != d_absence_erreur)
3345: {
3346: free(nom);
3347:
3348: liberation(s_etat_processus, s_objet_argument);
3349: liberation(s_etat_processus, s_objet_resultat);
3350:
3351: return;
3352: }
3353: }
3354: else
3355: {
3356: if (position_clef == 0)
3357: {
3358: free(nom);
3359:
3360: liberation(s_etat_processus, s_objet_argument);
3361: liberation(s_etat_processus, s_objet_resultat);
3362:
3363: (*s_etat_processus).erreur_execution =
3364: d_ex_erreur_parametre_fichier;
3365: return;
3366: }
3367:
3368: if (initialisation_fichier_acces_indexe(
3369: s_etat_processus, sqlite, position_clef,
3370: (format == 'N') ? d_faux : d_vrai)
3371: != d_absence_erreur)
3372: {
3373: free(nom);
3374:
3375: liberation(s_etat_processus, s_objet_argument);
3376: liberation(s_etat_processus, s_objet_resultat);
3377:
3378: return;
3379: }
3380: }
3381: }
3382:
3383: break;
3384: }
3385:
3386: default:
3387: {
3388: BUG(1, printf("type_ouverture=%c\n", type_ouverture));
3389: return;
3390: }
3391: }
3392:
3393: if (((*((struct_fichier *) (*s_objet_resultat).objet)).nom =
3394: malloc((strlen(nom) + 1) *
3395: sizeof(unsigned char))) == NULL)
3396: {
3397: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3398: return;
3399: }
3400:
3401: strcpy((*((struct_fichier *) (*s_objet_resultat).objet)).nom, nom);
3402: liberation(s_etat_processus, s_objet_argument);
3403:
3404: (*((struct_fichier *) (*s_objet_resultat).objet)).protection =
3405: protection;
3406: (*((struct_fichier *) (*s_objet_resultat).objet)).position_clef =
3407: position_clef;
3408:
3409: rewind(descripteur);
3410:
3411: lock.l_type = F_WRLCK;
3412: lock.l_whence = SEEK_SET;
3413: lock.l_start = 0;
3414: lock.l_len = 0;
3415: lock.l_pid = getpid();
3416:
3417: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
3418: {
3419: if (fclose(descripteur) != 0)
3420: {
3421: liberation(s_etat_processus, s_objet_resultat);
3422:
3423: (*s_etat_processus).erreur_systeme =
3424: d_es_erreur_fichier;
3425: return;
3426: }
3427:
3428: liberation(s_etat_processus, s_objet_resultat);
3429:
3430: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
3431: return;
3432: }
3433:
3434: if (lock.l_type == F_UNLCK)
3435: {
3436: /*
3437: * Positionnement d'un verrou exclusif d'écriture par défaut
3438: */
3439:
3440: lock.l_type = F_RDLCK;
3441: lock.l_whence = SEEK_SET;
3442: lock.l_start = 0;
3443: lock.l_len = 0;
3444: lock.l_pid = getpid();
3445:
3446: if (fcntl(fileno(descripteur), F_SETLK, &lock) == -1)
3447: {
3448: if (fclose(descripteur) != 0)
3449: {
3450: liberation(s_etat_processus, s_objet_resultat);
3451:
3452: (*s_etat_processus).erreur_systeme =
3453: d_es_erreur_fichier;
3454: return;
3455: }
3456:
3457: liberation(s_etat_processus, s_objet_resultat);
3458:
3459: (*s_etat_processus).erreur_systeme =
3460: d_es_erreur_fichier;
3461: return;
3462: }
3463: }
3464: else
3465: {
3466: /*
3467: * Test de la cohérence du verrou avec l'option PROTECTION
3468: */
3469:
3470: if ((lock.l_type == F_RDLCK) && (protection != 'R'))
3471: {
3472: free(nom);
3473:
3474: if (fclose(descripteur) != 0)
3475: {
3476: liberation(s_etat_processus, s_objet_resultat);
3477:
3478: (*s_etat_processus).erreur_systeme =
3479: d_es_erreur_fichier;
3480: return;
3481: }
3482:
3483: liberation(s_etat_processus, s_objet_resultat);
3484:
3485: (*s_etat_processus).erreur_execution =
3486: d_ex_fichier_verrouille;
3487: return;
3488: }
3489: else if ((lock.l_type == F_WRLCK) && (protection != 'W'))
3490: {
3491: free(nom);
3492:
3493: if (fclose(descripteur) != 0)
3494: {
3495: liberation(s_etat_processus, s_objet_resultat);
3496:
3497: (*s_etat_processus).erreur_systeme =
3498: d_es_erreur_fichier;
3499: return;
3500: }
3501:
3502: liberation(s_etat_processus, s_objet_resultat);
3503:
3504: (*s_etat_processus).erreur_execution =
3505: d_ex_fichier_verrouille;
3506: return;
3507: }
3508: else
3509: {
3510: free(nom);
3511:
3512: if (fclose(descripteur) != 0)
3513: {
3514: liberation(s_etat_processus, s_objet_resultat);
3515:
3516: (*s_etat_processus).erreur_systeme =
3517: d_es_erreur_fichier;
3518: return;
3519: }
3520:
3521: liberation(s_etat_processus, s_objet_resultat);
3522:
3523: (*s_etat_processus).erreur_execution =
3524: d_ex_fichier_verrouille;
3525: return;
3526: }
3527: }
3528:
3529: /*
3530: * Gestion de la liste des fichiers ouverts
3531: */
3532:
3533: l_element_courant = (*s_etat_processus).s_fichiers;
3534:
3535: if (l_element_courant == NULL)
3536: {
3537: if (((*s_etat_processus).s_fichiers = malloc(sizeof(
3538: struct_liste_chainee))) == NULL)
3539: {
3540: (*s_etat_processus).erreur_systeme =
3541: d_es_allocation_memoire;
3542: return;
3543: }
3544:
3545: (*(*s_etat_processus).s_fichiers).suivant = NULL;
3546:
3547: if (((*(*s_etat_processus).s_fichiers).donnee =
3548: malloc(sizeof(struct_descripteur_fichier))) == NULL)
3549: {
3550: (*s_etat_processus).erreur_systeme =
3551: d_es_allocation_memoire;
3552: return;
3553: }
3554:
3555: l_element_courant = (*s_etat_processus).s_fichiers;
3556: prochain_descripteur = 0;
3557: }
3558: else
3559: {
3560: /*
3561: * Recherche du premier descripteur libre
3562: */
3563:
3564: if ((chaine_descripteurs = malloc(sizeof(unsigned char) *
3565: (ds_nombre_maximum_fichiers_ouverts + 1))) == NULL)
3566: {
3567: (*s_etat_processus).erreur_systeme =
3568: d_es_allocation_memoire;
3569: return;
3570: }
3571:
3572: for(pointeur = chaine_descripteurs, i = 0;
3573: i < ds_nombre_maximum_fichiers_ouverts;
3574: (*pointeur) = d_code_espace, pointeur++, i++);
3575: (*pointeur) = d_code_fin_chaine;
3576:
3577: do
3578: {
3579: chaine_descripteurs[(*((struct_descripteur_fichier *)
3580: (*l_element_courant).donnee)).identifiant] = '-';
3581: l_element_courant = (*l_element_courant).suivant;
3582: } while(l_element_courant != NULL);
3583:
3584: i = 0;
3585: pointeur = chaine_descripteurs;
3586:
3587: while(i < ds_nombre_maximum_fichiers_ouverts)
3588: {
3589: if ((*pointeur) == ' ')
3590: {
3591: break;
3592: }
3593:
3594: pointeur++;
3595: i++;
3596: }
3597:
3598: free(chaine_descripteurs);
3599:
3600: if (i == ds_nombre_maximum_fichiers_ouverts)
3601: {
3602: (*s_etat_processus).erreur_systeme =
3603: d_es_nombre_max_descripteurs;
3604: return;
3605: }
3606:
3607: prochain_descripteur = i;
3608:
3609: /*
3610: * Ajout d'un élément à la fin de la liste chaînée
3611: */
3612:
3613: l_element_courant = (*s_etat_processus).s_fichiers;
3614: while((*l_element_courant).suivant != NULL)
3615: {
3616: l_element_courant = (*l_element_courant).suivant;
3617: }
3618:
3619: if (((*l_element_courant).suivant =
3620: allocation_maillon(s_etat_processus)) == NULL)
3621: {
3622: (*s_etat_processus).erreur_systeme =
3623: d_es_allocation_memoire;
3624: return;
3625: }
3626:
3627: l_element_courant = (*l_element_courant).suivant;
3628: (*l_element_courant).suivant = NULL;
3629:
3630: if (((*l_element_courant).donnee =
3631: malloc(sizeof(struct_descripteur_fichier))) == NULL)
3632: {
3633: (*s_etat_processus).erreur_systeme =
3634: d_es_allocation_memoire;
3635: return;
3636: }
3637: }
3638:
3639: (*((struct_fichier *) (*s_objet_resultat).objet)).descripteur
3640: = prochain_descripteur;
3641: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3642: .identifiant = prochain_descripteur;
3643:
3644: if (type_acces == 'S')
3645: {
3646: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3647: .type = 'C';
3648: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3649: .descripteur_c = descripteur;
3650: }
3651: else
3652: {
3653: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3654: .type = 'S';
3655: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3656: .descripteur_c = descripteur;
3657: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3658: .descripteur_sqlite = sqlite;
3659: }
3660:
3661: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3662: .pid = getpid();
3663: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3664: .tid = pthread_self();
3665: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3666: .effacement = (type_ouverture == 'S') ? 'Y' : 'N';
3667:
3668: (*((struct_descripteur_fichier *) (*l_element_courant)
3669: .donnee)).nom = nom;
3670: }
3671: else if (type_arguments == 'S')
3672: {
3673: /*
3674: * Traitement des sockets
3675: */
3676:
3677:
3678: inline logical1 options_socket()
3679: {
3680: /*
3681: * Options des sockets
3682: */
3683:
3684: # define WARNING(message) \
3685: if ((*s_etat_processus).langue != 'F') \
3686: printf("+++Warning : %s unavailable on host system\n", \
3687: message); \
3688: else \
3689: printf("+++Attention : %s non disponible sur le système " \
3690: "hôte\n", message)
3691:
3692: if (options[d_BIND_TO_DEVICE] == 'Y')
3693: {
3694: # ifdef SO_BINDTODEVICE
3695: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3696: .objet)).socket, SOL_SOCKET, SO_BINDTODEVICE,
3697: peripherique, strlen(peripherique)) != 0)
3698: {
3699: liberation(s_etat_processus, s_objet_argument);
3700: liberation(s_etat_processus, s_objet_resultat);
3701:
3702: (*s_etat_processus).erreur_execution =
3703: d_ex_erreur_parametre_fichier;
3704: return(d_erreur);
3705: }
3706: # else
3707: WARNING("BIND TO DEVICE");
3708: # endif
3709: }
3710:
3711: if (options[d_BROADCAST] == 'Y')
3712: {
3713: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3714: .objet)).socket, SOL_SOCKET, SO_BROADCAST,
3715: &drapeau, sizeof(drapeau)) != 0)
3716: {
3717: liberation(s_etat_processus, s_objet_argument);
3718: liberation(s_etat_processus, s_objet_resultat);
3719:
3720: (*s_etat_processus).erreur_execution =
3721: d_ex_erreur_parametre_fichier;
3722: return(d_erreur);
3723: }
3724: }
3725:
3726: if (options[d_DONT_ROUTE] == 'Y')
3727: {
3728: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3729: .objet)).socket, SOL_SOCKET, SO_DONTROUTE,
3730: &drapeau, sizeof(drapeau)) != 0)
3731: {
3732: liberation(s_etat_processus, s_objet_argument);
3733: liberation(s_etat_processus, s_objet_resultat);
3734:
3735: (*s_etat_processus).erreur_execution =
3736: d_ex_erreur_parametre_fichier;
3737: return(d_erreur);
3738: }
3739: }
3740:
3741: if (options[d_KEEP_ALIVE] == 'Y')
3742: {
3743: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3744: .objet)).socket, SOL_SOCKET, SO_KEEPALIVE,
3745: &drapeau, sizeof(drapeau)) != 0)
3746: {
3747: liberation(s_etat_processus, s_objet_argument);
3748: liberation(s_etat_processus, s_objet_resultat);
3749:
3750: (*s_etat_processus).erreur_execution =
3751: d_ex_erreur_parametre_fichier;
3752: return(d_erreur);
3753: }
3754: }
3755:
3756: if (options[d_PRIORITY] == 'Y')
3757: {
3758: # ifdef SO_PRIORITY
3759: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3760: .objet)).socket, SOL_SOCKET, SO_PRIORITY,
3761: &priorite, sizeof(priorite)) != 0)
3762: {
3763: liberation(s_etat_processus, s_objet_argument);
3764: liberation(s_etat_processus, s_objet_resultat);
3765:
3766: (*s_etat_processus).erreur_execution =
3767: d_ex_erreur_parametre_fichier;
3768: return(d_erreur);
3769: }
3770: # else
3771: WARNING("PRIORITY");
3772: # endif
3773: }
3774:
3775: if (options[d_RECEIVE_BUFFER] == 'Y')
3776: {
3777: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3778: .objet)).socket, SOL_SOCKET, SO_RCVBUF,
3779: &buffer_reception, sizeof(buffer_reception)) != 0)
3780: {
3781: liberation(s_etat_processus, s_objet_argument);
3782: liberation(s_etat_processus, s_objet_resultat);
3783:
3784: (*s_etat_processus).erreur_execution =
3785: d_ex_erreur_parametre_fichier;
3786: return(d_erreur);
3787: }
3788: }
3789:
3790: if (options[d_FORCE_RECEIVE_BUFFER] == 'Y')
3791: {
3792: # ifdef SO_RCVBUFFORCE
3793: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3794: .objet)).socket, SOL_SOCKET, SO_RCVBUFFORCE,
3795: &buffer_reception, sizeof(buffer_reception))
3796: != 0)
3797: {
3798: liberation(s_etat_processus, s_objet_argument);
3799: liberation(s_etat_processus, s_objet_resultat);
3800:
3801: (*s_etat_processus).erreur_execution =
3802: d_ex_erreur_parametre_fichier;
3803: return(d_erreur);
3804: }
3805: # else
3806: WARNING("FORCE_RECEIVE_BUFFER");
3807: # endif
3808: }
3809:
3810: if (options[d_SEND_BUFFER] == 'Y')
3811: {
3812: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3813: .objet)).socket, SOL_SOCKET, SO_SNDBUF,
3814: &buffer_emission, sizeof(buffer_emission)) != 0)
3815: {
3816: liberation(s_etat_processus, s_objet_argument);
3817: liberation(s_etat_processus, s_objet_resultat);
3818:
3819: (*s_etat_processus).erreur_execution =
3820: d_ex_erreur_parametre_fichier;
3821: return(d_erreur);
3822: }
3823: }
3824:
3825: if (options[d_FORCE_SEND_BUFFER] == 'Y')
3826: {
3827: # ifdef SO_SNDBUFFORCE
3828: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3829: .objet)).socket, SOL_SOCKET, SO_SNDBUFFORCE,
3830: &buffer_emission, sizeof(buffer_emission)) != 0)
3831: {
3832: liberation(s_etat_processus, s_objet_argument);
3833: liberation(s_etat_processus, s_objet_resultat);
3834:
3835: (*s_etat_processus).erreur_execution =
3836: d_ex_erreur_parametre_fichier;
3837: return(d_erreur);
3838: }
3839: # else
3840: WARNING("FORCE_SEND_BUFFER");
3841: # endif
3842: }
3843:
3844: if (options[d_RECEIVING_TIMEOUT] == 'Y')
3845: {
3846: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3847: .objet)).socket, SOL_SOCKET, SO_RCVTIMEO,
3848: &timeout_reception, sizeof(timeout_reception)) != 0)
3849: {
3850: liberation(s_etat_processus, s_objet_argument);
3851: liberation(s_etat_processus, s_objet_resultat);
3852:
3853: (*s_etat_processus).erreur_execution =
3854: d_ex_erreur_parametre_fichier;
3855: return(d_erreur);
3856: }
3857: }
3858:
3859: if (options[d_SENDING_TIMEOUT] == 'Y')
3860: {
3861: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3862: .objet)).socket, SOL_SOCKET, SO_SNDTIMEO,
3863: &timeout_emission, sizeof(timeout_emission)) != 0)
3864: {
3865: liberation(s_etat_processus, s_objet_argument);
3866: liberation(s_etat_processus, s_objet_resultat);
3867:
3868: (*s_etat_processus).erreur_execution =
3869: d_ex_erreur_parametre_fichier;
3870: return(d_erreur);
3871: }
3872: }
3873:
3874: if (options[d_REUSE_ADDRESS] == 'Y')
3875: {
3876: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3877: .objet)).socket, SOL_SOCKET, SO_REUSEADDR,
3878: &drapeau, sizeof(drapeau)) != 0)
3879: {
3880: liberation(s_etat_processus, s_objet_argument);
3881: liberation(s_etat_processus, s_objet_resultat);
3882:
3883: (*s_etat_processus).erreur_execution =
3884: d_ex_erreur_parametre_fichier;
3885: return(d_erreur);
3886: }
3887: }
3888:
3889: return(d_absence_erreur);
3890: #undef WARNING
3891: }
3892:
3893: /*
3894: * Vérification de la cohérence des arguments et traitement
3895: * des valeurs par défaut.
3896: */
3897:
3898: if (format == ' ')
3899: {
3900: format = 'N';
3901: }
3902:
3903: if (protection == ' ')
3904: {
3905: protection = 'N';
3906: }
3907:
3908: if (type_domaine == ' ')
3909: {
3910: type_domaine = 'L';
3911: }
3912:
3913: if (type_socket == ' ')
3914: {
3915: type_socket = 'S';
3916: type = SOCK_STREAM;
3917: }
3918:
3919: if (nom != NULL)
3920: {
3921: if (strcmp(protocole, "") == 0)
3922: {
3923: strcpy(protocole, "UNIX");
3924: }
3925: }
3926: else
3927: {
3928: if (strcmp(protocole, "") == 0)
3929: {
3930: strcpy(protocole, "IPV4");
3931: }
3932: }
3933:
3934: if ((nom != NULL) && (hote != NULL))
3935: {
3936: liberation(s_etat_processus, s_objet_argument);
3937:
3938: (*s_etat_processus).erreur_execution =
3939: d_ex_erreur_parametre_fichier;
3940: return;
3941: }
3942:
3943: if ((nom != NULL) && (strcmp(protocole, "UNIX") != 0))
3944: {
3945: liberation(s_etat_processus, s_objet_argument);
3946:
3947: (*s_etat_processus).erreur_execution =
3948: d_ex_erreur_parametre_fichier;
3949: return;
3950: }
3951:
3952: if ((hote != NULL) && (strcmp(protocole, "UNIX") == 0))
3953: {
3954: liberation(s_etat_processus, s_objet_argument);
3955:
3956: (*s_etat_processus).erreur_execution =
3957: d_ex_erreur_parametre_fichier;
3958: return;
3959: }
3960:
3961: if ((nom != NULL) && (type_domaine == 'F') && (type_adresse != ' '))
3962: {
3963: liberation(s_etat_processus, s_objet_argument);
3964:
3965: (*s_etat_processus).erreur_execution =
3966: d_ex_erreur_parametre_fichier;
3967: return;
3968: }
3969:
3970: if ((presence_port == d_vrai) && (nom != NULL))
3971: {
3972: liberation(s_etat_processus, s_objet_argument);
3973:
3974: (*s_etat_processus).erreur_execution =
3975: d_ex_erreur_parametre_fichier;
3976: return;
3977: }
3978:
3979: if (((strcmp(protocole, "IPV4") == 0) && (type_adresse == '6')) ||
3980: ((strcmp(protocole, "IPV6") == 0) && (type_adresse == '4')))
3981: {
3982: liberation(s_etat_processus, s_objet_argument);
3983:
3984: (*s_etat_processus).erreur_execution =
3985: d_ex_erreur_parametre_fichier;
3986: return;
3987: }
3988:
3989: if ((nombre_maximal_connexions != 0) && ((type_socket != 'S') &&
3990: (type_socket != 'Q')))
3991: {
3992: liberation(s_etat_processus, s_objet_argument);
3993:
3994: (*s_etat_processus).erreur_execution =
3995: d_ex_erreur_parametre_fichier;
3996: return;
3997: }
3998:
3999: if (nombre_maximal_connexions == 0)
4000: {
4001: nombre_maximal_connexions = 1;
4002: }
4003:
4004: if (protocole_socket == NULL)
4005: {
4006: protocole_numerique = 0;
4007: }
4008: else
4009: {
4010: for(i = 0; i < strlen(protocole_socket); i++)
4011: {
4012: if ((protocole_socket[i] >= 'A') &&
4013: (protocole_socket[i] <= 'Z'))
4014: {
4015: protocole_socket[i] += 'a' - 'A';
4016: }
4017: }
4018:
4019: if (strcmp(protocole_socket, "ipv4") == 0)
4020: {
4021: protocole_socket[2] = d_code_fin_chaine;
4022: }
4023:
4024: if ((s_protocole = getprotobyname(protocole_socket)) == NULL)
4025: {
4026: liberation(s_etat_processus, s_objet_argument);
4027:
4028: (*s_etat_processus).erreur_execution =
4029: d_ex_erreur_parametre_fichier;
4030: return;
4031: }
4032:
4033: protocole_numerique = (*s_protocole).p_proto;
4034: }
4035:
4036: if ((s_objet_resultat = allocation(s_etat_processus, SCK))
4037: == NULL)
4038: {
4039: (*s_etat_processus).erreur_systeme =
4040: d_es_allocation_memoire;
4041: return;
4042: }
4043:
4044: if (((*((struct_socket *) (*s_objet_resultat).objet)).format =
4045: allocation(s_etat_processus, LST)) == NULL)
4046: {
4047: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4048: return;
4049: }
4050:
4051: (*((struct_socket *) (*s_objet_resultat).objet)).protection
4052: = protection;
4053: (*(*((struct_socket *) (*s_objet_resultat).objet))
4054: .format).objet = NULL;
4055:
4056: switch(type_socket)
4057: {
4058: case 'S' :
4059: type = SOCK_STREAM;
4060: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4061: type, "STREAM");
4062: break;
4063:
4064: case 'D' :
4065: type = SOCK_DGRAM;
4066: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4067: type, "DATAGRAM");
4068: break;
4069:
4070: case 'Q' :
4071: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4072: type, "SEQUENTIAL DATAGRAM");
4073: type = SOCK_SEQPACKET;
4074: break;
4075:
4076: case 'R' :
4077: type = SOCK_RAW;
4078: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4079: type, "RAW");
4080: break;
4081:
4082: case 'M' :
4083: type = SOCK_RDM;
4084: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4085: type, "ROBUST DATAGRAM");
4086: break;
4087:
4088: default :
4089: BUG(1, printf("type_socket=%c\n", type_socket));
4090: break;
4091: }
4092:
4093: if ((protection != 'N') && ((type_socket != 'S') &&
4094: (type_socket != 'Q')))
4095: {
4096: liberation(s_etat_processus, s_objet_argument);
4097: liberation(s_etat_processus, s_objet_resultat);
4098:
4099: (*s_etat_processus).erreur_execution =
4100: d_ex_erreur_parametre_fichier;
4101: return;
4102: }
4103:
4104: if (nom == NULL)
4105: {
4106: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
4107: malloc(sizeof(unsigned char))) == NULL)
4108: {
4109: (*s_etat_processus).erreur_systeme =
4110: d_es_allocation_memoire;
4111: return;
4112: }
4113:
4114: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).adresse,
4115: "");
4116: }
4117: else
4118: {
4119: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
4120: transliteration(s_etat_processus, nom,
4121: d_locale, "UTF-8")) == NULL)
4122: {
4123: liberation(s_etat_processus, s_objet_argument);
4124: liberation(s_etat_processus, s_objet_resultat);
4125: return;
4126: }
4127: }
4128:
4129: if (((*((struct_socket *) (*s_objet_resultat).objet))
4130: .adresse_distante = malloc(sizeof(unsigned char))) == NULL)
4131: {
4132: (*s_etat_processus).erreur_systeme =
4133: d_es_allocation_memoire;
4134: return;
4135: }
4136:
4137: strcpy((*((struct_socket *) (*s_objet_resultat).objet))
4138: .adresse_distante, "");
4139:
4140: (*((struct_socket *) (*s_objet_resultat).objet)).localisation =
4141: type_domaine;
4142: (*((struct_socket *) (*s_objet_resultat).objet)).binaire =
4143: format;
4144: (*((struct_socket *) (*s_objet_resultat).objet)).pid =
4145: getpid();
4146: (*((struct_socket *) (*s_objet_resultat).objet)).tid =
4147: pthread_self();
4148: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
4149: = 'Y';
4150: (*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee
4151: = d_faux;
4152:
4153: if (type_domaine == 'L')
4154: { // Socket serveur
4155: if (nom != NULL)
4156: {
4157: /*
4158: * La socket locale est dans l'espace des noms.
4159: */
4160:
4161: if (((*((struct_socket *) (*s_objet_resultat).objet))
4162: .socket = socket(PF_UNIX, type,
4163: protocole_numerique)) == -1)
4164: {
4165: liberation(s_etat_processus, s_objet_argument);
4166: liberation(s_etat_processus, s_objet_resultat);
4167:
4168: (*s_etat_processus).erreur_execution =
4169: d_ex_erreur_acces_fichier;
4170: return;
4171: }
4172:
4173: (*((struct_socket *) (*s_objet_resultat).objet)).domaine
4174: = PF_UNIX;
4175: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4176: = 'Y';
4177:
4178: socket_unix.sun_family = AF_UNIX;
4179:
4180: pointeur = (*((struct_socket *)
4181: (*s_objet_resultat).objet)).adresse;
4182:
4183: while((*pointeur) == d_code_espace)
4184: {
4185: pointeur++;
4186: }
4187:
4188: strncpy(socket_unix.sun_path, pointeur, UNIX_PATH_MAX);
4189: socket_unix.sun_path[UNIX_PATH_MAX - 1] = d_code_fin_chaine;
4190:
4191: if (options_socket() == d_erreur)
4192: {
4193: liberation(s_etat_processus, s_objet_argument);
4194: liberation(s_etat_processus, s_objet_resultat);
4195:
4196: return;
4197: }
4198:
4199: if (bind((*((struct_socket *) (*s_objet_resultat).objet))
4200: .socket, (const struct sockaddr *) &socket_unix,
4201: sizeof(socket_unix)) != 0)
4202: {
4203: liberation(s_etat_processus, s_objet_argument);
4204: liberation(s_etat_processus, s_objet_resultat);
4205:
4206: (*s_etat_processus).erreur_execution =
4207: d_ex_erreur_acces_fichier;
4208: return;
4209: }
4210: }
4211: else
4212: {
4213: /*
4214: * La socket est une socket réseau locale. L'adresse
4215: * passée en argument est l'adresse sur laquelle
4216: * cette socket est à l'écoute.
4217: */
4218:
4219: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4220: = 'N';
4221:
4222: if (hote != NULL)
4223: { // Hôte défini par un nom
4224: resolution = NULL;
4225:
4226: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4227: {
4228: liberation(s_etat_processus, s_objet_argument);
4229: liberation(s_etat_processus, s_objet_resultat);
4230:
4231: if (resolution != NULL)
4232: {
4233: freeaddrinfo(resolution);
4234: }
4235:
4236: (*s_etat_processus).erreur_execution =
4237: d_ex_erreur_acces_fichier;
4238: return;
4239: }
4240:
4241: if (strcmp(protocole, "IPV4") == 0)
4242: { // Accès en IPv4
4243: resolution_courante = resolution;
4244:
4245: while(resolution_courante != NULL)
4246: {
4247: if ((*resolution_courante).ai_family ==
4248: AF_INET)
4249: {
4250: break;
4251: }
4252:
4253: resolution_courante = (*resolution_courante)
4254: .ai_next;
4255: }
4256:
4257: if (resolution_courante == NULL)
4258: {
4259: liberation(s_etat_processus, s_objet_argument);
4260: liberation(s_etat_processus, s_objet_resultat);
4261:
4262: freeaddrinfo(resolution);
4263:
4264: (*s_etat_processus).erreur_execution =
4265: d_ex_erreur_acces_fichier;
4266: return;
4267: }
4268:
4269: if (((*((struct_socket *)
4270: (*s_objet_resultat).objet))
4271: .socket = socket(PF_INET, type,
4272: protocole_numerique)) == -1)
4273: {
4274: liberation(s_etat_processus, s_objet_argument);
4275: liberation(s_etat_processus, s_objet_resultat);
4276:
4277: freeaddrinfo(resolution);
4278:
4279: (*s_etat_processus).erreur_execution =
4280: d_ex_erreur_acces_fichier;
4281: return;
4282: }
4283:
4284: (*((struct_socket *) (*s_objet_resultat).objet))
4285: .domaine = PF_INET;
4286:
4287: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4288: socket_ipv4.sin_family = AF_INET;
4289: socket_ipv4.sin_port = htons((uint16_t) port);
4290: socket_ipv4.sin_addr.s_addr =
4291: (*((struct sockaddr_in *)
4292: (*resolution_courante).ai_addr))
4293: .sin_addr.s_addr;
4294:
4295: if (options_socket() == d_erreur)
4296: {
4297: liberation(s_etat_processus, s_objet_argument);
4298: liberation(s_etat_processus, s_objet_resultat);
4299:
4300: freeaddrinfo(resolution);
4301: return;
4302: }
4303:
4304: if (bind((*((struct_socket *) (*s_objet_resultat)
4305: .objet)).socket, (const struct sockaddr *)
4306: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4307: {
4308: liberation(s_etat_processus, s_objet_argument);
4309: liberation(s_etat_processus, s_objet_resultat);
4310:
4311: freeaddrinfo(resolution);
4312:
4313: (*s_etat_processus).erreur_execution =
4314: d_ex_erreur_acces_fichier;
4315: return;
4316: }
4317:
4318: if (((*((struct_socket *) (*s_objet_resultat)
4319: .objet)).adresse = malloc(22 *
4320: sizeof(unsigned char))) == NULL)
4321: {
4322: (*s_etat_processus).erreur_systeme =
4323: d_es_allocation_memoire;
4324: return;
4325: }
4326:
4327: sprintf((*((struct_socket *) (*s_objet_resultat)
4328: .objet)).adresse, "%d.%d.%d.%d",
4329: (ntohl((*((struct sockaddr_in *)
4330: (*resolution_courante).ai_addr)).sin_addr
4331: .s_addr) >> 24) & 0xFF,
4332: (ntohl((*((struct sockaddr_in *)
4333: (*resolution_courante).ai_addr)).sin_addr
4334: .s_addr) >> 16) & 0xFF,
4335: (ntohl((*((struct sockaddr_in *)
4336: (*resolution_courante).ai_addr)).sin_addr
4337: .s_addr) >> 8) & 0xFF,
4338: ntohl((*((struct sockaddr_in *)
4339: (*resolution_courante).ai_addr)).sin_addr
4340: .s_addr) & 0xFF);
4341: }
4342: else
4343: { // Accès en IPv6
4344: # ifdef IPV6
4345: resolution_courante = resolution;
4346:
4347: while(resolution_courante != NULL)
4348: {
4349: if ((*resolution_courante).ai_family ==
4350: AF_INET6)
4351: {
4352: break;
4353: }
4354:
4355: resolution_courante = (*resolution_courante)
4356: .ai_next;
4357: }
4358:
4359: if (resolution_courante == NULL)
4360: {
4361: liberation(s_etat_processus, s_objet_argument);
4362: liberation(s_etat_processus, s_objet_resultat);
4363:
4364: freeaddrinfo(resolution);
4365:
4366: (*s_etat_processus).erreur_execution =
4367: d_ex_erreur_acces_fichier;
4368: return;
4369: }
4370:
4371: if (((*((struct_socket *)
4372: (*s_objet_resultat).objet))
4373: .socket = socket(PF_INET6, type,
4374: protocole_numerique)) == -1)
4375: {
4376: liberation(s_etat_processus, s_objet_argument);
4377: liberation(s_etat_processus, s_objet_resultat);
4378:
4379: freeaddrinfo(resolution);
4380:
4381: (*s_etat_processus).erreur_execution =
4382: d_ex_erreur_acces_fichier;
4383: return;
4384: }
4385:
4386: (*((struct_socket *) (*s_objet_resultat).objet))
4387: .domaine = PF_INET6;
4388:
4389: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4390: socket_ipv6.sin6_family = AF_INET6;
4391: socket_ipv6.sin6_port = htons((uint16_t) port);
4392:
4393: for(i = 0; i < 16;
4394: socket_ipv6.sin6_addr.s6_addr[i] =
4395: (*((struct sockaddr_in6 *)
4396: (*resolution_courante).ai_addr))
4397: .sin6_addr.s6_addr[i], i++);
4398:
4399: if (options_socket() == d_erreur)
4400: {
4401: liberation(s_etat_processus, s_objet_argument);
4402: liberation(s_etat_processus, s_objet_resultat);
4403:
4404: freeaddrinfo(resolution);
4405: return;
4406: }
4407:
4408: if (bind((*((struct_socket *) (*s_objet_resultat)
4409: .objet)).socket, (const struct sockaddr *)
4410: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4411: {
4412: liberation(s_etat_processus, s_objet_argument);
4413: liberation(s_etat_processus, s_objet_resultat);
4414:
4415: freeaddrinfo(resolution);
4416:
4417: (*s_etat_processus).erreur_execution =
4418: d_ex_erreur_acces_fichier;
4419: return;
4420: }
4421:
4422: if (((*((struct_socket *) (*s_objet_resultat)
4423: .objet)).adresse = malloc(55 *
4424: sizeof(unsigned char))) == NULL)
4425: {
4426: (*s_etat_processus).erreur_systeme =
4427: d_es_allocation_memoire;
4428: return;
4429: }
4430:
4431: for(i = 0; i < 16; i++)
4432: {
4433: sprintf((*((struct_socket *) (*s_objet_resultat)
4434: .objet)).adresse,
4435: (i == 0) ? "%s%X" : "%s:%X",
4436: (*((struct_socket *) (*s_objet_resultat)
4437: .objet)).adresse,
4438: (*((struct sockaddr_in6 *)
4439: (*resolution_courante).ai_addr))
4440: .sin6_addr.s6_addr[i]);
4441: }
4442: # else
4443: if ((*s_etat_processus).langue == 'F')
4444: {
4445: printf("+++Attention : Support du protocole"
4446: " IPv6 indisponible\n");
4447: }
4448: else
4449: {
4450: printf("+++Warning : IPv6 support "
4451: "unavailable\n");
4452: }
4453: # endif
4454: }
4455:
4456: freeaddrinfo(resolution);
4457:
4458: sprintf((*((struct_socket *) (*s_objet_resultat)
4459: .objet)).adresse, "%s(%u)",
4460: (*((struct_socket *) (*s_objet_resultat)
4461: .objet)).adresse, (unsigned int) port);
4462: }
4463: else
4464: { // Hôte défini par une adresse
4465: if (strcmp(protocole, "IPV4") == 0)
4466: { // Accès en IPv4
4467: if (((*((struct_socket *) (*s_objet_resultat)
4468: .objet)).adresse = malloc(22 *
4469: sizeof(unsigned char))) == NULL)
4470: {
4471: (*s_etat_processus).erreur_systeme =
4472: d_es_allocation_memoire;
4473: return;
4474: }
4475:
4476: (*((struct_socket *) (*s_objet_resultat).objet))
4477: .adresse[0] = d_code_fin_chaine;
4478:
4479: for(i = 0; i < 4; i++)
4480: {
4481: sprintf((*((struct_socket *) (*s_objet_resultat)
4482: .objet)).adresse,
4483: (i == 0) ? "%s%d" : "%s.%d",
4484: (*((struct_socket *) (*s_objet_resultat)
4485: .objet)).adresse, (int) adresse[i]);
4486: }
4487:
4488: sprintf((*((struct_socket *) (*s_objet_resultat)
4489: .objet)).adresse, "%s(%u)",
4490: (*((struct_socket *) (*s_objet_resultat)
4491: .objet)).adresse, (unsigned int) port);
4492:
4493: if (((*((struct_socket *)
4494: (*s_objet_resultat).objet))
4495: .socket = socket(PF_INET, type,
4496: protocole_numerique)) == -1)
4497: {
4498: liberation(s_etat_processus, s_objet_argument);
4499: liberation(s_etat_processus, s_objet_resultat);
4500:
4501: (*s_etat_processus).erreur_execution =
4502: d_ex_erreur_acces_fichier;
4503: return;
4504: }
4505:
4506: (*((struct_socket *) (*s_objet_resultat).objet))
4507: .domaine = PF_INET;
4508:
4509: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4510: socket_ipv4.sin_family = AF_INET;
4511: socket_ipv4.sin_port = htons((uint16_t) port);
4512:
4513: adresse_ipv4 = 0;
4514: for(i = 0; i < 4; adresse_ipv4 =
4515: (256 * adresse_ipv4) + adresse[i++]);
4516:
4517: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
4518:
4519: if (options_socket() == d_erreur)
4520: {
4521: liberation(s_etat_processus, s_objet_argument);
4522: liberation(s_etat_processus, s_objet_resultat);
4523:
4524: return;
4525: }
4526:
4527: if (bind((*((struct_socket *) (*s_objet_resultat)
4528: .objet)).socket, (const struct sockaddr *)
4529: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4530: {
4531: liberation(s_etat_processus, s_objet_argument);
4532: liberation(s_etat_processus, s_objet_resultat);
4533:
4534: (*s_etat_processus).erreur_execution =
4535: d_ex_erreur_acces_fichier;
4536: return;
4537: }
4538: }
4539: else
4540: { // Accès en IPv6
4541: # ifdef IPV6
4542: if (((*((struct_socket *) (*s_objet_resultat)
4543: .objet)).adresse = malloc(55 *
4544: sizeof(unsigned char))) == NULL)
4545: {
4546: (*s_etat_processus).erreur_systeme =
4547: d_es_allocation_memoire;
4548: return;
4549: }
4550:
4551: (*((struct_socket *) (*s_objet_resultat).objet))
4552: .adresse[0] = d_code_fin_chaine;
4553:
4554: for(i = 0; i < 16; i++)
4555: {
4556: sprintf((*((struct_socket *) (*s_objet_resultat)
4557: .objet)).adresse,
4558: (i == 0) ? "%s%X" : "%s:%X",
4559: (*((struct_socket *) (*s_objet_resultat)
4560: .objet)).adresse, (unsigned int)
4561: adresse[i]);
4562: }
4563:
4564: sprintf((*((struct_socket *) (*s_objet_resultat)
4565: .objet)).adresse, "%s(%u)",
4566: (*((struct_socket *) (*s_objet_resultat)
4567: .objet)).adresse, (unsigned int) port);
4568:
4569: if (((*((struct_socket *)
4570: (*s_objet_resultat).objet))
4571: .socket = socket(PF_INET6, type,
4572: protocole_numerique)) == -1)
4573: {
4574: liberation(s_etat_processus, s_objet_argument);
4575: liberation(s_etat_processus, s_objet_resultat);
4576:
4577: (*s_etat_processus).erreur_execution =
4578: d_ex_erreur_acces_fichier;
4579: return;
4580: }
4581:
4582: (*((struct_socket *) (*s_objet_resultat).objet))
4583: .domaine = PF_INET6;
4584:
4585: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4586: socket_ipv6.sin6_family = AF_INET6;
4587: socket_ipv6.sin6_port = htons((uint16_t) port);
4588:
4589: for(i = 0; i < 16;
4590: socket_ipv6.sin6_addr.s6_addr[i] =
4591: (unsigned char) (adresse[i]), i++);
4592:
4593: if (options_socket() == d_erreur)
4594: {
4595: liberation(s_etat_processus, s_objet_argument);
4596: liberation(s_etat_processus, s_objet_resultat);
4597:
4598: return;
4599: }
4600:
4601: if (bind((*((struct_socket *) (*s_objet_resultat)
4602: .objet)).socket, (const struct sockaddr *)
4603: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4604: {
4605: liberation(s_etat_processus, s_objet_argument);
4606: liberation(s_etat_processus, s_objet_resultat);
4607:
4608: (*s_etat_processus).erreur_execution =
4609: d_ex_erreur_acces_fichier;
4610: return;
4611: }
4612: # else
4613: if ((*s_etat_processus).langue == 'F')
4614: {
4615: printf("+++Attention : Support du protocole"
4616: " IPv6 indisponible\n");
4617: }
4618: else
4619: {
4620: printf("+++Warning : IPv6 support "
4621: "unavailable\n");
4622: }
4623: # endif
4624: }
4625: }
4626:
4627: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4628: = 'N';
4629: }
4630:
4631: if ((type_socket == 'S') || (type_socket == 'Q'))
4632: {
4633: if (listen((*((struct_socket *) (*s_objet_resultat).objet))
4634: .socket, (int) nombre_maximal_connexions) != 0)
4635: {
4636: liberation(s_etat_processus, s_objet_argument);
4637: liberation(s_etat_processus, s_objet_resultat);
4638:
4639: (*s_etat_processus).erreur_execution =
4640: d_ex_erreur_acces_fichier;
4641: return;
4642: }
4643:
4644: (*((struct_socket *) (*s_objet_resultat).objet))
4645: .socket_connectee = d_vrai;
4646:
4647: if (protection == 'R')
4648: { // WRITEONLY
4649: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4650: .objet)).socket, SHUT_RD) != 0)
4651: {
4652: liberation(s_etat_processus, s_objet_argument);
4653: liberation(s_etat_processus, s_objet_resultat);
4654:
4655: (*s_etat_processus).erreur_execution =
4656: d_ex_erreur_acces_fichier;
4657: return;
4658: }
4659: }
4660: else if (protection == 'W')
4661: { // READONLY
4662: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4663: .objet)).socket, SHUT_WR) != 0)
4664: {
4665: liberation(s_etat_processus, s_objet_argument);
4666: liberation(s_etat_processus, s_objet_resultat);
4667:
4668: (*s_etat_processus).erreur_execution =
4669: d_ex_erreur_acces_fichier;
4670: return;
4671: }
4672: }
4673: else
4674: { // READWRITE
4675: }
4676: }
4677: }
4678: else
4679: { // Socket cliente
4680: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4681: = 'N';
4682:
4683: /*
4684: * Dans le cas où la socket n'est pas connectée, on
4685: * ne peut utiliser ni "NAME", ni "HOST", ni "PORT",
4686: * et encore moins spécifier une adresse. En effet, la cible
4687: * est défini par la commande TARGET.
4688: */
4689:
4690: if ((type_socket != 'S') && (type_socket != 'Q'))
4691: {
4692: if ((presence_port == d_vrai) || (hote != NULL) ||
4693: (nom != NULL) || (type_adresse != ' '))
4694: {
4695: liberation(s_etat_processus, s_objet_argument);
4696: liberation(s_etat_processus, s_objet_resultat);
4697:
4698: (*s_etat_processus).erreur_execution =
4699: d_ex_erreur_parametre_fichier;
4700: return;
4701: }
4702: }
4703:
4704: if (nom != NULL)
4705: {
4706: /*
4707: * La socket est dans l'espace des noms.
4708: */
4709:
4710: if (((*((struct_socket *) (*s_objet_resultat).objet))
4711: .socket = socket(PF_UNIX, type,
4712: protocole_numerique)) == -1)
4713: {
4714: liberation(s_etat_processus, s_objet_argument);
4715: liberation(s_etat_processus, s_objet_resultat);
4716:
4717: (*s_etat_processus).erreur_execution =
4718: d_ex_erreur_acces_fichier;
4719: return;
4720: }
4721:
4722: (*((struct_socket *) (*s_objet_resultat).objet))
4723: .domaine = PF_UNIX;
4724:
4725: socket_unix.sun_family = AF_UNIX;
4726: strncpy(socket_unix.sun_path, (*((struct_socket *)
4727: (*s_objet_resultat).objet)).adresse, UNIX_PATH_MAX);
4728: socket_unix.sun_path[UNIX_PATH_MAX - 1] = d_code_fin_chaine;
4729:
4730: if ((type_socket == 'S') || (type_socket == 'Q'))
4731: {
4732: if (connect((*((struct_socket *) (*s_objet_resultat)
4733: .objet)).socket, (const struct sockaddr *)
4734: &socket_unix, sizeof(socket_unix)) != 0)
4735: {
4736: liberation(s_etat_processus, s_objet_argument);
4737: liberation(s_etat_processus, s_objet_resultat);
4738:
4739: (*s_etat_processus).erreur_execution =
4740: d_ex_erreur_acces_fichier;
4741: return;
4742: }
4743:
4744: (*((struct_socket *) (*s_objet_resultat).objet))
4745: .socket_connectee = d_vrai;
4746: (*((struct_socket *) (*s_objet_resultat).objet))
4747: .socket_en_ecoute = 'N';
4748: }
4749: }
4750: else
4751: {
4752: /*
4753: * La socket est une socket réseau. L'adresse
4754: * passée en argument est l'adresse sur laquelle
4755: * cette socket est à l'écoute.
4756: */
4757:
4758: if (hote != NULL)
4759: { // Hôte défini par un nom
4760: resolution = NULL;
4761:
4762: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4763: {
4764: liberation(s_etat_processus, s_objet_argument);
4765: liberation(s_etat_processus, s_objet_resultat);
4766:
4767: if (resolution != NULL)
4768: {
4769: freeaddrinfo(resolution);
4770: }
4771:
4772: (*s_etat_processus).erreur_execution =
4773: d_ex_erreur_acces_fichier;
4774: return;
4775: }
4776:
4777: if (strcmp(protocole, "IPV4") == 0)
4778: { // Accès en IPv4
4779: resolution_courante = resolution;
4780:
4781: while(resolution_courante != NULL)
4782: {
4783: if ((*resolution_courante).ai_family ==
4784: AF_INET)
4785: {
4786: break;
4787: }
4788:
4789: resolution_courante = (*resolution_courante)
4790: .ai_next;
4791: }
4792:
4793: if (resolution_courante == NULL)
4794: {
4795: liberation(s_etat_processus, s_objet_argument);
4796: liberation(s_etat_processus, s_objet_resultat);
4797:
4798: freeaddrinfo(resolution);
4799:
4800: (*s_etat_processus).erreur_execution =
4801: d_ex_erreur_acces_fichier;
4802: return;
4803: }
4804:
4805: if (((*((struct_socket *)
4806: (*s_objet_resultat).objet))
4807: .socket = socket(PF_INET, type,
4808: protocole_numerique)) == -1)
4809: {
4810: liberation(s_etat_processus, s_objet_argument);
4811: liberation(s_etat_processus, s_objet_resultat);
4812:
4813: freeaddrinfo(resolution);
4814:
4815: (*s_etat_processus).erreur_execution =
4816: d_ex_erreur_acces_fichier;
4817: return;
4818: }
4819:
4820: (*((struct_socket *) (*s_objet_resultat).objet))
4821: .domaine = PF_INET;
4822:
4823: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4824: socket_ipv4.sin_family = AF_INET;
4825: socket_ipv4.sin_port = htons((uint16_t) port);
4826: socket_ipv4.sin_addr.s_addr =
4827: (*((struct sockaddr_in *)
4828: (*resolution_courante).ai_addr))
4829: .sin_addr.s_addr;
4830:
4831: if ((type_socket == 'S') || (type_socket == 'Q'))
4832: {
4833: if (connect((*((struct_socket *)
4834: (*s_objet_resultat).objet)).socket,
4835: (const struct sockaddr *)
4836: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4837: {
4838: liberation(s_etat_processus,
4839: s_objet_argument);
4840: liberation(s_etat_processus,
4841: s_objet_resultat);
4842:
4843: freeaddrinfo(resolution);
4844:
4845: (*s_etat_processus).erreur_execution =
4846: d_ex_erreur_acces_fichier;
4847: return;
4848: }
4849:
4850: (*((struct_socket *) (*s_objet_resultat).objet))
4851: .socket_connectee = d_vrai;
4852: (*((struct_socket *) (*s_objet_resultat).objet))
4853: .socket_en_ecoute = 'N';
4854: }
4855:
4856: if (((*((struct_socket *) (*s_objet_resultat)
4857: .objet)).adresse = malloc(22 *
4858: sizeof(unsigned char))) == NULL)
4859: {
4860: (*s_etat_processus).erreur_systeme =
4861: d_es_allocation_memoire;
4862: return;
4863: }
4864:
4865: sprintf((*((struct_socket *) (*s_objet_resultat)
4866: .objet)).adresse, "%d.%d.%d.%d",
4867: (ntohl((*((struct sockaddr_in *)
4868: (*resolution_courante).ai_addr)).sin_addr
4869: .s_addr) >> 24) & 0xFF,
4870: (ntohl((*((struct sockaddr_in *)
4871: (*resolution_courante).ai_addr)).sin_addr
4872: .s_addr) >> 16) & 0xFF,
4873: (ntohl((*((struct sockaddr_in *)
4874: (*resolution_courante).ai_addr)).sin_addr
4875: .s_addr) >> 8) & 0xFF,
4876: ntohl((*((struct sockaddr_in *)
4877: (*resolution_courante).ai_addr)).sin_addr
4878: .s_addr) & 0xFF);
4879: }
4880: else
4881: { // Accès en IPv6
4882: # ifdef IPV6
4883: resolution_courante = resolution;
4884:
4885: while(resolution_courante != NULL)
4886: {
4887: if ((*resolution_courante).ai_family ==
4888: AF_INET6)
4889: {
4890: break;
4891: }
4892:
4893: resolution_courante = (*resolution_courante)
4894: .ai_next;
4895: }
4896:
4897: if (resolution_courante == NULL)
4898: {
4899: liberation(s_etat_processus, s_objet_argument);
4900: liberation(s_etat_processus, s_objet_resultat);
4901:
4902: freeaddrinfo(resolution);
4903:
4904: (*s_etat_processus).erreur_execution =
4905: d_ex_erreur_acces_fichier;
4906: return;
4907: }
4908:
4909: if (((*((struct_socket *)
4910: (*s_objet_resultat).objet))
4911: .socket = socket(PF_INET6, type,
4912: protocole_numerique)) == -1)
4913: {
4914: liberation(s_etat_processus, s_objet_argument);
4915: liberation(s_etat_processus, s_objet_resultat);
4916:
4917: freeaddrinfo(resolution);
4918:
4919: (*s_etat_processus).erreur_execution =
4920: d_ex_erreur_acces_fichier;
4921: return;
4922: }
4923:
4924: (*((struct_socket *) (*s_objet_resultat).objet))
4925: .domaine = PF_INET6;
4926:
4927: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4928: socket_ipv6.sin6_family = AF_INET6;
4929: socket_ipv6.sin6_port = htons((uint16_t) port);
4930:
4931: for(i = 0; i < 16;
4932: socket_ipv6.sin6_addr.s6_addr[i] =
4933: (*((struct sockaddr_in6 *)
4934: (*resolution_courante).ai_addr))
4935: .sin6_addr.s6_addr[i], i++);
4936:
4937: if ((type_socket == 'S') || (type_socket == 'Q'))
4938: {
4939: if (connect((*((struct_socket *)
4940: (*s_objet_resultat).objet)).socket,
4941: (const struct sockaddr *)
4942: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4943: {
4944: liberation(s_etat_processus,
4945: s_objet_argument);
4946: liberation(s_etat_processus,
4947: s_objet_resultat);
4948:
4949: freeaddrinfo(resolution);
4950:
4951: (*s_etat_processus).erreur_execution =
4952: d_ex_erreur_acces_fichier;
4953: return;
4954: }
4955:
4956: (*((struct_socket *) (*s_objet_resultat).objet))
4957: .socket_connectee = d_vrai;
4958: (*((struct_socket *) (*s_objet_resultat).objet))
4959: .socket_en_ecoute = 'N';
4960: }
4961:
4962: if (((*((struct_socket *) (*s_objet_resultat)
4963: .objet)).adresse = malloc(55 *
4964: sizeof(unsigned char))) == NULL)
4965: {
4966: (*s_etat_processus).erreur_systeme =
4967: d_es_allocation_memoire;
4968: return;
4969: }
4970:
4971: for(i = 0; i < 16; i++)
4972: {
4973: sprintf((*((struct_socket *) (*s_objet_resultat)
4974: .objet)).adresse,
4975: (i == 0) ? "%s%X" : "%s:%X",
4976: (*((struct_socket *) (*s_objet_resultat)
4977: .objet)).adresse,
4978: (*((struct sockaddr_in6 *)
4979: (*resolution_courante).ai_addr))
4980: .sin6_addr.s6_addr[i]);
4981: }
4982: # else
4983: if ((*s_etat_processus).langue == 'F')
4984: {
4985: printf("+++Attention : Support du protocole"
4986: " IPv6 indisponible\n");
4987: }
4988: else
4989: {
4990: printf("+++Warning : IPv6 support "
4991: "unavailable\n");
4992: }
4993: # endif
4994: }
4995:
4996: freeaddrinfo(resolution);
4997:
4998: sprintf((*((struct_socket *) (*s_objet_resultat)
4999: .objet)).adresse, "%s(%u)",
5000: (*((struct_socket *) (*s_objet_resultat)
5001: .objet)).adresse, (unsigned int) port);
5002: }
5003: else
5004: { // Hôte défini par une adresse
5005: if (strcmp(protocole, "IPV4") == 0)
5006: { // Accès en IPv4
5007: if (type_adresse == '4')
5008: {
5009: if (((*((struct_socket *) (*s_objet_resultat)
5010: .objet)).adresse = malloc(22 *
5011: sizeof(unsigned char))) == NULL)
5012: {
5013: (*s_etat_processus).erreur_systeme =
5014: d_es_allocation_memoire;
5015: return;
5016: }
5017:
5018: (*((struct_socket *) (*s_objet_resultat).objet))
5019: .adresse[0] = d_code_fin_chaine;
5020:
5021: for(i = 0; i < 4; i++)
5022: {
5023: sprintf((*((struct_socket *)
5024: (*s_objet_resultat).objet)).adresse,
5025: (i == 0) ? "%s%d" : "%s.%d",
5026: (*((struct_socket *)
5027: (*s_objet_resultat)
5028: .objet)).adresse, (int) adresse[i]);
5029: }
5030:
5031: sprintf((*((struct_socket *) (*s_objet_resultat)
5032: .objet)).adresse, "%s(%u)",
5033: (*((struct_socket *) (*s_objet_resultat)
5034: .objet)).adresse, (unsigned int) port);
5035: }
5036: else
5037: {
5038: if (((*((struct_socket *) (*s_objet_resultat)
5039: .objet)).adresse = malloc(
5040: sizeof(unsigned char))) == NULL)
5041: {
5042: (*s_etat_processus).erreur_systeme =
5043: d_es_allocation_memoire;
5044: return;
5045: }
5046:
5047: (*((struct_socket *) (*s_objet_resultat).objet))
5048: .adresse[0] = d_code_fin_chaine;
5049: }
5050:
5051: if (((*((struct_socket *)
5052: (*s_objet_resultat).objet))
5053: .socket = socket(PF_INET, type,
5054: protocole_numerique)) == -1)
5055: {
5056: liberation(s_etat_processus, s_objet_argument);
5057: liberation(s_etat_processus, s_objet_resultat);
5058:
5059: (*s_etat_processus).erreur_execution =
5060: d_ex_erreur_acces_fichier;
5061: return;
5062: }
5063:
5064: (*((struct_socket *) (*s_objet_resultat).objet))
5065: .domaine = PF_INET;
5066:
5067: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
5068: socket_ipv4.sin_family = AF_INET;
5069: socket_ipv4.sin_port = htons((uint16_t) port);
5070:
5071: adresse_ipv4 = 0;
5072: for(i = 0; i < 4; adresse_ipv4 =
5073: (256 * adresse_ipv4) + adresse[i++]);
5074:
5075: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
5076:
5077: if ((type_socket == 'S') || (type_socket == 'Q'))
5078: {
5079: if (connect((*((struct_socket *)
5080: (*s_objet_resultat).objet)).socket,
5081: (const struct sockaddr *)
5082: &socket_ipv4, sizeof(socket_ipv4)) != 0)
5083: {
5084: liberation(s_etat_processus,
5085: s_objet_argument);
5086: liberation(s_etat_processus,
5087: s_objet_resultat);
5088:
5089: (*s_etat_processus).erreur_execution =
5090: d_ex_erreur_acces_fichier;
5091: return;
5092: }
5093:
5094: (*((struct_socket *) (*s_objet_resultat).objet))
5095: .socket_connectee = d_vrai;
5096: (*((struct_socket *) (*s_objet_resultat).objet))
5097: .socket_en_ecoute = 'N';
5098: }
5099: }
5100: else if (strcmp(protocole, "IPV6") == 0)
5101: { // Accès en IPv6
5102: # ifdef IPV6
5103: if (type_adresse == '6')
5104: {
5105: if (((*((struct_socket *) (*s_objet_resultat)
5106: .objet)).adresse = malloc(55 *
5107: sizeof(unsigned char))) == NULL)
5108: {
5109: (*s_etat_processus).erreur_systeme =
5110: d_es_allocation_memoire;
5111: return;
5112: }
5113:
5114: (*((struct_socket *) (*s_objet_resultat).objet))
5115: .adresse[0] = d_code_fin_chaine;
5116:
5117: for(i = 0; i < 16; i++)
5118: {
5119: sprintf((*((struct_socket *)
5120: (*s_objet_resultat).objet)).adresse,
5121: (i == 0) ? "%s%X" : "%s:%X",
5122: (*((struct_socket *)
5123: (*s_objet_resultat)
5124: .objet)).adresse, (unsigned int)
5125: adresse[i]);
5126: }
5127:
5128: sprintf((*((struct_socket *) (*s_objet_resultat)
5129: .objet)).adresse, "%s(%u)",
5130: (*((struct_socket *) (*s_objet_resultat)
5131: .objet)).adresse, (unsigned int) port);
5132: }
5133: else
5134: {
5135: if (((*((struct_socket *) (*s_objet_resultat)
5136: .objet)).adresse = malloc(
5137: sizeof(unsigned char))) == NULL)
5138: {
5139: (*s_etat_processus).erreur_systeme =
5140: d_es_allocation_memoire;
5141: return;
5142: }
5143:
5144: (*((struct_socket *) (*s_objet_resultat).objet))
5145: .adresse[0] = d_code_fin_chaine;
5146: }
5147:
5148: if (((*((struct_socket *)
5149: (*s_objet_resultat).objet))
5150: .socket = socket(PF_INET6, type,
5151: protocole_numerique)) == -1)
5152: {
5153: liberation(s_etat_processus, s_objet_argument);
5154: liberation(s_etat_processus, s_objet_resultat);
5155:
5156: (*s_etat_processus).erreur_execution =
5157: d_ex_erreur_acces_fichier;
5158: return;
5159: }
5160:
5161: (*((struct_socket *) (*s_objet_resultat).objet))
5162: .domaine = PF_INET6;
5163:
5164: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5165: socket_ipv6.sin6_family = AF_INET6;
5166: socket_ipv6.sin6_port = htons((uint16_t) port);
5167:
5168: for(i = 0; i < 16;
5169: socket_ipv6.sin6_addr.s6_addr[i] =
5170: (unsigned char) (adresse[i]), i++);
5171:
5172: if ((type_socket == 'S') || (type_socket == 'Q'))
5173: {
5174: if (connect((*((struct_socket *)
5175: (*s_objet_resultat).objet)).socket,
5176: (const struct sockaddr *)
5177: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5178: {
5179: liberation(s_etat_processus,
5180: s_objet_argument);
5181: liberation(s_etat_processus,
5182: s_objet_resultat);
5183:
5184: (*s_etat_processus).erreur_execution =
5185: d_ex_erreur_acces_fichier;
5186: return;
5187: }
5188:
5189: (*((struct_socket *) (*s_objet_resultat).objet))
5190: .socket_connectee = d_vrai;
5191: (*((struct_socket *) (*s_objet_resultat).objet))
5192: .socket_en_ecoute = 'N';
5193: }
5194: # else
5195: if ((*s_etat_processus).langue == 'F')
5196: {
5197: printf("+++Attention : Support du protocole"
5198: " IPv6 indisponible\n");
5199: }
5200: else
5201: {
5202: printf("+++Warning : IPv6 support "
5203: "unavailable\n");
5204: }
5205: # endif
5206: }
5207: else
5208: { // Socket UNIX
5209: if (((*((struct_socket *) (*s_objet_resultat)
5210: .objet)).adresse = malloc(
5211: sizeof(unsigned char))) == NULL)
5212: {
5213: (*s_etat_processus).erreur_systeme =
5214: d_es_allocation_memoire;
5215: return;
5216: }
5217:
5218: (*((struct_socket *) (*s_objet_resultat).objet))
5219: .adresse[0] = d_code_fin_chaine;
5220:
5221: if (((*((struct_socket *)
5222: (*s_objet_resultat).objet))
5223: .socket = socket(PF_UNIX, type,
5224: protocole_numerique)) == -1)
5225: {
5226: liberation(s_etat_processus, s_objet_argument);
5227: liberation(s_etat_processus, s_objet_resultat);
5228:
5229: (*s_etat_processus).erreur_execution =
5230: d_ex_erreur_acces_fichier;
5231: return;
5232: }
5233: }
5234: }
5235:
5236: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
5237: = 'N';
5238: }
5239:
5240: if ((type_socket == 'S') || (type_socket == 'Q'))
5241: {
5242: if (protection == 'R')
5243: { // WRITEONLY
5244: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5245: .objet)).socket, SHUT_RD) != 0)
5246: {
5247: liberation(s_etat_processus, s_objet_argument);
5248: liberation(s_etat_processus, s_objet_resultat);
5249:
5250: (*s_etat_processus).erreur_execution =
5251: d_ex_erreur_acces_fichier;
5252: return;
5253: }
5254: }
5255: else if (protection == 'W')
5256: { // READONLY
5257: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5258: .objet)).socket, SHUT_WR) != 0)
5259: {
5260: liberation(s_etat_processus, s_objet_argument);
5261: liberation(s_etat_processus, s_objet_resultat);
5262:
5263: (*s_etat_processus).erreur_execution =
5264: d_ex_erreur_acces_fichier;
5265: return;
5266: }
5267: }
5268: else
5269: { // READWRITE
5270: }
5271: }
5272: }
5273:
5274: /*
5275: * Gestion de la liste des sockets ouvertes
5276: */
5277:
5278: l_element_courant = (*s_etat_processus).s_sockets;
5279:
5280: if (l_element_courant == NULL)
5281: {
5282: if (((*s_etat_processus).s_sockets =
5283: allocation_maillon(s_etat_processus)) == NULL)
5284: {
5285: (*s_etat_processus).erreur_systeme =
5286: d_es_allocation_memoire;
5287: return;
5288: }
5289:
5290: (*(*s_etat_processus).s_sockets).suivant = NULL;
5291: l_element_courant = (*s_etat_processus).s_sockets;
5292: }
5293: else
5294: {
5295: /*
5296: * Ajout d'un élément à la fin de la liste chaînée
5297: */
5298:
5299: while((*l_element_courant).suivant != NULL)
5300: {
5301: l_element_courant = (*l_element_courant).suivant;
5302: }
5303:
5304: if (((*l_element_courant).suivant =
5305: allocation_maillon(s_etat_processus)) == NULL)
5306: {
5307: (*s_etat_processus).erreur_systeme =
5308: d_es_allocation_memoire;
5309: return;
5310: }
5311:
5312: l_element_courant = (*l_element_courant).suivant;
5313: (*l_element_courant).suivant = NULL;
5314: }
5315:
5316: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
5317: s_objet_resultat, 'O')) == NULL)
5318: {
5319: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5320: return;
5321: }
5322:
5323: liberation(s_etat_processus, s_objet_argument);
5324: }
5325: else
5326: {
5327: liberation(s_etat_processus, s_objet_argument);
5328:
5329: (*s_etat_processus).erreur_execution =
5330: d_ex_erreur_parametre_fichier;
5331: return;
5332: }
5333: }
5334: else if ((*s_objet_argument).type == CHN)
5335: {
5336: if ((s_objet_resultat = allocation(s_etat_processus, SPH)) == NULL)
5337: {
5338: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5339: return;
5340: }
5341:
5342: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).nom =
5343: malloc((strlen((unsigned char *) (*s_objet_argument).objet)
5344: + 1) *sizeof(unsigned char))) == NULL)
5345: {
5346: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5347: return;
5348: }
5349:
5350: strcpy((*((struct_semaphore *) (*s_objet_resultat).objet)).nom,
5351: (unsigned char *) (*s_objet_argument).objet);
5352:
5353: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).semaphore =
5354: sem_open((*((struct_semaphore *) (*s_objet_resultat).objet))
5355: .nom, 0)) == SEM_FAILED)
5356: {
5357: if (errno == ENOMEM)
5358: {
5359: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5360: return;
5361: }
5362:
5363: (*s_etat_processus).erreur_execution = d_ex_semaphore;
5364:
5365: liberation(s_etat_processus, s_objet_argument);
5366: liberation(s_etat_processus, s_objet_resultat);
5367: return;
5368: }
5369: }
5370: else
5371: {
5372: liberation(s_etat_processus, s_objet_argument);
5373:
5374: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
5375: return;
5376: }
5377:
5378: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5379: s_objet_resultat) == d_erreur)
5380: {
5381: return;
5382: }
5383:
5384: return;
5385: }
5386:
5387: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_o1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src