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