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