1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.10
4: Copyright (C) 1989-2012 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: * FLOW : chaîne de caractères sans format (en tant qu'objet
901: * binaire comme "\x00avz\xFD")
902: */
903:
904: file *descripteur;
905:
906: int buffer_emission;
907: int buffer_reception;
908: int drapeau;
909: int priorite;
910: int protocole_numerique;
911: int timeout_emission;
912: int timeout_reception;
913: int type;
914:
915: integer8 adresse[16];
916: integer8 nombre_maximal_connexions;
917: integer8 port;
918: integer8 position_clef;
919:
920: logical1 erreur;
921: logical1 existence;
922: logical1 negation;
923: logical1 ouverture;
924: logical1 presence_port;
925:
926: sqlite3 *sqlite;
927:
928: struct_liste_chainee *l_element_courant;
929: struct_liste_chainee *l_element_courant_sous_objet;
930: struct_liste_chainee *parametre_courant;
931:
932: struct flock lock;
933:
934: struct addrinfo *resolution;
935: struct addrinfo *resolution_courante;
936:
937: struct protoent *s_protocole;
938:
939: struct sockaddr_un socket_unix;
940: struct sockaddr_in socket_ipv4;
941: # ifdef IPV6
942: struct sockaddr_in6 socket_ipv6;
943: # endif
944:
945: struct_objet *s_objet_argument;
946: struct_objet *s_objet_resultat;
947: struct_objet *s_parametres_tty;
948:
949: struct termios tc;
950:
951: uint32_t adresse_ipv4;
952:
953: unsigned char *argument_majuscule;
954: unsigned char *chaine_descripteurs;
955: unsigned char format;
956: unsigned char *hote;
957: unsigned char *nom;
958: unsigned char *nom_temporaire;
959: unsigned char options[12];
960: unsigned char *parametre_courant_majuscule;
961: unsigned char *peripherique;
962: unsigned char *pointeur;
963: unsigned char *position;
964: unsigned char protection;
965: unsigned char protocole[16 + 1];
966: unsigned char *protocole_socket;
967: unsigned char type_acces;
968: unsigned char type_adresse;
969: unsigned char type_arguments;
970: unsigned char type_domaine;
971: unsigned char type_ouverture;
972: unsigned char type_socket;
973:
974: unsigned long i;
975: unsigned long nombre_elements;
976: unsigned long prochain_descripteur;
977: unsigned long unite;
978:
979: # define d_BIND_TO_DEVICE 0
980: # define d_BROADCAST 1
981: # define d_DONT_ROUTE 2
982: # define d_KEEP_ALIVE 3
983: # define d_PRIORITY 4
984: # define d_RECEIVE_BUFFER 5
985: # define d_FORCE_RECEIVE_BUFFER 6
986: # define d_SEND_BUFFER 7
987: # define d_FORCE_SEND_BUFFER 8
988: # define d_RECEIVING_TIMEOUT 9
989: # define d_SENDING_TIMEOUT 10
990: # define d_REUSE_ADDRESS 11
991:
992: /*
993: * Argument : { "ouverture" "accès" "format" [ { "nom" } 'protection' ] }
994: */
995:
996: (*s_etat_processus).erreur_execution = d_ex;
997:
998: if ((*s_etat_processus).affichage_arguments == 'Y')
999: {
1000: printf("\n OPEN ");
1001:
1002: if ((*s_etat_processus).langue == 'F')
1003: {
1004: printf("(ouverture d'un fichier, d'une socket ou d'un sémaphore)"
1005: "\n\n");
1006: }
1007: else
1008: {
1009: printf("(open file, socket or semaphore)\n\n");
1010: }
1011:
1012: printf(" 1: %s\n", d_LST);
1013: printf("-> 1: %s, %s\n\n", d_FCH, d_SCK);
1014:
1015: printf(" 1: %s\n", d_CHN);
1016: printf("-> 1: %s\n\n", d_SPH);
1017:
1018: if ((*s_etat_processus).langue == 'F')
1019: {
1020: printf(" Utilisation :\n\n");
1021: }
1022: else
1023: {
1024: printf(" Usage:\n\n");
1025: }
1026:
1027: printf(" { \"filetype\" \"access\" \"format\" { \"name\" "
1028: "\"file name\" } \"protection\" } OPEN\n");
1029: printf(" { \"filetype\" \"access\" \"format\" { \"name\" "
1030: "\"file name\" } \n"
1031: " { \"stty\" { \"stty parameters\" ... } } } OPEN\n");
1032: printf(" { \"sockettype\" { \"name\" \"local name\" } } OPEN\n");
1033: printf(" { \"sockettype\" \"socketdomain\" \"protection\" } OPEN\n");
1034: printf(" \"/semaphore\" OPEN\n\n");
1035:
1036: printf(" File type : NEW/OLD/REPLACE/UNKNOWN/SCRATCH\n");
1037: printf(" File access : SEQUENTIAL/DIRECT/KEYED\n");
1038: printf(" Socket type : STREAM/DATAGRAM/RAW/"
1039: "ROBUST DATAGRAM/SEQUENTIAL DATAGRAM\n");
1040: printf(" Socket domain : LOCAL/FOREIGN\n");
1041: printf(" Socket protocol : IPV4/IPV6/UNIX\n");
1042: printf(" Format : FORMATTED/UNFORMATTED/FLOW\n");
1043: printf(" Protection : READONLY/WRITEONLY/READWRITE\n\n");
1044: printf(" Stty parameters : can be prefixed by 'NO'\n");
1045: printf(" IGNBRK, BRKINT, IGNPAR, PARMRK, INPCK, ISTRIP\n");
1046: printf(" INLCR, IGNCR, ICRNL, IXON, IXANY, IXOFF,\n");
1047: printf(" IMAXBEL, OPOST, ONLCR, OCRNL, ONOCR, ONLRET,\n");
1048: printf(" OFILL, HUPCL, CLOCAL, CRTSCTS, ISIG, ICANON,\n");
1049: printf(" ECHO, ECHOE, ECHOK, ECHONL, NOFLSH, TOSTOP,\n");
1050: printf(" IEXTEN\n");
1051:
1052: printf(" Address : { \"ADDRESS\" [ 127 0 0 1 ] }\n");
1053: printf(" { \"HOST\" \"hostname\" }\n");
1054: printf(" Connections : { \"LISTEN\" amount of connections }\n");
1055: printf(" Name : { \"NAME\" \"filename\" }\n");
1056: printf(" Options : { \"OPTION\" \"option\" argument }\n");
1057: printf(" \"BIND TO DEVICE\" \"device\"\n");
1058: printf(" \"BROADCAST\"\n");
1059: printf(" \"DO NOT ROUTE\"\n");
1060: printf(" \"KEEP ALIVE\"\n");
1061: printf(" \"PRIORITY\" integer\n");
1062: printf(" \"RECEIVE BUFFER\" integer\n");
1063: printf(" \"FORCE RECEIVE BUFFER\" integer\n");
1064: printf(" \"SEND BUFFER\" integer\n");
1065: printf(" \"FORCE SEND BUFFER\" integer\n");
1066: printf(" \"RECEIVING TIMEOUT\" integer\n");
1067: printf(" \"SENDING TIMEOUT\" integer\n");
1068: printf(" \"REUSE ADDRESS\"\n");
1069: printf(" Port : { \"PORT\" port number }\n");
1070: printf(" Protocol : { \"PROTOCOL\" \"protocol\" }\n\n");
1071:
1072: printf(" { { \"NAME\" \"filename\" } \"SEQUENTIAL\" } OPEN\n");
1073: printf(" { \"SCRATCH\" } OPEN\n");
1074: printf(" { { \"NAME\" \"filename\" } \"UNKNOWN\" \"FORMATTED\" "
1075: "\"DIRECT\" } OPEN\n");
1076: printf(" { { \"NAME\" \"filename\" } \"OLD\" \"FORMATTED\" "
1077: "\"KEYED\" { \"KEY\" 2 } } OPEN\n");
1078: printf(" { \"STREAM\" \"READWRITE\" } OPEN\n");
1079: printf(" { \"FOREIGN\" \"DATAGRAM\" } OPEN\n");
1080: printf(" { \"LOCAL\" { \"NAME\" \"socket.sock\" } } OPEN\n");
1081: printf(" { { \"NAME\" \"/dev/ttyS1\" } { \"STTY\" { \"9600,8,N,1\" "
1082: "\n { \"NO ICANON\" \"IGNBRK\" } } } OPEN\n");
1083:
1084: return;
1085: }
1086: else if ((*s_etat_processus).test_instruction == 'Y')
1087: {
1088: (*s_etat_processus).nombre_arguments = -1;
1089: return;
1090: }
1091:
1092: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1093: {
1094: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1095: {
1096: return;
1097: }
1098: }
1099:
1100: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1101: &s_objet_argument) == d_erreur)
1102: {
1103: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1104: return;
1105: }
1106:
1107: if ((*s_objet_argument).type == LST)
1108: {
1109: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
1110:
1111: if (l_element_courant == NULL)
1112: {
1113: liberation(s_etat_processus, s_objet_argument);
1114:
1115: (*s_etat_processus).erreur_execution =
1116: d_ex_erreur_parametre_fichier;
1117: return;
1118: }
1119:
1120: format = ' ';
1121: type_domaine = ' ';
1122: type_ouverture = ' ';
1123: protection = ' ';
1124: type_acces = ' ';
1125: type_socket = ' ';
1126: nom = NULL;
1127: position_clef = 0;
1128: port = 0;
1129: type_arguments = ' ';
1130: nombre_maximal_connexions = 0;
1131: hote = NULL;
1132: type_adresse = ' ';
1133: protocole[0] = d_code_fin_chaine;
1134: protocole_socket = NULL;
1135: presence_port = d_faux;
1136: peripherique = NULL;
1137: priorite = 0;
1138: buffer_emission = 0;
1139: buffer_reception = 0;
1140: timeout_emission = 0;
1141: timeout_reception = 0;
1142: drapeau = -1;
1143: s_parametres_tty = NULL;
1144:
1145: for(i = 0; i < 12; options[i++] = 'N');
1146:
1147: while(l_element_courant != NULL)
1148: {
1149: if ((*(*l_element_courant).donnee).type == CHN)
1150: {
1151: if ((argument_majuscule = conversion_majuscule((unsigned char *)
1152: (*(*l_element_courant).donnee).objet)) == NULL)
1153: {
1154: (*s_etat_processus).erreur_systeme =
1155: d_es_allocation_memoire;
1156: return;
1157: }
1158:
1159: if (strcmp(argument_majuscule, "NEW") == 0)
1160: {
1161: if (type_ouverture != ' ')
1162: {
1163: liberation(s_etat_processus, s_objet_argument);
1164: free(argument_majuscule);
1165:
1166: (*s_etat_processus).erreur_execution =
1167: d_ex_erreur_parametre_fichier;
1168: return;
1169: }
1170:
1171: if (type_arguments == ' ')
1172: {
1173: type_arguments = 'F';
1174: }
1175: else if (type_arguments == 'S')
1176: {
1177: liberation(s_etat_processus, s_objet_argument);
1178: free(argument_majuscule);
1179:
1180: (*s_etat_processus).erreur_execution =
1181: d_ex_erreur_parametre_fichier;
1182: return;
1183: }
1184:
1185: type_ouverture = 'N';
1186: }
1187: else if (strcmp(argument_majuscule, "REPLACE") == 0)
1188: {
1189: if (type_ouverture != ' ')
1190: {
1191: liberation(s_etat_processus, s_objet_argument);
1192: free(argument_majuscule);
1193:
1194: (*s_etat_processus).erreur_execution =
1195: d_ex_erreur_parametre_fichier;
1196: return;
1197: }
1198:
1199: if (type_arguments == ' ')
1200: {
1201: type_arguments = 'F';
1202: }
1203: else if (type_arguments == 'S')
1204: {
1205: liberation(s_etat_processus, s_objet_argument);
1206: free(argument_majuscule);
1207:
1208: (*s_etat_processus).erreur_execution =
1209: d_ex_erreur_parametre_fichier;
1210: return;
1211: }
1212:
1213: type_ouverture = 'R';
1214: }
1215: else if (strcmp(argument_majuscule, "OLD") == 0)
1216: {
1217: if (type_ouverture != ' ')
1218: {
1219: liberation(s_etat_processus, s_objet_argument);
1220: free(argument_majuscule);
1221:
1222: (*s_etat_processus).erreur_execution =
1223: d_ex_erreur_parametre_fichier;
1224: return;
1225: }
1226:
1227: if (type_arguments == ' ')
1228: {
1229: type_arguments = 'F';
1230: }
1231: else if (type_arguments == 'S')
1232: {
1233: liberation(s_etat_processus, s_objet_argument);
1234: free(argument_majuscule);
1235:
1236: (*s_etat_processus).erreur_execution =
1237: d_ex_erreur_parametre_fichier;
1238: return;
1239: }
1240:
1241: type_ouverture = 'O';
1242: }
1243: else if (strcmp(argument_majuscule, "UNKNOWN") == 0)
1244: {
1245: if (type_ouverture != ' ')
1246: {
1247: liberation(s_etat_processus, s_objet_argument);
1248: free(argument_majuscule);
1249:
1250: (*s_etat_processus).erreur_execution =
1251: d_ex_erreur_parametre_fichier;
1252: return;
1253: }
1254:
1255: if (type_arguments == ' ')
1256: {
1257: type_arguments = 'F';
1258: }
1259: else if (type_arguments == 'S')
1260: {
1261: liberation(s_etat_processus, s_objet_argument);
1262: free(argument_majuscule);
1263:
1264: (*s_etat_processus).erreur_execution =
1265: d_ex_erreur_parametre_fichier;
1266: return;
1267: }
1268:
1269: type_ouverture = 'U';
1270: }
1271: else if (strcmp(argument_majuscule, "SCRATCH") == 0)
1272: {
1273: if (type_ouverture != ' ')
1274: {
1275: liberation(s_etat_processus, s_objet_argument);
1276: free(argument_majuscule);
1277:
1278: (*s_etat_processus).erreur_execution =
1279: d_ex_erreur_parametre_fichier;
1280: return;
1281: }
1282:
1283: if (type_arguments == ' ')
1284: {
1285: type_arguments = 'F';
1286: }
1287: else if (type_arguments == 'S')
1288: {
1289: liberation(s_etat_processus, s_objet_argument);
1290: free(argument_majuscule);
1291:
1292: (*s_etat_processus).erreur_execution =
1293: d_ex_erreur_parametre_fichier;
1294: return;
1295: }
1296:
1297: type_ouverture = 'S';
1298: }
1299: else if (strcmp(argument_majuscule, "SEQUENTIAL") == 0)
1300: {
1301: if (type_acces != ' ')
1302: {
1303: liberation(s_etat_processus, s_objet_argument);
1304: free(argument_majuscule);
1305:
1306: (*s_etat_processus).erreur_execution =
1307: d_ex_erreur_parametre_fichier;
1308: return;
1309: }
1310:
1311: if (type_arguments == ' ')
1312: {
1313: type_arguments = 'F';
1314: }
1315: else if (type_arguments == 'S')
1316: {
1317: liberation(s_etat_processus, s_objet_argument);
1318: free(argument_majuscule);
1319:
1320: (*s_etat_processus).erreur_execution =
1321: d_ex_erreur_parametre_fichier;
1322: return;
1323: }
1324:
1325: type_acces = 'S';
1326: }
1327: else if (strcmp(argument_majuscule, "DIRECT") == 0)
1328: {
1329: if (type_acces != ' ')
1330: {
1331: liberation(s_etat_processus, s_objet_argument);
1332: free(argument_majuscule);
1333:
1334: (*s_etat_processus).erreur_execution =
1335: d_ex_erreur_parametre_fichier;
1336: return;
1337: }
1338:
1339: if (type_arguments == ' ')
1340: {
1341: type_arguments = 'F';
1342: }
1343: else if (type_arguments == 'S')
1344: {
1345: liberation(s_etat_processus, s_objet_argument);
1346: free(argument_majuscule);
1347:
1348: (*s_etat_processus).erreur_execution =
1349: d_ex_erreur_parametre_fichier;
1350: return;
1351: }
1352:
1353: type_acces = 'D';
1354: }
1355: else if (strcmp(argument_majuscule, "KEYED") == 0)
1356: {
1357: if (type_acces != ' ')
1358: {
1359: liberation(s_etat_processus, s_objet_argument);
1360: free(argument_majuscule);
1361:
1362: (*s_etat_processus).erreur_execution =
1363: d_ex_erreur_parametre_fichier;
1364: return;
1365: }
1366:
1367: if (type_arguments == ' ')
1368: {
1369: type_arguments = 'F';
1370: }
1371: else if (type_arguments == 'S')
1372: {
1373: liberation(s_etat_processus, s_objet_argument);
1374: free(argument_majuscule);
1375:
1376: (*s_etat_processus).erreur_execution =
1377: d_ex_erreur_parametre_fichier;
1378: return;
1379: }
1380:
1381: type_acces = 'I';
1382: }
1383: else if (strcmp(argument_majuscule, "READONLY") == 0)
1384: {
1385: if (protection != ' ')
1386: {
1387: liberation(s_etat_processus, s_objet_argument);
1388: free(argument_majuscule);
1389:
1390: (*s_etat_processus).erreur_execution =
1391: d_ex_erreur_parametre_fichier;
1392: return;
1393: }
1394:
1395: protection = 'R';
1396: }
1397: else if (strcmp(argument_majuscule, "WRITEONLY") == 0)
1398: {
1399: if (protection != ' ')
1400: {
1401: liberation(s_etat_processus, s_objet_argument);
1402: free(argument_majuscule);
1403:
1404: (*s_etat_processus).erreur_execution =
1405: d_ex_erreur_parametre_fichier;
1406: return;
1407: }
1408:
1409: protection = 'W';
1410: }
1411: else if (strcmp(argument_majuscule, "READWRITE") == 0)
1412: {
1413: if (protection != ' ')
1414: {
1415: liberation(s_etat_processus, s_objet_argument);
1416: free(argument_majuscule);
1417:
1418: (*s_etat_processus).erreur_execution =
1419: d_ex_erreur_parametre_fichier;
1420: return;
1421: }
1422:
1423: protection = 'N';
1424: }
1425: else if (strcmp(argument_majuscule, "FORMATTED") == 0)
1426: {
1427: if (format != ' ')
1428: {
1429: liberation(s_etat_processus, s_objet_argument);
1430: free(argument_majuscule);
1431:
1432: (*s_etat_processus).erreur_execution =
1433: d_ex_erreur_parametre_fichier;
1434: return;
1435: }
1436:
1437: format = 'N';
1438: }
1439: else if (strcmp(argument_majuscule, "UNFORMATTED") == 0)
1440: {
1441: if (format != ' ')
1442: {
1443: liberation(s_etat_processus, s_objet_argument);
1444: free(argument_majuscule);
1445:
1446: (*s_etat_processus).erreur_execution =
1447: d_ex_erreur_parametre_fichier;
1448: return;
1449: }
1450:
1451: format = 'Y';
1452: }
1453: else if (strcmp(argument_majuscule, "FLOW") == 0)
1454: {
1455: if (format != ' ')
1456: {
1457: liberation(s_etat_processus, s_objet_argument);
1458: free(argument_majuscule);
1459:
1460: (*s_etat_processus).erreur_execution =
1461: d_ex_erreur_parametre_fichier;
1462: return;
1463: }
1464:
1465: format = 'F';
1466: }
1467: else if (strcmp(argument_majuscule, "STREAM") == 0)
1468: {
1469: if (type_socket != ' ')
1470: {
1471: liberation(s_etat_processus, s_objet_argument);
1472: free(argument_majuscule);
1473:
1474: (*s_etat_processus).erreur_execution =
1475: d_ex_erreur_parametre_fichier;
1476: return;
1477: }
1478:
1479: if (type_arguments == ' ')
1480: {
1481: type_arguments = 'S';
1482: }
1483: else if (type_arguments == 'F')
1484: {
1485: liberation(s_etat_processus, s_objet_argument);
1486: free(argument_majuscule);
1487:
1488: (*s_etat_processus).erreur_execution =
1489: d_ex_erreur_parametre_fichier;
1490: return;
1491: }
1492:
1493: type_socket = 'S';
1494: }
1495: else if (strcmp(argument_majuscule, "DATAGRAM") == 0)
1496: {
1497: if (type_socket != ' ')
1498: {
1499: liberation(s_etat_processus, s_objet_argument);
1500: free(argument_majuscule);
1501:
1502: (*s_etat_processus).erreur_execution =
1503: d_ex_erreur_parametre_fichier;
1504: return;
1505: }
1506:
1507: type_socket = 'D';
1508: }
1509: else if (strcmp(argument_majuscule, "SEQUENTIAL DATAGRAM") == 0)
1510: {
1511: if (type_socket != ' ')
1512: {
1513: liberation(s_etat_processus, s_objet_argument);
1514: free(argument_majuscule);
1515:
1516: (*s_etat_processus).erreur_execution =
1517: d_ex_erreur_parametre_fichier;
1518: return;
1519: }
1520:
1521: if (type_arguments == ' ')
1522: {
1523: type_arguments = 'S';
1524: }
1525: else if (type_arguments == 'F')
1526: {
1527: liberation(s_etat_processus, s_objet_argument);
1528: free(argument_majuscule);
1529:
1530: (*s_etat_processus).erreur_execution =
1531: d_ex_erreur_parametre_fichier;
1532: return;
1533: }
1534:
1535: type_socket = 'Q';
1536: }
1537: else if (strcmp(argument_majuscule, "RAW") == 0)
1538: {
1539: if (type_socket != ' ')
1540: {
1541: liberation(s_etat_processus, s_objet_argument);
1542: free(argument_majuscule);
1543:
1544: (*s_etat_processus).erreur_execution =
1545: d_ex_erreur_parametre_fichier;
1546: return;
1547: }
1548:
1549: if (type_arguments == ' ')
1550: {
1551: type_arguments = 'S';
1552: }
1553: else if (type_arguments == 'F')
1554: {
1555: liberation(s_etat_processus, s_objet_argument);
1556: free(argument_majuscule);
1557:
1558: (*s_etat_processus).erreur_execution =
1559: d_ex_erreur_parametre_fichier;
1560: return;
1561: }
1562:
1563: type_socket = 'R';
1564: }
1565: else if (strcmp(argument_majuscule, "ROBUST DATAGRAM") == 0)
1566: {
1567: if (type_socket != ' ')
1568: {
1569: liberation(s_etat_processus, s_objet_argument);
1570: free(argument_majuscule);
1571:
1572: (*s_etat_processus).erreur_execution =
1573: d_ex_erreur_parametre_fichier;
1574: return;
1575: }
1576:
1577: if (type_arguments == ' ')
1578: {
1579: type_arguments = 'S';
1580: }
1581: else if (type_arguments == 'F')
1582: {
1583: liberation(s_etat_processus, s_objet_argument);
1584: free(argument_majuscule);
1585:
1586: (*s_etat_processus).erreur_execution =
1587: d_ex_erreur_parametre_fichier;
1588: return;
1589: }
1590:
1591: type_socket = 'M';
1592: }
1593: else if (strcmp(argument_majuscule, "LOCAL") == 0)
1594: {
1595: if (type_domaine != ' ')
1596: {
1597: liberation(s_etat_processus, s_objet_argument);
1598: free(argument_majuscule);
1599:
1600: (*s_etat_processus).erreur_execution =
1601: d_ex_erreur_parametre_fichier;
1602: return;
1603: }
1604:
1605: if (type_arguments == ' ')
1606: {
1607: type_arguments = 'S';
1608: }
1609: else if (type_arguments == 'F')
1610: {
1611: liberation(s_etat_processus, s_objet_argument);
1612: free(argument_majuscule);
1613:
1614: (*s_etat_processus).erreur_execution =
1615: d_ex_erreur_parametre_fichier;
1616: return;
1617: }
1618:
1619: type_domaine = 'L';
1620: }
1621: else if (strcmp(argument_majuscule, "FOREIGN") == 0)
1622: {
1623: if (type_domaine != ' ')
1624: {
1625: liberation(s_etat_processus, s_objet_argument);
1626: free(argument_majuscule);
1627:
1628: (*s_etat_processus).erreur_execution =
1629: d_ex_erreur_parametre_fichier;
1630: return;
1631: }
1632:
1633: if (type_arguments == ' ')
1634: {
1635: type_arguments = 'S';
1636: }
1637: else if (type_arguments == 'F')
1638: {
1639: liberation(s_etat_processus, s_objet_argument);
1640: free(argument_majuscule);
1641:
1642: (*s_etat_processus).erreur_execution =
1643: d_ex_erreur_parametre_fichier;
1644: return;
1645: }
1646:
1647: type_domaine = 'F';
1648: }
1649: else if (strcmp(argument_majuscule, "IPV4") == 0)
1650: {
1651: if (strcmp(protocole, "") != 0)
1652: {
1653: liberation(s_etat_processus, s_objet_argument);
1654: free(argument_majuscule);
1655:
1656: (*s_etat_processus).erreur_execution =
1657: d_ex_erreur_parametre_fichier;
1658: return;
1659: }
1660:
1661: if (type_arguments == ' ')
1662: {
1663: type_arguments = 'S';
1664: }
1665: else if (type_arguments == 'F')
1666: {
1667: liberation(s_etat_processus, s_objet_argument);
1668: free(argument_majuscule);
1669:
1670: (*s_etat_processus).erreur_execution =
1671: d_ex_erreur_parametre_fichier;
1672: return;
1673: }
1674:
1675: strcpy(protocole, "IPV4");
1676: }
1677: else if (strcmp(argument_majuscule, "IPV6") == 0)
1678: {
1679: if (strcmp(protocole, "") != 0)
1680: {
1681: liberation(s_etat_processus, s_objet_argument);
1682: free(argument_majuscule);
1683:
1684: (*s_etat_processus).erreur_execution =
1685: d_ex_erreur_parametre_fichier;
1686: return;
1687: }
1688:
1689: if (type_arguments == ' ')
1690: {
1691: type_arguments = 'S';
1692: }
1693: else if (type_arguments == 'F')
1694: {
1695: liberation(s_etat_processus, s_objet_argument);
1696: free(argument_majuscule);
1697:
1698: (*s_etat_processus).erreur_execution =
1699: d_ex_erreur_parametre_fichier;
1700: return;
1701: }
1702:
1703: strcpy(protocole, "IPV6");
1704: }
1705: else if (strcmp(argument_majuscule, "UNIX") == 0)
1706: {
1707: if (strcmp(protocole, "") != 0)
1708: {
1709: liberation(s_etat_processus, s_objet_argument);
1710: free(argument_majuscule);
1711:
1712: (*s_etat_processus).erreur_execution =
1713: d_ex_erreur_parametre_fichier;
1714: return;
1715: }
1716:
1717: if (type_arguments == ' ')
1718: {
1719: type_arguments = 'S';
1720: }
1721: else if (type_arguments == 'F')
1722: {
1723: liberation(s_etat_processus, s_objet_argument);
1724: free(argument_majuscule);
1725:
1726: (*s_etat_processus).erreur_execution =
1727: d_ex_erreur_parametre_fichier;
1728: return;
1729: }
1730:
1731: strcpy(protocole, "UNIX");
1732: }
1733: else
1734: {
1735: liberation(s_etat_processus, s_objet_argument);
1736: free(argument_majuscule);
1737:
1738: (*s_etat_processus).erreur_execution =
1739: d_ex_erreur_parametre_fichier;
1740: return;
1741: }
1742:
1743: free(argument_majuscule);
1744: }
1745: else if ((*(*l_element_courant).donnee).type == LST)
1746: {
1747: l_element_courant_sous_objet =
1748: (*(*l_element_courant).donnee).objet;
1749:
1750: nombre_elements = 0;
1751: while(l_element_courant_sous_objet != NULL)
1752: {
1753: nombre_elements++;
1754: l_element_courant_sous_objet =
1755: (*l_element_courant_sous_objet).suivant;
1756: }
1757:
1758: l_element_courant_sous_objet =
1759: (*(*l_element_courant).donnee).objet;
1760:
1761: if (nombre_elements == 2)
1762: {
1763: if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
1764: {
1765: if ((argument_majuscule = conversion_majuscule(
1766: (unsigned char *)
1767: (*(*l_element_courant_sous_objet)
1768: .donnee).objet)) == NULL)
1769: {
1770: (*s_etat_processus).erreur_systeme =
1771: d_es_allocation_memoire;
1772: return;
1773: }
1774:
1775: l_element_courant_sous_objet =
1776: (*l_element_courant_sous_objet).suivant;
1777:
1778: if (strcmp(argument_majuscule, "NAME") == 0)
1779: {
1780: if ((*(*l_element_courant_sous_objet).donnee).type
1781: == CHN)
1782: {
1783: if (nom != NULL)
1784: {
1785: liberation(s_etat_processus,
1786: s_objet_argument);
1787: free(argument_majuscule);
1788:
1789: (*s_etat_processus).erreur_execution =
1790: d_ex_erreur_parametre_fichier;
1791: return;
1792: }
1793:
1794: nom = (unsigned char *)
1795: (*(*l_element_courant_sous_objet)
1796: .donnee).objet;
1797: }
1798: else
1799: {
1800: liberation(s_etat_processus, s_objet_argument);
1801: free(argument_majuscule);
1802:
1803: (*s_etat_processus).erreur_execution =
1804: d_ex_erreur_parametre_fichier;
1805: return;
1806: }
1807: }
1808: else if (strcmp(argument_majuscule, "OPTION") == 0)
1809: {
1810: if ((*(*l_element_courant_sous_objet).donnee).type
1811: == CHN)
1812: {
1813: if (type_arguments == ' ')
1814: {
1815: type_arguments = 'S';
1816: }
1817: else if (type_arguments == 'F')
1818: {
1819: liberation(s_etat_processus,
1820: s_objet_argument);
1821: free(argument_majuscule);
1822:
1823: (*s_etat_processus).erreur_execution =
1824: d_ex_erreur_parametre_fichier;
1825: return;
1826: }
1827: }
1828:
1829: free(argument_majuscule);
1830:
1831: if ((argument_majuscule = conversion_majuscule(
1832: (unsigned char *)
1833: (*(*l_element_courant_sous_objet)
1834: .donnee).objet)) == NULL)
1835: {
1836: (*s_etat_processus).erreur_systeme =
1837: d_es_allocation_memoire;
1838: return;
1839: }
1840:
1841: if (strcmp(argument_majuscule, "BROADCAST") == 0)
1842: {
1843: if (options[d_BROADCAST] == 'Y')
1844: {
1845: liberation(s_etat_processus,
1846: s_objet_argument);
1847: free(argument_majuscule);
1848:
1849: (*s_etat_processus).erreur_execution =
1850: d_ex_erreur_parametre_fichier;
1851: return;
1852: }
1853:
1854: options[d_BROADCAST] = 'Y';
1855: }
1856: else if (strcmp(argument_majuscule, "DO NOT ROUTE")
1857: == 0)
1858: {
1859: if (options[d_DONT_ROUTE] == 'Y')
1860: {
1861: liberation(s_etat_processus,
1862: s_objet_argument);
1863: free(argument_majuscule);
1864:
1865: (*s_etat_processus).erreur_execution =
1866: d_ex_erreur_parametre_fichier;
1867: return;
1868: }
1869:
1870: options[d_DONT_ROUTE] = 'Y';
1871: }
1872: else if (strcmp(argument_majuscule, "KEEP ALIVE")
1873: == 0)
1874: {
1875: if (options[d_KEEP_ALIVE] == 'Y')
1876: {
1877: liberation(s_etat_processus,
1878: s_objet_argument);
1879: free(argument_majuscule);
1880:
1881: (*s_etat_processus).erreur_execution =
1882: d_ex_erreur_parametre_fichier;
1883: return;
1884: }
1885:
1886: options[d_KEEP_ALIVE] = 'Y';
1887: }
1888: else if (strcmp(argument_majuscule, "REUSE ADDRESS")
1889: == 0)
1890: {
1891: if (options[d_REUSE_ADDRESS] == 'Y')
1892: {
1893: liberation(s_etat_processus,
1894: s_objet_argument);
1895: free(argument_majuscule);
1896:
1897: (*s_etat_processus).erreur_execution =
1898: d_ex_erreur_parametre_fichier;
1899: return;
1900: }
1901:
1902: options[d_REUSE_ADDRESS] = 'Y';
1903: }
1904: else
1905: {
1906: liberation(s_etat_processus,
1907: s_objet_argument);
1908: free(argument_majuscule);
1909:
1910: (*s_etat_processus).erreur_execution =
1911: d_ex_erreur_parametre_fichier;
1912: return;
1913: }
1914: }
1915: else if (strcmp(argument_majuscule, "HOST") == 0)
1916: {
1917: if ((*(*l_element_courant_sous_objet).donnee).type
1918: == CHN)
1919: {
1920: if (type_arguments == ' ')
1921: {
1922: type_arguments = 'S';
1923: }
1924: else if (type_arguments == 'F')
1925: {
1926: liberation(s_etat_processus,
1927: s_objet_argument);
1928: free(argument_majuscule);
1929:
1930: (*s_etat_processus).erreur_execution =
1931: d_ex_erreur_parametre_fichier;
1932: return;
1933: }
1934:
1935: if (hote != NULL)
1936: {
1937: liberation(s_etat_processus,
1938: s_objet_argument);
1939: free(argument_majuscule);
1940:
1941: (*s_etat_processus).erreur_execution =
1942: d_ex_erreur_parametre_fichier;
1943: return;
1944: }
1945:
1946: hote = (unsigned char *)
1947: (*(*l_element_courant_sous_objet)
1948: .donnee).objet;
1949: }
1950: else
1951: {
1952: liberation(s_etat_processus,
1953: s_objet_argument);
1954: free(argument_majuscule);
1955:
1956: (*s_etat_processus).erreur_execution =
1957: d_ex_erreur_parametre_fichier;
1958: return;
1959: }
1960: }
1961: else if (strcmp(argument_majuscule, "PROTOCOL") == 0)
1962: {
1963: if ((*(*l_element_courant_sous_objet).donnee).type
1964: == CHN)
1965: {
1966: if (type_arguments == ' ')
1967: {
1968: type_arguments = 'S';
1969: }
1970: else if (type_arguments == 'F')
1971: {
1972: liberation(s_etat_processus,
1973: s_objet_argument);
1974: free(argument_majuscule);
1975:
1976: (*s_etat_processus).erreur_execution =
1977: d_ex_erreur_parametre_fichier;
1978: return;
1979: }
1980:
1981: if (protocole_socket != NULL)
1982: {
1983: liberation(s_etat_processus,
1984: s_objet_argument);
1985: free(argument_majuscule);
1986:
1987: (*s_etat_processus).erreur_execution =
1988: d_ex_erreur_parametre_fichier;
1989: return;
1990: }
1991:
1992: protocole_socket = (unsigned char *)
1993: (*(*l_element_courant_sous_objet)
1994: .donnee).objet;
1995:
1996: for(i = 0; i < strlen(protocole_socket); i++)
1997: {
1998: if ((protocole_socket[i] >= 'a') &&
1999: (protocole_socket[i] <= 'z'))
2000: {
2001: protocole_socket[i] -= 'a' - 'A';
2002: }
2003: }
2004: }
2005: else
2006: {
2007: liberation(s_etat_processus, s_objet_argument);
2008: free(argument_majuscule);
2009:
2010: (*s_etat_processus).erreur_execution =
2011: d_ex_erreur_parametre_fichier;
2012: return;
2013: }
2014: }
2015: else if (strcmp(argument_majuscule, "KEY") == 0)
2016: {
2017: if ((*(*l_element_courant_sous_objet).donnee).type
2018: == INT)
2019: {
2020: if (type_arguments == ' ')
2021: {
2022: type_arguments = 'F';
2023: }
2024: else if (type_arguments == 'S')
2025: {
2026: liberation(s_etat_processus,
2027: s_objet_argument);
2028: free(argument_majuscule);
2029:
2030: (*s_etat_processus).erreur_execution =
2031: d_ex_erreur_parametre_fichier;
2032: return;
2033: }
2034:
2035: if (position_clef != 0)
2036: {
2037: liberation(s_etat_processus,
2038: s_objet_argument);
2039:
2040: (*s_etat_processus).erreur_execution =
2041: d_ex_erreur_parametre_fichier;
2042: return;
2043: }
2044: else
2045: {
2046: if ((position_clef = (*((integer8 *)
2047: (*(*l_element_courant_sous_objet)
2048: .donnee).objet))) <= 0)
2049: {
2050: liberation(s_etat_processus,
2051: s_objet_argument);
2052:
2053: (*s_etat_processus).erreur_execution =
2054: d_ex_erreur_parametre_fichier;
2055: return;
2056: }
2057: }
2058: }
2059: else
2060: {
2061: liberation(s_etat_processus, s_objet_argument);
2062: free(argument_majuscule);
2063:
2064: (*s_etat_processus).erreur_execution =
2065: d_ex_erreur_parametre_fichier;
2066: return;
2067: }
2068: }
2069: else if (strcmp(argument_majuscule, "PORT") == 0)
2070: {
2071: if ((*(*l_element_courant_sous_objet)
2072: .donnee).type == INT)
2073: {
2074: if (type_arguments == ' ')
2075: {
2076: type_arguments = 'S';
2077: }
2078: else if (type_arguments == 'F')
2079: {
2080: liberation(s_etat_processus,
2081: s_objet_argument);
2082: free(argument_majuscule);
2083:
2084: (*s_etat_processus).erreur_execution =
2085: d_ex_erreur_parametre_fichier;
2086: return;
2087: }
2088:
2089: if (presence_port == d_vrai)
2090: {
2091: liberation(s_etat_processus,
2092: s_objet_argument);
2093:
2094: (*s_etat_processus).erreur_execution =
2095: d_ex_erreur_parametre_fichier;
2096: return;
2097: }
2098: else
2099: {
2100: presence_port = d_vrai;
2101:
2102: if ((port = (*((integer8 *)
2103: (*(*l_element_courant_sous_objet)
2104: .donnee).objet))) < 0)
2105: {
2106: liberation(s_etat_processus,
2107: s_objet_argument);
2108:
2109: (*s_etat_processus).erreur_execution =
2110: d_ex_erreur_parametre_fichier;
2111: return;
2112: }
2113:
2114: if (port > 65535)
2115: {
2116: liberation(s_etat_processus,
2117: s_objet_argument);
2118:
2119: (*s_etat_processus).erreur_execution =
2120: d_ex_erreur_parametre_fichier;
2121: return;
2122: }
2123: }
2124: }
2125: else
2126: {
2127: liberation(s_etat_processus, s_objet_argument);
2128: free(argument_majuscule);
2129:
2130: (*s_etat_processus).erreur_execution =
2131: d_ex_erreur_parametre_fichier;
2132: return;
2133: }
2134: }
2135: else if (strcmp(argument_majuscule, "LISTEN") == 0)
2136: {
2137: if ((*(*l_element_courant_sous_objet).donnee).type
2138: == INT)
2139: {
2140: if (type_arguments == ' ')
2141: {
2142: type_arguments = 'S';
2143: }
2144: else if (type_arguments == 'F')
2145: {
2146: liberation(s_etat_processus,
2147: s_objet_argument);
2148: free(argument_majuscule);
2149:
2150: (*s_etat_processus).erreur_execution =
2151: d_ex_erreur_parametre_fichier;
2152: return;
2153: }
2154:
2155: if (nombre_maximal_connexions != 0)
2156: {
2157: liberation(s_etat_processus,
2158: s_objet_argument);
2159:
2160: (*s_etat_processus).erreur_execution =
2161: d_ex_erreur_parametre_fichier;
2162: return;
2163: }
2164: else
2165: {
2166: if ((nombre_maximal_connexions =
2167: (*((integer8 *)
2168: (*(*l_element_courant_sous_objet)
2169: .donnee).objet))) <= 0)
2170: {
2171: liberation(s_etat_processus,
2172: s_objet_argument);
2173:
2174: (*s_etat_processus).erreur_execution =
2175: d_ex_erreur_parametre_fichier;
2176: return;
2177: }
2178: }
2179: }
2180: }
2181: else if (strcmp(argument_majuscule, "ADDRESS") == 0)
2182: {
2183: if ((*(*l_element_courant_sous_objet)
2184: .donnee).type == VIN)
2185: {
2186: if (type_arguments == ' ')
2187: {
2188: type_arguments = 'S';
2189: }
2190: else if (type_arguments == 'F')
2191: {
2192: liberation(s_etat_processus,
2193: s_objet_argument);
2194: free(argument_majuscule);
2195:
2196: (*s_etat_processus).erreur_execution =
2197: d_ex_erreur_parametre_fichier;
2198: return;
2199: }
2200:
2201: if (type_adresse != ' ')
2202: {
2203: liberation(s_etat_processus,
2204: s_objet_argument);
2205:
2206: (*s_etat_processus).erreur_execution =
2207: d_ex_erreur_parametre_fichier;
2208: return;
2209: }
2210:
2211: if ((*((struct_vecteur *)
2212: (*(*l_element_courant_sous_objet)
2213: .donnee).objet)).taille == 4)
2214: { // Adresse IPv4
2215: type_adresse = '4';
2216:
2217: for(i = 0; i < 4; i++)
2218: {
2219: adresse[i] = ((integer8 *)
2220: (*((struct_vecteur *) (*
2221: (*l_element_courant_sous_objet)
2222: .donnee).objet)).tableau)[i];
2223:
2224: if ((adresse[i] < 0) || (adresse[i] >
2225: 255))
2226: {
2227: liberation(s_etat_processus,
2228: s_objet_argument);
2229:
2230: (*s_etat_processus).erreur_execution
2231: = d_ex_erreur_parametre_fichier;
2232: return;
2233: }
2234: }
2235: }
2236: else if ((*((struct_vecteur *)
2237: (*(*l_element_courant_sous_objet)
2238: .donnee).objet)).taille == 16)
2239: { // Adresse IPv6
2240: type_adresse = '6';
2241:
2242: for(i = 0; i < 16; i++)
2243: {
2244: adresse[i] = ((integer8 *)
2245: (*((struct_vecteur *) (*
2246: (*l_element_courant_sous_objet)
2247: .donnee).objet)).tableau)[i];
2248:
2249: if ((adresse[i] < 0) || (adresse[i] >
2250: 255))
2251: {
2252: liberation(s_etat_processus,
2253: s_objet_argument);
2254:
2255: (*s_etat_processus).erreur_execution
2256: = d_ex_erreur_parametre_fichier;
2257: return;
2258: }
2259: }
2260: }
2261: else
2262: { // Adresse non supportée
2263: liberation(s_etat_processus,
2264: s_objet_argument);
2265:
2266: (*s_etat_processus).erreur_execution =
2267: d_ex_erreur_parametre_fichier;
2268: return;
2269: }
2270: }
2271: }
2272: else if (strcmp(argument_majuscule, "STTY") == 0)
2273: {
2274: if ((*(*l_element_courant_sous_objet)
2275: .donnee).type == CHN)
2276: {
2277: if (type_arguments == ' ')
2278: {
2279: type_arguments = 'F';
2280: }
2281: else if (type_arguments == 'S')
2282: {
2283: liberation(s_etat_processus,
2284: s_objet_argument);
2285: free(argument_majuscule);
2286:
2287: (*s_etat_processus).erreur_execution =
2288: d_ex_erreur_parametre_fichier;
2289: return;
2290: }
2291:
2292: s_parametres_tty = (*l_element_courant).donnee;
2293: }
2294: }
2295: else
2296: {
2297: liberation(s_etat_processus, s_objet_argument);
2298: free(argument_majuscule);
2299:
2300: (*s_etat_processus).erreur_execution =
2301: d_ex_erreur_parametre_fichier;
2302: return;
2303: }
2304:
2305: free(argument_majuscule);
2306: }
2307: else
2308: {
2309: liberation(s_etat_processus, s_objet_argument);
2310: (*s_etat_processus).erreur_execution =
2311: d_ex_erreur_parametre_fichier;
2312:
2313: return;
2314: }
2315: }
2316: else if (nombre_elements == 3)
2317: {
2318: if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
2319: {
2320: if ((argument_majuscule = conversion_majuscule(
2321: (unsigned char *)
2322: (*(*l_element_courant_sous_objet)
2323: .donnee).objet)) == NULL)
2324: {
2325: (*s_etat_processus).erreur_systeme =
2326: d_es_allocation_memoire;
2327: return;
2328: }
2329:
2330: if (strcmp(argument_majuscule, "OPTION") == 0)
2331: {
2332: if (type_arguments == ' ')
2333: {
2334: type_arguments = 'S';
2335: }
2336: else if (type_arguments == 'F')
2337: {
2338: liberation(s_etat_processus, s_objet_argument);
2339: free(argument_majuscule);
2340:
2341: (*s_etat_processus).erreur_execution =
2342: d_ex_erreur_parametre_fichier;
2343: return;
2344: }
2345:
2346: free(argument_majuscule);
2347:
2348: l_element_courant_sous_objet =
2349: (*l_element_courant_sous_objet).suivant;
2350:
2351: if ((*(*l_element_courant_sous_objet)
2352: .donnee).type != CHN)
2353: {
2354: liberation(s_etat_processus, s_objet_argument);
2355:
2356: (*s_etat_processus).erreur_execution =
2357: d_ex_erreur_parametre_fichier;
2358: return;
2359: }
2360:
2361: if ((argument_majuscule = conversion_majuscule(
2362: (unsigned char *)
2363: (*(*l_element_courant_sous_objet)
2364: .donnee).objet)) == NULL)
2365: {
2366: (*s_etat_processus).erreur_systeme =
2367: d_es_allocation_memoire;
2368: return;
2369: }
2370:
2371: l_element_courant_sous_objet =
2372: (*l_element_courant_sous_objet).suivant;
2373:
2374: if (strcmp(argument_majuscule, "BIND TO DEVICE")
2375: == 0)
2376: {
2377: if ((*(*l_element_courant_sous_objet)
2378: .donnee).type != CHN)
2379: {
2380: liberation(s_etat_processus,
2381: s_objet_argument);
2382: free(argument_majuscule);
2383:
2384: (*s_etat_processus).erreur_execution =
2385: d_ex_erreur_parametre_fichier;
2386: return;
2387: }
2388:
2389: if (options[d_BIND_TO_DEVICE] == 'Y')
2390: {
2391: liberation(s_etat_processus,
2392: s_objet_argument);
2393: free(argument_majuscule);
2394:
2395: (*s_etat_processus).erreur_execution =
2396: d_ex_erreur_parametre_fichier;
2397: return;
2398: }
2399:
2400: options[d_BIND_TO_DEVICE] = 'Y';
2401:
2402: peripherique = (unsigned char *)
2403: (*(*l_element_courant_sous_objet)
2404: .donnee).objet;
2405: }
2406: else if (strcmp(argument_majuscule, "PRIORITY")
2407: == 0)
2408: {
2409: if ((*(*l_element_courant_sous_objet)
2410: .donnee).type != INT)
2411: {
2412: liberation(s_etat_processus,
2413: s_objet_argument);
2414: free(argument_majuscule);
2415:
2416: (*s_etat_processus).erreur_execution =
2417: d_ex_erreur_parametre_fichier;
2418: return;
2419: }
2420:
2421: if (options[d_PRIORITY] == 'Y')
2422: {
2423: liberation(s_etat_processus,
2424: s_objet_argument);
2425: free(argument_majuscule);
2426:
2427: (*s_etat_processus).erreur_execution =
2428: d_ex_erreur_parametre_fichier;
2429: return;
2430: }
2431:
2432: options[d_PRIORITY] = 'Y';
2433:
2434: priorite = (int) (*((integer8 *)
2435: (*(*l_element_courant_sous_objet)
2436: .donnee).objet));
2437: }
2438: else if (strcmp(argument_majuscule,
2439: "RECEIVE BUFFER") == 0)
2440: {
2441: if ((*(*l_element_courant_sous_objet)
2442: .donnee).type != INT)
2443: {
2444: liberation(s_etat_processus,
2445: s_objet_argument);
2446: free(argument_majuscule);
2447:
2448: (*s_etat_processus).erreur_execution =
2449: d_ex_erreur_parametre_fichier;
2450: return;
2451: }
2452:
2453: if ((options[d_RECEIVE_BUFFER] == 'Y') ||
2454: (options[d_FORCE_RECEIVE_BUFFER]
2455: == 'Y'))
2456: {
2457: liberation(s_etat_processus,
2458: s_objet_argument);
2459: free(argument_majuscule);
2460:
2461: (*s_etat_processus).erreur_execution =
2462: d_ex_erreur_parametre_fichier;
2463: return;
2464: }
2465:
2466: options[d_RECEIVE_BUFFER] = 'Y';
2467:
2468: buffer_reception = (int) (*((integer8 *)
2469: (*(*l_element_courant_sous_objet)
2470: .donnee).objet));
2471: }
2472: else if (strcmp(argument_majuscule,
2473: "FORCE RECEIVE BUFFER") == 0)
2474: {
2475: if ((*(*l_element_courant_sous_objet)
2476: .donnee).type != INT)
2477: {
2478: liberation(s_etat_processus,
2479: s_objet_argument);
2480: free(argument_majuscule);
2481:
2482: (*s_etat_processus).erreur_execution =
2483: d_ex_erreur_parametre_fichier;
2484: return;
2485: }
2486:
2487: if ((options[d_RECEIVE_BUFFER] == 'Y') ||
2488: (options[d_FORCE_RECEIVE_BUFFER]
2489: == 'Y'))
2490: {
2491: liberation(s_etat_processus,
2492: s_objet_argument);
2493: free(argument_majuscule);
2494:
2495: (*s_etat_processus).erreur_execution =
2496: d_ex_erreur_parametre_fichier;
2497: return;
2498: }
2499:
2500: options[d_FORCE_RECEIVE_BUFFER] = 'Y';
2501:
2502: buffer_reception = (int) (*((integer8 *)
2503: (*(*l_element_courant_sous_objet)
2504: .donnee).objet));
2505: }
2506: else if (strcmp(argument_majuscule,
2507: "SEND BUFFER") == 0)
2508: {
2509: if ((*(*l_element_courant_sous_objet)
2510: .donnee).type != INT)
2511: {
2512: liberation(s_etat_processus,
2513: s_objet_argument);
2514: free(argument_majuscule);
2515:
2516: (*s_etat_processus).erreur_execution =
2517: d_ex_erreur_parametre_fichier;
2518: return;
2519: }
2520:
2521: if ((options[d_SEND_BUFFER] == 'Y') ||
2522: (options[d_FORCE_SEND_BUFFER] == 'Y'))
2523: {
2524: liberation(s_etat_processus,
2525: s_objet_argument);
2526: free(argument_majuscule);
2527:
2528: (*s_etat_processus).erreur_execution =
2529: d_ex_erreur_parametre_fichier;
2530: return;
2531: }
2532:
2533: options[d_SEND_BUFFER] = 'Y';
2534:
2535: buffer_emission = (int) (*((integer8 *)
2536: (*(*l_element_courant_sous_objet)
2537: .donnee).objet));
2538: }
2539: else if (strcmp(argument_majuscule,
2540: "FORCE SEND BUFFER") == 0)
2541: {
2542: if ((*(*l_element_courant_sous_objet)
2543: .donnee).type != INT)
2544: {
2545: liberation(s_etat_processus,
2546: s_objet_argument);
2547: free(argument_majuscule);
2548:
2549: (*s_etat_processus).erreur_execution =
2550: d_ex_erreur_parametre_fichier;
2551: return;
2552: }
2553:
2554: if ((options[d_SEND_BUFFER] == 'Y') ||
2555: (options[d_FORCE_SEND_BUFFER] == 'Y'))
2556: {
2557: liberation(s_etat_processus,
2558: s_objet_argument);
2559: free(argument_majuscule);
2560:
2561: (*s_etat_processus).erreur_execution =
2562: d_ex_erreur_parametre_fichier;
2563: return;
2564: }
2565:
2566: options[d_FORCE_SEND_BUFFER] = 'Y';
2567:
2568: buffer_emission = (int) (*((integer8 *)
2569: (*(*l_element_courant_sous_objet)
2570: .donnee).objet));
2571: }
2572: else if (strcmp(argument_majuscule,
2573: "RECEIVING TIMEOUT") == 0)
2574: {
2575: if ((*(*l_element_courant_sous_objet)
2576: .donnee).type != INT)
2577: {
2578: liberation(s_etat_processus,
2579: s_objet_argument);
2580: free(argument_majuscule);
2581:
2582: (*s_etat_processus).erreur_execution =
2583: d_ex_erreur_parametre_fichier;
2584: return;
2585: }
2586:
2587: if (options[d_RECEIVING_TIMEOUT] == 'Y')
2588: {
2589: liberation(s_etat_processus,
2590: s_objet_argument);
2591: free(argument_majuscule);
2592:
2593: (*s_etat_processus).erreur_execution =
2594: d_ex_erreur_parametre_fichier;
2595: return;
2596: }
2597:
2598: options[d_RECEIVING_TIMEOUT] = 'Y';
2599:
2600: timeout_reception = (int) (*((integer8 *)
2601: (*(*l_element_courant_sous_objet)
2602: .donnee).objet));
2603: }
2604: else if (strcmp(argument_majuscule,
2605: "SENDING TIMEOUT") == 0)
2606: {
2607: if ((*(*l_element_courant_sous_objet)
2608: .donnee).type != INT)
2609: {
2610: liberation(s_etat_processus,
2611: s_objet_argument);
2612: free(argument_majuscule);
2613:
2614: (*s_etat_processus).erreur_execution =
2615: d_ex_erreur_parametre_fichier;
2616: return;
2617: }
2618:
2619: if (options[d_SENDING_TIMEOUT] == 'Y')
2620: {
2621: liberation(s_etat_processus,
2622: s_objet_argument);
2623: free(argument_majuscule);
2624:
2625: (*s_etat_processus).erreur_execution =
2626: d_ex_erreur_parametre_fichier;
2627: return;
2628: }
2629:
2630: options[d_SENDING_TIMEOUT] = 'Y';
2631:
2632: timeout_emission = (int) (*((integer8 *)
2633: (*(*l_element_courant_sous_objet)
2634: .donnee).objet));
2635: }
2636: else
2637: {
2638: liberation(s_etat_processus, s_objet_argument);
2639: free(argument_majuscule);
2640:
2641: (*s_etat_processus).erreur_execution =
2642: d_ex_erreur_parametre_fichier;
2643: return;
2644: }
2645:
2646: free(argument_majuscule);
2647: }
2648: else if (strcmp(argument_majuscule, "STTY") == 0)
2649: {
2650: if (type_arguments == ' ')
2651: {
2652: type_arguments = 'F';
2653: }
2654: else if (type_arguments == 'S')
2655: {
2656: liberation(s_etat_processus, s_objet_argument);
2657: free(argument_majuscule);
2658:
2659: (*s_etat_processus).erreur_execution =
2660: d_ex_erreur_parametre_fichier;
2661: return;
2662: }
2663:
2664: free(argument_majuscule);
2665:
2666: l_element_courant_sous_objet =
2667: (*l_element_courant_sous_objet).suivant;
2668:
2669: if ((*(*l_element_courant_sous_objet)
2670: .donnee).type != CHN)
2671: {
2672: liberation(s_etat_processus, s_objet_argument);
2673:
2674: (*s_etat_processus).erreur_execution =
2675: d_ex_erreur_parametre_fichier;
2676: return;
2677: }
2678:
2679: l_element_courant_sous_objet =
2680: (*l_element_courant_sous_objet).suivant;
2681:
2682: if ((*(*l_element_courant_sous_objet)
2683: .donnee).type != LST)
2684: {
2685: liberation(s_etat_processus, s_objet_argument);
2686:
2687: (*s_etat_processus).erreur_execution =
2688: d_ex_erreur_parametre_fichier;
2689: return;
2690: }
2691:
2692: s_parametres_tty = (*l_element_courant).donnee;
2693: }
2694: else
2695: {
2696: liberation(s_etat_processus, s_objet_argument);
2697: free(argument_majuscule);
2698:
2699: (*s_etat_processus).erreur_execution =
2700: d_ex_erreur_parametre_fichier;
2701: return;
2702: }
2703: }
2704: else
2705: {
2706: liberation(s_etat_processus, s_objet_argument);
2707: (*s_etat_processus).erreur_execution =
2708: d_ex_erreur_parametre_fichier;
2709:
2710: return;
2711: }
2712: }
2713: else
2714: {
2715: liberation(s_etat_processus, s_objet_argument);
2716: (*s_etat_processus).erreur_execution =
2717: d_ex_erreur_parametre_fichier;
2718:
2719: return;
2720: }
2721: }
2722: else
2723: {
2724: liberation(s_etat_processus, s_objet_argument);
2725:
2726: (*s_etat_processus).erreur_execution =
2727: d_ex_erreur_parametre_fichier;
2728: return;
2729: }
2730:
2731: l_element_courant = (*l_element_courant).suivant;
2732: }
2733:
2734: // Si aucun paramètre n'est discriminant, l'instruction ouvre
2735: // par défaut un fichier.
2736:
2737: if (type_arguments == ' ')
2738: {
2739: type_arguments = 'F';
2740: }
2741:
2742: if (type_arguments == 'F')
2743: {
2744: /*
2745: * Traitement des fichiers
2746: */
2747:
2748: /*
2749: * Vérification de la cohérence et comportement par défaut
2750: */
2751:
2752: if (type_ouverture == ' ')
2753: {
2754: type_ouverture = 'U';
2755: }
2756:
2757: if (type_acces == ' ')
2758: {
2759: type_acces = 'S';
2760: }
2761:
2762: if (format == ' ')
2763: {
2764: format = 'N';
2765: }
2766:
2767: if (protection == ' ')
2768: {
2769: protection = 'N';
2770: }
2771:
2772: if ((type_ouverture == 'S') && (protection != 'N'))
2773: {
2774: liberation(s_etat_processus, s_objet_argument);
2775:
2776: (*s_etat_processus).erreur_execution =
2777: d_ex_erreur_parametre_fichier;
2778: return;
2779: }
2780:
2781: if ((type_ouverture != 'S') && (nom == NULL))
2782: {
2783: liberation(s_etat_processus, s_objet_argument);
2784:
2785: (*s_etat_processus).erreur_execution =
2786: d_ex_erreur_parametre_fichier;
2787: return;
2788: }
2789:
2790: if (((type_acces != 'I') && (position_clef != 0)) ||
2791: ((type_acces == 'I') && (position_clef == 0) &&
2792: ((type_ouverture == 'N') || (type_ouverture == 'R') ||
2793: (type_ouverture == 'S'))))
2794: {
2795: liberation(s_etat_processus, s_objet_argument);
2796:
2797: (*s_etat_processus).erreur_execution =
2798: d_ex_erreur_parametre_fichier;
2799: return;
2800: }
2801:
2802: if ((s_objet_resultat = allocation(s_etat_processus, FCH))
2803: == NULL)
2804: {
2805: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2806: return;
2807: }
2808:
2809: if (nom == NULL)
2810: {
2811: if ((nom_temporaire = creation_nom_fichier(s_etat_processus,
2812: (*s_etat_processus).chemin_fichiers_temporaires))
2813: == NULL)
2814: {
2815: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2816: return;
2817: }
2818:
2819: if ((nom = malloc((strlen(nom_temporaire)
2820: + 5) * sizeof(unsigned char))) == NULL)
2821: {
2822: (*s_etat_processus).erreur_systeme =
2823: d_es_allocation_memoire;
2824: return;
2825: }
2826:
2827: sprintf(nom, "%s.rpl", nom_temporaire);
2828: free(nom_temporaire);
2829: }
2830: else
2831: {
2832: if ((nom = transliteration(s_etat_processus, nom,
2833: d_locale, "UTF-8")) == NULL)
2834: {
2835: liberation(s_etat_processus, s_objet_argument);
2836: liberation(s_etat_processus, s_objet_resultat);
2837: return;
2838: }
2839: }
2840:
2841: /*
2842: * Ouverture du fichier
2843: */
2844:
2845: (*((struct_fichier *) (*s_objet_resultat).objet))
2846: .nom = NULL;
2847: (*((struct_fichier *) (*s_objet_resultat).objet))
2848: .acces = type_acces;
2849: (*((struct_fichier *) (*s_objet_resultat).objet))
2850: .binaire = format;
2851: (*((struct_fichier *) (*s_objet_resultat).objet))
2852: .ouverture = type_ouverture;
2853: (*((struct_fichier *) (*s_objet_resultat).objet)).pid
2854: = getpid();
2855: (*((struct_fichier *) (*s_objet_resultat).objet)).tid
2856: = pthread_self();
2857:
2858: if (((*((struct_fichier *) (*s_objet_resultat).objet)).format =
2859: allocation(s_etat_processus, LST)) == NULL)
2860: {
2861: free(nom);
2862:
2863: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2864: return;
2865: }
2866:
2867: (*(*((struct_fichier *) (*s_objet_resultat).objet))
2868: .format).objet = NULL;
2869:
2870: descripteur = NULL;
2871:
2872: switch(type_ouverture)
2873: {
2874: case 'N' :
2875: {
2876: erreur = caracteristiques_fichier(s_etat_processus,
2877: nom, &existence, &ouverture, &unite);
2878:
2879: if ((erreur != 0) || (unite != 0))
2880: {
2881: free(nom);
2882:
2883: liberation(s_etat_processus, s_objet_argument);
2884: liberation(s_etat_processus, s_objet_resultat);
2885:
2886: (*s_etat_processus).erreur_execution =
2887: d_ex_erreur_acces_fichier;
2888: return;
2889: }
2890:
2891: if (type_acces == 'S')
2892: {
2893: if ((descripteur = fopen(nom, "w+")) == NULL)
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: else
2906: {
2907: // Si le fichier existe, on le supprime.
2908:
2909: if (unlink(nom) != 0)
2910: {
2911: free(nom);
2912:
2913: liberation(s_etat_processus, s_objet_argument);
2914: liberation(s_etat_processus, s_objet_resultat);
2915:
2916: (*s_etat_processus).erreur_execution =
2917: d_ex_erreur_acces_fichier;
2918: return;
2919: }
2920:
2921: sqlite = NULL;
2922:
2923: if (sqlite3_open_v2(nom, &sqlite,
2924: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
2925: NULL) != SQLITE_OK)
2926: {
2927: if (sqlite != NULL)
2928: {
2929: sqlite3_close(sqlite);
2930: }
2931:
2932: free(nom);
2933:
2934: liberation(s_etat_processus, s_objet_argument);
2935: liberation(s_etat_processus, s_objet_resultat);
2936:
2937: (*s_etat_processus).erreur_execution =
2938: d_ex_erreur_acces_fichier;
2939: return;
2940: }
2941:
2942: if ((descripteur = fopen(nom, "a+")) == NULL)
2943: {
2944: free(nom);
2945:
2946: liberation(s_etat_processus, s_objet_argument);
2947: liberation(s_etat_processus, s_objet_resultat);
2948:
2949: (*s_etat_processus).erreur_execution =
2950: d_ex_erreur_acces_fichier;
2951: return;
2952: }
2953:
2954: if (type_acces == 'D')
2955: {
2956: if (initialisation_fichier_acces_direct(
2957: s_etat_processus, sqlite,
2958: (format == 'N') ? d_faux : d_vrai)
2959: != d_absence_erreur)
2960: {
2961: free(nom);
2962:
2963: liberation(s_etat_processus, s_objet_argument);
2964: liberation(s_etat_processus, s_objet_resultat);
2965:
2966: return;
2967: }
2968: }
2969: else
2970: {
2971: if (position_clef == 0)
2972: {
2973: free(nom);
2974:
2975: liberation(s_etat_processus, s_objet_argument);
2976: liberation(s_etat_processus, s_objet_resultat);
2977:
2978: (*s_etat_processus).erreur_execution =
2979: d_ex_erreur_parametre_fichier;
2980: return;
2981: }
2982:
2983: if (initialisation_fichier_acces_indexe(
2984: s_etat_processus, sqlite, position_clef,
2985: (format == 'N') ? d_faux : d_vrai)
2986: != d_absence_erreur)
2987: {
2988: free(nom);
2989:
2990: liberation(s_etat_processus, s_objet_argument);
2991: liberation(s_etat_processus, s_objet_resultat);
2992:
2993: return;
2994: }
2995: }
2996: }
2997:
2998: break;
2999: }
3000:
3001: case 'O' :
3002: {
3003: erreur = caracteristiques_fichier(s_etat_processus, nom,
3004: &existence, &ouverture, &unite);
3005:
3006: if ((erreur != d_absence_erreur) || (existence == d_faux))
3007: {
3008: free(nom);
3009:
3010: liberation(s_etat_processus, s_objet_argument);
3011: liberation(s_etat_processus, s_objet_resultat);
3012:
3013: (*s_etat_processus).erreur_execution =
3014: d_ex_erreur_acces_fichier;
3015: return;
3016: }
3017:
3018: if (type_acces == 'S')
3019: {
3020: if ((descripteur = fopen(nom, "r+")) == NULL)
3021: {
3022: free(nom);
3023:
3024: liberation(s_etat_processus, s_objet_argument);
3025: liberation(s_etat_processus, s_objet_resultat);
3026:
3027: (*s_etat_processus).erreur_execution =
3028: d_ex_erreur_acces_fichier;
3029: return;
3030: }
3031: }
3032: else
3033: {
3034: sqlite = NULL;
3035:
3036: if (sqlite3_open_v2(nom, &sqlite,
3037: SQLITE_OPEN_READWRITE,
3038: NULL) != SQLITE_OK)
3039: {
3040: if (sqlite != NULL)
3041: {
3042: sqlite3_close(sqlite);
3043: }
3044:
3045: free(nom);
3046:
3047: liberation(s_etat_processus, s_objet_argument);
3048: liberation(s_etat_processus, s_objet_resultat);
3049:
3050: (*s_etat_processus).erreur_execution =
3051: d_ex_erreur_acces_fichier;
3052: return;
3053: }
3054:
3055: if ((descripteur = fopen(nom, "a+")) == NULL)
3056: {
3057: free(nom);
3058:
3059: liberation(s_etat_processus, s_objet_argument);
3060: liberation(s_etat_processus, s_objet_resultat);
3061:
3062: (*s_etat_processus).erreur_execution =
3063: d_ex_erreur_acces_fichier;
3064: return;
3065: }
3066: }
3067:
3068: break;
3069: }
3070:
3071: case 'R' :
3072: {
3073: erreur = caracteristiques_fichier(s_etat_processus,
3074: nom, &existence, &ouverture, &unite);
3075:
3076: if ((erreur != d_absence_erreur) || (existence == d_faux))
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_acces_fichier;
3085: return;
3086: }
3087:
3088: /* Test du verrou */
3089:
3090: if ((descripteur = fopen(nom, "r")) == NULL)
3091: {
3092: free(nom);
3093:
3094: liberation(s_etat_processus, s_objet_argument);
3095: liberation(s_etat_processus, s_objet_resultat);
3096:
3097: (*s_etat_processus).erreur_execution =
3098: d_ex_erreur_acces_fichier;
3099: return;
3100: }
3101:
3102: lock.l_type = F_WRLCK;
3103: lock.l_whence = SEEK_SET;
3104: lock.l_start = 0;
3105: lock.l_len = 0;
3106: lock.l_pid = getpid();
3107:
3108: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
3109: {
3110: free(nom);
3111:
3112: if (fclose(descripteur) != 0)
3113: {
3114: liberation(s_etat_processus, s_objet_argument);
3115: liberation(s_etat_processus, s_objet_resultat);
3116:
3117: (*s_etat_processus).erreur_systeme =
3118: d_es_erreur_fichier;
3119: return;
3120: }
3121:
3122: liberation(s_etat_processus, s_objet_argument);
3123: liberation(s_etat_processus, s_objet_resultat);
3124:
3125: (*s_etat_processus).erreur_systeme =
3126: d_es_erreur_fichier;
3127: return;
3128: }
3129:
3130: if (lock.l_type != F_UNLCK)
3131: {
3132: free(nom);
3133:
3134: if (fclose(descripteur) != 0)
3135: {
3136: liberation(s_etat_processus, s_objet_argument);
3137: liberation(s_etat_processus, s_objet_resultat);
3138:
3139: (*s_etat_processus).erreur_systeme =
3140: d_es_erreur_fichier;
3141: return;
3142: }
3143:
3144: liberation(s_etat_processus, s_objet_argument);
3145: liberation(s_etat_processus, s_objet_resultat);
3146:
3147: (*s_etat_processus).erreur_execution =
3148: d_ex_fichier_verrouille;
3149: return;
3150: }
3151:
3152: if (fclose(descripteur) != 0)
3153: {
3154: free(nom);
3155:
3156: liberation(s_etat_processus, s_objet_argument);
3157: liberation(s_etat_processus, s_objet_resultat);
3158:
3159: (*s_etat_processus).erreur_systeme =
3160: d_es_erreur_fichier;
3161: return;
3162: }
3163:
3164: if (type_acces == 'S')
3165: {
3166: if ((descripteur = fopen(nom, "w+")) == NULL)
3167: {
3168: free(nom);
3169:
3170: liberation(s_etat_processus, s_objet_argument);
3171: liberation(s_etat_processus, s_objet_resultat);
3172:
3173: (*s_etat_processus).erreur_execution =
3174: d_ex_erreur_acces_fichier;
3175: return;
3176: }
3177: }
3178: else
3179: {
3180: sqlite = NULL;
3181:
3182: if (sqlite3_open_v2(nom, &sqlite,
3183: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3184: NULL) != SQLITE_OK)
3185: {
3186: if (sqlite != NULL)
3187: {
3188: sqlite3_close(sqlite);
3189: }
3190:
3191: free(nom);
3192:
3193: liberation(s_etat_processus, s_objet_argument);
3194: liberation(s_etat_processus, s_objet_resultat);
3195:
3196: (*s_etat_processus).erreur_execution =
3197: d_ex_erreur_acces_fichier;
3198: return;
3199: }
3200:
3201: // Ouverture du fichier pour pouvoir gérer les
3202: // verrous à la façon des fichiers séquentiels.
3203:
3204: if ((descripteur = fopen(nom, "a+")) == NULL)
3205: {
3206: free(nom);
3207:
3208: liberation(s_etat_processus, s_objet_argument);
3209: liberation(s_etat_processus, s_objet_resultat);
3210:
3211: (*s_etat_processus).erreur_execution =
3212: d_ex_erreur_acces_fichier;
3213: return;
3214: }
3215:
3216: if (type_acces == 'D')
3217: {
3218: if (initialisation_fichier_acces_direct(
3219: s_etat_processus, sqlite,
3220: (format == 'N') ? d_faux : d_vrai)
3221: != d_absence_erreur)
3222: {
3223: free(nom);
3224:
3225: liberation(s_etat_processus, s_objet_argument);
3226: liberation(s_etat_processus, s_objet_resultat);
3227:
3228: return;
3229: }
3230: }
3231: else
3232: {
3233: if (position_clef == 0)
3234: {
3235: free(nom);
3236:
3237: liberation(s_etat_processus, s_objet_argument);
3238: liberation(s_etat_processus, s_objet_resultat);
3239:
3240: (*s_etat_processus).erreur_execution =
3241: d_ex_erreur_parametre_fichier;
3242: return;
3243: }
3244:
3245: if (initialisation_fichier_acces_indexe(
3246: s_etat_processus, sqlite, position_clef,
3247: (format == 'N') ? d_faux : d_vrai)
3248: != d_absence_erreur)
3249: {
3250: free(nom);
3251:
3252: liberation(s_etat_processus, s_objet_argument);
3253: liberation(s_etat_processus, s_objet_resultat);
3254:
3255: return;
3256: }
3257: }
3258: }
3259:
3260: break;
3261: }
3262:
3263: case 'U' :
3264: {
3265: erreur = caracteristiques_fichier(s_etat_processus,
3266: nom, &existence, &ouverture, &unite);
3267:
3268: if (erreur == d_erreur)
3269: {
3270: free(nom);
3271:
3272: liberation(s_etat_processus, s_objet_argument);
3273: liberation(s_etat_processus, s_objet_resultat);
3274:
3275: (*s_etat_processus).erreur_execution =
3276: d_ex_erreur_acces_fichier;
3277: return;
3278: }
3279:
3280: if (existence == d_faux)
3281: {
3282: if (type_acces == 'S')
3283: {
3284: if ((descripteur = fopen(nom, "w+")) == NULL)
3285: {
3286: free(nom);
3287:
3288: liberation(s_etat_processus, s_objet_argument);
3289: liberation(s_etat_processus, s_objet_resultat);
3290:
3291: (*s_etat_processus).erreur_execution =
3292: d_ex_erreur_acces_fichier;
3293: return;
3294: }
3295: }
3296: else
3297: {
3298: sqlite = NULL;
3299:
3300: if (sqlite3_open_v2(nom, &sqlite,
3301: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3302: NULL) != SQLITE_OK)
3303: {
3304: if (sqlite != NULL)
3305: {
3306: sqlite3_close(sqlite);
3307: }
3308:
3309: free(nom);
3310:
3311: liberation(s_etat_processus, s_objet_argument);
3312: liberation(s_etat_processus, s_objet_resultat);
3313:
3314: (*s_etat_processus).erreur_execution =
3315: d_ex_erreur_acces_fichier;
3316: return;
3317: }
3318:
3319: if ((descripteur = fopen(nom, "a+")) == NULL)
3320: {
3321: free(nom);
3322:
3323: liberation(s_etat_processus, s_objet_argument);
3324: liberation(s_etat_processus, s_objet_resultat);
3325:
3326: (*s_etat_processus).erreur_execution =
3327: d_ex_erreur_acces_fichier;
3328: return;
3329: }
3330:
3331: if (type_acces == 'D')
3332: {
3333: if (initialisation_fichier_acces_direct(
3334: s_etat_processus, sqlite,
3335: (format == 'N') ? d_faux : d_vrai)
3336: != d_absence_erreur)
3337: {
3338: free(nom);
3339:
3340: liberation(s_etat_processus,
3341: s_objet_argument);
3342: liberation(s_etat_processus,
3343: s_objet_resultat);
3344:
3345: return;
3346: }
3347: }
3348: else
3349: {
3350: if (position_clef == 0)
3351: {
3352: free(nom);
3353:
3354: liberation(s_etat_processus,
3355: s_objet_argument);
3356: liberation(s_etat_processus,
3357: s_objet_resultat);
3358:
3359: (*s_etat_processus).erreur_execution =
3360: d_ex_erreur_parametre_fichier;
3361: return;
3362: }
3363:
3364: if (initialisation_fichier_acces_indexe(
3365: s_etat_processus, sqlite, position_clef,
3366: (format == 'N') ? d_faux : d_vrai)
3367: != d_absence_erreur)
3368: {
3369: free(nom);
3370:
3371: liberation(s_etat_processus,
3372: s_objet_argument);
3373: liberation(s_etat_processus,
3374: s_objet_resultat);
3375:
3376: return;
3377: }
3378: }
3379: }
3380: }
3381: else
3382: {
3383: if (type_acces == 'S')
3384: {
3385: if ((descripteur = fopen(nom, "r+")) == NULL)
3386: {
3387: free(nom);
3388:
3389: liberation(s_etat_processus, s_objet_argument);
3390: liberation(s_etat_processus, s_objet_resultat);
3391:
3392: (*s_etat_processus).erreur_execution =
3393: d_ex_erreur_acces_fichier;
3394: return;
3395: }
3396: }
3397: else
3398: {
3399: sqlite = NULL;
3400:
3401: if (sqlite3_open_v2(nom, &sqlite,
3402: SQLITE_OPEN_READWRITE,
3403: NULL) != SQLITE_OK)
3404: {
3405: if (sqlite != NULL)
3406: {
3407: sqlite3_close(sqlite);
3408: }
3409:
3410: free(nom);
3411:
3412: liberation(s_etat_processus, s_objet_argument);
3413: liberation(s_etat_processus, s_objet_resultat);
3414:
3415: (*s_etat_processus).erreur_execution =
3416: d_ex_erreur_acces_fichier;
3417: return;
3418: }
3419:
3420: if ((descripteur = fopen(nom, "a+")) == NULL)
3421: {
3422: free(nom);
3423:
3424: liberation(s_etat_processus, s_objet_argument);
3425: liberation(s_etat_processus, s_objet_resultat);
3426:
3427: (*s_etat_processus).erreur_execution =
3428: d_ex_erreur_acces_fichier;
3429: return;
3430: }
3431: }
3432: }
3433:
3434: break;
3435: }
3436:
3437: case 'S' :
3438: {
3439: erreur = caracteristiques_fichier(s_etat_processus,
3440: nom, &existence, &ouverture, &unite);
3441:
3442: if ((erreur != d_absence_erreur) || (existence != d_faux))
3443: {
3444: free(nom);
3445:
3446: liberation(s_etat_processus, s_objet_argument);
3447: liberation(s_etat_processus, s_objet_resultat);
3448:
3449: (*s_etat_processus).erreur_execution =
3450: d_ex_erreur_acces_fichier;
3451: return;
3452: }
3453:
3454: if (type_acces == 'S')
3455: {
3456: if ((descripteur = fopen(nom, "w+")) == NULL)
3457: {
3458: free(nom);
3459:
3460: liberation(s_etat_processus, s_objet_argument);
3461: liberation(s_etat_processus, s_objet_resultat);
3462:
3463: (*s_etat_processus).erreur_execution =
3464: d_ex_erreur_acces_fichier;
3465: return;
3466: }
3467: }
3468: else
3469: {
3470: // Si le fichier existe, on le supprime.
3471:
3472: if (unlink(nom) != 0)
3473: {
3474: free(nom);
3475:
3476: liberation(s_etat_processus, s_objet_argument);
3477: liberation(s_etat_processus, s_objet_resultat);
3478:
3479: (*s_etat_processus).erreur_execution =
3480: d_ex_erreur_acces_fichier;
3481: return;
3482: }
3483:
3484: sqlite = NULL;
3485:
3486: if (sqlite3_open_v2(nom, &sqlite,
3487: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3488: NULL) != SQLITE_OK)
3489: {
3490: if (sqlite != NULL)
3491: {
3492: sqlite3_close(sqlite);
3493: }
3494:
3495: free(nom);
3496:
3497: liberation(s_etat_processus, s_objet_argument);
3498: liberation(s_etat_processus, s_objet_resultat);
3499:
3500: (*s_etat_processus).erreur_execution =
3501: d_ex_erreur_acces_fichier;
3502: return;
3503: }
3504:
3505: if ((descripteur = fopen(nom, "a+")) == NULL)
3506: {
3507: free(nom);
3508:
3509: liberation(s_etat_processus, s_objet_argument);
3510: liberation(s_etat_processus, s_objet_resultat);
3511:
3512: (*s_etat_processus).erreur_execution =
3513: d_ex_erreur_acces_fichier;
3514: return;
3515: }
3516:
3517: if (type_acces == 'D')
3518: {
3519: if (initialisation_fichier_acces_direct(
3520: s_etat_processus, sqlite,
3521: (format == 'N') ? d_faux : d_vrai)
3522: != d_absence_erreur)
3523: {
3524: free(nom);
3525:
3526: liberation(s_etat_processus, s_objet_argument);
3527: liberation(s_etat_processus, s_objet_resultat);
3528:
3529: return;
3530: }
3531: }
3532: else
3533: {
3534: if (position_clef == 0)
3535: {
3536: free(nom);
3537:
3538: liberation(s_etat_processus, s_objet_argument);
3539: liberation(s_etat_processus, s_objet_resultat);
3540:
3541: (*s_etat_processus).erreur_execution =
3542: d_ex_erreur_parametre_fichier;
3543: return;
3544: }
3545:
3546: if (initialisation_fichier_acces_indexe(
3547: s_etat_processus, sqlite, position_clef,
3548: (format == 'N') ? d_faux : d_vrai)
3549: != d_absence_erreur)
3550: {
3551: free(nom);
3552:
3553: liberation(s_etat_processus, s_objet_argument);
3554: liberation(s_etat_processus, s_objet_resultat);
3555:
3556: return;
3557: }
3558: }
3559: }
3560:
3561: break;
3562: }
3563:
3564: default:
3565: {
3566: BUG(1, printf("type_ouverture=%c\n", type_ouverture));
3567: return;
3568: }
3569: }
3570:
3571: if (((*((struct_fichier *) (*s_objet_resultat).objet)).nom =
3572: malloc((strlen(nom) + 1) *
3573: sizeof(unsigned char))) == NULL)
3574: {
3575: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3576: return;
3577: }
3578:
3579: if (s_parametres_tty != NULL)
3580: {
3581: // Affectation des paramètres du port série.
3582:
3583: if (tcgetattr(fileno(descripteur), &tc) != 0)
3584: {
3585: liberation(s_etat_processus, s_objet_argument);
3586: liberation(s_etat_processus, s_objet_resultat);
3587:
3588: (*s_etat_processus).erreur_systeme =
3589: d_ex_erreur_fichier;
3590: return;
3591: }
3592:
3593: // Un test a déjà été fait pour vérifier que s_parametres_tty
3594: // contient deux ou trois arguments.
3595:
3596: parametre_courant = ((*(struct_liste_chainee *)
3597: (*s_parametres_tty).objet)).suivant;
3598:
3599: // Le premier paramètre concerne la vitesse du port. Il doit
3600: // toujours être présent.
3601:
3602: if (parametre_courant == NULL)
3603: {
3604: liberation(s_etat_processus, s_objet_argument);
3605: liberation(s_etat_processus, s_objet_resultat);
3606:
3607: (*s_etat_processus).erreur_execution =
3608: d_ex_erreur_parametre_fichier;
3609: return;
3610: }
3611:
3612: if ((*(*parametre_courant).donnee).type != CHN)
3613: {
3614: liberation(s_etat_processus, s_objet_argument);
3615: liberation(s_etat_processus, s_objet_resultat);
3616:
3617: (*s_etat_processus).erreur_execution =
3618: d_ex_erreur_parametre_fichier;
3619: return;
3620: }
3621:
3622: if ((parametre_courant_majuscule = conversion_majuscule(
3623: (*(*parametre_courant).donnee).objet)) == NULL)
3624: {
3625: liberation(s_etat_processus, s_objet_argument);
3626: liberation(s_etat_processus, s_objet_resultat);
3627:
3628: (*s_etat_processus).erreur_systeme =
3629: d_es_allocation_memoire;
3630: return;
3631: }
3632:
3633: position = parametre_courant_majuscule;
3634:
3635: while((*position) != d_code_fin_chaine)
3636: {
3637: if ((*position) == ',')
3638: {
3639: (*position) = ' ';
3640: }
3641:
3642: position++;
3643: }
3644:
3645: position = parametre_courant_majuscule;
3646:
3647: while((*position) != d_code_fin_chaine)
3648: {
3649: if (isalnum((*position)) != 0)
3650: {
3651: break;
3652: }
3653:
3654: position++;
3655: }
3656:
3657: // Vitesse
3658:
3659: unsigned char *vitesses[] =
3660: { "0", "50", "75", "110", "134", "150",
3661: "200", "300", "600", "1200", "1800", "2400",
3662: "4800", "9600", "19200", "38400",
3663: #ifdef B57600
3664: "57600",
3665: #endif
3666: #ifdef B115200
3667: "115200",
3668: #endif
3669: #ifdef B230400
3670: "230400",
3671: #endif
3672: NULL };
3673: int vitesses_constantes[] =
3674: { B0, B50, B75, B110, B134, B150, B200, B300, B600,
3675: B1200, B1800, B2400, B4800, B9600, B19200, B38400,
3676: #ifdef B57600
3677: B57600,
3678: #endif
3679: #ifdef B115200
3680: B115200,
3681: #endif
3682: #ifdef B230400
3683: B230400,
3684: #endif
3685: 0 };
3686: unsigned int vitesse_courante;
3687:
3688: vitesse_courante = 0;
3689:
3690: while(vitesses[vitesse_courante] != NULL)
3691: {
3692: if (strncmp(position, vitesses[vitesse_courante],
3693: strlen(vitesses[vitesse_courante])) == 0)
3694: {
3695: if (position[strlen(vitesses[vitesse_courante])] ==
3696: d_code_espace)
3697: {
3698: #ifdef CBAUD
3699: tc.c_cflag &= ~CBAUD;
3700: tc.c_cflag |= vitesses_constantes[vitesse_courante];
3701: #else // POSIX
3702: cfsetispeed(&tc,
3703: vitesses_constantes[vitesse_courante]);
3704: cfsetospeed(&tc,
3705: vitesses_constantes[vitesse_courante]);
3706: #endif
3707: position += strlen(vitesses[vitesse_courante]);
3708:
3709: break;
3710: }
3711: }
3712:
3713: vitesse_courante++;
3714: }
3715:
3716: if (vitesses[vitesse_courante] == NULL)
3717: {
3718: // La vitesse indiquée n'est pas une vitesse autorisée.
3719:
3720: free(parametre_courant_majuscule);
3721: liberation(s_etat_processus, s_objet_argument);
3722: liberation(s_etat_processus, s_objet_resultat);
3723:
3724: (*s_etat_processus).erreur_execution =
3725: d_ex_erreur_parametre_fichier;
3726: return;
3727: }
3728:
3729: // Nombre de bits par caractère.
3730:
3731: while((*position) != d_code_fin_chaine)
3732: {
3733: if (isalnum((*position)) != 0)
3734: {
3735: break;
3736: }
3737:
3738: position++;
3739: }
3740:
3741: switch((*position))
3742: {
3743: case '5':
3744: {
3745: tc.c_cflag &= ~CSIZE;
3746: tc.c_cflag |= CS5;
3747: break;
3748: }
3749:
3750: case '6':
3751: {
3752: tc.c_cflag &= ~CSIZE;
3753: tc.c_cflag |= CS6;
3754: break;
3755: }
3756:
3757: case '7':
3758: {
3759: tc.c_cflag &= ~CSIZE;
3760: tc.c_cflag |= CS7;
3761: break;
3762: }
3763:
3764: case '8':
3765: {
3766: tc.c_cflag &= ~CSIZE;
3767: tc.c_cflag |= CS8;
3768: break;
3769: }
3770:
3771: default:
3772: {
3773: free(parametre_courant_majuscule);
3774: liberation(s_etat_processus, s_objet_argument);
3775: liberation(s_etat_processus, s_objet_resultat);
3776:
3777: (*s_etat_processus).erreur_execution =
3778: d_ex_erreur_parametre_fichier;
3779: return;
3780: }
3781: }
3782:
3783: position++;
3784:
3785: if ((*position) != d_code_espace)
3786: {
3787: free(parametre_courant_majuscule);
3788: liberation(s_etat_processus, s_objet_argument);
3789: liberation(s_etat_processus, s_objet_resultat);
3790:
3791: (*s_etat_processus).erreur_execution =
3792: d_ex_erreur_parametre_fichier;
3793: return;
3794: }
3795:
3796: // Parité
3797:
3798: while((*position) != d_code_fin_chaine)
3799: {
3800: if (isalnum((*position)) != 0)
3801: {
3802: break;
3803: }
3804:
3805: position++;
3806: }
3807:
3808: switch((*position))
3809: {
3810: case 'N':
3811: {
3812: tc.c_cflag &= ~PARENB;
3813: break;
3814: }
3815:
3816: case 'O':
3817: {
3818: tc.c_cflag |= PARENB;
3819: tc.c_cflag |= PARODD;
3820: break;
3821: }
3822:
3823: case 'E':
3824: {
3825: tc.c_cflag |= PARENB;
3826: tc.c_cflag &= ~PARODD;
3827: break;
3828: }
3829:
3830: default:
3831: {
3832: free(parametre_courant_majuscule);
3833: liberation(s_etat_processus, s_objet_argument);
3834: liberation(s_etat_processus, s_objet_resultat);
3835:
3836: (*s_etat_processus).erreur_execution =
3837: d_ex_erreur_parametre_fichier;
3838: return;
3839: }
3840: }
3841:
3842: position++;
3843:
3844: if ((*position) != d_code_espace)
3845: {
3846: free(parametre_courant_majuscule);
3847: liberation(s_etat_processus, s_objet_argument);
3848: liberation(s_etat_processus, s_objet_resultat);
3849:
3850: (*s_etat_processus).erreur_execution =
3851: d_ex_erreur_parametre_fichier;
3852: return;
3853: }
3854:
3855: // Bits de stop
3856:
3857: while((*position) != d_code_fin_chaine)
3858: {
3859: if (isalnum((*position)) != 0)
3860: {
3861: break;
3862: }
3863:
3864: position++;
3865: }
3866:
3867: switch((*position))
3868: {
3869: case '1':
3870: {
3871: tc.c_cflag &= ~CSTOPB;
3872: break;
3873: }
3874:
3875: case '2':
3876: {
3877: tc.c_cflag |= CSTOPB;
3878: break;
3879: }
3880:
3881: default:
3882: {
3883: free(parametre_courant_majuscule);
3884: liberation(s_etat_processus, s_objet_argument);
3885: liberation(s_etat_processus, s_objet_resultat);
3886:
3887: (*s_etat_processus).erreur_execution =
3888: d_ex_erreur_parametre_fichier;
3889: return;
3890: }
3891: }
3892:
3893: // S'il reste autre chose que des espaces, il y a un
3894: // problème de paramètres.
3895:
3896: position++;
3897:
3898: while((*position) != d_code_fin_chaine)
3899: {
3900: if ((*position) != d_code_espace)
3901: {
3902: free(parametre_courant_majuscule);
3903: liberation(s_etat_processus, s_objet_argument);
3904: liberation(s_etat_processus, s_objet_resultat);
3905:
3906: (*s_etat_processus).erreur_execution =
3907: d_ex_erreur_parametre_fichier;
3908: return;
3909: }
3910:
3911: position++;
3912: }
3913:
3914: // Autres paramètres
3915:
3916: free(parametre_courant_majuscule);
3917: parametre_courant = (*parametre_courant).suivant;
3918:
3919: if (parametre_courant != NULL)
3920: {
3921: parametre_courant = (*(*parametre_courant).donnee).objet;
3922: }
3923:
3924: while(parametre_courant != NULL)
3925: {
3926: if ((*(*parametre_courant).donnee).type != CHN)
3927: {
3928: liberation(s_etat_processus, s_objet_argument);
3929: liberation(s_etat_processus, s_objet_resultat);
3930:
3931: (*s_etat_processus).erreur_execution =
3932: d_ex_erreur_parametre_fichier;
3933: return;
3934: }
3935:
3936: if ((parametre_courant_majuscule = conversion_majuscule(
3937: (*(*parametre_courant).donnee).objet)) == NULL)
3938: {
3939: (*s_etat_processus).erreur_systeme =
3940: d_es_allocation_memoire;
3941: return;
3942: }
3943:
3944: position = parametre_courant_majuscule;
3945: negation = d_faux;
3946:
3947: unsigned char *fonctions[] =
3948: { "IGNBRK", "BRKINT", "IGNPAR", "PARMRK",
3949: "INPCK", "ISTRIP", "INLCR", "IGNCR", "ICRNL",
3950: "IXON",
3951: #ifdef IXANY
3952: "IXANY",
3953: #endif
3954: "IXOFF", "OPOST",
3955: "ONLCR", "OCRNL", "ONOCR", "ONLRET",
3956: #ifdef OFILL
3957: "OFILL",
3958: #endif
3959: "HUPCL", "CLOCAL",
3960: #ifdef CRTSCTS
3961: "CRTSCTS",
3962: #endif
3963: "ISIG", "ICANON", "ECHO", "ECHOE", "ECHOK",
3964: "ECHONL", "NOFLSH", "TOSTOP", "IEXTEN", NULL };
3965: int fonctions_constantes[] =
3966: { /* c_iflag */
3967: 1, IGNBRK, 1, BRKINT, 1, IGNPAR, 1, PARMRK,
3968: 1, INPCK, 1, ISTRIP, 1, INLCR, 1, IGNCR, 1, ICRNL,
3969: 1, IXON,
3970: #ifdef IXANY
3971: 1, IXANY,
3972: #endif
3973: 1, IXOFF,
3974: /* c_oflag */
3975: 2 , OPOST, 2, ONLCR, 2, OCRNL, 2, ONOCR, 2, ONLRET,
3976: #ifdef OFILL
3977: 2, OFILL,
3978: #endif
3979: 2, HUPCL,
3980: /* c_cflag */
3981: 3, CLOCAL,
3982: #ifdef CRTSCTS
3983: 3, CRTSCTS,
3984: #endif
3985: /* c_lfkag */
3986: 4, ISIG, 4, ICANON, 4, ECHO, 4, ECHOE, 4, ECHOK,
3987: 4, ECHONL, 4, NOFLSH, 4, TOSTOP, 4, IEXTEN };
3988: unsigned int fonction_courante;
3989:
3990: // On vient de trouver quelque chose à interpréter.
3991:
3992: if (strncmp(position, "NO ", 3) == 0)
3993: {
3994: position += 3;
3995: negation = d_vrai;
3996: }
3997:
3998: for(fonction_courante = 0;
3999: fonctions[fonction_courante] != NULL;
4000: fonction_courante++)
4001: {
4002: if (strcmp(fonctions[fonction_courante], position)
4003: == 0)
4004: {
4005: if (negation == d_vrai)
4006: {
4007: switch(fonctions_constantes
4008: [fonction_courante * 2])
4009: {
4010: case 1:
4011: {
4012: tc.c_iflag &= ~fonctions_constantes
4013: [(fonction_courante * 2) + 1];
4014: break;
4015: }
4016:
4017: case 2:
4018: {
4019: tc.c_oflag &= ~fonctions_constantes
4020: [(fonction_courante * 2) + 1];
4021: break;
4022: }
4023:
4024: case 3:
4025: {
4026: tc.c_cflag &= ~fonctions_constantes
4027: [(fonction_courante * 2) + 1];
4028: break;
4029: }
4030:
4031: case 4:
4032: {
4033: tc.c_lflag &= ~fonctions_constantes
4034: [(fonction_courante * 2) + 1];
4035: break;
4036: }
4037: }
4038: }
4039: else
4040: {
4041: switch(fonctions_constantes
4042: [fonction_courante * 2])
4043: {
4044: case 1:
4045: {
4046: tc.c_iflag |= fonctions_constantes
4047: [(fonction_courante * 2) + 1];
4048: break;
4049: }
4050:
4051: case 2:
4052: {
4053: tc.c_oflag |= fonctions_constantes
4054: [(fonction_courante * 2) + 1];
4055: break;
4056: }
4057:
4058: case 3:
4059: {
4060: tc.c_cflag |= fonctions_constantes
4061: [(fonction_courante * 2) + 1];
4062: break;
4063: }
4064:
4065: case 4:
4066: {
4067: tc.c_lflag |= fonctions_constantes
4068: [(fonction_courante * 2) + 1];
4069: break;
4070: }
4071: }
4072: }
4073:
4074: break;
4075: }
4076: }
4077:
4078: if (fonctions[fonction_courante] == NULL)
4079: {
4080: free(parametre_courant_majuscule);
4081: liberation(s_etat_processus, s_objet_argument);
4082: liberation(s_etat_processus, s_objet_resultat);
4083:
4084: (*s_etat_processus).erreur_execution =
4085: d_ex_erreur_parametre_fichier;
4086: return;
4087: }
4088:
4089: free(parametre_courant_majuscule);
4090: parametre_courant = (*parametre_courant).suivant;
4091: }
4092:
4093: if (tcsetattr(fileno(descripteur), TCSANOW, &tc) != 0)
4094: {
4095: liberation(s_etat_processus, s_objet_argument);
4096: liberation(s_etat_processus, s_objet_resultat);
4097:
4098: (*s_etat_processus).erreur_systeme =
4099: d_ex_erreur_fichier;
4100: return;
4101: }
4102: }
4103:
4104: strcpy((*((struct_fichier *) (*s_objet_resultat).objet)).nom, nom);
4105: liberation(s_etat_processus, s_objet_argument);
4106:
4107: (*((struct_fichier *) (*s_objet_resultat).objet)).protection =
4108: protection;
4109: (*((struct_fichier *) (*s_objet_resultat).objet)).position_clef =
4110: position_clef;
4111:
4112: rewind(descripteur);
4113:
4114: lock.l_type = F_WRLCK;
4115: lock.l_whence = SEEK_SET;
4116: lock.l_start = 0;
4117: lock.l_len = 0;
4118: lock.l_pid = getpid();
4119:
4120: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
4121: {
4122: if (fclose(descripteur) != 0)
4123: {
4124: liberation(s_etat_processus, s_objet_resultat);
4125:
4126: (*s_etat_processus).erreur_systeme =
4127: d_es_erreur_fichier;
4128: return;
4129: }
4130:
4131: liberation(s_etat_processus, s_objet_resultat);
4132:
4133: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
4134: return;
4135: }
4136:
4137: if (lock.l_type == F_UNLCK)
4138: {
4139: /*
4140: * Positionnement d'un verrou exclusif d'écriture par défaut
4141: */
4142:
4143: lock.l_type = F_RDLCK;
4144: lock.l_whence = SEEK_SET;
4145: lock.l_start = 0;
4146: lock.l_len = 0;
4147: lock.l_pid = getpid();
4148:
4149: if (fcntl(fileno(descripteur), F_SETLK, &lock) == -1)
4150: {
4151: if (fclose(descripteur) != 0)
4152: {
4153: liberation(s_etat_processus, s_objet_resultat);
4154:
4155: (*s_etat_processus).erreur_systeme =
4156: d_es_erreur_fichier;
4157: return;
4158: }
4159:
4160: liberation(s_etat_processus, s_objet_resultat);
4161:
4162: (*s_etat_processus).erreur_systeme =
4163: d_es_erreur_fichier;
4164: return;
4165: }
4166: }
4167: else
4168: {
4169: /*
4170: * Test de la cohérence du verrou avec l'option PROTECTION
4171: */
4172:
4173: if ((lock.l_type == F_RDLCK) && (protection != 'R'))
4174: {
4175: free(nom);
4176:
4177: if (fclose(descripteur) != 0)
4178: {
4179: liberation(s_etat_processus, s_objet_resultat);
4180:
4181: (*s_etat_processus).erreur_systeme =
4182: d_es_erreur_fichier;
4183: return;
4184: }
4185:
4186: liberation(s_etat_processus, s_objet_resultat);
4187:
4188: (*s_etat_processus).erreur_execution =
4189: d_ex_fichier_verrouille;
4190: return;
4191: }
4192: else if ((lock.l_type == F_WRLCK) && (protection != 'W'))
4193: {
4194: free(nom);
4195:
4196: if (fclose(descripteur) != 0)
4197: {
4198: liberation(s_etat_processus, s_objet_resultat);
4199:
4200: (*s_etat_processus).erreur_systeme =
4201: d_es_erreur_fichier;
4202: return;
4203: }
4204:
4205: liberation(s_etat_processus, s_objet_resultat);
4206:
4207: (*s_etat_processus).erreur_execution =
4208: d_ex_fichier_verrouille;
4209: return;
4210: }
4211: else
4212: {
4213: free(nom);
4214:
4215: if (fclose(descripteur) != 0)
4216: {
4217: liberation(s_etat_processus, s_objet_resultat);
4218:
4219: (*s_etat_processus).erreur_systeme =
4220: d_es_erreur_fichier;
4221: return;
4222: }
4223:
4224: liberation(s_etat_processus, s_objet_resultat);
4225:
4226: (*s_etat_processus).erreur_execution =
4227: d_ex_fichier_verrouille;
4228: return;
4229: }
4230: }
4231:
4232: /*
4233: * Gestion de la liste des fichiers ouverts
4234: */
4235:
4236: l_element_courant = (*s_etat_processus).s_fichiers;
4237:
4238: if (l_element_courant == NULL)
4239: {
4240: if (((*s_etat_processus).s_fichiers = malloc(sizeof(
4241: struct_liste_chainee))) == NULL)
4242: {
4243: (*s_etat_processus).erreur_systeme =
4244: d_es_allocation_memoire;
4245: return;
4246: }
4247:
4248: (*(*s_etat_processus).s_fichiers).suivant = NULL;
4249:
4250: if (((*(*s_etat_processus).s_fichiers).donnee =
4251: malloc(sizeof(struct_descripteur_fichier))) == NULL)
4252: {
4253: (*s_etat_processus).erreur_systeme =
4254: d_es_allocation_memoire;
4255: return;
4256: }
4257:
4258: l_element_courant = (*s_etat_processus).s_fichiers;
4259: prochain_descripteur = 0;
4260: }
4261: else
4262: {
4263: /*
4264: * Recherche du premier descripteur libre
4265: */
4266:
4267: if ((chaine_descripteurs = malloc(sizeof(unsigned char) *
4268: (ds_nombre_maximum_fichiers_ouverts + 1))) == NULL)
4269: {
4270: (*s_etat_processus).erreur_systeme =
4271: d_es_allocation_memoire;
4272: return;
4273: }
4274:
4275: for(pointeur = chaine_descripteurs, i = 0;
4276: i < ds_nombre_maximum_fichiers_ouverts;
4277: (*pointeur) = d_code_espace, pointeur++, i++);
4278: (*pointeur) = d_code_fin_chaine;
4279:
4280: do
4281: {
4282: chaine_descripteurs[(*((struct_descripteur_fichier *)
4283: (*l_element_courant).donnee)).identifiant] = '-';
4284: l_element_courant = (*l_element_courant).suivant;
4285: } while(l_element_courant != NULL);
4286:
4287: i = 0;
4288: pointeur = chaine_descripteurs;
4289:
4290: while(i < ds_nombre_maximum_fichiers_ouverts)
4291: {
4292: if ((*pointeur) == ' ')
4293: {
4294: break;
4295: }
4296:
4297: pointeur++;
4298: i++;
4299: }
4300:
4301: free(chaine_descripteurs);
4302:
4303: if (i == ds_nombre_maximum_fichiers_ouverts)
4304: {
4305: (*s_etat_processus).erreur_systeme =
4306: d_es_nombre_max_descripteurs;
4307: return;
4308: }
4309:
4310: prochain_descripteur = i;
4311:
4312: /*
4313: * Ajout d'un élément à la fin de la liste chaînée
4314: */
4315:
4316: l_element_courant = (*s_etat_processus).s_fichiers;
4317: while((*l_element_courant).suivant != NULL)
4318: {
4319: l_element_courant = (*l_element_courant).suivant;
4320: }
4321:
4322: if (((*l_element_courant).suivant =
4323: allocation_maillon(s_etat_processus)) == NULL)
4324: {
4325: (*s_etat_processus).erreur_systeme =
4326: d_es_allocation_memoire;
4327: return;
4328: }
4329:
4330: l_element_courant = (*l_element_courant).suivant;
4331: (*l_element_courant).suivant = NULL;
4332:
4333: if (((*l_element_courant).donnee =
4334: malloc(sizeof(struct_descripteur_fichier))) == NULL)
4335: {
4336: (*s_etat_processus).erreur_systeme =
4337: d_es_allocation_memoire;
4338: return;
4339: }
4340: }
4341:
4342: (*((struct_fichier *) (*s_objet_resultat).objet)).descripteur
4343: = prochain_descripteur;
4344: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4345: .identifiant = prochain_descripteur;
4346:
4347: if (type_acces == 'S')
4348: {
4349: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4350: .type = 'C';
4351: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4352: .descripteur_c = descripteur;
4353: }
4354: else
4355: {
4356: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4357: .type = 'S';
4358: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4359: .descripteur_c = descripteur;
4360: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4361: .descripteur_sqlite = sqlite;
4362: }
4363:
4364: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4365: .pid = getpid();
4366: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4367: .tid = pthread_self();
4368: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4369: .effacement = (type_ouverture == 'S') ? 'Y' : 'N';
4370:
4371: (*((struct_descripteur_fichier *) (*l_element_courant)
4372: .donnee)).nom = nom;
4373: }
4374: else if (type_arguments == 'S')
4375: {
4376: /*
4377: * Traitement des sockets
4378: */
4379:
4380:
4381: inline logical1 options_socket()
4382: {
4383: /*
4384: * Options des sockets
4385: */
4386:
4387: # define WARNING(message) \
4388: if ((*s_etat_processus).langue != 'F') \
4389: printf("+++Warning : %s unavailable on host system\n", \
4390: message); \
4391: else \
4392: printf("+++Attention : %s non disponible sur le système " \
4393: "hôte\n", message)
4394:
4395: if (options[d_BIND_TO_DEVICE] == 'Y')
4396: {
4397: # ifdef SO_BINDTODEVICE
4398: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4399: .objet)).socket, SOL_SOCKET, SO_BINDTODEVICE,
4400: peripherique, strlen(peripherique)) != 0)
4401: {
4402: liberation(s_etat_processus, s_objet_argument);
4403: liberation(s_etat_processus, s_objet_resultat);
4404:
4405: (*s_etat_processus).erreur_execution =
4406: d_ex_erreur_parametre_fichier;
4407: return(d_erreur);
4408: }
4409: # else
4410: WARNING("BIND TO DEVICE");
4411: # endif
4412: }
4413:
4414: if (options[d_BROADCAST] == 'Y')
4415: {
4416: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4417: .objet)).socket, SOL_SOCKET, SO_BROADCAST,
4418: &drapeau, sizeof(drapeau)) != 0)
4419: {
4420: liberation(s_etat_processus, s_objet_argument);
4421: liberation(s_etat_processus, s_objet_resultat);
4422:
4423: (*s_etat_processus).erreur_execution =
4424: d_ex_erreur_parametre_fichier;
4425: return(d_erreur);
4426: }
4427: }
4428:
4429: if (options[d_DONT_ROUTE] == 'Y')
4430: {
4431: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4432: .objet)).socket, SOL_SOCKET, SO_DONTROUTE,
4433: &drapeau, sizeof(drapeau)) != 0)
4434: {
4435: liberation(s_etat_processus, s_objet_argument);
4436: liberation(s_etat_processus, s_objet_resultat);
4437:
4438: (*s_etat_processus).erreur_execution =
4439: d_ex_erreur_parametre_fichier;
4440: return(d_erreur);
4441: }
4442: }
4443:
4444: if (options[d_KEEP_ALIVE] == 'Y')
4445: {
4446: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4447: .objet)).socket, SOL_SOCKET, SO_KEEPALIVE,
4448: &drapeau, sizeof(drapeau)) != 0)
4449: {
4450: liberation(s_etat_processus, s_objet_argument);
4451: liberation(s_etat_processus, s_objet_resultat);
4452:
4453: (*s_etat_processus).erreur_execution =
4454: d_ex_erreur_parametre_fichier;
4455: return(d_erreur);
4456: }
4457: }
4458:
4459: if (options[d_PRIORITY] == 'Y')
4460: {
4461: # ifdef SO_PRIORITY
4462: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4463: .objet)).socket, SOL_SOCKET, SO_PRIORITY,
4464: &priorite, sizeof(priorite)) != 0)
4465: {
4466: liberation(s_etat_processus, s_objet_argument);
4467: liberation(s_etat_processus, s_objet_resultat);
4468:
4469: (*s_etat_processus).erreur_execution =
4470: d_ex_erreur_parametre_fichier;
4471: return(d_erreur);
4472: }
4473: # else
4474: WARNING("PRIORITY");
4475: # endif
4476: }
4477:
4478: if (options[d_RECEIVE_BUFFER] == 'Y')
4479: {
4480: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4481: .objet)).socket, SOL_SOCKET, SO_RCVBUF,
4482: &buffer_reception, sizeof(buffer_reception)) != 0)
4483: {
4484: liberation(s_etat_processus, s_objet_argument);
4485: liberation(s_etat_processus, s_objet_resultat);
4486:
4487: (*s_etat_processus).erreur_execution =
4488: d_ex_erreur_parametre_fichier;
4489: return(d_erreur);
4490: }
4491: }
4492:
4493: if (options[d_FORCE_RECEIVE_BUFFER] == 'Y')
4494: {
4495: # ifdef SO_RCVBUFFORCE
4496: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4497: .objet)).socket, SOL_SOCKET, SO_RCVBUFFORCE,
4498: &buffer_reception, sizeof(buffer_reception))
4499: != 0)
4500: {
4501: liberation(s_etat_processus, s_objet_argument);
4502: liberation(s_etat_processus, s_objet_resultat);
4503:
4504: (*s_etat_processus).erreur_execution =
4505: d_ex_erreur_parametre_fichier;
4506: return(d_erreur);
4507: }
4508: # else
4509: WARNING("FORCE_RECEIVE_BUFFER");
4510: # endif
4511: }
4512:
4513: if (options[d_SEND_BUFFER] == 'Y')
4514: {
4515: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4516: .objet)).socket, SOL_SOCKET, SO_SNDBUF,
4517: &buffer_emission, sizeof(buffer_emission)) != 0)
4518: {
4519: liberation(s_etat_processus, s_objet_argument);
4520: liberation(s_etat_processus, s_objet_resultat);
4521:
4522: (*s_etat_processus).erreur_execution =
4523: d_ex_erreur_parametre_fichier;
4524: return(d_erreur);
4525: }
4526: }
4527:
4528: if (options[d_FORCE_SEND_BUFFER] == 'Y')
4529: {
4530: # ifdef SO_SNDBUFFORCE
4531: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4532: .objet)).socket, SOL_SOCKET, SO_SNDBUFFORCE,
4533: &buffer_emission, sizeof(buffer_emission)) != 0)
4534: {
4535: liberation(s_etat_processus, s_objet_argument);
4536: liberation(s_etat_processus, s_objet_resultat);
4537:
4538: (*s_etat_processus).erreur_execution =
4539: d_ex_erreur_parametre_fichier;
4540: return(d_erreur);
4541: }
4542: # else
4543: WARNING("FORCE_SEND_BUFFER");
4544: # endif
4545: }
4546:
4547: if (options[d_RECEIVING_TIMEOUT] == 'Y')
4548: {
4549: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4550: .objet)).socket, SOL_SOCKET, SO_RCVTIMEO,
4551: &timeout_reception, sizeof(timeout_reception)) != 0)
4552: {
4553: liberation(s_etat_processus, s_objet_argument);
4554: liberation(s_etat_processus, s_objet_resultat);
4555:
4556: (*s_etat_processus).erreur_execution =
4557: d_ex_erreur_parametre_fichier;
4558: return(d_erreur);
4559: }
4560: }
4561:
4562: if (options[d_SENDING_TIMEOUT] == 'Y')
4563: {
4564: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4565: .objet)).socket, SOL_SOCKET, SO_SNDTIMEO,
4566: &timeout_emission, sizeof(timeout_emission)) != 0)
4567: {
4568: liberation(s_etat_processus, s_objet_argument);
4569: liberation(s_etat_processus, s_objet_resultat);
4570:
4571: (*s_etat_processus).erreur_execution =
4572: d_ex_erreur_parametre_fichier;
4573: return(d_erreur);
4574: }
4575: }
4576:
4577: if (options[d_REUSE_ADDRESS] == 'Y')
4578: {
4579: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
4580: .objet)).socket, SOL_SOCKET, SO_REUSEADDR,
4581: &drapeau, sizeof(drapeau)) != 0)
4582: {
4583: liberation(s_etat_processus, s_objet_argument);
4584: liberation(s_etat_processus, s_objet_resultat);
4585:
4586: (*s_etat_processus).erreur_execution =
4587: d_ex_erreur_parametre_fichier;
4588: return(d_erreur);
4589: }
4590: }
4591:
4592: return(d_absence_erreur);
4593: #undef WARNING
4594: }
4595:
4596: /*
4597: * Vérification de la cohérence des arguments et traitement
4598: * des valeurs par défaut.
4599: */
4600:
4601: if (format == ' ')
4602: {
4603: format = 'N';
4604: }
4605:
4606: if (protection == ' ')
4607: {
4608: protection = 'N';
4609: }
4610:
4611: if (type_domaine == ' ')
4612: {
4613: type_domaine = 'L';
4614: }
4615:
4616: if (type_socket == ' ')
4617: {
4618: type_socket = 'S';
4619: type = SOCK_STREAM;
4620: }
4621:
4622: if (nom != NULL)
4623: {
4624: if (strcmp(protocole, "") == 0)
4625: {
4626: strcpy(protocole, "UNIX");
4627: }
4628: }
4629: else
4630: {
4631: if (strcmp(protocole, "") == 0)
4632: {
4633: strcpy(protocole, "IPV4");
4634: }
4635: }
4636:
4637: if ((nom != NULL) && (hote != NULL))
4638: {
4639: liberation(s_etat_processus, s_objet_argument);
4640:
4641: (*s_etat_processus).erreur_execution =
4642: d_ex_erreur_parametre_fichier;
4643: return;
4644: }
4645:
4646: if ((nom != NULL) && (strcmp(protocole, "UNIX") != 0))
4647: {
4648: liberation(s_etat_processus, s_objet_argument);
4649:
4650: (*s_etat_processus).erreur_execution =
4651: d_ex_erreur_parametre_fichier;
4652: return;
4653: }
4654:
4655: if ((hote != NULL) && (strcmp(protocole, "UNIX") == 0))
4656: {
4657: liberation(s_etat_processus, s_objet_argument);
4658:
4659: (*s_etat_processus).erreur_execution =
4660: d_ex_erreur_parametre_fichier;
4661: return;
4662: }
4663:
4664: if ((nom != NULL) && (type_domaine == 'F') && (type_adresse != ' '))
4665: {
4666: liberation(s_etat_processus, s_objet_argument);
4667:
4668: (*s_etat_processus).erreur_execution =
4669: d_ex_erreur_parametre_fichier;
4670: return;
4671: }
4672:
4673: if ((presence_port == d_vrai) && (nom != NULL))
4674: {
4675: liberation(s_etat_processus, s_objet_argument);
4676:
4677: (*s_etat_processus).erreur_execution =
4678: d_ex_erreur_parametre_fichier;
4679: return;
4680: }
4681:
4682: if ((type_adresse == ' ') && (type_domaine == 'L'))
4683: {
4684: if (strcmp(protocole, "IPV4") == 0)
4685: {
4686: for(i = 0; i < 4; adresse[i++] = 0);
4687: type_adresse = '4';
4688: }
4689: else if (strcmp(protocole, "IPV6") == 0)
4690: {
4691: for(i = 0; i < 16; adresse[i++] = 0);
4692: type_adresse = '6';
4693: }
4694: else
4695: {
4696: liberation(s_etat_processus, s_objet_argument);
4697:
4698: (*s_etat_processus).erreur_execution =
4699: d_ex_erreur_parametre_fichier;
4700: return;
4701: }
4702: }
4703:
4704: if (((strcmp(protocole, "IPV4") == 0) && (type_adresse == '6')) ||
4705: ((strcmp(protocole, "IPV6") == 0) && (type_adresse == '4')))
4706: {
4707: liberation(s_etat_processus, s_objet_argument);
4708:
4709: (*s_etat_processus).erreur_execution =
4710: d_ex_erreur_parametre_fichier;
4711: return;
4712: }
4713:
4714: if ((nombre_maximal_connexions != 0) && ((type_socket != 'S') &&
4715: (type_socket != 'Q')))
4716: {
4717: liberation(s_etat_processus, s_objet_argument);
4718:
4719: (*s_etat_processus).erreur_execution =
4720: d_ex_erreur_parametre_fichier;
4721: return;
4722: }
4723:
4724: if (nombre_maximal_connexions == 0)
4725: {
4726: nombre_maximal_connexions = 1;
4727: }
4728:
4729: if (protocole_socket == NULL)
4730: {
4731: protocole_numerique = 0;
4732: }
4733: else
4734: {
4735: if (strcmp(protocole_socket, "IPV4") == 0)
4736: {
4737: protocole_socket[2] = d_code_fin_chaine;
4738: protocole_numerique = 0;
4739: }
4740: else
4741: {
4742: if ((s_protocole = getprotobyname(protocole_socket))
4743: == NULL)
4744: {
4745: liberation(s_etat_processus, s_objet_argument);
4746:
4747: (*s_etat_processus).erreur_execution =
4748: d_ex_erreur_parametre_fichier;
4749: return;
4750: }
4751:
4752: protocole_numerique = (*s_protocole).p_proto;
4753: }
4754: }
4755:
4756: if ((s_objet_resultat = allocation(s_etat_processus, SCK))
4757: == NULL)
4758: {
4759: (*s_etat_processus).erreur_systeme =
4760: d_es_allocation_memoire;
4761: return;
4762: }
4763:
4764: if (((*((struct_socket *) (*s_objet_resultat).objet)).format =
4765: allocation(s_etat_processus, LST)) == NULL)
4766: {
4767: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4768: return;
4769: }
4770:
4771: (*((struct_socket *) (*s_objet_resultat).objet)).protection
4772: = protection;
4773: (*(*((struct_socket *) (*s_objet_resultat).objet))
4774: .format).objet = NULL;
4775: (*((struct_socket *) (*s_objet_resultat).objet)).adresse = NULL;
4776:
4777: switch(type_socket)
4778: {
4779: case 'S' :
4780: type = SOCK_STREAM;
4781: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4782: type, "STREAM");
4783: break;
4784:
4785: case 'D' :
4786: type = SOCK_DGRAM;
4787: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4788: type, "DATAGRAM");
4789: break;
4790:
4791: case 'Q' :
4792: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4793: type, "SEQUENTIAL DATAGRAM");
4794: type = SOCK_SEQPACKET;
4795: break;
4796:
4797: case 'R' :
4798: type = SOCK_RAW;
4799: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4800: type, "RAW");
4801: break;
4802:
4803: case 'M' :
4804: type = SOCK_RDM;
4805: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4806: type, "ROBUST DATAGRAM");
4807: break;
4808:
4809: default :
4810: BUG(1, printf("type_socket=%c\n", type_socket));
4811: break;
4812: }
4813:
4814: if ((protection != 'N') && ((type_socket != 'S') &&
4815: (type_socket != 'Q')))
4816: {
4817: liberation(s_etat_processus, s_objet_argument);
4818: liberation(s_etat_processus, s_objet_resultat);
4819:
4820: (*s_etat_processus).erreur_execution =
4821: d_ex_erreur_parametre_fichier;
4822: return;
4823: }
4824:
4825: if (nom == NULL)
4826: {
4827: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
4828: malloc(sizeof(unsigned char))) == NULL)
4829: {
4830: (*s_etat_processus).erreur_systeme =
4831: d_es_allocation_memoire;
4832: return;
4833: }
4834:
4835: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).adresse,
4836: "");
4837: }
4838: else
4839: {
4840: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
4841: transliteration(s_etat_processus, nom,
4842: d_locale, "UTF-8")) == NULL)
4843: {
4844: liberation(s_etat_processus, s_objet_argument);
4845: liberation(s_etat_processus, s_objet_resultat);
4846: return;
4847: }
4848: }
4849:
4850: if (((*((struct_socket *) (*s_objet_resultat).objet))
4851: .adresse_distante = malloc(sizeof(unsigned char))) == NULL)
4852: {
4853: (*s_etat_processus).erreur_systeme =
4854: d_es_allocation_memoire;
4855: return;
4856: }
4857:
4858: strcpy((*((struct_socket *) (*s_objet_resultat).objet))
4859: .adresse_distante, "");
4860:
4861: (*((struct_socket *) (*s_objet_resultat).objet)).localisation =
4862: type_domaine;
4863: (*((struct_socket *) (*s_objet_resultat).objet)).binaire =
4864: format;
4865: (*((struct_socket *) (*s_objet_resultat).objet)).pid =
4866: getpid();
4867: (*((struct_socket *) (*s_objet_resultat).objet)).tid =
4868: pthread_self();
4869: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
4870: = 'Y';
4871: (*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee
4872: = d_faux;
4873:
4874: if (type_domaine == 'L')
4875: { // Socket serveur
4876: if (nom != NULL)
4877: {
4878: /*
4879: * La socket locale est dans l'espace des noms.
4880: */
4881:
4882: if (((*((struct_socket *) (*s_objet_resultat).objet))
4883: .socket = socket(PF_UNIX, type,
4884: protocole_numerique)) == -1)
4885: {
4886: liberation(s_etat_processus, s_objet_argument);
4887: liberation(s_etat_processus, s_objet_resultat);
4888:
4889: (*s_etat_processus).erreur_execution =
4890: d_ex_erreur_acces_fichier;
4891: return;
4892: }
4893:
4894: (*((struct_socket *) (*s_objet_resultat).objet)).domaine
4895: = PF_UNIX;
4896: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4897: = 'Y';
4898:
4899: socket_unix.sun_family = AF_UNIX;
4900:
4901: pointeur = (*((struct_socket *)
4902: (*s_objet_resultat).objet)).adresse;
4903:
4904: while((*pointeur) == d_code_espace)
4905: {
4906: pointeur++;
4907: }
4908:
4909: strncpy(socket_unix.sun_path, pointeur, UNIX_PATH_MAX);
4910: socket_unix.sun_path[UNIX_PATH_MAX - 1] = d_code_fin_chaine;
4911:
4912: if (options_socket() == d_erreur)
4913: {
4914: liberation(s_etat_processus, s_objet_argument);
4915: liberation(s_etat_processus, s_objet_resultat);
4916:
4917: return;
4918: }
4919:
4920: if (bind((*((struct_socket *) (*s_objet_resultat).objet))
4921: .socket, (const struct sockaddr *) &socket_unix,
4922: sizeof(socket_unix)) != 0)
4923: {
4924: liberation(s_etat_processus, s_objet_argument);
4925: liberation(s_etat_processus, s_objet_resultat);
4926:
4927: (*s_etat_processus).erreur_execution =
4928: d_ex_erreur_acces_fichier;
4929: return;
4930: }
4931: }
4932: else
4933: {
4934: /*
4935: * La socket est une socket réseau locale. L'adresse
4936: * passée en argument est l'adresse sur laquelle
4937: * cette socket est à l'écoute.
4938: */
4939:
4940: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4941: = 'N';
4942:
4943: if (hote != NULL)
4944: { // Hôte défini par un nom
4945: resolution = NULL;
4946:
4947: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4948: {
4949: liberation(s_etat_processus, s_objet_argument);
4950: liberation(s_etat_processus, s_objet_resultat);
4951:
4952: if (resolution != NULL)
4953: {
4954: freeaddrinfo(resolution);
4955: }
4956:
4957: (*s_etat_processus).erreur_execution =
4958: d_ex_erreur_acces_fichier;
4959: return;
4960: }
4961:
4962: if (strcmp(protocole, "IPV4") == 0)
4963: { // Accès en IPv4
4964: resolution_courante = resolution;
4965:
4966: while(resolution_courante != NULL)
4967: {
4968: if ((*resolution_courante).ai_family ==
4969: AF_INET)
4970: {
4971: break;
4972: }
4973:
4974: resolution_courante = (*resolution_courante)
4975: .ai_next;
4976: }
4977:
4978: if (resolution_courante == NULL)
4979: {
4980: liberation(s_etat_processus, s_objet_argument);
4981: liberation(s_etat_processus, s_objet_resultat);
4982:
4983: freeaddrinfo(resolution);
4984:
4985: (*s_etat_processus).erreur_execution =
4986: d_ex_erreur_acces_fichier;
4987: return;
4988: }
4989:
4990: if (((*((struct_socket *)
4991: (*s_objet_resultat).objet))
4992: .socket = socket(PF_INET, type,
4993: protocole_numerique)) == -1)
4994: {
4995: liberation(s_etat_processus, s_objet_argument);
4996: liberation(s_etat_processus, s_objet_resultat);
4997:
4998: freeaddrinfo(resolution);
4999:
5000: (*s_etat_processus).erreur_execution =
5001: d_ex_erreur_acces_fichier;
5002: return;
5003: }
5004:
5005: (*((struct_socket *) (*s_objet_resultat).objet))
5006: .domaine = PF_INET;
5007:
5008: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
5009: socket_ipv4.sin_family = AF_INET;
5010: socket_ipv4.sin_port = htons((uint16_t) port);
5011: socket_ipv4.sin_addr.s_addr =
5012: (*((struct sockaddr_in *)
5013: (*resolution_courante).ai_addr))
5014: .sin_addr.s_addr;
5015:
5016: if (options_socket() == d_erreur)
5017: {
5018: liberation(s_etat_processus, s_objet_argument);
5019: liberation(s_etat_processus, s_objet_resultat);
5020:
5021: freeaddrinfo(resolution);
5022: return;
5023: }
5024:
5025: if (bind((*((struct_socket *) (*s_objet_resultat)
5026: .objet)).socket, (const struct sockaddr *)
5027: &socket_ipv4, sizeof(socket_ipv4)) != 0)
5028: {
5029: liberation(s_etat_processus, s_objet_argument);
5030: liberation(s_etat_processus, s_objet_resultat);
5031:
5032: freeaddrinfo(resolution);
5033:
5034: (*s_etat_processus).erreur_execution =
5035: d_ex_erreur_acces_fichier;
5036: return;
5037: }
5038:
5039: free((*((struct_socket *) (*s_objet_resultat)
5040: .objet)).adresse);
5041:
5042: if (((*((struct_socket *) (*s_objet_resultat)
5043: .objet)).adresse = malloc(22 *
5044: sizeof(unsigned char))) == NULL)
5045: {
5046: (*s_etat_processus).erreur_systeme =
5047: d_es_allocation_memoire;
5048: return;
5049: }
5050:
5051: sprintf((*((struct_socket *) (*s_objet_resultat)
5052: .objet)).adresse, "%d.%d.%d.%d",
5053: (ntohl((*((struct sockaddr_in *)
5054: (*resolution_courante).ai_addr)).sin_addr
5055: .s_addr) >> 24) & 0xFF,
5056: (ntohl((*((struct sockaddr_in *)
5057: (*resolution_courante).ai_addr)).sin_addr
5058: .s_addr) >> 16) & 0xFF,
5059: (ntohl((*((struct sockaddr_in *)
5060: (*resolution_courante).ai_addr)).sin_addr
5061: .s_addr) >> 8) & 0xFF,
5062: ntohl((*((struct sockaddr_in *)
5063: (*resolution_courante).ai_addr)).sin_addr
5064: .s_addr) & 0xFF);
5065: }
5066: else
5067: { // Accès en IPv6
5068: # ifdef IPV6
5069: resolution_courante = resolution;
5070:
5071: while(resolution_courante != NULL)
5072: {
5073: if ((*resolution_courante).ai_family ==
5074: AF_INET6)
5075: {
5076: break;
5077: }
5078:
5079: resolution_courante = (*resolution_courante)
5080: .ai_next;
5081: }
5082:
5083: if (resolution_courante == NULL)
5084: {
5085: liberation(s_etat_processus, s_objet_argument);
5086: liberation(s_etat_processus, s_objet_resultat);
5087:
5088: freeaddrinfo(resolution);
5089:
5090: (*s_etat_processus).erreur_execution =
5091: d_ex_erreur_acces_fichier;
5092: return;
5093: }
5094:
5095: if (((*((struct_socket *)
5096: (*s_objet_resultat).objet))
5097: .socket = socket(PF_INET6, type,
5098: protocole_numerique)) == -1)
5099: {
5100: liberation(s_etat_processus, s_objet_argument);
5101: liberation(s_etat_processus, s_objet_resultat);
5102:
5103: freeaddrinfo(resolution);
5104:
5105: (*s_etat_processus).erreur_execution =
5106: d_ex_erreur_acces_fichier;
5107: return;
5108: }
5109:
5110: (*((struct_socket *) (*s_objet_resultat).objet))
5111: .domaine = PF_INET6;
5112:
5113: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5114: socket_ipv6.sin6_family = AF_INET6;
5115: socket_ipv6.sin6_port = htons((uint16_t) port);
5116:
5117: for(i = 0; i < 16;
5118: socket_ipv6.sin6_addr.s6_addr[i] =
5119: (*((struct sockaddr_in6 *)
5120: (*resolution_courante).ai_addr))
5121: .sin6_addr.s6_addr[i], i++);
5122:
5123: if (options_socket() == d_erreur)
5124: {
5125: liberation(s_etat_processus, s_objet_argument);
5126: liberation(s_etat_processus, s_objet_resultat);
5127:
5128: freeaddrinfo(resolution);
5129: return;
5130: }
5131:
5132: if (bind((*((struct_socket *) (*s_objet_resultat)
5133: .objet)).socket, (const struct sockaddr *)
5134: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5135: {
5136: liberation(s_etat_processus, s_objet_argument);
5137: liberation(s_etat_processus, s_objet_resultat);
5138:
5139: freeaddrinfo(resolution);
5140:
5141: (*s_etat_processus).erreur_execution =
5142: d_ex_erreur_acces_fichier;
5143: return;
5144: }
5145:
5146: free((*((struct_socket *) (*s_objet_resultat)
5147: .objet)).adresse);
5148:
5149: if (((*((struct_socket *) (*s_objet_resultat)
5150: .objet)).adresse = malloc(55 *
5151: sizeof(unsigned char))) == NULL)
5152: {
5153: (*s_etat_processus).erreur_systeme =
5154: d_es_allocation_memoire;
5155: return;
5156: }
5157:
5158: for(i = 0; i < 16; i++)
5159: {
5160: sprintf((*((struct_socket *) (*s_objet_resultat)
5161: .objet)).adresse,
5162: (i == 0) ? "%s%X" : "%s:%X",
5163: (*((struct_socket *) (*s_objet_resultat)
5164: .objet)).adresse,
5165: (*((struct sockaddr_in6 *)
5166: (*resolution_courante).ai_addr))
5167: .sin6_addr.s6_addr[i]);
5168: }
5169: # else
5170: if ((*s_etat_processus).langue == 'F')
5171: {
5172: printf("+++Attention : Support du protocole"
5173: " IPv6 indisponible\n");
5174: }
5175: else
5176: {
5177: printf("+++Warning : IPv6 support "
5178: "unavailable\n");
5179: }
5180:
5181: liberation(s_etat_processus, s_objet_argument);
5182: liberation(s_etat_processus, s_objet_resultat);
5183:
5184: freeaddrinfo(resolution);
5185:
5186: (*s_etat_processus).erreur_execution =
5187: d_ex_instruction_indisponible;
5188: return;
5189: # endif
5190: }
5191:
5192: freeaddrinfo(resolution);
5193:
5194: sprintf((*((struct_socket *) (*s_objet_resultat)
5195: .objet)).adresse, "%s(%u)",
5196: (*((struct_socket *) (*s_objet_resultat)
5197: .objet)).adresse, (unsigned int) port);
5198: }
5199: else
5200: { // Hôte défini par une adresse
5201: if (strcmp(protocole, "IPV4") == 0)
5202: { // Accès en IPv4
5203: free((*((struct_socket *) (*s_objet_resultat)
5204: .objet)).adresse);
5205:
5206: if (((*((struct_socket *) (*s_objet_resultat)
5207: .objet)).adresse = malloc(22 *
5208: sizeof(unsigned char))) == NULL)
5209: {
5210: (*s_etat_processus).erreur_systeme =
5211: d_es_allocation_memoire;
5212: return;
5213: }
5214:
5215: (*((struct_socket *) (*s_objet_resultat).objet))
5216: .adresse[0] = d_code_fin_chaine;
5217:
5218: for(i = 0; i < 4; i++)
5219: {
5220: sprintf((*((struct_socket *) (*s_objet_resultat)
5221: .objet)).adresse,
5222: (i == 0) ? "%s%d" : "%s.%d",
5223: (*((struct_socket *) (*s_objet_resultat)
5224: .objet)).adresse, (int) adresse[i]);
5225: }
5226:
5227: sprintf((*((struct_socket *) (*s_objet_resultat)
5228: .objet)).adresse, "%s(%u)",
5229: (*((struct_socket *) (*s_objet_resultat)
5230: .objet)).adresse, (unsigned int) port);
5231:
5232: if (((*((struct_socket *)
5233: (*s_objet_resultat).objet))
5234: .socket = socket(PF_INET, type,
5235: protocole_numerique)) == -1)
5236: {
5237: liberation(s_etat_processus, s_objet_argument);
5238: liberation(s_etat_processus, s_objet_resultat);
5239:
5240: (*s_etat_processus).erreur_execution =
5241: d_ex_erreur_acces_fichier;
5242: return;
5243: }
5244:
5245: (*((struct_socket *) (*s_objet_resultat).objet))
5246: .domaine = PF_INET;
5247:
5248: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
5249: socket_ipv4.sin_family = AF_INET;
5250: socket_ipv4.sin_port = htons((uint16_t) port);
5251:
5252: adresse_ipv4 = 0;
5253: for(i = 0; i < 4; adresse_ipv4 =
5254: (256 * adresse_ipv4) + adresse[i++]);
5255:
5256: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
5257:
5258: if (options_socket() == d_erreur)
5259: {
5260: liberation(s_etat_processus, s_objet_argument);
5261: liberation(s_etat_processus, s_objet_resultat);
5262:
5263: return;
5264: }
5265:
5266: if (bind((*((struct_socket *) (*s_objet_resultat)
5267: .objet)).socket, (const struct sockaddr *)
5268: &socket_ipv4, sizeof(socket_ipv4)) != 0)
5269: {
5270: liberation(s_etat_processus, s_objet_argument);
5271: liberation(s_etat_processus, s_objet_resultat);
5272:
5273: (*s_etat_processus).erreur_execution =
5274: d_ex_erreur_acces_fichier;
5275: return;
5276: }
5277: }
5278: else
5279: { // Accès en IPv6
5280: # ifdef IPV6
5281: free((*((struct_socket *) (*s_objet_resultat)
5282: .objet)).adresse);
5283:
5284: if (((*((struct_socket *) (*s_objet_resultat)
5285: .objet)).adresse = malloc(55 *
5286: sizeof(unsigned char))) == NULL)
5287: {
5288: (*s_etat_processus).erreur_systeme =
5289: d_es_allocation_memoire;
5290: return;
5291: }
5292:
5293: (*((struct_socket *) (*s_objet_resultat).objet))
5294: .adresse[0] = d_code_fin_chaine;
5295:
5296: for(i = 0; i < 16; i++)
5297: {
5298: sprintf((*((struct_socket *) (*s_objet_resultat)
5299: .objet)).adresse,
5300: (i == 0) ? "%s%X" : "%s:%X",
5301: (*((struct_socket *) (*s_objet_resultat)
5302: .objet)).adresse, (unsigned int)
5303: adresse[i]);
5304: }
5305:
5306: sprintf((*((struct_socket *) (*s_objet_resultat)
5307: .objet)).adresse, "%s(%u)",
5308: (*((struct_socket *) (*s_objet_resultat)
5309: .objet)).adresse, (unsigned int) port);
5310:
5311: if (((*((struct_socket *)
5312: (*s_objet_resultat).objet))
5313: .socket = socket(PF_INET6, type,
5314: protocole_numerique)) == -1)
5315: {
5316: liberation(s_etat_processus, s_objet_argument);
5317: liberation(s_etat_processus, s_objet_resultat);
5318:
5319: (*s_etat_processus).erreur_execution =
5320: d_ex_erreur_acces_fichier;
5321: return;
5322: }
5323:
5324: (*((struct_socket *) (*s_objet_resultat).objet))
5325: .domaine = PF_INET6;
5326:
5327: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5328: socket_ipv6.sin6_family = AF_INET6;
5329: socket_ipv6.sin6_port = htons((uint16_t) port);
5330:
5331: for(i = 0; i < 16;
5332: socket_ipv6.sin6_addr.s6_addr[i] =
5333: (unsigned char) (adresse[i]), i++);
5334:
5335: if (options_socket() == d_erreur)
5336: {
5337: liberation(s_etat_processus, s_objet_argument);
5338: liberation(s_etat_processus, s_objet_resultat);
5339:
5340: return;
5341: }
5342:
5343: if (bind((*((struct_socket *) (*s_objet_resultat)
5344: .objet)).socket, (const struct sockaddr *)
5345: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5346: {
5347: liberation(s_etat_processus, s_objet_argument);
5348: liberation(s_etat_processus, s_objet_resultat);
5349:
5350: (*s_etat_processus).erreur_execution =
5351: d_ex_erreur_acces_fichier;
5352: return;
5353: }
5354: # else
5355: if ((*s_etat_processus).langue == 'F')
5356: {
5357: printf("+++Attention : Support du protocole"
5358: " IPv6 indisponible\n");
5359: }
5360: else
5361: {
5362: printf("+++Warning : IPv6 support "
5363: "unavailable\n");
5364: }
5365:
5366: liberation(s_etat_processus, s_objet_argument);
5367: liberation(s_etat_processus, s_objet_resultat);
5368:
5369: (*s_etat_processus).erreur_execution =
5370: d_ex_instruction_indisponible;
5371: return;
5372: # endif
5373: }
5374: }
5375:
5376: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
5377: = 'N';
5378: }
5379:
5380: if ((type_socket == 'S') || (type_socket == 'Q'))
5381: {
5382: if (listen((*((struct_socket *) (*s_objet_resultat).objet))
5383: .socket, (int) nombre_maximal_connexions) != 0)
5384: {
5385: liberation(s_etat_processus, s_objet_argument);
5386: liberation(s_etat_processus, s_objet_resultat);
5387:
5388: (*s_etat_processus).erreur_execution =
5389: d_ex_erreur_acces_fichier;
5390: return;
5391: }
5392:
5393: (*((struct_socket *) (*s_objet_resultat).objet))
5394: .socket_connectee = d_vrai;
5395:
5396: if (protection == 'R')
5397: { // WRITEONLY
5398: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5399: .objet)).socket, SHUT_RD) != 0)
5400: {
5401: liberation(s_etat_processus, s_objet_argument);
5402: liberation(s_etat_processus, s_objet_resultat);
5403:
5404: (*s_etat_processus).erreur_execution =
5405: d_ex_erreur_acces_fichier;
5406: return;
5407: }
5408: }
5409: else if (protection == 'W')
5410: { // READONLY
5411: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5412: .objet)).socket, SHUT_WR) != 0)
5413: {
5414: liberation(s_etat_processus, s_objet_argument);
5415: liberation(s_etat_processus, s_objet_resultat);
5416:
5417: (*s_etat_processus).erreur_execution =
5418: d_ex_erreur_acces_fichier;
5419: return;
5420: }
5421: }
5422: else
5423: { // READWRITE
5424: }
5425: }
5426: }
5427: else
5428: { // Socket cliente
5429: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
5430: = 'N';
5431:
5432: /*
5433: * Dans le cas où la socket n'est pas connectée, on
5434: * ne peut utiliser ni "NAME", ni "HOST", ni "PORT",
5435: * et encore moins spécifier une adresse. En effet, la cible
5436: * est défini par la commande TARGET.
5437: */
5438:
5439: if ((type_socket != 'S') && (type_socket != 'Q'))
5440: {
5441: if ((presence_port == d_vrai) || (hote != NULL) ||
5442: (nom != NULL) || (type_adresse != ' '))
5443: {
5444: liberation(s_etat_processus, s_objet_argument);
5445: liberation(s_etat_processus, s_objet_resultat);
5446:
5447: (*s_etat_processus).erreur_execution =
5448: d_ex_erreur_parametre_fichier;
5449: return;
5450: }
5451: }
5452:
5453: if (nom != NULL)
5454: {
5455: /*
5456: * La socket est dans l'espace des noms.
5457: */
5458:
5459: if (((*((struct_socket *) (*s_objet_resultat).objet))
5460: .socket = socket(PF_UNIX, type,
5461: protocole_numerique)) == -1)
5462: {
5463: liberation(s_etat_processus, s_objet_argument);
5464: liberation(s_etat_processus, s_objet_resultat);
5465:
5466: (*s_etat_processus).erreur_execution =
5467: d_ex_erreur_acces_fichier;
5468: return;
5469: }
5470:
5471: (*((struct_socket *) (*s_objet_resultat).objet))
5472: .domaine = PF_UNIX;
5473:
5474: socket_unix.sun_family = AF_UNIX;
5475: strncpy(socket_unix.sun_path, (*((struct_socket *)
5476: (*s_objet_resultat).objet)).adresse, UNIX_PATH_MAX);
5477: socket_unix.sun_path[UNIX_PATH_MAX - 1] = d_code_fin_chaine;
5478:
5479: if ((type_socket == 'S') || (type_socket == 'Q'))
5480: {
5481: if (connect((*((struct_socket *) (*s_objet_resultat)
5482: .objet)).socket, (const struct sockaddr *)
5483: &socket_unix, sizeof(socket_unix)) != 0)
5484: {
5485: liberation(s_etat_processus, s_objet_argument);
5486: liberation(s_etat_processus, s_objet_resultat);
5487:
5488: (*s_etat_processus).erreur_execution =
5489: d_ex_erreur_acces_fichier;
5490: return;
5491: }
5492:
5493: (*((struct_socket *) (*s_objet_resultat).objet))
5494: .socket_connectee = d_vrai;
5495: (*((struct_socket *) (*s_objet_resultat).objet))
5496: .socket_en_ecoute = 'N';
5497: }
5498: }
5499: else
5500: {
5501: /*
5502: * La socket est une socket réseau. L'adresse
5503: * passée en argument est l'adresse sur laquelle
5504: * cette socket est à l'écoute.
5505: */
5506:
5507: if (hote != NULL)
5508: { // Hôte défini par un nom
5509: resolution = NULL;
5510:
5511: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
5512: {
5513: liberation(s_etat_processus, s_objet_argument);
5514: liberation(s_etat_processus, s_objet_resultat);
5515:
5516: if (resolution != NULL)
5517: {
5518: freeaddrinfo(resolution);
5519: }
5520:
5521: (*s_etat_processus).erreur_execution =
5522: d_ex_erreur_acces_fichier;
5523: return;
5524: }
5525:
5526: if (strcmp(protocole, "IPV4") == 0)
5527: { // Accès en IPv4
5528: resolution_courante = resolution;
5529:
5530: while(resolution_courante != NULL)
5531: {
5532: if ((*resolution_courante).ai_family ==
5533: AF_INET)
5534: {
5535: break;
5536: }
5537:
5538: resolution_courante = (*resolution_courante)
5539: .ai_next;
5540: }
5541:
5542: if (resolution_courante == NULL)
5543: {
5544: liberation(s_etat_processus, s_objet_argument);
5545: liberation(s_etat_processus, s_objet_resultat);
5546:
5547: freeaddrinfo(resolution);
5548:
5549: (*s_etat_processus).erreur_execution =
5550: d_ex_erreur_acces_fichier;
5551: return;
5552: }
5553:
5554: if (((*((struct_socket *)
5555: (*s_objet_resultat).objet))
5556: .socket = socket(PF_INET, type,
5557: protocole_numerique)) == -1)
5558: {
5559: liberation(s_etat_processus, s_objet_argument);
5560: liberation(s_etat_processus, s_objet_resultat);
5561:
5562: freeaddrinfo(resolution);
5563:
5564: (*s_etat_processus).erreur_execution =
5565: d_ex_erreur_acces_fichier;
5566: return;
5567: }
5568:
5569: (*((struct_socket *) (*s_objet_resultat).objet))
5570: .domaine = PF_INET;
5571:
5572: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
5573: socket_ipv4.sin_family = AF_INET;
5574: socket_ipv4.sin_port = htons((uint16_t) port);
5575: socket_ipv4.sin_addr.s_addr =
5576: (*((struct sockaddr_in *)
5577: (*resolution_courante).ai_addr))
5578: .sin_addr.s_addr;
5579:
5580: if ((type_socket == 'S') || (type_socket == 'Q'))
5581: {
5582: if (connect((*((struct_socket *)
5583: (*s_objet_resultat).objet)).socket,
5584: (const struct sockaddr *)
5585: &socket_ipv4, sizeof(socket_ipv4)) != 0)
5586: {
5587: liberation(s_etat_processus,
5588: s_objet_argument);
5589: liberation(s_etat_processus,
5590: s_objet_resultat);
5591:
5592: freeaddrinfo(resolution);
5593:
5594: (*s_etat_processus).erreur_execution =
5595: d_ex_erreur_acces_fichier;
5596: return;
5597: }
5598:
5599: (*((struct_socket *) (*s_objet_resultat).objet))
5600: .socket_connectee = d_vrai;
5601: (*((struct_socket *) (*s_objet_resultat).objet))
5602: .socket_en_ecoute = 'N';
5603: }
5604:
5605: free((*((struct_socket *) (*s_objet_resultat)
5606: .objet)).adresse);
5607:
5608: if (((*((struct_socket *) (*s_objet_resultat)
5609: .objet)).adresse = malloc(22 *
5610: sizeof(unsigned char))) == NULL)
5611: {
5612: (*s_etat_processus).erreur_systeme =
5613: d_es_allocation_memoire;
5614: return;
5615: }
5616:
5617: sprintf((*((struct_socket *) (*s_objet_resultat)
5618: .objet)).adresse, "%d.%d.%d.%d",
5619: (ntohl((*((struct sockaddr_in *)
5620: (*resolution_courante).ai_addr)).sin_addr
5621: .s_addr) >> 24) & 0xFF,
5622: (ntohl((*((struct sockaddr_in *)
5623: (*resolution_courante).ai_addr)).sin_addr
5624: .s_addr) >> 16) & 0xFF,
5625: (ntohl((*((struct sockaddr_in *)
5626: (*resolution_courante).ai_addr)).sin_addr
5627: .s_addr) >> 8) & 0xFF,
5628: ntohl((*((struct sockaddr_in *)
5629: (*resolution_courante).ai_addr)).sin_addr
5630: .s_addr) & 0xFF);
5631: }
5632: else
5633: { // Accès en IPv6
5634: # ifdef IPV6
5635: resolution_courante = resolution;
5636:
5637: while(resolution_courante != NULL)
5638: {
5639: if ((*resolution_courante).ai_family ==
5640: AF_INET6)
5641: {
5642: break;
5643: }
5644:
5645: resolution_courante = (*resolution_courante)
5646: .ai_next;
5647: }
5648:
5649: if (resolution_courante == NULL)
5650: {
5651: liberation(s_etat_processus, s_objet_argument);
5652: liberation(s_etat_processus, s_objet_resultat);
5653:
5654: freeaddrinfo(resolution);
5655:
5656: (*s_etat_processus).erreur_execution =
5657: d_ex_erreur_acces_fichier;
5658: return;
5659: }
5660:
5661: if (((*((struct_socket *)
5662: (*s_objet_resultat).objet))
5663: .socket = socket(PF_INET6, type,
5664: protocole_numerique)) == -1)
5665: {
5666: liberation(s_etat_processus, s_objet_argument);
5667: liberation(s_etat_processus, s_objet_resultat);
5668:
5669: freeaddrinfo(resolution);
5670:
5671: (*s_etat_processus).erreur_execution =
5672: d_ex_erreur_acces_fichier;
5673: return;
5674: }
5675:
5676: (*((struct_socket *) (*s_objet_resultat).objet))
5677: .domaine = PF_INET6;
5678:
5679: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5680: socket_ipv6.sin6_family = AF_INET6;
5681: socket_ipv6.sin6_port = htons((uint16_t) port);
5682:
5683: for(i = 0; i < 16;
5684: socket_ipv6.sin6_addr.s6_addr[i] =
5685: (*((struct sockaddr_in6 *)
5686: (*resolution_courante).ai_addr))
5687: .sin6_addr.s6_addr[i], i++);
5688:
5689: if ((type_socket == 'S') || (type_socket == 'Q'))
5690: {
5691: if (connect((*((struct_socket *)
5692: (*s_objet_resultat).objet)).socket,
5693: (const struct sockaddr *)
5694: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5695: {
5696: liberation(s_etat_processus,
5697: s_objet_argument);
5698: liberation(s_etat_processus,
5699: s_objet_resultat);
5700:
5701: freeaddrinfo(resolution);
5702:
5703: (*s_etat_processus).erreur_execution =
5704: d_ex_erreur_acces_fichier;
5705: return;
5706: }
5707:
5708: (*((struct_socket *) (*s_objet_resultat).objet))
5709: .socket_connectee = d_vrai;
5710: (*((struct_socket *) (*s_objet_resultat).objet))
5711: .socket_en_ecoute = 'N';
5712: }
5713:
5714: free((*((struct_socket *) (*s_objet_resultat)
5715: .objet)).adresse);
5716:
5717: if (((*((struct_socket *) (*s_objet_resultat)
5718: .objet)).adresse = malloc(55 *
5719: sizeof(unsigned char))) == NULL)
5720: {
5721: (*s_etat_processus).erreur_systeme =
5722: d_es_allocation_memoire;
5723: return;
5724: }
5725:
5726: for(i = 0; i < 16; i++)
5727: {
5728: sprintf((*((struct_socket *) (*s_objet_resultat)
5729: .objet)).adresse,
5730: (i == 0) ? "%s%X" : "%s:%X",
5731: (*((struct_socket *) (*s_objet_resultat)
5732: .objet)).adresse,
5733: (*((struct sockaddr_in6 *)
5734: (*resolution_courante).ai_addr))
5735: .sin6_addr.s6_addr[i]);
5736: }
5737: # else
5738: if ((*s_etat_processus).langue == 'F')
5739: {
5740: printf("+++Attention : Support du protocole"
5741: " IPv6 indisponible\n");
5742: }
5743: else
5744: {
5745: printf("+++Warning : IPv6 support "
5746: "unavailable\n");
5747: }
5748:
5749: liberation(s_etat_processus, s_objet_argument);
5750: liberation(s_etat_processus, s_objet_resultat);
5751:
5752: freeaddrinfo(resolution);
5753:
5754: (*s_etat_processus).erreur_execution =
5755: d_ex_instruction_indisponible;
5756: return;
5757: # endif
5758: }
5759:
5760: freeaddrinfo(resolution);
5761:
5762: sprintf((*((struct_socket *) (*s_objet_resultat)
5763: .objet)).adresse, "%s(%u)",
5764: (*((struct_socket *) (*s_objet_resultat)
5765: .objet)).adresse, (unsigned int) port);
5766: }
5767: else
5768: { // Hôte défini par une adresse
5769: if (strcmp(protocole, "IPV4") == 0)
5770: { // Accès en IPv4
5771: if (type_adresse == '4')
5772: {
5773: free((*((struct_socket *) (*s_objet_resultat)
5774: .objet)).adresse);
5775:
5776: if (((*((struct_socket *) (*s_objet_resultat)
5777: .objet)).adresse = malloc(22 *
5778: sizeof(unsigned char))) == NULL)
5779: {
5780: (*s_etat_processus).erreur_systeme =
5781: d_es_allocation_memoire;
5782: return;
5783: }
5784:
5785: (*((struct_socket *) (*s_objet_resultat).objet))
5786: .adresse[0] = d_code_fin_chaine;
5787:
5788: for(i = 0; i < 4; i++)
5789: {
5790: sprintf((*((struct_socket *)
5791: (*s_objet_resultat).objet)).adresse,
5792: (i == 0) ? "%s%d" : "%s.%d",
5793: (*((struct_socket *)
5794: (*s_objet_resultat)
5795: .objet)).adresse, (int) adresse[i]);
5796: }
5797:
5798: sprintf((*((struct_socket *) (*s_objet_resultat)
5799: .objet)).adresse, "%s(%u)",
5800: (*((struct_socket *) (*s_objet_resultat)
5801: .objet)).adresse, (unsigned int) port);
5802: }
5803: else
5804: {
5805: free((*((struct_socket *) (*s_objet_resultat)
5806: .objet)).adresse);
5807:
5808: if (((*((struct_socket *) (*s_objet_resultat)
5809: .objet)).adresse = malloc(
5810: sizeof(unsigned char))) == NULL)
5811: {
5812: (*s_etat_processus).erreur_systeme =
5813: d_es_allocation_memoire;
5814: return;
5815: }
5816:
5817: (*((struct_socket *) (*s_objet_resultat).objet))
5818: .adresse[0] = d_code_fin_chaine;
5819: }
5820:
5821: if (((*((struct_socket *)
5822: (*s_objet_resultat).objet))
5823: .socket = socket(PF_INET, type,
5824: protocole_numerique)) == -1)
5825: {
5826: liberation(s_etat_processus, s_objet_argument);
5827: liberation(s_etat_processus, s_objet_resultat);
5828:
5829: (*s_etat_processus).erreur_execution =
5830: d_ex_erreur_acces_fichier;
5831: return;
5832: }
5833:
5834: (*((struct_socket *) (*s_objet_resultat).objet))
5835: .domaine = PF_INET;
5836:
5837: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
5838: socket_ipv4.sin_family = AF_INET;
5839: socket_ipv4.sin_port = htons((uint16_t) port);
5840:
5841: adresse_ipv4 = 0;
5842: for(i = 0; i < 4; adresse_ipv4 =
5843: (256 * adresse_ipv4) + adresse[i++]);
5844:
5845: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
5846:
5847: if ((type_socket == 'S') || (type_socket == 'Q'))
5848: {
5849: if (connect((*((struct_socket *)
5850: (*s_objet_resultat).objet)).socket,
5851: (const struct sockaddr *)
5852: &socket_ipv4, sizeof(socket_ipv4)) != 0)
5853: {
5854: liberation(s_etat_processus,
5855: s_objet_argument);
5856: liberation(s_etat_processus,
5857: s_objet_resultat);
5858:
5859: (*s_etat_processus).erreur_execution =
5860: d_ex_erreur_acces_fichier;
5861: return;
5862: }
5863:
5864: (*((struct_socket *) (*s_objet_resultat).objet))
5865: .socket_connectee = d_vrai;
5866: (*((struct_socket *) (*s_objet_resultat).objet))
5867: .socket_en_ecoute = 'N';
5868: }
5869: }
5870: else if (strcmp(protocole, "IPV6") == 0)
5871: { // Accès en IPv6
5872: # ifdef IPV6
5873: if (type_adresse == '6')
5874: {
5875: free((*((struct_socket *) (*s_objet_resultat)
5876: .objet)).adresse);
5877:
5878: if (((*((struct_socket *) (*s_objet_resultat)
5879: .objet)).adresse = malloc(55 *
5880: sizeof(unsigned char))) == NULL)
5881: {
5882: (*s_etat_processus).erreur_systeme =
5883: d_es_allocation_memoire;
5884: return;
5885: }
5886:
5887: (*((struct_socket *) (*s_objet_resultat).objet))
5888: .adresse[0] = d_code_fin_chaine;
5889:
5890: for(i = 0; i < 16; i++)
5891: {
5892: sprintf((*((struct_socket *)
5893: (*s_objet_resultat).objet)).adresse,
5894: (i == 0) ? "%s%X" : "%s:%X",
5895: (*((struct_socket *)
5896: (*s_objet_resultat)
5897: .objet)).adresse, (unsigned int)
5898: adresse[i]);
5899: }
5900:
5901: sprintf((*((struct_socket *) (*s_objet_resultat)
5902: .objet)).adresse, "%s(%u)",
5903: (*((struct_socket *) (*s_objet_resultat)
5904: .objet)).adresse, (unsigned int) port);
5905: }
5906: else
5907: {
5908: free((*((struct_socket *) (*s_objet_resultat)
5909: .objet)).adresse);
5910:
5911: if (((*((struct_socket *) (*s_objet_resultat)
5912: .objet)).adresse = malloc(
5913: sizeof(unsigned char))) == NULL)
5914: {
5915: (*s_etat_processus).erreur_systeme =
5916: d_es_allocation_memoire;
5917: return;
5918: }
5919:
5920: (*((struct_socket *) (*s_objet_resultat).objet))
5921: .adresse[0] = d_code_fin_chaine;
5922: }
5923:
5924: if (((*((struct_socket *)
5925: (*s_objet_resultat).objet))
5926: .socket = socket(PF_INET6, type,
5927: protocole_numerique)) == -1)
5928: {
5929: liberation(s_etat_processus, s_objet_argument);
5930: liberation(s_etat_processus, s_objet_resultat);
5931:
5932: (*s_etat_processus).erreur_execution =
5933: d_ex_erreur_acces_fichier;
5934: return;
5935: }
5936:
5937: (*((struct_socket *) (*s_objet_resultat).objet))
5938: .domaine = PF_INET6;
5939:
5940: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5941: socket_ipv6.sin6_family = AF_INET6;
5942: socket_ipv6.sin6_port = htons((uint16_t) port);
5943:
5944: for(i = 0; i < 16;
5945: socket_ipv6.sin6_addr.s6_addr[i] =
5946: (unsigned char) (adresse[i]), i++);
5947:
5948: if ((type_socket == 'S') || (type_socket == 'Q'))
5949: {
5950: if (connect((*((struct_socket *)
5951: (*s_objet_resultat).objet)).socket,
5952: (const struct sockaddr *)
5953: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5954: {
5955: liberation(s_etat_processus,
5956: s_objet_argument);
5957: liberation(s_etat_processus,
5958: s_objet_resultat);
5959:
5960: (*s_etat_processus).erreur_execution =
5961: d_ex_erreur_acces_fichier;
5962: return;
5963: }
5964:
5965: (*((struct_socket *) (*s_objet_resultat).objet))
5966: .socket_connectee = d_vrai;
5967: (*((struct_socket *) (*s_objet_resultat).objet))
5968: .socket_en_ecoute = 'N';
5969: }
5970: # else
5971: if ((*s_etat_processus).langue == 'F')
5972: {
5973: printf("+++Attention : Support du protocole"
5974: " IPv6 indisponible\n");
5975: }
5976: else
5977: {
5978: printf("+++Warning : IPv6 support "
5979: "unavailable\n");
5980: }
5981:
5982: liberation(s_etat_processus, s_objet_argument);
5983: liberation(s_etat_processus, s_objet_resultat);
5984:
5985: (*s_etat_processus).erreur_execution =
5986: d_ex_instruction_indisponible;
5987: return;
5988: # endif
5989: }
5990: else
5991: { // Socket UNIX
5992: free((*((struct_socket *) (*s_objet_resultat)
5993: .objet)).adresse);
5994:
5995: if (((*((struct_socket *) (*s_objet_resultat)
5996: .objet)).adresse = malloc(
5997: sizeof(unsigned char))) == NULL)
5998: {
5999: (*s_etat_processus).erreur_systeme =
6000: d_es_allocation_memoire;
6001: return;
6002: }
6003:
6004: (*((struct_socket *) (*s_objet_resultat).objet))
6005: .adresse[0] = d_code_fin_chaine;
6006:
6007: if (((*((struct_socket *)
6008: (*s_objet_resultat).objet))
6009: .socket = socket(PF_UNIX, type,
6010: protocole_numerique)) == -1)
6011: {
6012: liberation(s_etat_processus, s_objet_argument);
6013: liberation(s_etat_processus, s_objet_resultat);
6014:
6015: (*s_etat_processus).erreur_execution =
6016: d_ex_erreur_acces_fichier;
6017: return;
6018: }
6019: }
6020: }
6021:
6022: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
6023: = 'N';
6024: }
6025:
6026: if ((type_socket == 'S') || (type_socket == 'Q'))
6027: {
6028: if (protection == 'R')
6029: { // WRITEONLY
6030: if (shutdown((*((struct_socket *) (*s_objet_resultat)
6031: .objet)).socket, SHUT_RD) != 0)
6032: {
6033: liberation(s_etat_processus, s_objet_argument);
6034: liberation(s_etat_processus, s_objet_resultat);
6035:
6036: (*s_etat_processus).erreur_execution =
6037: d_ex_erreur_acces_fichier;
6038: return;
6039: }
6040: }
6041: else if (protection == 'W')
6042: { // READONLY
6043: if (shutdown((*((struct_socket *) (*s_objet_resultat)
6044: .objet)).socket, SHUT_WR) != 0)
6045: {
6046: liberation(s_etat_processus, s_objet_argument);
6047: liberation(s_etat_processus, s_objet_resultat);
6048:
6049: (*s_etat_processus).erreur_execution =
6050: d_ex_erreur_acces_fichier;
6051: return;
6052: }
6053: }
6054: else
6055: { // READWRITE
6056: }
6057: }
6058: }
6059:
6060: /*
6061: * Gestion de la liste des sockets ouvertes
6062: */
6063:
6064: l_element_courant = (*s_etat_processus).s_sockets;
6065:
6066: if (l_element_courant == NULL)
6067: {
6068: if (((*s_etat_processus).s_sockets =
6069: allocation_maillon(s_etat_processus)) == NULL)
6070: {
6071: (*s_etat_processus).erreur_systeme =
6072: d_es_allocation_memoire;
6073: return;
6074: }
6075:
6076: (*(*s_etat_processus).s_sockets).suivant = NULL;
6077: l_element_courant = (*s_etat_processus).s_sockets;
6078: }
6079: else
6080: {
6081: /*
6082: * Ajout d'un élément à la fin de la liste chaînée
6083: */
6084:
6085: while((*l_element_courant).suivant != NULL)
6086: {
6087: l_element_courant = (*l_element_courant).suivant;
6088: }
6089:
6090: if (((*l_element_courant).suivant =
6091: allocation_maillon(s_etat_processus)) == NULL)
6092: {
6093: (*s_etat_processus).erreur_systeme =
6094: d_es_allocation_memoire;
6095: return;
6096: }
6097:
6098: l_element_courant = (*l_element_courant).suivant;
6099: (*l_element_courant).suivant = NULL;
6100: }
6101:
6102: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
6103: s_objet_resultat, 'O')) == NULL)
6104: {
6105: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
6106: return;
6107: }
6108:
6109: liberation(s_etat_processus, s_objet_argument);
6110: }
6111: else
6112: {
6113: liberation(s_etat_processus, s_objet_argument);
6114:
6115: (*s_etat_processus).erreur_execution =
6116: d_ex_erreur_parametre_fichier;
6117: return;
6118: }
6119: }
6120: else if ((*s_objet_argument).type == CHN)
6121: {
6122: if ((s_objet_resultat = allocation(s_etat_processus, SPH)) == NULL)
6123: {
6124: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
6125: return;
6126: }
6127:
6128: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).nom =
6129: malloc((strlen((unsigned char *) (*s_objet_argument).objet)
6130: + 1) *sizeof(unsigned char))) == NULL)
6131: {
6132: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
6133: return;
6134: }
6135:
6136: strcpy((*((struct_semaphore *) (*s_objet_resultat).objet)).nom,
6137: (unsigned char *) (*s_objet_argument).objet);
6138:
6139: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).semaphore =
6140: sem_open((*((struct_semaphore *) (*s_objet_resultat).objet))
6141: .nom, 0)) == SEM_FAILED)
6142: {
6143: if (errno == ENOMEM)
6144: {
6145: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
6146: return;
6147: }
6148:
6149: (*s_etat_processus).erreur_execution = d_ex_semaphore;
6150:
6151: liberation(s_etat_processus, s_objet_argument);
6152: liberation(s_etat_processus, s_objet_resultat);
6153: return;
6154: }
6155: }
6156: else
6157: {
6158: liberation(s_etat_processus, s_objet_argument);
6159:
6160: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
6161: return;
6162: }
6163:
6164: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
6165: s_objet_resultat) == d_erreur)
6166: {
6167: return;
6168: }
6169:
6170: return;
6171: }
6172:
6173: // 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