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