1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.10
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 autorisation_liberation_nom;
919: logical1 erreur;
920: logical1 existence;
921: logical1 ouverture;
922: logical1 presence_port;
923:
924: struct_liste_chainee *l_element_courant;
925: struct_liste_chainee *l_element_courant_sous_objet;
926:
927: struct flock lock;
928:
929: struct addrinfo *resolution;
930: struct addrinfo *resolution_courante;
931:
932: struct protoent *s_protocole;
933:
934: struct sockaddr_un socket_unix;
935: struct sockaddr_in socket_ipv4;
936: struct sockaddr_in6 socket_ipv6;
937:
938: struct_objet *s_objet_argument;
939: struct_objet *s_objet_resultat;
940:
941: uint32_t adresse_ipv4;
942:
943: unsigned char *argument_majuscule;
944: unsigned char *chaine_descripteurs;
945: unsigned char format;
946: unsigned char *hote;
947: unsigned char *nom;
948: unsigned char *nom_temporaire;
949: unsigned char options[12];
950: unsigned char *peripherique;
951: unsigned char *pointeur;
952: unsigned char protection;
953: unsigned char protocole[16 + 1];
954: unsigned char *protocole_socket;
955: unsigned char type_acces;
956: unsigned char type_adresse;
957: unsigned char type_arguments;
958: unsigned char type_domaine;
959: unsigned char type_ouverture;
960: unsigned char type_socket;
961:
962: unsigned long i;
963: unsigned long nombre_elements;
964: unsigned long prochain_descripteur;
965: unsigned long unite;
966:
967: # define d_BIND_TO_DEVICE 0
968: # define d_BROADCAST 1
969: # define d_DONT_ROUTE 2
970: # define d_KEEP_ALIVE 3
971: # define d_PRIORITY 4
972: # define d_RECEIVE_BUFFER 5
973: # define d_FORCE_RECEIVE_BUFFER 6
974: # define d_SEND_BUFFER 7
975: # define d_FORCE_SEND_BUFFER 8
976: # define d_RECEIVING_TIMEOUT 9
977: # define d_SENDING_TIMEOUT 10
978: # define d_REUSE_ADDRESS 11
979:
980: /*
981: * Argument : { "ouverture" "accès" "format" [ { "nom" } 'protection' ] }
982: */
983:
984: (*s_etat_processus).erreur_execution = d_ex;
985:
986: if ((*s_etat_processus).affichage_arguments == 'Y')
987: {
988: printf("\n OPEN ");
989:
990: if ((*s_etat_processus).langue == 'F')
991: {
992: printf("(ouverture d'un fichier, d'une socket ou d'un sémaphore)"
993: "\n\n");
994: }
995: else
996: {
997: printf("(open file, socket or semaphore)\n\n");
998: }
999:
1000: printf(" 1: %s\n", d_LST);
1001: printf("-> 1: %s, %s\n\n", d_FCH, d_SCK);
1002:
1003: printf(" 1: %s\n", d_CHN);
1004: printf("-> 1: %s\n\n", d_SPH);
1005:
1006: if ((*s_etat_processus).langue == 'F')
1007: {
1008: printf(" Utilisation :\n\n");
1009: }
1010: else
1011: {
1012: printf(" Usage:\n\n");
1013: }
1014:
1015: printf(" { \"filetype\" \"access\" \"format\" { \"name\" "
1016: "\"file name\" } \"protection\" } OPEN\n");
1017: printf(" { \"sockettype\" { \"name\" \"local name\" } } OPEN\n");
1018: printf(" { \"sockettype\" \"socketdomain\" \"protection\" } OPEN\n");
1019:
1020: printf(" File type : NEW/OLD/REPLACE/UNKNOWN/SCRATCH\n");
1021: printf(" File access : SEQUENTIAL/DIRECT/KEYED\n");
1022: printf(" Socket type : STREAM/DATAGRAM/RAW/"
1023: "ROBUST DATAGRAM/SEQUENTIAL DATAGRAM\n");
1024: printf(" Socket domain : LOCAL/FOREIGN\n");
1025: printf(" Socket protocol : IPV4/IPV6/UNIX\n");
1026: printf(" Format : FORMATTED/UNFORMATTED/FLOW\n");
1027: printf(" Protection : READONLY/WRITEONLY/READWRITE\n\n");
1028:
1029: printf(" Address : { \"ADDRESS\" [ 127 0 0 1 ] }\n");
1030: printf(" { \"HOST\" \"hostname\" }\n");
1031: printf(" Connections : { \"LISTEN\" amount of connections }\n");
1032: printf(" Name : { \"NAME\" \"filename\" }\n");
1033: printf(" Options : { \"OPTION\" \"option\" argument }\n");
1034: printf(" \"BIND TO DEVICE\" \"device\"\n");
1035: printf(" \"BROADCAST\"\n");
1036: printf(" \"DO NOT ROUTE\"\n");
1037: printf(" \"KEEP ALIVE\"\n");
1038: printf(" \"PRIORITY\" integer\n");
1039: printf(" \"RECEIVE BUFFER\" integer\n");
1040: printf(" \"FORCE RECEIVE BUFFER\" integer\n");
1041: printf(" \"SEND BUFFER\" integer\n");
1042: printf(" \"FORCE SEND BUFFER\" integer\n");
1043: printf(" \"RECEIVING TIMEOUT\" integer\n");
1044: printf(" \"SENDING TIMEOUT\" integer\n");
1045: printf(" \"REUSE ADDRESS\"\n");
1046: printf(" Port : { \"PORT\" port number }\n");
1047: printf(" Protocol : { \"PROTOCOL\" \"protocol\" }\n\n");
1048:
1049: printf(" { { \"NAME\" \"filename\" } } OPEN\n");
1050: printf(" { \"SCRATCH\" } OPEN\n");
1051: printf(" { { \"NAME\" \"filename\" } \"UNKNOWN\" \"FORMATTED\" "
1052: "\"DIRECT\" } OPEN\n");
1053: printf(" { { \"NAME\" \"filename\" } \"OLD\" \"FORMATTED\" "
1054: "\"KEYED\" { \"KEY\" 2 } } OPEN\n");
1055: printf(" { \"STREAM\" \"READWRITE\" } OPEN\n");
1056: printf(" { \"FOREIGN\" \"DATAGRAM\" } OPEN\n");
1057: printf(" { \"LOCAL\" { \"NAME\" \"socket.sock\" } } OPEN\n");
1058:
1059: return;
1060: }
1061: else if ((*s_etat_processus).test_instruction == 'Y')
1062: {
1063: (*s_etat_processus).nombre_arguments = -1;
1064: return;
1065: }
1066:
1067: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1068: {
1069: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1070: {
1071: return;
1072: }
1073: }
1074:
1075: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1076: &s_objet_argument) == d_erreur)
1077: {
1078: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1079: return;
1080: }
1081:
1082: if ((*s_objet_argument).type == LST)
1083: {
1084: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
1085:
1086: if (l_element_courant == NULL)
1087: {
1088: liberation(s_etat_processus, s_objet_argument);
1089:
1090: (*s_etat_processus).erreur_execution =
1091: d_ex_erreur_parametre_fichier;
1092: return;
1093: }
1094:
1095: format = ' ';
1096: type_domaine = ' ';
1097: type_ouverture = ' ';
1098: protection = ' ';
1099: type_acces = ' ';
1100: type_socket = ' ';
1101: nom = NULL;
1102: position_clef = 0;
1103: port = 0;
1104: type_arguments = ' ';
1105: nombre_maximal_connexions = 0;
1106: hote = NULL;
1107: type_adresse = ' ';
1108: protocole[0] = d_code_fin_chaine;
1109: protocole_socket = NULL;
1110: presence_port = d_faux;
1111: peripherique = NULL;
1112: priorite = 0;
1113: buffer_emission = 0;
1114: buffer_reception = 0;
1115: timeout_emission = 0;
1116: timeout_reception = 0;
1117: drapeau = -1;
1118:
1119: for(i = 0; i < 12; options[i++] = 'N');
1120:
1121: while(l_element_courant != NULL)
1122: {
1123: if ((*(*l_element_courant).donnee).type == CHN)
1124: {
1125: if ((argument_majuscule = conversion_majuscule((unsigned char *)
1126: (*(*l_element_courant).donnee).objet)) == NULL)
1127: {
1128: (*s_etat_processus).erreur_systeme =
1129: d_es_allocation_memoire;
1130: return;
1131: }
1132:
1133: if (strcmp(argument_majuscule, "NEW") == 0)
1134: {
1135: if (type_ouverture != ' ')
1136: {
1137: liberation(s_etat_processus, s_objet_argument);
1138: free(argument_majuscule);
1139:
1140: (*s_etat_processus).erreur_execution =
1141: d_ex_erreur_parametre_fichier;
1142: return;
1143: }
1144:
1145: if (type_arguments == ' ')
1146: {
1147: type_arguments = 'F';
1148: }
1149: else if (type_arguments == 'S')
1150: {
1151: liberation(s_etat_processus, s_objet_argument);
1152: free(argument_majuscule);
1153:
1154: (*s_etat_processus).erreur_execution =
1155: d_ex_erreur_parametre_fichier;
1156: return;
1157: }
1158:
1159: type_ouverture = 'N';
1160: }
1161: else if (strcmp(argument_majuscule, "REPLACE") == 0)
1162: {
1163: if (type_ouverture != ' ')
1164: {
1165: liberation(s_etat_processus, s_objet_argument);
1166: free(argument_majuscule);
1167:
1168: (*s_etat_processus).erreur_execution =
1169: d_ex_erreur_parametre_fichier;
1170: return;
1171: }
1172:
1173: if (type_arguments == ' ')
1174: {
1175: type_arguments = 'F';
1176: }
1177: else if (type_arguments == 'S')
1178: {
1179: liberation(s_etat_processus, s_objet_argument);
1180: free(argument_majuscule);
1181:
1182: (*s_etat_processus).erreur_execution =
1183: d_ex_erreur_parametre_fichier;
1184: return;
1185: }
1186:
1187: type_ouverture = 'R';
1188: }
1189: else if (strcmp(argument_majuscule, "UNKNOWN") == 0)
1190: {
1191: if (type_ouverture != ' ')
1192: {
1193: liberation(s_etat_processus, s_objet_argument);
1194: free(argument_majuscule);
1195:
1196: (*s_etat_processus).erreur_execution =
1197: d_ex_erreur_parametre_fichier;
1198: return;
1199: }
1200:
1201: if (type_arguments == ' ')
1202: {
1203: type_arguments = 'F';
1204: }
1205: else if (type_arguments == 'S')
1206: {
1207: liberation(s_etat_processus, s_objet_argument);
1208: free(argument_majuscule);
1209:
1210: (*s_etat_processus).erreur_execution =
1211: d_ex_erreur_parametre_fichier;
1212: return;
1213: }
1214:
1215: type_ouverture = 'U';
1216: }
1217: else if (strcmp(argument_majuscule, "SCRATCH") == 0)
1218: {
1219: if (type_ouverture != ' ')
1220: {
1221: liberation(s_etat_processus, s_objet_argument);
1222: free(argument_majuscule);
1223:
1224: (*s_etat_processus).erreur_execution =
1225: d_ex_erreur_parametre_fichier;
1226: return;
1227: }
1228:
1229: if (type_arguments == ' ')
1230: {
1231: type_arguments = 'F';
1232: }
1233: else if (type_arguments == 'S')
1234: {
1235: liberation(s_etat_processus, s_objet_argument);
1236: free(argument_majuscule);
1237:
1238: (*s_etat_processus).erreur_execution =
1239: d_ex_erreur_parametre_fichier;
1240: return;
1241: }
1242:
1243: type_ouverture = 'S';
1244: }
1245: else if (strcmp(argument_majuscule, "SEQUENTIAL") == 0)
1246: {
1247: if (type_acces != ' ')
1248: {
1249: liberation(s_etat_processus, s_objet_argument);
1250: free(argument_majuscule);
1251:
1252: (*s_etat_processus).erreur_execution =
1253: d_ex_erreur_parametre_fichier;
1254: return;
1255: }
1256:
1257: if (type_arguments == ' ')
1258: {
1259: type_arguments = 'F';
1260: }
1261: else if (type_arguments == 'S')
1262: {
1263: liberation(s_etat_processus, s_objet_argument);
1264: free(argument_majuscule);
1265:
1266: (*s_etat_processus).erreur_execution =
1267: d_ex_erreur_parametre_fichier;
1268: return;
1269: }
1270:
1271: type_acces = 'S';
1272: }
1273: else if (strcmp(argument_majuscule, "DIRECT") == 0)
1274: {
1275: if (type_acces != ' ')
1276: {
1277: liberation(s_etat_processus, s_objet_argument);
1278: free(argument_majuscule);
1279:
1280: (*s_etat_processus).erreur_execution =
1281: d_ex_erreur_parametre_fichier;
1282: return;
1283: }
1284:
1285: if (type_arguments == ' ')
1286: {
1287: type_arguments = 'F';
1288: }
1289: else if (type_arguments == 'S')
1290: {
1291: liberation(s_etat_processus, s_objet_argument);
1292: free(argument_majuscule);
1293:
1294: (*s_etat_processus).erreur_execution =
1295: d_ex_erreur_parametre_fichier;
1296: return;
1297: }
1298:
1299: type_acces = 'D';
1300: }
1301: else if (strcmp(argument_majuscule, "KEYED") == 0)
1302: {
1303: if (type_acces != ' ')
1304: {
1305: liberation(s_etat_processus, s_objet_argument);
1306: free(argument_majuscule);
1307:
1308: (*s_etat_processus).erreur_execution =
1309: d_ex_erreur_parametre_fichier;
1310: return;
1311: }
1312:
1313: if (type_arguments == ' ')
1314: {
1315: type_arguments = 'F';
1316: }
1317: else if (type_arguments == 'S')
1318: {
1319: liberation(s_etat_processus, s_objet_argument);
1320: free(argument_majuscule);
1321:
1322: (*s_etat_processus).erreur_execution =
1323: d_ex_erreur_parametre_fichier;
1324: return;
1325: }
1326:
1327: type_acces = 'I';
1328: }
1329: else if (strcmp(argument_majuscule, "READONLY") == 0)
1330: {
1331: if (protection != ' ')
1332: {
1333: liberation(s_etat_processus, s_objet_argument);
1334: free(argument_majuscule);
1335:
1336: (*s_etat_processus).erreur_execution =
1337: d_ex_erreur_parametre_fichier;
1338: return;
1339: }
1340:
1341: protection = 'R';
1342: }
1343: else if (strcmp(argument_majuscule, "WRITEONLY") == 0)
1344: {
1345: if (protection != ' ')
1346: {
1347: liberation(s_etat_processus, s_objet_argument);
1348: free(argument_majuscule);
1349:
1350: (*s_etat_processus).erreur_execution =
1351: d_ex_erreur_parametre_fichier;
1352: return;
1353: }
1354:
1355: protection = 'W';
1356: }
1357: else if (strcmp(argument_majuscule, "READWRITE") == 0)
1358: {
1359: if (protection != ' ')
1360: {
1361: liberation(s_etat_processus, s_objet_argument);
1362: free(argument_majuscule);
1363:
1364: (*s_etat_processus).erreur_execution =
1365: d_ex_erreur_parametre_fichier;
1366: return;
1367: }
1368:
1369: protection = 'N';
1370: }
1371: else if (strcmp(argument_majuscule, "FORMATTED") == 0)
1372: {
1373: if (format != ' ')
1374: {
1375: liberation(s_etat_processus, s_objet_argument);
1376: free(argument_majuscule);
1377:
1378: (*s_etat_processus).erreur_execution =
1379: d_ex_erreur_parametre_fichier;
1380: return;
1381: }
1382:
1383: format = 'N';
1384: }
1385: else if (strcmp(argument_majuscule, "UNFORMATTED") == 0)
1386: {
1387: if (format != ' ')
1388: {
1389: liberation(s_etat_processus, s_objet_argument);
1390: free(argument_majuscule);
1391:
1392: (*s_etat_processus).erreur_execution =
1393: d_ex_erreur_parametre_fichier;
1394: return;
1395: }
1396:
1397: format = 'Y';
1398: }
1399: else if (strcmp(argument_majuscule, "FLOW") == 0)
1400: {
1401: if (format != ' ')
1402: {
1403: liberation(s_etat_processus, s_objet_argument);
1404: free(argument_majuscule);
1405:
1406: (*s_etat_processus).erreur_execution =
1407: d_ex_erreur_parametre_fichier;
1408: return;
1409: }
1410:
1411: format = 'F';
1412: }
1413: else if (strcmp(argument_majuscule, "STREAM") == 0)
1414: {
1415: if (type_socket != ' ')
1416: {
1417: liberation(s_etat_processus, s_objet_argument);
1418: free(argument_majuscule);
1419:
1420: (*s_etat_processus).erreur_execution =
1421: d_ex_erreur_parametre_fichier;
1422: return;
1423: }
1424:
1425: if (type_arguments == ' ')
1426: {
1427: type_arguments = 'S';
1428: }
1429: else if (type_arguments == 'F')
1430: {
1431: liberation(s_etat_processus, s_objet_argument);
1432: free(argument_majuscule);
1433:
1434: (*s_etat_processus).erreur_execution =
1435: d_ex_erreur_parametre_fichier;
1436: return;
1437: }
1438:
1439: type_socket = 'S';
1440: }
1441: else if (strcmp(argument_majuscule, "DATAGRAM") == 0)
1442: {
1443: if (type_socket != ' ')
1444: {
1445: liberation(s_etat_processus, s_objet_argument);
1446: free(argument_majuscule);
1447:
1448: (*s_etat_processus).erreur_execution =
1449: d_ex_erreur_parametre_fichier;
1450: return;
1451: }
1452:
1453: type_socket = 'D';
1454: }
1455: else if (strcmp(argument_majuscule, "SEQUENTIAL DATAGRAM") == 0)
1456: {
1457: if (type_socket != ' ')
1458: {
1459: liberation(s_etat_processus, s_objet_argument);
1460: free(argument_majuscule);
1461:
1462: (*s_etat_processus).erreur_execution =
1463: d_ex_erreur_parametre_fichier;
1464: return;
1465: }
1466:
1467: if (type_arguments == ' ')
1468: {
1469: type_arguments = 'S';
1470: }
1471: else if (type_arguments == 'F')
1472: {
1473: liberation(s_etat_processus, s_objet_argument);
1474: free(argument_majuscule);
1475:
1476: (*s_etat_processus).erreur_execution =
1477: d_ex_erreur_parametre_fichier;
1478: return;
1479: }
1480:
1481: type_socket = 'Q';
1482: }
1483: else if (strcmp(argument_majuscule, "RAW") == 0)
1484: {
1485: if (type_socket != ' ')
1486: {
1487: liberation(s_etat_processus, s_objet_argument);
1488: free(argument_majuscule);
1489:
1490: (*s_etat_processus).erreur_execution =
1491: d_ex_erreur_parametre_fichier;
1492: return;
1493: }
1494:
1495: if (type_arguments == ' ')
1496: {
1497: type_arguments = 'S';
1498: }
1499: else if (type_arguments == 'F')
1500: {
1501: liberation(s_etat_processus, s_objet_argument);
1502: free(argument_majuscule);
1503:
1504: (*s_etat_processus).erreur_execution =
1505: d_ex_erreur_parametre_fichier;
1506: return;
1507: }
1508:
1509: type_socket = 'R';
1510: }
1511: else if (strcmp(argument_majuscule, "ROBUST DATAGRAM") == 0)
1512: {
1513: if (type_socket != ' ')
1514: {
1515: liberation(s_etat_processus, s_objet_argument);
1516: free(argument_majuscule);
1517:
1518: (*s_etat_processus).erreur_execution =
1519: d_ex_erreur_parametre_fichier;
1520: return;
1521: }
1522:
1523: if (type_arguments == ' ')
1524: {
1525: type_arguments = 'S';
1526: }
1527: else if (type_arguments == 'F')
1528: {
1529: liberation(s_etat_processus, s_objet_argument);
1530: free(argument_majuscule);
1531:
1532: (*s_etat_processus).erreur_execution =
1533: d_ex_erreur_parametre_fichier;
1534: return;
1535: }
1536:
1537: type_socket = 'M';
1538: }
1539: else if (strcmp(argument_majuscule, "LOCAL") == 0)
1540: {
1541: if (type_domaine != ' ')
1542: {
1543: liberation(s_etat_processus, s_objet_argument);
1544: free(argument_majuscule);
1545:
1546: (*s_etat_processus).erreur_execution =
1547: d_ex_erreur_parametre_fichier;
1548: return;
1549: }
1550:
1551: if (type_arguments == ' ')
1552: {
1553: type_arguments = 'S';
1554: }
1555: else if (type_arguments == 'F')
1556: {
1557: liberation(s_etat_processus, s_objet_argument);
1558: free(argument_majuscule);
1559:
1560: (*s_etat_processus).erreur_execution =
1561: d_ex_erreur_parametre_fichier;
1562: return;
1563: }
1564:
1565: type_domaine = 'L';
1566: }
1567: else if (strcmp(argument_majuscule, "FOREIGN") == 0)
1568: {
1569: if (type_domaine != ' ')
1570: {
1571: liberation(s_etat_processus, s_objet_argument);
1572: free(argument_majuscule);
1573:
1574: (*s_etat_processus).erreur_execution =
1575: d_ex_erreur_parametre_fichier;
1576: return;
1577: }
1578:
1579: if (type_arguments == ' ')
1580: {
1581: type_arguments = 'S';
1582: }
1583: else if (type_arguments == 'F')
1584: {
1585: liberation(s_etat_processus, s_objet_argument);
1586: free(argument_majuscule);
1587:
1588: (*s_etat_processus).erreur_execution =
1589: d_ex_erreur_parametre_fichier;
1590: return;
1591: }
1592:
1593: type_domaine = 'F';
1594: }
1595: else if (strcmp(argument_majuscule, "IPV4") == 0)
1596: {
1597: if (strcmp(protocole, "") != 0)
1598: {
1599: liberation(s_etat_processus, s_objet_argument);
1600: free(argument_majuscule);
1601:
1602: (*s_etat_processus).erreur_execution =
1603: d_ex_erreur_parametre_fichier;
1604: return;
1605: }
1606:
1607: if (type_arguments == ' ')
1608: {
1609: type_arguments = 'S';
1610: }
1611: else if (type_arguments == 'F')
1612: {
1613: liberation(s_etat_processus, s_objet_argument);
1614: free(argument_majuscule);
1615:
1616: (*s_etat_processus).erreur_execution =
1617: d_ex_erreur_parametre_fichier;
1618: return;
1619: }
1620:
1621: strcpy(protocole, "IPV4");
1622: }
1623: else if (strcmp(argument_majuscule, "IPV6") == 0)
1624: {
1625: if (strcmp(protocole, "") != 0)
1626: {
1627: liberation(s_etat_processus, s_objet_argument);
1628: free(argument_majuscule);
1629:
1630: (*s_etat_processus).erreur_execution =
1631: d_ex_erreur_parametre_fichier;
1632: return;
1633: }
1634:
1635: if (type_arguments == ' ')
1636: {
1637: type_arguments = 'S';
1638: }
1639: else if (type_arguments == 'F')
1640: {
1641: liberation(s_etat_processus, s_objet_argument);
1642: free(argument_majuscule);
1643:
1644: (*s_etat_processus).erreur_execution =
1645: d_ex_erreur_parametre_fichier;
1646: return;
1647: }
1648:
1649: strcpy(protocole, "IPV6");
1650: }
1651: else if (strcmp(argument_majuscule, "UNIX") == 0)
1652: {
1653: if (strcmp(protocole, "") != 0)
1654: {
1655: liberation(s_etat_processus, s_objet_argument);
1656: free(argument_majuscule);
1657:
1658: (*s_etat_processus).erreur_execution =
1659: d_ex_erreur_parametre_fichier;
1660: return;
1661: }
1662:
1663: if (type_arguments == ' ')
1664: {
1665: type_arguments = 'S';
1666: }
1667: else if (type_arguments == 'F')
1668: {
1669: liberation(s_etat_processus, s_objet_argument);
1670: free(argument_majuscule);
1671:
1672: (*s_etat_processus).erreur_execution =
1673: d_ex_erreur_parametre_fichier;
1674: return;
1675: }
1676:
1677: strcpy(protocole, "UNIX");
1678: }
1679: else
1680: {
1681: liberation(s_etat_processus, s_objet_argument);
1682: free(argument_majuscule);
1683:
1684: (*s_etat_processus).erreur_execution =
1685: d_ex_erreur_parametre_fichier;
1686: return;
1687: }
1688:
1689: free(argument_majuscule);
1690: }
1691: else if ((*(*l_element_courant).donnee).type == LST)
1692: {
1693: l_element_courant_sous_objet =
1694: (*(*l_element_courant).donnee).objet;
1695:
1696: nombre_elements = 0;
1697: while(l_element_courant_sous_objet != NULL)
1698: {
1699: nombre_elements++;
1700: l_element_courant_sous_objet =
1701: (*l_element_courant_sous_objet).suivant;
1702: }
1703:
1704: l_element_courant_sous_objet =
1705: (*(*l_element_courant).donnee).objet;
1706:
1707: if (nombre_elements == 2)
1708: {
1709: if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
1710: {
1711: if ((argument_majuscule = conversion_majuscule(
1712: (unsigned char *)
1713: (*(*l_element_courant_sous_objet)
1714: .donnee).objet)) == NULL)
1715: {
1716: (*s_etat_processus).erreur_systeme =
1717: d_es_allocation_memoire;
1718: return;
1719: }
1720:
1721: l_element_courant_sous_objet =
1722: (*l_element_courant_sous_objet).suivant;
1723:
1724: if (strcmp(argument_majuscule, "NAME") == 0)
1725: {
1726: if ((*(*l_element_courant_sous_objet).donnee).type
1727: == CHN)
1728: {
1729: if (nom != NULL)
1730: {
1731: liberation(s_etat_processus,
1732: s_objet_argument);
1733: free(argument_majuscule);
1734:
1735: (*s_etat_processus).erreur_execution =
1736: d_ex_erreur_parametre_fichier;
1737: return;
1738: }
1739:
1740: nom = (unsigned char *)
1741: (*(*l_element_courant_sous_objet)
1742: .donnee).objet;
1743: }
1744: else
1745: {
1746: liberation(s_etat_processus, s_objet_argument);
1747: free(argument_majuscule);
1748:
1749: (*s_etat_processus).erreur_execution =
1750: d_ex_erreur_parametre_fichier;
1751: return;
1752: }
1753: }
1754: else if (strcmp(argument_majuscule, "OPTION") == 0)
1755: {
1756: if ((*(*l_element_courant_sous_objet).donnee).type
1757: == CHN)
1758: {
1759: if (type_arguments == ' ')
1760: {
1761: type_arguments = 'S';
1762: }
1763: else if (type_arguments == 'F')
1764: {
1765: liberation(s_etat_processus,
1766: s_objet_argument);
1767: free(argument_majuscule);
1768:
1769: (*s_etat_processus).erreur_execution =
1770: d_ex_erreur_parametre_fichier;
1771: return;
1772: }
1773: }
1774:
1775: free(argument_majuscule);
1776:
1777: if ((argument_majuscule = conversion_majuscule(
1778: (unsigned char *)
1779: (*(*l_element_courant_sous_objet)
1780: .donnee).objet)) == NULL)
1781: {
1782: (*s_etat_processus).erreur_systeme =
1783: d_es_allocation_memoire;
1784: return;
1785: }
1786:
1787: if (strcmp(argument_majuscule, "BROADCAST") == 0)
1788: {
1789: if (options[d_BROADCAST] == 'Y')
1790: {
1791: liberation(s_etat_processus,
1792: s_objet_argument);
1793: free(argument_majuscule);
1794:
1795: (*s_etat_processus).erreur_execution =
1796: d_ex_erreur_parametre_fichier;
1797: return;
1798: }
1799:
1800: options[d_BROADCAST] = 'Y';
1801: }
1802: else if (strcmp(argument_majuscule, "DO NOT ROUTE")
1803: == 0)
1804: {
1805: if (options[d_DONT_ROUTE] == 'Y')
1806: {
1807: liberation(s_etat_processus,
1808: s_objet_argument);
1809: free(argument_majuscule);
1810:
1811: (*s_etat_processus).erreur_execution =
1812: d_ex_erreur_parametre_fichier;
1813: return;
1814: }
1815:
1816: options[d_DONT_ROUTE] = 'Y';
1817: }
1818: else if (strcmp(argument_majuscule, "KEEP ALIVE")
1819: == 0)
1820: {
1821: if (options[d_KEEP_ALIVE] == 'Y')
1822: {
1823: liberation(s_etat_processus,
1824: s_objet_argument);
1825: free(argument_majuscule);
1826:
1827: (*s_etat_processus).erreur_execution =
1828: d_ex_erreur_parametre_fichier;
1829: return;
1830: }
1831:
1832: options[d_KEEP_ALIVE] = 'Y';
1833: }
1834: else if (strcmp(argument_majuscule, "REUSE ADDRESS")
1835: == 0)
1836: {
1837: if (options[d_REUSE_ADDRESS] == 'Y')
1838: {
1839: liberation(s_etat_processus,
1840: s_objet_argument);
1841: free(argument_majuscule);
1842:
1843: (*s_etat_processus).erreur_execution =
1844: d_ex_erreur_parametre_fichier;
1845: return;
1846: }
1847:
1848: options[d_REUSE_ADDRESS] = 'Y';
1849: }
1850: else
1851: {
1852: liberation(s_etat_processus,
1853: s_objet_argument);
1854: free(argument_majuscule);
1855:
1856: (*s_etat_processus).erreur_execution =
1857: d_ex_erreur_parametre_fichier;
1858: return;
1859: }
1860: }
1861: else if (strcmp(argument_majuscule, "HOST") == 0)
1862: {
1863: if ((*(*l_element_courant_sous_objet).donnee).type
1864: == CHN)
1865: {
1866: if (type_arguments == ' ')
1867: {
1868: type_arguments = 'S';
1869: }
1870: else if (type_arguments == 'F')
1871: {
1872: liberation(s_etat_processus,
1873: s_objet_argument);
1874: free(argument_majuscule);
1875:
1876: (*s_etat_processus).erreur_execution =
1877: d_ex_erreur_parametre_fichier;
1878: return;
1879: }
1880:
1881: if (hote != NULL)
1882: {
1883: liberation(s_etat_processus,
1884: s_objet_argument);
1885: free(argument_majuscule);
1886:
1887: (*s_etat_processus).erreur_execution =
1888: d_ex_erreur_parametre_fichier;
1889: return;
1890: }
1891:
1892: hote = (unsigned char *)
1893: (*(*l_element_courant_sous_objet)
1894: .donnee).objet;
1895: }
1896: else
1897: {
1898: liberation(s_etat_processus,
1899: s_objet_argument);
1900: free(argument_majuscule);
1901:
1902: (*s_etat_processus).erreur_execution =
1903: d_ex_erreur_parametre_fichier;
1904: return;
1905: }
1906: }
1907: else if (strcmp(argument_majuscule, "PROTOCOL") == 0)
1908: {
1909: if ((*(*l_element_courant_sous_objet).donnee).type
1910: == CHN)
1911: {
1912: if (type_arguments == ' ')
1913: {
1914: type_arguments = 'S';
1915: }
1916: else if (type_arguments == 'F')
1917: {
1918: liberation(s_etat_processus,
1919: s_objet_argument);
1920: free(argument_majuscule);
1921:
1922: (*s_etat_processus).erreur_execution =
1923: d_ex_erreur_parametre_fichier;
1924: return;
1925: }
1926:
1927: if (protocole_socket != NULL)
1928: {
1929: liberation(s_etat_processus,
1930: s_objet_argument);
1931: free(argument_majuscule);
1932:
1933: (*s_etat_processus).erreur_execution =
1934: d_ex_erreur_parametre_fichier;
1935: return;
1936: }
1937:
1938: protocole_socket = (unsigned char *)
1939: (*(*l_element_courant_sous_objet)
1940: .donnee).objet;
1941: }
1942: else
1943: {
1944: liberation(s_etat_processus, s_objet_argument);
1945: free(argument_majuscule);
1946:
1947: (*s_etat_processus).erreur_execution =
1948: d_ex_erreur_parametre_fichier;
1949: return;
1950: }
1951: }
1952: else if (strcmp(argument_majuscule, "KEY") == 0)
1953: {
1954: if ((*(*l_element_courant_sous_objet).donnee).type
1955: == INT)
1956: {
1957: if (type_arguments == ' ')
1958: {
1959: type_arguments = 'F';
1960: }
1961: else if (type_arguments == 'S')
1962: {
1963: liberation(s_etat_processus,
1964: s_objet_argument);
1965: free(argument_majuscule);
1966:
1967: (*s_etat_processus).erreur_execution =
1968: d_ex_erreur_parametre_fichier;
1969: return;
1970: }
1971:
1972: if (position_clef != 0)
1973: {
1974: liberation(s_etat_processus,
1975: s_objet_argument);
1976:
1977: (*s_etat_processus).erreur_execution =
1978: d_ex_erreur_parametre_fichier;
1979: return;
1980: }
1981: else
1982: {
1983: if ((position_clef = (*((integer8 *)
1984: (*(*l_element_courant_sous_objet)
1985: .donnee).objet))) <= 0)
1986: {
1987: liberation(s_etat_processus,
1988: s_objet_argument);
1989:
1990: (*s_etat_processus).erreur_execution =
1991: d_ex_erreur_parametre_fichier;
1992: return;
1993: }
1994: }
1995: }
1996: else
1997: {
1998: liberation(s_etat_processus, s_objet_argument);
1999: free(argument_majuscule);
2000:
2001: (*s_etat_processus).erreur_execution =
2002: d_ex_erreur_parametre_fichier;
2003: return;
2004: }
2005: }
2006: else if (strcmp(argument_majuscule, "PORT") == 0)
2007: {
2008: if ((*(*l_element_courant_sous_objet)
2009: .donnee).type == INT)
2010: {
2011: if (type_arguments == ' ')
2012: {
2013: type_arguments = 'S';
2014: }
2015: else if (type_arguments == 'F')
2016: {
2017: liberation(s_etat_processus,
2018: s_objet_argument);
2019: free(argument_majuscule);
2020:
2021: (*s_etat_processus).erreur_execution =
2022: d_ex_erreur_parametre_fichier;
2023: return;
2024: }
2025:
2026: if (presence_port == d_vrai)
2027: {
2028: liberation(s_etat_processus,
2029: s_objet_argument);
2030:
2031: (*s_etat_processus).erreur_execution =
2032: d_ex_erreur_parametre_fichier;
2033: return;
2034: }
2035: else
2036: {
2037: presence_port = d_vrai;
2038:
2039: if ((port = (*((integer8 *)
2040: (*(*l_element_courant_sous_objet)
2041: .donnee).objet))) < 0)
2042: {
2043: liberation(s_etat_processus,
2044: s_objet_argument);
2045:
2046: (*s_etat_processus).erreur_execution =
2047: d_ex_erreur_parametre_fichier;
2048: return;
2049: }
2050:
2051: if (port > 65535)
2052: {
2053: liberation(s_etat_processus,
2054: s_objet_argument);
2055:
2056: (*s_etat_processus).erreur_execution =
2057: d_ex_erreur_parametre_fichier;
2058: return;
2059: }
2060: }
2061: }
2062: else
2063: {
2064: liberation(s_etat_processus, s_objet_argument);
2065: free(argument_majuscule);
2066:
2067: (*s_etat_processus).erreur_execution =
2068: d_ex_erreur_parametre_fichier;
2069: return;
2070: }
2071: }
2072: else if (strcmp(argument_majuscule, "LISTEN") == 0)
2073: {
2074: if ((*(*l_element_courant_sous_objet).donnee).type
2075: == INT)
2076: {
2077: if (type_arguments == ' ')
2078: {
2079: type_arguments = 'S';
2080: }
2081: else if (type_arguments == 'F')
2082: {
2083: liberation(s_etat_processus,
2084: s_objet_argument);
2085: free(argument_majuscule);
2086:
2087: (*s_etat_processus).erreur_execution =
2088: d_ex_erreur_parametre_fichier;
2089: return;
2090: }
2091:
2092: if (nombre_maximal_connexions != 0)
2093: {
2094: liberation(s_etat_processus,
2095: s_objet_argument);
2096:
2097: (*s_etat_processus).erreur_execution =
2098: d_ex_erreur_parametre_fichier;
2099: return;
2100: }
2101: else
2102: {
2103: if ((nombre_maximal_connexions =
2104: (*((integer8 *)
2105: (*(*l_element_courant_sous_objet)
2106: .donnee).objet))) <= 0)
2107: {
2108: liberation(s_etat_processus,
2109: s_objet_argument);
2110:
2111: (*s_etat_processus).erreur_execution =
2112: d_ex_erreur_parametre_fichier;
2113: return;
2114: }
2115: }
2116: }
2117: }
2118: else if (strcmp(argument_majuscule, "ADDRESS") == 0)
2119: {
2120: if ((*(*l_element_courant_sous_objet)
2121: .donnee).type == VIN)
2122: {
2123: if (type_arguments == ' ')
2124: {
2125: type_arguments = 'S';
2126: }
2127: else if (type_arguments == 'F')
2128: {
2129: liberation(s_etat_processus,
2130: s_objet_argument);
2131: free(argument_majuscule);
2132:
2133: (*s_etat_processus).erreur_execution =
2134: d_ex_erreur_parametre_fichier;
2135: return;
2136: }
2137:
2138: if (type_adresse != ' ')
2139: {
2140: liberation(s_etat_processus,
2141: s_objet_argument);
2142:
2143: (*s_etat_processus).erreur_execution =
2144: d_ex_erreur_parametre_fichier;
2145: return;
2146: }
2147:
2148: if ((*((struct_vecteur *)
2149: (*(*l_element_courant_sous_objet)
2150: .donnee).objet)).taille == 4)
2151: { // Adresse IPv4
2152: type_adresse = '4';
2153:
2154: for(i = 0; i < 4; i++)
2155: {
2156: adresse[i] = ((integer8 *)
2157: (*((struct_vecteur *) (*
2158: (*l_element_courant_sous_objet)
2159: .donnee).objet)).tableau)[i];
2160:
2161: if ((adresse[i] < 0) || (adresse[i] >
2162: 255))
2163: {
2164: liberation(s_etat_processus,
2165: s_objet_argument);
2166:
2167: (*s_etat_processus).erreur_execution
2168: = d_ex_erreur_parametre_fichier;
2169: return;
2170: }
2171: }
2172: }
2173: else if ((*((struct_vecteur *)
2174: (*(*l_element_courant_sous_objet)
2175: .donnee).objet)).taille == 16)
2176: { // Adresse IPv6
2177: type_adresse = '6';
2178:
2179: for(i = 0; i < 16; i++)
2180: {
2181: adresse[i] = ((integer8 *)
2182: (*((struct_vecteur *) (*
2183: (*l_element_courant_sous_objet)
2184: .donnee).objet)).tableau)[i];
2185:
2186: if ((adresse[i] < 0) || (adresse[i] >
2187: 255))
2188: {
2189: liberation(s_etat_processus,
2190: s_objet_argument);
2191:
2192: (*s_etat_processus).erreur_execution
2193: = d_ex_erreur_parametre_fichier;
2194: return;
2195: }
2196: }
2197: }
2198: else
2199: { // Adresse non supportée
2200: liberation(s_etat_processus,
2201: s_objet_argument);
2202:
2203: (*s_etat_processus).erreur_execution =
2204: d_ex_erreur_parametre_fichier;
2205: return;
2206: }
2207: }
2208: }
2209: else
2210: {
2211: liberation(s_etat_processus, s_objet_argument);
2212: free(argument_majuscule);
2213:
2214: (*s_etat_processus).erreur_execution =
2215: d_ex_erreur_parametre_fichier;
2216: return;
2217: }
2218:
2219: free(argument_majuscule);
2220: }
2221: else
2222: {
2223: liberation(s_etat_processus, s_objet_argument);
2224: (*s_etat_processus).erreur_execution =
2225: d_ex_erreur_parametre_fichier;
2226:
2227: return;
2228: }
2229: }
2230: else if (nombre_elements == 3)
2231: {
2232: if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
2233: {
2234: if ((argument_majuscule = conversion_majuscule(
2235: (unsigned char *)
2236: (*(*l_element_courant_sous_objet)
2237: .donnee).objet)) == NULL)
2238: {
2239: (*s_etat_processus).erreur_systeme =
2240: d_es_allocation_memoire;
2241: return;
2242: }
2243:
2244: if (strcmp(argument_majuscule, "OPTION") == 0)
2245: {
2246: if (type_arguments == ' ')
2247: {
2248: type_arguments = 'S';
2249: }
2250: else if (type_arguments == 'F')
2251: {
2252: liberation(s_etat_processus, s_objet_argument);
2253: free(argument_majuscule);
2254:
2255: (*s_etat_processus).erreur_execution =
2256: d_ex_erreur_parametre_fichier;
2257: return;
2258: }
2259:
2260: free(argument_majuscule);
2261:
2262: l_element_courant_sous_objet =
2263: (*l_element_courant_sous_objet).suivant;
2264:
2265: if ((*(*l_element_courant_sous_objet)
2266: .donnee).type != CHN)
2267: {
2268: liberation(s_etat_processus, s_objet_argument);
2269:
2270: (*s_etat_processus).erreur_execution =
2271: d_ex_erreur_parametre_fichier;
2272: return;
2273: }
2274:
2275: if ((argument_majuscule = conversion_majuscule(
2276: (unsigned char *)
2277: (*(*l_element_courant_sous_objet)
2278: .donnee).objet)) == NULL)
2279: {
2280: (*s_etat_processus).erreur_systeme =
2281: d_es_allocation_memoire;
2282: return;
2283: }
2284:
2285: l_element_courant_sous_objet =
2286: (*l_element_courant_sous_objet).suivant;
2287:
2288: if (strcmp(argument_majuscule, "BIND TO DEVICE")
2289: == 0)
2290: {
2291: if ((*(*l_element_courant_sous_objet)
2292: .donnee).type != CHN)
2293: {
2294: liberation(s_etat_processus,
2295: s_objet_argument);
2296: free(argument_majuscule);
2297:
2298: (*s_etat_processus).erreur_execution =
2299: d_ex_erreur_parametre_fichier;
2300: return;
2301: }
2302:
2303: if (options[d_BIND_TO_DEVICE] == 'Y')
2304: {
2305: liberation(s_etat_processus,
2306: s_objet_argument);
2307: free(argument_majuscule);
2308:
2309: (*s_etat_processus).erreur_execution =
2310: d_ex_erreur_parametre_fichier;
2311: return;
2312: }
2313:
2314: options[d_BIND_TO_DEVICE] = 'Y';
2315:
2316: peripherique = (unsigned char *)
2317: (*(*l_element_courant_sous_objet)
2318: .donnee).objet;
2319: }
2320: else if (strcmp(argument_majuscule, "PRIORITY")
2321: == 0)
2322: {
2323: if ((*(*l_element_courant_sous_objet)
2324: .donnee).type != INT)
2325: {
2326: liberation(s_etat_processus,
2327: s_objet_argument);
2328: free(argument_majuscule);
2329:
2330: (*s_etat_processus).erreur_execution =
2331: d_ex_erreur_parametre_fichier;
2332: return;
2333: }
2334:
2335: if (options[d_PRIORITY] == 'Y')
2336: {
2337: liberation(s_etat_processus,
2338: s_objet_argument);
2339: free(argument_majuscule);
2340:
2341: (*s_etat_processus).erreur_execution =
2342: d_ex_erreur_parametre_fichier;
2343: return;
2344: }
2345:
2346: options[d_PRIORITY] = 'Y';
2347:
2348: priorite = (int) (*((integer8 *)
2349: (*(*l_element_courant_sous_objet)
2350: .donnee).objet));
2351: }
2352: else if (strcmp(argument_majuscule,
2353: "RECEIVE BUFFER") == 0)
2354: {
2355: if ((*(*l_element_courant_sous_objet)
2356: .donnee).type != INT)
2357: {
2358: liberation(s_etat_processus,
2359: s_objet_argument);
2360: free(argument_majuscule);
2361:
2362: (*s_etat_processus).erreur_execution =
2363: d_ex_erreur_parametre_fichier;
2364: return;
2365: }
2366:
2367: if ((options[d_RECEIVE_BUFFER] == 'Y') ||
2368: (options[d_FORCE_RECEIVE_BUFFER]
2369: == 'Y'))
2370: {
2371: liberation(s_etat_processus,
2372: s_objet_argument);
2373: free(argument_majuscule);
2374:
2375: (*s_etat_processus).erreur_execution =
2376: d_ex_erreur_parametre_fichier;
2377: return;
2378: }
2379:
2380: options[d_RECEIVE_BUFFER] = 'Y';
2381:
2382: buffer_reception = (int) (*((integer8 *)
2383: (*(*l_element_courant_sous_objet)
2384: .donnee).objet));
2385: }
2386: else if (strcmp(argument_majuscule,
2387: "FORCE RECEIVE BUFFER") == 0)
2388: {
2389: if ((*(*l_element_courant_sous_objet)
2390: .donnee).type != INT)
2391: {
2392: liberation(s_etat_processus,
2393: s_objet_argument);
2394: free(argument_majuscule);
2395:
2396: (*s_etat_processus).erreur_execution =
2397: d_ex_erreur_parametre_fichier;
2398: return;
2399: }
2400:
2401: if ((options[d_RECEIVE_BUFFER] == 'Y') ||
2402: (options[d_FORCE_RECEIVE_BUFFER]
2403: == 'Y'))
2404: {
2405: liberation(s_etat_processus,
2406: s_objet_argument);
2407: free(argument_majuscule);
2408:
2409: (*s_etat_processus).erreur_execution =
2410: d_ex_erreur_parametre_fichier;
2411: return;
2412: }
2413:
2414: options[d_FORCE_RECEIVE_BUFFER] = 'Y';
2415:
2416: buffer_reception = (int) (*((integer8 *)
2417: (*(*l_element_courant_sous_objet)
2418: .donnee).objet));
2419: }
2420: else if (strcmp(argument_majuscule,
2421: "SEND BUFFER") == 0)
2422: {
2423: if ((*(*l_element_courant_sous_objet)
2424: .donnee).type != INT)
2425: {
2426: liberation(s_etat_processus,
2427: s_objet_argument);
2428: free(argument_majuscule);
2429:
2430: (*s_etat_processus).erreur_execution =
2431: d_ex_erreur_parametre_fichier;
2432: return;
2433: }
2434:
2435: if ((options[d_SEND_BUFFER] == 'Y') ||
2436: (options[d_FORCE_SEND_BUFFER] == 'Y'))
2437: {
2438: liberation(s_etat_processus,
2439: s_objet_argument);
2440: free(argument_majuscule);
2441:
2442: (*s_etat_processus).erreur_execution =
2443: d_ex_erreur_parametre_fichier;
2444: return;
2445: }
2446:
2447: options[d_SEND_BUFFER] = 'Y';
2448:
2449: buffer_emission = (int) (*((integer8 *)
2450: (*(*l_element_courant_sous_objet)
2451: .donnee).objet));
2452: }
2453: else if (strcmp(argument_majuscule,
2454: "FORCE SEND BUFFER") == 0)
2455: {
2456: if ((*(*l_element_courant_sous_objet)
2457: .donnee).type != INT)
2458: {
2459: liberation(s_etat_processus,
2460: s_objet_argument);
2461: free(argument_majuscule);
2462:
2463: (*s_etat_processus).erreur_execution =
2464: d_ex_erreur_parametre_fichier;
2465: return;
2466: }
2467:
2468: if ((options[d_SEND_BUFFER] == 'Y') ||
2469: (options[d_FORCE_SEND_BUFFER] == 'Y'))
2470: {
2471: liberation(s_etat_processus,
2472: s_objet_argument);
2473: free(argument_majuscule);
2474:
2475: (*s_etat_processus).erreur_execution =
2476: d_ex_erreur_parametre_fichier;
2477: return;
2478: }
2479:
2480: options[d_FORCE_SEND_BUFFER] = 'Y';
2481:
2482: buffer_emission = (int) (*((integer8 *)
2483: (*(*l_element_courant_sous_objet)
2484: .donnee).objet));
2485: }
2486: else if (strcmp(argument_majuscule,
2487: "RECEIVING TIMEOUT") == 0)
2488: {
2489: if ((*(*l_element_courant_sous_objet)
2490: .donnee).type != INT)
2491: {
2492: liberation(s_etat_processus,
2493: s_objet_argument);
2494: free(argument_majuscule);
2495:
2496: (*s_etat_processus).erreur_execution =
2497: d_ex_erreur_parametre_fichier;
2498: return;
2499: }
2500:
2501: if (options[d_RECEIVING_TIMEOUT] == 'Y')
2502: {
2503: liberation(s_etat_processus,
2504: s_objet_argument);
2505: free(argument_majuscule);
2506:
2507: (*s_etat_processus).erreur_execution =
2508: d_ex_erreur_parametre_fichier;
2509: return;
2510: }
2511:
2512: options[d_RECEIVING_TIMEOUT] = 'Y';
2513:
2514: timeout_reception = (int) (*((integer8 *)
2515: (*(*l_element_courant_sous_objet)
2516: .donnee).objet));
2517: }
2518: else if (strcmp(argument_majuscule,
2519: "SENDING TIMEOUT") == 0)
2520: {
2521: if ((*(*l_element_courant_sous_objet)
2522: .donnee).type != INT)
2523: {
2524: liberation(s_etat_processus,
2525: s_objet_argument);
2526: free(argument_majuscule);
2527:
2528: (*s_etat_processus).erreur_execution =
2529: d_ex_erreur_parametre_fichier;
2530: return;
2531: }
2532:
2533: if (options[d_SENDING_TIMEOUT] == 'Y')
2534: {
2535: liberation(s_etat_processus,
2536: s_objet_argument);
2537: free(argument_majuscule);
2538:
2539: (*s_etat_processus).erreur_execution =
2540: d_ex_erreur_parametre_fichier;
2541: return;
2542: }
2543:
2544: options[d_SENDING_TIMEOUT] = 'Y';
2545:
2546: timeout_emission = (int) (*((integer8 *)
2547: (*(*l_element_courant_sous_objet)
2548: .donnee).objet));
2549: }
2550: else
2551: {
2552: liberation(s_etat_processus, s_objet_argument);
2553: free(argument_majuscule);
2554:
2555: (*s_etat_processus).erreur_execution =
2556: d_ex_erreur_parametre_fichier;
2557: return;
2558: }
2559:
2560: free(argument_majuscule);
2561: }
2562: else
2563: {
2564: liberation(s_etat_processus, s_objet_argument);
2565: free(argument_majuscule);
2566:
2567: (*s_etat_processus).erreur_execution =
2568: d_ex_erreur_parametre_fichier;
2569: return;
2570: }
2571: }
2572: else
2573: {
2574: liberation(s_etat_processus, s_objet_argument);
2575: (*s_etat_processus).erreur_execution =
2576: d_ex_erreur_parametre_fichier;
2577:
2578: return;
2579: }
2580: }
2581: else
2582: {
2583: liberation(s_etat_processus, s_objet_argument);
2584: (*s_etat_processus).erreur_execution =
2585: d_ex_erreur_parametre_fichier;
2586:
2587: return;
2588: }
2589: }
2590: else
2591: {
2592: liberation(s_etat_processus, s_objet_argument);
2593:
2594: (*s_etat_processus).erreur_execution =
2595: d_ex_erreur_parametre_fichier;
2596: return;
2597: }
2598:
2599: l_element_courant = (*l_element_courant).suivant;
2600: }
2601:
2602: if (type_arguments == 'F')
2603: {
2604: /*
2605: * Traitement des fichiers
2606: */
2607:
2608: /*
2609: * Vérification de la cohérence et comportement par défaut
2610: */
2611:
2612: if (type_ouverture == ' ')
2613: {
2614: type_ouverture = 'U';
2615: }
2616:
2617: if (type_acces == ' ')
2618: {
2619: type_acces = 'S';
2620: }
2621:
2622: if (format == ' ')
2623: {
2624: format = 'N';
2625: }
2626:
2627: if (protection == ' ')
2628: {
2629: protection = 'N';
2630: }
2631:
2632: if ((type_ouverture == 'S') && (protection != 'N'))
2633: {
2634: liberation(s_etat_processus, s_objet_argument);
2635:
2636: (*s_etat_processus).erreur_execution =
2637: d_ex_erreur_parametre_fichier;
2638: return;
2639: }
2640:
2641: if ((type_ouverture != 'S') && (nom == NULL))
2642: {
2643: liberation(s_etat_processus, s_objet_argument);
2644:
2645: (*s_etat_processus).erreur_execution =
2646: d_ex_erreur_parametre_fichier;
2647: return;
2648: }
2649:
2650: if (((type_acces != 'I') && (position_clef != 0)) ||
2651: ((type_acces == 'I') && (position_clef == 0)))
2652: {
2653: liberation(s_etat_processus, s_objet_argument);
2654:
2655: (*s_etat_processus).erreur_execution =
2656: d_ex_erreur_parametre_fichier;
2657: return;
2658: }
2659:
2660: if ((s_objet_resultat = allocation(s_etat_processus, FCH))
2661: == NULL)
2662: {
2663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2664: return;
2665: }
2666:
2667: if (nom == NULL)
2668: {
2669: if ((nom_temporaire = creation_nom_fichier(s_etat_processus,
2670: (*s_etat_processus).chemin_fichiers_temporaires))
2671: == NULL)
2672: {
2673: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2674: return;
2675: }
2676:
2677: if ((nom = malloc((strlen(nom_temporaire)
2678: + 5) * sizeof(unsigned char))) == NULL)
2679: {
2680: (*s_etat_processus).erreur_systeme =
2681: d_es_allocation_memoire;
2682: return;
2683: }
2684:
2685: sprintf(nom, "%s.rpl", nom_temporaire);
2686: free(nom_temporaire);
2687:
2688: autorisation_liberation_nom = d_vrai;
2689: }
2690: else
2691: {
2692: autorisation_liberation_nom = d_faux;
2693: }
2694:
2695: /*
2696: * Ouverture du fichier
2697: */
2698:
2699: (*((struct_fichier *) (*s_objet_resultat).objet))
2700: .nom = NULL;
2701: (*((struct_fichier *) (*s_objet_resultat).objet))
2702: .acces = type_acces;
2703: (*((struct_fichier *) (*s_objet_resultat).objet))
2704: .binaire = format;
2705: (*((struct_fichier *) (*s_objet_resultat).objet))
2706: .ouverture = type_ouverture;
2707: (*((struct_fichier *) (*s_objet_resultat).objet)).pid
2708: = getpid();
2709: (*((struct_fichier *) (*s_objet_resultat).objet)).tid
2710: = pthread_self();
2711:
2712: if (((*((struct_fichier *) (*s_objet_resultat).objet)).format =
2713: allocation(s_etat_processus, LST)) == NULL)
2714: {
2715: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2716: return;
2717: }
2718:
2719: (*(*((struct_fichier *) (*s_objet_resultat).objet))
2720: .format).objet = NULL;
2721:
2722: switch(type_ouverture)
2723: {
2724: case 'N' :
2725: {
2726: erreur = caracteristiques_fichier(s_etat_processus,
2727: nom, &existence, &ouverture, &unite);
2728:
2729: if ((erreur != 0) || (unite != 0))
2730: {
2731: liberation(s_etat_processus, s_objet_argument);
2732: liberation(s_etat_processus, s_objet_resultat);
2733:
2734: (*s_etat_processus).erreur_execution =
2735: d_ex_erreur_acces_fichier;
2736: return;
2737: }
2738:
2739: if ((descripteur = fopen(nom, "w+")) == NULL)
2740: {
2741: liberation(s_etat_processus, s_objet_argument);
2742: liberation(s_etat_processus, s_objet_resultat);
2743:
2744: (*s_etat_processus).erreur_execution =
2745: d_ex_erreur_acces_fichier;
2746: return;
2747: }
2748:
2749: break;
2750: }
2751:
2752: case 'O' :
2753: {
2754: erreur = caracteristiques_fichier(s_etat_processus,
2755: nom, &existence, &ouverture, &unite);
2756:
2757: if ((erreur != d_absence_erreur) || (existence == d_faux))
2758: {
2759: liberation(s_etat_processus, s_objet_argument);
2760: liberation(s_etat_processus, s_objet_resultat);
2761:
2762: (*s_etat_processus).erreur_execution =
2763: d_ex_erreur_acces_fichier;
2764: return;
2765: }
2766:
2767: if ((descripteur = fopen(nom, "r+")) == NULL)
2768: {
2769: liberation(s_etat_processus, s_objet_argument);
2770: liberation(s_etat_processus, s_objet_resultat);
2771:
2772: (*s_etat_processus).erreur_execution =
2773: d_ex_erreur_acces_fichier;
2774: return;
2775: }
2776:
2777: break;
2778: }
2779:
2780: case 'R' :
2781: {
2782: erreur = caracteristiques_fichier(s_etat_processus,
2783: nom, &existence, &ouverture, &unite);
2784:
2785: if ((erreur != d_absence_erreur) || (existence == d_faux))
2786: {
2787: liberation(s_etat_processus, s_objet_argument);
2788: liberation(s_etat_processus, s_objet_resultat);
2789:
2790: (*s_etat_processus).erreur_execution =
2791: d_ex_erreur_acces_fichier;
2792: return;
2793: }
2794:
2795: /* Test du verrou */
2796:
2797: if ((descripteur = fopen(nom, "r")) == NULL)
2798: {
2799: liberation(s_etat_processus, s_objet_argument);
2800: liberation(s_etat_processus, s_objet_resultat);
2801:
2802: (*s_etat_processus).erreur_execution =
2803: d_ex_erreur_acces_fichier;
2804: return;
2805: }
2806:
2807: lock.l_type = F_WRLCK;
2808: lock.l_whence = SEEK_SET;
2809: lock.l_start = 0;
2810: lock.l_len = 0;
2811: lock.l_pid = getpid();
2812:
2813: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
2814: {
2815: if (fclose(descripteur) != 0)
2816: {
2817: liberation(s_etat_processus, s_objet_resultat);
2818:
2819: (*s_etat_processus).erreur_systeme =
2820: d_es_erreur_fichier;
2821: return;
2822: }
2823:
2824: liberation(s_etat_processus, s_objet_resultat);
2825:
2826: (*s_etat_processus).erreur_systeme =
2827: d_es_erreur_fichier;
2828: return;
2829: }
2830:
2831: if (fclose(descripteur) != 0)
2832: {
2833: liberation(s_etat_processus, s_objet_resultat);
2834:
2835: (*s_etat_processus).erreur_systeme =
2836: d_es_erreur_fichier;
2837: return;
2838: }
2839:
2840: if ((descripteur = fopen(nom, "w+")) == NULL)
2841: {
2842: liberation(s_etat_processus, s_objet_argument);
2843: liberation(s_etat_processus, s_objet_resultat);
2844:
2845: (*s_etat_processus).erreur_execution =
2846: d_ex_erreur_acces_fichier;
2847: return;
2848: }
2849:
2850: break;
2851: }
2852:
2853: case 'U' :
2854: {
2855: erreur = caracteristiques_fichier(s_etat_processus,
2856: nom, &existence, &ouverture, &unite);
2857:
2858: if (erreur == d_erreur)
2859: {
2860: liberation(s_etat_processus, s_objet_argument);
2861: liberation(s_etat_processus, s_objet_resultat);
2862:
2863: (*s_etat_processus).erreur_execution =
2864: d_ex_erreur_acces_fichier;
2865: return;
2866: }
2867:
2868: if (existence == d_faux)
2869: {
2870: if ((descripteur = fopen(nom, "w+")) == NULL)
2871: {
2872: liberation(s_etat_processus, s_objet_argument);
2873: liberation(s_etat_processus, s_objet_resultat);
2874:
2875: (*s_etat_processus).erreur_execution =
2876: d_ex_erreur_acces_fichier;
2877: return;
2878: }
2879: }
2880: else
2881: {
2882: if ((descripteur = fopen(nom, "r+")) == NULL)
2883: {
2884: liberation(s_etat_processus, s_objet_argument);
2885: liberation(s_etat_processus, s_objet_resultat);
2886:
2887: (*s_etat_processus).erreur_execution =
2888: d_ex_erreur_acces_fichier;
2889: return;
2890: }
2891: }
2892:
2893: break;
2894: }
2895:
2896: case 'S' :
2897: {
2898: erreur = caracteristiques_fichier(s_etat_processus,
2899: nom, &existence, &ouverture, &unite);
2900:
2901: if ((erreur != d_absence_erreur) || (existence != d_faux))
2902: {
2903: liberation(s_etat_processus, s_objet_argument);
2904: liberation(s_etat_processus, s_objet_resultat);
2905:
2906: (*s_etat_processus).erreur_execution =
2907: d_ex_erreur_acces_fichier;
2908: return;
2909: }
2910:
2911: if ((descripteur = fopen(nom, "w+")) == NULL)
2912: {
2913: liberation(s_etat_processus, s_objet_argument);
2914: liberation(s_etat_processus, s_objet_resultat);
2915:
2916: (*s_etat_processus).erreur_execution =
2917: d_ex_erreur_acces_fichier;
2918: return;
2919: }
2920:
2921: break;
2922: }
2923:
2924: default:
2925: {
2926: BUG(1, printf("type_ouverture=%c\n", type_ouverture));
2927: return;
2928: }
2929: }
2930:
2931: if (((*((struct_fichier *) (*s_objet_resultat).objet)).nom =
2932: malloc((strlen(nom) + 1) *
2933: sizeof(unsigned char))) == NULL)
2934: {
2935: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2936: return;
2937: }
2938:
2939: strcpy((*((struct_fichier *) (*s_objet_resultat).objet)).nom, nom);
2940: liberation(s_etat_processus, s_objet_argument);
2941:
2942: (*((struct_fichier *) (*s_objet_resultat).objet)).protection =
2943: protection;
2944: (*((struct_fichier *) (*s_objet_resultat).objet)).position_clef =
2945: position_clef;
2946:
2947: if (autorisation_liberation_nom == d_vrai)
2948: {
2949: free(nom);
2950: }
2951:
2952: rewind(descripteur);
2953:
2954: lock.l_type = F_WRLCK;
2955: lock.l_whence = SEEK_SET;
2956: lock.l_start = 0;
2957: lock.l_len = 0;
2958: lock.l_pid = getpid();
2959:
2960: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
2961: {
2962: if (fclose(descripteur) != 0)
2963: {
2964: liberation(s_etat_processus, s_objet_resultat);
2965:
2966: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2967: return;
2968: }
2969:
2970: liberation(s_etat_processus, s_objet_resultat);
2971:
2972: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2973: return;
2974: }
2975:
2976: if (lock.l_type == F_UNLCK)
2977: {
2978: /*
2979: * Positionnement d'un verrou exclusif d'écriture par défaut
2980: */
2981:
2982: lock.l_type = F_RDLCK;
2983: lock.l_whence = SEEK_SET;
2984: lock.l_start = 0;
2985: lock.l_len = 0;
2986: lock.l_pid = getpid();
2987:
2988: if (fcntl(fileno(descripteur), F_SETLK, &lock) == -1)
2989: {
2990: if (fclose(descripteur) != 0)
2991: {
2992: liberation(s_etat_processus, s_objet_resultat);
2993:
2994: (*s_etat_processus).erreur_systeme =
2995: d_es_erreur_fichier;
2996: return;
2997: }
2998:
2999: liberation(s_etat_processus, s_objet_resultat);
3000:
3001: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
3002: return;
3003: }
3004: }
3005: else
3006: {
3007: /*
3008: * Test de la cohérence du verrou avec l'option PROTECTION
3009: */
3010:
3011: if ((lock.l_type == F_RDLCK) && (protection != 'R'))
3012: {
3013: if (fclose(descripteur) != 0)
3014: {
3015: liberation(s_etat_processus, s_objet_resultat);
3016:
3017: (*s_etat_processus).erreur_systeme =
3018: d_es_erreur_fichier;
3019: return;
3020: }
3021:
3022: liberation(s_etat_processus, s_objet_resultat);
3023:
3024: (*s_etat_processus).erreur_execution =
3025: d_ex_fichier_verrouille;
3026: return;
3027: }
3028: else if ((lock.l_type == F_WRLCK) && (protection != 'W'))
3029: {
3030: if (fclose(descripteur) != 0)
3031: {
3032: liberation(s_etat_processus, s_objet_resultat);
3033:
3034: (*s_etat_processus).erreur_systeme =
3035: d_es_erreur_fichier;
3036: return;
3037: }
3038:
3039: liberation(s_etat_processus, s_objet_resultat);
3040:
3041: (*s_etat_processus).erreur_execution =
3042: d_ex_fichier_verrouille;
3043: return;
3044: }
3045: else
3046: {
3047: liberation(s_etat_processus, s_objet_resultat);
3048:
3049: (*s_etat_processus).erreur_execution =
3050: d_ex_fichier_verrouille;
3051: return;
3052: }
3053: }
3054:
3055: /*
3056: * Gestion de la liste des fichiers ouverts
3057: */
3058:
3059: l_element_courant = (*s_etat_processus).s_fichiers;
3060:
3061: if (l_element_courant == NULL)
3062: {
3063: if (((*s_etat_processus).s_fichiers = malloc(sizeof(
3064: struct_liste_chainee))) == NULL)
3065: {
3066: (*s_etat_processus).erreur_systeme =
3067: d_es_allocation_memoire;
3068: return;
3069: }
3070:
3071: (*(*s_etat_processus).s_fichiers).suivant = NULL;
3072:
3073: if (((*(*s_etat_processus).s_fichiers).donnee =
3074: malloc(sizeof(struct_descripteur_fichier))) == NULL)
3075: {
3076: (*s_etat_processus).erreur_systeme =
3077: d_es_allocation_memoire;
3078: return;
3079: }
3080:
3081: l_element_courant = (*s_etat_processus).s_fichiers;
3082: prochain_descripteur = 0;
3083: }
3084: else
3085: {
3086: /*
3087: * Recherche du premier descripteur libre
3088: */
3089:
3090: if ((chaine_descripteurs = malloc(
3091: ds_nombre_maximum_fichiers_ouverts + 1)) == NULL)
3092: {
3093: (*s_etat_processus).erreur_systeme =
3094: d_es_allocation_memoire;
3095: return;
3096: }
3097:
3098: for(pointeur = chaine_descripteurs, i = 0;
3099: i < ds_nombre_maximum_fichiers_ouverts;
3100: (*pointeur) = d_code_espace, pointeur++, i++);
3101: (*pointeur) = d_code_fin_chaine;
3102:
3103: do
3104: {
3105: chaine_descripteurs[(*((struct_descripteur_fichier *)
3106: (*l_element_courant).donnee)).identifiant] = '-';
3107: l_element_courant = (*l_element_courant).suivant;
3108: } while(l_element_courant != NULL);
3109:
3110: i = 0;
3111: pointeur = chaine_descripteurs;
3112:
3113: while(i < ds_nombre_maximum_fichiers_ouverts)
3114: {
3115: if ((*pointeur) == ' ')
3116: {
3117: break;
3118: }
3119:
3120: pointeur++;
3121: i++;
3122: }
3123:
3124: free(chaine_descripteurs);
3125:
3126: if (i == ds_nombre_maximum_fichiers_ouverts)
3127: {
3128: (*s_etat_processus).erreur_systeme =
3129: d_es_nombre_max_descripteurs;
3130: return;
3131: }
3132:
3133: prochain_descripteur = i;
3134:
3135: /*
3136: * Ajout d'un élément à la fin de la liste chaînée
3137: */
3138:
3139: l_element_courant = (*s_etat_processus).s_fichiers;
3140: while((*l_element_courant).suivant != NULL)
3141: {
3142: l_element_courant = (*l_element_courant).suivant;
3143: }
3144:
3145: if (((*l_element_courant).suivant =
3146: allocation_maillon(s_etat_processus)) == NULL)
3147: {
3148: (*s_etat_processus).erreur_systeme =
3149: d_es_allocation_memoire;
3150: return;
3151: }
3152:
3153: l_element_courant = (*l_element_courant).suivant;
3154: (*l_element_courant).suivant = NULL;
3155:
3156: if (((*l_element_courant).donnee =
3157: malloc(sizeof(struct_descripteur_fichier))) == NULL)
3158: {
3159: (*s_etat_processus).erreur_systeme =
3160: d_es_allocation_memoire;
3161: return;
3162: }
3163: }
3164:
3165: (*((struct_fichier *) (*s_objet_resultat).objet)).descripteur
3166: = prochain_descripteur;
3167: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3168: .identifiant = prochain_descripteur;
3169: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3170: .descripteur = descripteur;
3171: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3172: .pid = getpid();
3173: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3174: .tid = pthread_self();
3175: (*((struct_descripteur_fichier *) (*l_element_courant).donnee))
3176: .effacement = (type_ouverture == 'S') ? 'Y' : 'N';
3177:
3178: if (((*((struct_descripteur_fichier *) (*l_element_courant)
3179: .donnee)).nom = malloc((strlen((*((struct_fichier *)
3180: (*s_objet_resultat).objet)).nom) + 1) *
3181: sizeof(unsigned char))) == NULL)
3182: {
3183: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3184: return;
3185: }
3186:
3187: strcpy((*((struct_descripteur_fichier *) (*l_element_courant)
3188: .donnee)).nom, (*((struct_fichier *) (*s_objet_resultat)
3189: .objet)).nom);
3190:
3191: }
3192: else if (type_arguments == 'S')
3193: {
3194: /*
3195: * Traitement des sockets
3196: */
3197:
3198:
3199: inline logical1 options_socket()
3200: {
3201: /*
3202: * Options des sockets
3203: */
3204:
3205: # define WARNING(message) \
3206: if ((*s_etat_processus).langue != 'F') \
3207: printf("+++Warning : %s unavailable on host system\n", \
3208: message); \
3209: else \
3210: printf("+++Attention : %s non disponible sur le système " \
3211: "hôte\n", message)
3212:
3213: if (options[d_BIND_TO_DEVICE] == 'Y')
3214: {
3215: # ifdef SO_BINDTODEVICE
3216: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3217: .objet)).socket, SOL_SOCKET, SO_BINDTODEVICE,
3218: peripherique, strlen(peripherique)) != 0)
3219: {
3220: liberation(s_etat_processus, s_objet_argument);
3221: liberation(s_etat_processus, s_objet_resultat);
3222:
3223: (*s_etat_processus).erreur_execution =
3224: d_ex_erreur_parametre_fichier;
3225: return(d_erreur);
3226: }
3227: # else
3228: WARNING("BIND TO DEVICE");
3229: # endif
3230: }
3231:
3232: if (options[d_BROADCAST] == 'Y')
3233: {
3234: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3235: .objet)).socket, SOL_SOCKET, SO_BROADCAST,
3236: &drapeau, sizeof(drapeau)) != 0)
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_parametre_fichier;
3243: return(d_erreur);
3244: }
3245: }
3246:
3247: if (options[d_DONT_ROUTE] == 'Y')
3248: {
3249: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3250: .objet)).socket, SOL_SOCKET, SO_DONTROUTE,
3251: &drapeau, sizeof(drapeau)) != 0)
3252: {
3253: liberation(s_etat_processus, s_objet_argument);
3254: liberation(s_etat_processus, s_objet_resultat);
3255:
3256: (*s_etat_processus).erreur_execution =
3257: d_ex_erreur_parametre_fichier;
3258: return(d_erreur);
3259: }
3260: }
3261:
3262: if (options[d_KEEP_ALIVE] == 'Y')
3263: {
3264: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3265: .objet)).socket, SOL_SOCKET, SO_KEEPALIVE,
3266: &drapeau, sizeof(drapeau)) != 0)
3267: {
3268: liberation(s_etat_processus, s_objet_argument);
3269: liberation(s_etat_processus, s_objet_resultat);
3270:
3271: (*s_etat_processus).erreur_execution =
3272: d_ex_erreur_parametre_fichier;
3273: return(d_erreur);
3274: }
3275: }
3276:
3277: if (options[d_PRIORITY] == 'Y')
3278: {
3279: # ifdef SO_PRIORITY
3280: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3281: .objet)).socket, SOL_SOCKET, SO_PRIORITY,
3282: &priorite, sizeof(priorite)) != 0)
3283: {
3284: liberation(s_etat_processus, s_objet_argument);
3285: liberation(s_etat_processus, s_objet_resultat);
3286:
3287: (*s_etat_processus).erreur_execution =
3288: d_ex_erreur_parametre_fichier;
3289: return(d_erreur);
3290: }
3291: # else
3292: WARNING("PRIORITY");
3293: # endif
3294: }
3295:
3296: if (options[d_RECEIVE_BUFFER] == 'Y')
3297: {
3298: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3299: .objet)).socket, SOL_SOCKET, SO_RCVBUF,
3300: &buffer_reception, sizeof(buffer_reception)) != 0)
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_parametre_fichier;
3307: return(d_erreur);
3308: }
3309: }
3310:
3311: if (options[d_FORCE_RECEIVE_BUFFER] == 'Y')
3312: {
3313: # ifdef SO_RCVBUFFORCE
3314: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3315: .objet)).socket, SOL_SOCKET, SO_RCVBUFFORCE,
3316: &buffer_reception, sizeof(buffer_reception))
3317: != 0)
3318: {
3319: liberation(s_etat_processus, s_objet_argument);
3320: liberation(s_etat_processus, s_objet_resultat);
3321:
3322: (*s_etat_processus).erreur_execution =
3323: d_ex_erreur_parametre_fichier;
3324: return(d_erreur);
3325: }
3326: # else
3327: WARNING("FORCE_RECEIVE_BUFFER");
3328: # endif
3329: }
3330:
3331: if (options[d_SEND_BUFFER] == 'Y')
3332: {
3333: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3334: .objet)).socket, SOL_SOCKET, SO_SNDBUF,
3335: &buffer_emission, sizeof(buffer_emission)) != 0)
3336: {
3337: liberation(s_etat_processus, s_objet_argument);
3338: liberation(s_etat_processus, s_objet_resultat);
3339:
3340: (*s_etat_processus).erreur_execution =
3341: d_ex_erreur_parametre_fichier;
3342: return(d_erreur);
3343: }
3344: }
3345:
3346: if (options[d_FORCE_SEND_BUFFER] == 'Y')
3347: {
3348: # ifdef SO_SNDBUFFORCE
3349: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3350: .objet)).socket, SOL_SOCKET, SO_SNDBUFFORCE,
3351: &buffer_emission, sizeof(buffer_emission)) != 0)
3352: {
3353: liberation(s_etat_processus, s_objet_argument);
3354: liberation(s_etat_processus, s_objet_resultat);
3355:
3356: (*s_etat_processus).erreur_execution =
3357: d_ex_erreur_parametre_fichier;
3358: return(d_erreur);
3359: }
3360: # else
3361: WARNING("FORCE_SEND_BUFFER");
3362: # endif
3363: }
3364:
3365: if (options[d_RECEIVING_TIMEOUT] == 'Y')
3366: {
3367: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3368: .objet)).socket, SOL_SOCKET, SO_RCVTIMEO,
3369: &timeout_reception, sizeof(timeout_reception)) != 0)
3370: {
3371: liberation(s_etat_processus, s_objet_argument);
3372: liberation(s_etat_processus, s_objet_resultat);
3373:
3374: (*s_etat_processus).erreur_execution =
3375: d_ex_erreur_parametre_fichier;
3376: return(d_erreur);
3377: }
3378: }
3379:
3380: if (options[d_SENDING_TIMEOUT] == 'Y')
3381: {
3382: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3383: .objet)).socket, SOL_SOCKET, SO_SNDTIMEO,
3384: &timeout_emission, sizeof(timeout_emission)) != 0)
3385: {
3386: liberation(s_etat_processus, s_objet_argument);
3387: liberation(s_etat_processus, s_objet_resultat);
3388:
3389: (*s_etat_processus).erreur_execution =
3390: d_ex_erreur_parametre_fichier;
3391: return(d_erreur);
3392: }
3393: }
3394:
3395: if (options[d_REUSE_ADDRESS] == 'Y')
3396: {
3397: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3398: .objet)).socket, SOL_SOCKET, SO_REUSEADDR,
3399: &drapeau, sizeof(drapeau)) != 0)
3400: {
3401: liberation(s_etat_processus, s_objet_argument);
3402: liberation(s_etat_processus, s_objet_resultat);
3403:
3404: (*s_etat_processus).erreur_execution =
3405: d_ex_erreur_parametre_fichier;
3406: return(d_erreur);
3407: }
3408: }
3409:
3410: return(d_absence_erreur);
3411: #undef WARNING
3412: }
3413:
3414: /*
3415: * Vérification de la cohérence des arguments et traitement
3416: * des valeurs par défaut.
3417: */
3418:
3419: if (format == ' ')
3420: {
3421: format = 'N';
3422: }
3423:
3424: if (protection == ' ')
3425: {
3426: protection = 'N';
3427: }
3428:
3429: if (type_domaine == ' ')
3430: {
3431: type_domaine = 'L';
3432: }
3433:
3434: if (type_socket == ' ')
3435: {
3436: type_socket = 'S';
3437: type = SOCK_STREAM;
3438: }
3439:
3440: if (nom != NULL)
3441: {
3442: if (strcmp(protocole, "") == 0)
3443: {
3444: strcpy(protocole, "UNIX");
3445: }
3446: }
3447: else
3448: {
3449: if (strcmp(protocole, "") == 0)
3450: {
3451: strcpy(protocole, "IPV4");
3452: }
3453: }
3454:
3455: if ((nom != NULL) && (hote != NULL))
3456: {
3457: liberation(s_etat_processus, s_objet_argument);
3458:
3459: (*s_etat_processus).erreur_execution =
3460: d_ex_erreur_parametre_fichier;
3461: return;
3462: }
3463:
3464: if ((nom != NULL) && (strcmp(protocole, "UNIX") != 0))
3465: {
3466: liberation(s_etat_processus, s_objet_argument);
3467:
3468: (*s_etat_processus).erreur_execution =
3469: d_ex_erreur_parametre_fichier;
3470: return;
3471: }
3472:
3473: if ((hote != NULL) && (strcmp(protocole, "UNIX") == 0))
3474: {
3475: liberation(s_etat_processus, s_objet_argument);
3476:
3477: (*s_etat_processus).erreur_execution =
3478: d_ex_erreur_parametre_fichier;
3479: return;
3480: }
3481:
3482: if ((nom != NULL) && (type_domaine == 'F') && (type_adresse != ' '))
3483: {
3484: liberation(s_etat_processus, s_objet_argument);
3485:
3486: (*s_etat_processus).erreur_execution =
3487: d_ex_erreur_parametre_fichier;
3488: return;
3489: }
3490:
3491: if ((presence_port == d_vrai) && (nom != NULL))
3492: {
3493: liberation(s_etat_processus, s_objet_argument);
3494:
3495: (*s_etat_processus).erreur_execution =
3496: d_ex_erreur_parametre_fichier;
3497: return;
3498: }
3499:
3500: if (((strcmp(protocole, "IPV4") == 0) && (type_adresse == '6')) ||
3501: ((strcmp(protocole, "IPV6") == 0) && (type_adresse == '4')))
3502: {
3503: liberation(s_etat_processus, s_objet_argument);
3504:
3505: (*s_etat_processus).erreur_execution =
3506: d_ex_erreur_parametre_fichier;
3507: return;
3508: }
3509:
3510: if ((nombre_maximal_connexions != 0) && ((type_socket != 'S') &&
3511: (type_socket != 'Q')))
3512: {
3513: liberation(s_etat_processus, s_objet_argument);
3514:
3515: (*s_etat_processus).erreur_execution =
3516: d_ex_erreur_parametre_fichier;
3517: return;
3518: }
3519:
3520: if (nombre_maximal_connexions == 0)
3521: {
3522: nombre_maximal_connexions = 1;
3523: }
3524:
3525: if (protocole_socket == NULL)
3526: {
3527: protocole_numerique = 0;
3528: }
3529: else
3530: {
3531: for(i = 0; i < strlen(protocole_socket); i++)
3532: {
3533: if ((protocole_socket[i] >= 'A') &&
3534: (protocole_socket[i] <= 'Z'))
3535: {
3536: protocole_socket[i] += 'a' - 'A';
3537: }
3538: }
3539:
3540: if (strcmp(protocole_socket, "ipv4") == 0)
3541: {
3542: protocole_socket[2] = d_code_fin_chaine;
3543: }
3544:
3545: if ((s_protocole = getprotobyname(protocole_socket)) == NULL)
3546: {
3547: liberation(s_etat_processus, s_objet_argument);
3548:
3549: (*s_etat_processus).erreur_execution =
3550: d_ex_erreur_parametre_fichier;
3551: return;
3552: }
3553:
3554: protocole_numerique = (*s_protocole).p_proto;
3555: }
3556:
3557: if ((s_objet_resultat = allocation(s_etat_processus, SCK))
3558: == NULL)
3559: {
3560: (*s_etat_processus).erreur_systeme =
3561: d_es_allocation_memoire;
3562: return;
3563: }
3564:
3565: if (((*((struct_socket *) (*s_objet_resultat).objet)).format =
3566: allocation(s_etat_processus, LST)) == NULL)
3567: {
3568: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3569: return;
3570: }
3571:
3572: (*((struct_socket *) (*s_objet_resultat).objet)).protection
3573: = protection;
3574: (*(*((struct_socket *) (*s_objet_resultat).objet))
3575: .format).objet = NULL;
3576:
3577: switch(type_socket)
3578: {
3579: case 'S' :
3580: type = SOCK_STREAM;
3581: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
3582: type, "STREAM");
3583: break;
3584:
3585: case 'D' :
3586: type = SOCK_DGRAM;
3587: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
3588: type, "DATAGRAM");
3589: break;
3590:
3591: case 'Q' :
3592: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
3593: type, "SEQUENTIAL DATAGRAM");
3594: type = SOCK_SEQPACKET;
3595: break;
3596:
3597: case 'R' :
3598: type = SOCK_RAW;
3599: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
3600: type, "RAW");
3601: break;
3602:
3603: case 'M' :
3604: type = SOCK_RDM;
3605: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
3606: type, "ROBUST DATAGRAM");
3607: break;
3608: }
3609:
3610: if ((protection != 'N') && ((type_socket != 'S') &&
3611: (type_socket != 'Q')))
3612: {
3613: liberation(s_etat_processus, s_objet_argument);
3614: liberation(s_etat_processus, s_objet_resultat);
3615:
3616: (*s_etat_processus).erreur_execution =
3617: d_ex_erreur_parametre_fichier;
3618: return;
3619: }
3620:
3621: if (nom == NULL)
3622: {
3623: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
3624: malloc(sizeof(unsigned char))) == NULL)
3625: {
3626: (*s_etat_processus).erreur_systeme =
3627: d_es_allocation_memoire;
3628: return;
3629: }
3630:
3631: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).adresse,
3632: "");
3633: }
3634: else
3635: {
3636: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
3637: malloc((strlen(nom) + 1) * sizeof(unsigned char)))
3638: == NULL)
3639: {
3640: (*s_etat_processus).erreur_systeme =
3641: d_es_allocation_memoire;
3642: return;
3643: }
3644:
3645: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).adresse,
3646: nom);
3647: }
3648:
3649: if (((*((struct_socket *) (*s_objet_resultat).objet))
3650: .adresse_distante = malloc(sizeof(unsigned char))) == NULL)
3651: {
3652: (*s_etat_processus).erreur_systeme =
3653: d_es_allocation_memoire;
3654: return;
3655: }
3656:
3657: strcpy((*((struct_socket *) (*s_objet_resultat).objet))
3658: .adresse_distante, "");
3659:
3660: (*((struct_socket *) (*s_objet_resultat).objet)).localisation =
3661: type_domaine;
3662: (*((struct_socket *) (*s_objet_resultat).objet)).binaire =
3663: format;
3664: (*((struct_socket *) (*s_objet_resultat).objet)).pid =
3665: getpid();
3666: (*((struct_socket *) (*s_objet_resultat).objet)).tid =
3667: pthread_self();
3668: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
3669: = 'Y';
3670: (*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee
3671: = d_faux;
3672:
3673: if (type_domaine == 'L')
3674: { // Socket serveur
3675: if (nom != NULL)
3676: {
3677: /*
3678: * La socket locale est dans l'espace des noms.
3679: */
3680:
3681: if (((*((struct_socket *) (*s_objet_resultat).objet))
3682: .socket = socket(PF_UNIX, type,
3683: protocole_numerique)) == -1)
3684: {
3685: liberation(s_etat_processus, s_objet_argument);
3686: liberation(s_etat_processus, s_objet_resultat);
3687:
3688: (*s_etat_processus).erreur_execution =
3689: d_ex_erreur_acces_fichier;
3690: return;
3691: }
3692:
3693: (*((struct_socket *) (*s_objet_resultat).objet)).domaine
3694: = PF_UNIX;
3695: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
3696: = 'Y';
3697:
3698: socket_unix.sun_family = AF_UNIX;
3699:
3700: pointeur = (*((struct_socket *)
3701: (*s_objet_resultat).objet)).adresse;
3702:
3703: while((*pointeur) == d_code_espace)
3704: {
3705: pointeur++;
3706: }
3707:
3708: strncpy(socket_unix.sun_path, pointeur, 108);
3709: socket_unix.sun_path[108 - 1] = d_code_fin_chaine;
3710:
3711: if (options_socket() == d_erreur)
3712: {
3713: liberation(s_etat_processus, s_objet_argument);
3714: liberation(s_etat_processus, s_objet_resultat);
3715:
3716: return;
3717: }
3718:
3719: if (bind((*((struct_socket *) (*s_objet_resultat).objet))
3720: .socket, (const struct sockaddr *) &socket_unix,
3721: sizeof(socket_unix)) != 0)
3722: {
3723: liberation(s_etat_processus, s_objet_argument);
3724: liberation(s_etat_processus, s_objet_resultat);
3725:
3726: (*s_etat_processus).erreur_execution =
3727: d_ex_erreur_acces_fichier;
3728: return;
3729: }
3730: }
3731: else
3732: {
3733: /*
3734: * La socket est une socket réseau locale. L'adresse
3735: * passée en argument est l'adresse sur laquelle
3736: * cette socket est à l'écoute.
3737: */
3738:
3739: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
3740: = 'N';
3741:
3742: if (hote != NULL)
3743: { // Hôte défini par un nom
3744: resolution = NULL;
3745:
3746: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
3747: {
3748: liberation(s_etat_processus, s_objet_argument);
3749: liberation(s_etat_processus, s_objet_resultat);
3750:
3751: if (resolution != NULL)
3752: {
3753: freeaddrinfo(resolution);
3754: }
3755:
3756: (*s_etat_processus).erreur_execution =
3757: d_ex_erreur_acces_fichier;
3758: return;
3759: }
3760:
3761: if (strcmp(protocole, "IPV4") == 0)
3762: { // Accès en IPv4
3763: resolution_courante = resolution;
3764:
3765: while(resolution_courante != NULL)
3766: {
3767: if ((*resolution_courante).ai_family ==
3768: AF_INET)
3769: {
3770: break;
3771: }
3772:
3773: resolution_courante = (*resolution_courante)
3774: .ai_next;
3775: }
3776:
3777: if (resolution_courante == NULL)
3778: {
3779: liberation(s_etat_processus, s_objet_argument);
3780: liberation(s_etat_processus, s_objet_resultat);
3781:
3782: freeaddrinfo(resolution);
3783:
3784: (*s_etat_processus).erreur_execution =
3785: d_ex_erreur_acces_fichier;
3786: return;
3787: }
3788:
3789: if (((*((struct_socket *)
3790: (*s_objet_resultat).objet))
3791: .socket = socket(PF_INET, type,
3792: protocole_numerique)) == -1)
3793: {
3794: liberation(s_etat_processus, s_objet_argument);
3795: liberation(s_etat_processus, s_objet_resultat);
3796:
3797: freeaddrinfo(resolution);
3798:
3799: (*s_etat_processus).erreur_execution =
3800: d_ex_erreur_acces_fichier;
3801: return;
3802: }
3803:
3804: (*((struct_socket *) (*s_objet_resultat).objet))
3805: .domaine = PF_INET;
3806:
3807: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
3808: socket_ipv4.sin_family = AF_INET;
3809: socket_ipv4.sin_port = htons((uint16_t) port);
3810: socket_ipv4.sin_addr.s_addr =
3811: (*((struct sockaddr_in *)
3812: (*resolution_courante).ai_addr))
3813: .sin_addr.s_addr;
3814:
3815: if (options_socket() == d_erreur)
3816: {
3817: liberation(s_etat_processus, s_objet_argument);
3818: liberation(s_etat_processus, s_objet_resultat);
3819:
3820: freeaddrinfo(resolution);
3821: return;
3822: }
3823:
3824: if (bind((*((struct_socket *) (*s_objet_resultat)
3825: .objet)).socket, (const struct sockaddr *)
3826: &socket_ipv4, sizeof(socket_ipv4)) != 0)
3827: {
3828: liberation(s_etat_processus, s_objet_argument);
3829: liberation(s_etat_processus, s_objet_resultat);
3830:
3831: freeaddrinfo(resolution);
3832:
3833: (*s_etat_processus).erreur_execution =
3834: d_ex_erreur_acces_fichier;
3835: return;
3836: }
3837:
3838: if (((*((struct_socket *) (*s_objet_resultat)
3839: .objet)).adresse = malloc(22 *
3840: sizeof(unsigned char))) == NULL)
3841: {
3842: (*s_etat_processus).erreur_systeme =
3843: d_es_allocation_memoire;
3844: return;
3845: }
3846:
3847: sprintf((*((struct_socket *) (*s_objet_resultat)
3848: .objet)).adresse, "%d.%d.%d.%d",
3849: (ntohl((*((struct sockaddr_in *)
3850: (*resolution_courante).ai_addr)).sin_addr
3851: .s_addr) >> 24) & 0xFF,
3852: (ntohl((*((struct sockaddr_in *)
3853: (*resolution_courante).ai_addr)).sin_addr
3854: .s_addr) >> 16) & 0xFF,
3855: (ntohl((*((struct sockaddr_in *)
3856: (*resolution_courante).ai_addr)).sin_addr
3857: .s_addr) >> 8) & 0xFF,
3858: ntohl((*((struct sockaddr_in *)
3859: (*resolution_courante).ai_addr)).sin_addr
3860: .s_addr) & 0xFF);
3861: }
3862: else
3863: { // Accès en IPv6
3864: resolution_courante = resolution;
3865:
3866: while(resolution_courante != NULL)
3867: {
3868: if ((*resolution_courante).ai_family ==
3869: AF_INET6)
3870: {
3871: break;
3872: }
3873:
3874: resolution_courante = (*resolution_courante)
3875: .ai_next;
3876: }
3877:
3878: if (resolution_courante == NULL)
3879: {
3880: liberation(s_etat_processus, s_objet_argument);
3881: liberation(s_etat_processus, s_objet_resultat);
3882:
3883: freeaddrinfo(resolution);
3884:
3885: (*s_etat_processus).erreur_execution =
3886: d_ex_erreur_acces_fichier;
3887: return;
3888: }
3889:
3890: if (((*((struct_socket *)
3891: (*s_objet_resultat).objet))
3892: .socket = socket(PF_INET6, type,
3893: protocole_numerique)) == -1)
3894: {
3895: liberation(s_etat_processus, s_objet_argument);
3896: liberation(s_etat_processus, s_objet_resultat);
3897:
3898: freeaddrinfo(resolution);
3899:
3900: (*s_etat_processus).erreur_execution =
3901: d_ex_erreur_acces_fichier;
3902: return;
3903: }
3904:
3905: (*((struct_socket *) (*s_objet_resultat).objet))
3906: .domaine = PF_INET6;
3907:
3908: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
3909: socket_ipv6.sin6_family = AF_INET6;
3910: socket_ipv6.sin6_port = htons((uint16_t) port);
3911:
3912: for(i = 0; i < 16;
3913: socket_ipv6.sin6_addr.s6_addr[i] =
3914: (*((struct sockaddr_in6 *)
3915: (*resolution_courante).ai_addr))
3916: .sin6_addr.s6_addr[i], i++);
3917:
3918: if (options_socket() == d_erreur)
3919: {
3920: liberation(s_etat_processus, s_objet_argument);
3921: liberation(s_etat_processus, s_objet_resultat);
3922:
3923: freeaddrinfo(resolution);
3924: return;
3925: }
3926:
3927: if (bind((*((struct_socket *) (*s_objet_resultat)
3928: .objet)).socket, (const struct sockaddr *)
3929: &socket_ipv6, sizeof(socket_ipv6)) != 0)
3930: {
3931: liberation(s_etat_processus, s_objet_argument);
3932: liberation(s_etat_processus, s_objet_resultat);
3933:
3934: freeaddrinfo(resolution);
3935:
3936: (*s_etat_processus).erreur_execution =
3937: d_ex_erreur_acces_fichier;
3938: return;
3939: }
3940:
3941: if (((*((struct_socket *) (*s_objet_resultat)
3942: .objet)).adresse = malloc(55 *
3943: sizeof(unsigned char))) == NULL)
3944: {
3945: (*s_etat_processus).erreur_systeme =
3946: d_es_allocation_memoire;
3947: return;
3948: }
3949:
3950: for(i = 0; i < 16; i++)
3951: {
3952: sprintf((*((struct_socket *) (*s_objet_resultat)
3953: .objet)).adresse,
3954: (i == 0) ? "%s%X" : "%s:%X",
3955: (*((struct_socket *) (*s_objet_resultat)
3956: .objet)).adresse,
3957: (*((struct sockaddr_in6 *)
3958: (*resolution_courante).ai_addr))
3959: .sin6_addr.s6_addr[i]);
3960: }
3961: }
3962:
3963: freeaddrinfo(resolution);
3964:
3965: sprintf((*((struct_socket *) (*s_objet_resultat)
3966: .objet)).adresse, "%s(%u)",
3967: (*((struct_socket *) (*s_objet_resultat)
3968: .objet)).adresse, (unsigned int) port);
3969: }
3970: else
3971: { // Hôte défini par une adresse
3972: if (strcmp(protocole, "IPV4") == 0)
3973: { // Accès en IPv4
3974: if (((*((struct_socket *) (*s_objet_resultat)
3975: .objet)).adresse = malloc(22 *
3976: sizeof(unsigned char))) == NULL)
3977: {
3978: (*s_etat_processus).erreur_systeme =
3979: d_es_allocation_memoire;
3980: return;
3981: }
3982:
3983: (*((struct_socket *) (*s_objet_resultat).objet))
3984: .adresse[0] = d_code_fin_chaine;
3985:
3986: for(i = 0; i < 4; i++)
3987: {
3988: sprintf((*((struct_socket *) (*s_objet_resultat)
3989: .objet)).adresse,
3990: (i == 0) ? "%s%d" : "%s.%d",
3991: (*((struct_socket *) (*s_objet_resultat)
3992: .objet)).adresse, (int) adresse[i]);
3993: }
3994:
3995: sprintf((*((struct_socket *) (*s_objet_resultat)
3996: .objet)).adresse, "%s(%u)",
3997: (*((struct_socket *) (*s_objet_resultat)
3998: .objet)).adresse, (unsigned int) port);
3999:
4000: if (((*((struct_socket *)
4001: (*s_objet_resultat).objet))
4002: .socket = socket(PF_INET, type,
4003: protocole_numerique)) == -1)
4004: {
4005: liberation(s_etat_processus, s_objet_argument);
4006: liberation(s_etat_processus, s_objet_resultat);
4007:
4008: (*s_etat_processus).erreur_execution =
4009: d_ex_erreur_acces_fichier;
4010: return;
4011: }
4012:
4013: (*((struct_socket *) (*s_objet_resultat).objet))
4014: .domaine = PF_INET;
4015:
4016: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4017: socket_ipv4.sin_family = AF_INET;
4018: socket_ipv4.sin_port = htons((uint16_t) port);
4019:
4020: adresse_ipv4 = 0;
4021: for(i = 0; i < 4; adresse_ipv4 =
4022: (256 * adresse_ipv4) + adresse[i++]);
4023:
4024: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
4025:
4026: if (options_socket() == d_erreur)
4027: {
4028: liberation(s_etat_processus, s_objet_argument);
4029: liberation(s_etat_processus, s_objet_resultat);
4030:
4031: return;
4032: }
4033:
4034: if (bind((*((struct_socket *) (*s_objet_resultat)
4035: .objet)).socket, (const struct sockaddr *)
4036: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4037: {
4038: liberation(s_etat_processus, s_objet_argument);
4039: liberation(s_etat_processus, s_objet_resultat);
4040:
4041: (*s_etat_processus).erreur_execution =
4042: d_ex_erreur_acces_fichier;
4043: return;
4044: }
4045: }
4046: else
4047: { // Accès en IPv6
4048: if (((*((struct_socket *) (*s_objet_resultat)
4049: .objet)).adresse = malloc(55 *
4050: sizeof(unsigned char))) == NULL)
4051: {
4052: (*s_etat_processus).erreur_systeme =
4053: d_es_allocation_memoire;
4054: return;
4055: }
4056:
4057: (*((struct_socket *) (*s_objet_resultat).objet))
4058: .adresse[0] = d_code_fin_chaine;
4059:
4060: for(i = 0; i < 16; i++)
4061: {
4062: sprintf((*((struct_socket *) (*s_objet_resultat)
4063: .objet)).adresse,
4064: (i == 0) ? "%s%X" : "%s:%X",
4065: (*((struct_socket *) (*s_objet_resultat)
4066: .objet)).adresse, (unsigned int)
4067: adresse[i]);
4068: }
4069:
4070: sprintf((*((struct_socket *) (*s_objet_resultat)
4071: .objet)).adresse, "%s(%u)",
4072: (*((struct_socket *) (*s_objet_resultat)
4073: .objet)).adresse, (unsigned int) port);
4074:
4075: if (((*((struct_socket *)
4076: (*s_objet_resultat).objet))
4077: .socket = socket(PF_INET6, type,
4078: protocole_numerique)) == -1)
4079: {
4080: liberation(s_etat_processus, s_objet_argument);
4081: liberation(s_etat_processus, s_objet_resultat);
4082:
4083: (*s_etat_processus).erreur_execution =
4084: d_ex_erreur_acces_fichier;
4085: return;
4086: }
4087:
4088: (*((struct_socket *) (*s_objet_resultat).objet))
4089: .domaine = PF_INET6;
4090:
4091: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4092: socket_ipv6.sin6_family = AF_INET6;
4093: socket_ipv6.sin6_port = htons((uint16_t) port);
4094:
4095: for(i = 0; i < 16;
4096: socket_ipv6.sin6_addr.s6_addr[i] =
4097: (unsigned char) (adresse[i]), i++);
4098:
4099: if (options_socket() == d_erreur)
4100: {
4101: liberation(s_etat_processus, s_objet_argument);
4102: liberation(s_etat_processus, s_objet_resultat);
4103:
4104: return;
4105: }
4106:
4107: if (bind((*((struct_socket *) (*s_objet_resultat)
4108: .objet)).socket, (const struct sockaddr *)
4109: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4110: {
4111: liberation(s_etat_processus, s_objet_argument);
4112: liberation(s_etat_processus, s_objet_resultat);
4113:
4114: (*s_etat_processus).erreur_execution =
4115: d_ex_erreur_acces_fichier;
4116: return;
4117: }
4118: }
4119: }
4120:
4121: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4122: = 'N';
4123: }
4124:
4125: if ((type_socket == 'S') || (type_socket == 'Q'))
4126: {
4127: if (listen((*((struct_socket *) (*s_objet_resultat).objet))
4128: .socket, (int) nombre_maximal_connexions) != 0)
4129: {
4130: liberation(s_etat_processus, s_objet_argument);
4131: liberation(s_etat_processus, s_objet_resultat);
4132:
4133: (*s_etat_processus).erreur_execution =
4134: d_ex_erreur_acces_fichier;
4135: return;
4136: }
4137:
4138: (*((struct_socket *) (*s_objet_resultat).objet))
4139: .socket_connectee = d_vrai;
4140:
4141: if (protection == 'R')
4142: { // WRITEONLY
4143: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4144: .objet)).socket, SHUT_RD) != 0)
4145: {
4146: liberation(s_etat_processus, s_objet_argument);
4147: liberation(s_etat_processus, s_objet_resultat);
4148:
4149: (*s_etat_processus).erreur_execution =
4150: d_ex_erreur_acces_fichier;
4151: return;
4152: }
4153: }
4154: else if (protection == 'W')
4155: { // READONLY
4156: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4157: .objet)).socket, SHUT_WR) != 0)
4158: {
4159: liberation(s_etat_processus, s_objet_argument);
4160: liberation(s_etat_processus, s_objet_resultat);
4161:
4162: (*s_etat_processus).erreur_execution =
4163: d_ex_erreur_acces_fichier;
4164: return;
4165: }
4166: }
4167: else
4168: { // READWRITE
4169: }
4170: }
4171: }
4172: else
4173: { // Socket cliente
4174: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4175: = 'N';
4176:
4177: /*
4178: * Dans le cas où la socket n'est pas connectée, on
4179: * ne peut utiliser ni "NAME", ni "HOST", ni "PORT",
4180: * et encore moins spécifier une adresse. En effet, la cible
4181: * est défini par la commande TARGET.
4182: */
4183:
4184: if ((type_socket != 'S') && (type_socket != 'Q'))
4185: {
4186: if ((presence_port == d_vrai) || (hote != NULL) ||
4187: (nom != NULL) || (type_adresse != ' '))
4188: {
4189: liberation(s_etat_processus, s_objet_argument);
4190: liberation(s_etat_processus, s_objet_resultat);
4191:
4192: (*s_etat_processus).erreur_execution =
4193: d_ex_erreur_parametre_fichier;
4194: return;
4195: }
4196: }
4197:
4198: if (nom != NULL)
4199: {
4200: /*
4201: * La socket est dans l'espace des noms.
4202: */
4203:
4204: if (((*((struct_socket *) (*s_objet_resultat).objet))
4205: .socket = socket(PF_UNIX, type,
4206: protocole_numerique)) == -1)
4207: {
4208: liberation(s_etat_processus, s_objet_argument);
4209: liberation(s_etat_processus, s_objet_resultat);
4210:
4211: (*s_etat_processus).erreur_execution =
4212: d_ex_erreur_acces_fichier;
4213: return;
4214: }
4215:
4216: (*((struct_socket *) (*s_objet_resultat).objet))
4217: .domaine = PF_UNIX;
4218:
4219: socket_unix.sun_family = AF_UNIX;
4220: strncpy(socket_unix.sun_path, (*((struct_socket *)
4221: (*s_objet_resultat).objet)).adresse, 108);
4222: socket_unix.sun_path[108 - 1] = d_code_fin_chaine;
4223:
4224: if ((type_socket == 'S') || (type_socket == 'Q'))
4225: {
4226: if (connect((*((struct_socket *) (*s_objet_resultat)
4227: .objet)).socket, (const struct sockaddr *)
4228: &socket_unix, sizeof(socket_unix)) != 0)
4229: {
4230: liberation(s_etat_processus, s_objet_argument);
4231: liberation(s_etat_processus, s_objet_resultat);
4232:
4233: (*s_etat_processus).erreur_execution =
4234: d_ex_erreur_acces_fichier;
4235: return;
4236: }
4237:
4238: (*((struct_socket *) (*s_objet_resultat).objet))
4239: .socket_connectee = d_vrai;
4240: (*((struct_socket *) (*s_objet_resultat).objet))
4241: .socket_en_ecoute = 'N';
4242: }
4243: }
4244: else
4245: {
4246: /*
4247: * La socket est une socket réseau. L'adresse
4248: * passée en argument est l'adresse sur laquelle
4249: * cette socket est à l'écoute.
4250: */
4251:
4252: if (hote != NULL)
4253: { // Hôte défini par un nom
4254: resolution = NULL;
4255:
4256: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4257: {
4258: liberation(s_etat_processus, s_objet_argument);
4259: liberation(s_etat_processus, s_objet_resultat);
4260:
4261: if (resolution != NULL)
4262: {
4263: freeaddrinfo(resolution);
4264: }
4265:
4266: (*s_etat_processus).erreur_execution =
4267: d_ex_erreur_acces_fichier;
4268: return;
4269: }
4270:
4271: if (strcmp(protocole, "IPV4") == 0)
4272: { // Accès en IPv4
4273: resolution_courante = resolution;
4274:
4275: while(resolution_courante != NULL)
4276: {
4277: if ((*resolution_courante).ai_family ==
4278: AF_INET)
4279: {
4280: break;
4281: }
4282:
4283: resolution_courante = (*resolution_courante)
4284: .ai_next;
4285: }
4286:
4287: if (resolution_courante == NULL)
4288: {
4289: liberation(s_etat_processus, s_objet_argument);
4290: liberation(s_etat_processus, s_objet_resultat);
4291:
4292: freeaddrinfo(resolution);
4293:
4294: (*s_etat_processus).erreur_execution =
4295: d_ex_erreur_acces_fichier;
4296: return;
4297: }
4298:
4299: if (((*((struct_socket *)
4300: (*s_objet_resultat).objet))
4301: .socket = socket(PF_INET, type,
4302: protocole_numerique)) == -1)
4303: {
4304: liberation(s_etat_processus, s_objet_argument);
4305: liberation(s_etat_processus, s_objet_resultat);
4306:
4307: freeaddrinfo(resolution);
4308:
4309: (*s_etat_processus).erreur_execution =
4310: d_ex_erreur_acces_fichier;
4311: return;
4312: }
4313:
4314: (*((struct_socket *) (*s_objet_resultat).objet))
4315: .domaine = PF_INET;
4316:
4317: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4318: socket_ipv4.sin_family = AF_INET;
4319: socket_ipv4.sin_port = htons((uint16_t) port);
4320: socket_ipv4.sin_addr.s_addr =
4321: (*((struct sockaddr_in *)
4322: (*resolution_courante).ai_addr))
4323: .sin_addr.s_addr;
4324:
4325: if ((type_socket == 'S') || (type_socket == 'Q'))
4326: {
4327: if (connect((*((struct_socket *)
4328: (*s_objet_resultat).objet)).socket,
4329: (const struct sockaddr *)
4330: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4331: {
4332: liberation(s_etat_processus,
4333: s_objet_argument);
4334: liberation(s_etat_processus,
4335: s_objet_resultat);
4336:
4337: freeaddrinfo(resolution);
4338:
4339: (*s_etat_processus).erreur_execution =
4340: d_ex_erreur_acces_fichier;
4341: return;
4342: }
4343:
4344: (*((struct_socket *) (*s_objet_resultat).objet))
4345: .socket_connectee = d_vrai;
4346: (*((struct_socket *) (*s_objet_resultat).objet))
4347: .socket_en_ecoute = 'N';
4348: }
4349:
4350: if (((*((struct_socket *) (*s_objet_resultat)
4351: .objet)).adresse = malloc(22 *
4352: sizeof(unsigned char))) == NULL)
4353: {
4354: (*s_etat_processus).erreur_systeme =
4355: d_es_allocation_memoire;
4356: return;
4357: }
4358:
4359: sprintf((*((struct_socket *) (*s_objet_resultat)
4360: .objet)).adresse, "%d.%d.%d.%d",
4361: (ntohl((*((struct sockaddr_in *)
4362: (*resolution_courante).ai_addr)).sin_addr
4363: .s_addr) >> 24) & 0xFF,
4364: (ntohl((*((struct sockaddr_in *)
4365: (*resolution_courante).ai_addr)).sin_addr
4366: .s_addr) >> 16) & 0xFF,
4367: (ntohl((*((struct sockaddr_in *)
4368: (*resolution_courante).ai_addr)).sin_addr
4369: .s_addr) >> 8) & 0xFF,
4370: ntohl((*((struct sockaddr_in *)
4371: (*resolution_courante).ai_addr)).sin_addr
4372: .s_addr) & 0xFF);
4373: }
4374: else
4375: { // Accès en IPv6
4376: resolution_courante = resolution;
4377:
4378: while(resolution_courante != NULL)
4379: {
4380: if ((*resolution_courante).ai_family ==
4381: AF_INET6)
4382: {
4383: break;
4384: }
4385:
4386: resolution_courante = (*resolution_courante)
4387: .ai_next;
4388: }
4389:
4390: if (resolution_courante == NULL)
4391: {
4392: liberation(s_etat_processus, s_objet_argument);
4393: liberation(s_etat_processus, s_objet_resultat);
4394:
4395: freeaddrinfo(resolution);
4396:
4397: (*s_etat_processus).erreur_execution =
4398: d_ex_erreur_acces_fichier;
4399: return;
4400: }
4401:
4402: if (((*((struct_socket *)
4403: (*s_objet_resultat).objet))
4404: .socket = socket(PF_INET6, type,
4405: protocole_numerique)) == -1)
4406: {
4407: liberation(s_etat_processus, s_objet_argument);
4408: liberation(s_etat_processus, s_objet_resultat);
4409:
4410: freeaddrinfo(resolution);
4411:
4412: (*s_etat_processus).erreur_execution =
4413: d_ex_erreur_acces_fichier;
4414: return;
4415: }
4416:
4417: (*((struct_socket *) (*s_objet_resultat).objet))
4418: .domaine = PF_INET6;
4419:
4420: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4421: socket_ipv6.sin6_family = AF_INET6;
4422: socket_ipv6.sin6_port = htons((uint16_t) port);
4423:
4424: for(i = 0; i < 16;
4425: socket_ipv6.sin6_addr.s6_addr[i] =
4426: (*((struct sockaddr_in6 *)
4427: (*resolution_courante).ai_addr))
4428: .sin6_addr.s6_addr[i], i++);
4429:
4430: if ((type_socket == 'S') || (type_socket == 'Q'))
4431: {
4432: if (connect((*((struct_socket *)
4433: (*s_objet_resultat).objet)).socket,
4434: (const struct sockaddr *)
4435: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4436: {
4437: liberation(s_etat_processus,
4438: s_objet_argument);
4439: liberation(s_etat_processus,
4440: s_objet_resultat);
4441:
4442: freeaddrinfo(resolution);
4443:
4444: (*s_etat_processus).erreur_execution =
4445: d_ex_erreur_acces_fichier;
4446: return;
4447: }
4448:
4449: (*((struct_socket *) (*s_objet_resultat).objet))
4450: .socket_connectee = d_vrai;
4451: (*((struct_socket *) (*s_objet_resultat).objet))
4452: .socket_en_ecoute = 'N';
4453: }
4454:
4455: if (((*((struct_socket *) (*s_objet_resultat)
4456: .objet)).adresse = malloc(55 *
4457: sizeof(unsigned char))) == NULL)
4458: {
4459: (*s_etat_processus).erreur_systeme =
4460: d_es_allocation_memoire;
4461: return;
4462: }
4463:
4464: for(i = 0; i < 16; i++)
4465: {
4466: sprintf((*((struct_socket *) (*s_objet_resultat)
4467: .objet)).adresse,
4468: (i == 0) ? "%s%X" : "%s:%X",
4469: (*((struct_socket *) (*s_objet_resultat)
4470: .objet)).adresse,
4471: (*((struct sockaddr_in6 *)
4472: (*resolution_courante).ai_addr))
4473: .sin6_addr.s6_addr[i]);
4474: }
4475: }
4476:
4477: freeaddrinfo(resolution);
4478:
4479: sprintf((*((struct_socket *) (*s_objet_resultat)
4480: .objet)).adresse, "%s(%u)",
4481: (*((struct_socket *) (*s_objet_resultat)
4482: .objet)).adresse, (unsigned int) port);
4483: }
4484: else
4485: { // Hôte défini par une adresse
4486: if (strcmp(protocole, "IPV4") == 0)
4487: { // Accès en IPv4
4488: if (type_adresse == '4')
4489: {
4490: if (((*((struct_socket *) (*s_objet_resultat)
4491: .objet)).adresse = malloc(22 *
4492: sizeof(unsigned char))) == NULL)
4493: {
4494: (*s_etat_processus).erreur_systeme =
4495: d_es_allocation_memoire;
4496: return;
4497: }
4498:
4499: (*((struct_socket *) (*s_objet_resultat).objet))
4500: .adresse[0] = d_code_fin_chaine;
4501:
4502: for(i = 0; i < 4; i++)
4503: {
4504: sprintf((*((struct_socket *)
4505: (*s_objet_resultat).objet)).adresse,
4506: (i == 0) ? "%s%d" : "%s.%d",
4507: (*((struct_socket *)
4508: (*s_objet_resultat)
4509: .objet)).adresse, (int) adresse[i]);
4510: }
4511:
4512: sprintf((*((struct_socket *) (*s_objet_resultat)
4513: .objet)).adresse, "%s(%u)",
4514: (*((struct_socket *) (*s_objet_resultat)
4515: .objet)).adresse, (unsigned int) port);
4516: }
4517: else
4518: {
4519: if (((*((struct_socket *) (*s_objet_resultat)
4520: .objet)).adresse = malloc(
4521: sizeof(unsigned char))) == NULL)
4522: {
4523: (*s_etat_processus).erreur_systeme =
4524: d_es_allocation_memoire;
4525: return;
4526: }
4527:
4528: (*((struct_socket *) (*s_objet_resultat).objet))
4529: .adresse[0] = d_code_fin_chaine;
4530: }
4531:
4532: if (((*((struct_socket *)
4533: (*s_objet_resultat).objet))
4534: .socket = socket(PF_INET, type,
4535: protocole_numerique)) == -1)
4536: {
4537: liberation(s_etat_processus, s_objet_argument);
4538: liberation(s_etat_processus, s_objet_resultat);
4539:
4540: (*s_etat_processus).erreur_execution =
4541: d_ex_erreur_acces_fichier;
4542: return;
4543: }
4544:
4545: (*((struct_socket *) (*s_objet_resultat).objet))
4546: .domaine = PF_INET;
4547:
4548: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4549: socket_ipv4.sin_family = AF_INET;
4550: socket_ipv4.sin_port = htons((uint16_t) port);
4551:
4552: adresse_ipv4 = 0;
4553: for(i = 0; i < 4; adresse_ipv4 =
4554: (256 * adresse_ipv4) + adresse[i++]);
4555:
4556: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
4557:
4558: if ((type_socket == 'S') || (type_socket == 'Q'))
4559: {
4560: if (connect((*((struct_socket *)
4561: (*s_objet_resultat).objet)).socket,
4562: (const struct sockaddr *)
4563: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4564: {
4565: liberation(s_etat_processus,
4566: s_objet_argument);
4567: liberation(s_etat_processus,
4568: s_objet_resultat);
4569:
4570: (*s_etat_processus).erreur_execution =
4571: d_ex_erreur_acces_fichier;
4572: return;
4573: }
4574:
4575: (*((struct_socket *) (*s_objet_resultat).objet))
4576: .socket_connectee = d_vrai;
4577: (*((struct_socket *) (*s_objet_resultat).objet))
4578: .socket_en_ecoute = 'N';
4579: }
4580: }
4581: else if (strcmp(protocole, "IPV6") == 0)
4582: { // Accès en IPv6
4583: if (type_adresse == '6')
4584: {
4585: if (((*((struct_socket *) (*s_objet_resultat)
4586: .objet)).adresse = malloc(55 *
4587: sizeof(unsigned char))) == NULL)
4588: {
4589: (*s_etat_processus).erreur_systeme =
4590: d_es_allocation_memoire;
4591: return;
4592: }
4593:
4594: (*((struct_socket *) (*s_objet_resultat).objet))
4595: .adresse[0] = d_code_fin_chaine;
4596:
4597: for(i = 0; i < 16; i++)
4598: {
4599: sprintf((*((struct_socket *)
4600: (*s_objet_resultat).objet)).adresse,
4601: (i == 0) ? "%s%X" : "%s:%X",
4602: (*((struct_socket *)
4603: (*s_objet_resultat)
4604: .objet)).adresse, (unsigned int)
4605: adresse[i]);
4606: }
4607:
4608: sprintf((*((struct_socket *) (*s_objet_resultat)
4609: .objet)).adresse, "%s(%u)",
4610: (*((struct_socket *) (*s_objet_resultat)
4611: .objet)).adresse, (unsigned int) port);
4612: }
4613: else
4614: {
4615: if (((*((struct_socket *) (*s_objet_resultat)
4616: .objet)).adresse = malloc(
4617: sizeof(unsigned char))) == NULL)
4618: {
4619: (*s_etat_processus).erreur_systeme =
4620: d_es_allocation_memoire;
4621: return;
4622: }
4623:
4624: (*((struct_socket *) (*s_objet_resultat).objet))
4625: .adresse[0] = d_code_fin_chaine;
4626: }
4627:
4628: if (((*((struct_socket *)
4629: (*s_objet_resultat).objet))
4630: .socket = socket(PF_INET6, type,
4631: protocole_numerique)) == -1)
4632: {
4633: liberation(s_etat_processus, s_objet_argument);
4634: liberation(s_etat_processus, s_objet_resultat);
4635:
4636: (*s_etat_processus).erreur_execution =
4637: d_ex_erreur_acces_fichier;
4638: return;
4639: }
4640:
4641: (*((struct_socket *) (*s_objet_resultat).objet))
4642: .domaine = PF_INET6;
4643:
4644: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4645: socket_ipv6.sin6_family = AF_INET6;
4646: socket_ipv6.sin6_port = htons((uint16_t) port);
4647:
4648: for(i = 0; i < 16;
4649: socket_ipv6.sin6_addr.s6_addr[i] =
4650: (unsigned char) (adresse[i]), i++);
4651:
4652: if ((type_socket == 'S') || (type_socket == 'Q'))
4653: {
4654: if (connect((*((struct_socket *)
4655: (*s_objet_resultat).objet)).socket,
4656: (const struct sockaddr *)
4657: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4658: {
4659: liberation(s_etat_processus,
4660: s_objet_argument);
4661: liberation(s_etat_processus,
4662: s_objet_resultat);
4663:
4664: (*s_etat_processus).erreur_execution =
4665: d_ex_erreur_acces_fichier;
4666: return;
4667: }
4668:
4669: (*((struct_socket *) (*s_objet_resultat).objet))
4670: .socket_connectee = d_vrai;
4671: (*((struct_socket *) (*s_objet_resultat).objet))
4672: .socket_en_ecoute = 'N';
4673: }
4674: }
4675: else
4676: { // Socket UNIX
4677: if (((*((struct_socket *) (*s_objet_resultat)
4678: .objet)).adresse = malloc(
4679: sizeof(unsigned char))) == NULL)
4680: {
4681: (*s_etat_processus).erreur_systeme =
4682: d_es_allocation_memoire;
4683: return;
4684: }
4685:
4686: (*((struct_socket *) (*s_objet_resultat).objet))
4687: .adresse[0] = d_code_fin_chaine;
4688:
4689: if (((*((struct_socket *)
4690: (*s_objet_resultat).objet))
4691: .socket = socket(PF_UNIX, type,
4692: protocole_numerique)) == -1)
4693: {
4694: liberation(s_etat_processus, s_objet_argument);
4695: liberation(s_etat_processus, s_objet_resultat);
4696:
4697: (*s_etat_processus).erreur_execution =
4698: d_ex_erreur_acces_fichier;
4699: return;
4700: }
4701: }
4702: }
4703:
4704: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4705: = 'N';
4706: }
4707:
4708: if ((type_socket == 'S') || (type_socket == 'Q'))
4709: {
4710: if (protection == 'R')
4711: { // WRITEONLY
4712: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4713: .objet)).socket, SHUT_RD) != 0)
4714: {
4715: liberation(s_etat_processus, s_objet_argument);
4716: liberation(s_etat_processus, s_objet_resultat);
4717:
4718: (*s_etat_processus).erreur_execution =
4719: d_ex_erreur_acces_fichier;
4720: return;
4721: }
4722: }
4723: else if (protection == 'W')
4724: { // READONLY
4725: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4726: .objet)).socket, SHUT_WR) != 0)
4727: {
4728: liberation(s_etat_processus, s_objet_argument);
4729: liberation(s_etat_processus, s_objet_resultat);
4730:
4731: (*s_etat_processus).erreur_execution =
4732: d_ex_erreur_acces_fichier;
4733: return;
4734: }
4735: }
4736: else
4737: { // READWRITE
4738: }
4739: }
4740: }
4741:
4742: /*
4743: * Gestion de la liste des sockets ouvertes
4744: */
4745:
4746: l_element_courant = (*s_etat_processus).s_sockets;
4747:
4748: if (l_element_courant == NULL)
4749: {
4750: if (((*s_etat_processus).s_sockets =
4751: allocation_maillon(s_etat_processus)) == NULL)
4752: {
4753: (*s_etat_processus).erreur_systeme =
4754: d_es_allocation_memoire;
4755: return;
4756: }
4757:
4758: (*(*s_etat_processus).s_sockets).suivant = NULL;
4759: l_element_courant = (*s_etat_processus).s_sockets;
4760: }
4761: else
4762: {
4763: /*
4764: * Ajout d'un élément à la fin de la liste chaînée
4765: */
4766:
4767: while((*l_element_courant).suivant != NULL)
4768: {
4769: l_element_courant = (*l_element_courant).suivant;
4770: }
4771:
4772: if (((*l_element_courant).suivant =
4773: allocation_maillon(s_etat_processus)) == NULL)
4774: {
4775: (*s_etat_processus).erreur_systeme =
4776: d_es_allocation_memoire;
4777: return;
4778: }
4779:
4780: l_element_courant = (*l_element_courant).suivant;
4781: (*l_element_courant).suivant = NULL;
4782: }
4783:
4784: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
4785: s_objet_resultat, 'O')) == NULL)
4786: {
4787: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4788: return;
4789: }
4790: }
4791: else
4792: {
4793: liberation(s_etat_processus, s_objet_argument);
4794:
4795: (*s_etat_processus).erreur_execution =
4796: d_ex_erreur_parametre_fichier;
4797: return;
4798: }
4799: }
4800: else if ((*s_objet_argument).type == CHN)
4801: {
4802: if ((s_objet_resultat = allocation(s_etat_processus, SPH)) == NULL)
4803: {
4804: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4805: return;
4806: }
4807:
4808: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).nom =
4809: malloc((strlen((unsigned char *) (*s_objet_argument).objet)
4810: + 1) *sizeof(unsigned char))) == NULL)
4811: {
4812: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4813: return;
4814: }
4815:
4816: strcpy((*((struct_semaphore *) (*s_objet_resultat).objet)).nom,
4817: (unsigned char *) (*s_objet_argument).objet);
4818:
4819: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).semaphore =
4820: sem_open((*((struct_semaphore *) (*s_objet_resultat).objet))
4821: .nom, 0)) == SEM_FAILED)
4822: {
4823: if (errno == ENOMEM)
4824: {
4825: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4826: return;
4827: }
4828:
4829: (*s_etat_processus).erreur_execution = d_ex_semaphore;
4830:
4831: liberation(s_etat_processus, s_objet_argument);
4832: liberation(s_etat_processus, s_objet_resultat);
4833: return;
4834: }
4835: }
4836: else
4837: {
4838: liberation(s_etat_processus, s_objet_argument);
4839:
4840: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
4841: return;
4842: }
4843:
4844: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
4845: s_objet_resultat) == d_erreur)
4846: {
4847: return;
4848: }
4849:
4850: return;
4851: }
4852:
4853: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_o1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src