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