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