1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.36
4: Copyright (C) 1989-2025 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, %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, d_REC);
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, %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, d_REC);
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, %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, d_REC);
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, %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, d_REC);
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, RAW\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: else if (type_arguments == 'F')
2365: {
2366: liberation(s_etat_processus,
2367: s_objet_argument);
2368: free(argument_majuscule);
2369:
2370: (*s_etat_processus).erreur_execution =
2371: d_ex_erreur_parametre_fichier;
2372: return;
2373: }
2374:
2375: if (nombre_maximal_connexions != 0)
2376: {
2377: liberation(s_etat_processus,
2378: s_objet_argument);
2379:
2380: (*s_etat_processus).erreur_execution =
2381: d_ex_erreur_parametre_fichier;
2382: return;
2383: }
2384: else
2385: {
2386: if ((nombre_maximal_connexions =
2387: (*((integer8 *)
2388: (*(*l_element_courant_sous_objet)
2389: .donnee).objet))) <= 0)
2390: {
2391: liberation(s_etat_processus,
2392: s_objet_argument);
2393:
2394: (*s_etat_processus).erreur_execution =
2395: d_ex_erreur_parametre_fichier;
2396: return;
2397: }
2398: }
2399: }
2400: }
2401: else if (strcmp(argument_majuscule, "ADDRESS") == 0)
2402: {
2403: if ((*(*l_element_courant_sous_objet)
2404: .donnee).type == VIN)
2405: {
2406: if (type_arguments == ' ')
2407: {
2408: type_arguments = 'S';
2409: }
2410: else if (type_arguments == 'F')
2411: {
2412: liberation(s_etat_processus,
2413: s_objet_argument);
2414: free(argument_majuscule);
2415:
2416: (*s_etat_processus).erreur_execution =
2417: d_ex_erreur_parametre_fichier;
2418: return;
2419: }
2420:
2421: if (type_adresse != ' ')
2422: {
2423: liberation(s_etat_processus,
2424: s_objet_argument);
2425:
2426: (*s_etat_processus).erreur_execution =
2427: d_ex_erreur_parametre_fichier;
2428: return;
2429: }
2430:
2431: if ((*((struct_vecteur *)
2432: (*(*l_element_courant_sous_objet)
2433: .donnee).objet)).taille == 4)
2434: { // Adresse IPv4
2435: type_adresse = '4';
2436:
2437: for(i = 0; i < 4; i++)
2438: {
2439: adresse[i] = ((integer8 *)
2440: (*((struct_vecteur *) (*
2441: (*l_element_courant_sous_objet)
2442: .donnee).objet)).tableau)[i];
2443:
2444: if ((adresse[i] < 0) || (adresse[i] >
2445: 255))
2446: {
2447: liberation(s_etat_processus,
2448: s_objet_argument);
2449:
2450: (*s_etat_processus).erreur_execution
2451: = d_ex_erreur_parametre_fichier;
2452: return;
2453: }
2454: }
2455: }
2456: else if ((*((struct_vecteur *)
2457: (*(*l_element_courant_sous_objet)
2458: .donnee).objet)).taille == 16)
2459: { // Adresse IPv6
2460: type_adresse = '6';
2461:
2462: for(i = 0; i < 16; i++)
2463: {
2464: adresse[i] = ((integer8 *)
2465: (*((struct_vecteur *) (*
2466: (*l_element_courant_sous_objet)
2467: .donnee).objet)).tableau)[i];
2468:
2469: if ((adresse[i] < 0) || (adresse[i] >
2470: 255))
2471: {
2472: liberation(s_etat_processus,
2473: s_objet_argument);
2474:
2475: (*s_etat_processus).erreur_execution
2476: = d_ex_erreur_parametre_fichier;
2477: return;
2478: }
2479: }
2480: }
2481: else
2482: { // Adresse non supportée
2483: liberation(s_etat_processus,
2484: s_objet_argument);
2485:
2486: (*s_etat_processus).erreur_execution =
2487: d_ex_erreur_parametre_fichier;
2488: return;
2489: }
2490: }
2491: }
2492: else if (strcmp(argument_majuscule, "STTY") == 0)
2493: {
2494: if ((*(*l_element_courant_sous_objet)
2495: .donnee).type == CHN)
2496: {
2497: if (type_arguments == ' ')
2498: {
2499: type_arguments = 'F';
2500: }
2501: else if (type_arguments == 'S')
2502: {
2503: liberation(s_etat_processus,
2504: s_objet_argument);
2505: free(argument_majuscule);
2506:
2507: (*s_etat_processus).erreur_execution =
2508: d_ex_erreur_parametre_fichier;
2509: return;
2510: }
2511:
2512: s_parametres_tty = (*l_element_courant).donnee;
2513: }
2514: }
2515: else
2516: {
2517: liberation(s_etat_processus, s_objet_argument);
2518: free(argument_majuscule);
2519:
2520: (*s_etat_processus).erreur_execution =
2521: d_ex_erreur_parametre_fichier;
2522: return;
2523: }
2524:
2525: free(argument_majuscule);
2526: }
2527: else
2528: {
2529: liberation(s_etat_processus, s_objet_argument);
2530: (*s_etat_processus).erreur_execution =
2531: d_ex_erreur_parametre_fichier;
2532:
2533: return;
2534: }
2535: }
2536: else if (nombre_elements == 3)
2537: {
2538: if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
2539: {
2540: if ((argument_majuscule = conversion_majuscule(
2541: s_etat_processus, (unsigned char *)
2542: (*(*l_element_courant_sous_objet)
2543: .donnee).objet)) == NULL)
2544: {
2545: (*s_etat_processus).erreur_systeme =
2546: d_es_allocation_memoire;
2547: return;
2548: }
2549:
2550: if (strcmp(argument_majuscule, "OPTION") == 0)
2551: {
2552: if (type_arguments == ' ')
2553: {
2554: type_arguments = 'S';
2555: }
2556: else if (type_arguments == 'F')
2557: {
2558: liberation(s_etat_processus, s_objet_argument);
2559: free(argument_majuscule);
2560:
2561: (*s_etat_processus).erreur_execution =
2562: d_ex_erreur_parametre_fichier;
2563: return;
2564: }
2565:
2566: free(argument_majuscule);
2567:
2568: l_element_courant_sous_objet =
2569: (*l_element_courant_sous_objet).suivant;
2570:
2571: if ((*(*l_element_courant_sous_objet)
2572: .donnee).type != CHN)
2573: {
2574: liberation(s_etat_processus, s_objet_argument);
2575:
2576: (*s_etat_processus).erreur_execution =
2577: d_ex_erreur_parametre_fichier;
2578: return;
2579: }
2580:
2581: if ((argument_majuscule = conversion_majuscule(
2582: s_etat_processus, (unsigned char *)
2583: (*(*l_element_courant_sous_objet)
2584: .donnee).objet)) == NULL)
2585: {
2586: (*s_etat_processus).erreur_systeme =
2587: d_es_allocation_memoire;
2588: return;
2589: }
2590:
2591: l_element_courant_sous_objet =
2592: (*l_element_courant_sous_objet).suivant;
2593:
2594: if (strcmp(argument_majuscule, "BIND TO DEVICE")
2595: == 0)
2596: {
2597: if ((*(*l_element_courant_sous_objet)
2598: .donnee).type != CHN)
2599: {
2600: liberation(s_etat_processus,
2601: s_objet_argument);
2602: free(argument_majuscule);
2603:
2604: (*s_etat_processus).erreur_execution =
2605: d_ex_erreur_parametre_fichier;
2606: return;
2607: }
2608:
2609: if (options[d_BIND_TO_DEVICE] == 'Y')
2610: {
2611: liberation(s_etat_processus,
2612: s_objet_argument);
2613: free(argument_majuscule);
2614:
2615: (*s_etat_processus).erreur_execution =
2616: d_ex_erreur_parametre_fichier;
2617: return;
2618: }
2619:
2620: options[d_BIND_TO_DEVICE] = 'Y';
2621:
2622: peripherique = (unsigned char *)
2623: (*(*l_element_courant_sous_objet)
2624: .donnee).objet;
2625: }
2626: else if (strcmp(argument_majuscule, "PRIORITY")
2627: == 0)
2628: {
2629: if ((*(*l_element_courant_sous_objet)
2630: .donnee).type != INT)
2631: {
2632: liberation(s_etat_processus,
2633: s_objet_argument);
2634: free(argument_majuscule);
2635:
2636: (*s_etat_processus).erreur_execution =
2637: d_ex_erreur_parametre_fichier;
2638: return;
2639: }
2640:
2641: if (options[d_PRIORITY] == 'Y')
2642: {
2643: liberation(s_etat_processus,
2644: s_objet_argument);
2645: free(argument_majuscule);
2646:
2647: (*s_etat_processus).erreur_execution =
2648: d_ex_erreur_parametre_fichier;
2649: return;
2650: }
2651:
2652: options[d_PRIORITY] = 'Y';
2653:
2654: priorite = (int) (*((integer8 *)
2655: (*(*l_element_courant_sous_objet)
2656: .donnee).objet));
2657: }
2658: else if (strcmp(argument_majuscule,
2659: "RECEIVE BUFFER") == 0)
2660: {
2661: if ((*(*l_element_courant_sous_objet)
2662: .donnee).type != INT)
2663: {
2664: liberation(s_etat_processus,
2665: s_objet_argument);
2666: free(argument_majuscule);
2667:
2668: (*s_etat_processus).erreur_execution =
2669: d_ex_erreur_parametre_fichier;
2670: return;
2671: }
2672:
2673: if ((options[d_RECEIVE_BUFFER] == 'Y') ||
2674: (options[d_FORCE_RECEIVE_BUFFER]
2675: == 'Y'))
2676: {
2677: liberation(s_etat_processus,
2678: s_objet_argument);
2679: free(argument_majuscule);
2680:
2681: (*s_etat_processus).erreur_execution =
2682: d_ex_erreur_parametre_fichier;
2683: return;
2684: }
2685:
2686: options[d_RECEIVE_BUFFER] = 'Y';
2687:
2688: buffer_reception = (int) (*((integer8 *)
2689: (*(*l_element_courant_sous_objet)
2690: .donnee).objet));
2691: }
2692: else if (strcmp(argument_majuscule,
2693: "FORCE RECEIVE BUFFER") == 0)
2694: {
2695: if ((*(*l_element_courant_sous_objet)
2696: .donnee).type != INT)
2697: {
2698: liberation(s_etat_processus,
2699: s_objet_argument);
2700: free(argument_majuscule);
2701:
2702: (*s_etat_processus).erreur_execution =
2703: d_ex_erreur_parametre_fichier;
2704: return;
2705: }
2706:
2707: if ((options[d_RECEIVE_BUFFER] == 'Y') ||
2708: (options[d_FORCE_RECEIVE_BUFFER]
2709: == 'Y'))
2710: {
2711: liberation(s_etat_processus,
2712: s_objet_argument);
2713: free(argument_majuscule);
2714:
2715: (*s_etat_processus).erreur_execution =
2716: d_ex_erreur_parametre_fichier;
2717: return;
2718: }
2719:
2720: options[d_FORCE_RECEIVE_BUFFER] = 'Y';
2721:
2722: buffer_reception = (int) (*((integer8 *)
2723: (*(*l_element_courant_sous_objet)
2724: .donnee).objet));
2725: }
2726: else if (strcmp(argument_majuscule,
2727: "SEND BUFFER") == 0)
2728: {
2729: if ((*(*l_element_courant_sous_objet)
2730: .donnee).type != INT)
2731: {
2732: liberation(s_etat_processus,
2733: s_objet_argument);
2734: free(argument_majuscule);
2735:
2736: (*s_etat_processus).erreur_execution =
2737: d_ex_erreur_parametre_fichier;
2738: return;
2739: }
2740:
2741: if ((options[d_SEND_BUFFER] == 'Y') ||
2742: (options[d_FORCE_SEND_BUFFER] == 'Y'))
2743: {
2744: liberation(s_etat_processus,
2745: s_objet_argument);
2746: free(argument_majuscule);
2747:
2748: (*s_etat_processus).erreur_execution =
2749: d_ex_erreur_parametre_fichier;
2750: return;
2751: }
2752:
2753: options[d_SEND_BUFFER] = 'Y';
2754:
2755: buffer_emission = (int) (*((integer8 *)
2756: (*(*l_element_courant_sous_objet)
2757: .donnee).objet));
2758: }
2759: else if (strcmp(argument_majuscule,
2760: "FORCE SEND BUFFER") == 0)
2761: {
2762: if ((*(*l_element_courant_sous_objet)
2763: .donnee).type != INT)
2764: {
2765: liberation(s_etat_processus,
2766: s_objet_argument);
2767: free(argument_majuscule);
2768:
2769: (*s_etat_processus).erreur_execution =
2770: d_ex_erreur_parametre_fichier;
2771: return;
2772: }
2773:
2774: if ((options[d_SEND_BUFFER] == 'Y') ||
2775: (options[d_FORCE_SEND_BUFFER] == 'Y'))
2776: {
2777: liberation(s_etat_processus,
2778: s_objet_argument);
2779: free(argument_majuscule);
2780:
2781: (*s_etat_processus).erreur_execution =
2782: d_ex_erreur_parametre_fichier;
2783: return;
2784: }
2785:
2786: options[d_FORCE_SEND_BUFFER] = 'Y';
2787:
2788: buffer_emission = (int) (*((integer8 *)
2789: (*(*l_element_courant_sous_objet)
2790: .donnee).objet));
2791: }
2792: else if (strcmp(argument_majuscule,
2793: "RECEIVING TIMEOUT") == 0)
2794: {
2795: if ((*(*l_element_courant_sous_objet)
2796: .donnee).type != INT)
2797: {
2798: liberation(s_etat_processus,
2799: s_objet_argument);
2800: free(argument_majuscule);
2801:
2802: (*s_etat_processus).erreur_execution =
2803: d_ex_erreur_parametre_fichier;
2804: return;
2805: }
2806:
2807: if (options[d_RECEIVING_TIMEOUT] == 'Y')
2808: {
2809: liberation(s_etat_processus,
2810: s_objet_argument);
2811: free(argument_majuscule);
2812:
2813: (*s_etat_processus).erreur_execution =
2814: d_ex_erreur_parametre_fichier;
2815: return;
2816: }
2817:
2818: options[d_RECEIVING_TIMEOUT] = 'Y';
2819:
2820: timeout_reception = (int) (*((integer8 *)
2821: (*(*l_element_courant_sous_objet)
2822: .donnee).objet));
2823: }
2824: else if (strcmp(argument_majuscule,
2825: "SENDING TIMEOUT") == 0)
2826: {
2827: if ((*(*l_element_courant_sous_objet)
2828: .donnee).type != INT)
2829: {
2830: liberation(s_etat_processus,
2831: s_objet_argument);
2832: free(argument_majuscule);
2833:
2834: (*s_etat_processus).erreur_execution =
2835: d_ex_erreur_parametre_fichier;
2836: return;
2837: }
2838:
2839: if (options[d_SENDING_TIMEOUT] == 'Y')
2840: {
2841: liberation(s_etat_processus,
2842: s_objet_argument);
2843: free(argument_majuscule);
2844:
2845: (*s_etat_processus).erreur_execution =
2846: d_ex_erreur_parametre_fichier;
2847: return;
2848: }
2849:
2850: options[d_SENDING_TIMEOUT] = 'Y';
2851:
2852: timeout_emission = (int) (*((integer8 *)
2853: (*(*l_element_courant_sous_objet)
2854: .donnee).objet));
2855: }
2856: else
2857: {
2858: liberation(s_etat_processus, s_objet_argument);
2859: free(argument_majuscule);
2860:
2861: (*s_etat_processus).erreur_execution =
2862: d_ex_erreur_parametre_fichier;
2863: return;
2864: }
2865:
2866: free(argument_majuscule);
2867: }
2868: else if (strcmp(argument_majuscule, "STTY") == 0)
2869: {
2870: if (type_arguments == ' ')
2871: {
2872: type_arguments = 'F';
2873: }
2874: else if (type_arguments == 'S')
2875: {
2876: liberation(s_etat_processus, s_objet_argument);
2877: free(argument_majuscule);
2878:
2879: (*s_etat_processus).erreur_execution =
2880: d_ex_erreur_parametre_fichier;
2881: return;
2882: }
2883:
2884: free(argument_majuscule);
2885:
2886: l_element_courant_sous_objet =
2887: (*l_element_courant_sous_objet).suivant;
2888:
2889: if ((*(*l_element_courant_sous_objet)
2890: .donnee).type != CHN)
2891: {
2892: liberation(s_etat_processus, s_objet_argument);
2893:
2894: (*s_etat_processus).erreur_execution =
2895: d_ex_erreur_parametre_fichier;
2896: return;
2897: }
2898:
2899: l_element_courant_sous_objet =
2900: (*l_element_courant_sous_objet).suivant;
2901:
2902: if ((*(*l_element_courant_sous_objet)
2903: .donnee).type != LST)
2904: {
2905: liberation(s_etat_processus, s_objet_argument);
2906:
2907: (*s_etat_processus).erreur_execution =
2908: d_ex_erreur_parametre_fichier;
2909: return;
2910: }
2911:
2912: s_parametres_tty = (*l_element_courant).donnee;
2913: }
2914: else
2915: {
2916: liberation(s_etat_processus, s_objet_argument);
2917: free(argument_majuscule);
2918:
2919: (*s_etat_processus).erreur_execution =
2920: d_ex_erreur_parametre_fichier;
2921: return;
2922: }
2923: }
2924: else
2925: {
2926: liberation(s_etat_processus, s_objet_argument);
2927: (*s_etat_processus).erreur_execution =
2928: d_ex_erreur_parametre_fichier;
2929:
2930: return;
2931: }
2932: }
2933: else
2934: {
2935: liberation(s_etat_processus, s_objet_argument);
2936: (*s_etat_processus).erreur_execution =
2937: d_ex_erreur_parametre_fichier;
2938:
2939: return;
2940: }
2941: }
2942: else
2943: {
2944: liberation(s_etat_processus, s_objet_argument);
2945:
2946: (*s_etat_processus).erreur_execution =
2947: d_ex_erreur_parametre_fichier;
2948: return;
2949: }
2950:
2951: l_element_courant = (*l_element_courant).suivant;
2952: }
2953:
2954: // Si aucun paramètre n'est discriminant, l'instruction ouvre
2955: // par défaut un fichier.
2956:
2957: if (type_arguments == ' ')
2958: {
2959: type_arguments = 'F';
2960: }
2961:
2962: if (type_arguments == 'F')
2963: {
2964: /*
2965: * Traitement des fichiers
2966: */
2967:
2968: /*
2969: * Vérification de la cohérence et comportement par défaut
2970: */
2971:
2972: if (type_ouverture == ' ')
2973: {
2974: type_ouverture = 'U';
2975: }
2976:
2977: if (type_acces == ' ')
2978: {
2979: type_acces = 'S';
2980: }
2981:
2982: if (format == ' ')
2983: {
2984: format = 'N';
2985: }
2986:
2987: if (protection == ' ')
2988: {
2989: protection = 'N';
2990: }
2991:
2992: if ((type_ouverture == 'S') && (protection != 'N'))
2993: {
2994: liberation(s_etat_processus, s_objet_argument);
2995:
2996: (*s_etat_processus).erreur_execution =
2997: d_ex_erreur_parametre_fichier;
2998: return;
2999: }
3000:
3001: if ((type_ouverture != 'S') && (nom == NULL))
3002: {
3003: liberation(s_etat_processus, s_objet_argument);
3004:
3005: (*s_etat_processus).erreur_execution =
3006: d_ex_erreur_parametre_fichier;
3007: return;
3008: }
3009:
3010: if (((type_acces != 'I') && (position_clef != 0)) ||
3011: ((type_acces == 'I') && (position_clef == 0) &&
3012: ((type_ouverture == 'N') || (type_ouverture == 'R') ||
3013: (type_ouverture == 'S'))))
3014: {
3015: liberation(s_etat_processus, s_objet_argument);
3016:
3017: (*s_etat_processus).erreur_execution =
3018: d_ex_erreur_parametre_fichier;
3019: return;
3020: }
3021:
3022: if ((s_objet_resultat = allocation(s_etat_processus, FCH))
3023: == NULL)
3024: {
3025: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3026: return;
3027: }
3028:
3029: if (nom == NULL)
3030: {
3031: if ((nom_temporaire = creation_nom_fichier(s_etat_processus,
3032: (*s_etat_processus).chemin_fichiers_temporaires))
3033: == NULL)
3034: {
3035: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
3036: return;
3037: }
3038:
3039: if ((nom = malloc((strlen(nom_temporaire)
3040: + 5) * sizeof(unsigned char))) == NULL)
3041: {
3042: (*s_etat_processus).erreur_systeme =
3043: d_es_allocation_memoire;
3044: return;
3045: }
3046:
3047: sprintf(nom, "%s.rpl", nom_temporaire);
3048: free(nom_temporaire);
3049: }
3050: else
3051: {
3052: if ((nom = transliteration(s_etat_processus, nom,
3053: d_locale, "UTF-8")) == NULL)
3054: {
3055: liberation(s_etat_processus, s_objet_argument);
3056: liberation(s_etat_processus, s_objet_resultat);
3057: return;
3058: }
3059: }
3060:
3061: /*
3062: * Ouverture du fichier
3063: */
3064:
3065: (*((struct_fichier *) (*s_objet_resultat).objet))
3066: .nom = NULL;
3067: (*((struct_fichier *) (*s_objet_resultat).objet))
3068: .acces = type_acces;
3069: (*((struct_fichier *) (*s_objet_resultat).objet))
3070: .binaire = format;
3071: (*((struct_fichier *) (*s_objet_resultat).objet))
3072: .ouverture = type_ouverture;
3073: (*((struct_fichier *) (*s_objet_resultat).objet)).pid
3074: = getpid();
3075: (*((struct_fichier *) (*s_objet_resultat).objet)).tid
3076: = pthread_self();
3077:
3078: if (((*((struct_fichier *) (*s_objet_resultat).objet)).format =
3079: allocation(s_etat_processus, LST)) == NULL)
3080: {
3081: free(nom);
3082:
3083: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3084: return;
3085: }
3086:
3087: (*(*((struct_fichier *) (*s_objet_resultat).objet))
3088: .format).objet = NULL;
3089:
3090: descripteur = NULL;
3091:
3092: switch(type_ouverture)
3093: {
3094: case 'N' :
3095: {
3096: erreur = caracteristiques_fichier(s_etat_processus,
3097: nom, &existence, &ouverture, &unite);
3098:
3099: if ((erreur != 0) || (unite != 0))
3100: {
3101: free(nom);
3102:
3103: liberation(s_etat_processus, s_objet_argument);
3104: liberation(s_etat_processus, s_objet_resultat);
3105:
3106: (*s_etat_processus).erreur_execution =
3107: d_ex_erreur_acces_fichier;
3108: return;
3109: }
3110:
3111: if (type_acces == 'S')
3112: {
3113: if ((descripteur = fopen(nom, "w+")) == NULL)
3114: {
3115: free(nom);
3116:
3117: liberation(s_etat_processus, s_objet_argument);
3118: liberation(s_etat_processus, s_objet_resultat);
3119:
3120: (*s_etat_processus).erreur_execution =
3121: d_ex_erreur_acces_fichier;
3122: return;
3123: }
3124: }
3125: else
3126: {
3127: // Si le fichier existe, on le supprime.
3128:
3129: if (unlink(nom) != 0)
3130: {
3131: free(nom);
3132:
3133: liberation(s_etat_processus, s_objet_argument);
3134: liberation(s_etat_processus, s_objet_resultat);
3135:
3136: (*s_etat_processus).erreur_execution =
3137: d_ex_erreur_acces_fichier;
3138: return;
3139: }
3140:
3141: sqlite = NULL;
3142:
3143: if (sqlite3_open_v2(nom, &sqlite,
3144: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3145: NULL) != SQLITE_OK)
3146: {
3147: if (sqlite != NULL)
3148: {
3149: sqlite3_close(sqlite);
3150: }
3151:
3152: free(nom);
3153:
3154: liberation(s_etat_processus, s_objet_argument);
3155: liberation(s_etat_processus, s_objet_resultat);
3156:
3157: (*s_etat_processus).erreur_execution =
3158: d_ex_erreur_acces_fichier;
3159: return;
3160: }
3161:
3162: if ((descripteur = fopen(nom, "a+")) == NULL)
3163: {
3164: free(nom);
3165:
3166: liberation(s_etat_processus, s_objet_argument);
3167: liberation(s_etat_processus, s_objet_resultat);
3168:
3169: (*s_etat_processus).erreur_execution =
3170: d_ex_erreur_acces_fichier;
3171: return;
3172: }
3173:
3174: if (type_acces == 'D')
3175: {
3176: if (initialisation_fichier_acces_direct(
3177: s_etat_processus, sqlite,
3178: (format == 'N') ? d_faux : d_vrai)
3179: != d_absence_erreur)
3180: {
3181: free(nom);
3182:
3183: liberation(s_etat_processus, s_objet_argument);
3184: liberation(s_etat_processus, s_objet_resultat);
3185:
3186: return;
3187: }
3188: }
3189: else
3190: {
3191: if (position_clef == 0)
3192: {
3193: free(nom);
3194:
3195: liberation(s_etat_processus, s_objet_argument);
3196: liberation(s_etat_processus, s_objet_resultat);
3197:
3198: (*s_etat_processus).erreur_execution =
3199: d_ex_erreur_parametre_fichier;
3200: return;
3201: }
3202:
3203: if (initialisation_fichier_acces_indexe(
3204: s_etat_processus, sqlite, position_clef,
3205: (format == 'N') ? d_faux : d_vrai)
3206: != d_absence_erreur)
3207: {
3208: free(nom);
3209:
3210: liberation(s_etat_processus, s_objet_argument);
3211: liberation(s_etat_processus, s_objet_resultat);
3212:
3213: return;
3214: }
3215: }
3216: }
3217:
3218: break;
3219: }
3220:
3221: case 'O' :
3222: {
3223: erreur = caracteristiques_fichier(s_etat_processus, nom,
3224: &existence, &ouverture, &unite);
3225:
3226: if ((erreur != d_absence_erreur) || (existence == d_faux))
3227: {
3228: free(nom);
3229:
3230: liberation(s_etat_processus, s_objet_argument);
3231: liberation(s_etat_processus, s_objet_resultat);
3232:
3233: (*s_etat_processus).erreur_execution =
3234: d_ex_erreur_acces_fichier;
3235: return;
3236: }
3237:
3238: if (type_acces == 'S')
3239: {
3240: if ((descripteur = fopen(nom, "r+")) == NULL)
3241: {
3242: free(nom);
3243:
3244: liberation(s_etat_processus, s_objet_argument);
3245: liberation(s_etat_processus, s_objet_resultat);
3246:
3247: (*s_etat_processus).erreur_execution =
3248: d_ex_erreur_acces_fichier;
3249: return;
3250: }
3251: }
3252: else
3253: {
3254: sqlite = NULL;
3255:
3256: if (sqlite3_open_v2(nom, &sqlite,
3257: SQLITE_OPEN_READWRITE,
3258: NULL) != SQLITE_OK)
3259: {
3260: if (sqlite != NULL)
3261: {
3262: sqlite3_close(sqlite);
3263: }
3264:
3265: free(nom);
3266:
3267: liberation(s_etat_processus, s_objet_argument);
3268: liberation(s_etat_processus, s_objet_resultat);
3269:
3270: (*s_etat_processus).erreur_execution =
3271: d_ex_erreur_acces_fichier;
3272: return;
3273: }
3274:
3275: if ((descripteur = fopen(nom, "a+")) == NULL)
3276: {
3277: free(nom);
3278:
3279: liberation(s_etat_processus, s_objet_argument);
3280: liberation(s_etat_processus, s_objet_resultat);
3281:
3282: (*s_etat_processus).erreur_execution =
3283: d_ex_erreur_acces_fichier;
3284: return;
3285: }
3286: }
3287:
3288: break;
3289: }
3290:
3291: case 'R' :
3292: {
3293: erreur = caracteristiques_fichier(s_etat_processus,
3294: nom, &existence, &ouverture, &unite);
3295:
3296: if ((erreur != d_absence_erreur) || (existence == d_faux))
3297: {
3298: free(nom);
3299:
3300: liberation(s_etat_processus, s_objet_argument);
3301: liberation(s_etat_processus, s_objet_resultat);
3302:
3303: (*s_etat_processus).erreur_execution =
3304: d_ex_erreur_acces_fichier;
3305: return;
3306: }
3307:
3308: /* Test du verrou */
3309:
3310: if ((descripteur = fopen(nom, "r")) == NULL)
3311: {
3312: free(nom);
3313:
3314: liberation(s_etat_processus, s_objet_argument);
3315: liberation(s_etat_processus, s_objet_resultat);
3316:
3317: (*s_etat_processus).erreur_execution =
3318: d_ex_erreur_acces_fichier;
3319: return;
3320: }
3321:
3322: lock.l_type = F_WRLCK;
3323: lock.l_whence = SEEK_SET;
3324: lock.l_start = 0;
3325: lock.l_len = 0;
3326: lock.l_pid = getpid();
3327:
3328: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
3329: {
3330: free(nom);
3331:
3332: if (fclose(descripteur) != 0)
3333: {
3334: liberation(s_etat_processus, s_objet_argument);
3335: liberation(s_etat_processus, s_objet_resultat);
3336:
3337: (*s_etat_processus).erreur_systeme =
3338: d_es_erreur_fichier;
3339: return;
3340: }
3341:
3342: liberation(s_etat_processus, s_objet_argument);
3343: liberation(s_etat_processus, s_objet_resultat);
3344:
3345: (*s_etat_processus).erreur_systeme =
3346: d_es_erreur_fichier;
3347: return;
3348: }
3349:
3350: if (lock.l_type != F_UNLCK)
3351: {
3352: free(nom);
3353:
3354: if (fclose(descripteur) != 0)
3355: {
3356: liberation(s_etat_processus, s_objet_argument);
3357: liberation(s_etat_processus, s_objet_resultat);
3358:
3359: (*s_etat_processus).erreur_systeme =
3360: d_es_erreur_fichier;
3361: return;
3362: }
3363:
3364: liberation(s_etat_processus, s_objet_argument);
3365: liberation(s_etat_processus, s_objet_resultat);
3366:
3367: (*s_etat_processus).erreur_execution =
3368: d_ex_fichier_verrouille;
3369: return;
3370: }
3371:
3372: if (fclose(descripteur) != 0)
3373: {
3374: free(nom);
3375:
3376: liberation(s_etat_processus, s_objet_argument);
3377: liberation(s_etat_processus, s_objet_resultat);
3378:
3379: (*s_etat_processus).erreur_systeme =
3380: d_es_erreur_fichier;
3381: return;
3382: }
3383:
3384: if (type_acces == 'S')
3385: {
3386: if ((descripteur = fopen(nom, "w+")) == NULL)
3387: {
3388: free(nom);
3389:
3390: liberation(s_etat_processus, s_objet_argument);
3391: liberation(s_etat_processus, s_objet_resultat);
3392:
3393: (*s_etat_processus).erreur_execution =
3394: d_ex_erreur_acces_fichier;
3395: return;
3396: }
3397: }
3398: else
3399: {
3400: sqlite = NULL;
3401:
3402: if (sqlite3_open_v2(nom, &sqlite,
3403: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3404: NULL) != SQLITE_OK)
3405: {
3406: if (sqlite != NULL)
3407: {
3408: sqlite3_close(sqlite);
3409: }
3410:
3411: free(nom);
3412:
3413: liberation(s_etat_processus, s_objet_argument);
3414: liberation(s_etat_processus, s_objet_resultat);
3415:
3416: (*s_etat_processus).erreur_execution =
3417: d_ex_erreur_acces_fichier;
3418: return;
3419: }
3420:
3421: // Ouverture du fichier pour pouvoir gérer les
3422: // verrous à la façon des fichiers séquentiels.
3423:
3424: if ((descripteur = fopen(nom, "a+")) == NULL)
3425: {
3426: free(nom);
3427:
3428: liberation(s_etat_processus, s_objet_argument);
3429: liberation(s_etat_processus, s_objet_resultat);
3430:
3431: (*s_etat_processus).erreur_execution =
3432: d_ex_erreur_acces_fichier;
3433: return;
3434: }
3435:
3436: if (type_acces == 'D')
3437: {
3438: if (initialisation_fichier_acces_direct(
3439: s_etat_processus, sqlite,
3440: (format == 'N') ? d_faux : d_vrai)
3441: != d_absence_erreur)
3442: {
3443: free(nom);
3444:
3445: liberation(s_etat_processus, s_objet_argument);
3446: liberation(s_etat_processus, s_objet_resultat);
3447:
3448: return;
3449: }
3450: }
3451: else
3452: {
3453: if (position_clef == 0)
3454: {
3455: free(nom);
3456:
3457: liberation(s_etat_processus, s_objet_argument);
3458: liberation(s_etat_processus, s_objet_resultat);
3459:
3460: (*s_etat_processus).erreur_execution =
3461: d_ex_erreur_parametre_fichier;
3462: return;
3463: }
3464:
3465: if (initialisation_fichier_acces_indexe(
3466: s_etat_processus, sqlite, position_clef,
3467: (format == 'N') ? d_faux : d_vrai)
3468: != d_absence_erreur)
3469: {
3470: free(nom);
3471:
3472: liberation(s_etat_processus, s_objet_argument);
3473: liberation(s_etat_processus, s_objet_resultat);
3474:
3475: return;
3476: }
3477: }
3478: }
3479:
3480: break;
3481: }
3482:
3483: case 'U' :
3484: {
3485: erreur = caracteristiques_fichier(s_etat_processus,
3486: nom, &existence, &ouverture, &unite);
3487:
3488: if (erreur == d_erreur)
3489: {
3490: free(nom);
3491:
3492: liberation(s_etat_processus, s_objet_argument);
3493: liberation(s_etat_processus, s_objet_resultat);
3494:
3495: (*s_etat_processus).erreur_execution =
3496: d_ex_erreur_acces_fichier;
3497: return;
3498: }
3499:
3500: if (existence == d_faux)
3501: {
3502: if (type_acces == 'S')
3503: {
3504: if ((descripteur = fopen(nom, "w+")) == NULL)
3505: {
3506: free(nom);
3507:
3508: liberation(s_etat_processus, s_objet_argument);
3509: liberation(s_etat_processus, s_objet_resultat);
3510:
3511: (*s_etat_processus).erreur_execution =
3512: d_ex_erreur_acces_fichier;
3513: return;
3514: }
3515: }
3516: else
3517: {
3518: sqlite = NULL;
3519:
3520: if (sqlite3_open_v2(nom, &sqlite,
3521: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3522: NULL) != SQLITE_OK)
3523: {
3524: if (sqlite != NULL)
3525: {
3526: sqlite3_close(sqlite);
3527: }
3528:
3529: free(nom);
3530:
3531: liberation(s_etat_processus, s_objet_argument);
3532: liberation(s_etat_processus, s_objet_resultat);
3533:
3534: (*s_etat_processus).erreur_execution =
3535: d_ex_erreur_acces_fichier;
3536: return;
3537: }
3538:
3539: if ((descripteur = fopen(nom, "a+")) == NULL)
3540: {
3541: free(nom);
3542:
3543: liberation(s_etat_processus, s_objet_argument);
3544: liberation(s_etat_processus, s_objet_resultat);
3545:
3546: (*s_etat_processus).erreur_execution =
3547: d_ex_erreur_acces_fichier;
3548: return;
3549: }
3550:
3551: if (type_acces == 'D')
3552: {
3553: if (initialisation_fichier_acces_direct(
3554: s_etat_processus, sqlite,
3555: (format == 'N') ? d_faux : d_vrai)
3556: != d_absence_erreur)
3557: {
3558: free(nom);
3559:
3560: liberation(s_etat_processus,
3561: s_objet_argument);
3562: liberation(s_etat_processus,
3563: s_objet_resultat);
3564:
3565: return;
3566: }
3567: }
3568: else
3569: {
3570: if (position_clef == 0)
3571: {
3572: free(nom);
3573:
3574: liberation(s_etat_processus,
3575: s_objet_argument);
3576: liberation(s_etat_processus,
3577: s_objet_resultat);
3578:
3579: (*s_etat_processus).erreur_execution =
3580: d_ex_erreur_parametre_fichier;
3581: return;
3582: }
3583:
3584: if (initialisation_fichier_acces_indexe(
3585: s_etat_processus, sqlite, position_clef,
3586: (format == 'N') ? d_faux : d_vrai)
3587: != d_absence_erreur)
3588: {
3589: free(nom);
3590:
3591: liberation(s_etat_processus,
3592: s_objet_argument);
3593: liberation(s_etat_processus,
3594: s_objet_resultat);
3595:
3596: return;
3597: }
3598: }
3599: }
3600: }
3601: else
3602: {
3603: if (type_acces == 'S')
3604: {
3605: if ((descripteur = fopen(nom, "r+")) == NULL)
3606: {
3607: free(nom);
3608:
3609: liberation(s_etat_processus, s_objet_argument);
3610: liberation(s_etat_processus, s_objet_resultat);
3611:
3612: (*s_etat_processus).erreur_execution =
3613: d_ex_erreur_acces_fichier;
3614: return;
3615: }
3616: }
3617: else
3618: {
3619: sqlite = NULL;
3620:
3621: if (sqlite3_open_v2(nom, &sqlite,
3622: SQLITE_OPEN_READWRITE,
3623: NULL) != SQLITE_OK)
3624: {
3625: if (sqlite != NULL)
3626: {
3627: sqlite3_close(sqlite);
3628: }
3629:
3630: free(nom);
3631:
3632: liberation(s_etat_processus, s_objet_argument);
3633: liberation(s_etat_processus, s_objet_resultat);
3634:
3635: (*s_etat_processus).erreur_execution =
3636: d_ex_erreur_acces_fichier;
3637: return;
3638: }
3639:
3640: if ((descripteur = fopen(nom, "a+")) == NULL)
3641: {
3642: free(nom);
3643:
3644: liberation(s_etat_processus, s_objet_argument);
3645: liberation(s_etat_processus, s_objet_resultat);
3646:
3647: (*s_etat_processus).erreur_execution =
3648: d_ex_erreur_acces_fichier;
3649: return;
3650: }
3651: }
3652: }
3653:
3654: break;
3655: }
3656:
3657: case 'S' :
3658: {
3659: erreur = caracteristiques_fichier(s_etat_processus,
3660: nom, &existence, &ouverture, &unite);
3661:
3662: if ((erreur != d_absence_erreur) || (existence != d_faux))
3663: {
3664: free(nom);
3665:
3666: liberation(s_etat_processus, s_objet_argument);
3667: liberation(s_etat_processus, s_objet_resultat);
3668:
3669: (*s_etat_processus).erreur_execution =
3670: d_ex_erreur_acces_fichier;
3671: return;
3672: }
3673:
3674: if (type_acces == 'S')
3675: {
3676: if ((descripteur = fopen(nom, "w+")) == NULL)
3677: {
3678: free(nom);
3679:
3680: liberation(s_etat_processus, s_objet_argument);
3681: liberation(s_etat_processus, s_objet_resultat);
3682:
3683: (*s_etat_processus).erreur_execution =
3684: d_ex_erreur_acces_fichier;
3685: return;
3686: }
3687: }
3688: else
3689: {
3690: // Si le fichier existe, on le supprime.
3691:
3692: if (unlink(nom) != 0)
3693: {
3694: free(nom);
3695:
3696: liberation(s_etat_processus, s_objet_argument);
3697: liberation(s_etat_processus, s_objet_resultat);
3698:
3699: (*s_etat_processus).erreur_execution =
3700: d_ex_erreur_acces_fichier;
3701: return;
3702: }
3703:
3704: sqlite = NULL;
3705:
3706: if (sqlite3_open_v2(nom, &sqlite,
3707: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3708: NULL) != SQLITE_OK)
3709: {
3710: if (sqlite != NULL)
3711: {
3712: sqlite3_close(sqlite);
3713: }
3714:
3715: free(nom);
3716:
3717: liberation(s_etat_processus, s_objet_argument);
3718: liberation(s_etat_processus, s_objet_resultat);
3719:
3720: (*s_etat_processus).erreur_execution =
3721: d_ex_erreur_acces_fichier;
3722: return;
3723: }
3724:
3725: if ((descripteur = fopen(nom, "a+")) == NULL)
3726: {
3727: free(nom);
3728:
3729: liberation(s_etat_processus, s_objet_argument);
3730: liberation(s_etat_processus, s_objet_resultat);
3731:
3732: (*s_etat_processus).erreur_execution =
3733: d_ex_erreur_acces_fichier;
3734: return;
3735: }
3736:
3737: if (type_acces == 'D')
3738: {
3739: if (initialisation_fichier_acces_direct(
3740: s_etat_processus, sqlite,
3741: (format == 'N') ? d_faux : d_vrai)
3742: != d_absence_erreur)
3743: {
3744: free(nom);
3745:
3746: liberation(s_etat_processus, s_objet_argument);
3747: liberation(s_etat_processus, s_objet_resultat);
3748:
3749: return;
3750: }
3751: }
3752: else
3753: {
3754: if (position_clef == 0)
3755: {
3756: free(nom);
3757:
3758: liberation(s_etat_processus, s_objet_argument);
3759: liberation(s_etat_processus, s_objet_resultat);
3760:
3761: (*s_etat_processus).erreur_execution =
3762: d_ex_erreur_parametre_fichier;
3763: return;
3764: }
3765:
3766: if (initialisation_fichier_acces_indexe(
3767: s_etat_processus, sqlite, position_clef,
3768: (format == 'N') ? d_faux : d_vrai)
3769: != d_absence_erreur)
3770: {
3771: free(nom);
3772:
3773: liberation(s_etat_processus, s_objet_argument);
3774: liberation(s_etat_processus, s_objet_resultat);
3775:
3776: return;
3777: }
3778: }
3779: }
3780:
3781: break;
3782: }
3783:
3784: default:
3785: {
3786: BUG(1, printf("type_ouverture=%c\n", type_ouverture));
3787: return;
3788: }
3789: }
3790:
3791: if (((*((struct_fichier *) (*s_objet_resultat).objet)).nom =
3792: malloc((strlen(nom) + 1) *
3793: sizeof(unsigned char))) == NULL)
3794: {
3795: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3796: return;
3797: }
3798:
3799: if (s_parametres_tty != NULL)
3800: {
3801: // Affectation des paramètres du port série.
3802:
3803: if (tcgetattr(fileno(descripteur), &tc) != 0)
3804: {
3805: liberation(s_etat_processus, s_objet_argument);
3806: liberation(s_etat_processus, s_objet_resultat);
3807:
3808: (*s_etat_processus).erreur_systeme =
3809: d_ex_erreur_fichier;
3810: return;
3811: }
3812:
3813: // Un test a déjà été fait pour vérifier que s_parametres_tty
3814: // contient deux ou trois arguments.
3815:
3816: parametre_courant = ((*(struct_liste_chainee *)
3817: (*s_parametres_tty).objet)).suivant;
3818:
3819: // Le premier paramètre concerne la vitesse du port. Il doit
3820: // toujours être présent.
3821:
3822: if (parametre_courant == NULL)
3823: {
3824: liberation(s_etat_processus, s_objet_argument);
3825: liberation(s_etat_processus, s_objet_resultat);
3826:
3827: (*s_etat_processus).erreur_execution =
3828: d_ex_erreur_parametre_fichier;
3829: return;
3830: }
3831:
3832: if ((*(*parametre_courant).donnee).type != CHN)
3833: {
3834: liberation(s_etat_processus, s_objet_argument);
3835: liberation(s_etat_processus, s_objet_resultat);
3836:
3837: (*s_etat_processus).erreur_execution =
3838: d_ex_erreur_parametre_fichier;
3839: return;
3840: }
3841:
3842: if ((parametre_courant_majuscule = conversion_majuscule(
3843: s_etat_processus, (*(*parametre_courant).donnee).objet))
3844: == NULL)
3845: {
3846: liberation(s_etat_processus, s_objet_argument);
3847: liberation(s_etat_processus, s_objet_resultat);
3848:
3849: (*s_etat_processus).erreur_systeme =
3850: d_es_allocation_memoire;
3851: return;
3852: }
3853:
3854: position = parametre_courant_majuscule;
3855:
3856: while((*position) != d_code_fin_chaine)
3857: {
3858: if ((*position) == ',')
3859: {
3860: (*position) = ' ';
3861: }
3862:
3863: position++;
3864: }
3865:
3866: position = parametre_courant_majuscule;
3867:
3868: while((*position) != d_code_fin_chaine)
3869: {
3870: if (isalnum((*position)) != 0)
3871: {
3872: break;
3873: }
3874:
3875: position++;
3876: }
3877:
3878: // Vitesse
3879:
3880: unsigned char *vitesses[] =
3881: { "50", "75", "110", "134", "150",
3882: "200", "300", "600", "1200", "1800", "2400",
3883: "4800", "9600", "19200", "38400",
3884: #ifdef B57600
3885: "57600",
3886: #endif
3887: #ifdef B115200
3888: "115200",
3889: #endif
3890: #ifdef B230400
3891: "230400",
3892: #endif
3893: #ifdef B460800
3894: "460800",
3895: #endif
3896: #ifdef B500000
3897: "500000",
3898: #endif
3899: #ifdef B576000
3900: "576000",
3901: #endif
3902: #ifdef B921600
3903: "921600",
3904: #endif
3905: #ifdef B1000000
3906: "1000000",
3907: #endif
3908: #ifdef B1152000
3909: "1152000",
3910: #endif
3911: NULL };
3912: tcflag_t vitesses_constantes[] =
3913: { B50, B75, B110, B134, B150, B200, B300, B600,
3914: B1200, B1800, B2400, B4800, B9600, B19200, B38400,
3915: #ifdef B57600
3916: B57600,
3917: #endif
3918: #ifdef B115200
3919: B115200,
3920: #endif
3921: #ifdef B230400
3922: B230400,
3923: #endif
3924: #ifdef B460800
3925: B460800,
3926: #endif
3927: #ifdef B500000
3928: B500000,
3929: #endif
3930: #ifdef B576000
3931: B576000,
3932: #endif
3933: #ifdef B921600
3934: B921600,
3935: #endif
3936: #ifdef B1000000
3937: B1000000,
3938: #endif
3939: #ifdef B1152000
3940: B1152000,
3941: #endif
3942: 0 };
3943: unsigned int vitesse_courante;
3944:
3945: vitesse_courante = 0;
3946:
3947: while(vitesses[vitesse_courante] != NULL)
3948: {
3949: if (strncmp(position, vitesses[vitesse_courante],
3950: strlen(vitesses[vitesse_courante])) == 0)
3951: {
3952: if (position[strlen(vitesses[vitesse_courante])] ==
3953: d_code_espace)
3954: {
3955: #ifdef CBAUD
3956: tc.c_cflag &= ~((tcflag_t) CBAUD);
3957: tc.c_cflag |= vitesses_constantes[vitesse_courante];
3958: #else // POSIX
3959: cfsetispeed(&tc,
3960: vitesses_constantes[vitesse_courante]);
3961: cfsetospeed(&tc,
3962: vitesses_constantes[vitesse_courante]);
3963: #endif
3964: position += strlen(vitesses[vitesse_courante]);
3965:
3966: break;
3967: }
3968: }
3969:
3970: vitesse_courante++;
3971: }
3972:
3973: if (vitesses[vitesse_courante] == NULL)
3974: {
3975: // La vitesse indiquée n'est pas une vitesse autorisée.
3976:
3977: free(parametre_courant_majuscule);
3978: liberation(s_etat_processus, s_objet_argument);
3979: liberation(s_etat_processus, s_objet_resultat);
3980:
3981: (*s_etat_processus).erreur_execution =
3982: d_ex_erreur_parametre_fichier;
3983: return;
3984: }
3985:
3986: // Nombre de bits par caractère.
3987:
3988: while((*position) != d_code_fin_chaine)
3989: {
3990: if (isalnum((*position)) != 0)
3991: {
3992: break;
3993: }
3994:
3995: position++;
3996: }
3997:
3998: switch((*position))
3999: {
4000: case '5':
4001: {
4002: tc.c_cflag &= ~((tcflag_t) CSIZE);
4003: tc.c_cflag |= CS5;
4004: break;
4005: }
4006:
4007: case '6':
4008: {
4009: tc.c_cflag &= ~((tcflag_t) CSIZE);
4010: tc.c_cflag |= CS6;
4011: break;
4012: }
4013:
4014: case '7':
4015: {
4016: tc.c_cflag &= ~((tcflag_t) CSIZE);
4017: tc.c_cflag |= CS7;
4018: break;
4019: }
4020:
4021: case '8':
4022: {
4023: tc.c_cflag &= ~((tcflag_t) CSIZE);
4024: tc.c_cflag |= CS8;
4025: break;
4026: }
4027:
4028: default:
4029: {
4030: free(parametre_courant_majuscule);
4031: liberation(s_etat_processus, s_objet_argument);
4032: liberation(s_etat_processus, s_objet_resultat);
4033:
4034: (*s_etat_processus).erreur_execution =
4035: d_ex_erreur_parametre_fichier;
4036: return;
4037: }
4038: }
4039:
4040: position++;
4041:
4042: if ((*position) != d_code_espace)
4043: {
4044: free(parametre_courant_majuscule);
4045: liberation(s_etat_processus, s_objet_argument);
4046: liberation(s_etat_processus, s_objet_resultat);
4047:
4048: (*s_etat_processus).erreur_execution =
4049: d_ex_erreur_parametre_fichier;
4050: return;
4051: }
4052:
4053: // Parité
4054:
4055: while((*position) != d_code_fin_chaine)
4056: {
4057: if (isalnum((*position)) != 0)
4058: {
4059: break;
4060: }
4061:
4062: position++;
4063: }
4064:
4065: switch((*position))
4066: {
4067: case 'N':
4068: {
4069: tc.c_cflag &= ~((tcflag_t) PARENB);
4070: break;
4071: }
4072:
4073: case 'O':
4074: {
4075: tc.c_cflag |= PARENB;
4076: tc.c_cflag |= PARODD;
4077: break;
4078: }
4079:
4080: case 'E':
4081: {
4082: tc.c_cflag |= PARENB;
4083: tc.c_cflag &= ~((tcflag_t) PARODD);
4084: break;
4085: }
4086:
4087: default:
4088: {
4089: free(parametre_courant_majuscule);
4090: liberation(s_etat_processus, s_objet_argument);
4091: liberation(s_etat_processus, s_objet_resultat);
4092:
4093: (*s_etat_processus).erreur_execution =
4094: d_ex_erreur_parametre_fichier;
4095: return;
4096: }
4097: }
4098:
4099: position++;
4100:
4101: if ((*position) != d_code_espace)
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: // Bits de stop
4113:
4114: while((*position) != d_code_fin_chaine)
4115: {
4116: if (isalnum((*position)) != 0)
4117: {
4118: break;
4119: }
4120:
4121: position++;
4122: }
4123:
4124: switch((*position))
4125: {
4126: case '1':
4127: {
4128: tc.c_cflag &= ~((tcflag_t) CSTOPB);
4129: break;
4130: }
4131:
4132: case '2':
4133: {
4134: tc.c_cflag |= CSTOPB;
4135: break;
4136: }
4137:
4138: default:
4139: {
4140: free(parametre_courant_majuscule);
4141: liberation(s_etat_processus, s_objet_argument);
4142: liberation(s_etat_processus, s_objet_resultat);
4143:
4144: (*s_etat_processus).erreur_execution =
4145: d_ex_erreur_parametre_fichier;
4146: return;
4147: }
4148: }
4149:
4150: // S'il reste autre chose que des espaces, il y a un
4151: // problème de paramètres.
4152:
4153: position++;
4154:
4155: while((*position) != d_code_fin_chaine)
4156: {
4157: if ((*position) != d_code_espace)
4158: {
4159: free(parametre_courant_majuscule);
4160: liberation(s_etat_processus, s_objet_argument);
4161: liberation(s_etat_processus, s_objet_resultat);
4162:
4163: (*s_etat_processus).erreur_execution =
4164: d_ex_erreur_parametre_fichier;
4165: return;
4166: }
4167:
4168: position++;
4169: }
4170:
4171: // Autres paramètres
4172:
4173: free(parametre_courant_majuscule);
4174: parametre_courant = (*parametre_courant).suivant;
4175:
4176: if (parametre_courant != NULL)
4177: {
4178: parametre_courant = (*(*parametre_courant).donnee).objet;
4179: }
4180:
4181: while(parametre_courant != NULL)
4182: {
4183: if ((*(*parametre_courant).donnee).type != CHN)
4184: {
4185: liberation(s_etat_processus, s_objet_argument);
4186: liberation(s_etat_processus, s_objet_resultat);
4187:
4188: (*s_etat_processus).erreur_execution =
4189: d_ex_erreur_parametre_fichier;
4190: return;
4191: }
4192:
4193: if ((parametre_courant_majuscule = conversion_majuscule(
4194: s_etat_processus, (*(*parametre_courant).donnee)
4195: .objet)) == NULL)
4196: {
4197: (*s_etat_processus).erreur_systeme =
4198: d_es_allocation_memoire;
4199: return;
4200: }
4201:
4202: position = parametre_courant_majuscule;
4203: negation = d_faux;
4204:
4205: unsigned char *fonctions[] =
4206: { "IGNBRK", "BRKINT", "IGNPAR", "PARMRK",
4207: "INPCK", "ISTRIP", "INLCR", "IGNCR", "ICRNL",
4208: "IXON",
4209: #ifdef IXANY
4210: "IXANY",
4211: #endif
4212: "IXOFF",
4213: "OPOST", "ONLCR", "OCRNL", "ONOCR", "ONLRET",
4214: #ifdef OFILL
4215: "OFILL",
4216: #endif
4217: "HUPCL", "CLOCAL",
4218: #ifdef CRTSCTS
4219: "CRTSCTS",
4220: #endif
4221: "ISIG", "ICANON", "ECHO", "ECHOE", "ECHOK",
4222: "ECHONL", "NOFLSH", "TOSTOP", "IEXTEN",
4223:
4224: "RAW",
4225:
4226: NULL };
4227: tcflag_t fonctions_constantes[] =
4228: { /* c_iflag */
4229: 1, IGNBRK, 1, BRKINT, 1, IGNPAR, 1, PARMRK,
4230: 1, INPCK, 1, ISTRIP, 1, INLCR, 1, IGNCR, 1, ICRNL,
4231: 1, IXON,
4232: #ifdef IXANY
4233: 1, IXANY,
4234: #endif
4235: 1, IXOFF,
4236: /* c_oflag */
4237: 2 , OPOST, 2, ONLCR, 2, OCRNL, 2, ONOCR, 2, ONLRET,
4238: #ifdef OFILL
4239: 2, OFILL,
4240: #endif
4241: 2, HUPCL,
4242: /* c_cflag */
4243: 3, CLOCAL,
4244: #ifdef CRTSCTS
4245: 3, CRTSCTS,
4246: #endif
4247: /* c_lflag */
4248: 4, ISIG, 4, ICANON, 4, ECHO, 4, ECHOE, 4, ECHOK,
4249: 4, ECHONL, 4, NOFLSH, 4, TOSTOP, 4, IEXTEN,
4250:
4251: /* RAW */
4252: 5, 0 };
4253: unsigned int fonction_courante;
4254:
4255: // On vient de trouver quelque chose à interpréter.
4256:
4257: if (strncmp(position, "NO ", 3) == 0)
4258: {
4259: position += 3;
4260: negation = d_vrai;
4261: }
4262:
4263: for(fonction_courante = 0;
4264: fonctions[fonction_courante] != NULL;
4265: fonction_courante++)
4266: {
4267: if (strcmp(fonctions[fonction_courante], position)
4268: == 0)
4269: {
4270: if (negation == d_vrai)
4271: {
4272: switch(fonctions_constantes
4273: [fonction_courante * 2])
4274: {
4275: case 1:
4276: {
4277: tc.c_iflag &= ~fonctions_constantes
4278: [(fonction_courante * 2) + 1];
4279: break;
4280: }
4281:
4282: case 2:
4283: {
4284: tc.c_oflag &= ~fonctions_constantes
4285: [(fonction_courante * 2) + 1];
4286: break;
4287: }
4288:
4289: case 3:
4290: {
4291: tc.c_cflag &= ~fonctions_constantes
4292: [(fonction_courante * 2) + 1];
4293: break;
4294: }
4295:
4296: case 4:
4297: {
4298: tc.c_lflag &= ~fonctions_constantes
4299: [(fonction_courante * 2) + 1];
4300: break;
4301: }
4302:
4303: case 5:
4304: {
4305: // RAW ne peut être négatif
4306: break;
4307: }
4308: }
4309: }
4310: else
4311: {
4312: switch(fonctions_constantes
4313: [fonction_courante * 2])
4314: {
4315: case 1:
4316: {
4317: tc.c_iflag |= fonctions_constantes
4318: [(fonction_courante * 2) + 1];
4319: break;
4320: }
4321:
4322: case 2:
4323: {
4324: tc.c_oflag |= fonctions_constantes
4325: [(fonction_courante * 2) + 1];
4326: break;
4327: }
4328:
4329: case 3:
4330: {
4331: tc.c_cflag |= fonctions_constantes
4332: [(fonction_courante * 2) + 1];
4333: break;
4334: }
4335:
4336: case 4:
4337: {
4338: tc.c_lflag |= fonctions_constantes
4339: [(fonction_courante * 2) + 1];
4340: break;
4341: }
4342:
4343: case 5:
4344: {
4345: // no ignbrk
4346: tc.c_iflag &= ~(tcflag_t) IGNBRK;
4347: // no brkint
4348: tc.c_iflag &= ~(tcflag_t) BRKINT;
4349: // no ignpar
4350: tc.c_iflag &= ~(tcflag_t) IGNPAR;
4351: // no parmrk
4352: tc.c_iflag &= ~(tcflag_t) PARMRK;
4353: // no inpck
4354: tc.c_iflag &= ~(tcflag_t) INPCK;
4355: // no istrip
4356: tc.c_iflag &= ~(tcflag_t) ISTRIP;
4357: // no inlcr
4358: tc.c_iflag &= ~(tcflag_t) INLCR;
4359: // no icrnl
4360: tc.c_iflag &= ~(tcflag_t) ICRNL;
4361: // no ixon
4362: tc.c_iflag &= ~(tcflag_t) IXON;
4363: // no ixoff
4364: tc.c_iflag &= ~(tcflag_t) IXOFF;
4365: #ifdef IXANY
4366: // no ixany
4367: tc.c_iflag &= ~(tcflag_t) IXANY;
4368: #endif
4369: // no opost
4370: tc.c_oflag &= ~(tcflag_t) OPOST;
4371: // no isig
4372: tc.c_lflag &= ~(tcflag_t) ISIG;
4373: // no icanon
4374: tc.c_lflag &= ~(tcflag_t) ICANON;
4375: // no echo
4376: tc.c_lflag &= ~(tcflag_t) ECHO;
4377: // no echoe
4378: tc.c_lflag &= ~(tcflag_t) ECHOE;
4379: // no echok
4380: tc.c_lflag &= ~(tcflag_t) ECHOK;
4381: }
4382: }
4383: }
4384:
4385: // On sort si on a trouvé un paramètre
4386: // correct et donc différent de "NO RAW".
4387:
4388: if (!((negation == d_vrai) &&
4389: (fonctions_constantes[fonction_courante * 2]
4390: == 5)))
4391: {
4392: break;
4393: }
4394: }
4395: }
4396:
4397: if (fonctions[fonction_courante] == NULL)
4398: {
4399: // Paramètre inconnu
4400: free(parametre_courant_majuscule);
4401: liberation(s_etat_processus, s_objet_argument);
4402: liberation(s_etat_processus, s_objet_resultat);
4403:
4404: (*s_etat_processus).erreur_execution =
4405: d_ex_erreur_parametre_fichier;
4406: return;
4407: }
4408:
4409: free(parametre_courant_majuscule);
4410: parametre_courant = (*parametre_courant).suivant;
4411: }
4412:
4413: if (tcsetattr(fileno(descripteur), TCSANOW, &tc) != 0)
4414: {
4415: liberation(s_etat_processus, s_objet_argument);
4416: liberation(s_etat_processus, s_objet_resultat);
4417:
4418: (*s_etat_processus).erreur_systeme =
4419: d_ex_erreur_fichier;
4420: return;
4421: }
4422: }
4423:
4424: strcpy((*((struct_fichier *) (*s_objet_resultat).objet)).nom, nom);
4425: liberation(s_etat_processus, s_objet_argument);
4426:
4427: (*((struct_fichier *) (*s_objet_resultat).objet)).protection =
4428: protection;
4429: (*((struct_fichier *) (*s_objet_resultat).objet)).position_clef =
4430: position_clef;
4431:
4432: rewind(descripteur);
4433:
4434: lock.l_type = F_WRLCK;
4435: lock.l_whence = SEEK_SET;
4436: lock.l_start = 0;
4437: lock.l_len = 0;
4438: lock.l_pid = getpid();
4439:
4440: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
4441: {
4442: if (fclose(descripteur) != 0)
4443: {
4444: liberation(s_etat_processus, s_objet_resultat);
4445:
4446: (*s_etat_processus).erreur_systeme =
4447: d_es_erreur_fichier;
4448: return;
4449: }
4450:
4451: liberation(s_etat_processus, s_objet_resultat);
4452:
4453: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
4454: return;
4455: }
4456:
4457: if (lock.l_type == F_UNLCK)
4458: {
4459: /*
4460: * Positionnement d'un verrou exclusif d'écriture par défaut
4461: */
4462:
4463: lock.l_type = F_RDLCK;
4464: lock.l_whence = SEEK_SET;
4465: lock.l_start = 0;
4466: lock.l_len = 0;
4467: lock.l_pid = getpid();
4468:
4469: if (fcntl(fileno(descripteur), F_SETLK, &lock) == -1)
4470: {
4471: if (fclose(descripteur) != 0)
4472: {
4473: liberation(s_etat_processus, s_objet_resultat);
4474:
4475: (*s_etat_processus).erreur_systeme =
4476: d_es_erreur_fichier;
4477: return;
4478: }
4479:
4480: liberation(s_etat_processus, s_objet_resultat);
4481:
4482: (*s_etat_processus).erreur_systeme =
4483: d_es_erreur_fichier;
4484: return;
4485: }
4486: }
4487: else
4488: {
4489: /*
4490: * Test de la cohérence du verrou avec l'option PROTECTION
4491: */
4492:
4493: if ((lock.l_type == F_RDLCK) && (protection != 'R'))
4494: {
4495: free(nom);
4496:
4497: if (fclose(descripteur) != 0)
4498: {
4499: liberation(s_etat_processus, s_objet_resultat);
4500:
4501: (*s_etat_processus).erreur_systeme =
4502: d_es_erreur_fichier;
4503: return;
4504: }
4505:
4506: liberation(s_etat_processus, s_objet_resultat);
4507:
4508: (*s_etat_processus).erreur_execution =
4509: d_ex_fichier_verrouille;
4510: return;
4511: }
4512: else if ((lock.l_type == F_WRLCK) && (protection != 'W'))
4513: {
4514: free(nom);
4515:
4516: if (fclose(descripteur) != 0)
4517: {
4518: liberation(s_etat_processus, s_objet_resultat);
4519:
4520: (*s_etat_processus).erreur_systeme =
4521: d_es_erreur_fichier;
4522: return;
4523: }
4524:
4525: liberation(s_etat_processus, s_objet_resultat);
4526:
4527: (*s_etat_processus).erreur_execution =
4528: d_ex_fichier_verrouille;
4529: return;
4530: }
4531: else
4532: {
4533: free(nom);
4534:
4535: if (fclose(descripteur) != 0)
4536: {
4537: liberation(s_etat_processus, s_objet_resultat);
4538:
4539: (*s_etat_processus).erreur_systeme =
4540: d_es_erreur_fichier;
4541: return;
4542: }
4543:
4544: liberation(s_etat_processus, s_objet_resultat);
4545:
4546: (*s_etat_processus).erreur_execution =
4547: d_ex_fichier_verrouille;
4548: return;
4549: }
4550: }
4551:
4552: /*
4553: * Gestion de la liste des fichiers ouverts
4554: */
4555:
4556: l_element_courant = (*s_etat_processus).s_fichiers;
4557:
4558: if (l_element_courant == NULL)
4559: {
4560: if (((*s_etat_processus).s_fichiers = malloc(sizeof(
4561: struct_liste_chainee))) == NULL)
4562: {
4563: (*s_etat_processus).erreur_systeme =
4564: d_es_allocation_memoire;
4565: return;
4566: }
4567:
4568: (*(*s_etat_processus).s_fichiers).suivant = NULL;
4569:
4570: if (((*(*s_etat_processus).s_fichiers).donnee =
4571: malloc(sizeof(struct_descripteur_fichier))) == NULL)
4572: {
4573: (*s_etat_processus).erreur_systeme =
4574: d_es_allocation_memoire;
4575: return;
4576: }
4577:
4578: l_element_courant = (*s_etat_processus).s_fichiers;
4579: prochain_descripteur = 0;
4580: }
4581: else
4582: {
4583: /*
4584: * Recherche du premier descripteur libre
4585: */
4586:
4587: if ((chaine_descripteurs = malloc(sizeof(unsigned char) *
4588: (ds_nombre_maximum_fichiers_ouverts + 1))) == NULL)
4589: {
4590: (*s_etat_processus).erreur_systeme =
4591: d_es_allocation_memoire;
4592: return;
4593: }
4594:
4595: for(pointeur = chaine_descripteurs, i = 0;
4596: i < ds_nombre_maximum_fichiers_ouverts;
4597: (*pointeur) = d_code_espace, pointeur++, i++);
4598: (*pointeur) = d_code_fin_chaine;
4599:
4600: do
4601: {
4602: chaine_descripteurs[(*((struct_descripteur_fichier *)
4603: (*l_element_courant).donnee)).identifiant] = '-';
4604: l_element_courant = (*l_element_courant).suivant;
4605: } while(l_element_courant != NULL);
4606:
4607: i = 0;
4608: pointeur = chaine_descripteurs;
4609:
4610: while(i < ds_nombre_maximum_fichiers_ouverts)
4611: {
4612: if ((*pointeur) == ' ')
4613: {
4614: break;
4615: }
4616:
4617: pointeur++;
4618: i++;
4619: }
4620:
4621: free(chaine_descripteurs);
4622:
4623: if (i == ds_nombre_maximum_fichiers_ouverts)
4624: {
4625: (*s_etat_processus).erreur_systeme =
4626: d_es_nombre_max_descripteurs;
4627: return;
4628: }
4629:
4630: prochain_descripteur = (int) i;
4631:
4632: /*
4633: * Ajout d'un élément à la fin de la liste chaînée
4634: */
4635:
4636: l_element_courant = (*s_etat_processus).s_fichiers;
4637: while((*l_element_courant).suivant != NULL)
4638: {
4639: l_element_courant = (*l_element_courant).suivant;
4640: }
4641:
4642: if (((*l_element_courant).suivant =
4643: allocation_maillon(s_etat_processus)) == NULL)
4644: {
4645: (*s_etat_processus).erreur_systeme =
4646: d_es_allocation_memoire;
4647: return;
4648: }
4649:
4650: l_element_courant = (*l_element_courant).suivant;
4651: (*l_element_courant).suivant = NULL;
4652:
4653: if (((*l_element_courant).donnee =
4654: malloc(sizeof(struct_descripteur_fichier))) == NULL)
4655: {
4656: (*s_etat_processus).erreur_systeme =
4657: d_es_allocation_memoire;
4658: return;
4659: }
4660: }
4661:
4662: (*((struct_fichier *) (*s_objet_resultat).objet)).descripteur
4663: = prochain_descripteur;
4664: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4665: .identifiant = prochain_descripteur;
4666:
4667: if (type_acces == 'S')
4668: {
4669: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4670: .type = 'C';
4671: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4672: .descripteur_c = descripteur;
4673: }
4674: else
4675: {
4676: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4677: .type = 'S';
4678: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4679: .descripteur_c = descripteur;
4680: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4681: .descripteur_sqlite = sqlite;
4682: }
4683:
4684: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4685: .pid = getpid();
4686: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4687: .tid = pthread_self();
4688: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
4689: .effacement = (type_ouverture == 'S') ? 'Y' : 'N';
4690:
4691: (*((struct_descripteur_fichier *) (*l_element_courant)
4692: .donnee)).nom = nom;
4693: }
4694: else if (type_arguments == 'S')
4695: {
4696: /*
4697: * Traitement des sockets
4698: */
4699:
4700: /*
4701: * Vérification de la cohérence des arguments et traitement
4702: * des valeurs par défaut.
4703: */
4704:
4705: if (format == ' ')
4706: {
4707: format = 'N';
4708: }
4709:
4710: if (protection == ' ')
4711: {
4712: protection = 'N';
4713: }
4714:
4715: if (type_domaine == ' ')
4716: {
4717: type_domaine = 'L';
4718: }
4719:
4720: if (type_socket == ' ')
4721: {
4722: type_socket = 'S';
4723: type = SOCK_STREAM;
4724: }
4725:
4726: if (nom != NULL)
4727: {
4728: if (strcmp(protocole, "") == 0)
4729: {
4730: strcpy(protocole, "UNIX");
4731: }
4732: }
4733: else
4734: {
4735: if (strcmp(protocole, "") == 0)
4736: {
4737: strcpy(protocole, "IPV4");
4738: }
4739: }
4740:
4741: if ((nom != NULL) && (hote != NULL))
4742: {
4743: liberation(s_etat_processus, s_objet_argument);
4744:
4745: (*s_etat_processus).erreur_execution =
4746: d_ex_erreur_parametre_fichier;
4747: return;
4748: }
4749:
4750: if ((nom != NULL) && (strcmp(protocole, "UNIX") != 0))
4751: {
4752: liberation(s_etat_processus, s_objet_argument);
4753:
4754: (*s_etat_processus).erreur_execution =
4755: d_ex_erreur_parametre_fichier;
4756: return;
4757: }
4758:
4759: if ((hote != NULL) && (strcmp(protocole, "UNIX") == 0))
4760: {
4761: liberation(s_etat_processus, s_objet_argument);
4762:
4763: (*s_etat_processus).erreur_execution =
4764: d_ex_erreur_parametre_fichier;
4765: return;
4766: }
4767:
4768: if ((nom != NULL) && (type_domaine == 'F') && (type_adresse != ' '))
4769: {
4770: liberation(s_etat_processus, s_objet_argument);
4771:
4772: (*s_etat_processus).erreur_execution =
4773: d_ex_erreur_parametre_fichier;
4774: return;
4775: }
4776:
4777: if ((presence_port == d_vrai) && (nom != NULL))
4778: {
4779: liberation(s_etat_processus, s_objet_argument);
4780:
4781: (*s_etat_processus).erreur_execution =
4782: d_ex_erreur_parametre_fichier;
4783: return;
4784: }
4785:
4786: if ((type_adresse == ' ') && (type_domaine == 'L'))
4787: {
4788: if (strcmp(protocole, "IPV4") == 0)
4789: {
4790: for(i = 0; i < 4; adresse[i++] = 0);
4791: type_adresse = '4';
4792: }
4793: else if (strcmp(protocole, "IPV6") == 0)
4794: {
4795: for(i = 0; i < 16; adresse[i++] = 0);
4796: type_adresse = '6';
4797: }
4798: else if (strcmp(protocole, "UNIX") != 0)
4799: {
4800: liberation(s_etat_processus, s_objet_argument);
4801:
4802: (*s_etat_processus).erreur_execution =
4803: d_ex_erreur_parametre_fichier;
4804: return;
4805: }
4806: }
4807:
4808: if (((strcmp(protocole, "IPV4") == 0) && (type_adresse == '6')) ||
4809: ((strcmp(protocole, "IPV6") == 0) && (type_adresse == '4')))
4810: {
4811: liberation(s_etat_processus, s_objet_argument);
4812:
4813: (*s_etat_processus).erreur_execution =
4814: d_ex_erreur_parametre_fichier;
4815: return;
4816: }
4817:
4818: if ((nombre_maximal_connexions != 0) && ((type_socket != 'S') &&
4819: (type_socket != 'Q')))
4820: {
4821: liberation(s_etat_processus, s_objet_argument);
4822:
4823: (*s_etat_processus).erreur_execution =
4824: d_ex_erreur_parametre_fichier;
4825: return;
4826: }
4827:
4828: if (nombre_maximal_connexions == 0)
4829: {
4830: nombre_maximal_connexions = 1;
4831: }
4832:
4833: if (protocole_socket == NULL)
4834: {
4835: protocole_numerique = 0;
4836: }
4837: else
4838: {
4839: if (strcmp(protocole_socket, "IPV4") == 0)
4840: {
4841: protocole_socket[2] = d_code_fin_chaine;
4842: protocole_numerique = 0;
4843: }
4844: else
4845: {
4846: if ((s_protocole = getprotobyname(protocole_socket))
4847: == NULL)
4848: {
4849: liberation(s_etat_processus, s_objet_argument);
4850:
4851: (*s_etat_processus).erreur_execution =
4852: d_ex_erreur_parametre_fichier;
4853: return;
4854: }
4855:
4856: protocole_numerique = (*s_protocole).p_proto;
4857: }
4858: }
4859:
4860: if ((s_objet_resultat = allocation(s_etat_processus, SCK))
4861: == NULL)
4862: {
4863: (*s_etat_processus).erreur_systeme =
4864: d_es_allocation_memoire;
4865: return;
4866: }
4867:
4868: if (((*((struct_socket *) (*s_objet_resultat).objet)).format =
4869: allocation(s_etat_processus, LST)) == NULL)
4870: {
4871: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4872: return;
4873: }
4874:
4875: (*((struct_socket *) (*s_objet_resultat).objet)).protection
4876: = protection;
4877: (*(*((struct_socket *) (*s_objet_resultat).objet))
4878: .format).objet = NULL;
4879: (*((struct_socket *) (*s_objet_resultat).objet)).adresse = NULL;
4880:
4881: switch(type_socket)
4882: {
4883: case 'S' :
4884: type = SOCK_STREAM;
4885: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4886: type, "STREAM");
4887: break;
4888:
4889: case 'D' :
4890: type = SOCK_DGRAM;
4891: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4892: type, "DATAGRAM");
4893: break;
4894:
4895: case 'Q' :
4896: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4897: type, "SEQUENTIAL DATAGRAM");
4898: type = SOCK_SEQPACKET;
4899: break;
4900:
4901: case 'R' :
4902: type = SOCK_RAW;
4903: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4904: type, "RAW");
4905: break;
4906:
4907: case 'M' :
4908: type = SOCK_RDM;
4909: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4910: type, "ROBUST DATAGRAM");
4911: break;
4912:
4913: default :
4914: BUG(1, printf("type_socket=%c\n", type_socket));
4915: break;
4916: }
4917:
4918: if ((protection != 'N') && ((type_socket != 'S') &&
4919: (type_socket != 'Q')))
4920: {
4921: liberation(s_etat_processus, s_objet_argument);
4922: liberation(s_etat_processus, s_objet_resultat);
4923:
4924: (*s_etat_processus).erreur_execution =
4925: d_ex_erreur_parametre_fichier;
4926: return;
4927: }
4928:
4929: if (nom == NULL)
4930: {
4931: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
4932: malloc(sizeof(unsigned char))) == NULL)
4933: {
4934: (*s_etat_processus).erreur_systeme =
4935: d_es_allocation_memoire;
4936: return;
4937: }
4938:
4939: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).adresse,
4940: "");
4941: }
4942: else
4943: {
4944: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
4945: transliteration(s_etat_processus, nom,
4946: d_locale, "UTF-8")) == NULL)
4947: {
4948: liberation(s_etat_processus, s_objet_argument);
4949: liberation(s_etat_processus, s_objet_resultat);
4950: return;
4951: }
4952: }
4953:
4954: if (((*((struct_socket *) (*s_objet_resultat).objet))
4955: .adresse_distante = malloc(sizeof(unsigned char))) == NULL)
4956: {
4957: (*s_etat_processus).erreur_systeme =
4958: d_es_allocation_memoire;
4959: return;
4960: }
4961:
4962: strcpy((*((struct_socket *) (*s_objet_resultat).objet))
4963: .adresse_distante, "");
4964:
4965: (*((struct_socket *) (*s_objet_resultat).objet)).localisation =
4966: type_domaine;
4967: (*((struct_socket *) (*s_objet_resultat).objet)).binaire =
4968: format;
4969: (*((struct_socket *) (*s_objet_resultat).objet)).pid =
4970: getpid();
4971: (*((struct_socket *) (*s_objet_resultat).objet)).tid =
4972: pthread_self();
4973: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
4974: = 'Y';
4975: (*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee
4976: = d_faux;
4977: (*((struct_socket *) (*s_objet_resultat).objet)).options = 0;
4978:
4979: if (type_domaine == 'L')
4980: { // Socket serveur
4981: if (nom != NULL)
4982: {
4983: /*
4984: * La socket locale est dans l'espace des noms.
4985: */
4986:
4987: if (((*((struct_socket *) (*s_objet_resultat).objet))
4988: .socket = socket(PF_UNIX, type,
4989: protocole_numerique)) == -1)
4990: {
4991: liberation(s_etat_processus, s_objet_argument);
4992: liberation(s_etat_processus, s_objet_resultat);
4993:
4994: (*s_etat_processus).erreur_execution =
4995: d_ex_erreur_acces_fichier;
4996: return;
4997: }
4998:
4999: (*((struct_socket *) (*s_objet_resultat).objet)).domaine
5000: = PF_UNIX;
5001: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
5002: = 'Y';
5003:
5004: socket_unix.sun_family = AF_UNIX;
5005:
5006: pointeur = (*((struct_socket *)
5007: (*s_objet_resultat).objet)).adresse;
5008:
5009: while((*pointeur) == d_code_espace)
5010: {
5011: pointeur++;
5012: }
5013:
5014: strncpy(socket_unix.sun_path, pointeur, UNIX_PATH_MAX);
5015: socket_unix.sun_path[UNIX_PATH_MAX - 1] = d_code_fin_chaine;
5016:
5017: if (options_socket(s_etat_processus, s_objet_resultat,
5018: options, peripherique, &priorite,
5019: &buffer_emission, &buffer_reception,
5020: &timeout_emission, &timeout_reception) == d_erreur)
5021: {
5022: liberation(s_etat_processus, s_objet_argument);
5023: liberation(s_etat_processus, s_objet_resultat);
5024:
5025: return;
5026: }
5027:
5028: if (bind((*((struct_socket *) (*s_objet_resultat).objet))
5029: .socket, (const struct sockaddr *) &socket_unix,
5030: sizeof(socket_unix)) != 0)
5031: {
5032: liberation(s_etat_processus, s_objet_argument);
5033: liberation(s_etat_processus, s_objet_resultat);
5034:
5035: (*s_etat_processus).erreur_execution =
5036: d_ex_erreur_acces_fichier;
5037: return;
5038: }
5039: }
5040: else
5041: {
5042: /*
5043: * La socket est une socket réseau locale. L'adresse
5044: * passée en argument est l'adresse sur laquelle
5045: * cette socket est à l'écoute.
5046: */
5047:
5048: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
5049: = 'N';
5050:
5051: if (hote != NULL)
5052: { // Hôte défini par un nom
5053: resolution = NULL;
5054:
5055: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
5056: {
5057: liberation(s_etat_processus, s_objet_argument);
5058: liberation(s_etat_processus, s_objet_resultat);
5059:
5060: if (resolution != NULL)
5061: {
5062: freeaddrinfo(resolution);
5063: }
5064:
5065: (*s_etat_processus).erreur_execution =
5066: d_ex_erreur_acces_fichier;
5067: return;
5068: }
5069:
5070: if (strcmp(protocole, "IPV4") == 0)
5071: { // Accès en IPv4
5072: resolution_courante = resolution;
5073:
5074: while(resolution_courante != NULL)
5075: {
5076: if ((*resolution_courante).ai_family ==
5077: AF_INET)
5078: {
5079: break;
5080: }
5081:
5082: resolution_courante = (*resolution_courante)
5083: .ai_next;
5084: }
5085:
5086: if (resolution_courante == NULL)
5087: {
5088: liberation(s_etat_processus, s_objet_argument);
5089: liberation(s_etat_processus, s_objet_resultat);
5090:
5091: freeaddrinfo(resolution);
5092:
5093: (*s_etat_processus).erreur_execution =
5094: d_ex_erreur_acces_fichier;
5095: return;
5096: }
5097:
5098: if (((*((struct_socket *)
5099: (*s_objet_resultat).objet))
5100: .socket = socket(PF_INET, type,
5101: protocole_numerique)) == -1)
5102: {
5103: liberation(s_etat_processus, s_objet_argument);
5104: liberation(s_etat_processus, s_objet_resultat);
5105:
5106: freeaddrinfo(resolution);
5107:
5108: (*s_etat_processus).erreur_execution =
5109: d_ex_erreur_acces_fichier;
5110: return;
5111: }
5112:
5113: (*((struct_socket *) (*s_objet_resultat).objet))
5114: .domaine = PF_INET;
5115:
5116: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
5117: socket_ipv4.sin_family = AF_INET;
5118: socket_ipv4.sin_port = htons((uint16_t) port);
5119: socket_ipv4.sin_addr.s_addr =
5120: (*((struct sockaddr_in *)
5121: (*resolution_courante).ai_addr))
5122: .sin_addr.s_addr;
5123:
5124: if (options_socket(s_etat_processus,
5125: s_objet_resultat,
5126: options, peripherique, &priorite,
5127: &buffer_emission, &buffer_reception,
5128: &timeout_emission, &timeout_reception)
5129: == d_erreur)
5130: {
5131: liberation(s_etat_processus, s_objet_argument);
5132: liberation(s_etat_processus, s_objet_resultat);
5133:
5134: freeaddrinfo(resolution);
5135: return;
5136: }
5137:
5138: if (bind((*((struct_socket *) (*s_objet_resultat)
5139: .objet)).socket, (const struct sockaddr *)
5140: &socket_ipv4, sizeof(socket_ipv4)) != 0)
5141: {
5142: liberation(s_etat_processus, s_objet_argument);
5143: liberation(s_etat_processus, s_objet_resultat);
5144:
5145: freeaddrinfo(resolution);
5146:
5147: (*s_etat_processus).erreur_execution =
5148: d_ex_erreur_acces_fichier;
5149: return;
5150: }
5151:
5152: free((*((struct_socket *) (*s_objet_resultat)
5153: .objet)).adresse);
5154:
5155: if (((*((struct_socket *) (*s_objet_resultat)
5156: .objet)).adresse = malloc(23 *
5157: sizeof(unsigned char))) == NULL)
5158: {
5159: (*s_etat_processus).erreur_systeme =
5160: d_es_allocation_memoire;
5161: return;
5162: }
5163:
5164: sprintf((*((struct_socket *) (*s_objet_resultat)
5165: .objet)).adresse, "%d.%d.%d.%d(%u)",
5166: (ntohl((*((struct sockaddr_in *)
5167: (*resolution_courante).ai_addr)).sin_addr
5168: .s_addr) >> 24) & 0xFF,
5169: (ntohl((*((struct sockaddr_in *)
5170: (*resolution_courante).ai_addr)).sin_addr
5171: .s_addr) >> 16) & 0xFF,
5172: (ntohl((*((struct sockaddr_in *)
5173: (*resolution_courante).ai_addr)).sin_addr
5174: .s_addr) >> 8) & 0xFF,
5175: ntohl((*((struct sockaddr_in *)
5176: (*resolution_courante).ai_addr)).sin_addr
5177: .s_addr) & 0xFF,
5178: (unsigned int) port);
5179: }
5180: else
5181: { // Accès en IPv6
5182: # ifdef IPV6
5183: resolution_courante = resolution;
5184:
5185: while(resolution_courante != NULL)
5186: {
5187: if ((*resolution_courante).ai_family ==
5188: AF_INET6)
5189: {
5190: break;
5191: }
5192:
5193: resolution_courante = (*resolution_courante)
5194: .ai_next;
5195: }
5196:
5197: if (resolution_courante == NULL)
5198: {
5199: liberation(s_etat_processus, s_objet_argument);
5200: liberation(s_etat_processus, s_objet_resultat);
5201:
5202: freeaddrinfo(resolution);
5203:
5204: (*s_etat_processus).erreur_execution =
5205: d_ex_erreur_acces_fichier;
5206: return;
5207: }
5208:
5209: if (((*((struct_socket *)
5210: (*s_objet_resultat).objet))
5211: .socket = socket(PF_INET6, type,
5212: protocole_numerique)) == -1)
5213: {
5214: liberation(s_etat_processus, s_objet_argument);
5215: liberation(s_etat_processus, s_objet_resultat);
5216:
5217: freeaddrinfo(resolution);
5218:
5219: (*s_etat_processus).erreur_execution =
5220: d_ex_erreur_acces_fichier;
5221: return;
5222: }
5223:
5224: (*((struct_socket *) (*s_objet_resultat).objet))
5225: .domaine = PF_INET6;
5226:
5227: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5228: socket_ipv6.sin6_family = AF_INET6;
5229: socket_ipv6.sin6_port = htons((uint16_t) port);
5230:
5231: for(i = 0; i < 16;
5232: socket_ipv6.sin6_addr.s6_addr[i] =
5233: (*((struct sockaddr_in6 *)
5234: (*resolution_courante).ai_addr))
5235: .sin6_addr.s6_addr[i], i++);
5236:
5237: if (options_socket(s_etat_processus,
5238: s_objet_resultat,
5239: options, peripherique, &priorite,
5240: &buffer_emission, &buffer_reception,
5241: &timeout_emission, &timeout_reception)
5242: == d_erreur)
5243: {
5244: liberation(s_etat_processus, s_objet_argument);
5245: liberation(s_etat_processus, s_objet_resultat);
5246:
5247: freeaddrinfo(resolution);
5248: return;
5249: }
5250:
5251: if (bind((*((struct_socket *) (*s_objet_resultat)
5252: .objet)).socket, (const struct sockaddr *)
5253: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5254: {
5255: liberation(s_etat_processus, s_objet_argument);
5256: liberation(s_etat_processus, s_objet_resultat);
5257:
5258: freeaddrinfo(resolution);
5259:
5260: (*s_etat_processus).erreur_execution =
5261: d_ex_erreur_acces_fichier;
5262: return;
5263: }
5264:
5265: free((*((struct_socket *) (*s_objet_resultat)
5266: .objet)).adresse);
5267:
5268: /*
5269: * Longueur de la chaîne :
5270: * Adresse IPv6 : 16 octets soit 128 bits.
5271: * => 32 chiffres en hexadécimal
5272: * Par groupe de 4, 8 groupes
5273: * => 7 ":"
5274: * Port : (%u)
5275: * => 7
5276: * ==> 32 + 7 + 7 + 1 = 47
5277: */
5278:
5279: if (((*((struct_socket *) (*s_objet_resultat)
5280: .objet)).adresse = malloc(47 *
5281: sizeof(unsigned char))) == NULL)
5282: {
5283: (*s_etat_processus).erreur_systeme =
5284: d_es_allocation_memoire;
5285: return;
5286: }
5287:
5288: sprintf((*((struct_socket *) (*s_objet_resultat)
5289: .objet)).adresse,
5290: "%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
5291: "%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)",
5292: (*((struct sockaddr_in6 *)
5293: (*resolution_courante).ai_addr)).sin6_addr
5294: .s6_addr[0],
5295: (*((struct sockaddr_in6 *)
5296: (*resolution_courante).ai_addr)).sin6_addr
5297: .s6_addr[1],
5298: (*((struct sockaddr_in6 *)
5299: (*resolution_courante).ai_addr)).sin6_addr
5300: .s6_addr[2],
5301: (*((struct sockaddr_in6 *)
5302: (*resolution_courante).ai_addr)).sin6_addr
5303: .s6_addr[3],
5304: (*((struct sockaddr_in6 *)
5305: (*resolution_courante).ai_addr)).sin6_addr
5306: .s6_addr[4],
5307: (*((struct sockaddr_in6 *)
5308: (*resolution_courante).ai_addr)).sin6_addr
5309: .s6_addr[5],
5310: (*((struct sockaddr_in6 *)
5311: (*resolution_courante).ai_addr)).sin6_addr
5312: .s6_addr[6],
5313: (*((struct sockaddr_in6 *)
5314: (*resolution_courante).ai_addr)).sin6_addr
5315: .s6_addr[7],
5316: (*((struct sockaddr_in6 *)
5317: (*resolution_courante).ai_addr)).sin6_addr
5318: .s6_addr[8],
5319: (*((struct sockaddr_in6 *)
5320: (*resolution_courante).ai_addr)).sin6_addr
5321: .s6_addr[9],
5322: (*((struct sockaddr_in6 *)
5323: (*resolution_courante).ai_addr)).sin6_addr
5324: .s6_addr[10],
5325: (*((struct sockaddr_in6 *)
5326: (*resolution_courante).ai_addr)).sin6_addr
5327: .s6_addr[11],
5328: (*((struct sockaddr_in6 *)
5329: (*resolution_courante).ai_addr)).sin6_addr
5330: .s6_addr[12],
5331: (*((struct sockaddr_in6 *)
5332: (*resolution_courante).ai_addr)).sin6_addr
5333: .s6_addr[13],
5334: (*((struct sockaddr_in6 *)
5335: (*resolution_courante).ai_addr)).sin6_addr
5336: .s6_addr[14],
5337: (*((struct sockaddr_in6 *)
5338: (*resolution_courante).ai_addr)).sin6_addr
5339: .s6_addr[15],
5340: (unsigned int) port);
5341: # else
5342: if ((*s_etat_processus).langue == 'F')
5343: {
5344: printf("+++Attention : Support du protocole"
5345: " IPv6 indisponible\n");
5346: }
5347: else
5348: {
5349: printf("+++Warning : IPv6 support "
5350: "unavailable\n");
5351: }
5352:
5353: liberation(s_etat_processus, s_objet_argument);
5354: liberation(s_etat_processus, s_objet_resultat);
5355:
5356: freeaddrinfo(resolution);
5357:
5358: (*s_etat_processus).erreur_execution =
5359: d_ex_instruction_indisponible;
5360: return;
5361: # endif
5362: }
5363:
5364: freeaddrinfo(resolution);
5365: }
5366: else
5367: { // Hôte défini par une adresse
5368: if (strcmp(protocole, "IPV4") == 0)
5369: { // Accès en IPv4
5370: free((*((struct_socket *) (*s_objet_resultat)
5371: .objet)).adresse);
5372:
5373: if (((*((struct_socket *) (*s_objet_resultat)
5374: .objet)).adresse = malloc(23 *
5375: sizeof(unsigned char))) == NULL)
5376: {
5377: (*s_etat_processus).erreur_systeme =
5378: d_es_allocation_memoire;
5379: return;
5380: }
5381:
5382: sprintf((*((struct_socket *) (*s_objet_resultat)
5383: .objet)).adresse, "%d.%d.%d.%d(%u)",
5384: (int) adresse[0], (int) adresse[1],
5385: (int) adresse[2], (int) adresse[3],
5386: (unsigned int) port);
5387:
5388: if (((*((struct_socket *)
5389: (*s_objet_resultat).objet))
5390: .socket = socket(PF_INET, type,
5391: protocole_numerique)) == -1)
5392: {
5393: liberation(s_etat_processus, s_objet_argument);
5394: liberation(s_etat_processus, s_objet_resultat);
5395:
5396: (*s_etat_processus).erreur_execution =
5397: d_ex_erreur_acces_fichier;
5398: return;
5399: }
5400:
5401: (*((struct_socket *) (*s_objet_resultat).objet))
5402: .domaine = PF_INET;
5403:
5404: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
5405: socket_ipv4.sin_family = AF_INET;
5406: socket_ipv4.sin_port = htons((uint16_t) port);
5407:
5408: adresse_ipv4 = 0;
5409: for(i = 0; i < 4; adresse_ipv4 =
5410: (256 * adresse_ipv4) +
5411: ((unsigned char) adresse[i++]));
5412:
5413: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
5414:
5415: if (options_socket(s_etat_processus,
5416: s_objet_resultat,
5417: options, peripherique, &priorite,
5418: &buffer_emission, &buffer_reception,
5419: &timeout_emission, &timeout_reception)
5420: == d_erreur)
5421: {
5422: liberation(s_etat_processus, s_objet_argument);
5423: liberation(s_etat_processus, s_objet_resultat);
5424:
5425: return;
5426: }
5427:
5428: if (bind((*((struct_socket *) (*s_objet_resultat)
5429: .objet)).socket, (const struct sockaddr *)
5430: &socket_ipv4, sizeof(socket_ipv4)) != 0)
5431: {
5432: liberation(s_etat_processus, s_objet_argument);
5433: liberation(s_etat_processus, s_objet_resultat);
5434:
5435: (*s_etat_processus).erreur_execution =
5436: d_ex_erreur_acces_fichier;
5437: return;
5438: }
5439: }
5440: else
5441: { // Accès en IPv6
5442: # ifdef IPV6
5443: free((*((struct_socket *) (*s_objet_resultat)
5444: .objet)).adresse);
5445:
5446: if (((*((struct_socket *) (*s_objet_resultat)
5447: .objet)).adresse = malloc(47 *
5448: sizeof(unsigned char))) == NULL)
5449: {
5450: (*s_etat_processus).erreur_systeme =
5451: d_es_allocation_memoire;
5452: return;
5453: }
5454:
5455: sprintf((*((struct_socket *) (*s_objet_resultat)
5456: .objet)).adresse,
5457: "%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
5458: "%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)",
5459: (unsigned int) adresse[0],
5460: (unsigned int) adresse[1],
5461: (unsigned int) adresse[2],
5462: (unsigned int) adresse[3],
5463: (unsigned int) adresse[4],
5464: (unsigned int) adresse[5],
5465: (unsigned int) adresse[6],
5466: (unsigned int) adresse[7],
5467: (unsigned int) adresse[8],
5468: (unsigned int) adresse[9],
5469: (unsigned int) adresse[10],
5470: (unsigned int) adresse[11],
5471: (unsigned int) adresse[12],
5472: (unsigned int) adresse[13],
5473: (unsigned int) adresse[14],
5474: (unsigned int) adresse[15],
5475: (unsigned int) port);
5476:
5477: if (((*((struct_socket *)
5478: (*s_objet_resultat).objet))
5479: .socket = socket(PF_INET6, type,
5480: protocole_numerique)) == -1)
5481: {
5482: liberation(s_etat_processus, s_objet_argument);
5483: liberation(s_etat_processus, s_objet_resultat);
5484:
5485: (*s_etat_processus).erreur_execution =
5486: d_ex_erreur_acces_fichier;
5487: return;
5488: }
5489:
5490: (*((struct_socket *) (*s_objet_resultat).objet))
5491: .domaine = PF_INET6;
5492:
5493: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5494: socket_ipv6.sin6_family = AF_INET6;
5495: socket_ipv6.sin6_port = htons((uint16_t) port);
5496:
5497: for(i = 0; i < 16;
5498: socket_ipv6.sin6_addr.s6_addr[i] =
5499: (unsigned char) (adresse[i]), i++);
5500:
5501: if (options_socket(s_etat_processus,
5502: s_objet_resultat,
5503: options, peripherique, &priorite,
5504: &buffer_emission, &buffer_reception,
5505: &timeout_emission, &timeout_reception)
5506: == d_erreur)
5507: {
5508: liberation(s_etat_processus, s_objet_argument);
5509: liberation(s_etat_processus, s_objet_resultat);
5510:
5511: return;
5512: }
5513:
5514: if (bind((*((struct_socket *) (*s_objet_resultat)
5515: .objet)).socket, (const struct sockaddr *)
5516: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5517: {
5518: liberation(s_etat_processus, s_objet_argument);
5519: liberation(s_etat_processus, s_objet_resultat);
5520:
5521: (*s_etat_processus).erreur_execution =
5522: d_ex_erreur_acces_fichier;
5523: return;
5524: }
5525: # else
5526: if ((*s_etat_processus).langue == 'F')
5527: {
5528: printf("+++Attention : Support du protocole"
5529: " IPv6 indisponible\n");
5530: }
5531: else
5532: {
5533: printf("+++Warning : IPv6 support "
5534: "unavailable\n");
5535: }
5536:
5537: liberation(s_etat_processus, s_objet_argument);
5538: liberation(s_etat_processus, s_objet_resultat);
5539:
5540: (*s_etat_processus).erreur_execution =
5541: d_ex_instruction_indisponible;
5542: return;
5543: # endif
5544: }
5545: }
5546:
5547: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
5548: = 'N';
5549: }
5550:
5551: if ((type_socket == 'S') || (type_socket == 'Q'))
5552: {
5553: if (listen((*((struct_socket *) (*s_objet_resultat).objet))
5554: .socket, (int) nombre_maximal_connexions) != 0)
5555: {
5556: liberation(s_etat_processus, s_objet_argument);
5557: liberation(s_etat_processus, s_objet_resultat);
5558:
5559: (*s_etat_processus).erreur_execution =
5560: d_ex_erreur_acces_fichier;
5561: return;
5562: }
5563:
5564: (*((struct_socket *) (*s_objet_resultat).objet))
5565: .socket_connectee = d_vrai;
5566:
5567: if (protection == 'R')
5568: { // WRITEONLY
5569: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5570: .objet)).socket, SHUT_RD) != 0)
5571: {
5572: liberation(s_etat_processus, s_objet_argument);
5573: liberation(s_etat_processus, s_objet_resultat);
5574:
5575: (*s_etat_processus).erreur_execution =
5576: d_ex_erreur_acces_fichier;
5577: return;
5578: }
5579: }
5580: else if (protection == 'W')
5581: { // READONLY
5582: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5583: .objet)).socket, SHUT_WR) != 0)
5584: {
5585: liberation(s_etat_processus, s_objet_argument);
5586: liberation(s_etat_processus, s_objet_resultat);
5587:
5588: (*s_etat_processus).erreur_execution =
5589: d_ex_erreur_acces_fichier;
5590: return;
5591: }
5592: }
5593: else
5594: { // READWRITE
5595: }
5596: }
5597: }
5598: else
5599: { // Socket cliente
5600: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
5601: = 'N';
5602:
5603: /*
5604: * Dans le cas où la socket n'est pas connectée, on
5605: * ne peut utiliser ni "NAME", ni "HOST", ni "PORT",
5606: * et encore moins spécifier une adresse. En effet, la cible
5607: * est défini par la commande TARGET.
5608: */
5609:
5610: if ((type_socket != 'S') && (type_socket != 'Q'))
5611: {
5612: if ((presence_port == d_vrai) || (hote != NULL) ||
5613: (nom != NULL) || (type_adresse != ' '))
5614: {
5615: liberation(s_etat_processus, s_objet_argument);
5616: liberation(s_etat_processus, s_objet_resultat);
5617:
5618: (*s_etat_processus).erreur_execution =
5619: d_ex_erreur_parametre_fichier;
5620: return;
5621: }
5622: }
5623:
5624: if (nom != NULL)
5625: {
5626: /*
5627: * La socket est dans l'espace des noms.
5628: */
5629:
5630: if (((*((struct_socket *) (*s_objet_resultat).objet))
5631: .socket = socket(PF_UNIX, type,
5632: protocole_numerique)) == -1)
5633: {
5634: liberation(s_etat_processus, s_objet_argument);
5635: liberation(s_etat_processus, s_objet_resultat);
5636:
5637: (*s_etat_processus).erreur_execution =
5638: d_ex_erreur_acces_fichier;
5639: return;
5640: }
5641:
5642: (*((struct_socket *) (*s_objet_resultat).objet))
5643: .domaine = PF_UNIX;
5644:
5645: socket_unix.sun_family = AF_UNIX;
5646: strncpy(socket_unix.sun_path, (*((struct_socket *)
5647: (*s_objet_resultat).objet)).adresse, UNIX_PATH_MAX);
5648: socket_unix.sun_path[UNIX_PATH_MAX - 1] = d_code_fin_chaine;
5649:
5650: if ((type_socket == 'S') || (type_socket == 'Q'))
5651: {
5652: if (connect((*((struct_socket *) (*s_objet_resultat)
5653: .objet)).socket, (const struct sockaddr *)
5654: &socket_unix, sizeof(socket_unix)) != 0)
5655: {
5656: liberation(s_etat_processus, s_objet_argument);
5657: liberation(s_etat_processus, s_objet_resultat);
5658:
5659: (*s_etat_processus).erreur_execution =
5660: d_ex_erreur_acces_fichier;
5661: return;
5662: }
5663:
5664: (*((struct_socket *) (*s_objet_resultat).objet))
5665: .socket_connectee = d_vrai;
5666: (*((struct_socket *) (*s_objet_resultat).objet))
5667: .socket_en_ecoute = 'N';
5668: }
5669: }
5670: else
5671: {
5672: /*
5673: * La socket est une socket réseau. L'adresse
5674: * passée en argument est l'adresse sur laquelle
5675: * cette socket est à l'écoute.
5676: */
5677:
5678: if (hote != NULL)
5679: { // Hôte défini par un nom
5680: resolution = NULL;
5681:
5682: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
5683: {
5684: liberation(s_etat_processus, s_objet_argument);
5685: liberation(s_etat_processus, s_objet_resultat);
5686:
5687: if (resolution != NULL)
5688: {
5689: freeaddrinfo(resolution);
5690: }
5691:
5692: (*s_etat_processus).erreur_execution =
5693: d_ex_erreur_acces_fichier;
5694: return;
5695: }
5696:
5697: if (strcmp(protocole, "IPV4") == 0)
5698: { // Accès en IPv4
5699: resolution_courante = resolution;
5700:
5701: while(resolution_courante != NULL)
5702: {
5703: if ((*resolution_courante).ai_family ==
5704: AF_INET)
5705: {
5706: break;
5707: }
5708:
5709: resolution_courante = (*resolution_courante)
5710: .ai_next;
5711: }
5712:
5713: if (resolution_courante == NULL)
5714: {
5715: liberation(s_etat_processus, s_objet_argument);
5716: liberation(s_etat_processus, s_objet_resultat);
5717:
5718: freeaddrinfo(resolution);
5719:
5720: (*s_etat_processus).erreur_execution =
5721: d_ex_erreur_acces_fichier;
5722: return;
5723: }
5724:
5725: if (((*((struct_socket *)
5726: (*s_objet_resultat).objet))
5727: .socket = socket(PF_INET, type,
5728: protocole_numerique)) == -1)
5729: {
5730: liberation(s_etat_processus, s_objet_argument);
5731: liberation(s_etat_processus, s_objet_resultat);
5732:
5733: freeaddrinfo(resolution);
5734:
5735: (*s_etat_processus).erreur_execution =
5736: d_ex_erreur_acces_fichier;
5737: return;
5738: }
5739:
5740: (*((struct_socket *) (*s_objet_resultat).objet))
5741: .domaine = PF_INET;
5742:
5743: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
5744: socket_ipv4.sin_family = AF_INET;
5745: socket_ipv4.sin_port = htons((uint16_t) port);
5746: socket_ipv4.sin_addr.s_addr =
5747: (*((struct sockaddr_in *)
5748: (*resolution_courante).ai_addr))
5749: .sin_addr.s_addr;
5750:
5751: if ((type_socket == 'S') || (type_socket == 'Q'))
5752: {
5753: if (connect((*((struct_socket *)
5754: (*s_objet_resultat).objet)).socket,
5755: (const struct sockaddr *)
5756: &socket_ipv4, sizeof(socket_ipv4)) != 0)
5757: {
5758: liberation(s_etat_processus,
5759: s_objet_argument);
5760: liberation(s_etat_processus,
5761: s_objet_resultat);
5762:
5763: freeaddrinfo(resolution);
5764:
5765: (*s_etat_processus).erreur_execution =
5766: d_ex_erreur_acces_fichier;
5767: return;
5768: }
5769:
5770: (*((struct_socket *) (*s_objet_resultat).objet))
5771: .socket_connectee = d_vrai;
5772: (*((struct_socket *) (*s_objet_resultat).objet))
5773: .socket_en_ecoute = 'N';
5774: }
5775:
5776: free((*((struct_socket *) (*s_objet_resultat)
5777: .objet)).adresse);
5778:
5779: if (((*((struct_socket *) (*s_objet_resultat)
5780: .objet)).adresse = malloc(23 *
5781: sizeof(unsigned char))) == NULL)
5782: {
5783: (*s_etat_processus).erreur_systeme =
5784: d_es_allocation_memoire;
5785: return;
5786: }
5787:
5788: sprintf((*((struct_socket *) (*s_objet_resultat)
5789: .objet)).adresse, "%d.%d.%d.%d(%u)",
5790: (ntohl((*((struct sockaddr_in *)
5791: (*resolution_courante).ai_addr)).sin_addr
5792: .s_addr) >> 24) & 0xFF,
5793: (ntohl((*((struct sockaddr_in *)
5794: (*resolution_courante).ai_addr)).sin_addr
5795: .s_addr) >> 16) & 0xFF,
5796: (ntohl((*((struct sockaddr_in *)
5797: (*resolution_courante).ai_addr)).sin_addr
5798: .s_addr) >> 8) & 0xFF,
5799: ntohl((*((struct sockaddr_in *)
5800: (*resolution_courante).ai_addr)).sin_addr
5801: .s_addr) & 0xFF,
5802: (unsigned int) port);
5803: }
5804: else
5805: { // Accès en IPv6
5806: # ifdef IPV6
5807: resolution_courante = resolution;
5808:
5809: while(resolution_courante != NULL)
5810: {
5811: if ((*resolution_courante).ai_family ==
5812: AF_INET6)
5813: {
5814: break;
5815: }
5816:
5817: resolution_courante = (*resolution_courante)
5818: .ai_next;
5819: }
5820:
5821: if (resolution_courante == NULL)
5822: {
5823: liberation(s_etat_processus, s_objet_argument);
5824: liberation(s_etat_processus, s_objet_resultat);
5825:
5826: freeaddrinfo(resolution);
5827:
5828: (*s_etat_processus).erreur_execution =
5829: d_ex_erreur_acces_fichier;
5830: return;
5831: }
5832:
5833: if (((*((struct_socket *)
5834: (*s_objet_resultat).objet))
5835: .socket = socket(PF_INET6, type,
5836: protocole_numerique)) == -1)
5837: {
5838: liberation(s_etat_processus, s_objet_argument);
5839: liberation(s_etat_processus, s_objet_resultat);
5840:
5841: freeaddrinfo(resolution);
5842:
5843: (*s_etat_processus).erreur_execution =
5844: d_ex_erreur_acces_fichier;
5845: return;
5846: }
5847:
5848: (*((struct_socket *) (*s_objet_resultat).objet))
5849: .domaine = PF_INET6;
5850:
5851: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5852: socket_ipv6.sin6_family = AF_INET6;
5853: socket_ipv6.sin6_port = htons((uint16_t) port);
5854:
5855: for(i = 0; i < 16;
5856: socket_ipv6.sin6_addr.s6_addr[i] =
5857: (*((struct sockaddr_in6 *)
5858: (*resolution_courante).ai_addr))
5859: .sin6_addr.s6_addr[i], i++);
5860:
5861: if ((type_socket == 'S') || (type_socket == 'Q'))
5862: {
5863: if (connect((*((struct_socket *)
5864: (*s_objet_resultat).objet)).socket,
5865: (const struct sockaddr *)
5866: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5867: {
5868: liberation(s_etat_processus,
5869: s_objet_argument);
5870: liberation(s_etat_processus,
5871: s_objet_resultat);
5872:
5873: freeaddrinfo(resolution);
5874:
5875: (*s_etat_processus).erreur_execution =
5876: d_ex_erreur_acces_fichier;
5877: return;
5878: }
5879:
5880: (*((struct_socket *) (*s_objet_resultat).objet))
5881: .socket_connectee = d_vrai;
5882: (*((struct_socket *) (*s_objet_resultat).objet))
5883: .socket_en_ecoute = 'N';
5884: }
5885:
5886: free((*((struct_socket *) (*s_objet_resultat)
5887: .objet)).adresse);
5888:
5889: if (((*((struct_socket *) (*s_objet_resultat)
5890: .objet)).adresse = malloc(47 *
5891: sizeof(unsigned char))) == NULL)
5892: {
5893: (*s_etat_processus).erreur_systeme =
5894: d_es_allocation_memoire;
5895: return;
5896: }
5897:
5898: sprintf((*((struct_socket *) (*s_objet_resultat)
5899: .objet)).adresse,
5900: "%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
5901: "%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)",
5902: (*((struct sockaddr_in6 *)
5903: (*resolution_courante).ai_addr)).sin6_addr
5904: .s6_addr[0],
5905: (*((struct sockaddr_in6 *)
5906: (*resolution_courante).ai_addr)).sin6_addr
5907: .s6_addr[1],
5908: (*((struct sockaddr_in6 *)
5909: (*resolution_courante).ai_addr)).sin6_addr
5910: .s6_addr[2],
5911: (*((struct sockaddr_in6 *)
5912: (*resolution_courante).ai_addr)).sin6_addr
5913: .s6_addr[3],
5914: (*((struct sockaddr_in6 *)
5915: (*resolution_courante).ai_addr)).sin6_addr
5916: .s6_addr[4],
5917: (*((struct sockaddr_in6 *)
5918: (*resolution_courante).ai_addr)).sin6_addr
5919: .s6_addr[5],
5920: (*((struct sockaddr_in6 *)
5921: (*resolution_courante).ai_addr)).sin6_addr
5922: .s6_addr[6],
5923: (*((struct sockaddr_in6 *)
5924: (*resolution_courante).ai_addr)).sin6_addr
5925: .s6_addr[7],
5926: (*((struct sockaddr_in6 *)
5927: (*resolution_courante).ai_addr)).sin6_addr
5928: .s6_addr[8],
5929: (*((struct sockaddr_in6 *)
5930: (*resolution_courante).ai_addr)).sin6_addr
5931: .s6_addr[9],
5932: (*((struct sockaddr_in6 *)
5933: (*resolution_courante).ai_addr)).sin6_addr
5934: .s6_addr[10],
5935: (*((struct sockaddr_in6 *)
5936: (*resolution_courante).ai_addr)).sin6_addr
5937: .s6_addr[11],
5938: (*((struct sockaddr_in6 *)
5939: (*resolution_courante).ai_addr)).sin6_addr
5940: .s6_addr[12],
5941: (*((struct sockaddr_in6 *)
5942: (*resolution_courante).ai_addr)).sin6_addr
5943: .s6_addr[13],
5944: (*((struct sockaddr_in6 *)
5945: (*resolution_courante).ai_addr)).sin6_addr
5946: .s6_addr[14],
5947: (*((struct sockaddr_in6 *)
5948: (*resolution_courante).ai_addr)).sin6_addr
5949: .s6_addr[15],
5950: (unsigned int) port);
5951: # else
5952: if ((*s_etat_processus).langue == 'F')
5953: {
5954: printf("+++Attention : Support du protocole"
5955: " IPv6 indisponible\n");
5956: }
5957: else
5958: {
5959: printf("+++Warning : IPv6 support "
5960: "unavailable\n");
5961: }
5962:
5963: liberation(s_etat_processus, s_objet_argument);
5964: liberation(s_etat_processus, s_objet_resultat);
5965:
5966: freeaddrinfo(resolution);
5967:
5968: (*s_etat_processus).erreur_execution =
5969: d_ex_instruction_indisponible;
5970: return;
5971: # endif
5972: }
5973:
5974: freeaddrinfo(resolution);
5975: }
5976: else
5977: { // Hôte défini par une adresse
5978: if (strcmp(protocole, "IPV4") == 0)
5979: { // Accès en IPv4
5980: if (type_adresse == '4')
5981: {
5982: free((*((struct_socket *) (*s_objet_resultat)
5983: .objet)).adresse);
5984:
5985: if (((*((struct_socket *) (*s_objet_resultat)
5986: .objet)).adresse = malloc(23 *
5987: sizeof(unsigned char))) == NULL)
5988: {
5989: (*s_etat_processus).erreur_systeme =
5990: d_es_allocation_memoire;
5991: return;
5992: }
5993:
5994: sprintf((*((struct_socket *) (*s_objet_resultat)
5995: .objet)).adresse, "%d.%d.%d.%d(%u)",
5996: (int) adresse[0], (int) adresse[1],
5997: (int) adresse[2], (int) adresse[3],
5998: (unsigned int) port);
5999: }
6000: else
6001: {
6002: free((*((struct_socket *) (*s_objet_resultat)
6003: .objet)).adresse);
6004:
6005: if (((*((struct_socket *) (*s_objet_resultat)
6006: .objet)).adresse = malloc(
6007: sizeof(unsigned char))) == NULL)
6008: {
6009: (*s_etat_processus).erreur_systeme =
6010: d_es_allocation_memoire;
6011: return;
6012: }
6013:
6014: (*((struct_socket *) (*s_objet_resultat).objet))
6015: .adresse[0] = d_code_fin_chaine;
6016: }
6017:
6018: if (((*((struct_socket *)
6019: (*s_objet_resultat).objet))
6020: .socket = socket(PF_INET, type,
6021: protocole_numerique)) == -1)
6022: {
6023: liberation(s_etat_processus, s_objet_argument);
6024: liberation(s_etat_processus, s_objet_resultat);
6025:
6026: (*s_etat_processus).erreur_execution =
6027: d_ex_erreur_acces_fichier;
6028: return;
6029: }
6030:
6031: (*((struct_socket *) (*s_objet_resultat).objet))
6032: .domaine = PF_INET;
6033:
6034: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
6035: socket_ipv4.sin_family = AF_INET;
6036: socket_ipv4.sin_port = htons((uint16_t) port);
6037:
6038: adresse_ipv4 = 0;
6039: for(i = 0; i < 4; adresse_ipv4 =
6040: (256 * adresse_ipv4)
6041: + ((unsigned char) adresse[i++]));
6042:
6043: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
6044:
6045: if ((type_socket == 'S') || (type_socket == 'Q'))
6046: {
6047: if (connect((*((struct_socket *)
6048: (*s_objet_resultat).objet)).socket,
6049: (const struct sockaddr *)
6050: &socket_ipv4, sizeof(socket_ipv4)) != 0)
6051: {
6052: liberation(s_etat_processus,
6053: s_objet_argument);
6054: liberation(s_etat_processus,
6055: s_objet_resultat);
6056:
6057: (*s_etat_processus).erreur_execution =
6058: d_ex_erreur_acces_fichier;
6059: return;
6060: }
6061:
6062: (*((struct_socket *) (*s_objet_resultat).objet))
6063: .socket_connectee = d_vrai;
6064: (*((struct_socket *) (*s_objet_resultat).objet))
6065: .socket_en_ecoute = 'N';
6066: }
6067: }
6068: else if (strcmp(protocole, "IPV6") == 0)
6069: { // Accès en IPv6
6070: # ifdef IPV6
6071: if (type_adresse == '6')
6072: {
6073: free((*((struct_socket *) (*s_objet_resultat)
6074: .objet)).adresse);
6075:
6076: if (((*((struct_socket *) (*s_objet_resultat)
6077: .objet)).adresse = malloc(47 *
6078: sizeof(unsigned char))) == NULL)
6079: {
6080: (*s_etat_processus).erreur_systeme =
6081: d_es_allocation_memoire;
6082: return;
6083: }
6084:
6085: sprintf((*((struct_socket *) (*s_objet_resultat)
6086: .objet)).adresse,
6087: "%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
6088: "%02X%02X:%02X%02X:%02X%02X:%02X%02X"
6089: "(%u)",
6090: (unsigned int) adresse[0],
6091: (unsigned int) adresse[1],
6092: (unsigned int) adresse[2],
6093: (unsigned int) adresse[3],
6094: (unsigned int) adresse[4],
6095: (unsigned int) adresse[5],
6096: (unsigned int) adresse[6],
6097: (unsigned int) adresse[7],
6098: (unsigned int) adresse[8],
6099: (unsigned int) adresse[9],
6100: (unsigned int) adresse[10],
6101: (unsigned int) adresse[11],
6102: (unsigned int) adresse[12],
6103: (unsigned int) adresse[13],
6104: (unsigned int) adresse[14],
6105: (unsigned int) adresse[15],
6106: (unsigned int) port);
6107: }
6108: else
6109: {
6110: free((*((struct_socket *) (*s_objet_resultat)
6111: .objet)).adresse);
6112:
6113: if (((*((struct_socket *) (*s_objet_resultat)
6114: .objet)).adresse = malloc(
6115: sizeof(unsigned char))) == NULL)
6116: {
6117: (*s_etat_processus).erreur_systeme =
6118: d_es_allocation_memoire;
6119: return;
6120: }
6121:
6122: (*((struct_socket *) (*s_objet_resultat).objet))
6123: .adresse[0] = d_code_fin_chaine;
6124: }
6125:
6126: if (((*((struct_socket *)
6127: (*s_objet_resultat).objet))
6128: .socket = socket(PF_INET6, type,
6129: protocole_numerique)) == -1)
6130: {
6131: liberation(s_etat_processus, s_objet_argument);
6132: liberation(s_etat_processus, s_objet_resultat);
6133:
6134: (*s_etat_processus).erreur_execution =
6135: d_ex_erreur_acces_fichier;
6136: return;
6137: }
6138:
6139: (*((struct_socket *) (*s_objet_resultat).objet))
6140: .domaine = PF_INET6;
6141:
6142: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
6143: socket_ipv6.sin6_family = AF_INET6;
6144: socket_ipv6.sin6_port = htons((uint16_t) port);
6145:
6146: for(i = 0; i < 16;
6147: socket_ipv6.sin6_addr.s6_addr[i] =
6148: (unsigned char) (adresse[i]), i++);
6149:
6150: if ((type_socket == 'S') || (type_socket == 'Q'))
6151: {
6152: if (connect((*((struct_socket *)
6153: (*s_objet_resultat).objet)).socket,
6154: (const struct sockaddr *)
6155: &socket_ipv6, sizeof(socket_ipv6)) != 0)
6156: {
6157: liberation(s_etat_processus,
6158: s_objet_argument);
6159: liberation(s_etat_processus,
6160: s_objet_resultat);
6161:
6162: (*s_etat_processus).erreur_execution =
6163: d_ex_erreur_acces_fichier;
6164: return;
6165: }
6166:
6167: (*((struct_socket *) (*s_objet_resultat).objet))
6168: .socket_connectee = d_vrai;
6169: (*((struct_socket *) (*s_objet_resultat).objet))
6170: .socket_en_ecoute = 'N';
6171: }
6172: # else
6173: if ((*s_etat_processus).langue == 'F')
6174: {
6175: printf("+++Attention : Support du protocole"
6176: " IPv6 indisponible\n");
6177: }
6178: else
6179: {
6180: printf("+++Warning : IPv6 support "
6181: "unavailable\n");
6182: }
6183:
6184: liberation(s_etat_processus, s_objet_argument);
6185: liberation(s_etat_processus, s_objet_resultat);
6186:
6187: (*s_etat_processus).erreur_execution =
6188: d_ex_instruction_indisponible;
6189: return;
6190: # endif
6191: }
6192: else
6193: { // Socket UNIX
6194: free((*((struct_socket *) (*s_objet_resultat)
6195: .objet)).adresse);
6196:
6197: if (((*((struct_socket *) (*s_objet_resultat)
6198: .objet)).adresse = malloc(
6199: sizeof(unsigned char))) == NULL)
6200: {
6201: (*s_etat_processus).erreur_systeme =
6202: d_es_allocation_memoire;
6203: return;
6204: }
6205:
6206: (*((struct_socket *) (*s_objet_resultat).objet))
6207: .adresse[0] = d_code_fin_chaine;
6208:
6209: if (((*((struct_socket *)
6210: (*s_objet_resultat).objet))
6211: .socket = socket(PF_UNIX, type,
6212: protocole_numerique)) == -1)
6213: {
6214: liberation(s_etat_processus, s_objet_argument);
6215: liberation(s_etat_processus, s_objet_resultat);
6216:
6217: (*s_etat_processus).erreur_execution =
6218: d_ex_erreur_acces_fichier;
6219: return;
6220: }
6221: }
6222: }
6223:
6224: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
6225: = 'N';
6226: }
6227:
6228: if ((type_socket == 'S') || (type_socket == 'Q'))
6229: {
6230: if (protection == 'R')
6231: { // WRITEONLY
6232: if (shutdown((*((struct_socket *) (*s_objet_resultat)
6233: .objet)).socket, SHUT_RD) != 0)
6234: {
6235: liberation(s_etat_processus, s_objet_argument);
6236: liberation(s_etat_processus, s_objet_resultat);
6237:
6238: (*s_etat_processus).erreur_execution =
6239: d_ex_erreur_acces_fichier;
6240: return;
6241: }
6242: }
6243: else if (protection == 'W')
6244: { // READONLY
6245: if (shutdown((*((struct_socket *) (*s_objet_resultat)
6246: .objet)).socket, SHUT_WR) != 0)
6247: {
6248: liberation(s_etat_processus, s_objet_argument);
6249: liberation(s_etat_processus, s_objet_resultat);
6250:
6251: (*s_etat_processus).erreur_execution =
6252: d_ex_erreur_acces_fichier;
6253: return;
6254: }
6255: }
6256: else
6257: { // READWRITE
6258: }
6259: }
6260: }
6261:
6262: /*
6263: * Gestion de la liste des sockets ouvertes
6264: */
6265:
6266: l_element_courant = (*s_etat_processus).s_sockets;
6267:
6268: if (l_element_courant == NULL)
6269: {
6270: if (((*s_etat_processus).s_sockets =
6271: allocation_maillon(s_etat_processus)) == NULL)
6272: {
6273: (*s_etat_processus).erreur_systeme =
6274: d_es_allocation_memoire;
6275: return;
6276: }
6277:
6278: (*(*s_etat_processus).s_sockets).suivant = NULL;
6279: l_element_courant = (*s_etat_processus).s_sockets;
6280: }
6281: else
6282: {
6283: /*
6284: * Ajout d'un élément à la fin de la liste chaînée
6285: */
6286:
6287: while((*l_element_courant).suivant != NULL)
6288: {
6289: l_element_courant = (*l_element_courant).suivant;
6290: }
6291:
6292: if (((*l_element_courant).suivant =
6293: allocation_maillon(s_etat_processus)) == NULL)
6294: {
6295: (*s_etat_processus).erreur_systeme =
6296: d_es_allocation_memoire;
6297: return;
6298: }
6299:
6300: l_element_courant = (*l_element_courant).suivant;
6301: (*l_element_courant).suivant = NULL;
6302: }
6303:
6304: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
6305: s_objet_resultat, 'O')) == NULL)
6306: {
6307: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
6308: return;
6309: }
6310:
6311: liberation(s_etat_processus, s_objet_argument);
6312: }
6313: else
6314: {
6315: liberation(s_etat_processus, s_objet_argument);
6316:
6317: (*s_etat_processus).erreur_execution =
6318: d_ex_erreur_parametre_fichier;
6319: return;
6320: }
6321: }
6322: else if ((*s_objet_argument).type == CHN)
6323: {
6324: if ((s_objet_resultat = allocation(s_etat_processus, SPH)) == NULL)
6325: {
6326: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
6327: return;
6328: }
6329:
6330: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).nom =
6331: malloc((strlen((unsigned char *) (*s_objet_argument).objet)
6332: + 1) *sizeof(unsigned char))) == NULL)
6333: {
6334: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
6335: return;
6336: }
6337:
6338: strcpy((*((struct_semaphore *) (*s_objet_resultat).objet)).nom,
6339: (unsigned char *) (*s_objet_argument).objet);
6340:
6341: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).semaphore =
6342: sem_open((*((struct_semaphore *) (*s_objet_resultat).objet))
6343: .nom, 0)) == SEM_FAILED)
6344: {
6345: if (errno == ENOMEM)
6346: {
6347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
6348: return;
6349: }
6350:
6351: (*s_etat_processus).erreur_execution = d_ex_semaphore;
6352:
6353: liberation(s_etat_processus, s_objet_argument);
6354: liberation(s_etat_processus, s_objet_resultat);
6355: return;
6356: }
6357: }
6358: else
6359: {
6360: liberation(s_etat_processus, s_objet_argument);
6361:
6362: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
6363: return;
6364: }
6365:
6366: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
6367: s_objet_resultat) == d_erreur)
6368: {
6369: return;
6370: }
6371:
6372: return;
6373: }
6374:
6375: // 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