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