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