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