Return to instructions_o1.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.8 ! bertrand 3: RPL/2 (R) version 4.0.13
1.1 bertrand 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:
1.6 bertrand 923: sqlite3 *sqlite;
924:
1.1 bertrand 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)) ||
1.7 bertrand 2652: ((type_acces == 'I') && (position_clef == 0) &&
2653: ((type_ouverture == 'N') || (type_ouverture == 'R') ||
2654: (type_ouverture == 'S'))))
1.1 bertrand 2655: {
2656: liberation(s_etat_processus, s_objet_argument);
2657:
2658: (*s_etat_processus).erreur_execution =
2659: d_ex_erreur_parametre_fichier;
2660: return;
2661: }
2662:
2663: if ((s_objet_resultat = allocation(s_etat_processus, FCH))
2664: == NULL)
2665: {
2666: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2667: return;
2668: }
2669:
2670: if (nom == NULL)
2671: {
2672: if ((nom_temporaire = creation_nom_fichier(s_etat_processus,
2673: (*s_etat_processus).chemin_fichiers_temporaires))
2674: == NULL)
2675: {
2676: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2677: return;
2678: }
2679:
2680: if ((nom = malloc((strlen(nom_temporaire)
2681: + 5) * sizeof(unsigned char))) == NULL)
2682: {
2683: (*s_etat_processus).erreur_systeme =
2684: d_es_allocation_memoire;
2685: return;
2686: }
2687:
2688: sprintf(nom, "%s.rpl", nom_temporaire);
2689: free(nom_temporaire);
2690: }
2691: else
2692: {
1.6 bertrand 2693: if ((nom = transliteration(s_etat_processus, nom,
2694: d_locale, "UTF-8")) == NULL)
2695: {
2696: liberation(s_etat_processus, s_objet_argument);
2697: liberation(s_etat_processus, s_objet_resultat);
2698: return;
2699: }
1.1 bertrand 2700: }
2701:
2702: /*
2703: * Ouverture du fichier
2704: */
2705:
2706: (*((struct_fichier *) (*s_objet_resultat).objet))
2707: .nom = NULL;
2708: (*((struct_fichier *) (*s_objet_resultat).objet))
2709: .acces = type_acces;
2710: (*((struct_fichier *) (*s_objet_resultat).objet))
2711: .binaire = format;
2712: (*((struct_fichier *) (*s_objet_resultat).objet))
2713: .ouverture = type_ouverture;
2714: (*((struct_fichier *) (*s_objet_resultat).objet)).pid
2715: = getpid();
2716: (*((struct_fichier *) (*s_objet_resultat).objet)).tid
2717: = pthread_self();
2718:
2719: if (((*((struct_fichier *) (*s_objet_resultat).objet)).format =
2720: allocation(s_etat_processus, LST)) == NULL)
2721: {
1.6 bertrand 2722: free(nom);
2723:
1.1 bertrand 2724: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2725: return;
2726: }
2727:
2728: (*(*((struct_fichier *) (*s_objet_resultat).objet))
2729: .format).objet = NULL;
2730:
1.6 bertrand 2731: descripteur = NULL;
2732:
1.1 bertrand 2733: switch(type_ouverture)
2734: {
2735: case 'N' :
2736: {
2737: erreur = caracteristiques_fichier(s_etat_processus,
2738: nom, &existence, &ouverture, &unite);
2739:
2740: if ((erreur != 0) || (unite != 0))
2741: {
1.6 bertrand 2742: free(nom);
2743:
1.1 bertrand 2744: liberation(s_etat_processus, s_objet_argument);
2745: liberation(s_etat_processus, s_objet_resultat);
2746:
2747: (*s_etat_processus).erreur_execution =
2748: d_ex_erreur_acces_fichier;
2749: return;
2750: }
2751:
1.6 bertrand 2752: if (type_acces == 'S')
2753: {
2754: if ((descripteur = fopen(nom, "w+")) == NULL)
2755: {
2756: free(nom);
2757:
2758: liberation(s_etat_processus, s_objet_argument);
2759: liberation(s_etat_processus, s_objet_resultat);
2760:
2761: (*s_etat_processus).erreur_execution =
2762: d_ex_erreur_acces_fichier;
2763: return;
2764: }
2765: }
2766: else
1.1 bertrand 2767: {
1.6 bertrand 2768: // Si le fichier existe, on le supprime.
2769:
2770: if (unlink(nom) != 0)
2771: {
2772: free(nom);
2773:
2774: liberation(s_etat_processus, s_objet_argument);
2775: liberation(s_etat_processus, s_objet_resultat);
2776:
2777: (*s_etat_processus).erreur_execution =
2778: d_ex_erreur_acces_fichier;
2779: return;
2780: }
2781:
2782: if (sqlite3_open_v2(nom, &sqlite,
2783: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
2784: NULL) != SQLITE_OK)
2785: {
2786: free(nom);
2787:
2788: liberation(s_etat_processus, s_objet_argument);
2789: liberation(s_etat_processus, s_objet_resultat);
2790:
2791: (*s_etat_processus).erreur_execution =
2792: d_ex_erreur_acces_fichier;
2793: return;
2794: }
2795:
2796: if ((descripteur = fopen(nom, "a+")) == NULL)
2797: {
2798: free(nom);
2799:
2800: liberation(s_etat_processus, s_objet_argument);
2801: liberation(s_etat_processus, s_objet_resultat);
2802:
2803: (*s_etat_processus).erreur_execution =
2804: d_ex_erreur_acces_fichier;
2805: return;
2806: }
2807:
2808: if (type_acces == 'D')
2809: {
2810: if (initialisation_fichier_acces_direct(
2811: s_etat_processus, sqlite,
2812: (format == 'N') ? d_faux : d_vrai)
2813: != d_absence_erreur)
2814: {
2815: free(nom);
2816:
2817: liberation(s_etat_processus, s_objet_argument);
2818: liberation(s_etat_processus, s_objet_resultat);
2819:
2820: return;
2821: }
2822: }
2823: else
2824: {
1.7 bertrand 2825: if (position_clef == 0)
2826: {
2827: free(nom);
2828:
2829: liberation(s_etat_processus, s_objet_argument);
2830: liberation(s_etat_processus, s_objet_resultat);
2831:
2832: (*s_etat_processus).erreur_execution =
2833: d_ex_erreur_parametre_fichier;
2834: return;
2835: }
2836:
1.6 bertrand 2837: if (initialisation_fichier_acces_indexe(
1.7 bertrand 2838: s_etat_processus, sqlite, position_clef,
1.6 bertrand 2839: (format == 'N') ? d_faux : d_vrai)
2840: != d_absence_erreur)
2841: {
2842: free(nom);
2843:
2844: liberation(s_etat_processus, s_objet_argument);
2845: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 2846:
1.6 bertrand 2847: return;
2848: }
2849: }
1.1 bertrand 2850: }
2851:
2852: break;
2853: }
2854:
2855: case 'O' :
2856: {
1.6 bertrand 2857: erreur = caracteristiques_fichier(s_etat_processus, nom,
2858: &existence, &ouverture, &unite);
1.1 bertrand 2859:
2860: if ((erreur != d_absence_erreur) || (existence == d_faux))
2861: {
1.6 bertrand 2862: free(nom);
2863:
1.1 bertrand 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:
1.6 bertrand 2872: if (type_acces == 'S')
1.1 bertrand 2873: {
1.6 bertrand 2874: if ((descripteur = fopen(nom, "r+")) == NULL)
2875: {
2876: free(nom);
2877:
2878: liberation(s_etat_processus, s_objet_argument);
2879: liberation(s_etat_processus, s_objet_resultat);
2880:
2881: (*s_etat_processus).erreur_execution =
2882: d_ex_erreur_acces_fichier;
2883: return;
2884: }
2885: }
2886: else
2887: {
2888: if (sqlite3_open_v2(nom, &sqlite,
2889: SQLITE_OPEN_READWRITE,
2890: NULL) != SQLITE_OK)
2891: {
2892: free(nom);
2893:
2894: liberation(s_etat_processus, s_objet_argument);
2895: liberation(s_etat_processus, s_objet_resultat);
2896:
2897: (*s_etat_processus).erreur_execution =
2898: d_ex_erreur_acces_fichier;
2899: return;
2900: }
2901:
2902: if ((descripteur = fopen(nom, "a+")) == NULL)
2903: {
2904: free(nom);
2905:
2906: liberation(s_etat_processus, s_objet_argument);
2907: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 2908:
1.6 bertrand 2909: (*s_etat_processus).erreur_execution =
2910: d_ex_erreur_acces_fichier;
2911: return;
2912: }
1.1 bertrand 2913: }
2914:
2915: break;
2916: }
2917:
2918: case 'R' :
2919: {
2920: erreur = caracteristiques_fichier(s_etat_processus,
2921: nom, &existence, &ouverture, &unite);
2922:
2923: if ((erreur != d_absence_erreur) || (existence == d_faux))
2924: {
1.6 bertrand 2925: free(nom);
2926:
1.1 bertrand 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: /* Test du verrou */
2936:
2937: if ((descripteur = fopen(nom, "r")) == NULL)
2938: {
1.6 bertrand 2939: free(nom);
2940:
1.1 bertrand 2941: liberation(s_etat_processus, s_objet_argument);
2942: liberation(s_etat_processus, s_objet_resultat);
2943:
2944: (*s_etat_processus).erreur_execution =
2945: d_ex_erreur_acces_fichier;
2946: return;
2947: }
2948:
2949: lock.l_type = F_WRLCK;
2950: lock.l_whence = SEEK_SET;
2951: lock.l_start = 0;
2952: lock.l_len = 0;
2953: lock.l_pid = getpid();
2954:
2955: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
2956: {
1.6 bertrand 2957: free(nom);
2958:
1.1 bertrand 2959: if (fclose(descripteur) != 0)
2960: {
1.6 bertrand 2961: liberation(s_etat_processus, s_objet_argument);
1.1 bertrand 2962: liberation(s_etat_processus, s_objet_resultat);
2963:
2964: (*s_etat_processus).erreur_systeme =
2965: d_es_erreur_fichier;
2966: return;
2967: }
2968:
1.6 bertrand 2969: liberation(s_etat_processus, s_objet_argument);
1.1 bertrand 2970: liberation(s_etat_processus, s_objet_resultat);
2971:
2972: (*s_etat_processus).erreur_systeme =
2973: d_es_erreur_fichier;
2974: return;
2975: }
2976:
1.6 bertrand 2977: if (lock.l_type != F_UNLCK)
2978: {
2979: free(nom);
2980:
2981: if (fclose(descripteur) != 0)
2982: {
2983: liberation(s_etat_processus, s_objet_argument);
2984: liberation(s_etat_processus, s_objet_resultat);
2985:
2986: (*s_etat_processus).erreur_systeme =
2987: d_es_erreur_fichier;
2988: return;
2989: }
2990:
2991: liberation(s_etat_processus, s_objet_argument);
2992: liberation(s_etat_processus, s_objet_resultat);
2993:
2994: (*s_etat_processus).erreur_execution =
2995: d_ex_fichier_verrouille;
2996: return;
2997: }
2998:
1.1 bertrand 2999: if (fclose(descripteur) != 0)
3000: {
1.6 bertrand 3001: free(nom);
3002:
3003: liberation(s_etat_processus, s_objet_argument);
1.1 bertrand 3004: liberation(s_etat_processus, s_objet_resultat);
3005:
3006: (*s_etat_processus).erreur_systeme =
3007: d_es_erreur_fichier;
3008: return;
3009: }
3010:
1.6 bertrand 3011: if (type_acces == 'S')
1.1 bertrand 3012: {
1.6 bertrand 3013: if ((descripteur = fopen(nom, "w+")) == NULL)
3014: {
3015: free(nom);
3016:
3017: liberation(s_etat_processus, s_objet_argument);
3018: liberation(s_etat_processus, s_objet_resultat);
3019:
3020: (*s_etat_processus).erreur_execution =
3021: d_ex_erreur_acces_fichier;
3022: return;
3023: }
3024: }
3025: else
3026: {
3027: if (sqlite3_open_v2(nom, &sqlite,
3028: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3029: NULL) != SQLITE_OK)
3030: {
3031: free(nom);
3032:
3033: liberation(s_etat_processus, s_objet_argument);
3034: liberation(s_etat_processus, s_objet_resultat);
3035:
3036: (*s_etat_processus).erreur_execution =
3037: d_ex_erreur_acces_fichier;
3038: return;
3039: }
3040:
3041: // Ouverture du fichier pour pouvoir gérer les
3042: // verrous à la façon des fichiers séquentiels.
3043:
3044: if ((descripteur = fopen(nom, "a+")) == NULL)
3045: {
3046: free(nom);
3047:
3048: liberation(s_etat_processus, s_objet_argument);
3049: liberation(s_etat_processus, s_objet_resultat);
3050:
3051: (*s_etat_processus).erreur_execution =
3052: d_ex_erreur_acces_fichier;
3053: return;
3054: }
3055:
3056: if (type_acces == 'D')
3057: {
3058: if (initialisation_fichier_acces_direct(
3059: s_etat_processus, sqlite,
3060: (format == 'N') ? d_faux : d_vrai)
3061: != d_absence_erreur)
3062: {
3063: free(nom);
3064:
3065: liberation(s_etat_processus, s_objet_argument);
3066: liberation(s_etat_processus, s_objet_resultat);
3067:
3068: return;
3069: }
3070: }
3071: else
3072: {
1.7 bertrand 3073: if (position_clef == 0)
3074: {
3075: free(nom);
3076:
3077: liberation(s_etat_processus, s_objet_argument);
3078: liberation(s_etat_processus, s_objet_resultat);
3079:
3080: (*s_etat_processus).erreur_execution =
3081: d_ex_erreur_parametre_fichier;
3082: return;
3083: }
3084:
1.6 bertrand 3085: if (initialisation_fichier_acces_indexe(
1.7 bertrand 3086: s_etat_processus, sqlite, position_clef,
1.6 bertrand 3087: (format == 'N') ? d_faux : d_vrai)
3088: != d_absence_erreur)
3089: {
3090: free(nom);
3091:
3092: liberation(s_etat_processus, s_objet_argument);
3093: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 3094:
1.6 bertrand 3095: return;
3096: }
3097: }
1.1 bertrand 3098: }
3099:
3100: break;
3101: }
3102:
3103: case 'U' :
3104: {
3105: erreur = caracteristiques_fichier(s_etat_processus,
3106: nom, &existence, &ouverture, &unite);
3107:
3108: if (erreur == d_erreur)
3109: {
1.6 bertrand 3110: free(nom);
3111:
1.1 bertrand 3112: liberation(s_etat_processus, s_objet_argument);
3113: liberation(s_etat_processus, s_objet_resultat);
3114:
3115: (*s_etat_processus).erreur_execution =
3116: d_ex_erreur_acces_fichier;
3117: return;
3118: }
3119:
3120: if (existence == d_faux)
3121: {
1.6 bertrand 3122: if (type_acces == 'S')
3123: {
3124: if ((descripteur = fopen(nom, "w+")) == NULL)
3125: {
3126: free(nom);
3127:
3128: liberation(s_etat_processus, s_objet_argument);
3129: liberation(s_etat_processus, s_objet_resultat);
3130:
3131: (*s_etat_processus).erreur_execution =
3132: d_ex_erreur_acces_fichier;
3133: return;
3134: }
3135: }
3136: else
1.1 bertrand 3137: {
1.6 bertrand 3138: if (sqlite3_open_v2(nom, &sqlite,
3139: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3140: NULL) != SQLITE_OK)
3141: {
3142: free(nom);
3143:
3144: liberation(s_etat_processus, s_objet_argument);
3145: liberation(s_etat_processus, s_objet_resultat);
3146:
3147: (*s_etat_processus).erreur_execution =
3148: d_ex_erreur_acces_fichier;
3149: return;
3150: }
3151:
3152: if ((descripteur = fopen(nom, "a+")) == NULL)
3153: {
3154: free(nom);
3155:
3156: liberation(s_etat_processus, s_objet_argument);
3157: liberation(s_etat_processus, s_objet_resultat);
3158:
3159: (*s_etat_processus).erreur_execution =
3160: d_ex_erreur_acces_fichier;
3161: return;
3162: }
3163:
3164: if (type_acces == 'D')
3165: {
3166: if (initialisation_fichier_acces_direct(
3167: s_etat_processus, sqlite,
3168: (format == 'N') ? d_faux : d_vrai)
3169: != d_absence_erreur)
3170: {
3171: free(nom);
3172:
3173: liberation(s_etat_processus,
3174: s_objet_argument);
3175: liberation(s_etat_processus,
3176: s_objet_resultat);
3177:
3178: return;
3179: }
3180: }
3181: else
3182: {
1.7 bertrand 3183: if (position_clef == 0)
3184: {
3185: free(nom);
3186:
3187: liberation(s_etat_processus,
3188: s_objet_argument);
3189: liberation(s_etat_processus,
3190: s_objet_resultat);
3191:
3192: (*s_etat_processus).erreur_execution =
3193: d_ex_erreur_parametre_fichier;
3194: return;
3195: }
3196:
1.6 bertrand 3197: if (initialisation_fichier_acces_indexe(
1.7 bertrand 3198: s_etat_processus, sqlite, position_clef,
1.6 bertrand 3199: (format == 'N') ? d_faux : d_vrai)
3200: != d_absence_erreur)
3201: {
3202: free(nom);
3203:
3204: liberation(s_etat_processus,
3205: s_objet_argument);
3206: liberation(s_etat_processus,
3207: s_objet_resultat);
1.1 bertrand 3208:
1.6 bertrand 3209: return;
3210: }
3211: }
1.1 bertrand 3212: }
3213: }
3214: else
3215: {
1.6 bertrand 3216: if (type_acces == 'S')
3217: {
3218: if ((descripteur = fopen(nom, "r+")) == NULL)
3219: {
3220: free(nom);
3221:
3222: liberation(s_etat_processus, s_objet_argument);
3223: liberation(s_etat_processus, s_objet_resultat);
3224:
3225: (*s_etat_processus).erreur_execution =
3226: d_ex_erreur_acces_fichier;
3227: return;
3228: }
3229: }
3230: else
1.1 bertrand 3231: {
1.6 bertrand 3232: if (sqlite3_open_v2(nom, &sqlite,
3233: SQLITE_OPEN_READWRITE,
3234: NULL) != SQLITE_OK)
3235: {
3236: free(nom);
3237:
3238: liberation(s_etat_processus, s_objet_argument);
3239: liberation(s_etat_processus, s_objet_resultat);
3240:
3241: (*s_etat_processus).erreur_execution =
3242: d_ex_erreur_acces_fichier;
3243: return;
3244: }
3245:
3246: if ((descripteur = fopen(nom, "a+")) == NULL)
3247: {
3248: free(nom);
3249:
3250: liberation(s_etat_processus, s_objet_argument);
3251: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 3252:
1.6 bertrand 3253: (*s_etat_processus).erreur_execution =
3254: d_ex_erreur_acces_fichier;
3255: return;
3256: }
1.1 bertrand 3257: }
3258: }
3259:
3260: break;
3261: }
3262:
3263: case 'S' :
3264: {
3265: erreur = caracteristiques_fichier(s_etat_processus,
3266: nom, &existence, &ouverture, &unite);
3267:
3268: if ((erreur != d_absence_erreur) || (existence != d_faux))
3269: {
1.6 bertrand 3270: free(nom);
3271:
1.1 bertrand 3272: liberation(s_etat_processus, s_objet_argument);
3273: liberation(s_etat_processus, s_objet_resultat);
3274:
3275: (*s_etat_processus).erreur_execution =
3276: d_ex_erreur_acces_fichier;
3277: return;
3278: }
3279:
1.6 bertrand 3280: if (type_acces == 'S')
1.1 bertrand 3281: {
1.6 bertrand 3282: if ((descripteur = fopen(nom, "w+")) == NULL)
3283: {
3284: free(nom);
3285:
3286: liberation(s_etat_processus, s_objet_argument);
3287: liberation(s_etat_processus, s_objet_resultat);
3288:
3289: (*s_etat_processus).erreur_execution =
3290: d_ex_erreur_acces_fichier;
3291: return;
3292: }
3293: }
3294: else
3295: {
3296: // Si le fichier existe, on le supprime.
3297:
3298: if (unlink(nom) != 0)
3299: {
3300: free(nom);
3301:
3302: liberation(s_etat_processus, s_objet_argument);
3303: liberation(s_etat_processus, s_objet_resultat);
3304:
3305: (*s_etat_processus).erreur_execution =
3306: d_ex_erreur_acces_fichier;
3307: return;
3308: }
3309:
3310: if (sqlite3_open_v2(nom, &sqlite,
3311: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
3312: NULL) != SQLITE_OK)
3313: {
3314: free(nom);
3315:
3316: liberation(s_etat_processus, s_objet_argument);
3317: liberation(s_etat_processus, s_objet_resultat);
3318:
3319: (*s_etat_processus).erreur_execution =
3320: d_ex_erreur_acces_fichier;
3321: return;
3322: }
3323:
3324: if ((descripteur = fopen(nom, "a+")) == NULL)
3325: {
3326: free(nom);
3327:
3328: liberation(s_etat_processus, s_objet_argument);
3329: liberation(s_etat_processus, s_objet_resultat);
3330:
3331: (*s_etat_processus).erreur_execution =
3332: d_ex_erreur_acces_fichier;
3333: return;
3334: }
3335:
3336: if (type_acces == 'D')
3337: {
3338: if (initialisation_fichier_acces_direct(
3339: s_etat_processus, sqlite,
3340: (format == 'N') ? d_faux : d_vrai)
3341: != d_absence_erreur)
3342: {
3343: free(nom);
3344:
3345: liberation(s_etat_processus, s_objet_argument);
3346: liberation(s_etat_processus, s_objet_resultat);
3347:
3348: return;
3349: }
3350: }
3351: else
1.7 bertrand 3352: {
3353: if (position_clef == 0)
3354: {
3355: free(nom);
3356:
3357: liberation(s_etat_processus, s_objet_argument);
3358: liberation(s_etat_processus, s_objet_resultat);
3359:
3360: (*s_etat_processus).erreur_execution =
3361: d_ex_erreur_parametre_fichier;
3362: return;
3363: }
3364:
1.6 bertrand 3365: if (initialisation_fichier_acces_indexe(
1.7 bertrand 3366: s_etat_processus, sqlite, position_clef,
1.6 bertrand 3367: (format == 'N') ? d_faux : d_vrai)
3368: != d_absence_erreur)
3369: {
3370: free(nom);
3371:
3372: liberation(s_etat_processus, s_objet_argument);
3373: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 3374:
1.6 bertrand 3375: return;
3376: }
3377: }
1.1 bertrand 3378: }
3379:
3380: break;
3381: }
3382:
3383: default:
3384: {
3385: BUG(1, printf("type_ouverture=%c\n", type_ouverture));
3386: return;
3387: }
3388: }
3389:
3390: if (((*((struct_fichier *) (*s_objet_resultat).objet)).nom =
3391: malloc((strlen(nom) + 1) *
3392: sizeof(unsigned char))) == NULL)
3393: {
3394: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3395: return;
3396: }
3397:
3398: strcpy((*((struct_fichier *) (*s_objet_resultat).objet)).nom, nom);
3399: liberation(s_etat_processus, s_objet_argument);
3400:
3401: (*((struct_fichier *) (*s_objet_resultat).objet)).protection =
3402: protection;
3403: (*((struct_fichier *) (*s_objet_resultat).objet)).position_clef =
3404: position_clef;
3405:
3406: rewind(descripteur);
3407:
3408: lock.l_type = F_WRLCK;
3409: lock.l_whence = SEEK_SET;
3410: lock.l_start = 0;
3411: lock.l_len = 0;
3412: lock.l_pid = getpid();
3413:
3414: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
3415: {
3416: if (fclose(descripteur) != 0)
3417: {
3418: liberation(s_etat_processus, s_objet_resultat);
3419:
1.6 bertrand 3420: (*s_etat_processus).erreur_systeme =
3421: d_es_erreur_fichier;
1.1 bertrand 3422: return;
3423: }
3424:
3425: liberation(s_etat_processus, s_objet_resultat);
3426:
3427: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
3428: return;
3429: }
3430:
3431: if (lock.l_type == F_UNLCK)
3432: {
3433: /*
3434: * Positionnement d'un verrou exclusif d'écriture par défaut
3435: */
3436:
3437: lock.l_type = F_RDLCK;
3438: lock.l_whence = SEEK_SET;
3439: lock.l_start = 0;
3440: lock.l_len = 0;
3441: lock.l_pid = getpid();
3442:
3443: if (fcntl(fileno(descripteur), F_SETLK, &lock) == -1)
3444: {
3445: if (fclose(descripteur) != 0)
3446: {
3447: liberation(s_etat_processus, s_objet_resultat);
3448:
3449: (*s_etat_processus).erreur_systeme =
3450: d_es_erreur_fichier;
3451: return;
3452: }
3453:
3454: liberation(s_etat_processus, s_objet_resultat);
3455:
1.6 bertrand 3456: (*s_etat_processus).erreur_systeme =
3457: d_es_erreur_fichier;
1.1 bertrand 3458: return;
3459: }
3460: }
3461: else
3462: {
3463: /*
3464: * Test de la cohérence du verrou avec l'option PROTECTION
3465: */
3466:
3467: if ((lock.l_type == F_RDLCK) && (protection != 'R'))
3468: {
1.6 bertrand 3469: free(nom);
3470:
1.1 bertrand 3471: if (fclose(descripteur) != 0)
3472: {
3473: liberation(s_etat_processus, s_objet_resultat);
3474:
3475: (*s_etat_processus).erreur_systeme =
3476: d_es_erreur_fichier;
3477: return;
3478: }
3479:
3480: liberation(s_etat_processus, s_objet_resultat);
3481:
3482: (*s_etat_processus).erreur_execution =
3483: d_ex_fichier_verrouille;
3484: return;
3485: }
3486: else if ((lock.l_type == F_WRLCK) && (protection != 'W'))
3487: {
1.6 bertrand 3488: free(nom);
3489:
1.1 bertrand 3490: if (fclose(descripteur) != 0)
3491: {
3492: liberation(s_etat_processus, s_objet_resultat);
3493:
3494: (*s_etat_processus).erreur_systeme =
3495: d_es_erreur_fichier;
3496: return;
3497: }
3498:
3499: liberation(s_etat_processus, s_objet_resultat);
3500:
3501: (*s_etat_processus).erreur_execution =
3502: d_ex_fichier_verrouille;
3503: return;
3504: }
3505: else
3506: {
1.6 bertrand 3507: free(nom);
3508:
3509: if (fclose(descripteur) != 0)
3510: {
3511: liberation(s_etat_processus, s_objet_resultat);
3512:
3513: (*s_etat_processus).erreur_systeme =
3514: d_es_erreur_fichier;
3515: return;
3516: }
3517:
1.1 bertrand 3518: liberation(s_etat_processus, s_objet_resultat);
3519:
3520: (*s_etat_processus).erreur_execution =
3521: d_ex_fichier_verrouille;
3522: return;
3523: }
3524: }
3525:
3526: /*
3527: * Gestion de la liste des fichiers ouverts
3528: */
3529:
3530: l_element_courant = (*s_etat_processus).s_fichiers;
3531:
3532: if (l_element_courant == NULL)
3533: {
3534: if (((*s_etat_processus).s_fichiers = malloc(sizeof(
3535: struct_liste_chainee))) == NULL)
3536: {
3537: (*s_etat_processus).erreur_systeme =
3538: d_es_allocation_memoire;
3539: return;
3540: }
3541:
3542: (*(*s_etat_processus).s_fichiers).suivant = NULL;
3543:
3544: if (((*(*s_etat_processus).s_fichiers).donnee =
3545: malloc(sizeof(struct_descripteur_fichier))) == NULL)
3546: {
3547: (*s_etat_processus).erreur_systeme =
3548: d_es_allocation_memoire;
3549: return;
3550: }
3551:
3552: l_element_courant = (*s_etat_processus).s_fichiers;
3553: prochain_descripteur = 0;
3554: }
3555: else
3556: {
3557: /*
3558: * Recherche du premier descripteur libre
3559: */
3560:
1.6 bertrand 3561: if ((chaine_descripteurs = malloc(sizeof(unsigned char) *
3562: (ds_nombre_maximum_fichiers_ouverts + 1))) == NULL)
1.1 bertrand 3563: {
3564: (*s_etat_processus).erreur_systeme =
3565: d_es_allocation_memoire;
3566: return;
3567: }
3568:
3569: for(pointeur = chaine_descripteurs, i = 0;
3570: i < ds_nombre_maximum_fichiers_ouverts;
3571: (*pointeur) = d_code_espace, pointeur++, i++);
3572: (*pointeur) = d_code_fin_chaine;
3573:
3574: do
3575: {
3576: chaine_descripteurs[(*((struct_descripteur_fichier *)
3577: (*l_element_courant).donnee)).identifiant] = '-';
3578: l_element_courant = (*l_element_courant).suivant;
3579: } while(l_element_courant != NULL);
3580:
3581: i = 0;
3582: pointeur = chaine_descripteurs;
3583:
3584: while(i < ds_nombre_maximum_fichiers_ouverts)
3585: {
3586: if ((*pointeur) == ' ')
3587: {
3588: break;
3589: }
3590:
3591: pointeur++;
3592: i++;
3593: }
3594:
3595: free(chaine_descripteurs);
3596:
3597: if (i == ds_nombre_maximum_fichiers_ouverts)
3598: {
3599: (*s_etat_processus).erreur_systeme =
3600: d_es_nombre_max_descripteurs;
3601: return;
3602: }
3603:
3604: prochain_descripteur = i;
3605:
3606: /*
3607: * Ajout d'un élément à la fin de la liste chaînée
3608: */
3609:
3610: l_element_courant = (*s_etat_processus).s_fichiers;
3611: while((*l_element_courant).suivant != NULL)
3612: {
3613: l_element_courant = (*l_element_courant).suivant;
3614: }
3615:
3616: if (((*l_element_courant).suivant =
3617: allocation_maillon(s_etat_processus)) == NULL)
3618: {
3619: (*s_etat_processus).erreur_systeme =
3620: d_es_allocation_memoire;
3621: return;
3622: }
3623:
3624: l_element_courant = (*l_element_courant).suivant;
3625: (*l_element_courant).suivant = NULL;
3626:
3627: if (((*l_element_courant).donnee =
3628: malloc(sizeof(struct_descripteur_fichier))) == NULL)
3629: {
3630: (*s_etat_processus).erreur_systeme =
3631: d_es_allocation_memoire;
3632: return;
3633: }
3634: }
3635:
3636: (*((struct_fichier *) (*s_objet_resultat).objet)).descripteur
3637: = prochain_descripteur;
3638: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3639: .identifiant = prochain_descripteur;
1.6 bertrand 3640:
3641: if (type_acces == 'S')
3642: {
3643: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3644: .type = 'C';
3645: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3646: .descripteur_c = descripteur;
3647: }
3648: else
3649: {
3650: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3651: .type = 'S';
3652: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3653: .descripteur_c = descripteur;
3654: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3655: .descripteur_sqlite = sqlite;
3656: }
3657:
1.1 bertrand 3658: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3659: .pid = getpid();
3660: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3661: .tid = pthread_self();
3662: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3663: .effacement = (type_ouverture == 'S') ? 'Y' : 'N';
3664:
1.6 bertrand 3665: (*((struct_descripteur_fichier *) (*l_element_courant)
3666: .donnee)).nom = nom;
1.1 bertrand 3667: }
3668: else if (type_arguments == 'S')
3669: {
3670: /*
3671: * Traitement des sockets
3672: */
3673:
3674:
3675: inline logical1 options_socket()
3676: {
3677: /*
3678: * Options des sockets
3679: */
3680:
3681: # define WARNING(message) \
3682: if ((*s_etat_processus).langue != 'F') \
3683: printf("+++Warning : %s unavailable on host system\n", \
3684: message); \
3685: else \
3686: printf("+++Attention : %s non disponible sur le système " \
3687: "hôte\n", message)
3688:
3689: if (options[d_BIND_TO_DEVICE] == 'Y')
3690: {
3691: # ifdef SO_BINDTODEVICE
3692: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3693: .objet)).socket, SOL_SOCKET, SO_BINDTODEVICE,
3694: peripherique, strlen(peripherique)) != 0)
3695: {
3696: liberation(s_etat_processus, s_objet_argument);
3697: liberation(s_etat_processus, s_objet_resultat);
3698:
3699: (*s_etat_processus).erreur_execution =
3700: d_ex_erreur_parametre_fichier;
3701: return(d_erreur);
3702: }
3703: # else
3704: WARNING("BIND TO DEVICE");
3705: # endif
3706: }
3707:
3708: if (options[d_BROADCAST] == 'Y')
3709: {
3710: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3711: .objet)).socket, SOL_SOCKET, SO_BROADCAST,
3712: &drapeau, sizeof(drapeau)) != 0)
3713: {
3714: liberation(s_etat_processus, s_objet_argument);
3715: liberation(s_etat_processus, s_objet_resultat);
3716:
3717: (*s_etat_processus).erreur_execution =
3718: d_ex_erreur_parametre_fichier;
3719: return(d_erreur);
3720: }
3721: }
3722:
3723: if (options[d_DONT_ROUTE] == 'Y')
3724: {
3725: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3726: .objet)).socket, SOL_SOCKET, SO_DONTROUTE,
3727: &drapeau, sizeof(drapeau)) != 0)
3728: {
3729: liberation(s_etat_processus, s_objet_argument);
3730: liberation(s_etat_processus, s_objet_resultat);
3731:
3732: (*s_etat_processus).erreur_execution =
3733: d_ex_erreur_parametre_fichier;
3734: return(d_erreur);
3735: }
3736: }
3737:
3738: if (options[d_KEEP_ALIVE] == 'Y')
3739: {
3740: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3741: .objet)).socket, SOL_SOCKET, SO_KEEPALIVE,
3742: &drapeau, sizeof(drapeau)) != 0)
3743: {
3744: liberation(s_etat_processus, s_objet_argument);
3745: liberation(s_etat_processus, s_objet_resultat);
3746:
3747: (*s_etat_processus).erreur_execution =
3748: d_ex_erreur_parametre_fichier;
3749: return(d_erreur);
3750: }
3751: }
3752:
3753: if (options[d_PRIORITY] == 'Y')
3754: {
3755: # ifdef SO_PRIORITY
3756: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3757: .objet)).socket, SOL_SOCKET, SO_PRIORITY,
3758: &priorite, sizeof(priorite)) != 0)
3759: {
3760: liberation(s_etat_processus, s_objet_argument);
3761: liberation(s_etat_processus, s_objet_resultat);
3762:
3763: (*s_etat_processus).erreur_execution =
3764: d_ex_erreur_parametre_fichier;
3765: return(d_erreur);
3766: }
3767: # else
3768: WARNING("PRIORITY");
3769: # endif
3770: }
3771:
3772: if (options[d_RECEIVE_BUFFER] == 'Y')
3773: {
3774: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3775: .objet)).socket, SOL_SOCKET, SO_RCVBUF,
3776: &buffer_reception, sizeof(buffer_reception)) != 0)
3777: {
3778: liberation(s_etat_processus, s_objet_argument);
3779: liberation(s_etat_processus, s_objet_resultat);
3780:
3781: (*s_etat_processus).erreur_execution =
3782: d_ex_erreur_parametre_fichier;
3783: return(d_erreur);
3784: }
3785: }
3786:
3787: if (options[d_FORCE_RECEIVE_BUFFER] == 'Y')
3788: {
3789: # ifdef SO_RCVBUFFORCE
3790: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3791: .objet)).socket, SOL_SOCKET, SO_RCVBUFFORCE,
3792: &buffer_reception, sizeof(buffer_reception))
3793: != 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: # else
3803: WARNING("FORCE_RECEIVE_BUFFER");
3804: # endif
3805: }
3806:
3807: if (options[d_SEND_BUFFER] == 'Y')
3808: {
3809: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3810: .objet)).socket, SOL_SOCKET, SO_SNDBUF,
3811: &buffer_emission, sizeof(buffer_emission)) != 0)
3812: {
3813: liberation(s_etat_processus, s_objet_argument);
3814: liberation(s_etat_processus, s_objet_resultat);
3815:
3816: (*s_etat_processus).erreur_execution =
3817: d_ex_erreur_parametre_fichier;
3818: return(d_erreur);
3819: }
3820: }
3821:
3822: if (options[d_FORCE_SEND_BUFFER] == 'Y')
3823: {
3824: # ifdef SO_SNDBUFFORCE
3825: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3826: .objet)).socket, SOL_SOCKET, SO_SNDBUFFORCE,
3827: &buffer_emission, sizeof(buffer_emission)) != 0)
3828: {
3829: liberation(s_etat_processus, s_objet_argument);
3830: liberation(s_etat_processus, s_objet_resultat);
3831:
3832: (*s_etat_processus).erreur_execution =
3833: d_ex_erreur_parametre_fichier;
3834: return(d_erreur);
3835: }
3836: # else
3837: WARNING("FORCE_SEND_BUFFER");
3838: # endif
3839: }
3840:
3841: if (options[d_RECEIVING_TIMEOUT] == 'Y')
3842: {
3843: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3844: .objet)).socket, SOL_SOCKET, SO_RCVTIMEO,
3845: &timeout_reception, sizeof(timeout_reception)) != 0)
3846: {
3847: liberation(s_etat_processus, s_objet_argument);
3848: liberation(s_etat_processus, s_objet_resultat);
3849:
3850: (*s_etat_processus).erreur_execution =
3851: d_ex_erreur_parametre_fichier;
3852: return(d_erreur);
3853: }
3854: }
3855:
3856: if (options[d_SENDING_TIMEOUT] == 'Y')
3857: {
3858: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3859: .objet)).socket, SOL_SOCKET, SO_SNDTIMEO,
3860: &timeout_emission, sizeof(timeout_emission)) != 0)
3861: {
3862: liberation(s_etat_processus, s_objet_argument);
3863: liberation(s_etat_processus, s_objet_resultat);
3864:
3865: (*s_etat_processus).erreur_execution =
3866: d_ex_erreur_parametre_fichier;
3867: return(d_erreur);
3868: }
3869: }
3870:
3871: if (options[d_REUSE_ADDRESS] == 'Y')
3872: {
3873: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3874: .objet)).socket, SOL_SOCKET, SO_REUSEADDR,
3875: &drapeau, sizeof(drapeau)) != 0)
3876: {
3877: liberation(s_etat_processus, s_objet_argument);
3878: liberation(s_etat_processus, s_objet_resultat);
3879:
3880: (*s_etat_processus).erreur_execution =
3881: d_ex_erreur_parametre_fichier;
3882: return(d_erreur);
3883: }
3884: }
3885:
3886: return(d_absence_erreur);
3887: #undef WARNING
3888: }
3889:
3890: /*
3891: * Vérification de la cohérence des arguments et traitement
3892: * des valeurs par défaut.
3893: */
3894:
3895: if (format == ' ')
3896: {
3897: format = 'N';
3898: }
3899:
3900: if (protection == ' ')
3901: {
3902: protection = 'N';
3903: }
3904:
3905: if (type_domaine == ' ')
3906: {
3907: type_domaine = 'L';
3908: }
3909:
3910: if (type_socket == ' ')
3911: {
3912: type_socket = 'S';
3913: type = SOCK_STREAM;
3914: }
3915:
3916: if (nom != NULL)
3917: {
3918: if (strcmp(protocole, "") == 0)
3919: {
3920: strcpy(protocole, "UNIX");
3921: }
3922: }
3923: else
3924: {
3925: if (strcmp(protocole, "") == 0)
3926: {
3927: strcpy(protocole, "IPV4");
3928: }
3929: }
3930:
3931: if ((nom != NULL) && (hote != NULL))
3932: {
3933: liberation(s_etat_processus, s_objet_argument);
3934:
3935: (*s_etat_processus).erreur_execution =
3936: d_ex_erreur_parametre_fichier;
3937: return;
3938: }
3939:
3940: if ((nom != NULL) && (strcmp(protocole, "UNIX") != 0))
3941: {
3942: liberation(s_etat_processus, s_objet_argument);
3943:
3944: (*s_etat_processus).erreur_execution =
3945: d_ex_erreur_parametre_fichier;
3946: return;
3947: }
3948:
3949: if ((hote != NULL) && (strcmp(protocole, "UNIX") == 0))
3950: {
3951: liberation(s_etat_processus, s_objet_argument);
3952:
3953: (*s_etat_processus).erreur_execution =
3954: d_ex_erreur_parametre_fichier;
3955: return;
3956: }
3957:
3958: if ((nom != NULL) && (type_domaine == 'F') && (type_adresse != ' '))
3959: {
3960: liberation(s_etat_processus, s_objet_argument);
3961:
3962: (*s_etat_processus).erreur_execution =
3963: d_ex_erreur_parametre_fichier;
3964: return;
3965: }
3966:
3967: if ((presence_port == d_vrai) && (nom != NULL))
3968: {
3969: liberation(s_etat_processus, s_objet_argument);
3970:
3971: (*s_etat_processus).erreur_execution =
3972: d_ex_erreur_parametre_fichier;
3973: return;
3974: }
3975:
3976: if (((strcmp(protocole, "IPV4") == 0) && (type_adresse == '6')) ||
3977: ((strcmp(protocole, "IPV6") == 0) && (type_adresse == '4')))
3978: {
3979: liberation(s_etat_processus, s_objet_argument);
3980:
3981: (*s_etat_processus).erreur_execution =
3982: d_ex_erreur_parametre_fichier;
3983: return;
3984: }
3985:
3986: if ((nombre_maximal_connexions != 0) && ((type_socket != 'S') &&
3987: (type_socket != 'Q')))
3988: {
3989: liberation(s_etat_processus, s_objet_argument);
3990:
3991: (*s_etat_processus).erreur_execution =
3992: d_ex_erreur_parametre_fichier;
3993: return;
3994: }
3995:
3996: if (nombre_maximal_connexions == 0)
3997: {
3998: nombre_maximal_connexions = 1;
3999: }
4000:
4001: if (protocole_socket == NULL)
4002: {
4003: protocole_numerique = 0;
4004: }
4005: else
4006: {
4007: for(i = 0; i < strlen(protocole_socket); i++)
4008: {
4009: if ((protocole_socket[i] >= 'A') &&
4010: (protocole_socket[i] <= 'Z'))
4011: {
4012: protocole_socket[i] += 'a' - 'A';
4013: }
4014: }
4015:
4016: if (strcmp(protocole_socket, "ipv4") == 0)
4017: {
4018: protocole_socket[2] = d_code_fin_chaine;
4019: }
4020:
4021: if ((s_protocole = getprotobyname(protocole_socket)) == NULL)
4022: {
4023: liberation(s_etat_processus, s_objet_argument);
4024:
4025: (*s_etat_processus).erreur_execution =
4026: d_ex_erreur_parametre_fichier;
4027: return;
4028: }
4029:
4030: protocole_numerique = (*s_protocole).p_proto;
4031: }
4032:
4033: if ((s_objet_resultat = allocation(s_etat_processus, SCK))
4034: == NULL)
4035: {
4036: (*s_etat_processus).erreur_systeme =
4037: d_es_allocation_memoire;
4038: return;
4039: }
4040:
4041: if (((*((struct_socket *) (*s_objet_resultat).objet)).format =
4042: allocation(s_etat_processus, LST)) == NULL)
4043: {
4044: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4045: return;
4046: }
4047:
4048: (*((struct_socket *) (*s_objet_resultat).objet)).protection
4049: = protection;
4050: (*(*((struct_socket *) (*s_objet_resultat).objet))
4051: .format).objet = NULL;
4052:
4053: switch(type_socket)
4054: {
4055: case 'S' :
4056: type = SOCK_STREAM;
4057: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4058: type, "STREAM");
4059: break;
4060:
4061: case 'D' :
4062: type = SOCK_DGRAM;
4063: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4064: type, "DATAGRAM");
4065: break;
4066:
4067: case 'Q' :
4068: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4069: type, "SEQUENTIAL DATAGRAM");
4070: type = SOCK_SEQPACKET;
4071: break;
4072:
4073: case 'R' :
4074: type = SOCK_RAW;
4075: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4076: type, "RAW");
4077: break;
4078:
4079: case 'M' :
4080: type = SOCK_RDM;
4081: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
4082: type, "ROBUST DATAGRAM");
4083: break;
4084: }
4085:
4086: if ((protection != 'N') && ((type_socket != 'S') &&
4087: (type_socket != 'Q')))
4088: {
4089: liberation(s_etat_processus, s_objet_argument);
4090: liberation(s_etat_processus, s_objet_resultat);
4091:
4092: (*s_etat_processus).erreur_execution =
4093: d_ex_erreur_parametre_fichier;
4094: return;
4095: }
4096:
4097: if (nom == NULL)
4098: {
4099: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
4100: malloc(sizeof(unsigned char))) == NULL)
4101: {
4102: (*s_etat_processus).erreur_systeme =
4103: d_es_allocation_memoire;
4104: return;
4105: }
4106:
4107: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).adresse,
4108: "");
4109: }
4110: else
4111: {
4112: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
1.6 bertrand 4113: transliteration(s_etat_processus, nom,
4114: d_locale, "UTF-8")) == NULL)
1.1 bertrand 4115: {
1.6 bertrand 4116: liberation(s_etat_processus, s_objet_argument);
4117: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 4118: return;
4119: }
4120: }
4121:
4122: if (((*((struct_socket *) (*s_objet_resultat).objet))
4123: .adresse_distante = malloc(sizeof(unsigned char))) == NULL)
4124: {
4125: (*s_etat_processus).erreur_systeme =
4126: d_es_allocation_memoire;
4127: return;
4128: }
4129:
4130: strcpy((*((struct_socket *) (*s_objet_resultat).objet))
4131: .adresse_distante, "");
4132:
4133: (*((struct_socket *) (*s_objet_resultat).objet)).localisation =
4134: type_domaine;
4135: (*((struct_socket *) (*s_objet_resultat).objet)).binaire =
4136: format;
4137: (*((struct_socket *) (*s_objet_resultat).objet)).pid =
4138: getpid();
4139: (*((struct_socket *) (*s_objet_resultat).objet)).tid =
4140: pthread_self();
4141: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
4142: = 'Y';
4143: (*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee
4144: = d_faux;
4145:
4146: if (type_domaine == 'L')
4147: { // Socket serveur
4148: if (nom != NULL)
4149: {
4150: /*
4151: * La socket locale est dans l'espace des noms.
4152: */
4153:
4154: if (((*((struct_socket *) (*s_objet_resultat).objet))
4155: .socket = socket(PF_UNIX, type,
4156: protocole_numerique)) == -1)
4157: {
4158: liberation(s_etat_processus, s_objet_argument);
4159: liberation(s_etat_processus, s_objet_resultat);
4160:
4161: (*s_etat_processus).erreur_execution =
4162: d_ex_erreur_acces_fichier;
4163: return;
4164: }
4165:
4166: (*((struct_socket *) (*s_objet_resultat).objet)).domaine
4167: = PF_UNIX;
4168: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4169: = 'Y';
4170:
4171: socket_unix.sun_family = AF_UNIX;
4172:
4173: pointeur = (*((struct_socket *)
4174: (*s_objet_resultat).objet)).adresse;
4175:
4176: while((*pointeur) == d_code_espace)
4177: {
4178: pointeur++;
4179: }
4180:
4181: strncpy(socket_unix.sun_path, pointeur, 108);
4182: socket_unix.sun_path[108 - 1] = d_code_fin_chaine;
4183:
4184: if (options_socket() == d_erreur)
4185: {
4186: liberation(s_etat_processus, s_objet_argument);
4187: liberation(s_etat_processus, s_objet_resultat);
4188:
4189: return;
4190: }
4191:
4192: if (bind((*((struct_socket *) (*s_objet_resultat).objet))
4193: .socket, (const struct sockaddr *) &socket_unix,
4194: sizeof(socket_unix)) != 0)
4195: {
4196: liberation(s_etat_processus, s_objet_argument);
4197: liberation(s_etat_processus, s_objet_resultat);
4198:
4199: (*s_etat_processus).erreur_execution =
4200: d_ex_erreur_acces_fichier;
4201: return;
4202: }
4203: }
4204: else
4205: {
4206: /*
4207: * La socket est une socket réseau locale. L'adresse
4208: * passée en argument est l'adresse sur laquelle
4209: * cette socket est à l'écoute.
4210: */
4211:
4212: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4213: = 'N';
4214:
4215: if (hote != NULL)
4216: { // Hôte défini par un nom
4217: resolution = NULL;
4218:
4219: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4220: {
4221: liberation(s_etat_processus, s_objet_argument);
4222: liberation(s_etat_processus, s_objet_resultat);
4223:
4224: if (resolution != NULL)
4225: {
4226: freeaddrinfo(resolution);
4227: }
4228:
4229: (*s_etat_processus).erreur_execution =
4230: d_ex_erreur_acces_fichier;
4231: return;
4232: }
4233:
4234: if (strcmp(protocole, "IPV4") == 0)
4235: { // Accès en IPv4
4236: resolution_courante = resolution;
4237:
4238: while(resolution_courante != NULL)
4239: {
4240: if ((*resolution_courante).ai_family ==
4241: AF_INET)
4242: {
4243: break;
4244: }
4245:
4246: resolution_courante = (*resolution_courante)
4247: .ai_next;
4248: }
4249:
4250: if (resolution_courante == NULL)
4251: {
4252: liberation(s_etat_processus, s_objet_argument);
4253: liberation(s_etat_processus, s_objet_resultat);
4254:
4255: freeaddrinfo(resolution);
4256:
4257: (*s_etat_processus).erreur_execution =
4258: d_ex_erreur_acces_fichier;
4259: return;
4260: }
4261:
4262: if (((*((struct_socket *)
4263: (*s_objet_resultat).objet))
4264: .socket = socket(PF_INET, type,
4265: protocole_numerique)) == -1)
4266: {
4267: liberation(s_etat_processus, s_objet_argument);
4268: liberation(s_etat_processus, s_objet_resultat);
4269:
4270: freeaddrinfo(resolution);
4271:
4272: (*s_etat_processus).erreur_execution =
4273: d_ex_erreur_acces_fichier;
4274: return;
4275: }
4276:
4277: (*((struct_socket *) (*s_objet_resultat).objet))
4278: .domaine = PF_INET;
4279:
4280: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4281: socket_ipv4.sin_family = AF_INET;
4282: socket_ipv4.sin_port = htons((uint16_t) port);
4283: socket_ipv4.sin_addr.s_addr =
4284: (*((struct sockaddr_in *)
4285: (*resolution_courante).ai_addr))
4286: .sin_addr.s_addr;
4287:
4288: if (options_socket() == d_erreur)
4289: {
4290: liberation(s_etat_processus, s_objet_argument);
4291: liberation(s_etat_processus, s_objet_resultat);
4292:
4293: freeaddrinfo(resolution);
4294: return;
4295: }
4296:
4297: if (bind((*((struct_socket *) (*s_objet_resultat)
4298: .objet)).socket, (const struct sockaddr *)
4299: &socket_ipv4, sizeof(socket_ipv4)) != 0)
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 *) (*s_objet_resultat)
4312: .objet)).adresse = malloc(22 *
4313: sizeof(unsigned char))) == NULL)
4314: {
4315: (*s_etat_processus).erreur_systeme =
4316: d_es_allocation_memoire;
4317: return;
4318: }
4319:
4320: sprintf((*((struct_socket *) (*s_objet_resultat)
4321: .objet)).adresse, "%d.%d.%d.%d",
4322: (ntohl((*((struct sockaddr_in *)
4323: (*resolution_courante).ai_addr)).sin_addr
4324: .s_addr) >> 24) & 0xFF,
4325: (ntohl((*((struct sockaddr_in *)
4326: (*resolution_courante).ai_addr)).sin_addr
4327: .s_addr) >> 16) & 0xFF,
4328: (ntohl((*((struct sockaddr_in *)
4329: (*resolution_courante).ai_addr)).sin_addr
4330: .s_addr) >> 8) & 0xFF,
4331: ntohl((*((struct sockaddr_in *)
4332: (*resolution_courante).ai_addr)).sin_addr
4333: .s_addr) & 0xFF);
4334: }
4335: else
4336: { // Accès en IPv6
4337: resolution_courante = resolution;
4338:
4339: while(resolution_courante != NULL)
4340: {
4341: if ((*resolution_courante).ai_family ==
4342: AF_INET6)
4343: {
4344: break;
4345: }
4346:
4347: resolution_courante = (*resolution_courante)
4348: .ai_next;
4349: }
4350:
4351: if (resolution_courante == NULL)
4352: {
4353: liberation(s_etat_processus, s_objet_argument);
4354: liberation(s_etat_processus, s_objet_resultat);
4355:
4356: freeaddrinfo(resolution);
4357:
4358: (*s_etat_processus).erreur_execution =
4359: d_ex_erreur_acces_fichier;
4360: return;
4361: }
4362:
4363: if (((*((struct_socket *)
4364: (*s_objet_resultat).objet))
4365: .socket = socket(PF_INET6, type,
4366: protocole_numerique)) == -1)
4367: {
4368: liberation(s_etat_processus, s_objet_argument);
4369: liberation(s_etat_processus, s_objet_resultat);
4370:
4371: freeaddrinfo(resolution);
4372:
4373: (*s_etat_processus).erreur_execution =
4374: d_ex_erreur_acces_fichier;
4375: return;
4376: }
4377:
4378: (*((struct_socket *) (*s_objet_resultat).objet))
4379: .domaine = PF_INET6;
4380:
4381: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4382: socket_ipv6.sin6_family = AF_INET6;
4383: socket_ipv6.sin6_port = htons((uint16_t) port);
4384:
4385: for(i = 0; i < 16;
4386: socket_ipv6.sin6_addr.s6_addr[i] =
4387: (*((struct sockaddr_in6 *)
4388: (*resolution_courante).ai_addr))
4389: .sin6_addr.s6_addr[i], i++);
4390:
4391: if (options_socket() == d_erreur)
4392: {
4393: liberation(s_etat_processus, s_objet_argument);
4394: liberation(s_etat_processus, s_objet_resultat);
4395:
4396: freeaddrinfo(resolution);
4397: return;
4398: }
4399:
4400: if (bind((*((struct_socket *) (*s_objet_resultat)
4401: .objet)).socket, (const struct sockaddr *)
4402: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4403: {
4404: liberation(s_etat_processus, s_objet_argument);
4405: liberation(s_etat_processus, s_objet_resultat);
4406:
4407: freeaddrinfo(resolution);
4408:
4409: (*s_etat_processus).erreur_execution =
4410: d_ex_erreur_acces_fichier;
4411: return;
4412: }
4413:
4414: if (((*((struct_socket *) (*s_objet_resultat)
4415: .objet)).adresse = malloc(55 *
4416: sizeof(unsigned char))) == NULL)
4417: {
4418: (*s_etat_processus).erreur_systeme =
4419: d_es_allocation_memoire;
4420: return;
4421: }
4422:
4423: for(i = 0; i < 16; i++)
4424: {
4425: sprintf((*((struct_socket *) (*s_objet_resultat)
4426: .objet)).adresse,
4427: (i == 0) ? "%s%X" : "%s:%X",
4428: (*((struct_socket *) (*s_objet_resultat)
4429: .objet)).adresse,
4430: (*((struct sockaddr_in6 *)
4431: (*resolution_courante).ai_addr))
4432: .sin6_addr.s6_addr[i]);
4433: }
4434: }
4435:
4436: freeaddrinfo(resolution);
4437:
4438: sprintf((*((struct_socket *) (*s_objet_resultat)
4439: .objet)).adresse, "%s(%u)",
4440: (*((struct_socket *) (*s_objet_resultat)
4441: .objet)).adresse, (unsigned int) port);
4442: }
4443: else
4444: { // Hôte défini par une adresse
4445: if (strcmp(protocole, "IPV4") == 0)
4446: { // Accès en IPv4
4447: if (((*((struct_socket *) (*s_objet_resultat)
4448: .objet)).adresse = malloc(22 *
4449: sizeof(unsigned char))) == NULL)
4450: {
4451: (*s_etat_processus).erreur_systeme =
4452: d_es_allocation_memoire;
4453: return;
4454: }
4455:
4456: (*((struct_socket *) (*s_objet_resultat).objet))
4457: .adresse[0] = d_code_fin_chaine;
4458:
4459: for(i = 0; i < 4; i++)
4460: {
4461: sprintf((*((struct_socket *) (*s_objet_resultat)
4462: .objet)).adresse,
4463: (i == 0) ? "%s%d" : "%s.%d",
4464: (*((struct_socket *) (*s_objet_resultat)
4465: .objet)).adresse, (int) adresse[i]);
4466: }
4467:
4468: sprintf((*((struct_socket *) (*s_objet_resultat)
4469: .objet)).adresse, "%s(%u)",
4470: (*((struct_socket *) (*s_objet_resultat)
4471: .objet)).adresse, (unsigned int) port);
4472:
4473: if (((*((struct_socket *)
4474: (*s_objet_resultat).objet))
4475: .socket = socket(PF_INET, type,
4476: protocole_numerique)) == -1)
4477: {
4478: liberation(s_etat_processus, s_objet_argument);
4479: liberation(s_etat_processus, s_objet_resultat);
4480:
4481: (*s_etat_processus).erreur_execution =
4482: d_ex_erreur_acces_fichier;
4483: return;
4484: }
4485:
4486: (*((struct_socket *) (*s_objet_resultat).objet))
4487: .domaine = PF_INET;
4488:
4489: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4490: socket_ipv4.sin_family = AF_INET;
4491: socket_ipv4.sin_port = htons((uint16_t) port);
4492:
4493: adresse_ipv4 = 0;
4494: for(i = 0; i < 4; adresse_ipv4 =
4495: (256 * adresse_ipv4) + adresse[i++]);
4496:
4497: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
4498:
4499: if (options_socket() == d_erreur)
4500: {
4501: liberation(s_etat_processus, s_objet_argument);
4502: liberation(s_etat_processus, s_objet_resultat);
4503:
4504: return;
4505: }
4506:
4507: if (bind((*((struct_socket *) (*s_objet_resultat)
4508: .objet)).socket, (const struct sockaddr *)
4509: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4510: {
4511: liberation(s_etat_processus, s_objet_argument);
4512: liberation(s_etat_processus, s_objet_resultat);
4513:
4514: (*s_etat_processus).erreur_execution =
4515: d_ex_erreur_acces_fichier;
4516: return;
4517: }
4518: }
4519: else
4520: { // Accès en IPv6
4521: if (((*((struct_socket *) (*s_objet_resultat)
4522: .objet)).adresse = malloc(55 *
4523: sizeof(unsigned char))) == NULL)
4524: {
4525: (*s_etat_processus).erreur_systeme =
4526: d_es_allocation_memoire;
4527: return;
4528: }
4529:
4530: (*((struct_socket *) (*s_objet_resultat).objet))
4531: .adresse[0] = d_code_fin_chaine;
4532:
4533: for(i = 0; i < 16; i++)
4534: {
4535: sprintf((*((struct_socket *) (*s_objet_resultat)
4536: .objet)).adresse,
4537: (i == 0) ? "%s%X" : "%s:%X",
4538: (*((struct_socket *) (*s_objet_resultat)
4539: .objet)).adresse, (unsigned int)
4540: adresse[i]);
4541: }
4542:
4543: sprintf((*((struct_socket *) (*s_objet_resultat)
4544: .objet)).adresse, "%s(%u)",
4545: (*((struct_socket *) (*s_objet_resultat)
4546: .objet)).adresse, (unsigned int) port);
4547:
4548: if (((*((struct_socket *)
4549: (*s_objet_resultat).objet))
4550: .socket = socket(PF_INET6, type,
4551: protocole_numerique)) == -1)
4552: {
4553: liberation(s_etat_processus, s_objet_argument);
4554: liberation(s_etat_processus, s_objet_resultat);
4555:
4556: (*s_etat_processus).erreur_execution =
4557: d_ex_erreur_acces_fichier;
4558: return;
4559: }
4560:
4561: (*((struct_socket *) (*s_objet_resultat).objet))
4562: .domaine = PF_INET6;
4563:
4564: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4565: socket_ipv6.sin6_family = AF_INET6;
4566: socket_ipv6.sin6_port = htons((uint16_t) port);
4567:
4568: for(i = 0; i < 16;
4569: socket_ipv6.sin6_addr.s6_addr[i] =
4570: (unsigned char) (adresse[i]), i++);
4571:
4572: if (options_socket() == d_erreur)
4573: {
4574: liberation(s_etat_processus, s_objet_argument);
4575: liberation(s_etat_processus, s_objet_resultat);
4576:
4577: return;
4578: }
4579:
4580: if (bind((*((struct_socket *) (*s_objet_resultat)
4581: .objet)).socket, (const struct sockaddr *)
4582: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4583: {
4584: liberation(s_etat_processus, s_objet_argument);
4585: liberation(s_etat_processus, s_objet_resultat);
4586:
4587: (*s_etat_processus).erreur_execution =
4588: d_ex_erreur_acces_fichier;
4589: return;
4590: }
4591: }
4592: }
4593:
4594: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4595: = 'N';
4596: }
4597:
4598: if ((type_socket == 'S') || (type_socket == 'Q'))
4599: {
4600: if (listen((*((struct_socket *) (*s_objet_resultat).objet))
4601: .socket, (int) nombre_maximal_connexions) != 0)
4602: {
4603: liberation(s_etat_processus, s_objet_argument);
4604: liberation(s_etat_processus, s_objet_resultat);
4605:
4606: (*s_etat_processus).erreur_execution =
4607: d_ex_erreur_acces_fichier;
4608: return;
4609: }
4610:
4611: (*((struct_socket *) (*s_objet_resultat).objet))
4612: .socket_connectee = d_vrai;
4613:
4614: if (protection == 'R')
4615: { // WRITEONLY
4616: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4617: .objet)).socket, SHUT_RD) != 0)
4618: {
4619: liberation(s_etat_processus, s_objet_argument);
4620: liberation(s_etat_processus, s_objet_resultat);
4621:
4622: (*s_etat_processus).erreur_execution =
4623: d_ex_erreur_acces_fichier;
4624: return;
4625: }
4626: }
4627: else if (protection == 'W')
4628: { // READONLY
4629: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4630: .objet)).socket, SHUT_WR) != 0)
4631: {
4632: liberation(s_etat_processus, s_objet_argument);
4633: liberation(s_etat_processus, s_objet_resultat);
4634:
4635: (*s_etat_processus).erreur_execution =
4636: d_ex_erreur_acces_fichier;
4637: return;
4638: }
4639: }
4640: else
4641: { // READWRITE
4642: }
4643: }
4644: }
4645: else
4646: { // Socket cliente
4647: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4648: = 'N';
4649:
4650: /*
4651: * Dans le cas où la socket n'est pas connectée, on
4652: * ne peut utiliser ni "NAME", ni "HOST", ni "PORT",
4653: * et encore moins spécifier une adresse. En effet, la cible
4654: * est défini par la commande TARGET.
4655: */
4656:
4657: if ((type_socket != 'S') && (type_socket != 'Q'))
4658: {
4659: if ((presence_port == d_vrai) || (hote != NULL) ||
4660: (nom != NULL) || (type_adresse != ' '))
4661: {
4662: liberation(s_etat_processus, s_objet_argument);
4663: liberation(s_etat_processus, s_objet_resultat);
4664:
4665: (*s_etat_processus).erreur_execution =
4666: d_ex_erreur_parametre_fichier;
4667: return;
4668: }
4669: }
4670:
4671: if (nom != NULL)
4672: {
4673: /*
4674: * La socket est dans l'espace des noms.
4675: */
4676:
4677: if (((*((struct_socket *) (*s_objet_resultat).objet))
4678: .socket = socket(PF_UNIX, type,
4679: protocole_numerique)) == -1)
4680: {
4681: liberation(s_etat_processus, s_objet_argument);
4682: liberation(s_etat_processus, s_objet_resultat);
4683:
4684: (*s_etat_processus).erreur_execution =
4685: d_ex_erreur_acces_fichier;
4686: return;
4687: }
4688:
4689: (*((struct_socket *) (*s_objet_resultat).objet))
4690: .domaine = PF_UNIX;
4691:
4692: socket_unix.sun_family = AF_UNIX;
4693: strncpy(socket_unix.sun_path, (*((struct_socket *)
4694: (*s_objet_resultat).objet)).adresse, 108);
4695: socket_unix.sun_path[108 - 1] = d_code_fin_chaine;
4696:
4697: if ((type_socket == 'S') || (type_socket == 'Q'))
4698: {
4699: if (connect((*((struct_socket *) (*s_objet_resultat)
4700: .objet)).socket, (const struct sockaddr *)
4701: &socket_unix, sizeof(socket_unix)) != 0)
4702: {
4703: liberation(s_etat_processus, s_objet_argument);
4704: liberation(s_etat_processus, s_objet_resultat);
4705:
4706: (*s_etat_processus).erreur_execution =
4707: d_ex_erreur_acces_fichier;
4708: return;
4709: }
4710:
4711: (*((struct_socket *) (*s_objet_resultat).objet))
4712: .socket_connectee = d_vrai;
4713: (*((struct_socket *) (*s_objet_resultat).objet))
4714: .socket_en_ecoute = 'N';
4715: }
4716: }
4717: else
4718: {
4719: /*
4720: * La socket est une socket réseau. L'adresse
4721: * passée en argument est l'adresse sur laquelle
4722: * cette socket est à l'écoute.
4723: */
4724:
4725: if (hote != NULL)
4726: { // Hôte défini par un nom
4727: resolution = NULL;
4728:
4729: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4730: {
4731: liberation(s_etat_processus, s_objet_argument);
4732: liberation(s_etat_processus, s_objet_resultat);
4733:
4734: if (resolution != NULL)
4735: {
4736: freeaddrinfo(resolution);
4737: }
4738:
4739: (*s_etat_processus).erreur_execution =
4740: d_ex_erreur_acces_fichier;
4741: return;
4742: }
4743:
4744: if (strcmp(protocole, "IPV4") == 0)
4745: { // Accès en IPv4
4746: resolution_courante = resolution;
4747:
4748: while(resolution_courante != NULL)
4749: {
4750: if ((*resolution_courante).ai_family ==
4751: AF_INET)
4752: {
4753: break;
4754: }
4755:
4756: resolution_courante = (*resolution_courante)
4757: .ai_next;
4758: }
4759:
4760: if (resolution_courante == NULL)
4761: {
4762: liberation(s_etat_processus, s_objet_argument);
4763: liberation(s_etat_processus, s_objet_resultat);
4764:
4765: freeaddrinfo(resolution);
4766:
4767: (*s_etat_processus).erreur_execution =
4768: d_ex_erreur_acces_fichier;
4769: return;
4770: }
4771:
4772: if (((*((struct_socket *)
4773: (*s_objet_resultat).objet))
4774: .socket = socket(PF_INET, type,
4775: protocole_numerique)) == -1)
4776: {
4777: liberation(s_etat_processus, s_objet_argument);
4778: liberation(s_etat_processus, s_objet_resultat);
4779:
4780: freeaddrinfo(resolution);
4781:
4782: (*s_etat_processus).erreur_execution =
4783: d_ex_erreur_acces_fichier;
4784: return;
4785: }
4786:
4787: (*((struct_socket *) (*s_objet_resultat).objet))
4788: .domaine = PF_INET;
4789:
4790: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4791: socket_ipv4.sin_family = AF_INET;
4792: socket_ipv4.sin_port = htons((uint16_t) port);
4793: socket_ipv4.sin_addr.s_addr =
4794: (*((struct sockaddr_in *)
4795: (*resolution_courante).ai_addr))
4796: .sin_addr.s_addr;
4797:
4798: if ((type_socket == 'S') || (type_socket == 'Q'))
4799: {
4800: if (connect((*((struct_socket *)
4801: (*s_objet_resultat).objet)).socket,
4802: (const struct sockaddr *)
4803: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4804: {
4805: liberation(s_etat_processus,
4806: s_objet_argument);
4807: liberation(s_etat_processus,
4808: s_objet_resultat);
4809:
4810: freeaddrinfo(resolution);
4811:
4812: (*s_etat_processus).erreur_execution =
4813: d_ex_erreur_acces_fichier;
4814: return;
4815: }
4816:
4817: (*((struct_socket *) (*s_objet_resultat).objet))
4818: .socket_connectee = d_vrai;
4819: (*((struct_socket *) (*s_objet_resultat).objet))
4820: .socket_en_ecoute = 'N';
4821: }
4822:
4823: if (((*((struct_socket *) (*s_objet_resultat)
4824: .objet)).adresse = malloc(22 *
4825: sizeof(unsigned char))) == NULL)
4826: {
4827: (*s_etat_processus).erreur_systeme =
4828: d_es_allocation_memoire;
4829: return;
4830: }
4831:
4832: sprintf((*((struct_socket *) (*s_objet_resultat)
4833: .objet)).adresse, "%d.%d.%d.%d",
4834: (ntohl((*((struct sockaddr_in *)
4835: (*resolution_courante).ai_addr)).sin_addr
4836: .s_addr) >> 24) & 0xFF,
4837: (ntohl((*((struct sockaddr_in *)
4838: (*resolution_courante).ai_addr)).sin_addr
4839: .s_addr) >> 16) & 0xFF,
4840: (ntohl((*((struct sockaddr_in *)
4841: (*resolution_courante).ai_addr)).sin_addr
4842: .s_addr) >> 8) & 0xFF,
4843: ntohl((*((struct sockaddr_in *)
4844: (*resolution_courante).ai_addr)).sin_addr
4845: .s_addr) & 0xFF);
4846: }
4847: else
4848: { // Accès en IPv6
4849: resolution_courante = resolution;
4850:
4851: while(resolution_courante != NULL)
4852: {
4853: if ((*resolution_courante).ai_family ==
4854: AF_INET6)
4855: {
4856: break;
4857: }
4858:
4859: resolution_courante = (*resolution_courante)
4860: .ai_next;
4861: }
4862:
4863: if (resolution_courante == NULL)
4864: {
4865: liberation(s_etat_processus, s_objet_argument);
4866: liberation(s_etat_processus, s_objet_resultat);
4867:
4868: freeaddrinfo(resolution);
4869:
4870: (*s_etat_processus).erreur_execution =
4871: d_ex_erreur_acces_fichier;
4872: return;
4873: }
4874:
4875: if (((*((struct_socket *)
4876: (*s_objet_resultat).objet))
4877: .socket = socket(PF_INET6, type,
4878: protocole_numerique)) == -1)
4879: {
4880: liberation(s_etat_processus, s_objet_argument);
4881: liberation(s_etat_processus, s_objet_resultat);
4882:
4883: freeaddrinfo(resolution);
4884:
4885: (*s_etat_processus).erreur_execution =
4886: d_ex_erreur_acces_fichier;
4887: return;
4888: }
4889:
4890: (*((struct_socket *) (*s_objet_resultat).objet))
4891: .domaine = PF_INET6;
4892:
4893: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4894: socket_ipv6.sin6_family = AF_INET6;
4895: socket_ipv6.sin6_port = htons((uint16_t) port);
4896:
4897: for(i = 0; i < 16;
4898: socket_ipv6.sin6_addr.s6_addr[i] =
4899: (*((struct sockaddr_in6 *)
4900: (*resolution_courante).ai_addr))
4901: .sin6_addr.s6_addr[i], i++);
4902:
4903: if ((type_socket == 'S') || (type_socket == 'Q'))
4904: {
4905: if (connect((*((struct_socket *)
4906: (*s_objet_resultat).objet)).socket,
4907: (const struct sockaddr *)
4908: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4909: {
4910: liberation(s_etat_processus,
4911: s_objet_argument);
4912: liberation(s_etat_processus,
4913: s_objet_resultat);
4914:
4915: freeaddrinfo(resolution);
4916:
4917: (*s_etat_processus).erreur_execution =
4918: d_ex_erreur_acces_fichier;
4919: return;
4920: }
4921:
4922: (*((struct_socket *) (*s_objet_resultat).objet))
4923: .socket_connectee = d_vrai;
4924: (*((struct_socket *) (*s_objet_resultat).objet))
4925: .socket_en_ecoute = 'N';
4926: }
4927:
4928: if (((*((struct_socket *) (*s_objet_resultat)
4929: .objet)).adresse = malloc(55 *
4930: sizeof(unsigned char))) == NULL)
4931: {
4932: (*s_etat_processus).erreur_systeme =
4933: d_es_allocation_memoire;
4934: return;
4935: }
4936:
4937: for(i = 0; i < 16; i++)
4938: {
4939: sprintf((*((struct_socket *) (*s_objet_resultat)
4940: .objet)).adresse,
4941: (i == 0) ? "%s%X" : "%s:%X",
4942: (*((struct_socket *) (*s_objet_resultat)
4943: .objet)).adresse,
4944: (*((struct sockaddr_in6 *)
4945: (*resolution_courante).ai_addr))
4946: .sin6_addr.s6_addr[i]);
4947: }
4948: }
4949:
4950: freeaddrinfo(resolution);
4951:
4952: sprintf((*((struct_socket *) (*s_objet_resultat)
4953: .objet)).adresse, "%s(%u)",
4954: (*((struct_socket *) (*s_objet_resultat)
4955: .objet)).adresse, (unsigned int) port);
4956: }
4957: else
4958: { // Hôte défini par une adresse
4959: if (strcmp(protocole, "IPV4") == 0)
4960: { // Accès en IPv4
4961: if (type_adresse == '4')
4962: {
4963: if (((*((struct_socket *) (*s_objet_resultat)
4964: .objet)).adresse = malloc(22 *
4965: sizeof(unsigned char))) == NULL)
4966: {
4967: (*s_etat_processus).erreur_systeme =
4968: d_es_allocation_memoire;
4969: return;
4970: }
4971:
4972: (*((struct_socket *) (*s_objet_resultat).objet))
4973: .adresse[0] = d_code_fin_chaine;
4974:
4975: for(i = 0; i < 4; i++)
4976: {
4977: sprintf((*((struct_socket *)
4978: (*s_objet_resultat).objet)).adresse,
4979: (i == 0) ? "%s%d" : "%s.%d",
4980: (*((struct_socket *)
4981: (*s_objet_resultat)
4982: .objet)).adresse, (int) adresse[i]);
4983: }
4984:
4985: sprintf((*((struct_socket *) (*s_objet_resultat)
4986: .objet)).adresse, "%s(%u)",
4987: (*((struct_socket *) (*s_objet_resultat)
4988: .objet)).adresse, (unsigned int) port);
4989: }
4990: else
4991: {
4992: if (((*((struct_socket *) (*s_objet_resultat)
4993: .objet)).adresse = malloc(
4994: sizeof(unsigned char))) == NULL)
4995: {
4996: (*s_etat_processus).erreur_systeme =
4997: d_es_allocation_memoire;
4998: return;
4999: }
5000:
5001: (*((struct_socket *) (*s_objet_resultat).objet))
5002: .adresse[0] = d_code_fin_chaine;
5003: }
5004:
5005: if (((*((struct_socket *)
5006: (*s_objet_resultat).objet))
5007: .socket = socket(PF_INET, type,
5008: protocole_numerique)) == -1)
5009: {
5010: liberation(s_etat_processus, s_objet_argument);
5011: liberation(s_etat_processus, s_objet_resultat);
5012:
5013: (*s_etat_processus).erreur_execution =
5014: d_ex_erreur_acces_fichier;
5015: return;
5016: }
5017:
5018: (*((struct_socket *) (*s_objet_resultat).objet))
5019: .domaine = PF_INET;
5020:
5021: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
5022: socket_ipv4.sin_family = AF_INET;
5023: socket_ipv4.sin_port = htons((uint16_t) port);
5024:
5025: adresse_ipv4 = 0;
5026: for(i = 0; i < 4; adresse_ipv4 =
5027: (256 * adresse_ipv4) + adresse[i++]);
5028:
5029: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
5030:
5031: if ((type_socket == 'S') || (type_socket == 'Q'))
5032: {
5033: if (connect((*((struct_socket *)
5034: (*s_objet_resultat).objet)).socket,
5035: (const struct sockaddr *)
5036: &socket_ipv4, sizeof(socket_ipv4)) != 0)
5037: {
5038: liberation(s_etat_processus,
5039: s_objet_argument);
5040: liberation(s_etat_processus,
5041: s_objet_resultat);
5042:
5043: (*s_etat_processus).erreur_execution =
5044: d_ex_erreur_acces_fichier;
5045: return;
5046: }
5047:
5048: (*((struct_socket *) (*s_objet_resultat).objet))
5049: .socket_connectee = d_vrai;
5050: (*((struct_socket *) (*s_objet_resultat).objet))
5051: .socket_en_ecoute = 'N';
5052: }
5053: }
5054: else if (strcmp(protocole, "IPV6") == 0)
5055: { // Accès en IPv6
5056: if (type_adresse == '6')
5057: {
5058: if (((*((struct_socket *) (*s_objet_resultat)
5059: .objet)).adresse = malloc(55 *
5060: sizeof(unsigned char))) == NULL)
5061: {
5062: (*s_etat_processus).erreur_systeme =
5063: d_es_allocation_memoire;
5064: return;
5065: }
5066:
5067: (*((struct_socket *) (*s_objet_resultat).objet))
5068: .adresse[0] = d_code_fin_chaine;
5069:
5070: for(i = 0; i < 16; i++)
5071: {
5072: sprintf((*((struct_socket *)
5073: (*s_objet_resultat).objet)).adresse,
5074: (i == 0) ? "%s%X" : "%s:%X",
5075: (*((struct_socket *)
5076: (*s_objet_resultat)
5077: .objet)).adresse, (unsigned int)
5078: adresse[i]);
5079: }
5080:
5081: sprintf((*((struct_socket *) (*s_objet_resultat)
5082: .objet)).adresse, "%s(%u)",
5083: (*((struct_socket *) (*s_objet_resultat)
5084: .objet)).adresse, (unsigned int) port);
5085: }
5086: else
5087: {
5088: if (((*((struct_socket *) (*s_objet_resultat)
5089: .objet)).adresse = malloc(
5090: sizeof(unsigned char))) == NULL)
5091: {
5092: (*s_etat_processus).erreur_systeme =
5093: d_es_allocation_memoire;
5094: return;
5095: }
5096:
5097: (*((struct_socket *) (*s_objet_resultat).objet))
5098: .adresse[0] = d_code_fin_chaine;
5099: }
5100:
5101: if (((*((struct_socket *)
5102: (*s_objet_resultat).objet))
5103: .socket = socket(PF_INET6, type,
5104: protocole_numerique)) == -1)
5105: {
5106: liberation(s_etat_processus, s_objet_argument);
5107: liberation(s_etat_processus, s_objet_resultat);
5108:
5109: (*s_etat_processus).erreur_execution =
5110: d_ex_erreur_acces_fichier;
5111: return;
5112: }
5113:
5114: (*((struct_socket *) (*s_objet_resultat).objet))
5115: .domaine = PF_INET6;
5116:
5117: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5118: socket_ipv6.sin6_family = AF_INET6;
5119: socket_ipv6.sin6_port = htons((uint16_t) port);
5120:
5121: for(i = 0; i < 16;
5122: socket_ipv6.sin6_addr.s6_addr[i] =
5123: (unsigned char) (adresse[i]), i++);
5124:
5125: if ((type_socket == 'S') || (type_socket == 'Q'))
5126: {
5127: if (connect((*((struct_socket *)
5128: (*s_objet_resultat).objet)).socket,
5129: (const struct sockaddr *)
5130: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5131: {
5132: liberation(s_etat_processus,
5133: s_objet_argument);
5134: liberation(s_etat_processus,
5135: s_objet_resultat);
5136:
5137: (*s_etat_processus).erreur_execution =
5138: d_ex_erreur_acces_fichier;
5139: return;
5140: }
5141:
5142: (*((struct_socket *) (*s_objet_resultat).objet))
5143: .socket_connectee = d_vrai;
5144: (*((struct_socket *) (*s_objet_resultat).objet))
5145: .socket_en_ecoute = 'N';
5146: }
5147: }
5148: else
5149: { // Socket UNIX
5150: if (((*((struct_socket *) (*s_objet_resultat)
5151: .objet)).adresse = malloc(
5152: sizeof(unsigned char))) == NULL)
5153: {
5154: (*s_etat_processus).erreur_systeme =
5155: d_es_allocation_memoire;
5156: return;
5157: }
5158:
5159: (*((struct_socket *) (*s_objet_resultat).objet))
5160: .adresse[0] = d_code_fin_chaine;
5161:
5162: if (((*((struct_socket *)
5163: (*s_objet_resultat).objet))
5164: .socket = socket(PF_UNIX, type,
5165: protocole_numerique)) == -1)
5166: {
5167: liberation(s_etat_processus, s_objet_argument);
5168: liberation(s_etat_processus, s_objet_resultat);
5169:
5170: (*s_etat_processus).erreur_execution =
5171: d_ex_erreur_acces_fichier;
5172: return;
5173: }
5174: }
5175: }
5176:
5177: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
5178: = 'N';
5179: }
5180:
5181: if ((type_socket == 'S') || (type_socket == 'Q'))
5182: {
5183: if (protection == 'R')
5184: { // WRITEONLY
5185: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5186: .objet)).socket, SHUT_RD) != 0)
5187: {
5188: liberation(s_etat_processus, s_objet_argument);
5189: liberation(s_etat_processus, s_objet_resultat);
5190:
5191: (*s_etat_processus).erreur_execution =
5192: d_ex_erreur_acces_fichier;
5193: return;
5194: }
5195: }
5196: else if (protection == 'W')
5197: { // READONLY
5198: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5199: .objet)).socket, SHUT_WR) != 0)
5200: {
5201: liberation(s_etat_processus, s_objet_argument);
5202: liberation(s_etat_processus, s_objet_resultat);
5203:
5204: (*s_etat_processus).erreur_execution =
5205: d_ex_erreur_acces_fichier;
5206: return;
5207: }
5208: }
5209: else
5210: { // READWRITE
5211: }
5212: }
5213: }
5214:
5215: /*
5216: * Gestion de la liste des sockets ouvertes
5217: */
5218:
5219: l_element_courant = (*s_etat_processus).s_sockets;
5220:
5221: if (l_element_courant == NULL)
5222: {
5223: if (((*s_etat_processus).s_sockets =
5224: allocation_maillon(s_etat_processus)) == NULL)
5225: {
5226: (*s_etat_processus).erreur_systeme =
5227: d_es_allocation_memoire;
5228: return;
5229: }
5230:
5231: (*(*s_etat_processus).s_sockets).suivant = NULL;
5232: l_element_courant = (*s_etat_processus).s_sockets;
5233: }
5234: else
5235: {
5236: /*
5237: * Ajout d'un élément à la fin de la liste chaînée
5238: */
5239:
5240: while((*l_element_courant).suivant != NULL)
5241: {
5242: l_element_courant = (*l_element_courant).suivant;
5243: }
5244:
5245: if (((*l_element_courant).suivant =
5246: allocation_maillon(s_etat_processus)) == NULL)
5247: {
5248: (*s_etat_processus).erreur_systeme =
5249: d_es_allocation_memoire;
5250: return;
5251: }
5252:
5253: l_element_courant = (*l_element_courant).suivant;
5254: (*l_element_courant).suivant = NULL;
5255: }
5256:
5257: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
5258: s_objet_resultat, 'O')) == NULL)
5259: {
5260: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5261: return;
5262: }
5263: }
5264: else
5265: {
5266: liberation(s_etat_processus, s_objet_argument);
5267:
5268: (*s_etat_processus).erreur_execution =
5269: d_ex_erreur_parametre_fichier;
5270: return;
5271: }
5272: }
5273: else if ((*s_objet_argument).type == CHN)
5274: {
5275: if ((s_objet_resultat = allocation(s_etat_processus, SPH)) == NULL)
5276: {
5277: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5278: return;
5279: }
5280:
5281: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).nom =
5282: malloc((strlen((unsigned char *) (*s_objet_argument).objet)
5283: + 1) *sizeof(unsigned char))) == NULL)
5284: {
5285: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5286: return;
5287: }
5288:
5289: strcpy((*((struct_semaphore *) (*s_objet_resultat).objet)).nom,
5290: (unsigned char *) (*s_objet_argument).objet);
5291:
5292: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).semaphore =
5293: sem_open((*((struct_semaphore *) (*s_objet_resultat).objet))
5294: .nom, 0)) == SEM_FAILED)
5295: {
5296: if (errno == ENOMEM)
5297: {
5298: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5299: return;
5300: }
5301:
5302: (*s_etat_processus).erreur_execution = d_ex_semaphore;
5303:
5304: liberation(s_etat_processus, s_objet_argument);
5305: liberation(s_etat_processus, s_objet_resultat);
5306: return;
5307: }
5308: }
5309: else
5310: {
5311: liberation(s_etat_processus, s_objet_argument);
5312:
5313: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
5314: return;
5315: }
5316:
5317: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5318: s_objet_resultat) == d_erreur)
5319: {
5320: return;
5321: }
5322:
5323: return;
5324: }
5325:
5326: // vim: ts=4