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