1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.12
4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'oct'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_oct(struct_processus *s_etat_processus)
40: {
41: (*s_etat_processus).erreur_execution = d_ex;
42:
43: if ((*s_etat_processus).affichage_arguments == 'Y')
44: {
45: printf("\n OCT ");
46:
47: if ((*s_etat_processus).langue == 'F')
48: {
49: printf("(base octale)\n\n");
50: printf(" Aucun argument\n");
51: }
52: else
53: {
54: printf("(octal base)\n\n");
55: printf(" No argument\n");
56: }
57:
58: return;
59: }
60: else if ((*s_etat_processus).test_instruction == 'Y')
61: {
62: (*s_etat_processus).nombre_arguments = -1;
63: return;
64: }
65:
66: if (test_cfsf(s_etat_processus, 31) == d_vrai)
67: {
68: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
69: {
70: return;
71: }
72: }
73:
74: sf(s_etat_processus, 43);
75: cf(s_etat_processus, 44);
76:
77: return;
78: }
79:
80:
81: /*
82: ================================================================================
83: Fonction 'over'
84: ================================================================================
85: Entrées :
86: --------------------------------------------------------------------------------
87: Sorties :
88: --------------------------------------------------------------------------------
89: Effets de bord : néant
90: ================================================================================
91: */
92:
93: void
94: instruction_over(struct_processus *s_etat_processus)
95: {
96: struct_objet *s_objet;
97:
98: (*s_etat_processus).erreur_execution = d_ex;
99:
100: if ((*s_etat_processus).affichage_arguments == 'Y')
101: {
102: printf("\n OVER ");
103:
104: if ((*s_etat_processus).langue == 'F')
105: {
106: printf("(duplication de l'objet de niveau 2)\n\n");
107: }
108: else
109: {
110: printf("(duplication of level 2 object)\n\n");
111: }
112:
113: printf(" 2: %s, %s, %s, %s, %s, %s,\n"
114: " %s, %s, %s, %s, %s,\n"
115: " %s, %s, %s, %s, %s,\n"
116: " %s, %s, %s, %s,\n"
117: " %s, %s\n",
118: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
119: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
120: d_SQL, d_SLB, d_PRC, d_MTX);
121: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
122: " %s, %s, %s, %s, %s,\n"
123: " %s, %s, %s, %s, %s,\n"
124: " %s, %s, %s, %s,\n"
125: " %s, %s\n",
126: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
127: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
128: d_SQL, d_SLB, d_PRC, d_MTX);
129: printf("-> 3: %s, %s, %s, %s, %s, %s,\n"
130: " %s, %s, %s, %s, %s,\n"
131: " %s, %s, %s, %s, %s,\n"
132: " %s, %s, %s, %s,\n"
133: " %s, %s\n",
134: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
135: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
136: d_SQL, d_SLB, d_PRC, d_MTX);
137: printf(" ...\n");
138: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
139: " %s, %s, %s, %s, %s,\n"
140: " %s, %s, %s, %s, %s,\n"
141: " %s, %s, %s, %s,\n"
142: " %s, %s\n",
143: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
144: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
145: d_SQL, d_SLB, d_PRC, d_MTX);
146:
147: return;
148: }
149: else if ((*s_etat_processus).test_instruction == 'Y')
150: {
151: (*s_etat_processus).nombre_arguments = -1;
152: return;
153: }
154:
155: if (test_cfsf(s_etat_processus, 31) == d_vrai)
156: {
157: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
158: {
159: return;
160: }
161: }
162:
163: if ((*s_etat_processus).hauteur_pile_operationnelle < 2)
164: {
165: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
166: return;
167: }
168:
169: s_objet = copie_objet(s_etat_processus,
170: (*(*(*s_etat_processus).l_base_pile).suivant).donnee, 'P');
171:
172: if (s_objet == NULL)
173: {
174: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
175: return;
176: }
177:
178: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
179: s_objet) == d_erreur)
180: {
181: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
182: return;
183: }
184:
185: return;
186: }
187:
188:
189: /*
190: ================================================================================
191: Fonction 'or'
192: ================================================================================
193: Entrées : pointeur sur une structure struct_processus
194: --------------------------------------------------------------------------------
195: Sorties :
196: --------------------------------------------------------------------------------
197: Effets de bord : néant
198: ================================================================================
199: */
200:
201: void
202: instruction_or(struct_processus *s_etat_processus)
203: {
204: struct_liste_chainee *l_element_courant;
205: struct_liste_chainee *l_element_precedent;
206:
207: struct_objet *s_copie_argument_1;
208: struct_objet *s_copie_argument_2;
209: struct_objet *s_objet_argument_1;
210: struct_objet *s_objet_argument_2;
211: struct_objet *s_objet_resultat;
212:
213: unsigned long nombre_elements;
214:
215: (*s_etat_processus).erreur_execution = d_ex;
216:
217: if ((*s_etat_processus).affichage_arguments == 'Y')
218: {
219: printf("\n OR ");
220:
221: if ((*s_etat_processus).langue == 'F')
222: {
223: printf("(opérateur ou)\n\n");
224: }
225: else
226: {
227: printf("(or operator)\n\n");
228: }
229:
230: printf(" 2: %s, %s\n", d_INT, d_REL);
231: printf(" 1: %s, %s\n", d_INT, d_REL);
232: printf("-> 1: %s\n\n", d_INT);
233:
234: printf(" 2: %s\n", d_BIN);
235: printf(" 1: %s\n", d_BIN);
236: printf("-> 1: %s\n\n", d_BIN);
237:
238: printf(" 2: %s\n", d_NOM);
239: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
240: printf("-> 1: %s\n\n", d_ALG);
241:
242: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
243: printf(" 1: %s\n", d_NOM);
244: printf("-> 1: %s\n\n", d_ALG);
245:
246: printf(" 2: %s\n", d_ALG);
247: printf(" 1: %s\n", d_ALG);
248: printf("-> 1: %s\n\n", d_ALG);
249:
250: printf(" 2: %s\n", d_RPN);
251: printf(" 1: %s\n", d_RPN);
252: printf("-> 1: %s\n", d_RPN);
253:
254: return;
255: }
256: else if ((*s_etat_processus).test_instruction == 'Y')
257: {
258: (*s_etat_processus).nombre_arguments = 0;
259: return;
260: }
261:
262: if (test_cfsf(s_etat_processus, 31) == d_vrai)
263: {
264: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
265: {
266: return;
267: }
268: }
269:
270: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
271: &s_objet_argument_1) == d_erreur)
272: {
273: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
274: return;
275: }
276:
277: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
278: &s_objet_argument_2) == d_erreur)
279: {
280: liberation(s_etat_processus, s_objet_argument_1);
281:
282: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
283: return;
284: }
285:
286: /*
287: --------------------------------------------------------------------------------
288: OR logique
289: --------------------------------------------------------------------------------
290: */
291:
292: if ((((*s_objet_argument_1).type == INT) ||
293: ((*s_objet_argument_1).type == REL)) &&
294: (((*s_objet_argument_2).type == INT) ||
295: ((*s_objet_argument_2).type == REL)))
296: {
297: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
298: {
299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
300: return;
301: }
302:
303: if ((*s_objet_argument_1).type == INT)
304: {
305: if ((*s_objet_argument_2).type == INT)
306: {
307: if (((*((integer8 *) (*s_objet_argument_1).objet)) != 0) ||
308: ((*((integer8 *) (*s_objet_argument_2).objet)) != 0))
309: {
310: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
311: }
312: else
313: {
314: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
315: }
316: }
317: else
318: {
319: if (((*((integer8 *) (*s_objet_argument_1).objet)) != 0) ||
320: ((*((real8 *) (*s_objet_argument_2).objet)) != 0))
321: {
322: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
323: }
324: else
325: {
326: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
327: }
328: }
329: }
330: else
331: {
332: if ((*s_objet_argument_2).type == INT)
333: {
334: if (((*((real8 *) (*s_objet_argument_1).objet)) != 0) ||
335: ((*((integer8 *) (*s_objet_argument_2).objet)) != 0))
336: {
337: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
338: }
339: else
340: {
341: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
342: }
343: }
344: else
345: {
346: if (((*((real8 *) (*s_objet_argument_1).objet)) != 0) ||
347: ((*((real8 *) (*s_objet_argument_2).objet)) != 0))
348: {
349: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
350: }
351: else
352: {
353: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
354: }
355: }
356: }
357: }
358:
359: /*
360: --------------------------------------------------------------------------------
361: OR binaire
362: --------------------------------------------------------------------------------
363: */
364:
365: else if (((*s_objet_argument_1).type == BIN) &&
366: ((*s_objet_argument_2).type == BIN))
367: {
368: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
369: {
370: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
371: return;
372: }
373:
374: (*((logical8 *) (*s_objet_resultat).objet)) =
375: (*((logical8 *) (*s_objet_argument_1).objet)) |
376: (*((logical8 *) (*s_objet_argument_2).objet));
377: }
378:
379: /*
380: --------------------------------------------------------------------------------
381: OR entre des arguments complexes
382: --------------------------------------------------------------------------------
383: */
384:
385: /*
386: * Nom ou valeur numérique / Nom ou valeur numérique
387: */
388:
389: else if ((((*s_objet_argument_1).type == NOM) &&
390: (((*s_objet_argument_2).type == NOM) ||
391: ((*s_objet_argument_2).type == INT) ||
392: ((*s_objet_argument_2).type == REL))) ||
393: (((*s_objet_argument_2).type == NOM) &&
394: (((*s_objet_argument_1).type == INT) ||
395: ((*s_objet_argument_1).type == REL))))
396: {
397: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
398: {
399: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
400: return;
401: }
402:
403: if (((*s_objet_resultat).objet =
404: allocation_maillon(s_etat_processus)) == NULL)
405: {
406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
407: return;
408: }
409:
410: l_element_courant = (*s_objet_resultat).objet;
411:
412: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
413: == NULL)
414: {
415: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
416: return;
417: }
418:
419: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
420: .nombre_arguments = 0;
421: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
422: .fonction = instruction_vers_niveau_superieur;
423:
424: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
425: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
426: {
427: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
428: return;
429: }
430:
431: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
432: .nom_fonction, "<<");
433:
434: if (((*l_element_courant).suivant =
435: allocation_maillon(s_etat_processus)) == NULL)
436: {
437: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
438: return;
439: }
440:
441: l_element_courant = (*l_element_courant).suivant;
442: (*l_element_courant).donnee = s_objet_argument_2;
443:
444: if (((*l_element_courant).suivant =
445: allocation_maillon(s_etat_processus)) == NULL)
446: {
447: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
448: return;
449: }
450:
451: l_element_courant = (*l_element_courant).suivant;
452: (*l_element_courant).donnee = s_objet_argument_1;
453:
454: if (((*l_element_courant).suivant =
455: allocation_maillon(s_etat_processus)) == NULL)
456: {
457: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
458: return;
459: }
460:
461: l_element_courant = (*l_element_courant).suivant;
462:
463: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
464: == NULL)
465: {
466: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
467: return;
468: }
469:
470: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
471: .nombre_arguments = 0;
472: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
473: .fonction = instruction_or;
474:
475: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
476: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
477: {
478: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
479: return;
480: }
481:
482: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
483: .nom_fonction, "OR");
484:
485: if (((*l_element_courant).suivant =
486: allocation_maillon(s_etat_processus)) == NULL)
487: {
488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
489: return;
490: }
491:
492: l_element_courant = (*l_element_courant).suivant;
493:
494: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
495: == NULL)
496: {
497: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
498: return;
499: }
500:
501: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
502: .nombre_arguments = 0;
503: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
504: .fonction = instruction_vers_niveau_inferieur;
505:
506: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
507: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
508: {
509: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
510: return;
511: }
512:
513: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
514: .nom_fonction, ">>");
515:
516: (*l_element_courant).suivant = NULL;
517:
518: s_objet_argument_1 = NULL;
519: s_objet_argument_2 = NULL;
520: }
521:
522: /*
523: * Nom ou valeur numérique / Expression
524: */
525:
526: else if ((((*s_objet_argument_1).type == ALG) ||
527: ((*s_objet_argument_1).type == RPN)) &&
528: (((*s_objet_argument_2).type == NOM) ||
529: ((*s_objet_argument_2).type == INT) ||
530: ((*s_objet_argument_2).type == REL)))
531: {
532: nombre_elements = 0;
533: l_element_courant = (struct_liste_chainee *)
534: (*s_objet_argument_1).objet;
535:
536: while(l_element_courant != NULL)
537: {
538: nombre_elements++;
539: l_element_courant = (*l_element_courant).suivant;
540: }
541:
542: if (nombre_elements == 2)
543: {
544: liberation(s_etat_processus, s_objet_argument_1);
545: liberation(s_etat_processus, s_objet_argument_2);
546:
547: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
548: return;
549: }
550:
551: if ((s_objet_resultat = copie_objet(s_etat_processus,
552: s_objet_argument_1, 'N')) == NULL)
553: {
554: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
555: return;
556: }
557:
558: l_element_courant = (struct_liste_chainee *)
559: (*s_objet_resultat).objet;
560: l_element_precedent = l_element_courant;
561: l_element_courant = (*l_element_courant).suivant;
562:
563: if (((*l_element_precedent).suivant =
564: allocation_maillon(s_etat_processus)) == NULL)
565: {
566: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
567: return;
568: }
569:
570: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
571: (*(*l_element_precedent).suivant).suivant = l_element_courant;
572:
573: while((*l_element_courant).suivant != NULL)
574: {
575: l_element_precedent = l_element_courant;
576: l_element_courant = (*l_element_courant).suivant;
577: }
578:
579: if (((*l_element_precedent).suivant =
580: allocation_maillon(s_etat_processus)) == NULL)
581: {
582: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
583: return;
584: }
585:
586: if (((*(*l_element_precedent).suivant).donnee =
587: allocation(s_etat_processus, FCT)) == NULL)
588: {
589: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
590: return;
591: }
592:
593: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
594: .donnee).objet)).nombre_arguments = 0;
595: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
596: .donnee).objet)).fonction = instruction_or;
597:
598: if (((*((struct_fonction *) (*(*(*l_element_precedent)
599: .suivant).donnee).objet)).nom_fonction =
600: malloc(3 * sizeof(unsigned char))) == NULL)
601: {
602: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
603: return;
604: }
605:
606: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
607: .suivant).donnee).objet)).nom_fonction, "OR");
608:
609: (*(*l_element_precedent).suivant).suivant = l_element_courant;
610:
611: s_objet_argument_2 = NULL;
612: }
613:
614: /*
615: * Expression / Nom ou valeur numérique
616: */
617:
618: else if ((((*s_objet_argument_1).type == NOM) ||
619: ((*s_objet_argument_1).type == INT) ||
620: ((*s_objet_argument_1).type == REL)) &&
621: (((*s_objet_argument_2).type == ALG) ||
622: ((*s_objet_argument_2).type == RPN)))
623: {
624: nombre_elements = 0;
625: l_element_courant = (struct_liste_chainee *)
626: (*s_objet_argument_2).objet;
627:
628: while(l_element_courant != NULL)
629: {
630: nombre_elements++;
631: l_element_courant = (*l_element_courant).suivant;
632: }
633:
634: if (nombre_elements == 2)
635: {
636: liberation(s_etat_processus, s_objet_argument_1);
637: liberation(s_etat_processus, s_objet_argument_2);
638:
639: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
640: return;
641: }
642:
643: if ((s_objet_resultat = copie_objet(s_etat_processus,
644: s_objet_argument_2, 'N')) == NULL)
645: {
646: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
647: return;
648: }
649:
650: l_element_courant = (struct_liste_chainee *)
651: (*s_objet_resultat).objet;
652: l_element_precedent = l_element_courant;
653:
654: while((*l_element_courant).suivant != NULL)
655: {
656: l_element_precedent = l_element_courant;
657: l_element_courant = (*l_element_courant).suivant;
658: }
659:
660: if (((*l_element_precedent).suivant =
661: allocation_maillon(s_etat_processus)) == NULL)
662: {
663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
664: return;
665: }
666:
667: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
668: l_element_precedent = (*l_element_precedent).suivant;
669:
670: if (((*l_element_precedent).suivant =
671: allocation_maillon(s_etat_processus)) == NULL)
672: {
673: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
674: return;
675: }
676:
677: if (((*(*l_element_precedent).suivant).donnee =
678: allocation(s_etat_processus, FCT)) == NULL)
679: {
680: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
681: return;
682: }
683:
684: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
685: .donnee).objet)).nombre_arguments = 0;
686: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
687: .donnee).objet)).fonction = instruction_or;
688:
689: if (((*((struct_fonction *) (*(*(*l_element_precedent)
690: .suivant).donnee).objet)).nom_fonction =
691: malloc(3 * sizeof(unsigned char))) == NULL)
692: {
693: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
694: return;
695: }
696:
697: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
698: .suivant).donnee).objet)).nom_fonction, "OR");
699:
700: (*(*l_element_precedent).suivant).suivant = l_element_courant;
701:
702: s_objet_argument_1 = NULL;
703: }
704:
705: /*
706: * Expression / Expression
707: */
708:
709: else if ((((*s_objet_argument_1).type == ALG) &&
710: ((*s_objet_argument_2).type == ALG)) ||
711: (((*s_objet_argument_1).type == RPN) &&
712: ((*s_objet_argument_2).type == RPN)))
713: {
714: nombre_elements = 0;
715: l_element_courant = (struct_liste_chainee *)
716: (*s_objet_argument_1).objet;
717:
718: while(l_element_courant != NULL)
719: {
720: nombre_elements++;
721: l_element_courant = (*l_element_courant).suivant;
722: }
723:
724: if (nombre_elements == 2)
725: {
726: liberation(s_etat_processus, s_objet_argument_1);
727: liberation(s_etat_processus, s_objet_argument_2);
728:
729: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
730: return;
731: }
732:
733: nombre_elements = 0;
734: l_element_courant = (struct_liste_chainee *)
735: (*s_objet_argument_2).objet;
736:
737: while(l_element_courant != NULL)
738: {
739: nombre_elements++;
740: l_element_courant = (*l_element_courant).suivant;
741: }
742:
743: if (nombre_elements == 2)
744: {
745: liberation(s_etat_processus, s_objet_argument_1);
746: liberation(s_etat_processus, s_objet_argument_2);
747:
748: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
749: return;
750: }
751:
752: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
753: s_objet_argument_1, 'N')) == NULL)
754: {
755: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
756: return;
757: }
758:
759: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
760: s_objet_argument_2, 'N')) == NULL)
761: {
762: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
763: return;
764: }
765:
766: l_element_courant = (struct_liste_chainee *)
767: (*s_copie_argument_1).objet;
768: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
769: (*s_copie_argument_1).objet)).suivant;
770:
771: liberation(s_etat_processus, (*l_element_courant).donnee);
772: free(l_element_courant);
773:
774: l_element_courant = (struct_liste_chainee *)
775: (*s_copie_argument_2).objet;
776: l_element_precedent = l_element_courant;
777: s_objet_resultat = s_copie_argument_2;
778:
779: while((*l_element_courant).suivant != NULL)
780: {
781: l_element_precedent = l_element_courant;
782: l_element_courant = (*l_element_courant).suivant;
783: }
784:
785: liberation(s_etat_processus, (*l_element_courant).donnee);
786: free(l_element_courant);
787:
788: (*l_element_precedent).suivant = (struct_liste_chainee *)
789: (*s_copie_argument_1).objet;
790: free(s_copie_argument_1);
791:
792: l_element_courant = (*l_element_precedent).suivant;
793: while((*l_element_courant).suivant != NULL)
794: {
795: l_element_precedent = l_element_courant;
796: l_element_courant = (*l_element_courant).suivant;
797: }
798:
799: if (((*l_element_precedent).suivant =
800: allocation_maillon(s_etat_processus)) == NULL)
801: {
802: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
803: return;
804: }
805:
806: (*(*l_element_precedent).suivant).suivant = l_element_courant;
807: l_element_courant = (*l_element_precedent).suivant;
808:
809: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
810: == NULL)
811: {
812: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
813: return;
814: }
815:
816: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
817: .nombre_arguments = 0;
818: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
819: .fonction = instruction_or;
820:
821: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
822: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
823: {
824: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
825: return;
826: }
827:
828: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
829: .nom_fonction, "OR");
830: }
831:
832: /*
833: --------------------------------------------------------------------------------
834: OR impossible
835: --------------------------------------------------------------------------------
836: */
837:
838: else
839: {
840: liberation(s_etat_processus, s_objet_argument_1);
841: liberation(s_etat_processus, s_objet_argument_2);
842:
843: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
844: return;
845: }
846:
847: liberation(s_etat_processus, s_objet_argument_1);
848: liberation(s_etat_processus, s_objet_argument_2);
849:
850: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
851: s_objet_resultat) == d_erreur)
852: {
853: return;
854: }
855:
856: return;
857: }
858:
859:
860: /*
861: ================================================================================
862: Fonction 'open'
863: ================================================================================
864: Entrées : pointeur sur une structure struct_processus
865: --------------------------------------------------------------------------------
866: Sorties :
867: --------------------------------------------------------------------------------
868: Effets de bord : néant
869: ================================================================================
870: */
871:
872: void
873: instruction_open(struct_processus *s_etat_processus)
874: {
875: /*
876: * Type d'ouverture :
877: * NEW : crée un nouveau fichier, retourne une erreur si un fichier
878: * préexiste ;
879: * OLD : ouvre un fichier existant, retourne une erreur si le fichier
880: * n'existe pas ;
881: * REPLACE : remplace un fichier existant, retourne une erreur s'il n'y
882: * a aucun fichier à effacer ;
883: * UNKNOWN : ouvre un fichier existant ou crée un nouveau fichier ;
884: * SCRATCH : crée un fichier temporaire automatiquement effacé lors
885: * de sa fermeture (protection automatique 'readwrite');
886: *
887: * Type d'accès :
888: * SEQUENTIAL : accès séquentiel ;
889: * DIRECT : accès direct ;
890: * KEYED : accès indexé.
891: *
892: * Protection :
893: * READONLY : lecture seule ;
894: * WRITEONLY : écriture seule ;
895: * READWRITE : lecture et écriture autorisées.
896: *
897: * Format :
898: * FORMATTED : fichier texte ;
899: * UNFORMATTED : fichier binaire.
900: */
901:
902: file *descripteur;
903:
904: int buffer_emission;
905: int buffer_reception;
906: int drapeau;
907: int priorite;
908: int protocole_numerique;
909: int timeout_emission;
910: int timeout_reception;
911: int type;
912:
913: integer8 adresse[16];
914: integer8 nombre_maximal_connexions;
915: integer8 port;
916: integer8 position_clef;
917:
918: logical1 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: else if (type_arguments == 'S')
3192: {
3193: /*
3194: * Traitement des sockets
3195: */
3196:
3197:
3198: inline logical1 options_socket()
3199: {
3200: /*
3201: * Options des sockets
3202: */
3203:
3204: # define WARNING(message) \
3205: if ((*s_etat_processus).langue != 'F') \
3206: printf("+++Warning : %s unavailable on host system\n", \
3207: message); \
3208: else \
3209: printf("+++Attention : %s non disponible sur le système " \
3210: "hôte\n", message)
3211:
3212: if (options[d_BIND_TO_DEVICE] == 'Y')
3213: {
3214: # ifdef SO_BINDTODEVICE
3215: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3216: .objet)).socket, SOL_SOCKET, SO_BINDTODEVICE,
3217: peripherique, strlen(peripherique)) != 0)
3218: {
3219: liberation(s_etat_processus, s_objet_argument);
3220: liberation(s_etat_processus, s_objet_resultat);
3221:
3222: (*s_etat_processus).erreur_execution =
3223: d_ex_erreur_parametre_fichier;
3224: return(d_erreur);
3225: }
3226: # else
3227: WARNING("BIND TO DEVICE");
3228: # endif
3229: }
3230:
3231: if (options[d_BROADCAST] == 'Y')
3232: {
3233: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3234: .objet)).socket, SOL_SOCKET, SO_BROADCAST,
3235: &drapeau, sizeof(drapeau)) != 0)
3236: {
3237: liberation(s_etat_processus, s_objet_argument);
3238: liberation(s_etat_processus, s_objet_resultat);
3239:
3240: (*s_etat_processus).erreur_execution =
3241: d_ex_erreur_parametre_fichier;
3242: return(d_erreur);
3243: }
3244: }
3245:
3246: if (options[d_DONT_ROUTE] == 'Y')
3247: {
3248: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3249: .objet)).socket, SOL_SOCKET, SO_DONTROUTE,
3250: &drapeau, sizeof(drapeau)) != 0)
3251: {
3252: liberation(s_etat_processus, s_objet_argument);
3253: liberation(s_etat_processus, s_objet_resultat);
3254:
3255: (*s_etat_processus).erreur_execution =
3256: d_ex_erreur_parametre_fichier;
3257: return(d_erreur);
3258: }
3259: }
3260:
3261: if (options[d_KEEP_ALIVE] == 'Y')
3262: {
3263: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3264: .objet)).socket, SOL_SOCKET, SO_KEEPALIVE,
3265: &drapeau, sizeof(drapeau)) != 0)
3266: {
3267: liberation(s_etat_processus, s_objet_argument);
3268: liberation(s_etat_processus, s_objet_resultat);
3269:
3270: (*s_etat_processus).erreur_execution =
3271: d_ex_erreur_parametre_fichier;
3272: return(d_erreur);
3273: }
3274: }
3275:
3276: if (options[d_PRIORITY] == 'Y')
3277: {
3278: # ifdef SO_PRIORITY
3279: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3280: .objet)).socket, SOL_SOCKET, SO_PRIORITY,
3281: &priorite, sizeof(priorite)) != 0)
3282: {
3283: liberation(s_etat_processus, s_objet_argument);
3284: liberation(s_etat_processus, s_objet_resultat);
3285:
3286: (*s_etat_processus).erreur_execution =
3287: d_ex_erreur_parametre_fichier;
3288: return(d_erreur);
3289: }
3290: # else
3291: WARNING("PRIORITY");
3292: # endif
3293: }
3294:
3295: if (options[d_RECEIVE_BUFFER] == 'Y')
3296: {
3297: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3298: .objet)).socket, SOL_SOCKET, SO_RCVBUF,
3299: &buffer_reception, sizeof(buffer_reception)) != 0)
3300: {
3301: liberation(s_etat_processus, s_objet_argument);
3302: liberation(s_etat_processus, s_objet_resultat);
3303:
3304: (*s_etat_processus).erreur_execution =
3305: d_ex_erreur_parametre_fichier;
3306: return(d_erreur);
3307: }
3308: }
3309:
3310: if (options[d_FORCE_RECEIVE_BUFFER] == 'Y')
3311: {
3312: # ifdef SO_RCVBUFFORCE
3313: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3314: .objet)).socket, SOL_SOCKET, SO_RCVBUFFORCE,
3315: &buffer_reception, sizeof(buffer_reception))
3316: != 0)
3317: {
3318: liberation(s_etat_processus, s_objet_argument);
3319: liberation(s_etat_processus, s_objet_resultat);
3320:
3321: (*s_etat_processus).erreur_execution =
3322: d_ex_erreur_parametre_fichier;
3323: return(d_erreur);
3324: }
3325: # else
3326: WARNING("FORCE_RECEIVE_BUFFER");
3327: # endif
3328: }
3329:
3330: if (options[d_SEND_BUFFER] == 'Y')
3331: {
3332: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3333: .objet)).socket, SOL_SOCKET, SO_SNDBUF,
3334: &buffer_emission, sizeof(buffer_emission)) != 0)
3335: {
3336: liberation(s_etat_processus, s_objet_argument);
3337: liberation(s_etat_processus, s_objet_resultat);
3338:
3339: (*s_etat_processus).erreur_execution =
3340: d_ex_erreur_parametre_fichier;
3341: return(d_erreur);
3342: }
3343: }
3344:
3345: if (options[d_FORCE_SEND_BUFFER] == 'Y')
3346: {
3347: # ifdef SO_SNDBUFFORCE
3348: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3349: .objet)).socket, SOL_SOCKET, SO_SNDBUFFORCE,
3350: &buffer_emission, sizeof(buffer_emission)) != 0)
3351: {
3352: liberation(s_etat_processus, s_objet_argument);
3353: liberation(s_etat_processus, s_objet_resultat);
3354:
3355: (*s_etat_processus).erreur_execution =
3356: d_ex_erreur_parametre_fichier;
3357: return(d_erreur);
3358: }
3359: # else
3360: WARNING("FORCE_SEND_BUFFER");
3361: # endif
3362: }
3363:
3364: if (options[d_RECEIVING_TIMEOUT] == 'Y')
3365: {
3366: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3367: .objet)).socket, SOL_SOCKET, SO_RCVTIMEO,
3368: &timeout_reception, sizeof(timeout_reception)) != 0)
3369: {
3370: liberation(s_etat_processus, s_objet_argument);
3371: liberation(s_etat_processus, s_objet_resultat);
3372:
3373: (*s_etat_processus).erreur_execution =
3374: d_ex_erreur_parametre_fichier;
3375: return(d_erreur);
3376: }
3377: }
3378:
3379: if (options[d_SENDING_TIMEOUT] == 'Y')
3380: {
3381: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3382: .objet)).socket, SOL_SOCKET, SO_SNDTIMEO,
3383: &timeout_emission, sizeof(timeout_emission)) != 0)
3384: {
3385: liberation(s_etat_processus, s_objet_argument);
3386: liberation(s_etat_processus, s_objet_resultat);
3387:
3388: (*s_etat_processus).erreur_execution =
3389: d_ex_erreur_parametre_fichier;
3390: return(d_erreur);
3391: }
3392: }
3393:
3394: if (options[d_REUSE_ADDRESS] == 'Y')
3395: {
3396: if (setsockopt((*((struct_socket *) (*s_objet_resultat)
3397: .objet)).socket, SOL_SOCKET, SO_REUSEADDR,
3398: &drapeau, sizeof(drapeau)) != 0)
3399: {
3400: liberation(s_etat_processus, s_objet_argument);
3401: liberation(s_etat_processus, s_objet_resultat);
3402:
3403: (*s_etat_processus).erreur_execution =
3404: d_ex_erreur_parametre_fichier;
3405: return(d_erreur);
3406: }
3407: }
3408:
3409: return(d_absence_erreur);
3410: #undef WARNING
3411: }
3412:
3413: /*
3414: * Vérification de la cohérence des arguments et traitement
3415: * des valeurs par défaut.
3416: */
3417:
3418: if (format == ' ')
3419: {
3420: format = 'N';
3421: }
3422:
3423: if (protection == ' ')
3424: {
3425: protection = 'N';
3426: }
3427:
3428: if (type_domaine == ' ')
3429: {
3430: type_domaine = 'L';
3431: }
3432:
3433: if (type_socket == ' ')
3434: {
3435: type_socket = 'S';
3436: type = SOCK_STREAM;
3437: }
3438:
3439: if (nom != NULL)
3440: {
3441: if (strcmp(protocole, "") == 0)
3442: {
3443: strcpy(protocole, "UNIX");
3444: }
3445: }
3446: else
3447: {
3448: if (strcmp(protocole, "") == 0)
3449: {
3450: strcpy(protocole, "IPV4");
3451: }
3452: }
3453:
3454: if ((nom != NULL) && (hote != NULL))
3455: {
3456: liberation(s_etat_processus, s_objet_argument);
3457:
3458: (*s_etat_processus).erreur_execution =
3459: d_ex_erreur_parametre_fichier;
3460: return;
3461: }
3462:
3463: if ((nom != NULL) && (strcmp(protocole, "UNIX") != 0))
3464: {
3465: liberation(s_etat_processus, s_objet_argument);
3466:
3467: (*s_etat_processus).erreur_execution =
3468: d_ex_erreur_parametre_fichier;
3469: return;
3470: }
3471:
3472: if ((hote != NULL) && (strcmp(protocole, "UNIX") == 0))
3473: {
3474: liberation(s_etat_processus, s_objet_argument);
3475:
3476: (*s_etat_processus).erreur_execution =
3477: d_ex_erreur_parametre_fichier;
3478: return;
3479: }
3480:
3481: if ((nom != NULL) && (type_domaine == 'F') && (type_adresse != ' '))
3482: {
3483: liberation(s_etat_processus, s_objet_argument);
3484:
3485: (*s_etat_processus).erreur_execution =
3486: d_ex_erreur_parametre_fichier;
3487: return;
3488: }
3489:
3490: if ((presence_port == d_vrai) && (nom != NULL))
3491: {
3492: liberation(s_etat_processus, s_objet_argument);
3493:
3494: (*s_etat_processus).erreur_execution =
3495: d_ex_erreur_parametre_fichier;
3496: return;
3497: }
3498:
3499: if (((strcmp(protocole, "IPV4") == 0) && (type_adresse == '6')) ||
3500: ((strcmp(protocole, "IPV6") == 0) && (type_adresse == '4')))
3501: {
3502: liberation(s_etat_processus, s_objet_argument);
3503:
3504: (*s_etat_processus).erreur_execution =
3505: d_ex_erreur_parametre_fichier;
3506: return;
3507: }
3508:
3509: if ((nombre_maximal_connexions != 0) && ((type_socket != 'S') &&
3510: (type_socket != 'Q')))
3511: {
3512: liberation(s_etat_processus, s_objet_argument);
3513:
3514: (*s_etat_processus).erreur_execution =
3515: d_ex_erreur_parametre_fichier;
3516: return;
3517: }
3518:
3519: if (nombre_maximal_connexions == 0)
3520: {
3521: nombre_maximal_connexions = 1;
3522: }
3523:
3524: if (protocole_socket == NULL)
3525: {
3526: protocole_numerique = 0;
3527: }
3528: else
3529: {
3530: for(i = 0; i < strlen(protocole_socket); i++)
3531: {
3532: if ((protocole_socket[i] >= 'A') &&
3533: (protocole_socket[i] <= 'Z'))
3534: {
3535: protocole_socket[i] += 'a' - 'A';
3536: }
3537: }
3538:
3539: if (strcmp(protocole_socket, "ipv4") == 0)
3540: {
3541: protocole_socket[2] = d_code_fin_chaine;
3542: }
3543:
3544: if ((s_protocole = getprotobyname(protocole_socket)) == NULL)
3545: {
3546: liberation(s_etat_processus, s_objet_argument);
3547:
3548: (*s_etat_processus).erreur_execution =
3549: d_ex_erreur_parametre_fichier;
3550: return;
3551: }
3552:
3553: protocole_numerique = (*s_protocole).p_proto;
3554: }
3555:
3556: if ((s_objet_resultat = allocation(s_etat_processus, SCK))
3557: == NULL)
3558: {
3559: (*s_etat_processus).erreur_systeme =
3560: d_es_allocation_memoire;
3561: return;
3562: }
3563:
3564: if (((*((struct_socket *) (*s_objet_resultat).objet)).format =
3565: allocation(s_etat_processus, LST)) == NULL)
3566: {
3567: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3568: return;
3569: }
3570:
3571: (*((struct_socket *) (*s_objet_resultat).objet)).protection
3572: = protection;
3573: (*(*((struct_socket *) (*s_objet_resultat).objet))
3574: .format).objet = NULL;
3575:
3576: switch(type_socket)
3577: {
3578: case 'S' :
3579: type = SOCK_STREAM;
3580: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
3581: type, "STREAM");
3582: break;
3583:
3584: case 'D' :
3585: type = SOCK_DGRAM;
3586: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
3587: type, "DATAGRAM");
3588: break;
3589:
3590: case 'Q' :
3591: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
3592: type, "SEQUENTIAL DATAGRAM");
3593: type = SOCK_SEQPACKET;
3594: break;
3595:
3596: case 'R' :
3597: type = SOCK_RAW;
3598: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
3599: type, "RAW");
3600: break;
3601:
3602: case 'M' :
3603: type = SOCK_RDM;
3604: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).
3605: type, "ROBUST DATAGRAM");
3606: break;
3607: }
3608:
3609: if ((protection != 'N') && ((type_socket != 'S') &&
3610: (type_socket != 'Q')))
3611: {
3612: liberation(s_etat_processus, s_objet_argument);
3613: liberation(s_etat_processus, s_objet_resultat);
3614:
3615: (*s_etat_processus).erreur_execution =
3616: d_ex_erreur_parametre_fichier;
3617: return;
3618: }
3619:
3620: if (nom == NULL)
3621: {
3622: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
3623: malloc(sizeof(unsigned char))) == NULL)
3624: {
3625: (*s_etat_processus).erreur_systeme =
3626: d_es_allocation_memoire;
3627: return;
3628: }
3629:
3630: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).adresse,
3631: "");
3632: }
3633: else
3634: {
3635: if (((*((struct_socket *) (*s_objet_resultat).objet)).adresse =
3636: malloc((strlen(nom) + 1) * sizeof(unsigned char)))
3637: == NULL)
3638: {
3639: (*s_etat_processus).erreur_systeme =
3640: d_es_allocation_memoire;
3641: return;
3642: }
3643:
3644: strcpy((*((struct_socket *) (*s_objet_resultat).objet)).adresse,
3645: nom);
3646: }
3647:
3648: if (((*((struct_socket *) (*s_objet_resultat).objet))
3649: .adresse_distante = malloc(sizeof(unsigned char))) == NULL)
3650: {
3651: (*s_etat_processus).erreur_systeme =
3652: d_es_allocation_memoire;
3653: return;
3654: }
3655:
3656: strcpy((*((struct_socket *) (*s_objet_resultat).objet))
3657: .adresse_distante, "");
3658:
3659: (*((struct_socket *) (*s_objet_resultat).objet)).localisation =
3660: type_domaine;
3661: (*((struct_socket *) (*s_objet_resultat).objet)).binaire =
3662: format;
3663: (*((struct_socket *) (*s_objet_resultat).objet)).pid =
3664: getpid();
3665: (*((struct_socket *) (*s_objet_resultat).objet)).tid =
3666: pthread_self();
3667: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
3668: = 'Y';
3669: (*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee
3670: = d_faux;
3671:
3672: if (type_domaine == 'L')
3673: { // Socket serveur
3674: if (nom != NULL)
3675: {
3676: /*
3677: * La socket locale est dans l'espace des noms.
3678: */
3679:
3680: if (((*((struct_socket *) (*s_objet_resultat).objet))
3681: .socket = socket(PF_UNIX, type,
3682: protocole_numerique)) == -1)
3683: {
3684: liberation(s_etat_processus, s_objet_argument);
3685: liberation(s_etat_processus, s_objet_resultat);
3686:
3687: (*s_etat_processus).erreur_execution =
3688: d_ex_erreur_acces_fichier;
3689: return;
3690: }
3691:
3692: (*((struct_socket *) (*s_objet_resultat).objet)).domaine
3693: = PF_UNIX;
3694: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
3695: = 'Y';
3696:
3697: socket_unix.sun_family = AF_UNIX;
3698:
3699: pointeur = (*((struct_socket *)
3700: (*s_objet_resultat).objet)).adresse;
3701:
3702: while((*pointeur) == d_code_espace)
3703: {
3704: pointeur++;
3705: }
3706:
3707: strncpy(socket_unix.sun_path, pointeur, 108);
3708: socket_unix.sun_path[108 - 1] = d_code_fin_chaine;
3709:
3710: if (options_socket() == d_erreur)
3711: {
3712: liberation(s_etat_processus, s_objet_argument);
3713: liberation(s_etat_processus, s_objet_resultat);
3714:
3715: return;
3716: }
3717:
3718: if (bind((*((struct_socket *) (*s_objet_resultat).objet))
3719: .socket, (const struct sockaddr *) &socket_unix,
3720: sizeof(socket_unix)) != 0)
3721: {
3722: liberation(s_etat_processus, s_objet_argument);
3723: liberation(s_etat_processus, s_objet_resultat);
3724:
3725: (*s_etat_processus).erreur_execution =
3726: d_ex_erreur_acces_fichier;
3727: return;
3728: }
3729: }
3730: else
3731: {
3732: /*
3733: * La socket est une socket réseau locale. L'adresse
3734: * passée en argument est l'adresse sur laquelle
3735: * cette socket est à l'écoute.
3736: */
3737:
3738: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
3739: = 'N';
3740:
3741: if (hote != NULL)
3742: { // Hôte défini par un nom
3743: resolution = NULL;
3744:
3745: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
3746: {
3747: liberation(s_etat_processus, s_objet_argument);
3748: liberation(s_etat_processus, s_objet_resultat);
3749:
3750: if (resolution != NULL)
3751: {
3752: freeaddrinfo(resolution);
3753: }
3754:
3755: (*s_etat_processus).erreur_execution =
3756: d_ex_erreur_acces_fichier;
3757: return;
3758: }
3759:
3760: if (strcmp(protocole, "IPV4") == 0)
3761: { // Accès en IPv4
3762: resolution_courante = resolution;
3763:
3764: while(resolution_courante != NULL)
3765: {
3766: if ((*resolution_courante).ai_family ==
3767: AF_INET)
3768: {
3769: break;
3770: }
3771:
3772: resolution_courante = (*resolution_courante)
3773: .ai_next;
3774: }
3775:
3776: if (resolution_courante == NULL)
3777: {
3778: liberation(s_etat_processus, s_objet_argument);
3779: liberation(s_etat_processus, s_objet_resultat);
3780:
3781: freeaddrinfo(resolution);
3782:
3783: (*s_etat_processus).erreur_execution =
3784: d_ex_erreur_acces_fichier;
3785: return;
3786: }
3787:
3788: if (((*((struct_socket *)
3789: (*s_objet_resultat).objet))
3790: .socket = socket(PF_INET, type,
3791: protocole_numerique)) == -1)
3792: {
3793: liberation(s_etat_processus, s_objet_argument);
3794: liberation(s_etat_processus, s_objet_resultat);
3795:
3796: freeaddrinfo(resolution);
3797:
3798: (*s_etat_processus).erreur_execution =
3799: d_ex_erreur_acces_fichier;
3800: return;
3801: }
3802:
3803: (*((struct_socket *) (*s_objet_resultat).objet))
3804: .domaine = PF_INET;
3805:
3806: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
3807: socket_ipv4.sin_family = AF_INET;
3808: socket_ipv4.sin_port = htons((uint16_t) port);
3809: socket_ipv4.sin_addr.s_addr =
3810: (*((struct sockaddr_in *)
3811: (*resolution_courante).ai_addr))
3812: .sin_addr.s_addr;
3813:
3814: if (options_socket() == d_erreur)
3815: {
3816: liberation(s_etat_processus, s_objet_argument);
3817: liberation(s_etat_processus, s_objet_resultat);
3818:
3819: freeaddrinfo(resolution);
3820: return;
3821: }
3822:
3823: if (bind((*((struct_socket *) (*s_objet_resultat)
3824: .objet)).socket, (const struct sockaddr *)
3825: &socket_ipv4, sizeof(socket_ipv4)) != 0)
3826: {
3827: liberation(s_etat_processus, s_objet_argument);
3828: liberation(s_etat_processus, s_objet_resultat);
3829:
3830: freeaddrinfo(resolution);
3831:
3832: (*s_etat_processus).erreur_execution =
3833: d_ex_erreur_acces_fichier;
3834: return;
3835: }
3836:
3837: if (((*((struct_socket *) (*s_objet_resultat)
3838: .objet)).adresse = malloc(22 *
3839: sizeof(unsigned char))) == NULL)
3840: {
3841: (*s_etat_processus).erreur_systeme =
3842: d_es_allocation_memoire;
3843: return;
3844: }
3845:
3846: sprintf((*((struct_socket *) (*s_objet_resultat)
3847: .objet)).adresse, "%d.%d.%d.%d",
3848: (ntohl((*((struct sockaddr_in *)
3849: (*resolution_courante).ai_addr)).sin_addr
3850: .s_addr) >> 24) & 0xFF,
3851: (ntohl((*((struct sockaddr_in *)
3852: (*resolution_courante).ai_addr)).sin_addr
3853: .s_addr) >> 16) & 0xFF,
3854: (ntohl((*((struct sockaddr_in *)
3855: (*resolution_courante).ai_addr)).sin_addr
3856: .s_addr) >> 8) & 0xFF,
3857: ntohl((*((struct sockaddr_in *)
3858: (*resolution_courante).ai_addr)).sin_addr
3859: .s_addr) & 0xFF);
3860: }
3861: else
3862: { // Accès en IPv6
3863: resolution_courante = resolution;
3864:
3865: while(resolution_courante != NULL)
3866: {
3867: if ((*resolution_courante).ai_family ==
3868: AF_INET6)
3869: {
3870: break;
3871: }
3872:
3873: resolution_courante = (*resolution_courante)
3874: .ai_next;
3875: }
3876:
3877: if (resolution_courante == NULL)
3878: {
3879: liberation(s_etat_processus, s_objet_argument);
3880: liberation(s_etat_processus, s_objet_resultat);
3881:
3882: freeaddrinfo(resolution);
3883:
3884: (*s_etat_processus).erreur_execution =
3885: d_ex_erreur_acces_fichier;
3886: return;
3887: }
3888:
3889: if (((*((struct_socket *)
3890: (*s_objet_resultat).objet))
3891: .socket = socket(PF_INET6, type,
3892: protocole_numerique)) == -1)
3893: {
3894: liberation(s_etat_processus, s_objet_argument);
3895: liberation(s_etat_processus, s_objet_resultat);
3896:
3897: freeaddrinfo(resolution);
3898:
3899: (*s_etat_processus).erreur_execution =
3900: d_ex_erreur_acces_fichier;
3901: return;
3902: }
3903:
3904: (*((struct_socket *) (*s_objet_resultat).objet))
3905: .domaine = PF_INET6;
3906:
3907: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
3908: socket_ipv6.sin6_family = AF_INET6;
3909: socket_ipv6.sin6_port = htons((uint16_t) port);
3910:
3911: for(i = 0; i < 16;
3912: socket_ipv6.sin6_addr.s6_addr[i] =
3913: (*((struct sockaddr_in6 *)
3914: (*resolution_courante).ai_addr))
3915: .sin6_addr.s6_addr[i], i++);
3916:
3917: if (options_socket() == d_erreur)
3918: {
3919: liberation(s_etat_processus, s_objet_argument);
3920: liberation(s_etat_processus, s_objet_resultat);
3921:
3922: freeaddrinfo(resolution);
3923: return;
3924: }
3925:
3926: if (bind((*((struct_socket *) (*s_objet_resultat)
3927: .objet)).socket, (const struct sockaddr *)
3928: &socket_ipv6, sizeof(socket_ipv6)) != 0)
3929: {
3930: liberation(s_etat_processus, s_objet_argument);
3931: liberation(s_etat_processus, s_objet_resultat);
3932:
3933: freeaddrinfo(resolution);
3934:
3935: (*s_etat_processus).erreur_execution =
3936: d_ex_erreur_acces_fichier;
3937: return;
3938: }
3939:
3940: if (((*((struct_socket *) (*s_objet_resultat)
3941: .objet)).adresse = malloc(55 *
3942: sizeof(unsigned char))) == NULL)
3943: {
3944: (*s_etat_processus).erreur_systeme =
3945: d_es_allocation_memoire;
3946: return;
3947: }
3948:
3949: for(i = 0; i < 16; i++)
3950: {
3951: sprintf((*((struct_socket *) (*s_objet_resultat)
3952: .objet)).adresse,
3953: (i == 0) ? "%s%X" : "%s:%X",
3954: (*((struct_socket *) (*s_objet_resultat)
3955: .objet)).adresse,
3956: (*((struct sockaddr_in6 *)
3957: (*resolution_courante).ai_addr))
3958: .sin6_addr.s6_addr[i]);
3959: }
3960: }
3961:
3962: freeaddrinfo(resolution);
3963:
3964: sprintf((*((struct_socket *) (*s_objet_resultat)
3965: .objet)).adresse, "%s(%u)",
3966: (*((struct_socket *) (*s_objet_resultat)
3967: .objet)).adresse, (unsigned int) port);
3968: }
3969: else
3970: { // Hôte défini par une adresse
3971: if (strcmp(protocole, "IPV4") == 0)
3972: { // Accès en IPv4
3973: if (((*((struct_socket *) (*s_objet_resultat)
3974: .objet)).adresse = malloc(22 *
3975: sizeof(unsigned char))) == NULL)
3976: {
3977: (*s_etat_processus).erreur_systeme =
3978: d_es_allocation_memoire;
3979: return;
3980: }
3981:
3982: (*((struct_socket *) (*s_objet_resultat).objet))
3983: .adresse[0] = d_code_fin_chaine;
3984:
3985: for(i = 0; i < 4; i++)
3986: {
3987: sprintf((*((struct_socket *) (*s_objet_resultat)
3988: .objet)).adresse,
3989: (i == 0) ? "%s%d" : "%s.%d",
3990: (*((struct_socket *) (*s_objet_resultat)
3991: .objet)).adresse, (int) adresse[i]);
3992: }
3993:
3994: sprintf((*((struct_socket *) (*s_objet_resultat)
3995: .objet)).adresse, "%s(%u)",
3996: (*((struct_socket *) (*s_objet_resultat)
3997: .objet)).adresse, (unsigned int) port);
3998:
3999: if (((*((struct_socket *)
4000: (*s_objet_resultat).objet))
4001: .socket = socket(PF_INET, type,
4002: protocole_numerique)) == -1)
4003: {
4004: liberation(s_etat_processus, s_objet_argument);
4005: liberation(s_etat_processus, s_objet_resultat);
4006:
4007: (*s_etat_processus).erreur_execution =
4008: d_ex_erreur_acces_fichier;
4009: return;
4010: }
4011:
4012: (*((struct_socket *) (*s_objet_resultat).objet))
4013: .domaine = PF_INET;
4014:
4015: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4016: socket_ipv4.sin_family = AF_INET;
4017: socket_ipv4.sin_port = htons((uint16_t) port);
4018:
4019: adresse_ipv4 = 0;
4020: for(i = 0; i < 4; adresse_ipv4 =
4021: (256 * adresse_ipv4) + adresse[i++]);
4022:
4023: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
4024:
4025: if (options_socket() == d_erreur)
4026: {
4027: liberation(s_etat_processus, s_objet_argument);
4028: liberation(s_etat_processus, s_objet_resultat);
4029:
4030: return;
4031: }
4032:
4033: if (bind((*((struct_socket *) (*s_objet_resultat)
4034: .objet)).socket, (const struct sockaddr *)
4035: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4036: {
4037: liberation(s_etat_processus, s_objet_argument);
4038: liberation(s_etat_processus, s_objet_resultat);
4039:
4040: (*s_etat_processus).erreur_execution =
4041: d_ex_erreur_acces_fichier;
4042: return;
4043: }
4044: }
4045: else
4046: { // Accès en IPv6
4047: if (((*((struct_socket *) (*s_objet_resultat)
4048: .objet)).adresse = malloc(55 *
4049: sizeof(unsigned char))) == NULL)
4050: {
4051: (*s_etat_processus).erreur_systeme =
4052: d_es_allocation_memoire;
4053: return;
4054: }
4055:
4056: (*((struct_socket *) (*s_objet_resultat).objet))
4057: .adresse[0] = d_code_fin_chaine;
4058:
4059: for(i = 0; i < 16; i++)
4060: {
4061: sprintf((*((struct_socket *) (*s_objet_resultat)
4062: .objet)).adresse,
4063: (i == 0) ? "%s%X" : "%s:%X",
4064: (*((struct_socket *) (*s_objet_resultat)
4065: .objet)).adresse, (unsigned int)
4066: adresse[i]);
4067: }
4068:
4069: sprintf((*((struct_socket *) (*s_objet_resultat)
4070: .objet)).adresse, "%s(%u)",
4071: (*((struct_socket *) (*s_objet_resultat)
4072: .objet)).adresse, (unsigned int) port);
4073:
4074: if (((*((struct_socket *)
4075: (*s_objet_resultat).objet))
4076: .socket = socket(PF_INET6, type,
4077: protocole_numerique)) == -1)
4078: {
4079: liberation(s_etat_processus, s_objet_argument);
4080: liberation(s_etat_processus, s_objet_resultat);
4081:
4082: (*s_etat_processus).erreur_execution =
4083: d_ex_erreur_acces_fichier;
4084: return;
4085: }
4086:
4087: (*((struct_socket *) (*s_objet_resultat).objet))
4088: .domaine = PF_INET6;
4089:
4090: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4091: socket_ipv6.sin6_family = AF_INET6;
4092: socket_ipv6.sin6_port = htons((uint16_t) port);
4093:
4094: for(i = 0; i < 16;
4095: socket_ipv6.sin6_addr.s6_addr[i] =
4096: (unsigned char) (adresse[i]), i++);
4097:
4098: if (options_socket() == d_erreur)
4099: {
4100: liberation(s_etat_processus, s_objet_argument);
4101: liberation(s_etat_processus, s_objet_resultat);
4102:
4103: return;
4104: }
4105:
4106: if (bind((*((struct_socket *) (*s_objet_resultat)
4107: .objet)).socket, (const struct sockaddr *)
4108: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4109: {
4110: liberation(s_etat_processus, s_objet_argument);
4111: liberation(s_etat_processus, s_objet_resultat);
4112:
4113: (*s_etat_processus).erreur_execution =
4114: d_ex_erreur_acces_fichier;
4115: return;
4116: }
4117: }
4118: }
4119:
4120: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4121: = 'N';
4122: }
4123:
4124: if ((type_socket == 'S') || (type_socket == 'Q'))
4125: {
4126: if (listen((*((struct_socket *) (*s_objet_resultat).objet))
4127: .socket, (int) nombre_maximal_connexions) != 0)
4128: {
4129: liberation(s_etat_processus, s_objet_argument);
4130: liberation(s_etat_processus, s_objet_resultat);
4131:
4132: (*s_etat_processus).erreur_execution =
4133: d_ex_erreur_acces_fichier;
4134: return;
4135: }
4136:
4137: (*((struct_socket *) (*s_objet_resultat).objet))
4138: .socket_connectee = d_vrai;
4139:
4140: if (protection == 'R')
4141: { // WRITEONLY
4142: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4143: .objet)).socket, SHUT_RD) != 0)
4144: {
4145: liberation(s_etat_processus, s_objet_argument);
4146: liberation(s_etat_processus, s_objet_resultat);
4147:
4148: (*s_etat_processus).erreur_execution =
4149: d_ex_erreur_acces_fichier;
4150: return;
4151: }
4152: }
4153: else if (protection == 'W')
4154: { // READONLY
4155: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4156: .objet)).socket, SHUT_WR) != 0)
4157: {
4158: liberation(s_etat_processus, s_objet_argument);
4159: liberation(s_etat_processus, s_objet_resultat);
4160:
4161: (*s_etat_processus).erreur_execution =
4162: d_ex_erreur_acces_fichier;
4163: return;
4164: }
4165: }
4166: else
4167: { // READWRITE
4168: }
4169: }
4170: }
4171: else
4172: { // Socket cliente
4173: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4174: = 'N';
4175:
4176: /*
4177: * Dans le cas où la socket n'est pas connectée, on
4178: * ne peut utiliser ni "NAME", ni "HOST", ni "PORT",
4179: * et encore moins spécifier une adresse. En effet, la cible
4180: * est défini par la commande TARGET.
4181: */
4182:
4183: if ((type_socket != 'S') && (type_socket != 'Q'))
4184: {
4185: if ((presence_port == d_vrai) || (hote != NULL) ||
4186: (nom != NULL) || (type_adresse != ' '))
4187: {
4188: liberation(s_etat_processus, s_objet_argument);
4189: liberation(s_etat_processus, s_objet_resultat);
4190:
4191: (*s_etat_processus).erreur_execution =
4192: d_ex_erreur_parametre_fichier;
4193: return;
4194: }
4195: }
4196:
4197: if (nom != NULL)
4198: {
4199: /*
4200: * La socket est dans l'espace des noms.
4201: */
4202:
4203: if (((*((struct_socket *) (*s_objet_resultat).objet))
4204: .socket = socket(PF_UNIX, type,
4205: protocole_numerique)) == -1)
4206: {
4207: liberation(s_etat_processus, s_objet_argument);
4208: liberation(s_etat_processus, s_objet_resultat);
4209:
4210: (*s_etat_processus).erreur_execution =
4211: d_ex_erreur_acces_fichier;
4212: return;
4213: }
4214:
4215: (*((struct_socket *) (*s_objet_resultat).objet))
4216: .domaine = PF_UNIX;
4217:
4218: socket_unix.sun_family = AF_UNIX;
4219: strncpy(socket_unix.sun_path, (*((struct_socket *)
4220: (*s_objet_resultat).objet)).adresse, 108);
4221: socket_unix.sun_path[108 - 1] = d_code_fin_chaine;
4222:
4223: if ((type_socket == 'S') || (type_socket == 'Q'))
4224: {
4225: if (connect((*((struct_socket *) (*s_objet_resultat)
4226: .objet)).socket, (const struct sockaddr *)
4227: &socket_unix, sizeof(socket_unix)) != 0)
4228: {
4229: liberation(s_etat_processus, s_objet_argument);
4230: liberation(s_etat_processus, s_objet_resultat);
4231:
4232: (*s_etat_processus).erreur_execution =
4233: d_ex_erreur_acces_fichier;
4234: return;
4235: }
4236:
4237: (*((struct_socket *) (*s_objet_resultat).objet))
4238: .socket_connectee = d_vrai;
4239: (*((struct_socket *) (*s_objet_resultat).objet))
4240: .socket_en_ecoute = 'N';
4241: }
4242: }
4243: else
4244: {
4245: /*
4246: * La socket est une socket réseau. L'adresse
4247: * passée en argument est l'adresse sur laquelle
4248: * cette socket est à l'écoute.
4249: */
4250:
4251: if (hote != NULL)
4252: { // Hôte défini par un nom
4253: resolution = NULL;
4254:
4255: if (getaddrinfo(hote, NULL, NULL, &resolution) != 0)
4256: {
4257: liberation(s_etat_processus, s_objet_argument);
4258: liberation(s_etat_processus, s_objet_resultat);
4259:
4260: if (resolution != NULL)
4261: {
4262: freeaddrinfo(resolution);
4263: }
4264:
4265: (*s_etat_processus).erreur_execution =
4266: d_ex_erreur_acces_fichier;
4267: return;
4268: }
4269:
4270: if (strcmp(protocole, "IPV4") == 0)
4271: { // Accès en IPv4
4272: resolution_courante = resolution;
4273:
4274: while(resolution_courante != NULL)
4275: {
4276: if ((*resolution_courante).ai_family ==
4277: AF_INET)
4278: {
4279: break;
4280: }
4281:
4282: resolution_courante = (*resolution_courante)
4283: .ai_next;
4284: }
4285:
4286: if (resolution_courante == NULL)
4287: {
4288: liberation(s_etat_processus, s_objet_argument);
4289: liberation(s_etat_processus, s_objet_resultat);
4290:
4291: freeaddrinfo(resolution);
4292:
4293: (*s_etat_processus).erreur_execution =
4294: d_ex_erreur_acces_fichier;
4295: return;
4296: }
4297:
4298: if (((*((struct_socket *)
4299: (*s_objet_resultat).objet))
4300: .socket = socket(PF_INET, type,
4301: protocole_numerique)) == -1)
4302: {
4303: liberation(s_etat_processus, s_objet_argument);
4304: liberation(s_etat_processus, s_objet_resultat);
4305:
4306: freeaddrinfo(resolution);
4307:
4308: (*s_etat_processus).erreur_execution =
4309: d_ex_erreur_acces_fichier;
4310: return;
4311: }
4312:
4313: (*((struct_socket *) (*s_objet_resultat).objet))
4314: .domaine = PF_INET;
4315:
4316: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4317: socket_ipv4.sin_family = AF_INET;
4318: socket_ipv4.sin_port = htons((uint16_t) port);
4319: socket_ipv4.sin_addr.s_addr =
4320: (*((struct sockaddr_in *)
4321: (*resolution_courante).ai_addr))
4322: .sin_addr.s_addr;
4323:
4324: if ((type_socket == 'S') || (type_socket == 'Q'))
4325: {
4326: if (connect((*((struct_socket *)
4327: (*s_objet_resultat).objet)).socket,
4328: (const struct sockaddr *)
4329: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4330: {
4331: liberation(s_etat_processus,
4332: s_objet_argument);
4333: liberation(s_etat_processus,
4334: s_objet_resultat);
4335:
4336: freeaddrinfo(resolution);
4337:
4338: (*s_etat_processus).erreur_execution =
4339: d_ex_erreur_acces_fichier;
4340: return;
4341: }
4342:
4343: (*((struct_socket *) (*s_objet_resultat).objet))
4344: .socket_connectee = d_vrai;
4345: (*((struct_socket *) (*s_objet_resultat).objet))
4346: .socket_en_ecoute = 'N';
4347: }
4348:
4349: if (((*((struct_socket *) (*s_objet_resultat)
4350: .objet)).adresse = malloc(22 *
4351: sizeof(unsigned char))) == NULL)
4352: {
4353: (*s_etat_processus).erreur_systeme =
4354: d_es_allocation_memoire;
4355: return;
4356: }
4357:
4358: sprintf((*((struct_socket *) (*s_objet_resultat)
4359: .objet)).adresse, "%d.%d.%d.%d",
4360: (ntohl((*((struct sockaddr_in *)
4361: (*resolution_courante).ai_addr)).sin_addr
4362: .s_addr) >> 24) & 0xFF,
4363: (ntohl((*((struct sockaddr_in *)
4364: (*resolution_courante).ai_addr)).sin_addr
4365: .s_addr) >> 16) & 0xFF,
4366: (ntohl((*((struct sockaddr_in *)
4367: (*resolution_courante).ai_addr)).sin_addr
4368: .s_addr) >> 8) & 0xFF,
4369: ntohl((*((struct sockaddr_in *)
4370: (*resolution_courante).ai_addr)).sin_addr
4371: .s_addr) & 0xFF);
4372: }
4373: else
4374: { // Accès en IPv6
4375: resolution_courante = resolution;
4376:
4377: while(resolution_courante != NULL)
4378: {
4379: if ((*resolution_courante).ai_family ==
4380: AF_INET6)
4381: {
4382: break;
4383: }
4384:
4385: resolution_courante = (*resolution_courante)
4386: .ai_next;
4387: }
4388:
4389: if (resolution_courante == NULL)
4390: {
4391: liberation(s_etat_processus, s_objet_argument);
4392: liberation(s_etat_processus, s_objet_resultat);
4393:
4394: freeaddrinfo(resolution);
4395:
4396: (*s_etat_processus).erreur_execution =
4397: d_ex_erreur_acces_fichier;
4398: return;
4399: }
4400:
4401: if (((*((struct_socket *)
4402: (*s_objet_resultat).objet))
4403: .socket = socket(PF_INET6, type,
4404: protocole_numerique)) == -1)
4405: {
4406: liberation(s_etat_processus, s_objet_argument);
4407: liberation(s_etat_processus, s_objet_resultat);
4408:
4409: freeaddrinfo(resolution);
4410:
4411: (*s_etat_processus).erreur_execution =
4412: d_ex_erreur_acces_fichier;
4413: return;
4414: }
4415:
4416: (*((struct_socket *) (*s_objet_resultat).objet))
4417: .domaine = PF_INET6;
4418:
4419: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4420: socket_ipv6.sin6_family = AF_INET6;
4421: socket_ipv6.sin6_port = htons((uint16_t) port);
4422:
4423: for(i = 0; i < 16;
4424: socket_ipv6.sin6_addr.s6_addr[i] =
4425: (*((struct sockaddr_in6 *)
4426: (*resolution_courante).ai_addr))
4427: .sin6_addr.s6_addr[i], i++);
4428:
4429: if ((type_socket == 'S') || (type_socket == 'Q'))
4430: {
4431: if (connect((*((struct_socket *)
4432: (*s_objet_resultat).objet)).socket,
4433: (const struct sockaddr *)
4434: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4435: {
4436: liberation(s_etat_processus,
4437: s_objet_argument);
4438: liberation(s_etat_processus,
4439: s_objet_resultat);
4440:
4441: freeaddrinfo(resolution);
4442:
4443: (*s_etat_processus).erreur_execution =
4444: d_ex_erreur_acces_fichier;
4445: return;
4446: }
4447:
4448: (*((struct_socket *) (*s_objet_resultat).objet))
4449: .socket_connectee = d_vrai;
4450: (*((struct_socket *) (*s_objet_resultat).objet))
4451: .socket_en_ecoute = 'N';
4452: }
4453:
4454: if (((*((struct_socket *) (*s_objet_resultat)
4455: .objet)).adresse = malloc(55 *
4456: sizeof(unsigned char))) == NULL)
4457: {
4458: (*s_etat_processus).erreur_systeme =
4459: d_es_allocation_memoire;
4460: return;
4461: }
4462:
4463: for(i = 0; i < 16; i++)
4464: {
4465: sprintf((*((struct_socket *) (*s_objet_resultat)
4466: .objet)).adresse,
4467: (i == 0) ? "%s%X" : "%s:%X",
4468: (*((struct_socket *) (*s_objet_resultat)
4469: .objet)).adresse,
4470: (*((struct sockaddr_in6 *)
4471: (*resolution_courante).ai_addr))
4472: .sin6_addr.s6_addr[i]);
4473: }
4474: }
4475:
4476: freeaddrinfo(resolution);
4477:
4478: sprintf((*((struct_socket *) (*s_objet_resultat)
4479: .objet)).adresse, "%s(%u)",
4480: (*((struct_socket *) (*s_objet_resultat)
4481: .objet)).adresse, (unsigned int) port);
4482: }
4483: else
4484: { // Hôte défini par une adresse
4485: if (strcmp(protocole, "IPV4") == 0)
4486: { // Accès en IPv4
4487: if (type_adresse == '4')
4488: {
4489: if (((*((struct_socket *) (*s_objet_resultat)
4490: .objet)).adresse = malloc(22 *
4491: sizeof(unsigned char))) == NULL)
4492: {
4493: (*s_etat_processus).erreur_systeme =
4494: d_es_allocation_memoire;
4495: return;
4496: }
4497:
4498: (*((struct_socket *) (*s_objet_resultat).objet))
4499: .adresse[0] = d_code_fin_chaine;
4500:
4501: for(i = 0; i < 4; i++)
4502: {
4503: sprintf((*((struct_socket *)
4504: (*s_objet_resultat).objet)).adresse,
4505: (i == 0) ? "%s%d" : "%s.%d",
4506: (*((struct_socket *)
4507: (*s_objet_resultat)
4508: .objet)).adresse, (int) adresse[i]);
4509: }
4510:
4511: sprintf((*((struct_socket *) (*s_objet_resultat)
4512: .objet)).adresse, "%s(%u)",
4513: (*((struct_socket *) (*s_objet_resultat)
4514: .objet)).adresse, (unsigned int) port);
4515: }
4516: else
4517: {
4518: if (((*((struct_socket *) (*s_objet_resultat)
4519: .objet)).adresse = malloc(
4520: sizeof(unsigned char))) == NULL)
4521: {
4522: (*s_etat_processus).erreur_systeme =
4523: d_es_allocation_memoire;
4524: return;
4525: }
4526:
4527: (*((struct_socket *) (*s_objet_resultat).objet))
4528: .adresse[0] = d_code_fin_chaine;
4529: }
4530:
4531: if (((*((struct_socket *)
4532: (*s_objet_resultat).objet))
4533: .socket = socket(PF_INET, type,
4534: protocole_numerique)) == -1)
4535: {
4536: liberation(s_etat_processus, s_objet_argument);
4537: liberation(s_etat_processus, s_objet_resultat);
4538:
4539: (*s_etat_processus).erreur_execution =
4540: d_ex_erreur_acces_fichier;
4541: return;
4542: }
4543:
4544: (*((struct_socket *) (*s_objet_resultat).objet))
4545: .domaine = PF_INET;
4546:
4547: memset(&socket_ipv4, 0, sizeof(socket_ipv4));
4548: socket_ipv4.sin_family = AF_INET;
4549: socket_ipv4.sin_port = htons((uint16_t) port);
4550:
4551: adresse_ipv4 = 0;
4552: for(i = 0; i < 4; adresse_ipv4 =
4553: (256 * adresse_ipv4) + adresse[i++]);
4554:
4555: socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
4556:
4557: if ((type_socket == 'S') || (type_socket == 'Q'))
4558: {
4559: if (connect((*((struct_socket *)
4560: (*s_objet_resultat).objet)).socket,
4561: (const struct sockaddr *)
4562: &socket_ipv4, sizeof(socket_ipv4)) != 0)
4563: {
4564: liberation(s_etat_processus,
4565: s_objet_argument);
4566: liberation(s_etat_processus,
4567: s_objet_resultat);
4568:
4569: (*s_etat_processus).erreur_execution =
4570: d_ex_erreur_acces_fichier;
4571: return;
4572: }
4573:
4574: (*((struct_socket *) (*s_objet_resultat).objet))
4575: .socket_connectee = d_vrai;
4576: (*((struct_socket *) (*s_objet_resultat).objet))
4577: .socket_en_ecoute = 'N';
4578: }
4579: }
4580: else if (strcmp(protocole, "IPV6") == 0)
4581: { // Accès en IPv6
4582: if (type_adresse == '6')
4583: {
4584: if (((*((struct_socket *) (*s_objet_resultat)
4585: .objet)).adresse = malloc(55 *
4586: sizeof(unsigned char))) == NULL)
4587: {
4588: (*s_etat_processus).erreur_systeme =
4589: d_es_allocation_memoire;
4590: return;
4591: }
4592:
4593: (*((struct_socket *) (*s_objet_resultat).objet))
4594: .adresse[0] = d_code_fin_chaine;
4595:
4596: for(i = 0; i < 16; i++)
4597: {
4598: sprintf((*((struct_socket *)
4599: (*s_objet_resultat).objet)).adresse,
4600: (i == 0) ? "%s%X" : "%s:%X",
4601: (*((struct_socket *)
4602: (*s_objet_resultat)
4603: .objet)).adresse, (unsigned int)
4604: adresse[i]);
4605: }
4606:
4607: sprintf((*((struct_socket *) (*s_objet_resultat)
4608: .objet)).adresse, "%s(%u)",
4609: (*((struct_socket *) (*s_objet_resultat)
4610: .objet)).adresse, (unsigned int) port);
4611: }
4612: else
4613: {
4614: if (((*((struct_socket *) (*s_objet_resultat)
4615: .objet)).adresse = malloc(
4616: sizeof(unsigned char))) == NULL)
4617: {
4618: (*s_etat_processus).erreur_systeme =
4619: d_es_allocation_memoire;
4620: return;
4621: }
4622:
4623: (*((struct_socket *) (*s_objet_resultat).objet))
4624: .adresse[0] = d_code_fin_chaine;
4625: }
4626:
4627: if (((*((struct_socket *)
4628: (*s_objet_resultat).objet))
4629: .socket = socket(PF_INET6, type,
4630: protocole_numerique)) == -1)
4631: {
4632: liberation(s_etat_processus, s_objet_argument);
4633: liberation(s_etat_processus, s_objet_resultat);
4634:
4635: (*s_etat_processus).erreur_execution =
4636: d_ex_erreur_acces_fichier;
4637: return;
4638: }
4639:
4640: (*((struct_socket *) (*s_objet_resultat).objet))
4641: .domaine = PF_INET6;
4642:
4643: memset(&socket_ipv6, 0, sizeof(socket_ipv6));
4644: socket_ipv6.sin6_family = AF_INET6;
4645: socket_ipv6.sin6_port = htons((uint16_t) port);
4646:
4647: for(i = 0; i < 16;
4648: socket_ipv6.sin6_addr.s6_addr[i] =
4649: (unsigned char) (adresse[i]), i++);
4650:
4651: if ((type_socket == 'S') || (type_socket == 'Q'))
4652: {
4653: if (connect((*((struct_socket *)
4654: (*s_objet_resultat).objet)).socket,
4655: (const struct sockaddr *)
4656: &socket_ipv6, sizeof(socket_ipv6)) != 0)
4657: {
4658: liberation(s_etat_processus,
4659: s_objet_argument);
4660: liberation(s_etat_processus,
4661: s_objet_resultat);
4662:
4663: (*s_etat_processus).erreur_execution =
4664: d_ex_erreur_acces_fichier;
4665: return;
4666: }
4667:
4668: (*((struct_socket *) (*s_objet_resultat).objet))
4669: .socket_connectee = d_vrai;
4670: (*((struct_socket *) (*s_objet_resultat).objet))
4671: .socket_en_ecoute = 'N';
4672: }
4673: }
4674: else
4675: { // Socket UNIX
4676: if (((*((struct_socket *) (*s_objet_resultat)
4677: .objet)).adresse = malloc(
4678: sizeof(unsigned char))) == NULL)
4679: {
4680: (*s_etat_processus).erreur_systeme =
4681: d_es_allocation_memoire;
4682: return;
4683: }
4684:
4685: (*((struct_socket *) (*s_objet_resultat).objet))
4686: .adresse[0] = d_code_fin_chaine;
4687:
4688: if (((*((struct_socket *)
4689: (*s_objet_resultat).objet))
4690: .socket = socket(PF_UNIX, type,
4691: protocole_numerique)) == -1)
4692: {
4693: liberation(s_etat_processus, s_objet_argument);
4694: liberation(s_etat_processus, s_objet_resultat);
4695:
4696: (*s_etat_processus).erreur_execution =
4697: d_ex_erreur_acces_fichier;
4698: return;
4699: }
4700: }
4701: }
4702:
4703: (*((struct_socket *) (*s_objet_resultat).objet)).effacement
4704: = 'N';
4705: }
4706:
4707: if ((type_socket == 'S') || (type_socket == 'Q'))
4708: {
4709: if (protection == 'R')
4710: { // WRITEONLY
4711: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4712: .objet)).socket, SHUT_RD) != 0)
4713: {
4714: liberation(s_etat_processus, s_objet_argument);
4715: liberation(s_etat_processus, s_objet_resultat);
4716:
4717: (*s_etat_processus).erreur_execution =
4718: d_ex_erreur_acces_fichier;
4719: return;
4720: }
4721: }
4722: else if (protection == 'W')
4723: { // READONLY
4724: if (shutdown((*((struct_socket *) (*s_objet_resultat)
4725: .objet)).socket, SHUT_WR) != 0)
4726: {
4727: liberation(s_etat_processus, s_objet_argument);
4728: liberation(s_etat_processus, s_objet_resultat);
4729:
4730: (*s_etat_processus).erreur_execution =
4731: d_ex_erreur_acces_fichier;
4732: return;
4733: }
4734: }
4735: else
4736: { // READWRITE
4737: }
4738: }
4739: }
4740:
4741: /*
4742: * Gestion de la liste des sockets ouvertes
4743: */
4744:
4745: l_element_courant = (*s_etat_processus).s_sockets;
4746:
4747: if (l_element_courant == NULL)
4748: {
4749: if (((*s_etat_processus).s_sockets =
4750: allocation_maillon(s_etat_processus)) == NULL)
4751: {
4752: (*s_etat_processus).erreur_systeme =
4753: d_es_allocation_memoire;
4754: return;
4755: }
4756:
4757: (*(*s_etat_processus).s_sockets).suivant = NULL;
4758: l_element_courant = (*s_etat_processus).s_sockets;
4759: }
4760: else
4761: {
4762: /*
4763: * Ajout d'un élément à la fin de la liste chaînée
4764: */
4765:
4766: while((*l_element_courant).suivant != NULL)
4767: {
4768: l_element_courant = (*l_element_courant).suivant;
4769: }
4770:
4771: if (((*l_element_courant).suivant =
4772: allocation_maillon(s_etat_processus)) == NULL)
4773: {
4774: (*s_etat_processus).erreur_systeme =
4775: d_es_allocation_memoire;
4776: return;
4777: }
4778:
4779: l_element_courant = (*l_element_courant).suivant;
4780: (*l_element_courant).suivant = NULL;
4781: }
4782:
4783: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
4784: s_objet_resultat, 'O')) == NULL)
4785: {
4786: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4787: return;
4788: }
4789: }
4790: else
4791: {
4792: liberation(s_etat_processus, s_objet_argument);
4793:
4794: (*s_etat_processus).erreur_execution =
4795: d_ex_erreur_parametre_fichier;
4796: return;
4797: }
4798: }
4799: else if ((*s_objet_argument).type == CHN)
4800: {
4801: if ((s_objet_resultat = allocation(s_etat_processus, SPH)) == NULL)
4802: {
4803: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4804: return;
4805: }
4806:
4807: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).nom =
4808: malloc((strlen((unsigned char *) (*s_objet_argument).objet)
4809: + 1) *sizeof(unsigned char))) == NULL)
4810: {
4811: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4812: return;
4813: }
4814:
4815: strcpy((*((struct_semaphore *) (*s_objet_resultat).objet)).nom,
4816: (unsigned char *) (*s_objet_argument).objet);
4817:
4818: if (((*((struct_semaphore *) (*s_objet_resultat).objet)).semaphore =
4819: sem_open((*((struct_semaphore *) (*s_objet_resultat).objet))
4820: .nom, 0)) == SEM_FAILED)
4821: {
4822: if (errno == ENOMEM)
4823: {
4824: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4825: return;
4826: }
4827:
4828: (*s_etat_processus).erreur_execution = d_ex_semaphore;
4829:
4830: liberation(s_etat_processus, s_objet_argument);
4831: liberation(s_etat_processus, s_objet_resultat);
4832: return;
4833: }
4834: }
4835: else
4836: {
4837: liberation(s_etat_processus, s_objet_argument);
4838:
4839: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
4840: return;
4841: }
4842:
4843: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
4844: s_objet_resultat) == d_erreur)
4845: {
4846: return;
4847: }
4848:
4849: return;
4850: }
4851:
4852: // 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