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