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