1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.12
4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'oct'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_oct(struct_processus *s_etat_processus)
40: {
41: (*s_etat_processus).erreur_execution = d_ex;
42:
43: if ((*s_etat_processus).affichage_arguments == 'Y')
44: {
45: printf("\n OCT ");
46:
47: if ((*s_etat_processus).langue == 'F')
48: {
49: printf("(base octale)\n\n");
50: printf(" Aucun argument\n");
51: }
52: else
53: {
54: printf("(octal base)\n\n");
55: printf(" No argument\n");
56: }
57:
58: return;
59: }
60: else if ((*s_etat_processus).test_instruction == 'Y')
61: {
62: (*s_etat_processus).nombre_arguments = -1;
63: return;
64: }
65:
66: if (test_cfsf(s_etat_processus, 31) == d_vrai)
67: {
68: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
69: {
70: return;
71: }
72: }
73:
74: sf(s_etat_processus, 43);
75: cf(s_etat_processus, 44);
76:
77: return;
78: }
79:
80:
81: /*
82: ================================================================================
83: Fonction 'over'
84: ================================================================================
85: Entrées :
86: --------------------------------------------------------------------------------
87: Sorties :
88: --------------------------------------------------------------------------------
89: Effets de bord : néant
90: ================================================================================
91: */
92:
93: void
94: instruction_over(struct_processus *s_etat_processus)
95: {
96: struct_objet *s_objet;
97:
98: (*s_etat_processus).erreur_execution = d_ex;
99:
100: if ((*s_etat_processus).affichage_arguments == 'Y')
101: {
102: printf("\n OVER ");
103:
104: if ((*s_etat_processus).langue == 'F')
105: {
106: printf("(duplication de l'objet de niveau 2)\n\n");
107: }
108: else
109: {
110: printf("(duplication of level 2 object)\n\n");
111: }
112:
113: printf(" 2: %s, %s, %s, %s, %s, %s,\n"
114: " %s, %s, %s, %s, %s,\n"
115: " %s, %s, %s, %s, %s,\n"
116: " %s, %s, %s, %s,\n"
117: " %s, %s\n",
118: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
119: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
120: d_SQL, d_SLB, d_PRC, d_MTX);
121: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
122: " %s, %s, %s, %s, %s,\n"
123: " %s, %s, %s, %s, %s,\n"
124: " %s, %s, %s, %s,\n"
125: " %s, %s\n",
126: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
127: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
128: d_SQL, d_SLB, d_PRC, d_MTX);
129: printf("-> 3: %s, %s, %s, %s, %s, %s,\n"
130: " %s, %s, %s, %s, %s,\n"
131: " %s, %s, %s, %s, %s,\n"
132: " %s, %s, %s, %s,\n"
133: " %s, %s\n",
134: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
135: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
136: d_SQL, d_SLB, d_PRC, d_MTX);
137: printf(" ...\n");
138: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
139: " %s, %s, %s, %s, %s,\n"
140: " %s, %s, %s, %s, %s,\n"
141: " %s, %s, %s, %s,\n"
142: " %s, %s\n",
143: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
144: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
145: d_SQL, d_SLB, d_PRC, d_MTX);
146:
147: return;
148: }
149: else if ((*s_etat_processus).test_instruction == 'Y')
150: {
151: (*s_etat_processus).nombre_arguments = -1;
152: return;
153: }
154:
155: if (test_cfsf(s_etat_processus, 31) == d_vrai)
156: {
157: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
158: {
159: return;
160: }
161: }
162:
163: if ((*s_etat_processus).hauteur_pile_operationnelle < 2)
164: {
165: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
166: return;
167: }
168:
169: s_objet = copie_objet(s_etat_processus,
170: (*(*(*s_etat_processus).l_base_pile).suivant).donnee, 'P');
171:
172: if (s_objet == NULL)
173: {
174: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
175: return;
176: }
177:
178: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
179: s_objet) == d_erreur)
180: {
181: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
182: return;
183: }
184:
185: return;
186: }
187:
188:
189: /*
190: ================================================================================
191: Fonction 'or'
192: ================================================================================
193: Entrées : pointeur sur une structure struct_processus
194: --------------------------------------------------------------------------------
195: Sorties :
196: --------------------------------------------------------------------------------
197: Effets de bord : néant
198: ================================================================================
199: */
200:
201: void
202: instruction_or(struct_processus *s_etat_processus)
203: {
204: struct_liste_chainee *l_element_courant;
205: struct_liste_chainee *l_element_precedent;
206:
207: struct_objet *s_copie_argument_1;
208: struct_objet *s_copie_argument_2;
209: struct_objet *s_objet_argument_1;
210: struct_objet *s_objet_argument_2;
211: struct_objet *s_objet_resultat;
212:
213: unsigned long nombre_elements;
214:
215: (*s_etat_processus).erreur_execution = d_ex;
216:
217: if ((*s_etat_processus).affichage_arguments == 'Y')
218: {
219: printf("\n OR ");
220:
221: if ((*s_etat_processus).langue == 'F')
222: {
223: printf("(opérateur ou)\n\n");
224: }
225: else
226: {
227: printf("(or operator)\n\n");
228: }
229:
230: printf(" 2: %s, %s\n", d_INT, d_REL);
231: printf(" 1: %s, %s\n", d_INT, d_REL);
232: printf("-> 1: %s\n\n", d_INT);
233:
234: printf(" 2: %s\n", d_BIN);
235: printf(" 1: %s\n", d_BIN);
236: printf("-> 1: %s\n\n", d_BIN);
237:
238: printf(" 2: %s\n", d_NOM);
239: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
240: printf("-> 1: %s\n\n", d_ALG);
241:
242: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
243: printf(" 1: %s\n", d_NOM);
244: printf("-> 1: %s\n\n", d_ALG);
245:
246: printf(" 2: %s\n", d_ALG);
247: printf(" 1: %s\n", d_ALG);
248: printf("-> 1: %s\n\n", d_ALG);
249:
250: printf(" 2: %s\n", d_RPN);
251: printf(" 1: %s\n", d_RPN);
252: printf("-> 1: %s\n", d_RPN);
253:
254: return;
255: }
256: else if ((*s_etat_processus).test_instruction == 'Y')
257: {
258: (*s_etat_processus).nombre_arguments = 0;
259: return;
260: }
261:
262: if (test_cfsf(s_etat_processus, 31) == d_vrai)
263: {
264: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
265: {
266: return;
267: }
268: }
269:
270: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
271: &s_objet_argument_1) == d_erreur)
272: {
273: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
274: return;
275: }
276:
277: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
278: &s_objet_argument_2) == d_erreur)
279: {
280: liberation(s_etat_processus, s_objet_argument_1);
281:
282: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
283: return;
284: }
285:
286: /*
287: --------------------------------------------------------------------------------
288: OR logique
289: --------------------------------------------------------------------------------
290: */
291:
292: if ((((*s_objet_argument_1).type == INT) ||
293: ((*s_objet_argument_1).type == REL)) &&
294: (((*s_objet_argument_2).type == INT) ||
295: ((*s_objet_argument_2).type == REL)))
296: {
297: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
298: {
299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
300: return;
301: }
302:
303: if ((*s_objet_argument_1).type == INT)
304: {
305: if ((*s_objet_argument_2).type == INT)
306: {
307: if (((*((integer8 *) (*s_objet_argument_1).objet)) != 0) ||
308: ((*((integer8 *) (*s_objet_argument_2).objet)) != 0))
309: {
310: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
311: }
312: else
313: {
314: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
315: }
316: }
317: else
318: {
319: if (((*((integer8 *) (*s_objet_argument_1).objet)) != 0) ||
320: ((*((real8 *) (*s_objet_argument_2).objet)) != 0))
321: {
322: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
323: }
324: else
325: {
326: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
327: }
328: }
329: }
330: else
331: {
332: if ((*s_objet_argument_2).type == INT)
333: {
334: if (((*((real8 *) (*s_objet_argument_1).objet)) != 0) ||
335: ((*((integer8 *) (*s_objet_argument_2).objet)) != 0))
336: {
337: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
338: }
339: else
340: {
341: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
342: }
343: }
344: else
345: {
346: if (((*((real8 *) (*s_objet_argument_1).objet)) != 0) ||
347: ((*((real8 *) (*s_objet_argument_2).objet)) != 0))
348: {
349: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
350: }
351: else
352: {
353: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
354: }
355: }
356: }
357: }
358:
359: /*
360: --------------------------------------------------------------------------------
361: OR binaire
362: --------------------------------------------------------------------------------
363: */
364:
365: else if (((*s_objet_argument_1).type == BIN) &&
366: ((*s_objet_argument_2).type == BIN))
367: {
368: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
369: {
370: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
371: return;
372: }
373:
374: (*((logical8 *) (*s_objet_resultat).objet)) =
375: (*((logical8 *) (*s_objet_argument_1).objet)) |
376: (*((logical8 *) (*s_objet_argument_2).objet));
377: }
378:
379: /*
380: --------------------------------------------------------------------------------
381: OR entre des arguments complexes
382: --------------------------------------------------------------------------------
383: */
384:
385: /*
386: * Nom ou valeur numérique / Nom ou valeur numérique
387: */
388:
389: else if ((((*s_objet_argument_1).type == NOM) &&
390: (((*s_objet_argument_2).type == NOM) ||
391: ((*s_objet_argument_2).type == INT) ||
392: ((*s_objet_argument_2).type == REL))) ||
393: (((*s_objet_argument_2).type == NOM) &&
394: (((*s_objet_argument_1).type == INT) ||
395: ((*s_objet_argument_1).type == REL))))
396: {
397: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
398: {
399: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
400: return;
401: }
402:
403: if (((*s_objet_resultat).objet =
404: allocation_maillon(s_etat_processus)) == NULL)
405: {
406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
407: return;
408: }
409:
410: l_element_courant = (*s_objet_resultat).objet;
411:
412: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
413: == NULL)
414: {
415: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
416: return;
417: }
418:
419: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
420: .nombre_arguments = 0;
421: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
422: .fonction = instruction_vers_niveau_superieur;
423:
424: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
425: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
426: {
427: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
428: return;
429: }
430:
431: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
432: .nom_fonction, "<<");
433:
434: if (((*l_element_courant).suivant =
435: allocation_maillon(s_etat_processus)) == NULL)
436: {
437: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
438: return;
439: }
440:
441: l_element_courant = (*l_element_courant).suivant;
442: (*l_element_courant).donnee = s_objet_argument_2;
443:
444: if (((*l_element_courant).suivant =
445: allocation_maillon(s_etat_processus)) == NULL)
446: {
447: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
448: return;
449: }
450:
451: l_element_courant = (*l_element_courant).suivant;
452: (*l_element_courant).donnee = s_objet_argument_1;
453:
454: if (((*l_element_courant).suivant =
455: allocation_maillon(s_etat_processus)) == NULL)
456: {
457: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
458: return;
459: }
460:
461: l_element_courant = (*l_element_courant).suivant;
462:
463: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
464: == NULL)
465: {
466: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
467: return;
468: }
469:
470: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
471: .nombre_arguments = 0;
472: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
473: .fonction = instruction_or;
474:
475: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
476: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
477: {
478: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
479: return;
480: }
481:
482: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
483: .nom_fonction, "OR");
484:
485: if (((*l_element_courant).suivant =
486: allocation_maillon(s_etat_processus)) == NULL)
487: {
488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
489: return;
490: }
491:
492: l_element_courant = (*l_element_courant).suivant;
493:
494: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
495: == NULL)
496: {
497: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
498: return;
499: }
500:
501: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
502: .nombre_arguments = 0;
503: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
504: .fonction = instruction_vers_niveau_inferieur;
505:
506: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
507: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
508: {
509: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
510: return;
511: }
512:
513: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
514: .nom_fonction, ">>");
515:
516: (*l_element_courant).suivant = NULL;
517:
518: s_objet_argument_1 = NULL;
519: s_objet_argument_2 = NULL;
520: }
521:
522: /*
523: * Nom ou valeur numérique / Expression
524: */
525:
526: else if ((((*s_objet_argument_1).type == ALG) ||
527: ((*s_objet_argument_1).type == RPN)) &&
528: (((*s_objet_argument_2).type == NOM) ||
529: ((*s_objet_argument_2).type == INT) ||
530: ((*s_objet_argument_2).type == REL)))
531: {
532: nombre_elements = 0;
533: l_element_courant = (struct_liste_chainee *)
534: (*s_objet_argument_1).objet;
535:
536: while(l_element_courant != NULL)
537: {
538: nombre_elements++;
539: l_element_courant = (*l_element_courant).suivant;
540: }
541:
542: if (nombre_elements == 2)
543: {
544: liberation(s_etat_processus, s_objet_argument_1);
545: liberation(s_etat_processus, s_objet_argument_2);
546:
547: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
548: return;
549: }
550:
551: if ((s_objet_resultat = copie_objet(s_etat_processus,
552: s_objet_argument_1, 'N')) == NULL)
553: {
554: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
555: return;
556: }
557:
558: l_element_courant = (struct_liste_chainee *)
559: (*s_objet_resultat).objet;
560: l_element_precedent = l_element_courant;
561: l_element_courant = (*l_element_courant).suivant;
562:
563: if (((*l_element_precedent).suivant =
564: allocation_maillon(s_etat_processus)) == NULL)
565: {
566: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
567: return;
568: }
569:
570: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
571: (*(*l_element_precedent).suivant).suivant = l_element_courant;
572:
573: while((*l_element_courant).suivant != NULL)
574: {
575: l_element_precedent = l_element_courant;
576: l_element_courant = (*l_element_courant).suivant;
577: }
578:
579: if (((*l_element_precedent).suivant =
580: allocation_maillon(s_etat_processus)) == NULL)
581: {
582: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
583: return;
584: }
585:
586: if (((*(*l_element_precedent).suivant).donnee =
587: allocation(s_etat_processus, FCT)) == NULL)
588: {
589: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
590: return;
591: }
592:
593: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
594: .donnee).objet)).nombre_arguments = 0;
595: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
596: .donnee).objet)).fonction = instruction_or;
597:
598: if (((*((struct_fonction *) (*(*(*l_element_precedent)
599: .suivant).donnee).objet)).nom_fonction =
600: malloc(3 * sizeof(unsigned char))) == NULL)
601: {
602: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
603: return;
604: }
605:
606: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
607: .suivant).donnee).objet)).nom_fonction, "OR");
608:
609: (*(*l_element_precedent).suivant).suivant = l_element_courant;
610:
611: s_objet_argument_2 = NULL;
612: }
613:
614: /*
615: * Expression / Nom ou valeur numérique
616: */
617:
618: else if ((((*s_objet_argument_1).type == NOM) ||
619: ((*s_objet_argument_1).type == INT) ||
620: ((*s_objet_argument_1).type == REL)) &&
621: (((*s_objet_argument_2).type == ALG) ||
622: ((*s_objet_argument_2).type == RPN)))
623: {
624: nombre_elements = 0;
625: l_element_courant = (struct_liste_chainee *)
626: (*s_objet_argument_2).objet;
627:
628: while(l_element_courant != NULL)
629: {
630: nombre_elements++;
631: l_element_courant = (*l_element_courant).suivant;
632: }
633:
634: if (nombre_elements == 2)
635: {
636: liberation(s_etat_processus, s_objet_argument_1);
637: liberation(s_etat_processus, s_objet_argument_2);
638:
639: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
640: return;
641: }
642:
643: if ((s_objet_resultat = copie_objet(s_etat_processus,
644: s_objet_argument_2, 'N')) == NULL)
645: {
646: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
647: return;
648: }
649:
650: l_element_courant = (struct_liste_chainee *)
651: (*s_objet_resultat).objet;
652: l_element_precedent = l_element_courant;
653:
654: while((*l_element_courant).suivant != NULL)
655: {
656: l_element_precedent = l_element_courant;
657: l_element_courant = (*l_element_courant).suivant;
658: }
659:
660: if (((*l_element_precedent).suivant =
661: allocation_maillon(s_etat_processus)) == NULL)
662: {
663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
664: return;
665: }
666:
667: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
668: l_element_precedent = (*l_element_precedent).suivant;
669:
670: if (((*l_element_precedent).suivant =
671: allocation_maillon(s_etat_processus)) == NULL)
672: {
673: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
674: return;
675: }
676:
677: if (((*(*l_element_precedent).suivant).donnee =
678: allocation(s_etat_processus, FCT)) == NULL)
679: {
680: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
681: return;
682: }
683:
684: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
685: .donnee).objet)).nombre_arguments = 0;
686: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
687: .donnee).objet)).fonction = instruction_or;
688:
689: if (((*((struct_fonction *) (*(*(*l_element_precedent)
690: .suivant).donnee).objet)).nom_fonction =
691: malloc(3 * sizeof(unsigned char))) == NULL)
692: {
693: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
694: return;
695: }
696:
697: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
698: .suivant).donnee).objet)).nom_fonction, "OR");
699:
700: (*(*l_element_precedent).suivant).suivant = l_element_courant;
701:
702: s_objet_argument_1 = NULL;
703: }
704:
705: /*
706: * Expression / Expression
707: */
708:
709: else if ((((*s_objet_argument_1).type == ALG) &&
710: ((*s_objet_argument_2).type == ALG)) ||
711: (((*s_objet_argument_1).type == RPN) &&
712: ((*s_objet_argument_2).type == RPN)))
713: {
714: nombre_elements = 0;
715: l_element_courant = (struct_liste_chainee *)
716: (*s_objet_argument_1).objet;
717:
718: while(l_element_courant != NULL)
719: {
720: nombre_elements++;
721: l_element_courant = (*l_element_courant).suivant;
722: }
723:
724: if (nombre_elements == 2)
725: {
726: liberation(s_etat_processus, s_objet_argument_1);
727: liberation(s_etat_processus, s_objet_argument_2);
728:
729: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
730: return;
731: }
732:
733: nombre_elements = 0;
734: l_element_courant = (struct_liste_chainee *)
735: (*s_objet_argument_2).objet;
736:
737: while(l_element_courant != NULL)
738: {
739: nombre_elements++;
740: l_element_courant = (*l_element_courant).suivant;
741: }
742:
743: if (nombre_elements == 2)
744: {
745: liberation(s_etat_processus, s_objet_argument_1);
746: liberation(s_etat_processus, s_objet_argument_2);
747:
748: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
749: return;
750: }
751:
752: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
753: s_objet_argument_1, 'N')) == NULL)
754: {
755: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
756: return;
757: }
758:
759: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
760: s_objet_argument_2, 'N')) == NULL)
761: {
762: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
763: return;
764: }
765:
766: l_element_courant = (struct_liste_chainee *)
767: (*s_copie_argument_1).objet;
768: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
769: (*s_copie_argument_1).objet)).suivant;
770:
771: liberation(s_etat_processus, (*l_element_courant).donnee);
772: free(l_element_courant);
773:
774: l_element_courant = (struct_liste_chainee *)
775: (*s_copie_argument_2).objet;
776: l_element_precedent = l_element_courant;
777: s_objet_resultat = s_copie_argument_2;
778:
779: while((*l_element_courant).suivant != NULL)
780: {
781: l_element_precedent = l_element_courant;
782: l_element_courant = (*l_element_courant).suivant;
783: }
784:
785: liberation(s_etat_processus, (*l_element_courant).donnee);
786: free(l_element_courant);
787:
788: (*l_element_precedent).suivant = (struct_liste_chainee *)
789: (*s_copie_argument_1).objet;
790: free(s_copie_argument_1);
791:
792: l_element_courant = (*l_element_precedent).suivant;
793: while((*l_element_courant).suivant != NULL)
794: {
795: l_element_precedent = l_element_courant;
796: l_element_courant = (*l_element_courant).suivant;
797: }
798:
799: if (((*l_element_precedent).suivant =
800: allocation_maillon(s_etat_processus)) == NULL)
801: {
802: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
803: return;
804: }
805:
806: (*(*l_element_precedent).suivant).suivant = l_element_courant;
807: l_element_courant = (*l_element_precedent).suivant;
808:
809: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
810: == NULL)
811: {
812: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
813: return;
814: }
815:
816: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
817: .nombre_arguments = 0;
818: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
819: .fonction = instruction_or;
820:
821: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
822: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
823: {
824: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
825: return;
826: }
827:
828: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
829: .nom_fonction, "OR");
830: }
831:
832: /*
833: --------------------------------------------------------------------------------
834: OR impossible
835: --------------------------------------------------------------------------------
836: */
837:
838: else
839: {
840: liberation(s_etat_processus, s_objet_argument_1);
841: liberation(s_etat_processus, s_objet_argument_2);
842:
843: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
844: return;
845: }
846:
847: liberation(s_etat_processus, s_objet_argument_1);
848: liberation(s_etat_processus, s_objet_argument_2);
849:
850: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
851: s_objet_resultat) == d_erreur)
852: {
853: return;
854: }
855:
856: return;
857: }
858:
859:
860: /*
861: ================================================================================
862: Fonction 'open'
863: ================================================================================
864: Entrées : pointeur sur une structure struct_processus
865: --------------------------------------------------------------------------------
866: Sorties :
867: --------------------------------------------------------------------------------
868: Effets de bord : néant
869: ================================================================================
870: */
871:
872: void
873: instruction_open(struct_processus *s_etat_processus)
874: {
875: /*
876: * Type d'ouverture :
877: * NEW : crée un nouveau fichier, retourne une erreur si un fichier
878: * préexiste ;
879: * OLD : ouvre un fichier existant, retourne une erreur si le fichier
880: * n'existe pas ;
881: * REPLACE : remplace un fichier existant, retourne une erreur s'il n'y
882: * a aucun fichier à effacer ;
883: * UNKNOWN : ouvre un fichier existant ou crée un nouveau fichier ;
884: * SCRATCH : crée un fichier temporaire automatiquement effacé lors
885: * de sa fermeture (protection automatique 'readwrite');
886: *
887: * Type d'accès :
888: * SEQUENTIAL : accès séquentiel ;
889: * DIRECT : accès direct ;
890: * KEYED : accès indexé.
891: *
892: * Protection :
893: * READONLY : lecture seule ;
894: * WRITEONLY : écriture seule ;
895: * READWRITE : lecture et écriture autorisées.
896: *
897: * Format :
898: * FORMATTED : fichier texte ;
899: * UNFORMATTED : fichier binaire.
900: */
901:
902: file *descripteur;
903:
904: int buffer_emission;
905: int buffer_reception;
906: int drapeau;
907: int priorite;
908: int protocole_numerique;
909: int timeout_emission;
910: int timeout_reception;
911: int type;
912:
913: integer8 adresse[16];
914: integer8 nombre_maximal_connexions;
915: integer8 port;
916: integer8 position_clef;
917:
918: logical1 erreur;
919: logical1 existence;
920: logical1 ouverture;
921: logical1 presence_port;
922:
923: sqlite3 *sqlite;
924:
925: struct_liste_chainee *l_element_courant;
926: struct_liste_chainee *l_element_courant_sous_objet;
927:
928: struct flock lock;
929:
930: struct addrinfo *resolution;
931: struct addrinfo *resolution_courante;
932:
933: struct protoent *s_protocole;
934:
935: struct sockaddr_un socket_unix;
936: struct sockaddr_in socket_ipv4;
937: struct sockaddr_in6 socket_ipv6;
938:
939: struct_objet *s_objet_argument;
940: struct_objet *s_objet_resultat;
941:
942: uint32_t adresse_ipv4;
943:
944: unsigned char *argument_majuscule;
945: unsigned char *chaine_descripteurs;
946: unsigned char format;
947: unsigned char *hote;
948: unsigned char *nom;
949: unsigned char *nom_temporaire;
950: unsigned char options[12];
951: unsigned char *peripherique;
952: unsigned char *pointeur;
953: unsigned char protection;
954: unsigned char protocole[16 + 1];
955: unsigned char *protocole_socket;
956: unsigned char type_acces;
957: unsigned char type_adresse;
958: unsigned char type_arguments;
959: unsigned char type_domaine;
960: unsigned char type_ouverture;
961: unsigned char type_socket;
962:
963: unsigned long i;
964: unsigned long nombre_elements;
965: unsigned long prochain_descripteur;
966: unsigned long unite;
967:
968: # define d_BIND_TO_DEVICE 0
969: # define d_BROADCAST 1
970: # define d_DONT_ROUTE 2
971: # define d_KEEP_ALIVE 3
972: # define d_PRIORITY 4
973: # define d_RECEIVE_BUFFER 5
974: # define d_FORCE_RECEIVE_BUFFER 6
975: # define d_SEND_BUFFER 7
976: # define d_FORCE_SEND_BUFFER 8
977: # define d_RECEIVING_TIMEOUT 9
978: # define d_SENDING_TIMEOUT 10
979: # define d_REUSE_ADDRESS 11
980:
981: /*
982: * Argument : { "ouverture" "accès" "format" [ { "nom" } 'protection' ] }
983: */
984:
985: (*s_etat_processus).erreur_execution = d_ex;
986:
987: if ((*s_etat_processus).affichage_arguments == 'Y')
988: {
989: printf("\n OPEN ");
990:
991: if ((*s_etat_processus).langue == 'F')
992: {
993: printf("(ouverture d'un fichier, d'une socket ou d'un sémaphore)"
994: "\n\n");
995: }
996: else
997: {
998: printf("(open file, socket or semaphore)\n\n");
999: }
1000:
1001: printf(" 1: %s\n", d_LST);
1002: printf("-> 1: %s, %s\n\n", d_FCH, d_SCK);
1003:
1004: printf(" 1: %s\n", d_CHN);
1005: printf("-> 1: %s\n\n", d_SPH);
1006:
1007: if ((*s_etat_processus).langue == 'F')
1008: {
1009: printf(" Utilisation :\n\n");
1010: }
1011: else
1012: {
1013: printf(" Usage:\n\n");
1014: }
1015:
1016: printf(" { \"filetype\" \"access\" \"format\" { \"name\" "
1017: "\"file name\" } \"protection\" } OPEN\n");
1018: printf(" { \"sockettype\" { \"name\" \"local name\" } } OPEN\n");
1019: printf(" { \"sockettype\" \"socketdomain\" \"protection\" } OPEN\n");
1020:
1021: printf(" File type : NEW/OLD/REPLACE/UNKNOWN/SCRATCH\n");
1022: printf(" File access : SEQUENTIAL/DIRECT/KEYED\n");
1023: printf(" Socket type : STREAM/DATAGRAM/RAW/"
1024: "ROBUST DATAGRAM/SEQUENTIAL DATAGRAM\n");
1025: printf(" Socket domain : LOCAL/FOREIGN\n");
1026: printf(" Socket protocol : IPV4/IPV6/UNIX\n");
1027: printf(" Format : FORMATTED/UNFORMATTED/FLOW\n");
1028: printf(" Protection : READONLY/WRITEONLY/READWRITE\n\n");
1029:
1030: printf(" Address : { \"ADDRESS\" [ 127 0 0 1 ] }\n");
1031: printf(" { \"HOST\" \"hostname\" }\n");
1032: printf(" Connections : { \"LISTEN\" amount of connections }\n");
1033: printf(" Name : { \"NAME\" \"filename\" }\n");
1034: printf(" Options : { \"OPTION\" \"option\" argument }\n");
1035: printf(" \"BIND TO DEVICE\" \"device\"\n");
1036: printf(" \"BROADCAST\"\n");
1037: printf(" \"DO NOT ROUTE\"\n");
1038: printf(" \"KEEP ALIVE\"\n");
1039: printf(" \"PRIORITY\" integer\n");
1040: printf(" \"RECEIVE BUFFER\" integer\n");
1041: printf(" \"FORCE RECEIVE BUFFER\" integer\n");
1042: printf(" \"SEND BUFFER\" integer\n");
1043: printf(" \"FORCE SEND BUFFER\" integer\n");
1044: printf(" \"RECEIVING TIMEOUT\" integer\n");
1045: printf(" \"SENDING TIMEOUT\" integer\n");
1046: printf(" \"REUSE ADDRESS\"\n");
1047: printf(" Port : { \"PORT\" port number }\n");
1048: printf(" Protocol : { \"PROTOCOL\" \"protocol\" }\n\n");
1049:
1050: printf(" { { \"NAME\" \"filename\" } } OPEN\n");
1051: printf(" { \"SCRATCH\" } OPEN\n");
1052: printf(" { { \"NAME\" \"filename\" } \"UNKNOWN\" \"FORMATTED\" "
1053: "\"DIRECT\" } OPEN\n");
1054: printf(" { { \"NAME\" \"filename\" } \"OLD\" \"FORMATTED\" "
1055: "\"KEYED\" { \"KEY\" 2 } } OPEN\n");
1056: printf(" { \"STREAM\" \"READWRITE\" } OPEN\n");
1057: printf(" { \"FOREIGN\" \"DATAGRAM\" } OPEN\n");
1058: printf(" { \"LOCAL\" { \"NAME\" \"socket.sock\" } } OPEN\n");
1059:
1060: return;
1061: }
1062: else if ((*s_etat_processus).test_instruction == 'Y')
1063: {
1064: (*s_etat_processus).nombre_arguments = -1;
1065: return;
1066: }
1067:
1068: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1069: {
1070: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1071: {
1072: return;
1073: }
1074: }
1075:
1076: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1077: &s_objet_argument) == d_erreur)
1078: {
1079: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1080: return;
1081: }
1082:
1083: if ((*s_objet_argument).type == LST)
1084: {
1085: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
1086:
1087: if (l_element_courant == NULL)
1088: {
1089: liberation(s_etat_processus, s_objet_argument);
1090:
1091: (*s_etat_processus).erreur_execution =
1092: d_ex_erreur_parametre_fichier;
1093: return;
1094: }
1095:
1096: format = ' ';
1097: type_domaine = ' ';
1098: type_ouverture = ' ';
1099: protection = ' ';
1100: type_acces = ' ';
1101: type_socket = ' ';
1102: nom = NULL;
1103: position_clef = 0;
1104: port = 0;
1105: type_arguments = ' ';
1106: nombre_maximal_connexions = 0;
1107: hote = NULL;
1108: type_adresse = ' ';
1109: protocole[0] = d_code_fin_chaine;
1110: protocole_socket = NULL;
1111: presence_port = d_faux;
1112: peripherique = NULL;
1113: priorite = 0;
1114: buffer_emission = 0;
1115: buffer_reception = 0;
1116: timeout_emission = 0;
1117: timeout_reception = 0;
1118: drapeau = -1;
1119:
1120: for(i = 0; i < 12; options[i++] = 'N');
1121:
1122: while(l_element_courant != NULL)
1123: {
1124: if ((*(*l_element_courant).donnee).type == CHN)
1125: {
1126: if ((argument_majuscule = conversion_majuscule((unsigned char *)
1127: (*(*l_element_courant).donnee).objet)) == NULL)
1128: {
1129: (*s_etat_processus).erreur_systeme =
1130: d_es_allocation_memoire;
1131: return;
1132: }
1133:
1134: if (strcmp(argument_majuscule, "NEW") == 0)
1135: {
1136: if (type_ouverture != ' ')
1137: {
1138: liberation(s_etat_processus, s_objet_argument);
1139: free(argument_majuscule);
1140:
1141: (*s_etat_processus).erreur_execution =
1142: d_ex_erreur_parametre_fichier;
1143: return;
1144: }
1145:
1146: if (type_arguments == ' ')
1147: {
1148: type_arguments = 'F';
1149: }
1150: else if (type_arguments == 'S')
1151: {
1152: liberation(s_etat_processus, s_objet_argument);
1153: free(argument_majuscule);
1154:
1155: (*s_etat_processus).erreur_execution =
1156: d_ex_erreur_parametre_fichier;
1157: return;
1158: }
1159:
1160: type_ouverture = 'N';
1161: }
1162: else if (strcmp(argument_majuscule, "REPLACE") == 0)
1163: {
1164: if (type_ouverture != ' ')
1165: {
1166: liberation(s_etat_processus, s_objet_argument);
1167: free(argument_majuscule);
1168:
1169: (*s_etat_processus).erreur_execution =
1170: d_ex_erreur_parametre_fichier;
1171: return;
1172: }
1173:
1174: if (type_arguments == ' ')
1175: {
1176: type_arguments = 'F';
1177: }
1178: else if (type_arguments == 'S')
1179: {
1180: liberation(s_etat_processus, s_objet_argument);
1181: free(argument_majuscule);
1182:
1183: (*s_etat_processus).erreur_execution =
1184: d_ex_erreur_parametre_fichier;
1185: return;
1186: }
1187:
1188: type_ouverture = 'R';
1189: }
1190: else if (strcmp(argument_majuscule, "UNKNOWN") == 0)
1191: {
1192: if (type_ouverture != ' ')
1193: {
1194: liberation(s_etat_processus, s_objet_argument);
1195: free(argument_majuscule);
1196:
1197: (*s_etat_processus).erreur_execution =
1198: d_ex_erreur_parametre_fichier;
1199: return;
1200: }
1201:
1202: if (type_arguments == ' ')
1203: {
1204: type_arguments = 'F';
1205: }
1206: else if (type_arguments == 'S')
1207: {
1208: liberation(s_etat_processus, s_objet_argument);
1209: free(argument_majuscule);
1210:
1211: (*s_etat_processus).erreur_execution =
1212: d_ex_erreur_parametre_fichier;
1213: return;
1214: }
1215:
1216: type_ouverture = 'U';
1217: }
1218: else if (strcmp(argument_majuscule, "SCRATCH") == 0)
1219: {
1220: if (type_ouverture != ' ')
1221: {
1222: liberation(s_etat_processus, s_objet_argument);
1223: free(argument_majuscule);
1224:
1225: (*s_etat_processus).erreur_execution =
1226: d_ex_erreur_parametre_fichier;
1227: return;
1228: }
1229:
1230: if (type_arguments == ' ')
1231: {
1232: type_arguments = 'F';
1233: }
1234: else if (type_arguments == 'S')
1235: {
1236: liberation(s_etat_processus, s_objet_argument);
1237: free(argument_majuscule);
1238:
1239: (*s_etat_processus).erreur_execution =
1240: d_ex_erreur_parametre_fichier;
1241: return;
1242: }
1243:
1244: type_ouverture = 'S';
1245: }
1246: else if (strcmp(argument_majuscule, "SEQUENTIAL") == 0)
1247: {
1248: if (type_acces != ' ')
1249: {
1250: liberation(s_etat_processus, s_objet_argument);
1251: free(argument_majuscule);
1252:
1253: (*s_etat_processus).erreur_execution =
1254: d_ex_erreur_parametre_fichier;
1255: return;
1256: }
1257:
1258: if (type_arguments == ' ')
1259: {
1260: type_arguments = 'F';
1261: }
1262: else if (type_arguments == 'S')
1263: {
1264: liberation(s_etat_processus, s_objet_argument);
1265: free(argument_majuscule);
1266:
1267: (*s_etat_processus).erreur_execution =
1268: d_ex_erreur_parametre_fichier;
1269: return;
1270: }
1271:
1272: type_acces = 'S';
1273: }
1274: else if (strcmp(argument_majuscule, "DIRECT") == 0)
1275: {
1276: if (type_acces != ' ')
1277: {
1278: liberation(s_etat_processus, s_objet_argument);
1279: free(argument_majuscule);
1280:
1281: (*s_etat_processus).erreur_execution =
1282: d_ex_erreur_parametre_fichier;
1283: return;
1284: }
1285:
1286: if (type_arguments == ' ')
1287: {
1288: type_arguments = 'F';
1289: }
1290: else if (type_arguments == 'S')
1291: {
1292: liberation(s_etat_processus, s_objet_argument);
1293: free(argument_majuscule);
1294:
1295: (*s_etat_processus).erreur_execution =
1296: d_ex_erreur_parametre_fichier;
1297: return;
1298: }
1299:
1300: type_acces = 'D';
1301: }
1302: else if (strcmp(argument_majuscule, "KEYED") == 0)
1303: {
1304: if (type_acces != ' ')
1305: {
1306: liberation(s_etat_processus, s_objet_argument);
1307: free(argument_majuscule);
1308:
1309: (*s_etat_processus).erreur_execution =
1310: d_ex_erreur_parametre_fichier;
1311: return;
1312: }
1313:
1314: if (type_arguments == ' ')
1315: {
1316: type_arguments = 'F';
1317: }
1318: else if (type_arguments == 'S')
1319: {
1320: liberation(s_etat_processus, s_objet_argument);
1321: free(argument_majuscule);
1322:
1323: (*s_etat_processus).erreur_execution =
1324: d_ex_erreur_parametre_fichier;
1325: return;
1326: }
1327:
1328: type_acces = 'I';
1329: }
1330: else if (strcmp(argument_majuscule, "READONLY") == 0)
1331: {
1332: if (protection != ' ')
1333: {
1334: liberation(s_etat_processus, s_objet_argument);
1335: free(argument_majuscule);
1336:
1337: (*s_etat_processus).erreur_execution =
1338: d_ex_erreur_parametre_fichier;
1339: return;
1340: }
1341:
1342: protection = 'R';
1343: }
1344: else if (strcmp(argument_majuscule, "WRITEONLY") == 0)
1345: {
1346: if (protection != ' ')
1347: {
1348: liberation(s_etat_processus, s_objet_argument);
1349: free(argument_majuscule);
1350:
1351: (*s_etat_processus).erreur_execution =
1352: d_ex_erreur_parametre_fichier;
1353: return;
1354: }
1355:
1356: protection = 'W';
1357: }
1358: else if (strcmp(argument_majuscule, "READWRITE") == 0)
1359: {
1360: if (protection != ' ')
1361: {
1362: liberation(s_etat_processus, s_objet_argument);
1363: free(argument_majuscule);
1364:
1365: (*s_etat_processus).erreur_execution =
1366: d_ex_erreur_parametre_fichier;
1367: return;
1368: }
1369:
1370: protection = 'N';
1371: }
1372: else if (strcmp(argument_majuscule, "FORMATTED") == 0)
1373: {
1374: if (format != ' ')
1375: {
1376: liberation(s_etat_processus, s_objet_argument);
1377: free(argument_majuscule);
1378:
1379: (*s_etat_processus).erreur_execution =
1380: d_ex_erreur_parametre_fichier;
1381: return;
1382: }
1383:
1384: format = 'N';
1385: }
1386: else if (strcmp(argument_majuscule, "UNFORMATTED") == 0)
1387: {
1388: if (format != ' ')
1389: {
1390: liberation(s_etat_processus, s_objet_argument);
1391: free(argument_majuscule);
1392:
1393: (*s_etat_processus).erreur_execution =
1394: d_ex_erreur_parametre_fichier;
1395: return;
1396: }
1397:
1398: format = 'Y';
1399: }
1400: else if (strcmp(argument_majuscule, "FLOW") == 0)
1401: {
1402: if (format != ' ')
1403: {
1404: liberation(s_etat_processus, s_objet_argument);
1405: free(argument_majuscule);
1406:
1407: (*s_etat_processus).erreur_execution =
1408: d_ex_erreur_parametre_fichier;
1409: return;
1410: }
1411:
1412: format = 'F';
1413: }
1414: else if (strcmp(argument_majuscule, "STREAM") == 0)
1415: {
1416: if (type_socket != ' ')
1417: {
1418: liberation(s_etat_processus, s_objet_argument);
1419: free(argument_majuscule);
1420:
1421: (*s_etat_processus).erreur_execution =
1422: d_ex_erreur_parametre_fichier;
1423: return;
1424: }
1425:
1426: if (type_arguments == ' ')
1427: {
1428: type_arguments = 'S';
1429: }
1430: else if (type_arguments == 'F')
1431: {
1432: liberation(s_etat_processus, s_objet_argument);
1433: free(argument_majuscule);
1434:
1435: (*s_etat_processus).erreur_execution =
1436: d_ex_erreur_parametre_fichier;
1437: return;
1438: }
1439:
1440: type_socket = 'S';
1441: }
1442: else if (strcmp(argument_majuscule, "DATAGRAM") == 0)
1443: {
1444: if (type_socket != ' ')
1445: {
1446: liberation(s_etat_processus, s_objet_argument);
1447: free(argument_majuscule);
1448:
1449: (*s_etat_processus).erreur_execution =
1450: d_ex_erreur_parametre_fichier;
1451: return;
1452: }
1453:
1454: type_socket = 'D';
1455: }
1456: else if (strcmp(argument_majuscule, "SEQUENTIAL DATAGRAM") == 0)
1457: {
1458: if (type_socket != ' ')
1459: {
1460: liberation(s_etat_processus, s_objet_argument);
1461: free(argument_majuscule);
1462:
1463: (*s_etat_processus).erreur_execution =
1464: d_ex_erreur_parametre_fichier;
1465: return;
1466: }
1467:
1468: if (type_arguments == ' ')
1469: {
1470: type_arguments = 'S';
1471: }
1472: else if (type_arguments == 'F')
1473: {
1474: liberation(s_etat_processus, s_objet_argument);
1475: free(argument_majuscule);
1476:
1477: (*s_etat_processus).erreur_execution =
1478: d_ex_erreur_parametre_fichier;
1479: return;
1480: }
1481:
1482: type_socket = 'Q';
1483: }
1484: else if (strcmp(argument_majuscule, "RAW") == 0)
1485: {
1486: if (type_socket != ' ')
1487: {
1488: liberation(s_etat_processus, s_objet_argument);
1489: free(argument_majuscule);
1490:
1491: (*s_etat_processus).erreur_execution =
1492: d_ex_erreur_parametre_fichier;
1493: return;
1494: }
1495:
1496: if (type_arguments == ' ')
1497: {
1498: type_arguments = 'S';
1499: }
1500: else if (type_arguments == 'F')
1501: {
1502: liberation(s_etat_processus, s_objet_argument);
1503: free(argument_majuscule);
1504:
1505: (*s_etat_processus).erreur_execution =
1506: d_ex_erreur_parametre_fichier;
1507: return;
1508: }
1509:
1510: type_socket = 'R';
1511: }
1512: else if (strcmp(argument_majuscule, "ROBUST DATAGRAM") == 0)
1513: {
1514: if (type_socket != ' ')
1515: {
1516: liberation(s_etat_processus, s_objet_argument);
1517: free(argument_majuscule);
1518:
1519: (*s_etat_processus).erreur_execution =
1520: d_ex_erreur_parametre_fichier;
1521: return;
1522: }
1523:
1524: if (type_arguments == ' ')
1525: {
1526: type_arguments = 'S';
1527: }
1528: else if (type_arguments == 'F')
1529: {
1530: liberation(s_etat_processus, s_objet_argument);
1531: free(argument_majuscule);
1532:
1533: (*s_etat_processus).erreur_execution =
1534: d_ex_erreur_parametre_fichier;
1535: return;
1536: }
1537:
1538: type_socket = 'M';
1539: }
1540: else if (strcmp(argument_majuscule, "LOCAL") == 0)
1541: {
1542: if (type_domaine != ' ')
1543: {
1544: liberation(s_etat_processus, s_objet_argument);
1545: free(argument_majuscule);
1546:
1547: (*s_etat_processus).erreur_execution =
1548: d_ex_erreur_parametre_fichier;
1549: return;
1550: }
1551:
1552: if (type_arguments == ' ')
1553: {
1554: type_arguments = 'S';
1555: }
1556: else if (type_arguments == 'F')
1557: {
1558: liberation(s_etat_processus, s_objet_argument);
1559: free(argument_majuscule);
1560:
1561: (*s_etat_processus).erreur_execution =
1562: d_ex_erreur_parametre_fichier;
1563: return;
1564: }
1565:
1566: type_domaine = 'L';
1567: }
1568: else if (strcmp(argument_majuscule, "FOREIGN") == 0)
1569: {
1570: if (type_domaine != ' ')
1571: {
1572: liberation(s_etat_processus, s_objet_argument);
1573: free(argument_majuscule);
1574:
1575: (*s_etat_processus).erreur_execution =
1576: d_ex_erreur_parametre_fichier;
1577: return;
1578: }
1579:
1580: if (type_arguments == ' ')
1581: {
1582: type_arguments = 'S';
1583: }
1584: else if (type_arguments == 'F')
1585: {
1586: liberation(s_etat_processus, s_objet_argument);
1587: free(argument_majuscule);
1588:
1589: (*s_etat_processus).erreur_execution =
1590: d_ex_erreur_parametre_fichier;
1591: return;
1592: }
1593:
1594: type_domaine = 'F';
1595: }
1596: else if (strcmp(argument_majuscule, "IPV4") == 0)
1597: {
1598: if (strcmp(protocole, "") != 0)
1599: {
1600: liberation(s_etat_processus, s_objet_argument);
1601: free(argument_majuscule);
1602:
1603: (*s_etat_processus).erreur_execution =
1604: d_ex_erreur_parametre_fichier;
1605: return;
1606: }
1607:
1608: if (type_arguments == ' ')
1609: {
1610: type_arguments = 'S';
1611: }
1612: else if (type_arguments == 'F')
1613: {
1614: liberation(s_etat_processus, s_objet_argument);
1615: free(argument_majuscule);
1616:
1617: (*s_etat_processus).erreur_execution =
1618: d_ex_erreur_parametre_fichier;
1619: return;
1620: }
1621:
1622: strcpy(protocole, "IPV4");
1623: }
1624: else if (strcmp(argument_majuscule, "IPV6") == 0)
1625: {
1626: if (strcmp(protocole, "") != 0)
1627: {
1628: liberation(s_etat_processus, s_objet_argument);
1629: free(argument_majuscule);
1630:
1631: (*s_etat_processus).erreur_execution =
1632: d_ex_erreur_parametre_fichier;
1633: return;
1634: }
1635:
1636: if (type_arguments == ' ')
1637: {
1638: type_arguments = 'S';
1639: }
1640: else if (type_arguments == 'F')
1641: {
1642: liberation(s_etat_processus, s_objet_argument);
1643: free(argument_majuscule);
1644:
1645: (*s_etat_processus).erreur_execution =
1646: d_ex_erreur_parametre_fichier;
1647: return;
1648: }
1649:
1650: strcpy(protocole, "IPV6");
1651: }
1652: else if (strcmp(argument_majuscule, "UNIX") == 0)
1653: {
1654: if (strcmp(protocole, "") != 0)
1655: {
1656: liberation(s_etat_processus, s_objet_argument);
1657: free(argument_majuscule);
1658:
1659: (*s_etat_processus).erreur_execution =
1660: d_ex_erreur_parametre_fichier;
1661: return;
1662: }
1663:
1664: if (type_arguments == ' ')
1665: {
1666: type_arguments = 'S';
1667: }
1668: else if (type_arguments == 'F')
1669: {
1670: liberation(s_etat_processus, s_objet_argument);
1671: free(argument_majuscule);
1672:
1673: (*s_etat_processus).erreur_execution =
1674: d_ex_erreur_parametre_fichier;
1675: return;
1676: }
1677:
1678: strcpy(protocole, "UNIX");
1679: }
1680: else
1681: {
1682: liberation(s_etat_processus, s_objet_argument);
1683: free(argument_majuscule);
1684:
1685: (*s_etat_processus).erreur_execution =
1686: d_ex_erreur_parametre_fichier;
1687: return;
1688: }
1689:
1690: free(argument_majuscule);
1691: }
1692: else if ((*(*l_element_courant).donnee).type == LST)
1693: {
1694: l_element_courant_sous_objet =
1695: (*(*l_element_courant).donnee).objet;
1696:
1697: nombre_elements = 0;
1698: while(l_element_courant_sous_objet != NULL)
1699: {
1700: nombre_elements++;
1701: l_element_courant_sous_objet =
1702: (*l_element_courant_sous_objet).suivant;
1703: }
1704:
1705: l_element_courant_sous_objet =
1706: (*(*l_element_courant).donnee).objet;
1707:
1708: if (nombre_elements == 2)
1709: {
1710: if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
1711: {
1712: if ((argument_majuscule = conversion_majuscule(
1713: (unsigned char *)
1714: (*(*l_element_courant_sous_objet)
1715: .donnee).objet)) == NULL)
1716: {
1717: (*s_etat_processus).erreur_systeme =
1718: d_es_allocation_memoire;
1719: return;
1720: }
1721:
1722: l_element_courant_sous_objet =
1723: (*l_element_courant_sous_objet).suivant;
1724:
1725: if (strcmp(argument_majuscule, "NAME") == 0)
1726: {
1727: if ((*(*l_element_courant_sous_objet).donnee).type
1728: == CHN)
1729: {
1730: if (nom != NULL)
1731: {
1732: liberation(s_etat_processus,
1733: s_objet_argument);
1734: free(argument_majuscule);
1735:
1736: (*s_etat_processus).erreur_execution =
1737: d_ex_erreur_parametre_fichier;
1738: return;
1739: }
1740:
1741: nom = (unsigned char *)
1742: (*(*l_element_courant_sous_objet)
1743: .donnee).objet;
1744: }
1745: else
1746: {
1747: liberation(s_etat_processus, s_objet_argument);
1748: free(argument_majuscule);
1749:
1750: (*s_etat_processus).erreur_execution =
1751: d_ex_erreur_parametre_fichier;
1752: return;
1753: }
1754: }
1755: else if (strcmp(argument_majuscule, "OPTION") == 0)
1756: {
1757: if ((*(*l_element_courant_sous_objet).donnee).type
1758: == CHN)
1759: {
1760: if (type_arguments == ' ')
1761: {
1762: type_arguments = 'S';
1763: }
1764: else if (type_arguments == 'F')
1765: {
1766: liberation(s_etat_processus,
1767: s_objet_argument);
1768: free(argument_majuscule);
1769:
1770: (*s_etat_processus).erreur_execution =
1771: d_ex_erreur_parametre_fichier;
1772: return;
1773: }
1774: }
1775:
1776: free(argument_majuscule);
1777:
1778: if ((argument_majuscule = conversion_majuscule(
1779: (unsigned char *)
1780: (*(*l_element_courant_sous_objet)
1781: .donnee).objet)) == NULL)
1782: {
1783: (*s_etat_processus).erreur_systeme =
1784: d_es_allocation_memoire;
1785: return;
1786: }
1787:
1788: if (strcmp(argument_majuscule, "BROADCAST") == 0)
1789: {
1790: if (options[d_BROADCAST] == 'Y')
1791: {
1792: liberation(s_etat_processus,
1793: s_objet_argument);
1794: free(argument_majuscule);
1795:
1796: (*s_etat_processus).erreur_execution =
1797: d_ex_erreur_parametre_fichier;
1798: return;
1799: }
1800:
1801: options[d_BROADCAST] = 'Y';
1802: }
1803: else if (strcmp(argument_majuscule, "DO NOT ROUTE")
1804: == 0)
1805: {
1806: if (options[d_DONT_ROUTE] == 'Y')
1807: {
1808: liberation(s_etat_processus,
1809: s_objet_argument);
1810: free(argument_majuscule);
1811:
1812: (*s_etat_processus).erreur_execution =
1813: d_ex_erreur_parametre_fichier;
1814: return;
1815: }
1816:
1817: options[d_DONT_ROUTE] = 'Y';
1818: }
1819: else if (strcmp(argument_majuscule, "KEEP ALIVE")
1820: == 0)
1821: {
1822: if (options[d_KEEP_ALIVE] == 'Y')
1823: {
1824: liberation(s_etat_processus,
1825: s_objet_argument);
1826: free(argument_majuscule);
1827:
1828: (*s_etat_processus).erreur_execution =
1829: d_ex_erreur_parametre_fichier;
1830: return;
1831: }
1832:
1833: options[d_KEEP_ALIVE] = 'Y';
1834: }
1835: else if (strcmp(argument_majuscule, "REUSE ADDRESS")
1836: == 0)
1837: {
1838: if (options[d_REUSE_ADDRESS] == 'Y')
1839: {
1840: liberation(s_etat_processus,
1841: s_objet_argument);
1842: free(argument_majuscule);
1843:
1844: (*s_etat_processus).erreur_execution =
1845: d_ex_erreur_parametre_fichier;
1846: return;
1847: }
1848:
1849: options[d_REUSE_ADDRESS] = 'Y';
1850: }
1851: else
1852: {
1853: liberation(s_etat_processus,
1854: s_objet_argument);
1855: free(argument_majuscule);
1856:
1857: (*s_etat_processus).erreur_execution =
1858: d_ex_erreur_parametre_fichier;
1859: return;
1860: }
1861: }
1862: else if (strcmp(argument_majuscule, "HOST") == 0)
1863: {
1864: if ((*(*l_element_courant_sous_objet).donnee).type
1865: == CHN)
1866: {
1867: if (type_arguments == ' ')
1868: {
1869: type_arguments = 'S';
1870: }
1871: else if (type_arguments == 'F')
1872: {
1873: liberation(s_etat_processus,
1874: s_objet_argument);
1875: free(argument_majuscule);
1876:
1877: (*s_etat_processus).erreur_execution =
1878: d_ex_erreur_parametre_fichier;
1879: return;
1880: }
1881:
1882: if (hote != NULL)
1883: {
1884: liberation(s_etat_processus,
1885: s_objet_argument);
1886: free(argument_majuscule);
1887:
1888: (*s_etat_processus).erreur_execution =
1889: d_ex_erreur_parametre_fichier;
1890: return;
1891: }
1892:
1893: hote = (unsigned char *)
1894: (*(*l_element_courant_sous_objet)
1895: .donnee).objet;
1896: }
1897: else
1898: {
1899: liberation(s_etat_processus,
1900: s_objet_argument);
1901: free(argument_majuscule);
1902:
1903: (*s_etat_processus).erreur_execution =
1904: d_ex_erreur_parametre_fichier;
1905: return;
1906: }
1907: }
1908: else if (strcmp(argument_majuscule, "PROTOCOL") == 0)
1909: {
1910: if ((*(*l_element_courant_sous_objet).donnee).type
1911: == CHN)
1912: {
1913: if (type_arguments == ' ')
1914: {
1915: type_arguments = 'S';
1916: }
1917: else if (type_arguments == 'F')
1918: {
1919: liberation(s_etat_processus,
1920: s_objet_argument);
1921: free(argument_majuscule);
1922:
1923: (*s_etat_processus).erreur_execution =
1924: d_ex_erreur_parametre_fichier;
1925: return;
1926: }
1927:
1928: if (protocole_socket != NULL)
1929: {
1930: liberation(s_etat_processus,
1931: s_objet_argument);
1932: free(argument_majuscule);
1933:
1934: (*s_etat_processus).erreur_execution =
1935: d_ex_erreur_parametre_fichier;
1936: return;
1937: }
1938:
1939: protocole_socket = (unsigned char *)
1940: (*(*l_element_courant_sous_objet)
1941: .donnee).objet;
1942: }
1943: else
1944: {
1945: liberation(s_etat_processus, s_objet_argument);
1946: free(argument_majuscule);
1947:
1948: (*s_etat_processus).erreur_execution =
1949: d_ex_erreur_parametre_fichier;
1950: return;
1951: }
1952: }
1953: else if (strcmp(argument_majuscule, "KEY") == 0)
1954: {
1955: if ((*(*l_element_courant_sous_objet).donnee).type
1956: == INT)
1957: {
1958: if (type_arguments == ' ')
1959: {
1960: type_arguments = 'F';
1961: }
1962: else if (type_arguments == 'S')
1963: {
1964: liberation(s_etat_processus,
1965: s_objet_argument);
1966: free(argument_majuscule);
1967:
1968: (*s_etat_processus).erreur_execution =
1969: d_ex_erreur_parametre_fichier;
1970: return;
1971: }
1972:
1973: if (position_clef != 0)
1974: {
1975: liberation(s_etat_processus,
1976: s_objet_argument);
1977:
1978: (*s_etat_processus).erreur_execution =
1979: d_ex_erreur_parametre_fichier;
1980: return;
1981: }
1982: else
1983: {
1984: if ((position_clef = (*((integer8 *)
1985: (*(*l_element_courant_sous_objet)
1986: .donnee).objet))) <= 0)
1987: {
1988: liberation(s_etat_processus,
1989: s_objet_argument);
1990:
1991: (*s_etat_processus).erreur_execution =
1992: d_ex_erreur_parametre_fichier;
1993: return;
1994: }
1995: }
1996: }
1997: else
1998: {
1999: liberation(s_etat_processus, s_objet_argument);
2000: free(argument_majuscule);
2001:
2002: (*s_etat_processus).erreur_execution =
2003: d_ex_erreur_parametre_fichier;
2004: return;
2005: }
2006: }
2007: else if (strcmp(argument_majuscule, "PORT") == 0)
2008: {
2009: if ((*(*l_element_courant_sous_objet)
2010: .donnee).type == INT)
2011: {
2012: if (type_arguments == ' ')
2013: {
2014: type_arguments = 'S';
2015: }
2016: else if (type_arguments == 'F')
2017: {
2018: liberation(s_etat_processus,
2019: s_objet_argument);
2020: free(argument_majuscule);
2021:
2022: (*s_etat_processus).erreur_execution =
2023: d_ex_erreur_parametre_fichier;
2024: return;
2025: }
2026:
2027: if (presence_port == d_vrai)
2028: {
2029: liberation(s_etat_processus,
2030: s_objet_argument);
2031:
2032: (*s_etat_processus).erreur_execution =
2033: d_ex_erreur_parametre_fichier;
2034: return;
2035: }
2036: else
2037: {
2038: presence_port = d_vrai;
2039:
2040: if ((port = (*((integer8 *)
2041: (*(*l_element_courant_sous_objet)
2042: .donnee).objet))) < 0)
2043: {
2044: liberation(s_etat_processus,
2045: s_objet_argument);
2046:
2047: (*s_etat_processus).erreur_execution =
2048: d_ex_erreur_parametre_fichier;
2049: return;
2050: }
2051:
2052: if (port > 65535)
2053: {
2054: liberation(s_etat_processus,
2055: s_objet_argument);
2056:
2057: (*s_etat_processus).erreur_execution =
2058: d_ex_erreur_parametre_fichier;
2059: return;
2060: }
2061: }
2062: }
2063: else
2064: {
2065: liberation(s_etat_processus, s_objet_argument);
2066: free(argument_majuscule);
2067:
2068: (*s_etat_processus).erreur_execution =
2069: d_ex_erreur_parametre_fichier;
2070: return;
2071: }
2072: }
2073: else if (strcmp(argument_majuscule, "LISTEN") == 0)
2074: {
2075: if ((*(*l_element_courant_sous_objet).donnee).type
2076: == INT)
2077: {
2078: if (type_arguments == ' ')
2079: {
2080: type_arguments = 'S';
2081: }
2082: else if (type_arguments == 'F')
2083: {
2084: liberation(s_etat_processus,
2085: s_objet_argument);
2086: free(argument_majuscule);
2087:
2088: (*s_etat_processus).erreur_execution =
2089: d_ex_erreur_parametre_fichier;
2090: return;
2091: }
2092:
2093: if (nombre_maximal_connexions != 0)
2094: {
2095: liberation(s_etat_processus,
2096: s_objet_argument);
2097:
2098: (*s_etat_processus).erreur_execution =
2099: d_ex_erreur_parametre_fichier;
2100: return;
2101: }
2102: else
2103: {
2104: if ((nombre_maximal_connexions =
2105: (*((integer8 *)
2106: (*(*l_element_courant_sous_objet)
2107: .donnee).objet))) <= 0)
2108: {
2109: liberation(s_etat_processus,
2110: s_objet_argument);
2111:
2112: (*s_etat_processus).erreur_execution =
2113: d_ex_erreur_parametre_fichier;
2114: return;
2115: }
2116: }
2117: }
2118: }
2119: else if (strcmp(argument_majuscule, "ADDRESS") == 0)
2120: {
2121: if ((*(*l_element_courant_sous_objet)
2122: .donnee).type == VIN)
2123: {
2124: if (type_arguments == ' ')
2125: {
2126: type_arguments = 'S';
2127: }
2128: else if (type_arguments == 'F')
2129: {
2130: liberation(s_etat_processus,
2131: s_objet_argument);
2132: free(argument_majuscule);
2133:
2134: (*s_etat_processus).erreur_execution =
2135: d_ex_erreur_parametre_fichier;
2136: return;
2137: }
2138:
2139: if (type_adresse != ' ')
2140: {
2141: liberation(s_etat_processus,
2142: s_objet_argument);
2143:
2144: (*s_etat_processus).erreur_execution =
2145: d_ex_erreur_parametre_fichier;
2146: return;
2147: }
2148:
2149: if ((*((struct_vecteur *)
2150: (*(*l_element_courant_sous_objet)
2151: .donnee).objet)).taille == 4)
2152: { // Adresse IPv4
2153: type_adresse = '4';
2154:
2155: for(i = 0; i < 4; i++)
2156: {
2157: adresse[i] = ((integer8 *)
2158: (*((struct_vecteur *) (*
2159: (*l_element_courant_sous_objet)
2160: .donnee).objet)).tableau)[i];
2161:
2162: if ((adresse[i] < 0) || (adresse[i] >
2163: 255))
2164: {
2165: liberation(s_etat_processus,
2166: s_objet_argument);
2167:
2168: (*s_etat_processus).erreur_execution
2169: = d_ex_erreur_parametre_fichier;
2170: return;
2171: }
2172: }
2173: }
2174: else if ((*((struct_vecteur *)
2175: (*(*l_element_courant_sous_objet)
2176: .donnee).objet)).taille == 16)
2177: { // Adresse IPv6
2178: type_adresse = '6';
2179:
2180: for(i = 0; i < 16; i++)
2181: {
2182: adresse[i] = ((integer8 *)
2183: (*((struct_vecteur *) (*
2184: (*l_element_courant_sous_objet)
2185: .donnee).objet)).tableau)[i];
2186:
2187: if ((adresse[i] < 0) || (adresse[i] >
2188: 255))
2189: {
2190: liberation(s_etat_processus,
2191: s_objet_argument);
2192:
2193: (*s_etat_processus).erreur_execution
2194: = d_ex_erreur_parametre_fichier;
2195: return;
2196: }
2197: }
2198: }
2199: else
2200: { // Adresse non supportée
2201: liberation(s_etat_processus,
2202: s_objet_argument);
2203:
2204: (*s_etat_processus).erreur_execution =
2205: d_ex_erreur_parametre_fichier;
2206: return;
2207: }
2208: }
2209: }
2210: else
2211: {
2212: liberation(s_etat_processus, s_objet_argument);
2213: free(argument_majuscule);
2214:
2215: (*s_etat_processus).erreur_execution =
2216: d_ex_erreur_parametre_fichier;
2217: return;
2218: }
2219:
2220: free(argument_majuscule);
2221: }
2222: else
2223: {
2224: liberation(s_etat_processus, s_objet_argument);
2225: (*s_etat_processus).erreur_execution =
2226: d_ex_erreur_parametre_fichier;
2227:
2228: return;
2229: }
2230: }
2231: else if (nombre_elements == 3)
2232: {
2233: if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
2234: {
2235: if ((argument_majuscule = conversion_majuscule(
2236: (unsigned char *)
2237: (*(*l_element_courant_sous_objet)
2238: .donnee).objet)) == NULL)
2239: {
2240: (*s_etat_processus).erreur_systeme =
2241: d_es_allocation_memoire;
2242: return;
2243: }
2244:
2245: if (strcmp(argument_majuscule, "OPTION") == 0)
2246: {
2247: if (type_arguments == ' ')
2248: {
2249: type_arguments = 'S';
2250: }
2251: else if (type_arguments == 'F')
2252: {
2253: liberation(s_etat_processus, s_objet_argument);
2254: free(argument_majuscule);
2255:
2256: (*s_etat_processus).erreur_execution =
2257: d_ex_erreur_parametre_fichier;
2258: return;
2259: }
2260:
2261: free(argument_majuscule);
2262:
2263: l_element_courant_sous_objet =
2264: (*l_element_courant_sous_objet).suivant;
2265:
2266: if ((*(*l_element_courant_sous_objet)
2267: .donnee).type != CHN)
2268: {
2269: liberation(s_etat_processus, s_objet_argument);
2270:
2271: (*s_etat_processus).erreur_execution =
2272: d_ex_erreur_parametre_fichier;
2273: return;
2274: }
2275:
2276: if ((argument_majuscule = conversion_majuscule(
2277: (unsigned char *)
2278: (*(*l_element_courant_sous_objet)
2279: .donnee).objet)) == NULL)
2280: {
2281: (*s_etat_processus).erreur_systeme =
2282: d_es_allocation_memoire;
2283: return;
2284: }
2285:
2286: l_element_courant_sous_objet =
2287: (*l_element_courant_sous_objet).suivant;
2288:
2289: if (strcmp(argument_majuscule, "BIND TO DEVICE")
2290: == 0)
2291: {
2292: if ((*(*l_element_courant_sous_objet)
2293: .donnee).type != CHN)
2294: {
2295: liberation(s_etat_processus,
2296: s_objet_argument);
2297: free(argument_majuscule);
2298:
2299: (*s_etat_processus).erreur_execution =
2300: d_ex_erreur_parametre_fichier;
2301: return;
2302: }
2303:
2304: if (options[d_BIND_TO_DEVICE] == 'Y')
2305: {
2306: liberation(s_etat_processus,
2307: s_objet_argument);
2308: free(argument_majuscule);
2309:
2310: (*s_etat_processus).erreur_execution =
2311: d_ex_erreur_parametre_fichier;
2312: return;
2313: }
2314:
2315: options[d_BIND_TO_DEVICE] = 'Y';
2316:
2317: peripherique = (unsigned char *)
2318: (*(*l_element_courant_sous_objet)
2319: .donnee).objet;
2320: }
2321: else if (strcmp(argument_majuscule, "PRIORITY")
2322: == 0)
2323: {
2324: if ((*(*l_element_courant_sous_objet)
2325: .donnee).type != INT)
2326: {
2327: liberation(s_etat_processus,
2328: s_objet_argument);
2329: free(argument_majuscule);
2330:
2331: (*s_etat_processus).erreur_execution =
2332: d_ex_erreur_parametre_fichier;
2333: return;
2334: }
2335:
2336: if (options[d_PRIORITY] == 'Y')
2337: {
2338: liberation(s_etat_processus,
2339: s_objet_argument);
2340: free(argument_majuscule);
2341:
2342: (*s_etat_processus).erreur_execution =
2343: d_ex_erreur_parametre_fichier;
2344: return;
2345: }
2346:
2347: options[d_PRIORITY] = 'Y';
2348:
2349: priorite = (int) (*((integer8 *)
2350: (*(*l_element_courant_sous_objet)
2351: .donnee).objet));
2352: }
2353: else if (strcmp(argument_majuscule,
2354: "RECEIVE BUFFER") == 0)
2355: {
2356: if ((*(*l_element_courant_sous_objet)
2357: .donnee).type != INT)
2358: {
2359: liberation(s_etat_processus,
2360: s_objet_argument);
2361: free(argument_majuscule);
2362:
2363: (*s_etat_processus).erreur_execution =
2364: d_ex_erreur_parametre_fichier;
2365: return;
2366: }
2367:
2368: if ((options[d_RECEIVE_BUFFER] == 'Y') ||
2369: (options[d_FORCE_RECEIVE_BUFFER]
2370: == 'Y'))
2371: {
2372: liberation(s_etat_processus,
2373: s_objet_argument);
2374: free(argument_majuscule);
2375:
2376: (*s_etat_processus).erreur_execution =
2377: d_ex_erreur_parametre_fichier;
2378: return;
2379: }
2380:
2381: options[d_RECEIVE_BUFFER] = 'Y';
2382:
2383: buffer_reception = (int) (*((integer8 *)
2384: (*(*l_element_courant_sous_objet)
2385: .donnee).objet));
2386: }
2387: else if (strcmp(argument_majuscule,
2388: "FORCE RECEIVE BUFFER") == 0)
2389: {
2390: if ((*(*l_element_courant_sous_objet)
2391: .donnee).type != INT)
2392: {
2393: liberation(s_etat_processus,
2394: s_objet_argument);
2395: free(argument_majuscule);
2396:
2397: (*s_etat_processus).erreur_execution =
2398: d_ex_erreur_parametre_fichier;
2399: return;
2400: }
2401:
2402: if ((options[d_RECEIVE_BUFFER] == 'Y') ||
2403: (options[d_FORCE_RECEIVE_BUFFER]
2404: == 'Y'))
2405: {
2406: liberation(s_etat_processus,
2407: s_objet_argument);
2408: free(argument_majuscule);
2409:
2410: (*s_etat_processus).erreur_execution =
2411: d_ex_erreur_parametre_fichier;
2412: return;
2413: }
2414:
2415: options[d_FORCE_RECEIVE_BUFFER] = 'Y';
2416:
2417: buffer_reception = (int) (*((integer8 *)
2418: (*(*l_element_courant_sous_objet)
2419: .donnee).objet));
2420: }
2421: else if (strcmp(argument_majuscule,
2422: "SEND BUFFER") == 0)
2423: {
2424: if ((*(*l_element_courant_sous_objet)
2425: .donnee).type != INT)
2426: {
2427: liberation(s_etat_processus,
2428: s_objet_argument);
2429: free(argument_majuscule);
2430:
2431: (*s_etat_processus).erreur_execution =
2432: d_ex_erreur_parametre_fichier;
2433: return;
2434: }
2435:
2436: if ((options[d_SEND_BUFFER] == 'Y') ||
2437: (options[d_FORCE_SEND_BUFFER] == 'Y'))
2438: {
2439: liberation(s_etat_processus,
2440: s_objet_argument);
2441: free(argument_majuscule);
2442:
2443: (*s_etat_processus).erreur_execution =
2444: d_ex_erreur_parametre_fichier;
2445: return;
2446: }
2447:
2448: options[d_SEND_BUFFER] = 'Y';
2449:
2450: buffer_emission = (int) (*((integer8 *)
2451: (*(*l_element_courant_sous_objet)
2452: .donnee).objet));
2453: }
2454: else if (strcmp(argument_majuscule,
2455: "FORCE SEND BUFFER") == 0)
2456: {
2457: if ((*(*l_element_courant_sous_objet)
2458: .donnee).type != INT)
2459: {
2460: liberation(s_etat_processus,
2461: s_objet_argument);
2462: free(argument_majuscule);
2463:
2464: (*s_etat_processus).erreur_execution =
2465: d_ex_erreur_parametre_fichier;
2466: return;
2467: }
2468:
2469: if ((options[d_SEND_BUFFER] == 'Y') ||
2470: (options[d_FORCE_SEND_BUFFER] == 'Y'))
2471: {
2472: liberation(s_etat_processus,
2473: s_objet_argument);
2474: free(argument_majuscule);
2475:
2476: (*s_etat_processus).erreur_execution =
2477: d_ex_erreur_parametre_fichier;
2478: return;
2479: }
2480:
2481: options[d_FORCE_SEND_BUFFER] = 'Y';
2482:
2483: buffer_emission = (int) (*((integer8 *)
2484: (*(*l_element_courant_sous_objet)
2485: .donnee).objet));
2486: }
2487: else if (strcmp(argument_majuscule,
2488: "RECEIVING TIMEOUT") == 0)
2489: {
2490: if ((*(*l_element_courant_sous_objet)
2491: .donnee).type != INT)
2492: {
2493: liberation(s_etat_processus,
2494: s_objet_argument);
2495: free(argument_majuscule);
2496:
2497: (*s_etat_processus).erreur_execution =
2498: d_ex_erreur_parametre_fichier;
2499: return;
2500: }
2501:
2502: if (options[d_RECEIVING_TIMEOUT] == 'Y')
2503: {
2504: liberation(s_etat_processus,
2505: s_objet_argument);
2506: free(argument_majuscule);
2507:
2508: (*s_etat_processus).erreur_execution =
2509: d_ex_erreur_parametre_fichier;
2510: return;
2511: }
2512:
2513: options[d_RECEIVING_TIMEOUT] = 'Y';
2514:
2515: timeout_reception = (int) (*((integer8 *)
2516: (*(*l_element_courant_sous_objet)
2517: .donnee).objet));
2518: }
2519: else if (strcmp(argument_majuscule,
2520: "SENDING TIMEOUT") == 0)
2521: {
2522: if ((*(*l_element_courant_sous_objet)
2523: .donnee).type != INT)
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: if (options[d_SENDING_TIMEOUT] == 'Y')
2535: {
2536: liberation(s_etat_processus,
2537: s_objet_argument);
2538: free(argument_majuscule);
2539:
2540: (*s_etat_processus).erreur_execution =
2541: d_ex_erreur_parametre_fichier;
2542: return;
2543: }
2544:
2545: options[d_SENDING_TIMEOUT] = 'Y';
2546:
2547: timeout_emission = (int) (*((integer8 *)
2548: (*(*l_element_courant_sous_objet)
2549: .donnee).objet));
2550: }
2551: else
2552: {
2553: liberation(s_etat_processus, s_objet_argument);
2554: free(argument_majuscule);
2555:
2556: (*s_etat_processus).erreur_execution =
2557: d_ex_erreur_parametre_fichier;
2558: return;
2559: }
2560:
2561: free(argument_majuscule);
2562: }
2563: else
2564: {
2565: liberation(s_etat_processus, s_objet_argument);
2566: free(argument_majuscule);
2567:
2568: (*s_etat_processus).erreur_execution =
2569: d_ex_erreur_parametre_fichier;
2570: return;
2571: }
2572: }
2573: else
2574: {
2575: liberation(s_etat_processus, s_objet_argument);
2576: (*s_etat_processus).erreur_execution =
2577: d_ex_erreur_parametre_fichier;
2578:
2579: return;
2580: }
2581: }
2582: else
2583: {
2584: liberation(s_etat_processus, s_objet_argument);
2585: (*s_etat_processus).erreur_execution =
2586: d_ex_erreur_parametre_fichier;
2587:
2588: return;
2589: }
2590: }
2591: else
2592: {
2593: liberation(s_etat_processus, s_objet_argument);
2594:
2595: (*s_etat_processus).erreur_execution =
2596: d_ex_erreur_parametre_fichier;
2597: return;
2598: }
2599:
2600: l_element_courant = (*l_element_courant).suivant;
2601: }
2602:
2603: if (type_arguments == 'F')
2604: {
2605: /*
2606: * Traitement des fichiers
2607: */
2608:
2609: /*
2610: * Vérification de la cohérence et comportement par défaut
2611: */
2612:
2613: if (type_ouverture == ' ')
2614: {
2615: type_ouverture = 'U';
2616: }
2617:
2618: if (type_acces == ' ')
2619: {
2620: type_acces = 'S';
2621: }
2622:
2623: if (format == ' ')
2624: {
2625: format = 'N';
2626: }
2627:
2628: if (protection == ' ')
2629: {
2630: protection = 'N';
2631: }
2632:
2633: if ((type_ouverture == 'S') && (protection != 'N'))
2634: {
2635: liberation(s_etat_processus, s_objet_argument);
2636:
2637: (*s_etat_processus).erreur_execution =
2638: d_ex_erreur_parametre_fichier;
2639: return;
2640: }
2641:
2642: if ((type_ouverture != 'S') && (nom == NULL))
2643: {
2644: liberation(s_etat_processus, s_objet_argument);
2645:
2646: (*s_etat_processus).erreur_execution =
2647: d_ex_erreur_parametre_fichier;
2648: return;
2649: }
2650:
2651: if (((type_acces != 'I') && (position_clef != 0)) ||
2652: ((type_acces == 'I') && (position_clef == 0)))
2653: {
2654: liberation(s_etat_processus, s_objet_argument);
2655:
2656: (*s_etat_processus).erreur_execution =
2657: d_ex_erreur_parametre_fichier;
2658: return;
2659: }
2660:
2661: if ((s_objet_resultat = allocation(s_etat_processus, FCH))
2662: == NULL)
2663: {
2664: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2665: return;
2666: }
2667:
2668: if (nom == NULL)
2669: {
2670: if ((nom_temporaire = creation_nom_fichier(s_etat_processus,
2671: (*s_etat_processus).chemin_fichiers_temporaires))
2672: == NULL)
2673: {
2674: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2675: return;
2676: }
2677:
2678: if ((nom = malloc((strlen(nom_temporaire)
2679: + 5) * sizeof(unsigned char))) == NULL)
2680: {
2681: (*s_etat_processus).erreur_systeme =
2682: d_es_allocation_memoire;
2683: return;
2684: }
2685:
2686: sprintf(nom, "%s.rpl", nom_temporaire);
2687: free(nom_temporaire);
2688: }
2689: else
2690: {
2691: if ((nom = transliteration(s_etat_processus, nom,
2692: d_locale, "UTF-8")) == NULL)
2693: {
2694: liberation(s_etat_processus, s_objet_argument);
2695: liberation(s_etat_processus, s_objet_resultat);
2696: return;
2697: }
2698: }
2699:
2700: /*
2701: * Ouverture du fichier
2702: */
2703:
2704: (*((struct_fichier *) (*s_objet_resultat).objet))
2705: .nom = NULL;
2706: (*((struct_fichier *) (*s_objet_resultat).objet))
2707: .acces = type_acces;
2708: (*((struct_fichier *) (*s_objet_resultat).objet))
2709: .binaire = format;
2710: (*((struct_fichier *) (*s_objet_resultat).objet))
2711: .ouverture = type_ouverture;
2712: (*((struct_fichier *) (*s_objet_resultat).objet)).pid
2713: = getpid();
2714: (*((struct_fichier *) (*s_objet_resultat).objet)).tid
2715: = pthread_self();
2716:
2717: if (((*((struct_fichier *) (*s_objet_resultat).objet)).format =
2718: allocation(s_etat_processus, LST)) == NULL)
2719: {
2720: free(nom);
2721:
2722: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2723: return;
2724: }
2725:
2726: (*(*((struct_fichier *) (*s_objet_resultat).objet))
2727: .format).objet = NULL;
2728:
2729: descripteur = NULL;
2730:
2731: switch(type_ouverture)
2732: {
2733: case 'N' :
2734: {
2735: erreur = caracteristiques_fichier(s_etat_processus,
2736: nom, &existence, &ouverture, &unite);
2737:
2738: if ((erreur != 0) || (unite != 0))
2739: {
2740: free(nom);
2741:
2742: liberation(s_etat_processus, s_objet_argument);
2743: liberation(s_etat_processus, s_objet_resultat);
2744:
2745: (*s_etat_processus).erreur_execution =
2746: d_ex_erreur_acces_fichier;
2747: return;
2748: }
2749:
2750: if (type_acces == 'S')
2751: {
2752: if ((descripteur = fopen(nom, "w+")) == NULL)
2753: {
2754: free(nom);
2755:
2756: liberation(s_etat_processus, s_objet_argument);
2757: liberation(s_etat_processus, s_objet_resultat);
2758:
2759: (*s_etat_processus).erreur_execution =
2760: d_ex_erreur_acces_fichier;
2761: return;
2762: }
2763: }
2764: else
2765: {
2766: // Si le fichier existe, on le supprime.
2767:
2768: if (unlink(nom) != 0)
2769: {
2770: free(nom);
2771:
2772: liberation(s_etat_processus, s_objet_argument);
2773: liberation(s_etat_processus, s_objet_resultat);
2774:
2775: (*s_etat_processus).erreur_execution =
2776: d_ex_erreur_acces_fichier;
2777: return;
2778: }
2779:
2780: if (sqlite3_open_v2(nom, &sqlite,
2781: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
2782: NULL) != SQLITE_OK)
2783: {
2784: free(nom);
2785:
2786: liberation(s_etat_processus, s_objet_argument);
2787: liberation(s_etat_processus, s_objet_resultat);
2788:
2789: (*s_etat_processus).erreur_execution =
2790: d_ex_erreur_acces_fichier;
2791: return;
2792: }
2793:
2794: if ((descripteur = fopen(nom, "a+")) == NULL)
2795: {
2796: free(nom);
2797:
2798: liberation(s_etat_processus, s_objet_argument);
2799: liberation(s_etat_processus, s_objet_resultat);
2800:
2801: (*s_etat_processus).erreur_execution =
2802: d_ex_erreur_acces_fichier;
2803: return;
2804: }
2805:
2806: if (type_acces == 'D')
2807: {
2808: if (initialisation_fichier_acces_direct(
2809: s_etat_processus, sqlite,
2810: (format == 'N') ? d_faux : d_vrai)
2811: != d_absence_erreur)
2812: {
2813: free(nom);
2814:
2815: liberation(s_etat_processus, s_objet_argument);
2816: liberation(s_etat_processus, s_objet_resultat);
2817:
2818: return;
2819: }
2820: }
2821: else
2822: {
2823: if (initialisation_fichier_acces_indexe(
2824: s_etat_processus, sqlite,
2825: (format == 'N') ? d_faux : d_vrai)
2826: != d_absence_erreur)
2827: {
2828: free(nom);
2829:
2830: liberation(s_etat_processus, s_objet_argument);
2831: liberation(s_etat_processus, s_objet_resultat);
2832:
2833: return;
2834: }
2835: }
2836: }
2837:
2838: break;
2839: }
2840:
2841: case 'O' :
2842: {
2843: erreur = caracteristiques_fichier(s_etat_processus, nom,
2844: &existence, &ouverture, &unite);
2845:
2846: if ((erreur != d_absence_erreur) || (existence == d_faux))
2847: {
2848: free(nom);
2849:
2850: liberation(s_etat_processus, s_objet_argument);
2851: liberation(s_etat_processus, s_objet_resultat);
2852:
2853: (*s_etat_processus).erreur_execution =
2854: d_ex_erreur_acces_fichier;
2855: return;
2856: }
2857:
2858: if (type_acces == 'S')
2859: {
2860: if ((descripteur = fopen(nom, "r+")) == NULL)
2861: {
2862: free(nom);
2863:
2864: liberation(s_etat_processus, s_objet_argument);
2865: liberation(s_etat_processus, s_objet_resultat);
2866:
2867: (*s_etat_processus).erreur_execution =
2868: d_ex_erreur_acces_fichier;
2869: return;
2870: }
2871: }
2872: else
2873: {
2874: if (sqlite3_open_v2(nom, &sqlite,
2875: SQLITE_OPEN_READWRITE,
2876: NULL) != SQLITE_OK)
2877: {
2878: free(nom);
2879:
2880: liberation(s_etat_processus, s_objet_argument);
2881: liberation(s_etat_processus, s_objet_resultat);
2882:
2883: (*s_etat_processus).erreur_execution =
2884: d_ex_erreur_acces_fichier;
2885: return;
2886: }
2887:
2888: if ((descripteur = fopen(nom, "a+")) == NULL)
2889: {
2890: free(nom);
2891:
2892: liberation(s_etat_processus, s_objet_argument);
2893: liberation(s_etat_processus, s_objet_resultat);
2894:
2895: (*s_etat_processus).erreur_execution =
2896: d_ex_erreur_acces_fichier;
2897: return;
2898: }
2899: }
2900:
2901: break;
2902: }
2903:
2904: case 'R' :
2905: {
2906: erreur = caracteristiques_fichier(s_etat_processus,
2907: nom, &existence, &ouverture, &unite);
2908:
2909: if ((erreur != d_absence_erreur) || (existence == d_faux))
2910: {
2911: free(nom);
2912:
2913: liberation(s_etat_processus, s_objet_argument);
2914: liberation(s_etat_processus, s_objet_resultat);
2915:
2916: (*s_etat_processus).erreur_execution =
2917: d_ex_erreur_acces_fichier;
2918: return;
2919: }
2920:
2921: /* Test du verrou */
2922:
2923: if ((descripteur = fopen(nom, "r")) == NULL)
2924: {
2925: free(nom);
2926:
2927: liberation(s_etat_processus, s_objet_argument);
2928: liberation(s_etat_processus, s_objet_resultat);
2929:
2930: (*s_etat_processus).erreur_execution =
2931: d_ex_erreur_acces_fichier;
2932: return;
2933: }
2934:
2935: lock.l_type = F_WRLCK;
2936: lock.l_whence = SEEK_SET;
2937: lock.l_start = 0;
2938: lock.l_len = 0;
2939: lock.l_pid = getpid();
2940:
2941: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
2942: {
2943: free(nom);
2944:
2945: if (fclose(descripteur) != 0)
2946: {
2947: liberation(s_etat_processus, s_objet_argument);
2948: liberation(s_etat_processus, s_objet_resultat);
2949:
2950: (*s_etat_processus).erreur_systeme =
2951: d_es_erreur_fichier;
2952: return;
2953: }
2954:
2955: liberation(s_etat_processus, s_objet_argument);
2956: liberation(s_etat_processus, s_objet_resultat);
2957:
2958: (*s_etat_processus).erreur_systeme =
2959: d_es_erreur_fichier;
2960: return;
2961: }
2962:
2963: if (lock.l_type != F_UNLCK)
2964: {
2965: free(nom);
2966:
2967: if (fclose(descripteur) != 0)
2968: {
2969: liberation(s_etat_processus, s_objet_argument);
2970: liberation(s_etat_processus, s_objet_resultat);
2971:
2972: (*s_etat_processus).erreur_systeme =
2973: d_es_erreur_fichier;
2974: return;
2975: }
2976:
2977: liberation(s_etat_processus, s_objet_argument);
2978: liberation(s_etat_processus, s_objet_resultat);
2979:
2980: (*s_etat_processus).erreur_execution =
2981: d_ex_fichier_verrouille;
2982: return;
2983: }
2984:
2985: if (fclose(descripteur) != 0)
2986: {
2987: free(nom);
2988:
2989: liberation(s_etat_processus, s_objet_argument);
2990: liberation(s_etat_processus, s_objet_resultat);
2991:
2992: (*s_etat_processus).erreur_systeme =
2993: d_es_erreur_fichier;
2994: return;
2995: }
2996:
2997: if (type_acces == 'S')
2998: {
2999: if ((descripteur = fopen(nom, "w+")) == NULL)
3000: {
3001: free(nom);
3002:
3003: liberation(s_etat_processus, s_objet_argument);
3004: liberation(s_etat_processus, s_objet_resultat);
3005:
3006: (*s_etat_processus).erreur_execution =
3007: d_ex_erreur_acces_fichier;
3008: return;
3009: }
3010: }
3011: else
3012: {
3013: if (sqlite3_open_v2(nom, &sqlite,
3014: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3015: NULL) != SQLITE_OK)
3016: {
3017: free(nom);
3018:
3019: liberation(s_etat_processus, s_objet_argument);
3020: liberation(s_etat_processus, s_objet_resultat);
3021:
3022: (*s_etat_processus).erreur_execution =
3023: d_ex_erreur_acces_fichier;
3024: return;
3025: }
3026:
3027: // Ouverture du fichier pour pouvoir gérer les
3028: // verrous à la façon des fichiers séquentiels.
3029:
3030: if ((descripteur = fopen(nom, "a+")) == NULL)
3031: {
3032: free(nom);
3033:
3034: liberation(s_etat_processus, s_objet_argument);
3035: liberation(s_etat_processus, s_objet_resultat);
3036:
3037: (*s_etat_processus).erreur_execution =
3038: d_ex_erreur_acces_fichier;
3039: return;
3040: }
3041:
3042: if (type_acces == 'D')
3043: {
3044: if (initialisation_fichier_acces_direct(
3045: s_etat_processus, sqlite,
3046: (format == 'N') ? d_faux : d_vrai)
3047: != d_absence_erreur)
3048: {
3049: free(nom);
3050:
3051: liberation(s_etat_processus, s_objet_argument);
3052: liberation(s_etat_processus, s_objet_resultat);
3053:
3054: return;
3055: }
3056: }
3057: else
3058: {
3059: if (initialisation_fichier_acces_indexe(
3060: s_etat_processus, sqlite,
3061: (format == 'N') ? d_faux : d_vrai)
3062: != d_absence_erreur)
3063: {
3064: free(nom);
3065:
3066: liberation(s_etat_processus, s_objet_argument);
3067: liberation(s_etat_processus, s_objet_resultat);
3068:
3069: return;
3070: }
3071: }
3072: }
3073:
3074: break;
3075: }
3076:
3077: case 'U' :
3078: {
3079: erreur = caracteristiques_fichier(s_etat_processus,
3080: nom, &existence, &ouverture, &unite);
3081:
3082: if (erreur == d_erreur)
3083: {
3084: free(nom);
3085:
3086: liberation(s_etat_processus, s_objet_argument);
3087: liberation(s_etat_processus, s_objet_resultat);
3088:
3089: (*s_etat_processus).erreur_execution =
3090: d_ex_erreur_acces_fichier;
3091: return;
3092: }
3093:
3094: if (existence == d_faux)
3095: {
3096: if (type_acces == 'S')
3097: {
3098: if ((descripteur = fopen(nom, "w+")) == NULL)
3099: {
3100: free(nom);
3101:
3102: liberation(s_etat_processus, s_objet_argument);
3103: liberation(s_etat_processus, s_objet_resultat);
3104:
3105: (*s_etat_processus).erreur_execution =
3106: d_ex_erreur_acces_fichier;
3107: return;
3108: }
3109: }
3110: else
3111: {
3112: if (sqlite3_open_v2(nom, &sqlite,
3113: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3114: NULL) != SQLITE_OK)
3115: {
3116: free(nom);
3117:
3118: liberation(s_etat_processus, s_objet_argument);
3119: liberation(s_etat_processus, s_objet_resultat);
3120:
3121: (*s_etat_processus).erreur_execution =
3122: d_ex_erreur_acces_fichier;
3123: return;
3124: }
3125:
3126: if ((descripteur = fopen(nom, "a+")) == NULL)
3127: {
3128: free(nom);
3129:
3130: liberation(s_etat_processus, s_objet_argument);
3131: liberation(s_etat_processus, s_objet_resultat);
3132:
3133: (*s_etat_processus).erreur_execution =
3134: d_ex_erreur_acces_fichier;
3135: return;
3136: }
3137:
3138: if (type_acces == 'D')
3139: {
3140: if (initialisation_fichier_acces_direct(
3141: s_etat_processus, sqlite,
3142: (format == 'N') ? d_faux : d_vrai)
3143: != d_absence_erreur)
3144: {
3145: free(nom);
3146:
3147: liberation(s_etat_processus,
3148: s_objet_argument);
3149: liberation(s_etat_processus,
3150: s_objet_resultat);
3151:
3152: return;
3153: }
3154: }
3155: else
3156: {
3157: if (initialisation_fichier_acces_indexe(
3158: s_etat_processus, sqlite,
3159: (format == 'N') ? d_faux : d_vrai)
3160: != d_absence_erreur)
3161: {
3162: free(nom);
3163:
3164: liberation(s_etat_processus,
3165: s_objet_argument);
3166: liberation(s_etat_processus,
3167: s_objet_resultat);
3168:
3169: return;
3170: }
3171: }
3172: }
3173: }
3174: else
3175: {
3176: if (type_acces == 'S')
3177: {
3178: if ((descripteur = fopen(nom, "r+")) == NULL)
3179: {
3180: free(nom);
3181:
3182: liberation(s_etat_processus, s_objet_argument);
3183: liberation(s_etat_processus, s_objet_resultat);
3184:
3185: (*s_etat_processus).erreur_execution =
3186: d_ex_erreur_acces_fichier;
3187: return;
3188: }
3189: }
3190: else
3191: {
3192: if (sqlite3_open_v2(nom, &sqlite,
3193: SQLITE_OPEN_READWRITE,
3194: NULL) != SQLITE_OK)
3195: {
3196: free(nom);
3197:
3198: liberation(s_etat_processus, s_objet_argument);
3199: liberation(s_etat_processus, s_objet_resultat);
3200:
3201: (*s_etat_processus).erreur_execution =
3202: d_ex_erreur_acces_fichier;
3203: return;
3204: }
3205:
3206: if ((descripteur = fopen(nom, "a+")) == NULL)
3207: {
3208: free(nom);
3209:
3210: liberation(s_etat_processus, s_objet_argument);
3211: liberation(s_etat_processus, s_objet_resultat);
3212:
3213: (*s_etat_processus).erreur_execution =
3214: d_ex_erreur_acces_fichier;
3215: return;
3216: }
3217: }
3218: }
3219:
3220: break;
3221: }
3222:
3223: case 'S' :
3224: {
3225: erreur = caracteristiques_fichier(s_etat_processus,
3226: nom, &existence, &ouverture, &unite);
3227:
3228: if ((erreur != d_absence_erreur) || (existence != d_faux))
3229: {
3230: free(nom);
3231:
3232: liberation(s_etat_processus, s_objet_argument);
3233: liberation(s_etat_processus, s_objet_resultat);
3234:
3235: (*s_etat_processus).erreur_execution =
3236: d_ex_erreur_acces_fichier;
3237: return;
3238: }
3239:
3240: if (type_acces == 'S')
3241: {
3242: if ((descripteur = fopen(nom, "w+")) == NULL)
3243: {
3244: free(nom);
3245:
3246: liberation(s_etat_processus, s_objet_argument);
3247: liberation(s_etat_processus, s_objet_resultat);
3248:
3249: (*s_etat_processus).erreur_execution =
3250: d_ex_erreur_acces_fichier;
3251: return;
3252: }
3253: }
3254: else
3255: {
3256: // Si le fichier existe, on le supprime.
3257:
3258: if (unlink(nom) != 0)
3259: {
3260: free(nom);
3261:
3262: liberation(s_etat_processus, s_objet_argument);
3263: liberation(s_etat_processus, s_objet_resultat);
3264:
3265: (*s_etat_processus).erreur_execution =
3266: d_ex_erreur_acces_fichier;
3267: return;
3268: }
3269:
3270: if (sqlite3_open_v2(nom, &sqlite,
3271: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3272: NULL) != SQLITE_OK)
3273: {
3274: free(nom);
3275:
3276: liberation(s_etat_processus, s_objet_argument);
3277: liberation(s_etat_processus, s_objet_resultat);
3278:
3279: (*s_etat_processus).erreur_execution =
3280: d_ex_erreur_acces_fichier;
3281: return;
3282: }
3283:
3284: if ((descripteur = fopen(nom, "a+")) == NULL)
3285: {
3286: free(nom);
3287:
3288: liberation(s_etat_processus, s_objet_argument);
3289: liberation(s_etat_processus, s_objet_resultat);
3290:
3291: (*s_etat_processus).erreur_execution =
3292: d_ex_erreur_acces_fichier;
3293: return;
3294: }
3295:
3296: if (type_acces == 'D')
3297: {
3298: if (initialisation_fichier_acces_direct(
3299: s_etat_processus, sqlite,
3300: (format == 'N') ? d_faux : d_vrai)
3301: != d_absence_erreur)
3302: {
3303: free(nom);
3304:
3305: liberation(s_etat_processus, s_objet_argument);
3306: liberation(s_etat_processus, s_objet_resultat);
3307:
3308: return;
3309: }
3310: }
3311: else
3312: {
3313: if (initialisation_fichier_acces_indexe(
3314: s_etat_processus, sqlite,
3315: (format == 'N') ? d_faux : d_vrai)
3316: != d_absence_erreur)
3317: {
3318: free(nom);
3319:
3320: liberation(s_etat_processus, s_objet_argument);
3321: liberation(s_etat_processus, s_objet_resultat);
3322:
3323: return;
3324: }
3325: }
3326: }
3327:
3328: break;
3329: }
3330:
3331: default:
3332: {
3333: BUG(1, printf("type_ouverture=%c\n", type_ouverture));
3334: return;
3335: }
3336: }
3337:
3338: if (((*((struct_fichier *) (*s_objet_resultat).objet)).nom =
3339: malloc((strlen(nom) + 1) *
3340: sizeof(unsigned char))) == NULL)
3341: {
3342: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3343: return;
3344: }
3345:
3346: strcpy((*((struct_fichier *) (*s_objet_resultat).objet)).nom, nom);
3347: liberation(s_etat_processus, s_objet_argument);
3348:
3349: (*((struct_fichier *) (*s_objet_resultat).objet)).protection =
3350: protection;
3351: (*((struct_fichier *) (*s_objet_resultat).objet)).position_clef =
3352: position_clef;
3353:
3354: rewind(descripteur);
3355:
3356: lock.l_type = F_WRLCK;
3357: lock.l_whence = SEEK_SET;
3358: lock.l_start = 0;
3359: lock.l_len = 0;
3360: lock.l_pid = getpid();
3361:
3362: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
3363: {
3364: if (fclose(descripteur) != 0)
3365: {
3366: liberation(s_etat_processus, s_objet_resultat);
3367:
3368: (*s_etat_processus).erreur_systeme =
3369: d_es_erreur_fichier;
3370: return;
3371: }
3372:
3373: liberation(s_etat_processus, s_objet_resultat);
3374:
3375: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
3376: return;
3377: }
3378:
3379: if (lock.l_type == F_UNLCK)
3380: {
3381: /*
3382: * Positionnement d'un verrou exclusif d'écriture par défaut
3383: */
3384:
3385: lock.l_type = F_RDLCK;
3386: lock.l_whence = SEEK_SET;
3387: lock.l_start = 0;
3388: lock.l_len = 0;
3389: lock.l_pid = getpid();
3390:
3391: if (fcntl(fileno(descripteur), F_SETLK, &lock) == -1)
3392: {
3393: if (fclose(descripteur) != 0)
3394: {
3395: liberation(s_etat_processus, s_objet_resultat);
3396:
3397: (*s_etat_processus).erreur_systeme =
3398: d_es_erreur_fichier;
3399: return;
3400: }
3401:
3402: liberation(s_etat_processus, s_objet_resultat);
3403:
3404: (*s_etat_processus).erreur_systeme =
3405: d_es_erreur_fichier;
3406: return;
3407: }
3408: }
3409: else
3410: {
3411: /*
3412: * Test de la cohérence du verrou avec l'option PROTECTION
3413: */
3414:
3415: if ((lock.l_type == F_RDLCK) && (protection != 'R'))
3416: {
3417: free(nom);
3418:
3419: if (fclose(descripteur) != 0)
3420: {
3421: liberation(s_etat_processus, s_objet_resultat);
3422:
3423: (*s_etat_processus).erreur_systeme =
3424: d_es_erreur_fichier;
3425: return;
3426: }
3427:
3428: liberation(s_etat_processus, s_objet_resultat);
3429:
3430: (*s_etat_processus).erreur_execution =
3431: d_ex_fichier_verrouille;
3432: return;
3433: }
3434: else if ((lock.l_type == F_WRLCK) && (protection != 'W'))
3435: {
3436: free(nom);
3437:
3438: if (fclose(descripteur) != 0)
3439: {
3440: liberation(s_etat_processus, s_objet_resultat);
3441:
3442: (*s_etat_processus).erreur_systeme =
3443: d_es_erreur_fichier;
3444: return;
3445: }
3446:
3447: liberation(s_etat_processus, s_objet_resultat);
3448:
3449: (*s_etat_processus).erreur_execution =
3450: d_ex_fichier_verrouille;
3451: return;
3452: }
3453: else
3454: {
3455: free(nom);
3456:
3457: if (fclose(descripteur) != 0)
3458: {
3459: liberation(s_etat_processus, s_objet_resultat);
3460:
3461: (*s_etat_processus).erreur_systeme =
3462: d_es_erreur_fichier;
3463: return;
3464: }
3465:
3466: liberation(s_etat_processus, s_objet_resultat);
3467:
3468: (*s_etat_processus).erreur_execution =
3469: d_ex_fichier_verrouille;
3470: return;
3471: }
3472: }
3473:
3474: /*
3475: * Gestion de la liste des fichiers ouverts
3476: */
3477:
3478: l_element_courant = (*s_etat_processus).s_fichiers;
3479:
3480: if (l_element_courant == NULL)
3481: {
3482: if (((*s_etat_processus).s_fichiers = malloc(sizeof(
3483: struct_liste_chainee))) == NULL)
3484: {
3485: (*s_etat_processus).erreur_systeme =
3486: d_es_allocation_memoire;
3487: return;
3488: }
3489:
3490: (*(*s_etat_processus).s_fichiers).suivant = NULL;
3491:
3492: if (((*(*s_etat_processus).s_fichiers).donnee =
3493: malloc(sizeof(struct_descripteur_fichier))) == NULL)
3494: {
3495: (*s_etat_processus).erreur_systeme =
3496: d_es_allocation_memoire;
3497: return;
3498: }
3499:
3500: l_element_courant = (*s_etat_processus).s_fichiers;
3501: prochain_descripteur = 0;
3502: }
3503: else
3504: {
3505: /*
3506: * Recherche du premier descripteur libre
3507: */
3508:
3509: if ((chaine_descripteurs = malloc(sizeof(unsigned char) *
3510: (ds_nombre_maximum_fichiers_ouverts + 1))) == NULL)
3511: {
3512: (*s_etat_processus).erreur_systeme =
3513: d_es_allocation_memoire;
3514: return;
3515: }
3516:
3517: for(pointeur = chaine_descripteurs, i = 0;
3518: i < ds_nombre_maximum_fichiers_ouverts;
3519: (*pointeur) = d_code_espace, pointeur++, i++);
3520: (*pointeur) = d_code_fin_chaine;
3521:
3522: do
3523: {
3524: chaine_descripteurs[(*((struct_descripteur_fichier *)
3525: (*l_element_courant).donnee)).identifiant] = '-';
3526: l_element_courant = (*l_element_courant).suivant;
3527: } while(l_element_courant != NULL);
3528:
3529: i = 0;
3530: pointeur = chaine_descripteurs;
3531:
3532: while(i < ds_nombre_maximum_fichiers_ouverts)
3533: {
3534: if ((*pointeur) == ' ')
3535: {
3536: break;
3537: }
3538:
3539: pointeur++;
3540: i++;
3541: }
3542:
3543: free(chaine_descripteurs);
3544:
3545: if (i == ds_nombre_maximum_fichiers_ouverts)
3546: {
3547: (*s_etat_processus).erreur_systeme =
3548: d_es_nombre_max_descripteurs;
3549: return;
3550: }
3551:
3552: prochain_descripteur = i;
3553:
3554: /*
3555: * Ajout d'un élément à la fin de la liste chaînée
3556: */
3557:
3558: l_element_courant = (*s_etat_processus).s_fichiers;
3559: while((*l_element_courant).suivant != NULL)
3560: {
3561: l_element_courant = (*l_element_courant).suivant;
3562: }
3563:
3564: if (((*l_element_courant).suivant =
3565: allocation_maillon(s_etat_processus)) == NULL)
3566: {
3567: (*s_etat_processus).erreur_systeme =
3568: d_es_allocation_memoire;
3569: return;
3570: }
3571:
3572: l_element_courant = (*l_element_courant).suivant;
3573: (*l_element_courant).suivant = NULL;
3574:
3575: if (((*l_element_courant).donnee =
3576: malloc(sizeof(struct_descripteur_fichier))) == NULL)
3577: {
3578: (*s_etat_processus).erreur_systeme =
3579: d_es_allocation_memoire;
3580: return;
3581: }
3582: }
3583:
3584: (*((struct_fichier *) (*s_objet_resultat).objet)).descripteur
3585: = prochain_descripteur;
3586: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3587: .identifiant = prochain_descripteur;
3588:
3589: if (type_acces == 'S')
3590: {
3591: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3592: .type = 'C';
3593: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3594: .descripteur_c = descripteur;
3595: }
3596: else
3597: {
3598: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3599: .type = 'S';
3600: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3601: .descripteur_c = descripteur;
3602: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3603: .descripteur_sqlite = sqlite;
3604: }
3605:
3606: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3607: .pid = getpid();
3608: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3609: .tid = pthread_self();
3610: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3611: .effacement = (type_ouverture == 'S') ? 'Y' : 'N';
3612:
3613: (*((struct_descripteur_fichier *) (*l_element_courant)
3614: .donnee)).nom = nom;
3615: }
3616: else if (type_arguments == 'S')
3617: {
3618: /*
3619: * Traitement des sockets
3620: */
3621:
3622:
3623: inline logical1 options_socket()
3624: {
3625: /*
3626: * Options des sockets
3627: */
3628:
3629: # define WARNING(message) \
3630: if ((*s_etat_processus).langue != 'F') \
3631: printf("+++Warning : %s unavailable on host system\n", \
3632: message); \
3633: else \
3634: printf("+++Attention : %s non disponible sur le système " \
3635: "hôte\n", message)
3636:
3637: if (options[d_BIND_TO_DEVICE] == 'Y')
3638: {
3639: # ifdef SO_BINDTODEVICE
3640: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3641: .objet)).socket, SOL_SOCKET, SO_BINDTODEVICE,
3642: peripherique, strlen(peripherique)) != 0)
3643: {
3644: liberation(s_etat_processus, s_objet_argument);
3645: liberation(s_etat_processus, s_objet_resultat);
3646:
3647: (*s_etat_processus).erreur_execution =
3648: d_ex_erreur_parametre_fichier;
3649: return(d_erreur);
3650: }
3651: # else
3652: WARNING("BIND TO DEVICE");
3653: # endif
3654: }
3655:
3656: if (options[d_BROADCAST] == 'Y')
3657: {
3658: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3659: .objet)).socket, SOL_SOCKET, SO_BROADCAST,
3660: &drapeau, sizeof(drapeau)) != 0)
3661: {
3662: liberation(s_etat_processus, s_objet_argument);
3663: liberation(s_etat_processus, s_objet_resultat);
3664:
3665: (*s_etat_processus).erreur_execution =
3666: d_ex_erreur_parametre_fichier;
3667: return(d_erreur);
3668: }
3669: }
3670:
3671: if (options[d_DONT_ROUTE] == 'Y')
3672: {
3673: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3674: .objet)).socket, SOL_SOCKET, SO_DONTROUTE,
3675: &drapeau, sizeof(drapeau)) != 0)
3676: {
3677: liberation(s_etat_processus, s_objet_argument);
3678: liberation(s_etat_processus, s_objet_resultat);
3679:
3680: (*s_etat_processus).erreur_execution =
3681: d_ex_erreur_parametre_fichier;
3682: return(d_erreur);
3683: }
3684: }
3685:
3686: if (options[d_KEEP_ALIVE] == 'Y')
3687: {
3688: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3689: .objet)).socket, SOL_SOCKET, SO_KEEPALIVE,
3690: &drapeau, sizeof(drapeau)) != 0)
3691: {
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(d_erreur);
3698: }
3699: }
3700:
3701: if (options[d_PRIORITY] == 'Y')
3702: {
3703: # ifdef SO_PRIORITY
3704: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3705: .objet)).socket, SOL_SOCKET, SO_PRIORITY,
3706: &priorite, sizeof(priorite)) != 0)
3707: {
3708: liberation(s_etat_processus, s_objet_argument);
3709: liberation(s_etat_processus, s_objet_resultat);
3710:
3711: (*s_etat_processus).erreur_execution =
3712: d_ex_erreur_parametre_fichier;
3713: return(d_erreur);
3714: }
3715: # else
3716: WARNING("PRIORITY");
3717: # endif
3718: }
3719:
3720: if (options[d_RECEIVE_BUFFER] == 'Y')
3721: {
3722: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3723: .objet)).socket, SOL_SOCKET, SO_RCVBUF,
3724: &buffer_reception, sizeof(buffer_reception)) != 0)
3725: {
3726: liberation(s_etat_processus, s_objet_argument);
3727: liberation(s_etat_processus, s_objet_resultat);
3728:
3729: (*s_etat_processus).erreur_execution =
3730: d_ex_erreur_parametre_fichier;
3731: return(d_erreur);
3732: }
3733: }
3734:
3735: if (options[d_FORCE_RECEIVE_BUFFER] == 'Y')
3736: {
3737: # ifdef SO_RCVBUFFORCE
3738: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3739: .objet)).socket, SOL_SOCKET, SO_RCVBUFFORCE,
3740: &buffer_reception, sizeof(buffer_reception))
3741: != 0)
3742: {
3743: liberation(s_etat_processus, s_objet_argument);
3744: liberation(s_etat_processus, s_objet_resultat);
3745:
3746: (*s_etat_processus).erreur_execution =
3747: d_ex_erreur_parametre_fichier;
3748: return(d_erreur);
3749: }
3750: # else
3751: WARNING("FORCE_RECEIVE_BUFFER");
3752: # endif
3753: }
3754:
3755: if (options[d_SEND_BUFFER] == 'Y')
3756: {
3757: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3758: .objet)).socket, SOL_SOCKET, SO_SNDBUF,
3759: &buffer_emission, sizeof(buffer_emission)) != 0)
3760: {
3761: liberation(s_etat_processus, s_objet_argument);
3762: liberation(s_etat_processus, s_objet_resultat);
3763:
3764: (*s_etat_processus).erreur_execution =
3765: d_ex_erreur_parametre_fichier;
3766: return(d_erreur);
3767: }
3768: }
3769:
3770: if (options[d_FORCE_SEND_BUFFER] == 'Y')
3771: {
3772: # ifdef SO_SNDBUFFORCE
3773: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3774: .objet)).socket, SOL_SOCKET, SO_SNDBUFFORCE,
3775: &buffer_emission, sizeof(buffer_emission)) != 0)
3776: {
3777: liberation(s_etat_processus, s_objet_argument);
3778: liberation(s_etat_processus, s_objet_resultat);
3779:
3780: (*s_etat_processus).erreur_execution =
3781: d_ex_erreur_parametre_fichier;
3782: return(d_erreur);
3783: }
3784: # else
3785: WARNING("FORCE_SEND_BUFFER");
3786: # endif
3787: }
3788:
3789: if (options[d_RECEIVING_TIMEOUT] == 'Y')
3790: {
3791: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3792: .objet)).socket, SOL_SOCKET, SO_RCVTIMEO,
3793: &timeout_reception, sizeof(timeout_reception)) != 0)
3794: {
3795: liberation(s_etat_processus, s_objet_argument);
3796: liberation(s_etat_processus, s_objet_resultat);
3797:
3798: (*s_etat_processus).erreur_execution =
3799: d_ex_erreur_parametre_fichier;
3800: return(d_erreur);
3801: }
3802: }
3803:
3804: if (options[d_SENDING_TIMEOUT] == 'Y')
3805: {
3806: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3807: .objet)).socket, SOL_SOCKET, SO_SNDTIMEO,
3808: &timeout_emission, sizeof(timeout_emission)) != 0)
3809: {
3810: liberation(s_etat_processus, s_objet_argument);
3811: liberation(s_etat_processus, s_objet_resultat);
3812:
3813: (*s_etat_processus).erreur_execution =
3814: d_ex_erreur_parametre_fichier;
3815: return(d_erreur);
3816: }
3817: }
3818:
3819: if (options[d_REUSE_ADDRESS] == 'Y')
3820: {
3821: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3822: .objet)).socket, SOL_SOCKET, SO_REUSEADDR,
3823: &drapeau, sizeof(drapeau)) != 0)
3824: {
3825: liberation(s_etat_processus, s_objet_argument);
3826: liberation(s_etat_processus, s_objet_resultat);
3827:
3828: (*s_etat_processus).erreur_execution =
3829: d_ex_erreur_parametre_fichier;
3830: return(d_erreur);
3831: }
3832: }
3833:
3834: return(d_absence_erreur);
3835: #undef WARNING
3836: }
3837:
3838: /*
3839: * Vérification de la cohérence des arguments et traitement
3840: * des valeurs par défaut.
3841: */
3842:
3843: if (format == ' ')
3844: {
3845: format = 'N';
3846: }
3847:
3848: if (protection == ' ')
3849: {
3850: protection = 'N';
3851: }
3852:
3853: if (type_domaine == ' ')
3854: {
3855: type_domaine = 'L';
3856: }
3857:
3858: if (type_socket == ' ')
3859: {
3860: type_socket = 'S';
3861: type = SOCK_STREAM;
3862: }
3863:
3864: if (nom != NULL)
3865: {
3866: if (strcmp(protocole, "") == 0)
3867: {
3868: strcpy(protocole, "UNIX");
3869: }
3870: }
3871: else
3872: {
3873: if (strcmp(protocole, "") == 0)
3874: {
3875: strcpy(protocole, "IPV4");
3876: }
3877: }
3878:
3879: if ((nom != NULL) && (hote != NULL))
3880: {
3881: liberation(s_etat_processus, s_objet_argument);
3882:
3883: (*s_etat_processus).erreur_execution =
3884: d_ex_erreur_parametre_fichier;
3885: return;
3886: }
3887:
3888: if ((nom != NULL) && (strcmp(protocole, "UNIX") != 0))
3889: {
3890: liberation(s_etat_processus, s_objet_argument);
3891:
3892: (*s_etat_processus).erreur_execution =
3893: d_ex_erreur_parametre_fichier;
3894: return;
3895: }
3896:
3897: if ((hote != NULL) && (strcmp(protocole, "UNIX") == 0))
3898: {
3899: liberation(s_etat_processus, s_objet_argument);
3900:
3901: (*s_etat_processus).erreur_execution =
3902: d_ex_erreur_parametre_fichier;
3903: return;
3904: }
3905:
3906: if ((nom != NULL) && (type_domaine == 'F') && (type_adresse != ' '))
3907: {
3908: liberation(s_etat_processus, s_objet_argument);
3909:
3910: (*s_etat_processus).erreur_execution =
3911: d_ex_erreur_parametre_fichier;
3912: return;
3913: }
3914:
3915: if ((presence_port == d_vrai) && (nom != NULL))
3916: {
3917: liberation(s_etat_processus, s_objet_argument);
3918:
3919: (*s_etat_processus).erreur_execution =
3920: d_ex_erreur_parametre_fichier;
3921: return;
3922: }
3923:
3924: if (((strcmp(protocole, "IPV4") == 0) && (type_adresse == '6')) ||
3925: ((strcmp(protocole, "IPV6") == 0) && (type_adresse == '4')))
3926: {
3927: liberation(s_etat_processus, s_objet_argument);
3928:
3929: (*s_etat_processus).erreur_execution =
3930: d_ex_erreur_parametre_fichier;
3931: return;
3932: }
3933:
3934: if ((nombre_maximal_connexions != 0) && ((type_socket != 'S') &&
3935: (type_socket != 'Q')))
3936: {
3937: liberation(s_etat_processus, s_objet_argument);
3938:
3939: (*s_etat_processus).erreur_execution =
3940: d_ex_erreur_parametre_fichier;
3941: return;
3942: }
3943:
3944: if (nombre_maximal_connexions == 0)
3945: {
3946: nombre_maximal_connexions = 1;
3947: }
3948:
3949: if (protocole_socket == NULL)
3950: {
3951: protocole_numerique = 0;
3952: }
3953: else
3954: {
3955: for(i = 0; i < strlen(protocole_socket); i++)
3956: {
3957: if ((protocole_socket[i] >= 'A') &&
3958: (protocole_socket[i] <= 'Z'))
3959: {
3960: protocole_socket[i] += 'a' - 'A';
3961: }
3962: }
3963:
3964: if (strcmp(protocole_socket, "ipv4") == 0)
3965: {
3966: protocole_socket[2] = d_code_fin_chaine;
3967: }
3968:
3969: if ((s_protocole = getprotobyname(protocole_socket)) == NULL)
3970: {
3971: liberation(s_etat_processus, s_objet_argument);
3972:
3973: (*s_etat_processus).erreur_execution =
3974: d_ex_erreur_parametre_fichier;
3975: return;
3976: }
3977:
3978: protocole_numerique = (*s_protocole).p_proto;
3979: }
3980:
3981: if ((s_objet_resultat = allocation(s_etat_processus, SCK))
3982: == NULL)
3983: {
3984: (*s_etat_processus).erreur_systeme =
3985: d_es_allocation_memoire;
3986: return;
3987: }
3988:
3989: if (((*((struct_socket *) (*s_objet_resultat).objet)).format =
3990: allocation(s_etat_processus, LST)) == NULL)
3991: {
3992: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3993: return;
3994: }
3995:
3996: (*((struct_socket *) (*s_objet_resultat).objet)).protection
3997: = protection;
3998: (*(*((struct_socket *) (*s_objet_resultat).objet))
3999: .format).objet = NULL;
4000:
4001: switch(type_socket)
4002: {
4003: case 'S' :
4004: type = SOCK_STREAM;
4005: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4006: type, "STREAM");
4007: break;
4008:
4009: case 'D' :
4010: type = SOCK_DGRAM;
4011: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4012: type, "DATAGRAM");
4013: break;
4014:
4015: case 'Q' :
4016: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4017: type, "SEQUENTIAL DATAGRAM");
4018: type = SOCK_SEQPACKET;
4019: break;
4020:
4021: case 'R' :
4022: type = SOCK_RAW;
4023: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4024: type, "RAW");
4025: break;
4026:
4027: case 'M' :
4028: type = SOCK_RDM;
4029: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4030: type, "ROBUST DATAGRAM");
4031: break;
4032: }
4033:
4034: if ((protection != 'N') && ((type_socket != 'S') &&
4035: (type_socket != 'Q')))
4036: {
4037: liberation(s_etat_processus, s_objet_argument);
4038: liberation(s_etat_processus, s_objet_resultat);
4039:
4040: (*s_etat_processus).erreur_execution =
4041: d_ex_erreur_parametre_fichier;
4042: return;
4043: }
4044:
4045: if (nom == NULL)
4046: {
4047: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
4048: malloc(sizeof(unsigned char))) == NULL)
4049: {
4050: (*s_etat_processus).erreur_systeme =
4051: d_es_allocation_memoire;
4052: return;
4053: }
4054:
4055: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).adresse,
4056: "");
4057: }
4058: else
4059: {
4060: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
4061: transliteration(s_etat_processus, nom,
4062: d_locale, "UTF-8")) == NULL)
4063: {
4064: liberation(s_etat_processus, s_objet_argument);
4065: liberation(s_etat_processus, s_objet_resultat);
4066: return;
4067: }
4068: }
4069:
4070: if (((*((struct_socket *) (*s_objet_resultat).objet))
4071: .adresse_distante = malloc(sizeof(unsigned char))) == NULL)
4072: {
4073: (*s_etat_processus).erreur_systeme =
4074: d_es_allocation_memoire;
4075: return;
4076: }
4077:
4078: strcpy((*((struct_socket *) (*s_objet_resultat).objet))
4079: .adresse_distante, "");
4080:
4081: (*((struct_socket *) (*s_objet_resultat).objet)).localisation =
4082: type_domaine;
4083: (*((struct_socket *) (*s_objet_resultat).objet)).binaire =
4084: format;
4085: (*((struct_socket *) (*s_objet_resultat).objet)).pid =
4086: getpid();
4087: (*((struct_socket *) (*s_objet_resultat).objet)).tid =
4088: pthread_self();
4089: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
4090: = 'Y';
4091: (*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee
4092: = d_faux;
4093:
4094: if (type_domaine == 'L')
4095: { // Socket serveur
4096: if (nom != NULL)
4097: {
4098: /*
4099: * La socket locale est dans l'espace des noms.
4100: */
4101:
4102: if (((*((struct_socket *) (*s_objet_resultat).objet))
4103: .socket = socket(PF_UNIX, type,
4104: protocole_numerique)) == -1)
4105: {
4106: liberation(s_etat_processus, s_objet_argument);
4107: liberation(s_etat_processus, s_objet_resultat);
4108:
4109: (*s_etat_processus).erreur_execution =
4110: d_ex_erreur_acces_fichier;
4111: return;
4112: }
4113:
4114: (*((struct_socket *) (*s_objet_resultat).objet)).domaine
4115: = PF_UNIX;
4116: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4117: = 'Y';
4118:
4119: socket_unix.sun_family = AF_UNIX;
4120:
4121: pointeur = (*((struct_socket *)
4122: (*s_objet_resultat).objet)).adresse;
4123:
4124: while((*pointeur) == d_code_espace)
4125: {
4126: pointeur++;
4127: }
4128:
4129: strncpy(socket_unix.sun_path, pointeur, 108);
4130: socket_unix.sun_path[108 - 1] = d_code_fin_chaine;
4131:
4132: if (options_socket() == d_erreur)
4133: {
4134: liberation(s_etat_processus, s_objet_argument);
4135: liberation(s_etat_processus, s_objet_resultat);
4136:
4137: return;
4138: }
4139:
4140: if (bind((*((struct_socket *) (*s_objet_resultat).objet))
4141: .socket, (const struct sockaddr *) &socket_unix,
4142: sizeof(socket_unix)) != 0)
4143: {
4144: liberation(s_etat_processus, s_objet_argument);
4145: liberation(s_etat_processus, s_objet_resultat);
4146:
4147: (*s_etat_processus).erreur_execution =
4148: d_ex_erreur_acces_fichier;
4149: return;
4150: }
4151: }
4152: else
4153: {
4154: /*
4155: * La socket est une socket réseau locale. L'adresse
4156: * passée en argument est l'adresse sur laquelle
4157: * cette socket est à l'écoute.
4158: */
4159:
4160: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4161: = 'N';
4162:
4163: if (hote != NULL)
4164: { // Hôte défini par un nom
4165: resolution = NULL;
4166:
4167: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4168: {
4169: liberation(s_etat_processus, s_objet_argument);
4170: liberation(s_etat_processus, s_objet_resultat);
4171:
4172: if (resolution != NULL)
4173: {
4174: freeaddrinfo(resolution);
4175: }
4176:
4177: (*s_etat_processus).erreur_execution =
4178: d_ex_erreur_acces_fichier;
4179: return;
4180: }
4181:
4182: if (strcmp(protocole, "IPV4") == 0)
4183: { // Accès en IPv4
4184: resolution_courante = resolution;
4185:
4186: while(resolution_courante != NULL)
4187: {
4188: if ((*resolution_courante).ai_family ==
4189: AF_INET)
4190: {
4191: break;
4192: }
4193:
4194: resolution_courante = (*resolution_courante)
4195: .ai_next;
4196: }
4197:
4198: if (resolution_courante == NULL)
4199: {
4200: liberation(s_etat_processus, s_objet_argument);
4201: liberation(s_etat_processus, s_objet_resultat);
4202:
4203: freeaddrinfo(resolution);
4204:
4205: (*s_etat_processus).erreur_execution =
4206: d_ex_erreur_acces_fichier;
4207: return;
4208: }
4209:
4210: if (((*((struct_socket *)
4211: (*s_objet_resultat).objet))
4212: .socket = socket(PF_INET, type,
4213: protocole_numerique)) == -1)
4214: {
4215: liberation(s_etat_processus, s_objet_argument);
4216: liberation(s_etat_processus, s_objet_resultat);
4217:
4218: freeaddrinfo(resolution);
4219:
4220: (*s_etat_processus).erreur_execution =
4221: d_ex_erreur_acces_fichier;
4222: return;
4223: }
4224:
4225: (*((struct_socket *) (*s_objet_resultat).objet))
4226: .domaine = PF_INET;
4227:
4228: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4229: socket_ipv4.sin_family = AF_INET;
4230: socket_ipv4.sin_port = htons((uint16_t) port);
4231: socket_ipv4.sin_addr.s_addr =
4232: (*((struct sockaddr_in *)
4233: (*resolution_courante).ai_addr))
4234: .sin_addr.s_addr;
4235:
4236: if (options_socket() == d_erreur)
4237: {
4238: liberation(s_etat_processus, s_objet_argument);
4239: liberation(s_etat_processus, s_objet_resultat);
4240:
4241: freeaddrinfo(resolution);
4242: return;
4243: }
4244:
4245: if (bind((*((struct_socket *) (*s_objet_resultat)
4246: .objet)).socket, (const struct sockaddr *)
4247: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4248: {
4249: liberation(s_etat_processus, s_objet_argument);
4250: liberation(s_etat_processus, s_objet_resultat);
4251:
4252: freeaddrinfo(resolution);
4253:
4254: (*s_etat_processus).erreur_execution =
4255: d_ex_erreur_acces_fichier;
4256: return;
4257: }
4258:
4259: if (((*((struct_socket *) (*s_objet_resultat)
4260: .objet)).adresse = malloc(22 *
4261: sizeof(unsigned char))) == NULL)
4262: {
4263: (*s_etat_processus).erreur_systeme =
4264: d_es_allocation_memoire;
4265: return;
4266: }
4267:
4268: sprintf((*((struct_socket *) (*s_objet_resultat)
4269: .objet)).adresse, "%d.%d.%d.%d",
4270: (ntohl((*((struct sockaddr_in *)
4271: (*resolution_courante).ai_addr)).sin_addr
4272: .s_addr) >> 24) & 0xFF,
4273: (ntohl((*((struct sockaddr_in *)
4274: (*resolution_courante).ai_addr)).sin_addr
4275: .s_addr) >> 16) & 0xFF,
4276: (ntohl((*((struct sockaddr_in *)
4277: (*resolution_courante).ai_addr)).sin_addr
4278: .s_addr) >> 8) & 0xFF,
4279: ntohl((*((struct sockaddr_in *)
4280: (*resolution_courante).ai_addr)).sin_addr
4281: .s_addr) & 0xFF);
4282: }
4283: else
4284: { // Accès en IPv6
4285: resolution_courante = resolution;
4286:
4287: while(resolution_courante != NULL)
4288: {
4289: if ((*resolution_courante).ai_family ==
4290: AF_INET6)
4291: {
4292: break;
4293: }
4294:
4295: resolution_courante = (*resolution_courante)
4296: .ai_next;
4297: }
4298:
4299: if (resolution_courante == NULL)
4300: {
4301: liberation(s_etat_processus, s_objet_argument);
4302: liberation(s_etat_processus, s_objet_resultat);
4303:
4304: freeaddrinfo(resolution);
4305:
4306: (*s_etat_processus).erreur_execution =
4307: d_ex_erreur_acces_fichier;
4308: return;
4309: }
4310:
4311: if (((*((struct_socket *)
4312: (*s_objet_resultat).objet))
4313: .socket = socket(PF_INET6, type,
4314: protocole_numerique)) == -1)
4315: {
4316: liberation(s_etat_processus, s_objet_argument);
4317: liberation(s_etat_processus, s_objet_resultat);
4318:
4319: freeaddrinfo(resolution);
4320:
4321: (*s_etat_processus).erreur_execution =
4322: d_ex_erreur_acces_fichier;
4323: return;
4324: }
4325:
4326: (*((struct_socket *) (*s_objet_resultat).objet))
4327: .domaine = PF_INET6;
4328:
4329: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4330: socket_ipv6.sin6_family = AF_INET6;
4331: socket_ipv6.sin6_port = htons((uint16_t) port);
4332:
4333: for(i = 0; i < 16;
4334: socket_ipv6.sin6_addr.s6_addr[i] =
4335: (*((struct sockaddr_in6 *)
4336: (*resolution_courante).ai_addr))
4337: .sin6_addr.s6_addr[i], i++);
4338:
4339: if (options_socket() == d_erreur)
4340: {
4341: liberation(s_etat_processus, s_objet_argument);
4342: liberation(s_etat_processus, s_objet_resultat);
4343:
4344: freeaddrinfo(resolution);
4345: return;
4346: }
4347:
4348: if (bind((*((struct_socket *) (*s_objet_resultat)
4349: .objet)).socket, (const struct sockaddr *)
4350: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4351: {
4352: liberation(s_etat_processus, s_objet_argument);
4353: liberation(s_etat_processus, s_objet_resultat);
4354:
4355: freeaddrinfo(resolution);
4356:
4357: (*s_etat_processus).erreur_execution =
4358: d_ex_erreur_acces_fichier;
4359: return;
4360: }
4361:
4362: if (((*((struct_socket *) (*s_objet_resultat)
4363: .objet)).adresse = malloc(55 *
4364: sizeof(unsigned char))) == NULL)
4365: {
4366: (*s_etat_processus).erreur_systeme =
4367: d_es_allocation_memoire;
4368: return;
4369: }
4370:
4371: for(i = 0; i < 16; i++)
4372: {
4373: sprintf((*((struct_socket *) (*s_objet_resultat)
4374: .objet)).adresse,
4375: (i == 0) ? "%s%X" : "%s:%X",
4376: (*((struct_socket *) (*s_objet_resultat)
4377: .objet)).adresse,
4378: (*((struct sockaddr_in6 *)
4379: (*resolution_courante).ai_addr))
4380: .sin6_addr.s6_addr[i]);
4381: }
4382: }
4383:
4384: freeaddrinfo(resolution);
4385:
4386: sprintf((*((struct_socket *) (*s_objet_resultat)
4387: .objet)).adresse, "%s(%u)",
4388: (*((struct_socket *) (*s_objet_resultat)
4389: .objet)).adresse, (unsigned int) port);
4390: }
4391: else
4392: { // Hôte défini par une adresse
4393: if (strcmp(protocole, "IPV4") == 0)
4394: { // Accès en IPv4
4395: if (((*((struct_socket *) (*s_objet_resultat)
4396: .objet)).adresse = malloc(22 *
4397: sizeof(unsigned char))) == NULL)
4398: {
4399: (*s_etat_processus).erreur_systeme =
4400: d_es_allocation_memoire;
4401: return;
4402: }
4403:
4404: (*((struct_socket *) (*s_objet_resultat).objet))
4405: .adresse[0] = d_code_fin_chaine;
4406:
4407: for(i = 0; i < 4; i++)
4408: {
4409: sprintf((*((struct_socket *) (*s_objet_resultat)
4410: .objet)).adresse,
4411: (i == 0) ? "%s%d" : "%s.%d",
4412: (*((struct_socket *) (*s_objet_resultat)
4413: .objet)).adresse, (int) adresse[i]);
4414: }
4415:
4416: sprintf((*((struct_socket *) (*s_objet_resultat)
4417: .objet)).adresse, "%s(%u)",
4418: (*((struct_socket *) (*s_objet_resultat)
4419: .objet)).adresse, (unsigned int) port);
4420:
4421: if (((*((struct_socket *)
4422: (*s_objet_resultat).objet))
4423: .socket = socket(PF_INET, type,
4424: protocole_numerique)) == -1)
4425: {
4426: liberation(s_etat_processus, s_objet_argument);
4427: liberation(s_etat_processus, s_objet_resultat);
4428:
4429: (*s_etat_processus).erreur_execution =
4430: d_ex_erreur_acces_fichier;
4431: return;
4432: }
4433:
4434: (*((struct_socket *) (*s_objet_resultat).objet))
4435: .domaine = PF_INET;
4436:
4437: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4438: socket_ipv4.sin_family = AF_INET;
4439: socket_ipv4.sin_port = htons((uint16_t) port);
4440:
4441: adresse_ipv4 = 0;
4442: for(i = 0; i < 4; adresse_ipv4 =
4443: (256 * adresse_ipv4) + adresse[i++]);
4444:
4445: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
4446:
4447: if (options_socket() == d_erreur)
4448: {
4449: liberation(s_etat_processus, s_objet_argument);
4450: liberation(s_etat_processus, s_objet_resultat);
4451:
4452: return;
4453: }
4454:
4455: if (bind((*((struct_socket *) (*s_objet_resultat)
4456: .objet)).socket, (const struct sockaddr *)
4457: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4458: {
4459: liberation(s_etat_processus, s_objet_argument);
4460: liberation(s_etat_processus, s_objet_resultat);
4461:
4462: (*s_etat_processus).erreur_execution =
4463: d_ex_erreur_acces_fichier;
4464: return;
4465: }
4466: }
4467: else
4468: { // Accès en IPv6
4469: if (((*((struct_socket *) (*s_objet_resultat)
4470: .objet)).adresse = malloc(55 *
4471: sizeof(unsigned char))) == NULL)
4472: {
4473: (*s_etat_processus).erreur_systeme =
4474: d_es_allocation_memoire;
4475: return;
4476: }
4477:
4478: (*((struct_socket *) (*s_objet_resultat).objet))
4479: .adresse[0] = d_code_fin_chaine;
4480:
4481: for(i = 0; i < 16; i++)
4482: {
4483: sprintf((*((struct_socket *) (*s_objet_resultat)
4484: .objet)).adresse,
4485: (i == 0) ? "%s%X" : "%s:%X",
4486: (*((struct_socket *) (*s_objet_resultat)
4487: .objet)).adresse, (unsigned int)
4488: adresse[i]);
4489: }
4490:
4491: sprintf((*((struct_socket *) (*s_objet_resultat)
4492: .objet)).adresse, "%s(%u)",
4493: (*((struct_socket *) (*s_objet_resultat)
4494: .objet)).adresse, (unsigned int) port);
4495:
4496: if (((*((struct_socket *)
4497: (*s_objet_resultat).objet))
4498: .socket = socket(PF_INET6, type,
4499: protocole_numerique)) == -1)
4500: {
4501: liberation(s_etat_processus, s_objet_argument);
4502: liberation(s_etat_processus, s_objet_resultat);
4503:
4504: (*s_etat_processus).erreur_execution =
4505: d_ex_erreur_acces_fichier;
4506: return;
4507: }
4508:
4509: (*((struct_socket *) (*s_objet_resultat).objet))
4510: .domaine = PF_INET6;
4511:
4512: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4513: socket_ipv6.sin6_family = AF_INET6;
4514: socket_ipv6.sin6_port = htons((uint16_t) port);
4515:
4516: for(i = 0; i < 16;
4517: socket_ipv6.sin6_addr.s6_addr[i] =
4518: (unsigned char) (adresse[i]), i++);
4519:
4520: if (options_socket() == d_erreur)
4521: {
4522: liberation(s_etat_processus, s_objet_argument);
4523: liberation(s_etat_processus, s_objet_resultat);
4524:
4525: return;
4526: }
4527:
4528: if (bind((*((struct_socket *) (*s_objet_resultat)
4529: .objet)).socket, (const struct sockaddr *)
4530: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4531: {
4532: liberation(s_etat_processus, s_objet_argument);
4533: liberation(s_etat_processus, s_objet_resultat);
4534:
4535: (*s_etat_processus).erreur_execution =
4536: d_ex_erreur_acces_fichier;
4537: return;
4538: }
4539: }
4540: }
4541:
4542: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4543: = 'N';
4544: }
4545:
4546: if ((type_socket == 'S') || (type_socket == 'Q'))
4547: {
4548: if (listen((*((struct_socket *) (*s_objet_resultat).objet))
4549: .socket, (int) nombre_maximal_connexions) != 0)
4550: {
4551: liberation(s_etat_processus, s_objet_argument);
4552: liberation(s_etat_processus, s_objet_resultat);
4553:
4554: (*s_etat_processus).erreur_execution =
4555: d_ex_erreur_acces_fichier;
4556: return;
4557: }
4558:
4559: (*((struct_socket *) (*s_objet_resultat).objet))
4560: .socket_connectee = d_vrai;
4561:
4562: if (protection == 'R')
4563: { // WRITEONLY
4564: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4565: .objet)).socket, SHUT_RD) != 0)
4566: {
4567: liberation(s_etat_processus, s_objet_argument);
4568: liberation(s_etat_processus, s_objet_resultat);
4569:
4570: (*s_etat_processus).erreur_execution =
4571: d_ex_erreur_acces_fichier;
4572: return;
4573: }
4574: }
4575: else if (protection == 'W')
4576: { // READONLY
4577: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4578: .objet)).socket, SHUT_WR) != 0)
4579: {
4580: liberation(s_etat_processus, s_objet_argument);
4581: liberation(s_etat_processus, s_objet_resultat);
4582:
4583: (*s_etat_processus).erreur_execution =
4584: d_ex_erreur_acces_fichier;
4585: return;
4586: }
4587: }
4588: else
4589: { // READWRITE
4590: }
4591: }
4592: }
4593: else
4594: { // Socket cliente
4595: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4596: = 'N';
4597:
4598: /*
4599: * Dans le cas où la socket n'est pas connectée, on
4600: * ne peut utiliser ni "NAME", ni "HOST", ni "PORT",
4601: * et encore moins spécifier une adresse. En effet, la cible
4602: * est défini par la commande TARGET.
4603: */
4604:
4605: if ((type_socket != 'S') && (type_socket != 'Q'))
4606: {
4607: if ((presence_port == d_vrai) || (hote != NULL) ||
4608: (nom != NULL) || (type_adresse != ' '))
4609: {
4610: liberation(s_etat_processus, s_objet_argument);
4611: liberation(s_etat_processus, s_objet_resultat);
4612:
4613: (*s_etat_processus).erreur_execution =
4614: d_ex_erreur_parametre_fichier;
4615: return;
4616: }
4617: }
4618:
4619: if (nom != NULL)
4620: {
4621: /*
4622: * La socket est dans l'espace des noms.
4623: */
4624:
4625: if (((*((struct_socket *) (*s_objet_resultat).objet))
4626: .socket = socket(PF_UNIX, type,
4627: protocole_numerique)) == -1)
4628: {
4629: liberation(s_etat_processus, s_objet_argument);
4630: liberation(s_etat_processus, s_objet_resultat);
4631:
4632: (*s_etat_processus).erreur_execution =
4633: d_ex_erreur_acces_fichier;
4634: return;
4635: }
4636:
4637: (*((struct_socket *) (*s_objet_resultat).objet))
4638: .domaine = PF_UNIX;
4639:
4640: socket_unix.sun_family = AF_UNIX;
4641: strncpy(socket_unix.sun_path, (*((struct_socket *)
4642: (*s_objet_resultat).objet)).adresse, 108);
4643: socket_unix.sun_path[108 - 1] = d_code_fin_chaine;
4644:
4645: if ((type_socket == 'S') || (type_socket == 'Q'))
4646: {
4647: if (connect((*((struct_socket *) (*s_objet_resultat)
4648: .objet)).socket, (const struct sockaddr *)
4649: &socket_unix, sizeof(socket_unix)) != 0)
4650: {
4651: liberation(s_etat_processus, s_objet_argument);
4652: liberation(s_etat_processus, s_objet_resultat);
4653:
4654: (*s_etat_processus).erreur_execution =
4655: d_ex_erreur_acces_fichier;
4656: return;
4657: }
4658:
4659: (*((struct_socket *) (*s_objet_resultat).objet))
4660: .socket_connectee = d_vrai;
4661: (*((struct_socket *) (*s_objet_resultat).objet))
4662: .socket_en_ecoute = 'N';
4663: }
4664: }
4665: else
4666: {
4667: /*
4668: * La socket est une socket réseau. L'adresse
4669: * passée en argument est l'adresse sur laquelle
4670: * cette socket est à l'écoute.
4671: */
4672:
4673: if (hote != NULL)
4674: { // Hôte défini par un nom
4675: resolution = NULL;
4676:
4677: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4678: {
4679: liberation(s_etat_processus, s_objet_argument);
4680: liberation(s_etat_processus, s_objet_resultat);
4681:
4682: if (resolution != NULL)
4683: {
4684: freeaddrinfo(resolution);
4685: }
4686:
4687: (*s_etat_processus).erreur_execution =
4688: d_ex_erreur_acces_fichier;
4689: return;
4690: }
4691:
4692: if (strcmp(protocole, "IPV4") == 0)
4693: { // Accès en IPv4
4694: resolution_courante = resolution;
4695:
4696: while(resolution_courante != NULL)
4697: {
4698: if ((*resolution_courante).ai_family ==
4699: AF_INET)
4700: {
4701: break;
4702: }
4703:
4704: resolution_courante = (*resolution_courante)
4705: .ai_next;
4706: }
4707:
4708: if (resolution_courante == NULL)
4709: {
4710: liberation(s_etat_processus, s_objet_argument);
4711: liberation(s_etat_processus, s_objet_resultat);
4712:
4713: freeaddrinfo(resolution);
4714:
4715: (*s_etat_processus).erreur_execution =
4716: d_ex_erreur_acces_fichier;
4717: return;
4718: }
4719:
4720: if (((*((struct_socket *)
4721: (*s_objet_resultat).objet))
4722: .socket = socket(PF_INET, type,
4723: protocole_numerique)) == -1)
4724: {
4725: liberation(s_etat_processus, s_objet_argument);
4726: liberation(s_etat_processus, s_objet_resultat);
4727:
4728: freeaddrinfo(resolution);
4729:
4730: (*s_etat_processus).erreur_execution =
4731: d_ex_erreur_acces_fichier;
4732: return;
4733: }
4734:
4735: (*((struct_socket *) (*s_objet_resultat).objet))
4736: .domaine = PF_INET;
4737:
4738: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4739: socket_ipv4.sin_family = AF_INET;
4740: socket_ipv4.sin_port = htons((uint16_t) port);
4741: socket_ipv4.sin_addr.s_addr =
4742: (*((struct sockaddr_in *)
4743: (*resolution_courante).ai_addr))
4744: .sin_addr.s_addr;
4745:
4746: if ((type_socket == 'S') || (type_socket == 'Q'))
4747: {
4748: if (connect((*((struct_socket *)
4749: (*s_objet_resultat).objet)).socket,
4750: (const struct sockaddr *)
4751: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4752: {
4753: liberation(s_etat_processus,
4754: s_objet_argument);
4755: liberation(s_etat_processus,
4756: s_objet_resultat);
4757:
4758: freeaddrinfo(resolution);
4759:
4760: (*s_etat_processus).erreur_execution =
4761: d_ex_erreur_acces_fichier;
4762: return;
4763: }
4764:
4765: (*((struct_socket *) (*s_objet_resultat).objet))
4766: .socket_connectee = d_vrai;
4767: (*((struct_socket *) (*s_objet_resultat).objet))
4768: .socket_en_ecoute = 'N';
4769: }
4770:
4771: if (((*((struct_socket *) (*s_objet_resultat)
4772: .objet)).adresse = malloc(22 *
4773: sizeof(unsigned char))) == NULL)
4774: {
4775: (*s_etat_processus).erreur_systeme =
4776: d_es_allocation_memoire;
4777: return;
4778: }
4779:
4780: sprintf((*((struct_socket *) (*s_objet_resultat)
4781: .objet)).adresse, "%d.%d.%d.%d",
4782: (ntohl((*((struct sockaddr_in *)
4783: (*resolution_courante).ai_addr)).sin_addr
4784: .s_addr) >> 24) & 0xFF,
4785: (ntohl((*((struct sockaddr_in *)
4786: (*resolution_courante).ai_addr)).sin_addr
4787: .s_addr) >> 16) & 0xFF,
4788: (ntohl((*((struct sockaddr_in *)
4789: (*resolution_courante).ai_addr)).sin_addr
4790: .s_addr) >> 8) & 0xFF,
4791: ntohl((*((struct sockaddr_in *)
4792: (*resolution_courante).ai_addr)).sin_addr
4793: .s_addr) & 0xFF);
4794: }
4795: else
4796: { // Accès en IPv6
4797: resolution_courante = resolution;
4798:
4799: while(resolution_courante != NULL)
4800: {
4801: if ((*resolution_courante).ai_family ==
4802: AF_INET6)
4803: {
4804: break;
4805: }
4806:
4807: resolution_courante = (*resolution_courante)
4808: .ai_next;
4809: }
4810:
4811: if (resolution_courante == NULL)
4812: {
4813: liberation(s_etat_processus, s_objet_argument);
4814: liberation(s_etat_processus, s_objet_resultat);
4815:
4816: freeaddrinfo(resolution);
4817:
4818: (*s_etat_processus).erreur_execution =
4819: d_ex_erreur_acces_fichier;
4820: return;
4821: }
4822:
4823: if (((*((struct_socket *)
4824: (*s_objet_resultat).objet))
4825: .socket = socket(PF_INET6, type,
4826: protocole_numerique)) == -1)
4827: {
4828: liberation(s_etat_processus, s_objet_argument);
4829: liberation(s_etat_processus, s_objet_resultat);
4830:
4831: freeaddrinfo(resolution);
4832:
4833: (*s_etat_processus).erreur_execution =
4834: d_ex_erreur_acces_fichier;
4835: return;
4836: }
4837:
4838: (*((struct_socket *) (*s_objet_resultat).objet))
4839: .domaine = PF_INET6;
4840:
4841: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4842: socket_ipv6.sin6_family = AF_INET6;
4843: socket_ipv6.sin6_port = htons((uint16_t) port);
4844:
4845: for(i = 0; i < 16;
4846: socket_ipv6.sin6_addr.s6_addr[i] =
4847: (*((struct sockaddr_in6 *)
4848: (*resolution_courante).ai_addr))
4849: .sin6_addr.s6_addr[i], i++);
4850:
4851: if ((type_socket == 'S') || (type_socket == 'Q'))
4852: {
4853: if (connect((*((struct_socket *)
4854: (*s_objet_resultat).objet)).socket,
4855: (const struct sockaddr *)
4856: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4857: {
4858: liberation(s_etat_processus,
4859: s_objet_argument);
4860: liberation(s_etat_processus,
4861: s_objet_resultat);
4862:
4863: freeaddrinfo(resolution);
4864:
4865: (*s_etat_processus).erreur_execution =
4866: d_ex_erreur_acces_fichier;
4867: return;
4868: }
4869:
4870: (*((struct_socket *) (*s_objet_resultat).objet))
4871: .socket_connectee = d_vrai;
4872: (*((struct_socket *) (*s_objet_resultat).objet))
4873: .socket_en_ecoute = 'N';
4874: }
4875:
4876: if (((*((struct_socket *) (*s_objet_resultat)
4877: .objet)).adresse = malloc(55 *
4878: sizeof(unsigned char))) == NULL)
4879: {
4880: (*s_etat_processus).erreur_systeme =
4881: d_es_allocation_memoire;
4882: return;
4883: }
4884:
4885: for(i = 0; i < 16; i++)
4886: {
4887: sprintf((*((struct_socket *) (*s_objet_resultat)
4888: .objet)).adresse,
4889: (i == 0) ? "%s%X" : "%s:%X",
4890: (*((struct_socket *) (*s_objet_resultat)
4891: .objet)).adresse,
4892: (*((struct sockaddr_in6 *)
4893: (*resolution_courante).ai_addr))
4894: .sin6_addr.s6_addr[i]);
4895: }
4896: }
4897:
4898: freeaddrinfo(resolution);
4899:
4900: sprintf((*((struct_socket *) (*s_objet_resultat)
4901: .objet)).adresse, "%s(%u)",
4902: (*((struct_socket *) (*s_objet_resultat)
4903: .objet)).adresse, (unsigned int) port);
4904: }
4905: else
4906: { // Hôte défini par une adresse
4907: if (strcmp(protocole, "IPV4") == 0)
4908: { // Accès en IPv4
4909: if (type_adresse == '4')
4910: {
4911: if (((*((struct_socket *) (*s_objet_resultat)
4912: .objet)).adresse = malloc(22 *
4913: sizeof(unsigned char))) == NULL)
4914: {
4915: (*s_etat_processus).erreur_systeme =
4916: d_es_allocation_memoire;
4917: return;
4918: }
4919:
4920: (*((struct_socket *) (*s_objet_resultat).objet))
4921: .adresse[0] = d_code_fin_chaine;
4922:
4923: for(i = 0; i < 4; i++)
4924: {
4925: sprintf((*((struct_socket *)
4926: (*s_objet_resultat).objet)).adresse,
4927: (i == 0) ? "%s%d" : "%s.%d",
4928: (*((struct_socket *)
4929: (*s_objet_resultat)
4930: .objet)).adresse, (int) adresse[i]);
4931: }
4932:
4933: sprintf((*((struct_socket *) (*s_objet_resultat)
4934: .objet)).adresse, "%s(%u)",
4935: (*((struct_socket *) (*s_objet_resultat)
4936: .objet)).adresse, (unsigned int) port);
4937: }
4938: else
4939: {
4940: if (((*((struct_socket *) (*s_objet_resultat)
4941: .objet)).adresse = malloc(
4942: sizeof(unsigned char))) == NULL)
4943: {
4944: (*s_etat_processus).erreur_systeme =
4945: d_es_allocation_memoire;
4946: return;
4947: }
4948:
4949: (*((struct_socket *) (*s_objet_resultat).objet))
4950: .adresse[0] = d_code_fin_chaine;
4951: }
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 ((type_socket == 'S') || (type_socket == 'Q'))
4980: {
4981: if (connect((*((struct_socket *)
4982: (*s_objet_resultat).objet)).socket,
4983: (const struct sockaddr *)
4984: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4985: {
4986: liberation(s_etat_processus,
4987: s_objet_argument);
4988: liberation(s_etat_processus,
4989: s_objet_resultat);
4990:
4991: (*s_etat_processus).erreur_execution =
4992: d_ex_erreur_acces_fichier;
4993: return;
4994: }
4995:
4996: (*((struct_socket *) (*s_objet_resultat).objet))
4997: .socket_connectee = d_vrai;
4998: (*((struct_socket *) (*s_objet_resultat).objet))
4999: .socket_en_ecoute = 'N';
5000: }
5001: }
5002: else if (strcmp(protocole, "IPV6") == 0)
5003: { // Accès en IPv6
5004: if (type_adresse == '6')
5005: {
5006: if (((*((struct_socket *) (*s_objet_resultat)
5007: .objet)).adresse = malloc(55 *
5008: sizeof(unsigned char))) == NULL)
5009: {
5010: (*s_etat_processus).erreur_systeme =
5011: d_es_allocation_memoire;
5012: return;
5013: }
5014:
5015: (*((struct_socket *) (*s_objet_resultat).objet))
5016: .adresse[0] = d_code_fin_chaine;
5017:
5018: for(i = 0; i < 16; i++)
5019: {
5020: sprintf((*((struct_socket *)
5021: (*s_objet_resultat).objet)).adresse,
5022: (i == 0) ? "%s%X" : "%s:%X",
5023: (*((struct_socket *)
5024: (*s_objet_resultat)
5025: .objet)).adresse, (unsigned int)
5026: adresse[i]);
5027: }
5028:
5029: sprintf((*((struct_socket *) (*s_objet_resultat)
5030: .objet)).adresse, "%s(%u)",
5031: (*((struct_socket *) (*s_objet_resultat)
5032: .objet)).adresse, (unsigned int) port);
5033: }
5034: else
5035: {
5036: if (((*((struct_socket *) (*s_objet_resultat)
5037: .objet)).adresse = malloc(
5038: sizeof(unsigned char))) == NULL)
5039: {
5040: (*s_etat_processus).erreur_systeme =
5041: d_es_allocation_memoire;
5042: return;
5043: }
5044:
5045: (*((struct_socket *) (*s_objet_resultat).objet))
5046: .adresse[0] = d_code_fin_chaine;
5047: }
5048:
5049: if (((*((struct_socket *)
5050: (*s_objet_resultat).objet))
5051: .socket = socket(PF_INET6, type,
5052: protocole_numerique)) == -1)
5053: {
5054: liberation(s_etat_processus, s_objet_argument);
5055: liberation(s_etat_processus, s_objet_resultat);
5056:
5057: (*s_etat_processus).erreur_execution =
5058: d_ex_erreur_acces_fichier;
5059: return;
5060: }
5061:
5062: (*((struct_socket *) (*s_objet_resultat).objet))
5063: .domaine = PF_INET6;
5064:
5065: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5066: socket_ipv6.sin6_family = AF_INET6;
5067: socket_ipv6.sin6_port = htons((uint16_t) port);
5068:
5069: for(i = 0; i < 16;
5070: socket_ipv6.sin6_addr.s6_addr[i] =
5071: (unsigned char) (adresse[i]), i++);
5072:
5073: if ((type_socket == 'S') || (type_socket == 'Q'))
5074: {
5075: if (connect((*((struct_socket *)
5076: (*s_objet_resultat).objet)).socket,
5077: (const struct sockaddr *)
5078: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5079: {
5080: liberation(s_etat_processus,
5081: s_objet_argument);
5082: liberation(s_etat_processus,
5083: s_objet_resultat);
5084:
5085: (*s_etat_processus).erreur_execution =
5086: d_ex_erreur_acces_fichier;
5087: return;
5088: }
5089:
5090: (*((struct_socket *) (*s_objet_resultat).objet))
5091: .socket_connectee = d_vrai;
5092: (*((struct_socket *) (*s_objet_resultat).objet))
5093: .socket_en_ecoute = 'N';
5094: }
5095: }
5096: else
5097: { // Socket UNIX
5098: if (((*((struct_socket *) (*s_objet_resultat)
5099: .objet)).adresse = malloc(
5100: sizeof(unsigned char))) == NULL)
5101: {
5102: (*s_etat_processus).erreur_systeme =
5103: d_es_allocation_memoire;
5104: return;
5105: }
5106:
5107: (*((struct_socket *) (*s_objet_resultat).objet))
5108: .adresse[0] = d_code_fin_chaine;
5109:
5110: if (((*((struct_socket *)
5111: (*s_objet_resultat).objet))
5112: .socket = socket(PF_UNIX, type,
5113: protocole_numerique)) == -1)
5114: {
5115: liberation(s_etat_processus, s_objet_argument);
5116: liberation(s_etat_processus, s_objet_resultat);
5117:
5118: (*s_etat_processus).erreur_execution =
5119: d_ex_erreur_acces_fichier;
5120: return;
5121: }
5122: }
5123: }
5124:
5125: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
5126: = 'N';
5127: }
5128:
5129: if ((type_socket == 'S') || (type_socket == 'Q'))
5130: {
5131: if (protection == 'R')
5132: { // WRITEONLY
5133: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5134: .objet)).socket, SHUT_RD) != 0)
5135: {
5136: liberation(s_etat_processus, s_objet_argument);
5137: liberation(s_etat_processus, s_objet_resultat);
5138:
5139: (*s_etat_processus).erreur_execution =
5140: d_ex_erreur_acces_fichier;
5141: return;
5142: }
5143: }
5144: else if (protection == 'W')
5145: { // READONLY
5146: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5147: .objet)).socket, SHUT_WR) != 0)
5148: {
5149: liberation(s_etat_processus, s_objet_argument);
5150: liberation(s_etat_processus, s_objet_resultat);
5151:
5152: (*s_etat_processus).erreur_execution =
5153: d_ex_erreur_acces_fichier;
5154: return;
5155: }
5156: }
5157: else
5158: { // READWRITE
5159: }
5160: }
5161: }
5162:
5163: /*
5164: * Gestion de la liste des sockets ouvertes
5165: */
5166:
5167: l_element_courant = (*s_etat_processus).s_sockets;
5168:
5169: if (l_element_courant == NULL)
5170: {
5171: if (((*s_etat_processus).s_sockets =
5172: allocation_maillon(s_etat_processus)) == NULL)
5173: {
5174: (*s_etat_processus).erreur_systeme =
5175: d_es_allocation_memoire;
5176: return;
5177: }
5178:
5179: (*(*s_etat_processus).s_sockets).suivant = NULL;
5180: l_element_courant = (*s_etat_processus).s_sockets;
5181: }
5182: else
5183: {
5184: /*
5185: * Ajout d'un élément à la fin de la liste chaînée
5186: */
5187:
5188: while((*l_element_courant).suivant != NULL)
5189: {
5190: l_element_courant = (*l_element_courant).suivant;
5191: }
5192:
5193: if (((*l_element_courant).suivant =
5194: allocation_maillon(s_etat_processus)) == NULL)
5195: {
5196: (*s_etat_processus).erreur_systeme =
5197: d_es_allocation_memoire;
5198: return;
5199: }
5200:
5201: l_element_courant = (*l_element_courant).suivant;
5202: (*l_element_courant).suivant = NULL;
5203: }
5204:
5205: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
5206: s_objet_resultat, 'O')) == NULL)
5207: {
5208: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5209: return;
5210: }
5211: }
5212: else
5213: {
5214: liberation(s_etat_processus, s_objet_argument);
5215:
5216: (*s_etat_processus).erreur_execution =
5217: d_ex_erreur_parametre_fichier;
5218: return;
5219: }
5220: }
5221: else if ((*s_objet_argument).type == CHN)
5222: {
5223: if ((s_objet_resultat = allocation(s_etat_processus, SPH)) == NULL)
5224: {
5225: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5226: return;
5227: }
5228:
5229: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).nom =
5230: malloc((strlen((unsigned char *) (*s_objet_argument).objet)
5231: + 1) *sizeof(unsigned char))) == NULL)
5232: {
5233: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5234: return;
5235: }
5236:
5237: strcpy((*((struct_semaphore *) (*s_objet_resultat).objet)).nom,
5238: (unsigned char *) (*s_objet_argument).objet);
5239:
5240: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).semaphore =
5241: sem_open((*((struct_semaphore *) (*s_objet_resultat).objet))
5242: .nom, 0)) == SEM_FAILED)
5243: {
5244: if (errno == ENOMEM)
5245: {
5246: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5247: return;
5248: }
5249:
5250: (*s_etat_processus).erreur_execution = d_ex_semaphore;
5251:
5252: liberation(s_etat_processus, s_objet_argument);
5253: liberation(s_etat_processus, s_objet_resultat);
5254: return;
5255: }
5256: }
5257: else
5258: {
5259: liberation(s_etat_processus, s_objet_argument);
5260:
5261: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
5262: return;
5263: }
5264:
5265: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5266: s_objet_resultat) == d_erreur)
5267: {
5268: return;
5269: }
5270:
5271: return;
5272: }
5273:
5274: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_o1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src