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