![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_o1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_o1.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.9 bertrand 3: RPL/2 (R) version 4.0.14
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;
1.10 ! bertrand 4084:
! 4085: default :
! 4086: BUG(1, printf("type_socket=%c\n", type_socket));
! 4087: break;
1.1 bertrand 4088: }
4089:
4090: if ((protection != 'N') && ((type_socket != 'S') &&
4091: (type_socket != 'Q')))
4092: {
4093: liberation(s_etat_processus, s_objet_argument);
4094: liberation(s_etat_processus, s_objet_resultat);
4095:
4096: (*s_etat_processus).erreur_execution =
4097: d_ex_erreur_parametre_fichier;
4098: return;
4099: }
4100:
4101: if (nom == NULL)
4102: {
4103: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
4104: malloc(sizeof(unsigned char))) == NULL)
4105: {
4106: (*s_etat_processus).erreur_systeme =
4107: d_es_allocation_memoire;
4108: return;
4109: }
4110:
4111: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).adresse,
4112: "");
4113: }
4114: else
4115: {
4116: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
1.6 bertrand 4117: transliteration(s_etat_processus, nom,
4118: d_locale, "UTF-8")) == NULL)
1.1 bertrand 4119: {
1.6 bertrand 4120: liberation(s_etat_processus, s_objet_argument);
4121: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 4122: return;
4123: }
4124: }
4125:
4126: if (((*((struct_socket *) (*s_objet_resultat).objet))
4127: .adresse_distante = malloc(sizeof(unsigned char))) == NULL)
4128: {
4129: (*s_etat_processus).erreur_systeme =
4130: d_es_allocation_memoire;
4131: return;
4132: }
4133:
4134: strcpy((*((struct_socket *) (*s_objet_resultat).objet))
4135: .adresse_distante, "");
4136:
4137: (*((struct_socket *) (*s_objet_resultat).objet)).localisation =
4138: type_domaine;
4139: (*((struct_socket *) (*s_objet_resultat).objet)).binaire =
4140: format;
4141: (*((struct_socket *) (*s_objet_resultat).objet)).pid =
4142: getpid();
4143: (*((struct_socket *) (*s_objet_resultat).objet)).tid =
4144: pthread_self();
4145: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
4146: = 'Y';
4147: (*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee
4148: = d_faux;
4149:
4150: if (type_domaine == 'L')
4151: { // Socket serveur
4152: if (nom != NULL)
4153: {
4154: /*
4155: * La socket locale est dans l'espace des noms.
4156: */
4157:
4158: if (((*((struct_socket *) (*s_objet_resultat).objet))
4159: .socket = socket(PF_UNIX, type,
4160: protocole_numerique)) == -1)
4161: {
4162: liberation(s_etat_processus, s_objet_argument);
4163: liberation(s_etat_processus, s_objet_resultat);
4164:
4165: (*s_etat_processus).erreur_execution =
4166: d_ex_erreur_acces_fichier;
4167: return;
4168: }
4169:
4170: (*((struct_socket *) (*s_objet_resultat).objet)).domaine
4171: = PF_UNIX;
4172: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4173: = 'Y';
4174:
4175: socket_unix.sun_family = AF_UNIX;
4176:
4177: pointeur = (*((struct_socket *)
4178: (*s_objet_resultat).objet)).adresse;
4179:
4180: while((*pointeur) == d_code_espace)
4181: {
4182: pointeur++;
4183: }
4184:
4185: strncpy(socket_unix.sun_path, pointeur, 108);
4186: socket_unix.sun_path[108 - 1] = d_code_fin_chaine;
4187:
4188: if (options_socket() == d_erreur)
4189: {
4190: liberation(s_etat_processus, s_objet_argument);
4191: liberation(s_etat_processus, s_objet_resultat);
4192:
4193: return;
4194: }
4195:
4196: if (bind((*((struct_socket *) (*s_objet_resultat).objet))
4197: .socket, (const struct sockaddr *) &socket_unix,
4198: sizeof(socket_unix)) != 0)
4199: {
4200: liberation(s_etat_processus, s_objet_argument);
4201: liberation(s_etat_processus, s_objet_resultat);
4202:
4203: (*s_etat_processus).erreur_execution =
4204: d_ex_erreur_acces_fichier;
4205: return;
4206: }
4207: }
4208: else
4209: {
4210: /*
4211: * La socket est une socket réseau locale. L'adresse
4212: * passée en argument est l'adresse sur laquelle
4213: * cette socket est à l'écoute.
4214: */
4215:
4216: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4217: = 'N';
4218:
4219: if (hote != NULL)
4220: { // Hôte défini par un nom
4221: resolution = NULL;
4222:
4223: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4224: {
4225: liberation(s_etat_processus, s_objet_argument);
4226: liberation(s_etat_processus, s_objet_resultat);
4227:
4228: if (resolution != NULL)
4229: {
4230: freeaddrinfo(resolution);
4231: }
4232:
4233: (*s_etat_processus).erreur_execution =
4234: d_ex_erreur_acces_fichier;
4235: return;
4236: }
4237:
4238: if (strcmp(protocole, "IPV4") == 0)
4239: { // Accès en IPv4
4240: resolution_courante = resolution;
4241:
4242: while(resolution_courante != NULL)
4243: {
4244: if ((*resolution_courante).ai_family ==
4245: AF_INET)
4246: {
4247: break;
4248: }
4249:
4250: resolution_courante = (*resolution_courante)
4251: .ai_next;
4252: }
4253:
4254: if (resolution_courante == NULL)
4255: {
4256: liberation(s_etat_processus, s_objet_argument);
4257: liberation(s_etat_processus, s_objet_resultat);
4258:
4259: freeaddrinfo(resolution);
4260:
4261: (*s_etat_processus).erreur_execution =
4262: d_ex_erreur_acces_fichier;
4263: return;
4264: }
4265:
4266: if (((*((struct_socket *)
4267: (*s_objet_resultat).objet))
4268: .socket = socket(PF_INET, type,
4269: protocole_numerique)) == -1)
4270: {
4271: liberation(s_etat_processus, s_objet_argument);
4272: liberation(s_etat_processus, s_objet_resultat);
4273:
4274: freeaddrinfo(resolution);
4275:
4276: (*s_etat_processus).erreur_execution =
4277: d_ex_erreur_acces_fichier;
4278: return;
4279: }
4280:
4281: (*((struct_socket *) (*s_objet_resultat).objet))
4282: .domaine = PF_INET;
4283:
4284: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4285: socket_ipv4.sin_family = AF_INET;
4286: socket_ipv4.sin_port = htons((uint16_t) port);
4287: socket_ipv4.sin_addr.s_addr =
4288: (*((struct sockaddr_in *)
4289: (*resolution_courante).ai_addr))
4290: .sin_addr.s_addr;
4291:
4292: if (options_socket() == d_erreur)
4293: {
4294: liberation(s_etat_processus, s_objet_argument);
4295: liberation(s_etat_processus, s_objet_resultat);
4296:
4297: freeaddrinfo(resolution);
4298: return;
4299: }
4300:
4301: if (bind((*((struct_socket *) (*s_objet_resultat)
4302: .objet)).socket, (const struct sockaddr *)
4303: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4304: {
4305: liberation(s_etat_processus, s_objet_argument);
4306: liberation(s_etat_processus, s_objet_resultat);
4307:
4308: freeaddrinfo(resolution);
4309:
4310: (*s_etat_processus).erreur_execution =
4311: d_ex_erreur_acces_fichier;
4312: return;
4313: }
4314:
4315: if (((*((struct_socket *) (*s_objet_resultat)
4316: .objet)).adresse = malloc(22 *
4317: sizeof(unsigned char))) == NULL)
4318: {
4319: (*s_etat_processus).erreur_systeme =
4320: d_es_allocation_memoire;
4321: return;
4322: }
4323:
4324: sprintf((*((struct_socket *) (*s_objet_resultat)
4325: .objet)).adresse, "%d.%d.%d.%d",
4326: (ntohl((*((struct sockaddr_in *)
4327: (*resolution_courante).ai_addr)).sin_addr
4328: .s_addr) >> 24) & 0xFF,
4329: (ntohl((*((struct sockaddr_in *)
4330: (*resolution_courante).ai_addr)).sin_addr
4331: .s_addr) >> 16) & 0xFF,
4332: (ntohl((*((struct sockaddr_in *)
4333: (*resolution_courante).ai_addr)).sin_addr
4334: .s_addr) >> 8) & 0xFF,
4335: ntohl((*((struct sockaddr_in *)
4336: (*resolution_courante).ai_addr)).sin_addr
4337: .s_addr) & 0xFF);
4338: }
4339: else
4340: { // Accès en IPv6
4341: resolution_courante = resolution;
4342:
4343: while(resolution_courante != NULL)
4344: {
4345: if ((*resolution_courante).ai_family ==
4346: AF_INET6)
4347: {
4348: break;
4349: }
4350:
4351: resolution_courante = (*resolution_courante)
4352: .ai_next;
4353: }
4354:
4355: if (resolution_courante == NULL)
4356: {
4357: liberation(s_etat_processus, s_objet_argument);
4358: liberation(s_etat_processus, s_objet_resultat);
4359:
4360: freeaddrinfo(resolution);
4361:
4362: (*s_etat_processus).erreur_execution =
4363: d_ex_erreur_acces_fichier;
4364: return;
4365: }
4366:
4367: if (((*((struct_socket *)
4368: (*s_objet_resultat).objet))
4369: .socket = socket(PF_INET6, type,
4370: protocole_numerique)) == -1)
4371: {
4372: liberation(s_etat_processus, s_objet_argument);
4373: liberation(s_etat_processus, s_objet_resultat);
4374:
4375: freeaddrinfo(resolution);
4376:
4377: (*s_etat_processus).erreur_execution =
4378: d_ex_erreur_acces_fichier;
4379: return;
4380: }
4381:
4382: (*((struct_socket *) (*s_objet_resultat).objet))
4383: .domaine = PF_INET6;
4384:
4385: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4386: socket_ipv6.sin6_family = AF_INET6;
4387: socket_ipv6.sin6_port = htons((uint16_t) port);
4388:
4389: for(i = 0; i < 16;
4390: socket_ipv6.sin6_addr.s6_addr[i] =
4391: (*((struct sockaddr_in6 *)
4392: (*resolution_courante).ai_addr))
4393: .sin6_addr.s6_addr[i], i++);
4394:
4395: if (options_socket() == d_erreur)
4396: {
4397: liberation(s_etat_processus, s_objet_argument);
4398: liberation(s_etat_processus, s_objet_resultat);
4399:
4400: freeaddrinfo(resolution);
4401: return;
4402: }
4403:
4404: if (bind((*((struct_socket *) (*s_objet_resultat)
4405: .objet)).socket, (const struct sockaddr *)
4406: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4407: {
4408: liberation(s_etat_processus, s_objet_argument);
4409: liberation(s_etat_processus, s_objet_resultat);
4410:
4411: freeaddrinfo(resolution);
4412:
4413: (*s_etat_processus).erreur_execution =
4414: d_ex_erreur_acces_fichier;
4415: return;
4416: }
4417:
4418: if (((*((struct_socket *) (*s_objet_resultat)
4419: .objet)).adresse = malloc(55 *
4420: sizeof(unsigned char))) == NULL)
4421: {
4422: (*s_etat_processus).erreur_systeme =
4423: d_es_allocation_memoire;
4424: return;
4425: }
4426:
4427: for(i = 0; i < 16; i++)
4428: {
4429: sprintf((*((struct_socket *) (*s_objet_resultat)
4430: .objet)).adresse,
4431: (i == 0) ? "%s%X" : "%s:%X",
4432: (*((struct_socket *) (*s_objet_resultat)
4433: .objet)).adresse,
4434: (*((struct sockaddr_in6 *)
4435: (*resolution_courante).ai_addr))
4436: .sin6_addr.s6_addr[i]);
4437: }
4438: }
4439:
4440: freeaddrinfo(resolution);
4441:
4442: sprintf((*((struct_socket *) (*s_objet_resultat)
4443: .objet)).adresse, "%s(%u)",
4444: (*((struct_socket *) (*s_objet_resultat)
4445: .objet)).adresse, (unsigned int) port);
4446: }
4447: else
4448: { // Hôte défini par une adresse
4449: if (strcmp(protocole, "IPV4") == 0)
4450: { // Accès en IPv4
4451: if (((*((struct_socket *) (*s_objet_resultat)
4452: .objet)).adresse = malloc(22 *
4453: sizeof(unsigned char))) == NULL)
4454: {
4455: (*s_etat_processus).erreur_systeme =
4456: d_es_allocation_memoire;
4457: return;
4458: }
4459:
4460: (*((struct_socket *) (*s_objet_resultat).objet))
4461: .adresse[0] = d_code_fin_chaine;
4462:
4463: for(i = 0; i < 4; i++)
4464: {
4465: sprintf((*((struct_socket *) (*s_objet_resultat)
4466: .objet)).adresse,
4467: (i == 0) ? "%s%d" : "%s.%d",
4468: (*((struct_socket *) (*s_objet_resultat)
4469: .objet)).adresse, (int) adresse[i]);
4470: }
4471:
4472: sprintf((*((struct_socket *) (*s_objet_resultat)
4473: .objet)).adresse, "%s(%u)",
4474: (*((struct_socket *) (*s_objet_resultat)
4475: .objet)).adresse, (unsigned int) port);
4476:
4477: if (((*((struct_socket *)
4478: (*s_objet_resultat).objet))
4479: .socket = socket(PF_INET, type,
4480: protocole_numerique)) == -1)
4481: {
4482: liberation(s_etat_processus, s_objet_argument);
4483: liberation(s_etat_processus, s_objet_resultat);
4484:
4485: (*s_etat_processus).erreur_execution =
4486: d_ex_erreur_acces_fichier;
4487: return;
4488: }
4489:
4490: (*((struct_socket *) (*s_objet_resultat).objet))
4491: .domaine = PF_INET;
4492:
4493: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4494: socket_ipv4.sin_family = AF_INET;
4495: socket_ipv4.sin_port = htons((uint16_t) port);
4496:
4497: adresse_ipv4 = 0;
4498: for(i = 0; i < 4; adresse_ipv4 =
4499: (256 * adresse_ipv4) + adresse[i++]);
4500:
4501: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
4502:
4503: if (options_socket() == d_erreur)
4504: {
4505: liberation(s_etat_processus, s_objet_argument);
4506: liberation(s_etat_processus, s_objet_resultat);
4507:
4508: return;
4509: }
4510:
4511: if (bind((*((struct_socket *) (*s_objet_resultat)
4512: .objet)).socket, (const struct sockaddr *)
4513: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4514: {
4515: liberation(s_etat_processus, s_objet_argument);
4516: liberation(s_etat_processus, s_objet_resultat);
4517:
4518: (*s_etat_processus).erreur_execution =
4519: d_ex_erreur_acces_fichier;
4520: return;
4521: }
4522: }
4523: else
4524: { // Accès en IPv6
4525: if (((*((struct_socket *) (*s_objet_resultat)
4526: .objet)).adresse = malloc(55 *
4527: sizeof(unsigned char))) == NULL)
4528: {
4529: (*s_etat_processus).erreur_systeme =
4530: d_es_allocation_memoire;
4531: return;
4532: }
4533:
4534: (*((struct_socket *) (*s_objet_resultat).objet))
4535: .adresse[0] = d_code_fin_chaine;
4536:
4537: for(i = 0; i < 16; i++)
4538: {
4539: sprintf((*((struct_socket *) (*s_objet_resultat)
4540: .objet)).adresse,
4541: (i == 0) ? "%s%X" : "%s:%X",
4542: (*((struct_socket *) (*s_objet_resultat)
4543: .objet)).adresse, (unsigned int)
4544: adresse[i]);
4545: }
4546:
4547: sprintf((*((struct_socket *) (*s_objet_resultat)
4548: .objet)).adresse, "%s(%u)",
4549: (*((struct_socket *) (*s_objet_resultat)
4550: .objet)).adresse, (unsigned int) port);
4551:
4552: if (((*((struct_socket *)
4553: (*s_objet_resultat).objet))
4554: .socket = socket(PF_INET6, type,
4555: protocole_numerique)) == -1)
4556: {
4557: liberation(s_etat_processus, s_objet_argument);
4558: liberation(s_etat_processus, s_objet_resultat);
4559:
4560: (*s_etat_processus).erreur_execution =
4561: d_ex_erreur_acces_fichier;
4562: return;
4563: }
4564:
4565: (*((struct_socket *) (*s_objet_resultat).objet))
4566: .domaine = PF_INET6;
4567:
4568: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4569: socket_ipv6.sin6_family = AF_INET6;
4570: socket_ipv6.sin6_port = htons((uint16_t) port);
4571:
4572: for(i = 0; i < 16;
4573: socket_ipv6.sin6_addr.s6_addr[i] =
4574: (unsigned char) (adresse[i]), i++);
4575:
4576: if (options_socket() == d_erreur)
4577: {
4578: liberation(s_etat_processus, s_objet_argument);
4579: liberation(s_etat_processus, s_objet_resultat);
4580:
4581: return;
4582: }
4583:
4584: if (bind((*((struct_socket *) (*s_objet_resultat)
4585: .objet)).socket, (const struct sockaddr *)
4586: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4587: {
4588: liberation(s_etat_processus, s_objet_argument);
4589: liberation(s_etat_processus, s_objet_resultat);
4590:
4591: (*s_etat_processus).erreur_execution =
4592: d_ex_erreur_acces_fichier;
4593: return;
4594: }
4595: }
4596: }
4597:
4598: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4599: = 'N';
4600: }
4601:
4602: if ((type_socket == 'S') || (type_socket == 'Q'))
4603: {
4604: if (listen((*((struct_socket *) (*s_objet_resultat).objet))
4605: .socket, (int) nombre_maximal_connexions) != 0)
4606: {
4607: liberation(s_etat_processus, s_objet_argument);
4608: liberation(s_etat_processus, s_objet_resultat);
4609:
4610: (*s_etat_processus).erreur_execution =
4611: d_ex_erreur_acces_fichier;
4612: return;
4613: }
4614:
4615: (*((struct_socket *) (*s_objet_resultat).objet))
4616: .socket_connectee = d_vrai;
4617:
4618: if (protection == 'R')
4619: { // WRITEONLY
4620: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4621: .objet)).socket, SHUT_RD) != 0)
4622: {
4623: liberation(s_etat_processus, s_objet_argument);
4624: liberation(s_etat_processus, s_objet_resultat);
4625:
4626: (*s_etat_processus).erreur_execution =
4627: d_ex_erreur_acces_fichier;
4628: return;
4629: }
4630: }
4631: else if (protection == 'W')
4632: { // READONLY
4633: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4634: .objet)).socket, SHUT_WR) != 0)
4635: {
4636: liberation(s_etat_processus, s_objet_argument);
4637: liberation(s_etat_processus, s_objet_resultat);
4638:
4639: (*s_etat_processus).erreur_execution =
4640: d_ex_erreur_acces_fichier;
4641: return;
4642: }
4643: }
4644: else
4645: { // READWRITE
4646: }
4647: }
4648: }
4649: else
4650: { // Socket cliente
4651: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4652: = 'N';
4653:
4654: /*
4655: * Dans le cas où la socket n'est pas connectée, on
4656: * ne peut utiliser ni "NAME", ni "HOST", ni "PORT",
4657: * et encore moins spécifier une adresse. En effet, la cible
4658: * est défini par la commande TARGET.
4659: */
4660:
4661: if ((type_socket != 'S') && (type_socket != 'Q'))
4662: {
4663: if ((presence_port == d_vrai) || (hote != NULL) ||
4664: (nom != NULL) || (type_adresse != ' '))
4665: {
4666: liberation(s_etat_processus, s_objet_argument);
4667: liberation(s_etat_processus, s_objet_resultat);
4668:
4669: (*s_etat_processus).erreur_execution =
4670: d_ex_erreur_parametre_fichier;
4671: return;
4672: }
4673: }
4674:
4675: if (nom != NULL)
4676: {
4677: /*
4678: * La socket est dans l'espace des noms.
4679: */
4680:
4681: if (((*((struct_socket *) (*s_objet_resultat).objet))
4682: .socket = socket(PF_UNIX, type,
4683: protocole_numerique)) == -1)
4684: {
4685: liberation(s_etat_processus, s_objet_argument);
4686: liberation(s_etat_processus, s_objet_resultat);
4687:
4688: (*s_etat_processus).erreur_execution =
4689: d_ex_erreur_acces_fichier;
4690: return;
4691: }
4692:
4693: (*((struct_socket *) (*s_objet_resultat).objet))
4694: .domaine = PF_UNIX;
4695:
4696: socket_unix.sun_family = AF_UNIX;
4697: strncpy(socket_unix.sun_path, (*((struct_socket *)
4698: (*s_objet_resultat).objet)).adresse, 108);
4699: socket_unix.sun_path[108 - 1] = d_code_fin_chaine;
4700:
4701: if ((type_socket == 'S') || (type_socket == 'Q'))
4702: {
4703: if (connect((*((struct_socket *) (*s_objet_resultat)
4704: .objet)).socket, (const struct sockaddr *)
4705: &socket_unix, sizeof(socket_unix)) != 0)
4706: {
4707: liberation(s_etat_processus, s_objet_argument);
4708: liberation(s_etat_processus, s_objet_resultat);
4709:
4710: (*s_etat_processus).erreur_execution =
4711: d_ex_erreur_acces_fichier;
4712: return;
4713: }
4714:
4715: (*((struct_socket *) (*s_objet_resultat).objet))
4716: .socket_connectee = d_vrai;
4717: (*((struct_socket *) (*s_objet_resultat).objet))
4718: .socket_en_ecoute = 'N';
4719: }
4720: }
4721: else
4722: {
4723: /*
4724: * La socket est une socket réseau. L'adresse
4725: * passée en argument est l'adresse sur laquelle
4726: * cette socket est à l'écoute.
4727: */
4728:
4729: if (hote != NULL)
4730: { // Hôte défini par un nom
4731: resolution = NULL;
4732:
4733: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4734: {
4735: liberation(s_etat_processus, s_objet_argument);
4736: liberation(s_etat_processus, s_objet_resultat);
4737:
4738: if (resolution != NULL)
4739: {
4740: freeaddrinfo(resolution);
4741: }
4742:
4743: (*s_etat_processus).erreur_execution =
4744: d_ex_erreur_acces_fichier;
4745: return;
4746: }
4747:
4748: if (strcmp(protocole, "IPV4") == 0)
4749: { // Accès en IPv4
4750: resolution_courante = resolution;
4751:
4752: while(resolution_courante != NULL)
4753: {
4754: if ((*resolution_courante).ai_family ==
4755: AF_INET)
4756: {
4757: break;
4758: }
4759:
4760: resolution_courante = (*resolution_courante)
4761: .ai_next;
4762: }
4763:
4764: if (resolution_courante == NULL)
4765: {
4766: liberation(s_etat_processus, s_objet_argument);
4767: liberation(s_etat_processus, s_objet_resultat);
4768:
4769: freeaddrinfo(resolution);
4770:
4771: (*s_etat_processus).erreur_execution =
4772: d_ex_erreur_acces_fichier;
4773: return;
4774: }
4775:
4776: if (((*((struct_socket *)
4777: (*s_objet_resultat).objet))
4778: .socket = socket(PF_INET, type,
4779: protocole_numerique)) == -1)
4780: {
4781: liberation(s_etat_processus, s_objet_argument);
4782: liberation(s_etat_processus, s_objet_resultat);
4783:
4784: freeaddrinfo(resolution);
4785:
4786: (*s_etat_processus).erreur_execution =
4787: d_ex_erreur_acces_fichier;
4788: return;
4789: }
4790:
4791: (*((struct_socket *) (*s_objet_resultat).objet))
4792: .domaine = PF_INET;
4793:
4794: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4795: socket_ipv4.sin_family = AF_INET;
4796: socket_ipv4.sin_port = htons((uint16_t) port);
4797: socket_ipv4.sin_addr.s_addr =
4798: (*((struct sockaddr_in *)
4799: (*resolution_courante).ai_addr))
4800: .sin_addr.s_addr;
4801:
4802: if ((type_socket == 'S') || (type_socket == 'Q'))
4803: {
4804: if (connect((*((struct_socket *)
4805: (*s_objet_resultat).objet)).socket,
4806: (const struct sockaddr *)
4807: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4808: {
4809: liberation(s_etat_processus,
4810: s_objet_argument);
4811: liberation(s_etat_processus,
4812: s_objet_resultat);
4813:
4814: freeaddrinfo(resolution);
4815:
4816: (*s_etat_processus).erreur_execution =
4817: d_ex_erreur_acces_fichier;
4818: return;
4819: }
4820:
4821: (*((struct_socket *) (*s_objet_resultat).objet))
4822: .socket_connectee = d_vrai;
4823: (*((struct_socket *) (*s_objet_resultat).objet))
4824: .socket_en_ecoute = 'N';
4825: }
4826:
4827: if (((*((struct_socket *) (*s_objet_resultat)
4828: .objet)).adresse = malloc(22 *
4829: sizeof(unsigned char))) == NULL)
4830: {
4831: (*s_etat_processus).erreur_systeme =
4832: d_es_allocation_memoire;
4833: return;
4834: }
4835:
4836: sprintf((*((struct_socket *) (*s_objet_resultat)
4837: .objet)).adresse, "%d.%d.%d.%d",
4838: (ntohl((*((struct sockaddr_in *)
4839: (*resolution_courante).ai_addr)).sin_addr
4840: .s_addr) >> 24) & 0xFF,
4841: (ntohl((*((struct sockaddr_in *)
4842: (*resolution_courante).ai_addr)).sin_addr
4843: .s_addr) >> 16) & 0xFF,
4844: (ntohl((*((struct sockaddr_in *)
4845: (*resolution_courante).ai_addr)).sin_addr
4846: .s_addr) >> 8) & 0xFF,
4847: ntohl((*((struct sockaddr_in *)
4848: (*resolution_courante).ai_addr)).sin_addr
4849: .s_addr) & 0xFF);
4850: }
4851: else
4852: { // Accès en IPv6
4853: resolution_courante = resolution;
4854:
4855: while(resolution_courante != NULL)
4856: {
4857: if ((*resolution_courante).ai_family ==
4858: AF_INET6)
4859: {
4860: break;
4861: }
4862:
4863: resolution_courante = (*resolution_courante)
4864: .ai_next;
4865: }
4866:
4867: if (resolution_courante == NULL)
4868: {
4869: liberation(s_etat_processus, s_objet_argument);
4870: liberation(s_etat_processus, s_objet_resultat);
4871:
4872: freeaddrinfo(resolution);
4873:
4874: (*s_etat_processus).erreur_execution =
4875: d_ex_erreur_acces_fichier;
4876: return;
4877: }
4878:
4879: if (((*((struct_socket *)
4880: (*s_objet_resultat).objet))
4881: .socket = socket(PF_INET6, type,
4882: protocole_numerique)) == -1)
4883: {
4884: liberation(s_etat_processus, s_objet_argument);
4885: liberation(s_etat_processus, s_objet_resultat);
4886:
4887: freeaddrinfo(resolution);
4888:
4889: (*s_etat_processus).erreur_execution =
4890: d_ex_erreur_acces_fichier;
4891: return;
4892: }
4893:
4894: (*((struct_socket *) (*s_objet_resultat).objet))
4895: .domaine = PF_INET6;
4896:
4897: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4898: socket_ipv6.sin6_family = AF_INET6;
4899: socket_ipv6.sin6_port = htons((uint16_t) port);
4900:
4901: for(i = 0; i < 16;
4902: socket_ipv6.sin6_addr.s6_addr[i] =
4903: (*((struct sockaddr_in6 *)
4904: (*resolution_courante).ai_addr))
4905: .sin6_addr.s6_addr[i], i++);
4906:
4907: if ((type_socket == 'S') || (type_socket == 'Q'))
4908: {
4909: if (connect((*((struct_socket *)
4910: (*s_objet_resultat).objet)).socket,
4911: (const struct sockaddr *)
4912: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4913: {
4914: liberation(s_etat_processus,
4915: s_objet_argument);
4916: liberation(s_etat_processus,
4917: s_objet_resultat);
4918:
4919: freeaddrinfo(resolution);
4920:
4921: (*s_etat_processus).erreur_execution =
4922: d_ex_erreur_acces_fichier;
4923: return;
4924: }
4925:
4926: (*((struct_socket *) (*s_objet_resultat).objet))
4927: .socket_connectee = d_vrai;
4928: (*((struct_socket *) (*s_objet_resultat).objet))
4929: .socket_en_ecoute = 'N';
4930: }
4931:
4932: if (((*((struct_socket *) (*s_objet_resultat)
4933: .objet)).adresse = malloc(55 *
4934: sizeof(unsigned char))) == NULL)
4935: {
4936: (*s_etat_processus).erreur_systeme =
4937: d_es_allocation_memoire;
4938: return;
4939: }
4940:
4941: for(i = 0; i < 16; i++)
4942: {
4943: sprintf((*((struct_socket *) (*s_objet_resultat)
4944: .objet)).adresse,
4945: (i == 0) ? "%s%X" : "%s:%X",
4946: (*((struct_socket *) (*s_objet_resultat)
4947: .objet)).adresse,
4948: (*((struct sockaddr_in6 *)
4949: (*resolution_courante).ai_addr))
4950: .sin6_addr.s6_addr[i]);
4951: }
4952: }
4953:
4954: freeaddrinfo(resolution);
4955:
4956: sprintf((*((struct_socket *) (*s_objet_resultat)
4957: .objet)).adresse, "%s(%u)",
4958: (*((struct_socket *) (*s_objet_resultat)
4959: .objet)).adresse, (unsigned int) port);
4960: }
4961: else
4962: { // Hôte défini par une adresse
4963: if (strcmp(protocole, "IPV4") == 0)
4964: { // Accès en IPv4
4965: if (type_adresse == '4')
4966: {
4967: if (((*((struct_socket *) (*s_objet_resultat)
4968: .objet)).adresse = malloc(22 *
4969: sizeof(unsigned char))) == NULL)
4970: {
4971: (*s_etat_processus).erreur_systeme =
4972: d_es_allocation_memoire;
4973: return;
4974: }
4975:
4976: (*((struct_socket *) (*s_objet_resultat).objet))
4977: .adresse[0] = d_code_fin_chaine;
4978:
4979: for(i = 0; i < 4; i++)
4980: {
4981: sprintf((*((struct_socket *)
4982: (*s_objet_resultat).objet)).adresse,
4983: (i == 0) ? "%s%d" : "%s.%d",
4984: (*((struct_socket *)
4985: (*s_objet_resultat)
4986: .objet)).adresse, (int) adresse[i]);
4987: }
4988:
4989: sprintf((*((struct_socket *) (*s_objet_resultat)
4990: .objet)).adresse, "%s(%u)",
4991: (*((struct_socket *) (*s_objet_resultat)
4992: .objet)).adresse, (unsigned int) port);
4993: }
4994: else
4995: {
4996: if (((*((struct_socket *) (*s_objet_resultat)
4997: .objet)).adresse = malloc(
4998: sizeof(unsigned char))) == NULL)
4999: {
5000: (*s_etat_processus).erreur_systeme =
5001: d_es_allocation_memoire;
5002: return;
5003: }
5004:
5005: (*((struct_socket *) (*s_objet_resultat).objet))
5006: .adresse[0] = d_code_fin_chaine;
5007: }
5008:
5009: if (((*((struct_socket *)
5010: (*s_objet_resultat).objet))
5011: .socket = socket(PF_INET, type,
5012: protocole_numerique)) == -1)
5013: {
5014: liberation(s_etat_processus, s_objet_argument);
5015: liberation(s_etat_processus, s_objet_resultat);
5016:
5017: (*s_etat_processus).erreur_execution =
5018: d_ex_erreur_acces_fichier;
5019: return;
5020: }
5021:
5022: (*((struct_socket *) (*s_objet_resultat).objet))
5023: .domaine = PF_INET;
5024:
5025: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
5026: socket_ipv4.sin_family = AF_INET;
5027: socket_ipv4.sin_port = htons((uint16_t) port);
5028:
5029: adresse_ipv4 = 0;
5030: for(i = 0; i < 4; adresse_ipv4 =
5031: (256 * adresse_ipv4) + adresse[i++]);
5032:
5033: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
5034:
5035: if ((type_socket == 'S') || (type_socket == 'Q'))
5036: {
5037: if (connect((*((struct_socket *)
5038: (*s_objet_resultat).objet)).socket,
5039: (const struct sockaddr *)
5040: &socket_ipv4, sizeof(socket_ipv4)) != 0)
5041: {
5042: liberation(s_etat_processus,
5043: s_objet_argument);
5044: liberation(s_etat_processus,
5045: s_objet_resultat);
5046:
5047: (*s_etat_processus).erreur_execution =
5048: d_ex_erreur_acces_fichier;
5049: return;
5050: }
5051:
5052: (*((struct_socket *) (*s_objet_resultat).objet))
5053: .socket_connectee = d_vrai;
5054: (*((struct_socket *) (*s_objet_resultat).objet))
5055: .socket_en_ecoute = 'N';
5056: }
5057: }
5058: else if (strcmp(protocole, "IPV6") == 0)
5059: { // Accès en IPv6
5060: if (type_adresse == '6')
5061: {
5062: if (((*((struct_socket *) (*s_objet_resultat)
5063: .objet)).adresse = malloc(55 *
5064: sizeof(unsigned char))) == NULL)
5065: {
5066: (*s_etat_processus).erreur_systeme =
5067: d_es_allocation_memoire;
5068: return;
5069: }
5070:
5071: (*((struct_socket *) (*s_objet_resultat).objet))
5072: .adresse[0] = d_code_fin_chaine;
5073:
5074: for(i = 0; i < 16; i++)
5075: {
5076: sprintf((*((struct_socket *)
5077: (*s_objet_resultat).objet)).adresse,
5078: (i == 0) ? "%s%X" : "%s:%X",
5079: (*((struct_socket *)
5080: (*s_objet_resultat)
5081: .objet)).adresse, (unsigned int)
5082: adresse[i]);
5083: }
5084:
5085: sprintf((*((struct_socket *) (*s_objet_resultat)
5086: .objet)).adresse, "%s(%u)",
5087: (*((struct_socket *) (*s_objet_resultat)
5088: .objet)).adresse, (unsigned int) port);
5089: }
5090: else
5091: {
5092: if (((*((struct_socket *) (*s_objet_resultat)
5093: .objet)).adresse = malloc(
5094: sizeof(unsigned char))) == NULL)
5095: {
5096: (*s_etat_processus).erreur_systeme =
5097: d_es_allocation_memoire;
5098: return;
5099: }
5100:
5101: (*((struct_socket *) (*s_objet_resultat).objet))
5102: .adresse[0] = d_code_fin_chaine;
5103: }
5104:
5105: if (((*((struct_socket *)
5106: (*s_objet_resultat).objet))
5107: .socket = socket(PF_INET6, type,
5108: protocole_numerique)) == -1)
5109: {
5110: liberation(s_etat_processus, s_objet_argument);
5111: liberation(s_etat_processus, s_objet_resultat);
5112:
5113: (*s_etat_processus).erreur_execution =
5114: d_ex_erreur_acces_fichier;
5115: return;
5116: }
5117:
5118: (*((struct_socket *) (*s_objet_resultat).objet))
5119: .domaine = PF_INET6;
5120:
5121: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
5122: socket_ipv6.sin6_family = AF_INET6;
5123: socket_ipv6.sin6_port = htons((uint16_t) port);
5124:
5125: for(i = 0; i < 16;
5126: socket_ipv6.sin6_addr.s6_addr[i] =
5127: (unsigned char) (adresse[i]), i++);
5128:
5129: if ((type_socket == 'S') || (type_socket == 'Q'))
5130: {
5131: if (connect((*((struct_socket *)
5132: (*s_objet_resultat).objet)).socket,
5133: (const struct sockaddr *)
5134: &socket_ipv6, sizeof(socket_ipv6)) != 0)
5135: {
5136: liberation(s_etat_processus,
5137: s_objet_argument);
5138: liberation(s_etat_processus,
5139: s_objet_resultat);
5140:
5141: (*s_etat_processus).erreur_execution =
5142: d_ex_erreur_acces_fichier;
5143: return;
5144: }
5145:
5146: (*((struct_socket *) (*s_objet_resultat).objet))
5147: .socket_connectee = d_vrai;
5148: (*((struct_socket *) (*s_objet_resultat).objet))
5149: .socket_en_ecoute = 'N';
5150: }
5151: }
5152: else
5153: { // Socket UNIX
5154: if (((*((struct_socket *) (*s_objet_resultat)
5155: .objet)).adresse = malloc(
5156: sizeof(unsigned char))) == NULL)
5157: {
5158: (*s_etat_processus).erreur_systeme =
5159: d_es_allocation_memoire;
5160: return;
5161: }
5162:
5163: (*((struct_socket *) (*s_objet_resultat).objet))
5164: .adresse[0] = d_code_fin_chaine;
5165:
5166: if (((*((struct_socket *)
5167: (*s_objet_resultat).objet))
5168: .socket = socket(PF_UNIX, type,
5169: protocole_numerique)) == -1)
5170: {
5171: liberation(s_etat_processus, s_objet_argument);
5172: liberation(s_etat_processus, s_objet_resultat);
5173:
5174: (*s_etat_processus).erreur_execution =
5175: d_ex_erreur_acces_fichier;
5176: return;
5177: }
5178: }
5179: }
5180:
5181: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
5182: = 'N';
5183: }
5184:
5185: if ((type_socket == 'S') || (type_socket == 'Q'))
5186: {
5187: if (protection == 'R')
5188: { // WRITEONLY
5189: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5190: .objet)).socket, SHUT_RD) != 0)
5191: {
5192: liberation(s_etat_processus, s_objet_argument);
5193: liberation(s_etat_processus, s_objet_resultat);
5194:
5195: (*s_etat_processus).erreur_execution =
5196: d_ex_erreur_acces_fichier;
5197: return;
5198: }
5199: }
5200: else if (protection == 'W')
5201: { // READONLY
5202: if (shutdown((*((struct_socket *) (*s_objet_resultat)
5203: .objet)).socket, SHUT_WR) != 0)
5204: {
5205: liberation(s_etat_processus, s_objet_argument);
5206: liberation(s_etat_processus, s_objet_resultat);
5207:
5208: (*s_etat_processus).erreur_execution =
5209: d_ex_erreur_acces_fichier;
5210: return;
5211: }
5212: }
5213: else
5214: { // READWRITE
5215: }
5216: }
5217: }
5218:
5219: /*
5220: * Gestion de la liste des sockets ouvertes
5221: */
5222:
5223: l_element_courant = (*s_etat_processus).s_sockets;
5224:
5225: if (l_element_courant == NULL)
5226: {
5227: if (((*s_etat_processus).s_sockets =
5228: allocation_maillon(s_etat_processus)) == NULL)
5229: {
5230: (*s_etat_processus).erreur_systeme =
5231: d_es_allocation_memoire;
5232: return;
5233: }
5234:
5235: (*(*s_etat_processus).s_sockets).suivant = NULL;
5236: l_element_courant = (*s_etat_processus).s_sockets;
5237: }
5238: else
5239: {
5240: /*
5241: * Ajout d'un élément à la fin de la liste chaînée
5242: */
5243:
5244: while((*l_element_courant).suivant != NULL)
5245: {
5246: l_element_courant = (*l_element_courant).suivant;
5247: }
5248:
5249: if (((*l_element_courant).suivant =
5250: allocation_maillon(s_etat_processus)) == NULL)
5251: {
5252: (*s_etat_processus).erreur_systeme =
5253: d_es_allocation_memoire;
5254: return;
5255: }
5256:
5257: l_element_courant = (*l_element_courant).suivant;
5258: (*l_element_courant).suivant = NULL;
5259: }
5260:
5261: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
5262: s_objet_resultat, 'O')) == NULL)
5263: {
5264: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5265: return;
5266: }
5267: }
5268: else
5269: {
5270: liberation(s_etat_processus, s_objet_argument);
5271:
5272: (*s_etat_processus).erreur_execution =
5273: d_ex_erreur_parametre_fichier;
5274: return;
5275: }
5276: }
5277: else if ((*s_objet_argument).type == CHN)
5278: {
5279: if ((s_objet_resultat = allocation(s_etat_processus, SPH)) == NULL)
5280: {
5281: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5282: return;
5283: }
5284:
5285: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).nom =
5286: malloc((strlen((unsigned char *) (*s_objet_argument).objet)
5287: + 1) *sizeof(unsigned char))) == NULL)
5288: {
5289: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5290: return;
5291: }
5292:
5293: strcpy((*((struct_semaphore *) (*s_objet_resultat).objet)).nom,
5294: (unsigned char *) (*s_objet_argument).objet);
5295:
5296: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).semaphore =
5297: sem_open((*((struct_semaphore *) (*s_objet_resultat).objet))
5298: .nom, 0)) == SEM_FAILED)
5299: {
5300: if (errno == ENOMEM)
5301: {
5302: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5303: return;
5304: }
5305:
5306: (*s_etat_processus).erreur_execution = d_ex_semaphore;
5307:
5308: liberation(s_etat_processus, s_objet_argument);
5309: liberation(s_etat_processus, s_objet_resultat);
5310: return;
5311: }
5312: }
5313: else
5314: {
5315: liberation(s_etat_processus, s_objet_argument);
5316:
5317: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
5318: return;
5319: }
5320:
5321: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
5322: s_objet_resultat) == d_erreur)
5323: {
5324: return;
5325: }
5326:
5327: return;
5328: }
5329:
5330: // vim: ts=4