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