![]() ![]() | ![]() |
Modification des paramètres du port série.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.32 4: Copyright (C) 1989-2020 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 'r->b' 29: ================================================================================ 30: Entrées : pointeur sur une structure struct_processus 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_r_vers_b(struct_processus *s_etat_processus) 40: { 41: struct_objet *s_objet_argument; 42: struct_objet *s_objet_resultat; 43: 44: (*s_etat_processus).erreur_execution = d_ex; 45: 46: if ((*s_etat_processus).affichage_arguments == 'Y') 47: { 48: printf("\n R->B "); 49: 50: if ((*s_etat_processus).langue == 'F') 51: { 52: printf("(réel vers binaire)\n\n"); 53: } 54: else 55: { 56: printf("(real to binary)\n\n"); 57: } 58: 59: printf(" 1: %s\n", d_INT); 60: printf("-> 1: %s\n", d_BIN); 61: 62: return; 63: } 64: else if ((*s_etat_processus).test_instruction == 'Y') 65: { 66: (*s_etat_processus).nombre_arguments = -1; 67: return; 68: } 69: 70: if (test_cfsf(s_etat_processus, 31) == d_vrai) 71: { 72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 73: { 74: return; 75: } 76: } 77: 78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 79: &s_objet_argument) == d_erreur) 80: { 81: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 82: return; 83: } 84: 85: if ((*s_objet_argument).type == INT) 86: { 87: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL) 88: { 89: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 90: return; 91: } 92: 93: if ((*((integer8 *) (*s_objet_argument).objet)) < 0) 94: { 95: (*((logical8 *) (*s_objet_resultat).objet)) = 0; 96: } 97: else 98: { 99: (*((logical8 *) (*s_objet_resultat).objet)) = (logical8) 100: (*((integer8 *) (*s_objet_argument).objet)); 101: } 102: } 103: else 104: { 105: liberation(s_etat_processus, s_objet_argument); 106: 107: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 108: return; 109: } 110: 111: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 112: s_objet_resultat) == d_erreur) 113: { 114: return; 115: } 116: 117: liberation(s_etat_processus, s_objet_argument); 118: return; 119: } 120: 121: 122: /* 123: ================================================================================ 124: Fonction 'rl' 125: ================================================================================ 126: Entrées : pointeur sur une structure struct_processus 127: -------------------------------------------------------------------------------- 128: Sorties : 129: -------------------------------------------------------------------------------- 130: Effets de bord : néant 131: ================================================================================ 132: */ 133: 134: void 135: instruction_rl(struct_processus *s_etat_processus) 136: { 137: logical8 masque; 138: logical8 tampon; 139: 140: struct_objet *s_copie; 141: struct_objet *s_objet; 142: 143: unsigned long i; 144: unsigned long j; 145: unsigned long longueur; 146: 147: (*s_etat_processus).erreur_execution = d_ex; 148: 149: if ((*s_etat_processus).affichage_arguments == 'Y') 150: { 151: printf("\n RL "); 152: 153: if ((*s_etat_processus).langue == 'F') 154: { 155: printf("(rotation à gauche)\n\n"); 156: } 157: else 158: { 159: printf("(rotate left)\n\n"); 160: } 161: 162: printf(" 1: %s\n", d_BIN); 163: printf("-> 1: %s\n", d_BIN); 164: 165: return; 166: } 167: else if ((*s_etat_processus).test_instruction == 'Y') 168: { 169: (*s_etat_processus).nombre_arguments = -1; 170: return; 171: } 172: 173: if (test_cfsf(s_etat_processus, 31) == d_vrai) 174: { 175: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 176: { 177: return; 178: } 179: } 180: 181: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 182: &s_objet) == d_erreur) 183: { 184: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 185: return; 186: } 187: 188: if ((*s_objet).type == BIN) 189: { 190: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL) 191: { 192: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 193: return; 194: } 195: 196: longueur = 1; 197: j = 1; 198: 199: for(i = 37; i <= 42; i++) 200: { 201: longueur += (test_cfsf(s_etat_processus, (unsigned char) i) 202: == d_vrai) ? j : 0; 203: j *= 2; 204: } 205: 206: tampon = (*((logical8 *) (*s_copie).objet)); 207: masque = ((logical8) 1) << (longueur - 1); 208: 209: if ((tampon & masque) == 0) 210: { 211: tampon <<= 1; 212: } 213: else 214: { 215: tampon <<= 1; 216: tampon |= (logical8) 1; 217: } 218: 219: for(masque = 0, i = 0; i < longueur; i++) 220: { 221: masque <<= 1; 222: masque |= (logical8) 1; 223: } 224: 225: tampon &= masque; 226: (*((logical8 *) (*s_copie).objet)) = tampon; 227: 228: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 229: s_copie) == d_erreur) 230: { 231: return; 232: } 233: } 234: else 235: { 236: liberation(s_etat_processus, s_objet); 237: 238: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 239: return; 240: } 241: 242: liberation(s_etat_processus, s_objet); 243: 244: return; 245: } 246: 247: 248: /* 249: ================================================================================ 250: Fonction 'rlb' 251: ================================================================================ 252: Entrées : pointeur sur une structure struct_processus 253: -------------------------------------------------------------------------------- 254: Sorties : 255: -------------------------------------------------------------------------------- 256: Effets de bord : néant 257: ================================================================================ 258: */ 259: 260: void 261: instruction_rlb(struct_processus *s_etat_processus) 262: { 263: struct_liste_chainee *l_base_pile; 264: 265: unsigned long i; 266: 267: (*s_etat_processus).erreur_execution = d_ex; 268: 269: if ((*s_etat_processus).affichage_arguments == 'Y') 270: { 271: printf("\n RLB "); 272: 273: if ((*s_etat_processus).langue == 'F') 274: { 275: printf("(rotation d'un octet vers la gauche)\n\n"); 276: } 277: else 278: { 279: printf("(rotate left byte)\n\n"); 280: } 281: 282: printf(" 1: %s\n", d_BIN); 283: printf("-> 1: %s\n", d_BIN); 284: 285: return; 286: } 287: else if ((*s_etat_processus).test_instruction == 'Y') 288: { 289: (*s_etat_processus).nombre_arguments = -1; 290: return; 291: } 292: 293: if (test_cfsf(s_etat_processus, 31) == d_vrai) 294: { 295: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 296: { 297: return; 298: } 299: } 300: 301: l_base_pile = (*s_etat_processus).l_base_pile_last; 302: (*s_etat_processus).l_base_pile_last = NULL; 303: 304: for(i = 0; i < 8; i++) 305: { 306: instruction_rl(s_etat_processus); 307: 308: if (((*s_etat_processus).erreur_systeme != d_es) || 309: ((*s_etat_processus).erreur_execution != d_ex)) 310: { 311: break; 312: } 313: } 314: 315: if (test_cfsf(s_etat_processus, 31) == d_vrai) 316: { 317: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 318: { 319: return; 320: } 321: } 322: 323: (*s_etat_processus).l_base_pile_last = l_base_pile; 324: return; 325: } 326: 327: 328: /* 329: ================================================================================ 330: Fonction 'rr' 331: ================================================================================ 332: Entrées : pointeur sur une structure struct_processus 333: -------------------------------------------------------------------------------- 334: Sorties : 335: -------------------------------------------------------------------------------- 336: Effets de bord : néant 337: ================================================================================ 338: */ 339: 340: void 341: instruction_rr(struct_processus *s_etat_processus) 342: { 343: logical8 masque; 344: logical8 tampon; 345: 346: struct_objet *s_copie; 347: struct_objet *s_objet; 348: 349: unsigned long i; 350: unsigned long j; 351: unsigned long longueur; 352: 353: (*s_etat_processus).erreur_execution = d_ex; 354: 355: if ((*s_etat_processus).affichage_arguments == 'Y') 356: { 357: printf("\n RR "); 358: 359: if ((*s_etat_processus).langue == 'F') 360: { 361: printf("(rotation à droite)\n\n"); 362: } 363: else 364: { 365: printf("(rotate right)\n\n"); 366: } 367: 368: printf(" 1: %s\n", d_BIN); 369: printf("-> 1: %s\n", d_BIN); 370: 371: return; 372: } 373: else if ((*s_etat_processus).test_instruction == 'Y') 374: { 375: (*s_etat_processus).nombre_arguments = -1; 376: return; 377: } 378: 379: if (test_cfsf(s_etat_processus, 31) == d_vrai) 380: { 381: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 382: { 383: return; 384: } 385: } 386: 387: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 388: &s_objet) == d_erreur) 389: { 390: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 391: return; 392: } 393: 394: if ((*s_objet).type == BIN) 395: { 396: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL) 397: { 398: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 399: return; 400: } 401: 402: longueur = 1; 403: j = 1; 404: 405: for(i = 37; i <= 42; i++) 406: { 407: longueur += (test_cfsf(s_etat_processus, (unsigned char) i) 408: == d_vrai) ? j : 0; 409: j *= 2; 410: } 411: 412: tampon = (*((logical8 *) (*s_copie).objet)); 413: masque = (logical8) 1; 414: 415: if ((tampon & masque) == 0) 416: { 417: tampon >>= 1; 418: } 419: else 420: { 421: tampon >>= 1; 422: tampon |= (((logical8) 1) << (longueur - 1)); 423: } 424: 425: for(masque = 0, i = 0; i < longueur; i++) 426: { 427: masque <<= 1; 428: masque |= 1; 429: } 430: 431: tampon &= masque; 432: (*((logical8 *) (*s_copie).objet)) = tampon; 433: 434: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 435: s_copie) == d_erreur) 436: { 437: return; 438: } 439: } 440: else 441: { 442: liberation(s_etat_processus, s_objet); 443: 444: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 445: return; 446: } 447: 448: liberation(s_etat_processus, s_objet); 449: 450: return; 451: } 452: 453: 454: /* 455: ================================================================================ 456: Fonction 'rrb' 457: ================================================================================ 458: Entrées : pointeur sur une structure struct_processus 459: -------------------------------------------------------------------------------- 460: Sorties : 461: -------------------------------------------------------------------------------- 462: Effets de bord : néant 463: ================================================================================ 464: */ 465: 466: void 467: instruction_rrb(struct_processus *s_etat_processus) 468: { 469: struct_liste_chainee *l_base_pile; 470: 471: unsigned long i; 472: 473: (*s_etat_processus).erreur_execution = d_ex; 474: 475: if ((*s_etat_processus).affichage_arguments == 'Y') 476: { 477: printf("\n RRB "); 478: 479: if ((*s_etat_processus).langue == 'F') 480: { 481: printf("(rotation d'un octet vers la droite)\n\n"); 482: } 483: else 484: { 485: printf("(rotate right byte)\n\n"); 486: } 487: 488: printf(" 1: %s\n", d_BIN); 489: printf("-> 1: %s\n", d_BIN); 490: 491: return; 492: } 493: else if ((*s_etat_processus).test_instruction == 'Y') 494: { 495: (*s_etat_processus).nombre_arguments = -1; 496: return; 497: } 498: 499: if (test_cfsf(s_etat_processus, 31) == d_vrai) 500: { 501: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 502: { 503: return; 504: } 505: } 506: 507: l_base_pile = (*s_etat_processus).l_base_pile_last; 508: (*s_etat_processus).l_base_pile_last = NULL; 509: 510: for(i = 0; i < 8; i++) 511: { 512: instruction_rr(s_etat_processus); 513: 514: if (((*s_etat_processus).erreur_systeme != d_es) || 515: ((*s_etat_processus).erreur_execution != d_ex)) 516: { 517: break; 518: } 519: } 520: 521: if (test_cfsf(s_etat_processus, 31) == d_vrai) 522: { 523: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 524: { 525: return; 526: } 527: } 528: 529: (*s_etat_processus).l_base_pile_last = l_base_pile; 530: return; 531: } 532: 533: 534: /* 535: ================================================================================ 536: Fonction 'redraw' 537: ================================================================================ 538: Entrées : pointeur sur une structure struct_processus 539: -------------------------------------------------------------------------------- 540: Sorties : 541: -------------------------------------------------------------------------------- 542: Effets de bord : néant 543: ================================================================================ 544: */ 545: 546: void 547: instruction_redraw(struct_processus *s_etat_processus) 548: { 549: (*s_etat_processus).erreur_execution = d_ex; 550: 551: if ((*s_etat_processus).affichage_arguments == 'Y') 552: { 553: printf("\n REDRAW "); 554: 555: if ((*s_etat_processus).langue == 'F') 556: { 557: printf("(redessine une courbe)\n\n"); 558: printf(" Aucun argument\n"); 559: } 560: else 561: { 562: printf("(redraw a graphic)\n\n"); 563: printf(" No argument\n"); 564: } 565: 566: return; 567: } 568: else if ((*s_etat_processus).test_instruction == 'Y') 569: { 570: (*s_etat_processus).nombre_arguments = -1; 571: return; 572: } 573: 574: if (test_cfsf(s_etat_processus, 31) == d_vrai) 575: { 576: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 577: { 578: return; 579: } 580: } 581: 582: if ((*s_etat_processus).mise_a_jour_trace_requise == d_vrai) 583: { 584: (*s_etat_processus).erreur_execution = d_ex_graphique_memorise; 585: return; 586: } 587: 588: if ((*s_etat_processus).fichiers_graphiques != NULL) 589: { 590: appel_gnuplot(s_etat_processus, 'N'); 591: } 592: 593: return; 594: } 595: 596: 597: /* 598: ================================================================================ 599: Fonction 'remove' 600: ================================================================================ 601: Entrées : pointeur sur une structure struct_processus 602: -------------------------------------------------------------------------------- 603: Sorties : 604: -------------------------------------------------------------------------------- 605: Effets de bord : néant 606: ================================================================================ 607: */ 608: 609: void 610: instruction_remove(struct_processus *s_etat_processus) 611: { 612: struct_objet *s_objet_argument; 613: 614: (*s_etat_processus).erreur_execution = d_ex; 615: 616: if ((*s_etat_processus).affichage_arguments == 'Y') 617: { 618: printf("\n REMOVE "); 619: 620: if ((*s_etat_processus).langue == 'F') 621: { 622: printf("(retrait d'une bibliothèque dynamique)\n\n"); 623: } 624: else 625: { 626: printf("(remove a shared library)\n\n"); 627: } 628: 629: printf(" 1: %s\n", d_SLB); 630: 631: return; 632: } 633: else if ((*s_etat_processus).test_instruction == 'Y') 634: { 635: (*s_etat_processus).nombre_arguments = -1; 636: return; 637: } 638: 639: if (test_cfsf(s_etat_processus, 31) == d_vrai) 640: { 641: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 642: { 643: return; 644: } 645: } 646: 647: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 648: &s_objet_argument) == d_erreur) 649: { 650: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 651: return; 652: } 653: 654: if ((*s_objet_argument).type == SLB) 655: { 656: /* 657: * On ne décharge que les bibliothèques qui ont été chargées dans 658: * le couple pid/tid courant. 659: */ 660: 661: if (((*((struct_bibliotheque *) (*s_objet_argument).objet)).pid == 662: getpid()) && (pthread_equal((*((struct_bibliotheque *) 663: (*s_objet_argument).objet)).tid, pthread_self()) != 0)) 664: { 665: if (retrait_bibliotheque(s_etat_processus, 666: (*s_objet_argument).objet) == d_erreur) 667: { 668: liberation(s_etat_processus, s_objet_argument); 669: 670: return; 671: } 672: } 673: } 674: else 675: { 676: liberation(s_etat_processus, s_objet_argument); 677: 678: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 679: return; 680: } 681: 682: liberation(s_etat_processus, s_objet_argument); 683: 684: return; 685: } 686: 687: 688: /* 689: ================================================================================ 690: Fonction 'relax' 691: ================================================================================ 692: Entrées : pointeur sur une structure struct_processus 693: -------------------------------------------------------------------------------- 694: Sorties : 695: -------------------------------------------------------------------------------- 696: Effets de bord : néant 697: ================================================================================ 698: */ 699: 700: void 701: instruction_relax(struct_processus *s_etat_processus) 702: { 703: (*s_etat_processus).erreur_execution = d_ex; 704: 705: if ((*s_etat_processus).affichage_arguments == 'Y') 706: { 707: printf("\n RELAX "); 708: 709: if ((*s_etat_processus).langue == 'F') 710: { 711: printf("(ne fait rien)\n\n"); 712: printf(" Aucun argument\n"); 713: } 714: else 715: { 716: printf("(do nothing)\n\n"); 717: printf(" No argument\n"); 718: } 719: 720: return; 721: } 722: else if ((*s_etat_processus).test_instruction == 'Y') 723: { 724: (*s_etat_processus).nombre_arguments = 1; 725: return; 726: } 727: 728: /* 729: * Cette instruction ne fait rien. Elle existe pour être symétrique 730: * à l'instruction CHS et permet de traiter les équations de façon 731: * simple (Ex : '+pi'). En principe, elle n'a pas a être appelée 732: * directement par l'utilisateur. 733: */ 734: 735: return; 736: } 737: 738: 739: /* 740: ================================================================================ 741: Fonction 'rewind' 742: ================================================================================ 743: Entrées : pointeur sur une structure struct_processus 744: -------------------------------------------------------------------------------- 745: Sorties : 746: -------------------------------------------------------------------------------- 747: Effets de bord : néant 748: ================================================================================ 749: */ 750: 751: void 752: instruction_rewind(struct_processus *s_etat_processus) 753: { 754: struct_descripteur_fichier *descripteur; 755: 756: struct_objet *s_objet_argument; 757: 758: (*s_etat_processus).erreur_execution = d_ex; 759: 760: if ((*s_etat_processus).affichage_arguments == 'Y') 761: { 762: printf("\n REWIND "); 763: 764: if ((*s_etat_processus).langue == 'F') 765: { 766: printf("(retour au début d'un fichier)\n\n"); 767: } 768: else 769: { 770: printf("(rewind a file)\n\n"); 771: } 772: 773: printf(" 1: %s\n", d_FCH); 774: 775: return; 776: } 777: else if ((*s_etat_processus).test_instruction == 'Y') 778: { 779: (*s_etat_processus).nombre_arguments = -1; 780: return; 781: } 782: 783: if (test_cfsf(s_etat_processus, 31) == d_vrai) 784: { 785: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 786: { 787: return; 788: } 789: } 790: 791: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 792: &s_objet_argument) == d_erreur) 793: { 794: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 795: return; 796: } 797: 798: if ((*s_objet_argument).type == FCH) 799: { 800: if ((descripteur = descripteur_fichier(s_etat_processus, 801: (struct_fichier *) (*s_objet_argument).objet)) == NULL) 802: { 803: return; 804: } 805: 806: if ((*descripteur).type == 'C') 807: { 808: if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_SET) != 0) 809: { 810: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 811: return; 812: } 813: } 814: else 815: { 816: liberation(s_etat_processus, s_objet_argument); 817: 818: (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier; 819: return; 820: } 821: } 822: else 823: { 824: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 825: return; 826: } 827: 828: liberation(s_etat_processus, s_objet_argument); 829: 830: return; 831: } 832: 833: 834: /* 835: ================================================================================ 836: Fonction 'read' 837: ================================================================================ 838: Entrées : pointeur sur une structure struct_processus 839: -------------------------------------------------------------------------------- 840: Sorties : 841: -------------------------------------------------------------------------------- 842: Effets de bord : néant 843: ================================================================================ 844: */ 845: 846: void 847: instruction_read(struct_processus *s_etat_processus) 848: { 849: const char *queue; 850: 851: int c; 852: int ios; 853: int timeout; 854: 855: integer8 element; 856: integer8 i; 857: integer8 id; 858: integer8 index; 859: integer8 longueur; 860: integer8 position_clef; 861: 862: integer8 longueur_effective; 863: integer8 longueur_enregistrement; 864: integer8 longueur_questure; 865: integer8 niveau; 866: integer8 pointeur; 867: integer8 position_finale; 868: integer8 position_initiale; 869: 870: logical1 device; 871: logical1 format_degenere; 872: logical1 format_oriente_ligne; 873: logical1 indicateur_48; 874: logical1 presence_chaine; 875: logical1 presence_indicateur; 876: logical1 trame_complete; 877: 878: socklen_t longueur_adresse; 879: 880: sqlite3_stmt *ppStmt; 881: 882: struct flock lock; 883: 884: struct pollfd fds[1]; 885: 886: struct sockaddr_un adresse_unix; 887: struct sockaddr_in adresse_ipv4; 888: # ifdef IPV6 889: struct sockaddr_in6 adresse_ipv6; 890: # endif 891: 892: struct termios tc; 893: 894: struct timespec attente; 895: 896: struct_descripteur_fichier *descripteur; 897: 898: struct_liste_chainee *l_element_courant; 899: struct_liste_chainee *l_element_courant_format; 900: struct_liste_chainee *l_element_inclus; 901: 902: struct_objet *s_objet_adresse; 903: struct_objet *s_objet_argument_1; 904: struct_objet *s_objet_argument_2; 905: struct_objet *s_objet_resultat; 906: struct_objet *s_objet_type; 907: 908: unsigned char caractere; 909: unsigned char *clef_utf8; 910: unsigned char *commande; 911: unsigned char *format_chaine; 912: unsigned char *ptr; 913: unsigned char *tampon_lecture; 914: unsigned char *tampon; 915: unsigned char *tampon2; 916: unsigned char *tampon3; 917: 918: int vitesses[] = 919: { 920: 50, 75, 110, 134, 150, 200, 300, 600, 921: 1200, 1800, 2400, 4800, 9600, 19200, 38400, 922: #ifdef B57600 923: 57600, 924: #endif 925: #ifdef B115200 926: 115200, 927: #endif 928: #ifdef B230400 929: 230400, 930: #endif 931: 0 932: }; 933: 934: tcflag_t vitesses_constantes[] = 935: { 936: B50, B75, B110, B134, B150, B200, B300, B600, 937: B1200, B1800, B2400, B4800, B9600, B19200, B38400, 938: #ifdef B57600 939: B57600, 940: #endif 941: #ifdef B115200 942: B115200, 943: #endif 944: #ifdef B230400 945: B230400, 946: #endif 947: 0 948: }; 949: 950: (*s_etat_processus).erreur_execution = d_ex; 951: 952: if ((*s_etat_processus).affichage_arguments == 'Y') 953: { 954: printf("\n READ "); 955: 956: if ((*s_etat_processus).langue == 'F') 957: { 958: printf("(lecture d'un enregistrement d'un fichier)\n\n"); 959: } 960: else 961: { 962: printf("(read a record of a file)\n\n"); 963: } 964: 965: printf(" 1: %s, %s\n\n", d_FCH, d_SCK); 966: 967: printf(" 2: %s, %s\n", d_INT, d_CHN); 968: printf(" 1: %s\n", d_FCH); 969: return; 970: } 971: else if ((*s_etat_processus).test_instruction == 'Y') 972: { 973: (*s_etat_processus).nombre_arguments = -1; 974: return; 975: } 976: 977: if (test_cfsf(s_etat_processus, 31) == d_vrai) 978: { 979: if ((*s_etat_processus).l_base_pile == NULL) 980: { 981: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 982: return; 983: } 984: 985: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH) 986: { 987: if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile) 988: .donnee).objet)).acces == 'S') 989: { 990: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 991: { 992: return; 993: } 994: } 995: else 996: { 997: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 998: { 999: return; 1000: } 1001: } 1002: } 1003: else 1004: { 1005: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1006: { 1007: return; 1008: } 1009: } 1010: } 1011: 1012: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1013: &s_objet_argument_1) == d_erreur) 1014: { 1015: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1016: return; 1017: } 1018: 1019: if ((*s_objet_argument_1).type == FCH) 1020: { 1021: if ((descripteur = descripteur_fichier(s_etat_processus, 1022: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL) 1023: { 1024: return; 1025: } 1026: 1027: /* 1028: * Vérification des verrous 1029: */ 1030: 1031: lock.l_type = F_RDLCK; 1032: lock.l_whence = SEEK_SET; 1033: lock.l_start = 0; 1034: lock.l_len = 0; 1035: lock.l_pid = getpid(); 1036: 1037: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock) 1038: == -1) 1039: { 1040: liberation(s_etat_processus, s_objet_argument_1); 1041: 1042: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1043: return; 1044: } 1045: 1046: if (lock.l_type != F_UNLCK) 1047: { 1048: liberation(s_etat_processus, s_objet_argument_1); 1049: 1050: (*s_etat_processus).erreur_execution = 1051: d_ex_fichier_verrouille; 1052: return; 1053: } 1054: 1055: /* 1056: * Vérification de l'autorisation de lecture 1057: */ 1058: 1059: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection 1060: == 'W') 1061: { 1062: liberation(s_etat_processus, s_objet_argument_1); 1063: 1064: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; 1065: return; 1066: } 1067: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection 1068: == 'N') 1069: { 1070: if ((*descripteur).type == 'C') 1071: { 1072: if (fflush((*descripteur).descripteur_c) != 0) 1073: { 1074: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1075: return; 1076: } 1077: } 1078: } 1079: 1080: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N') 1081: { 1082: /* 1083: * Fichiers formatés 1084: */ 1085: 1086: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 1087: == 'S') 1088: { 1089: /* 1090: * Fichiers séquentiels 1091: */ 1092: 1093: longueur_questure = 4096; 1094: 1095: if ((tampon_lecture = malloc(((size_t) longueur_questure) * 1096: sizeof(unsigned char))) == NULL) 1097: { 1098: (*s_etat_processus).erreur_systeme = 1099: d_es_allocation_memoire; 1100: return; 1101: } 1102: 1103: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); 1104: 1105: if ((position_initiale = ftell((*descripteur).descripteur_c)) 1106: == -1) 1107: { 1108: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1109: return; 1110: } 1111: 1112: do 1113: { 1114: longueur_effective = (integer8) fread(tampon_lecture, 1115: sizeof(unsigned char), (size_t) longueur_questure, 1116: (*descripteur).descripteur_c); 1117: 1118: pointeur = 0; 1119: presence_indicateur = d_faux; 1120: 1121: while(pointeur < longueur_effective) 1122: { 1123: if (tampon_lecture[pointeur] == '{') 1124: { 1125: presence_indicateur = d_vrai; 1126: break; 1127: } 1128: 1129: position_initiale++; 1130: pointeur++; 1131: } 1132: 1133: if (presence_indicateur == d_vrai) 1134: { 1135: break; 1136: } 1137: } while(longueur_effective == longueur_questure); 1138: 1139: if (presence_indicateur == d_faux) 1140: { 1141: liberation(s_etat_processus, s_objet_argument_1); 1142: free(tampon_lecture); 1143: 1144: (*s_etat_processus).erreur_execution = 1145: d_ex_fin_de_fichier_atteinte; 1146: return; 1147: } 1148: 1149: position_finale = position_initiale + 1; 1150: presence_chaine = d_faux; 1151: niveau = 1; 1152: 1153: if (fseek((*descripteur).descripteur_c, (long) position_finale, 1154: SEEK_SET) != 0) 1155: { 1156: liberation(s_etat_processus, s_objet_argument_1); 1157: free(tampon_lecture); 1158: 1159: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1160: return; 1161: } 1162: 1163: do 1164: { 1165: longueur_effective = (integer8) fread(tampon_lecture, 1166: sizeof(unsigned char), (size_t) longueur_questure, 1167: (*descripteur).descripteur_c); 1168: 1169: pointeur = 0; 1170: presence_indicateur = d_faux; 1171: 1172: while(pointeur < longueur_effective) 1173: { 1174: if (tampon_lecture[pointeur] == '"') 1175: { 1176: if (pointeur > 0) 1177: { 1178: if (tampon_lecture[pointeur - 1] != '\\') 1179: { 1180: presence_chaine = (presence_chaine == 1181: d_vrai) ? d_faux : d_vrai; 1182: } 1183: } 1184: else 1185: { 1186: presence_chaine = (presence_chaine == d_vrai) 1187: ? d_faux : d_vrai; 1188: } 1189: } 1190: else 1191: { 1192: if (presence_chaine == d_faux) 1193: { 1194: if (tampon_lecture[pointeur] == '{') 1195: { 1196: niveau++; 1197: } 1198: else if (tampon_lecture[pointeur] == '}') 1199: { 1200: niveau--; 1201: } 1202: } 1203: } 1204: 1205: position_finale++; 1206: pointeur++; 1207: 1208: if (niveau == 0) 1209: { 1210: presence_indicateur = d_vrai; 1211: break; 1212: } 1213: } 1214: 1215: if (presence_indicateur == d_vrai) 1216: { 1217: break; 1218: } 1219: } while(longueur_effective == longueur_questure); 1220: 1221: if (presence_indicateur == d_faux) 1222: { 1223: liberation(s_etat_processus, s_objet_argument_1); 1224: free(tampon_lecture); 1225: 1226: (*s_etat_processus).erreur_execution = 1227: d_ex_fin_de_fichier_atteinte; 1228: return; 1229: } 1230: 1231: free(tampon_lecture); 1232: longueur_enregistrement = position_finale - position_initiale; 1233: 1234: if ((tampon_lecture = malloc(((size_t) 1235: (longueur_enregistrement + 1)) * 1236: sizeof(unsigned char))) == NULL) 1237: { 1238: (*s_etat_processus).erreur_systeme = 1239: d_es_allocation_memoire; 1240: return; 1241: } 1242: 1243: if (fseek((*descripteur).descripteur_c, 1244: (long) position_initiale, SEEK_SET) != 0) 1245: { 1246: liberation(s_etat_processus, s_objet_argument_1); 1247: free(tampon_lecture); 1248: 1249: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1250: return; 1251: } 1252: 1253: longueur_effective = (integer8) fread(tampon_lecture, 1254: sizeof(unsigned char), (size_t) longueur_enregistrement, 1255: (*descripteur).descripteur_c); 1256: 1257: if (longueur_effective != longueur_enregistrement) 1258: { 1259: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1260: return; 1261: } 1262: 1263: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine; 1264: tampon = (*s_etat_processus).instruction_courante; 1265: 1266: if (((*s_etat_processus).instruction_courante = 1267: transliteration(s_etat_processus, tampon_lecture, 1268: "UTF-8", d_locale)) == NULL) 1269: { 1270: (*s_etat_processus).instruction_courante = tampon; 1271: liberation(s_etat_processus, s_objet_argument_1); 1272: free(tampon_lecture); 1273: return; 1274: } 1275: 1276: indicateur_48 = test_cfsf(s_etat_processus, 48); 1277: cf(s_etat_processus, 48); 1278: 1279: (*s_etat_processus).type_en_cours = NON; 1280: recherche_type(s_etat_processus); 1281: free((*s_etat_processus).instruction_courante); 1282: 1283: if ((*s_etat_processus).erreur_execution != d_ex) 1284: { 1285: if (indicateur_48 == d_vrai) 1286: { 1287: sf(s_etat_processus, 48); 1288: } 1289: else 1290: { 1291: cf(s_etat_processus, 48); 1292: } 1293: 1294: (*s_etat_processus).instruction_courante = tampon; 1295: free(tampon_lecture); 1296: 1297: liberation(s_etat_processus, s_objet_argument_1); 1298: return; 1299: } 1300: 1301: if (indicateur_48 == d_vrai) 1302: { 1303: sf(s_etat_processus, 48); 1304: } 1305: else 1306: { 1307: cf(s_etat_processus, 48); 1308: } 1309: 1310: (*s_etat_processus).instruction_courante = tampon; 1311: free(tampon_lecture); 1312: } 1313: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 1314: == 'D') 1315: { 1316: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); 1317: 1318: if (depilement(s_etat_processus, &((*s_etat_processus) 1319: .l_base_pile), &s_objet_argument_2) == d_erreur) 1320: { 1321: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1322: return; 1323: } 1324: 1325: if ((*s_objet_argument_2).type != INT) 1326: { 1327: liberation(s_etat_processus, s_objet_argument_1); 1328: liberation(s_etat_processus, s_objet_argument_2); 1329: 1330: (*s_etat_processus).erreur_execution = 1331: d_ex_erreur_type_argument; 1332: return; 1333: } 1334: 1335: if (alsprintf(s_etat_processus, &commande, 1336: "select data from data where id = %lld", 1337: (*((integer8 *) (*s_objet_argument_2).objet))) < 0) 1338: { 1339: (*s_etat_processus).erreur_systeme = 1340: d_es_allocation_memoire; 1341: return; 1342: } 1343: 1344: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1345: commande, (int) strlen(commande), &ppStmt, &queue) 1346: != SQLITE_OK) 1347: { 1348: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1349: return; 1350: } 1351: 1352: attente.tv_sec = 0; 1353: attente.tv_nsec = GRANULARITE_us * 1000; 1354: 1355: do 1356: { 1357: ios = sqlite3_step(ppStmt); 1358: 1359: switch(ios) 1360: { 1361: case SQLITE_ROW: 1362: { 1363: // Résultat attendu 1364: break; 1365: } 1366: 1367: case SQLITE_DONE: 1368: { 1369: // Aucun enregistrement 1370: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1371: { 1372: (*s_etat_processus).erreur_systeme = 1373: d_es_erreur_fichier; 1374: return; 1375: } 1376: 1377: free(commande); 1378: 1379: liberation(s_etat_processus, s_objet_argument_1); 1380: liberation(s_etat_processus, s_objet_argument_2); 1381: 1382: (*s_etat_processus).erreur_execution = 1383: d_ex_enregistrement_inexistant; 1384: return; 1385: } 1386: 1387: case SQLITE_BUSY: 1388: case SQLITE_LOCKED: 1389: { 1390: nanosleep(&attente, NULL); 1391: INCR_GRANULARITE(attente.tv_nsec); 1392: break; 1393: } 1394: 1395: default: 1396: { 1397: (*s_etat_processus).erreur_systeme = 1398: d_es_erreur_fichier; 1399: return; 1400: } 1401: } 1402: } while(ios != SQLITE_ROW); 1403: 1404: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) 1405: { 1406: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1407: return; 1408: } 1409: 1410: tampon = (*s_etat_processus).instruction_courante; 1411: 1412: if ((tampon_lecture = (unsigned char *) 1413: sqlite3_column_text(ppStmt, 0)) == NULL) 1414: { 1415: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1416: return; 1417: } 1418: 1419: if (((*s_etat_processus).instruction_courante = 1420: transliteration(s_etat_processus, tampon_lecture, 1421: "UTF-8", d_locale)) == NULL) 1422: { 1423: (*s_etat_processus).instruction_courante = tampon; 1424: 1425: liberation(s_etat_processus, s_objet_argument_1); 1426: liberation(s_etat_processus, s_objet_argument_2); 1427: free(commande); 1428: return; 1429: } 1430: 1431: indicateur_48 = test_cfsf(s_etat_processus, 48); 1432: cf(s_etat_processus, 48); 1433: 1434: (*s_etat_processus).type_en_cours = NON; 1435: recherche_type(s_etat_processus); 1436: 1437: if ((*s_etat_processus).erreur_execution != d_ex) 1438: { 1439: if (indicateur_48 == d_vrai) 1440: { 1441: sf(s_etat_processus, 48); 1442: } 1443: else 1444: { 1445: cf(s_etat_processus, 48); 1446: } 1447: 1448: liberation(s_etat_processus, s_objet_argument_1); 1449: liberation(s_etat_processus, s_objet_argument_2); 1450: 1451: free((*s_etat_processus).instruction_courante); 1452: free(commande); 1453: 1454: (*s_etat_processus).instruction_courante = tampon; 1455: return; 1456: } 1457: 1458: if (indicateur_48 == d_vrai) 1459: { 1460: sf(s_etat_processus, 48); 1461: } 1462: else 1463: { 1464: cf(s_etat_processus, 48); 1465: } 1466: 1467: free((*s_etat_processus).instruction_courante); 1468: liberation(s_etat_processus, s_objet_argument_2); 1469: (*s_etat_processus).instruction_courante = tampon; 1470: 1471: if (sqlite3_step(ppStmt) != SQLITE_DONE) 1472: { 1473: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1474: return; 1475: } 1476: 1477: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1478: { 1479: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1480: return; 1481: } 1482: 1483: free(commande); 1484: } 1485: else 1486: { 1487: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); 1488: 1489: if (depilement(s_etat_processus, &((*s_etat_processus) 1490: .l_base_pile), &s_objet_argument_2) == d_erreur) 1491: { 1492: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1493: return; 1494: } 1495: 1496: if ((*s_objet_argument_2).type != CHN) 1497: { 1498: liberation(s_etat_processus, s_objet_argument_1); 1499: liberation(s_etat_processus, s_objet_argument_2); 1500: 1501: (*s_etat_processus).erreur_execution = 1502: d_ex_erreur_type_argument; 1503: return; 1504: } 1505: 1506: // Récupération de la position de la clef 1507: 1508: if (alsprintf(s_etat_processus, &commande, 1509: "select key from control where id = 1") < 0) 1510: { 1511: (*s_etat_processus).erreur_systeme = 1512: d_es_allocation_memoire; 1513: return; 1514: } 1515: 1516: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1517: commande, (int) strlen(commande), &ppStmt, &queue) 1518: != SQLITE_OK) 1519: { 1520: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1521: return; 1522: } 1523: 1524: attente.tv_sec = 0; 1525: attente.tv_nsec = GRANULARITE_us * 1000; 1526: 1527: do 1528: { 1529: ios = sqlite3_step(ppStmt); 1530: 1531: if (ios == SQLITE_ROW) 1532: { 1533: break; 1534: } 1535: else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED)) 1536: { 1537: nanosleep(&attente, NULL); 1538: INCR_GRANULARITE(attente.tv_nsec); 1539: } 1540: else 1541: { 1542: (*s_etat_processus).erreur_systeme = 1543: d_es_erreur_fichier; 1544: return; 1545: } 1546: } while(ios != SQLITE_ROW); 1547: 1548: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) 1549: { 1550: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1551: return; 1552: } 1553: 1554: position_clef = sqlite3_column_int64(ppStmt, 0); 1555: 1556: if (sqlite3_step(ppStmt) != SQLITE_DONE) 1557: { 1558: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1559: return; 1560: } 1561: 1562: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1563: { 1564: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1565: return; 1566: } 1567: 1568: free(commande); 1569: 1570: if ((clef_utf8 = transliteration(s_etat_processus, 1571: (unsigned char *) (*s_objet_argument_2).objet, 1572: d_locale, "UTF-8")) == NULL) 1573: { 1574: liberation(s_etat_processus, s_objet_argument_1); 1575: liberation(s_etat_processus, s_objet_argument_2); 1576: 1577: return; 1578: } 1579: 1580: // Récupération de l'identifiant de la clef 1581: 1582: if (alsprintf(s_etat_processus, &commande, 1583: "select id from key where key = '{ \"%s\" }'", 1584: clef_utf8) < 0) 1585: { 1586: (*s_etat_processus).erreur_systeme = 1587: d_es_allocation_memoire; 1588: return; 1589: } 1590: 1591: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1592: commande, (int) strlen(commande), &ppStmt, &queue) 1593: != SQLITE_OK) 1594: { 1595: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1596: return; 1597: } 1598: 1599: attente.tv_sec = 0; 1600: attente.tv_nsec = GRANULARITE_us * 1000; 1601: 1602: do 1603: { 1604: ios = sqlite3_step(ppStmt); 1605: 1606: switch(ios) 1607: { 1608: case SQLITE_ROW: 1609: { 1610: // Résultat attendu : une clef correspond. 1611: break; 1612: } 1613: 1614: case SQLITE_DONE: 1615: { 1616: // Aucun enregistrement 1617: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1618: { 1619: (*s_etat_processus).erreur_systeme = 1620: d_es_erreur_fichier; 1621: return; 1622: } 1623: 1624: free(clef_utf8); 1625: free(commande); 1626: 1627: liberation(s_etat_processus, s_objet_argument_1); 1628: liberation(s_etat_processus, s_objet_argument_2); 1629: 1630: (*s_etat_processus).erreur_execution = 1631: d_ex_enregistrement_inexistant; 1632: return; 1633: } 1634: 1635: case SQLITE_BUSY: 1636: case SQLITE_LOCKED: 1637: { 1638: nanosleep(&attente, NULL); 1639: INCR_GRANULARITE(attente.tv_nsec); 1640: break; 1641: } 1642: 1643: default: 1644: { 1645: (*s_etat_processus).erreur_systeme = 1646: d_es_erreur_fichier; 1647: return; 1648: } 1649: } 1650: } while(ios != SQLITE_ROW); 1651: 1652: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) 1653: { 1654: free(clef_utf8); 1655: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1656: return; 1657: } 1658: 1659: id = sqlite3_column_int64(ppStmt, 0); 1660: 1661: if (sqlite3_step(ppStmt) != SQLITE_DONE) 1662: { 1663: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1664: return; 1665: } 1666: 1667: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1668: { 1669: (*s_etat_processus).erreur_systeme = 1670: d_es_erreur_fichier; 1671: return; 1672: } 1673: 1674: free(commande); 1675: 1676: if (alsprintf(s_etat_processus, &commande, 1677: "select data from data where " 1678: "key_id = %lld order by sequence asc", id) < 0) 1679: { 1680: (*s_etat_processus).erreur_systeme = 1681: d_es_allocation_memoire; 1682: return; 1683: } 1684: 1685: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1686: commande, (int) strlen(commande), &ppStmt, &queue) 1687: != SQLITE_OK) 1688: { 1689: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1690: return; 1691: } 1692: 1693: element = 1; 1694: 1695: attente.tv_sec = 0; 1696: attente.tv_nsec = GRANULARITE_us * 1000; 1697: 1698: do 1699: { 1700: switch(ios = sqlite3_step(ppStmt)) 1701: { 1702: case SQLITE_ROW: 1703: { 1704: // Donnée supplémentaire 1705: 1706: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) 1707: { 1708: (*s_etat_processus).erreur_systeme = 1709: d_es_erreur_fichier; 1710: return; 1711: } 1712: 1713: tampon = (*s_etat_processus).instruction_courante; 1714: 1715: if ((tampon_lecture = (unsigned char *) 1716: sqlite3_column_text(ppStmt, 0)) == NULL) 1717: { 1718: (*s_etat_processus).erreur_systeme = 1719: d_es_erreur_fichier; 1720: return; 1721: } 1722: 1723: if (((*s_etat_processus).instruction_courante = 1724: transliteration(s_etat_processus, 1725: tampon_lecture, 1726: "UTF-8", d_locale)) == NULL) 1727: { 1728: (*s_etat_processus).instruction_courante = 1729: tampon; 1730: 1731: liberation(s_etat_processus, 1732: s_objet_argument_1); 1733: liberation(s_etat_processus, 1734: s_objet_argument_2); 1735: 1736: free(commande); 1737: free(clef_utf8); 1738: return; 1739: } 1740: 1741: indicateur_48 = test_cfsf(s_etat_processus, 48); 1742: cf(s_etat_processus, 48); 1743: 1744: (*s_etat_processus).type_en_cours = NON; 1745: recherche_type(s_etat_processus); 1746: 1747: if ((*s_etat_processus).erreur_execution != d_ex) 1748: { 1749: if (indicateur_48 == d_vrai) 1750: { 1751: sf(s_etat_processus, 48); 1752: } 1753: else 1754: { 1755: cf(s_etat_processus, 48); 1756: } 1757: 1758: liberation(s_etat_processus, 1759: s_objet_argument_1); 1760: liberation(s_etat_processus, 1761: s_objet_argument_2); 1762: 1763: free((*s_etat_processus).instruction_courante); 1764: free(commande); 1765: free(clef_utf8); 1766: 1767: (*s_etat_processus).instruction_courante = 1768: tampon; 1769: return; 1770: } 1771: 1772: if (indicateur_48 == d_vrai) 1773: { 1774: sf(s_etat_processus, 48); 1775: } 1776: else 1777: { 1778: cf(s_etat_processus, 48); 1779: } 1780: 1781: free((*s_etat_processus).instruction_courante); 1782: (*s_etat_processus).instruction_courante = tampon; 1783: 1784: element++; 1785: 1786: // Inscription de la clef 1787: 1788: if (element == position_clef) 1789: { 1790: if (((*s_etat_processus).instruction_courante = 1791: transliteration(s_etat_processus, 1792: clef_utf8, "UTF-8", d_locale)) == NULL) 1793: { 1794: (*s_etat_processus).instruction_courante = 1795: tampon; 1796: 1797: liberation(s_etat_processus, 1798: s_objet_argument_1); 1799: liberation(s_etat_processus, 1800: s_objet_argument_2); 1801: 1802: free(commande); 1803: free(clef_utf8); 1804: return; 1805: } 1806: 1807: if (alsprintf(s_etat_processus, &tampon2, 1808: "{ \"%s\" }", (*s_etat_processus) 1809: .instruction_courante) < 0) 1810: { 1811: (*s_etat_processus).erreur_systeme = 1812: d_es_allocation_memoire; 1813: return; 1814: } 1815: 1816: free((*s_etat_processus).instruction_courante); 1817: (*s_etat_processus).instruction_courante 1818: = tampon2; 1819: 1820: indicateur_48 = test_cfsf(s_etat_processus, 48); 1821: cf(s_etat_processus, 48); 1822: 1823: (*s_etat_processus).type_en_cours = NON; 1824: recherche_type(s_etat_processus); 1825: 1826: if ((*s_etat_processus).erreur_execution 1827: != d_ex) 1828: { 1829: if (indicateur_48 == d_vrai) 1830: { 1831: sf(s_etat_processus, 48); 1832: } 1833: else 1834: { 1835: cf(s_etat_processus, 48); 1836: } 1837: 1838: liberation(s_etat_processus, 1839: s_objet_argument_1); 1840: liberation(s_etat_processus, 1841: s_objet_argument_2); 1842: 1843: free((*s_etat_processus) 1844: .instruction_courante); 1845: free(commande); 1846: free(clef_utf8); 1847: 1848: (*s_etat_processus).instruction_courante = 1849: tampon; 1850: return; 1851: } 1852: 1853: if (indicateur_48 == d_vrai) 1854: { 1855: sf(s_etat_processus, 48); 1856: } 1857: else 1858: { 1859: cf(s_etat_processus, 48); 1860: } 1861: 1862: free((*s_etat_processus).instruction_courante); 1863: (*s_etat_processus).instruction_courante = 1864: tampon; 1865: 1866: element++; 1867: } 1868: 1869: break; 1870: } 1871: 1872: case SQLITE_DONE: 1873: { 1874: // Fin de la liste 1875: break; 1876: } 1877: 1878: case SQLITE_BUSY: 1879: case SQLITE_LOCKED: 1880: { 1881: nanosleep(&attente, NULL); 1882: INCR_GRANULARITE(attente.tv_nsec); 1883: break; 1884: } 1885: 1886: default: 1887: { 1888: (*s_etat_processus).erreur_systeme = 1889: d_es_erreur_fichier; 1890: return; 1891: } 1892: } 1893: } while(ios != SQLITE_DONE); 1894: 1895: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1896: { 1897: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1898: return; 1899: } 1900: 1901: free(commande); 1902: free(clef_utf8); 1903: 1904: liberation(s_etat_processus, s_objet_argument_2); 1905: 1906: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 1907: == NULL) 1908: { 1909: (*s_etat_processus).erreur_systeme = 1910: d_es_allocation_memoire; 1911: return; 1912: } 1913: 1914: l_element_courant = NULL; 1915: l_element_inclus = NULL; 1916: 1917: for(element--; element > 0; element--) 1918: { 1919: if (depilement(s_etat_processus, &((*s_etat_processus) 1920: .l_base_pile), &s_objet_argument_2) == d_erreur) 1921: { 1922: (*s_etat_processus).erreur_systeme = 1923: d_es_erreur_fichier; 1924: return; 1925: } 1926: 1927: if ((*s_objet_argument_2).type != LST) 1928: { 1929: (*s_etat_processus).erreur_systeme = 1930: d_es_erreur_fichier; 1931: return; 1932: } 1933: 1934: l_element_inclus = (*s_objet_argument_2).objet; 1935: 1936: if (l_element_inclus != NULL) 1937: { 1938: while(l_element_inclus != NULL) 1939: { 1940: if ((*l_element_inclus).suivant == NULL) 1941: { 1942: (*l_element_inclus).suivant = l_element_courant; 1943: break; 1944: } 1945: 1946: l_element_inclus = (*l_element_inclus).suivant; 1947: } 1948: 1949: l_element_courant = (*s_objet_argument_2).objet; 1950: (*s_objet_argument_2).objet = NULL; 1951: } 1952: 1953: liberation(s_etat_processus, s_objet_argument_2); 1954: } 1955: 1956: (*s_objet_resultat).objet = l_element_inclus; 1957: 1958: if (empilement(s_etat_processus, 1959: &((*s_etat_processus).l_base_pile), 1960: s_objet_resultat) == d_erreur) 1961: { 1962: return; 1963: } 1964: } 1965: } 1966: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire 1967: == 'Y') 1968: { 1969: /* 1970: * Fichiers non formatés 1971: */ 1972: 1973: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 1974: == 'S') 1975: { 1976: /* 1977: * Fichiers séquentiels 1978: * 1979: * Les fichiers séquentiels non formatés contiennent comme 1980: * les fichiers séquentiels formatés leurs enregistrements 1981: * sous la forme de listes les unes derrières les autres. 1982: * 1983: * Le quartet de poids fort du premier octet à lire 1984: * doit donc être égal à 0100. Si ce n'est pas le cas, 1985: * il sera impossible de lire le fichier et on renvoie 1986: * immédiatement une erreur. Si on lit dans le fichier 1987: * la valeur attendue, on récupère la longueur en octet 1988: * de l'enregistrement puis on le lit. 1989: */ 1990: 1991: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); 1992: 1993: if ((s_objet_resultat = lecture_fichier_non_formate( 1994: s_etat_processus, (*descripteur).descripteur_c, -1, 1995: d_faux)) == NULL) 1996: { 1997: return; 1998: } 1999: 2000: if (empilement(s_etat_processus, 2001: &((*s_etat_processus).l_base_pile), 2002: s_objet_resultat) == d_erreur) 2003: { 2004: return; 2005: } 2006: } 2007: } 2008: else 2009: { 2010: /* 2011: * Fichiers de type FLOW 2012: */ 2013: 2014: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 2015: == 'S') 2016: { 2017: /* 2018: * Fichiers séquentiels 2019: */ 2020: 2021: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); 2022: longueur_enregistrement = 0; 2023: 2024: device = d_faux; 2025: 2026: if ((position_initiale = ftell((*descripteur).descripteur_c)) 2027: == -1) 2028: { 2029: if (errno == ESPIPE) 2030: { 2031: device = d_vrai; 2032: } 2033: else 2034: { 2035: (*s_etat_processus).erreur_systeme = 2036: d_es_erreur_fichier; 2037: return; 2038: } 2039: } 2040: 2041: l_element_courant_format = (struct_liste_chainee *) 2042: (*(*((struct_fichier *) (*s_objet_argument_1).objet)) 2043: .format).objet; 2044: l_element_courant = NULL; 2045: 2046: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 2047: == NULL) 2048: { 2049: (*s_etat_processus).erreur_systeme = 2050: d_es_allocation_memoire; 2051: return; 2052: } 2053: 2054: while(l_element_courant_format != NULL) 2055: { 2056: if ((*(*l_element_courant_format).donnee).type != CHN) 2057: { 2058: liberation(s_etat_processus, s_objet_argument_1); 2059: liberation(s_etat_processus, s_objet_resultat); 2060: 2061: (*s_etat_processus).erreur_execution = 2062: d_ex_erreur_type_argument; 2063: return; 2064: } 2065: 2066: if ((format_chaine = conversion_majuscule( 2067: s_etat_processus, (unsigned char *) 2068: (*(*l_element_courant_format).donnee).objet)) 2069: == NULL) 2070: { 2071: (*s_etat_processus).erreur_systeme = 2072: d_es_allocation_memoire; 2073: return; 2074: } 2075: 2076: if (strcmp("LINE*(*)", format_chaine) == 0) 2077: { 2078: format_degenere = d_vrai; 2079: format_oriente_ligne = d_vrai; 2080: } 2081: else 2082: { 2083: format_oriente_ligne = d_faux; 2084: 2085: if (strncmp("LENGTH*(", format_chaine, 8) != 0) 2086: { 2087: liberation(s_etat_processus, s_objet_argument_1); 2088: liberation(s_etat_processus, s_objet_resultat); 2089: free(format_chaine); 2090: 2091: (*s_etat_processus).erreur_execution = 2092: d_ex_erreur_format_fichier; 2093: return; 2094: } 2095: 2096: longueur = (integer8) strlen(format_chaine); 2097: 2098: if (format_chaine[longueur - 1] != ')') 2099: { 2100: liberation(s_etat_processus, s_objet_argument_1); 2101: liberation(s_etat_processus, s_objet_resultat); 2102: free(format_chaine); 2103: 2104: (*s_etat_processus).erreur_execution = 2105: d_ex_erreur_format_fichier; 2106: return; 2107: } 2108: 2109: format_chaine[longueur] = d_code_fin_chaine; 2110: 2111: if (format_chaine[8] == '*') 2112: { 2113: format_degenere = d_vrai; 2114: } 2115: else 2116: { 2117: // Détermination de la longueur 2118: format_degenere = d_faux; 2119: 2120: if (sscanf(&(format_chaine[8]), "%lld", &longueur) 2121: != 1) 2122: { 2123: liberation(s_etat_processus, 2124: s_objet_argument_1); 2125: liberation(s_etat_processus, s_objet_resultat); 2126: free(format_chaine); 2127: 2128: (*s_etat_processus).erreur_execution = 2129: d_ex_erreur_format_fichier; 2130: return; 2131: } 2132: } 2133: } 2134: 2135: free(format_chaine); 2136: tampon3 = NULL; 2137: 2138: if (format_degenere == d_vrai) 2139: { 2140: if (device == d_vrai) 2141: { 2142: longueur_questure = 4096; 2143: index = 0; 2144: 2145: if ((tampon3 = malloc(((size_t) longueur_questure) * 2146: sizeof(unsigned char))) == NULL) 2147: { 2148: (*s_etat_processus).erreur_systeme = 2149: d_es_allocation_memoire; 2150: return; 2151: } 2152: 2153: tampon3[index] = d_code_fin_chaine; 2154: 2155: fds[0].fd = fileno((*descripteur).descripteur_c); 2156: fds[0].events = POLLIN; 2157: fds[0].revents = 0; 2158: 2159: tcgetattr(fileno((*descripteur).descripteur_c), 2160: &tc); 2161: timeout = 0; 2162: 2163: for(i = 0; vitesses[i] != 0; i++) 2164: { 2165: if (cfgetispeed(&tc) == vitesses_constantes[i]) 2166: { 2167: // La durée entre deux caractères sur le 2168: // périphérique série ne doit pas dépasser 2169: // la moitié de la durée de transmission 2170: // d'un caractère complet. 2171: 2172: timeout = (int) (((double) 1000) / 2173: (((double) vitesses_constantes[i]) / 2174: 4)); 2175: break; 2176: } 2177: } 2178: } 2179: else 2180: { 2181: // Évite un warning de gcc. 2182: longueur_questure = 0; 2183: index = 0; 2184: timeout = 0; 2185: } 2186: 2187: do 2188: { 2189: if (device == d_vrai) 2190: { 2191: if (poll(fds, 1, timeout) == 0) 2192: { 2193: break; 2194: } 2195: } 2196: 2197: c = getc((*descripteur).descripteur_c); 2198: longueur_enregistrement++; 2199: 2200: if (device == d_vrai) 2201: { 2202: if (longueur_enregistrement >= 2203: longueur_questure) 2204: { 2205: if ((tampon3 = realloc(tampon3, 2206: (size_t) (longueur_questure *= 2))) 2207: == NULL) 2208: { 2209: (*s_etat_processus).erreur_systeme = 2210: d_es_allocation_memoire; 2211: return; 2212: } 2213: } 2214: 2215: tampon3[index++] = (unsigned char) c; 2216: } 2217: 2218: if (format_oriente_ligne == d_vrai) 2219: { 2220: if (c == '\n') 2221: { 2222: break; 2223: } 2224: } 2225: } while(c != EOF); 2226: 2227: if (device == d_faux) 2228: { 2229: if (fseek((*descripteur).descripteur_c, 2230: (long) position_initiale, SEEK_SET) != 0) 2231: { 2232: liberation(s_etat_processus, 2233: s_objet_argument_1); 2234: liberation(s_etat_processus, s_objet_resultat); 2235: 2236: (*s_etat_processus).erreur_systeme = 2237: d_es_erreur_fichier; 2238: return; 2239: } 2240: } 2241: } 2242: else 2243: { 2244: longueur_enregistrement = longueur; 2245: } 2246: 2247: if ((device == d_vrai) && (format_degenere == d_vrai)) 2248: { 2249: longueur_effective = longueur_enregistrement; 2250: tampon_lecture = tampon3; 2251: } 2252: else 2253: { 2254: if ((tampon_lecture = malloc(((size_t) 2255: longueur_enregistrement) * 2256: sizeof(unsigned char))) == NULL) 2257: { 2258: (*s_etat_processus).erreur_systeme = 2259: d_es_allocation_memoire; 2260: return; 2261: } 2262: 2263: longueur_effective = (integer8) fread(tampon_lecture, 2264: sizeof(unsigned char), 2265: (size_t) longueur_enregistrement, 2266: (*descripteur).descripteur_c); 2267: } 2268: 2269: if (l_element_courant == NULL) 2270: { 2271: // Premier maillon de la liste 2272: if (((*s_objet_resultat).objet = 2273: allocation_maillon(s_etat_processus)) == NULL) 2274: { 2275: (*s_etat_processus).erreur_systeme = 2276: d_es_allocation_memoire; 2277: return; 2278: } 2279: 2280: l_element_courant = (*s_objet_resultat).objet; 2281: } 2282: else 2283: { 2284: if (((*l_element_courant).suivant = 2285: allocation_maillon(s_etat_processus)) == NULL) 2286: { 2287: (*s_etat_processus).erreur_systeme = 2288: d_es_allocation_memoire; 2289: return; 2290: } 2291: 2292: l_element_courant = (*l_element_courant).suivant; 2293: } 2294: 2295: (*l_element_courant).suivant = NULL; 2296: 2297: if (((*l_element_courant).donnee = 2298: allocation(s_etat_processus, CHN)) == NULL) 2299: { 2300: (*s_etat_processus).erreur_systeme = 2301: d_es_allocation_memoire; 2302: return; 2303: } 2304: 2305: if (format_degenere == d_vrai) 2306: { 2307: if (device == d_faux) 2308: { 2309: if (((*(*l_element_courant).donnee).objet = 2310: analyse_flux(s_etat_processus, tampon_lecture, 2311: longueur_enregistrement - 1)) == NULL) 2312: { 2313: return; 2314: } 2315: } 2316: else 2317: { 2318: if (((*(*l_element_courant).donnee).objet = 2319: analyse_flux(s_etat_processus, tampon_lecture, 2320: longueur_enregistrement)) == NULL) 2321: { 2322: return; 2323: } 2324: } 2325: } 2326: else 2327: { 2328: if (((*(*l_element_courant).donnee).objet = 2329: analyse_flux(s_etat_processus, tampon_lecture, 2330: longueur_enregistrement)) == NULL) 2331: { 2332: return; 2333: } 2334: } 2335: 2336: free(tampon_lecture); 2337: 2338: l_element_courant_format = 2339: (*l_element_courant_format).suivant; 2340: } 2341: 2342: if (empilement(s_etat_processus, 2343: &((*s_etat_processus).l_base_pile), 2344: s_objet_resultat) == d_erreur) 2345: { 2346: return; 2347: } 2348: } 2349: else 2350: { 2351: liberation(s_etat_processus, s_objet_argument_1); 2352: 2353: (*s_etat_processus).erreur_execution = 2354: d_ex_erreur_type_fichier; 2355: return; 2356: } 2357: } 2358: } 2359: else if ((*s_objet_argument_1).type == SCK) 2360: { 2361: /* 2362: * Vérification de l'autorisation de lecture 2363: */ 2364: 2365: if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection 2366: == 'W') 2367: { 2368: liberation(s_etat_processus, s_objet_argument_1); 2369: 2370: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; 2371: return; 2372: } 2373: 2374: /* 2375: * Vérification de l'écoute de la socket si celle-ci est connectée 2376: */ 2377: 2378: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, 2379: "STREAM") == 0) || (strcmp((*((struct_socket *) 2380: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM") 2381: == 0)) 2382: { 2383: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2384: .socket_en_ecoute == 'Y') 2385: { 2386: liberation(s_etat_processus, s_objet_argument_1); 2387: 2388: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute; 2389: return; 2390: } 2391: } 2392: 2393: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N') 2394: { // Socket formatée 2395: longueur_questure = 4096; 2396: longueur_effective = 0; 2397: tampon_lecture = NULL; 2398: 2399: attente.tv_sec = 0; 2400: attente.tv_nsec = GRANULARITE_us * 1000; 2401: 2402: trame_complete = d_faux; 2403: position_initiale = 0; 2404: position_finale = 0; 2405: 2406: do 2407: { 2408: presence_indicateur = d_faux; 2409: 2410: if ((tampon_lecture = realloc(tampon_lecture, 2411: ((size_t) (longueur_effective + longueur_questure + 1)) 2412: * sizeof(unsigned char))) == NULL) 2413: { 2414: (*s_etat_processus).erreur_systeme = 2415: d_es_allocation_memoire; 2416: return; 2417: } 2418: 2419: # ifndef SEMAPHORES_NOMMES 2420: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 2421: # else 2422: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 2423: # endif 2424: { 2425: (*s_etat_processus).erreur_systeme = d_es_processus; 2426: return; 2427: } 2428: 2429: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2430: .domaine == PF_UNIX) 2431: { 2432: longueur_adresse = sizeof(adresse_unix); 2433: 2434: do 2435: { 2436: ios = (int) recvfrom((*((struct_socket *) 2437: (*s_objet_argument_1).objet)).socket, 2438: tampon_lecture, (size_t) (longueur_effective + 2439: longueur_questure), 2440: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2441: &adresse_unix, &longueur_adresse); 2442: } while((ios == -1) && (errno == EINTR)); 2443: } 2444: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2445: .domaine == PF_INET) 2446: { 2447: longueur_adresse = sizeof(adresse_ipv4); 2448: 2449: do 2450: { 2451: ios = (int) recvfrom((*((struct_socket *) 2452: (*s_objet_argument_1).objet)).socket, 2453: tampon_lecture, (size_t) (longueur_effective + 2454: longueur_questure), 2455: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2456: &adresse_ipv4, &longueur_adresse); 2457: } while((ios == -1) && (errno == EINTR)); 2458: } 2459: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2460: .domaine == PF_INET6) 2461: { 2462: # ifdef IPV6 2463: longueur_adresse = sizeof(adresse_ipv6); 2464: 2465: do 2466: { 2467: ios = (int) recvfrom((*((struct_socket *) 2468: (*s_objet_argument_1).objet)).socket, 2469: tampon_lecture, (size_t) (longueur_effective + 2470: longueur_questure), 2471: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2472: &adresse_ipv6, &longueur_adresse); 2473: } while((ios == -1) && (errno == EINTR)); 2474: # else 2475: if ((*s_etat_processus).langue == 'F') 2476: { 2477: printf("+++Attention : Support du protocole" 2478: " IPv6 indisponible\n"); 2479: } 2480: else 2481: { 2482: printf("+++Warning : IPv6 support " 2483: "unavailable\n"); 2484: } 2485: 2486: longueur_adresse = 0; 2487: longueur_effective = 0; 2488: ios = 0; 2489: # endif 2490: } 2491: else 2492: { 2493: free(tampon_lecture); 2494: liberation(s_etat_processus, s_objet_argument_1); 2495: 2496: # ifndef SEMAPHORES_NOMMES 2497: while(sem_wait(&((*s_etat_processus) 2498: .semaphore_fork)) != 0) 2499: # else 2500: while(sem_wait((*s_etat_processus) 2501: .semaphore_fork) != 0) 2502: # endif 2503: { 2504: (*s_etat_processus).erreur_systeme = 2505: d_es_processus; 2506: } 2507: 2508: (*s_etat_processus).erreur_execution = 2509: d_ex_erreur_acces_fichier; 2510: return; 2511: } 2512: 2513: if (ios <= 0) 2514: { 2515: nanosleep(&attente, NULL); 2516: INCR_GRANULARITE(attente.tv_nsec); 2517: } 2518: else 2519: { 2520: attente.tv_sec = 0; 2521: attente.tv_nsec = GRANULARITE_us * 1000; 2522: } 2523: 2524: scrutation_injection(s_etat_processus); 2525: 2526: if ((*s_etat_processus).var_volatile_requete_arret == -1) 2527: { 2528: if (ios >= 0) 2529: { 2530: longueur_effective = ios; 2531: } 2532: 2533: break; 2534: } 2535: 2536: // Une donnée a été reçue. 2537: 2538: if (ios >= 0) 2539: { 2540: longueur_effective = ios; 2541: position_initiale = 0; 2542: presence_indicateur = d_faux; 2543: 2544: do 2545: { 2546: if (tampon_lecture[position_initiale] == '{') 2547: { 2548: presence_indicateur = d_vrai; 2549: break; 2550: } 2551: 2552: position_initiale++; 2553: } while(position_initiale < longueur_effective); 2554: 2555: if (presence_indicateur == d_vrai) 2556: { 2557: position_finale = position_initiale + 1; 2558: presence_chaine = d_faux; 2559: presence_indicateur = d_faux; 2560: niveau = 1; 2561: 2562: while(position_finale < longueur_effective) 2563: { 2564: caractere = tampon_lecture[position_finale]; 2565: 2566: if (caractere == '"') 2567: { 2568: if (position_finale > 0) 2569: { 2570: if (tampon_lecture[position_finale - 1] 2571: != '\\') 2572: { 2573: presence_chaine = (presence_chaine == 2574: d_vrai) ? d_faux : d_vrai; 2575: } 2576: } 2577: else 2578: { 2579: presence_chaine = 2580: (presence_chaine == d_vrai) 2581: ? d_faux : d_vrai; 2582: } 2583: } 2584: else 2585: { 2586: if (presence_chaine == d_faux) 2587: { 2588: if (caractere == '{') 2589: { 2590: niveau++; 2591: } 2592: else if (caractere == '}') 2593: { 2594: niveau--; 2595: } 2596: } 2597: } 2598: 2599: if (niveau == 0) 2600: { 2601: presence_indicateur = d_vrai; 2602: trame_complete = d_vrai; 2603: break; 2604: } 2605: 2606: position_finale++; 2607: } 2608: } 2609: 2610: // On retire une trame du buffer. 2611: 2612: if (trame_complete == d_vrai) 2613: { 2614: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2615: .domaine == PF_UNIX) 2616: { 2617: do 2618: { 2619: longueur_adresse = sizeof(adresse_unix); 2620: recvfrom((*((struct_socket *) 2621: (*s_objet_argument_1).objet)).socket, 2622: tampon_lecture, 2623: (size_t) longueur_effective, 2624: 0, (struct sockaddr *) 2625: &adresse_unix, &longueur_adresse); 2626: } while((ios == -1) && (errno == EINTR)); 2627: } 2628: else if ((*((struct_socket *) (*s_objet_argument_1) 2629: .objet)).domaine == PF_INET) 2630: { 2631: do 2632: { 2633: longueur_adresse = sizeof(adresse_ipv4); 2634: recvfrom((*((struct_socket *) 2635: (*s_objet_argument_1).objet)).socket, 2636: tampon_lecture, 2637: (size_t) longueur_effective, 2638: 0, (struct sockaddr *) 2639: &adresse_ipv4, &longueur_adresse); 2640: } while((ios == -1) && (errno == EINTR)); 2641: } 2642: else if ((*((struct_socket *) (*s_objet_argument_1) 2643: .objet)) .domaine == PF_INET6) 2644: { 2645: # ifdef IPV6 2646: do 2647: { 2648: longueur_adresse = sizeof(adresse_ipv6); 2649: recvfrom((*((struct_socket *) 2650: (*s_objet_argument_1).objet)).socket, 2651: tampon_lecture, 2652: (size_t) longueur_effective, 2653: 0, (struct sockaddr *) 2654: &adresse_ipv6, &longueur_adresse); 2655: } while((ios == -1) && (errno == EINTR)); 2656: # else 2657: if ((*s_etat_processus).langue == 'F') 2658: { 2659: printf("+++Attention : Support du protocole" 2660: " IPv6 indisponible\n"); 2661: } 2662: else 2663: { 2664: printf("+++Warning : IPv6 support " 2665: "unavailable\n"); 2666: } 2667: 2668: # endif 2669: } 2670: 2671: longueur_effective = ios; 2672: } 2673: else 2674: { 2675: // Si on a lu toute une trame et qu'on n'a pas 2676: // réussi à en trouver la structure, on remonte 2677: // une erreur de syntaxe. 2678: 2679: if (longueur_effective == ios) 2680: { 2681: if ((*((struct_socket *) (*s_objet_argument_1) 2682: .objet)).domaine == PF_UNIX) 2683: { 2684: do 2685: { 2686: longueur_adresse = sizeof(adresse_unix); 2687: recvfrom((*((struct_socket *) 2688: (*s_objet_argument_1).objet)) 2689: .socket, tampon_lecture, 2690: (size_t) longueur_effective, 2691: 0, (struct sockaddr *) 2692: &adresse_unix, &longueur_adresse); 2693: } while((ios == -1) && (errno == EINTR)); 2694: } 2695: else if ((*((struct_socket *) (*s_objet_argument_1) 2696: .objet)).domaine == PF_INET) 2697: { 2698: do 2699: { 2700: longueur_adresse = sizeof(adresse_ipv4); 2701: recvfrom((*((struct_socket *) 2702: (*s_objet_argument_1).objet)) 2703: .socket, tampon_lecture, 2704: (size_t) longueur_effective, 2705: 0, (struct sockaddr *) 2706: &adresse_ipv4, &longueur_adresse); 2707: } while((ios == -1) && (errno == EINTR)); 2708: } 2709: else if ((*((struct_socket *) (*s_objet_argument_1) 2710: .objet)) .domaine == PF_INET6) 2711: { 2712: # ifdef IPV6 2713: do 2714: { 2715: longueur_adresse = sizeof(adresse_ipv6); 2716: recvfrom((*((struct_socket *) 2717: (*s_objet_argument_1).objet)) 2718: .socket, tampon_lecture, 2719: (size_t) longueur_effective, 2720: 0, (struct sockaddr *) 2721: &adresse_ipv6, &longueur_adresse); 2722: } while((ios == -1) && (errno == EINTR)); 2723: # else 2724: if ((*s_etat_processus).langue == 'F') 2725: { 2726: printf("+++Attention : Support du protocole" 2727: " IPv6 indisponible\n"); 2728: } 2729: else 2730: { 2731: printf("+++Warning : IPv6 support " 2732: "unavailable\n"); 2733: } 2734: 2735: # endif 2736: } 2737: 2738: liberation(s_etat_processus, s_objet_argument_1); 2739: free(tampon_lecture); 2740: 2741: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 2742: return; 2743: } 2744: } 2745: } 2746: 2747: # ifndef SEMAPHORES_NOMMES 2748: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) 2749: # else 2750: while(sem_wait((*s_etat_processus).semaphore_fork) != 0) 2751: # endif 2752: { 2753: if (errno == EINTR) 2754: { 2755: (*s_etat_processus).erreur_systeme = d_es_processus; 2756: return; 2757: } 2758: } 2759: 2760: if ((*s_etat_processus).var_volatile_requete_arret == -1) 2761: { 2762: 2763: /* 2764: * Si le père tue le processus courant grâce au signal 2765: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement 2766: * correspond à l'utilisation de STOP sur le processus 2767: * en cours. La variable longueur_effective vaut '-1'. 2768: */ 2769: 2770: free(tampon_lecture); 2771: liberation(s_etat_processus, s_objet_argument_1); 2772: return; 2773: } 2774: 2775: if (longueur_effective == -1) 2776: { 2777: free(tampon_lecture); 2778: liberation(s_etat_processus, s_objet_argument_1); 2779: 2780: (*s_etat_processus).erreur_execution = 2781: d_ex_erreur_acces_fichier; 2782: return; 2783: } 2784: } while(trame_complete == d_faux); 2785: 2786: tampon_lecture[++position_finale] = d_code_fin_chaine; 2787: tampon = (*s_etat_processus).instruction_courante; 2788: (*s_etat_processus).instruction_courante = tampon_lecture; 2789: 2790: indicateur_48 = test_cfsf(s_etat_processus, 48); 2791: cf(s_etat_processus, 48); 2792: 2793: (*s_etat_processus).type_en_cours = NON; 2794: recherche_type(s_etat_processus); 2795: 2796: if ((*s_etat_processus).erreur_execution != d_ex) 2797: { 2798: (*s_etat_processus).instruction_courante = tampon; 2799: free(tampon_lecture); 2800: 2801: if (indicateur_48 == d_vrai) 2802: { 2803: sf(s_etat_processus, 48); 2804: } 2805: else 2806: { 2807: cf(s_etat_processus, 48); 2808: } 2809: 2810: if ((*s_etat_processus).var_volatile_requete_arret == -1) 2811: { 2812: (*s_etat_processus).erreur_execution = d_ex; 2813: } 2814: 2815: liberation(s_etat_processus, s_objet_argument_1); 2816: return; 2817: } 2818: 2819: if (indicateur_48 == d_vrai) 2820: { 2821: sf(s_etat_processus, 48); 2822: } 2823: else 2824: { 2825: cf(s_etat_processus, 48); 2826: } 2827: 2828: (*s_etat_processus).instruction_courante = tampon; 2829: 2830: /* 2831: * Création de la liste de sortie 2832: */ 2833: 2834: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2835: &s_objet_type) == d_erreur) 2836: { 2837: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 2838: return; 2839: } 2840: 2841: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 2842: == NULL) 2843: { 2844: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2845: return; 2846: } 2847: 2848: if (((*s_objet_resultat).objet = 2849: allocation_maillon(s_etat_processus)) == NULL) 2850: { 2851: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2852: return; 2853: } 2854: 2855: (*((struct_liste_chainee *) (*s_objet_resultat).objet)) 2856: .donnee = s_objet_type; 2857: 2858: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) 2859: .suivant = allocation_maillon(s_etat_processus)) == NULL) 2860: { 2861: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2862: return; 2863: } 2864: 2865: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 2866: .suivant = NULL; 2867: 2868: if ((s_objet_adresse = allocation(s_etat_processus, LST)) 2869: == NULL) 2870: { 2871: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2872: return; 2873: } 2874: 2875: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 2876: .donnee = s_objet_adresse; 2877: 2878: /* 2879: * Les informations concernant la cible sont valides si 2880: * la socket est non connectée et des domaines INET ou INET6. 2881: * Dans tous les autres cas, on renvoie une liste vide. 2882: */ 2883: 2884: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine 2885: == PF_UNIX) || (strcmp((*((struct_socket *) 2886: (*s_objet_argument_1).objet)).type, "STREAM") == 0) || 2887: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) 2888: .type, "SEQUENTIAL DATAGRAM") == 0)) 2889: { 2890: (*s_objet_adresse).objet = NULL; 2891: } 2892: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2893: .domaine == PF_INET) 2894: { 2895: if (((*s_objet_adresse).objet = 2896: allocation_maillon(s_etat_processus)) == NULL) 2897: { 2898: (*s_etat_processus).erreur_systeme = 2899: d_es_allocation_memoire; 2900: return; 2901: } 2902: 2903: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2904: .donnee = allocation(s_etat_processus, VIN)) == NULL) 2905: { 2906: (*s_etat_processus).erreur_systeme = 2907: d_es_allocation_memoire; 2908: return; 2909: } 2910: 2911: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 2912: (*s_objet_adresse).objet)).donnee).objet)).taille = 4; 2913: 2914: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 2915: (*s_objet_adresse).objet)).donnee).objet)).tableau = 2916: malloc(4 * sizeof(integer8))) == NULL) 2917: { 2918: (*s_etat_processus).erreur_systeme = 2919: d_es_allocation_memoire; 2920: return; 2921: } 2922: 2923: ((integer8 *) (*((struct_vecteur *) 2924: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2925: .objet)).donnee).objet)).tableau)[0] = 2926: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; 2927: ((integer8 *) (*((struct_vecteur *) 2928: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2929: .objet)).donnee).objet)).tableau)[1] = 2930: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; 2931: ((integer8 *) (*((struct_vecteur *) 2932: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2933: .objet)).donnee).objet)).tableau)[2] = 2934: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; 2935: ((integer8 *) (*((struct_vecteur *) 2936: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2937: .objet)).donnee).objet)).tableau)[3] = 2938: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; 2939: 2940: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2941: .suivant = allocation_maillon(s_etat_processus)) 2942: == NULL) 2943: { 2944: (*s_etat_processus).erreur_systeme = 2945: d_es_allocation_memoire; 2946: return; 2947: } 2948: 2949: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2950: .suivant).donnee = allocation(s_etat_processus, INT)) 2951: == NULL) 2952: { 2953: (*s_etat_processus).erreur_systeme = 2954: d_es_allocation_memoire; 2955: return; 2956: } 2957: 2958: (*((integer8 *) (*(*(*((struct_liste_chainee *) 2959: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 2960: (integer8) ntohs(adresse_ipv4.sin_port); 2961: 2962: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2963: .suivant).suivant = NULL; 2964: } 2965: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2966: .domaine == PF_INET6) 2967: { 2968: # ifdef IPV6 2969: if (((*s_objet_adresse).objet = 2970: allocation_maillon(s_etat_processus)) == NULL) 2971: { 2972: (*s_etat_processus).erreur_systeme = 2973: d_es_allocation_memoire; 2974: return; 2975: } 2976: 2977: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2978: .donnee = allocation(s_etat_processus, VIN)) == NULL) 2979: { 2980: (*s_etat_processus).erreur_systeme = 2981: d_es_allocation_memoire; 2982: return; 2983: } 2984: 2985: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 2986: (*s_objet_adresse).objet)).donnee).objet)).taille = 16; 2987: 2988: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 2989: (*s_objet_adresse).objet)).donnee).objet)).tableau = 2990: malloc(16 * sizeof(integer8))) == NULL) 2991: { 2992: (*s_etat_processus).erreur_systeme = 2993: d_es_allocation_memoire; 2994: return; 2995: } 2996: 2997: for(i = 0; i < 16; i++) 2998: { 2999: ((integer8 *) (*((struct_vecteur *) 3000: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3001: .objet)).donnee).objet)).tableau)[0] = 3002: adresse_ipv6.sin6_addr.s6_addr[i]; 3003: } 3004: 3005: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3006: .suivant = allocation_maillon(s_etat_processus)) 3007: == NULL) 3008: { 3009: (*s_etat_processus).erreur_systeme = 3010: d_es_allocation_memoire; 3011: return; 3012: } 3013: 3014: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3015: .suivant).donnee = allocation(s_etat_processus, INT)) 3016: == NULL) 3017: { 3018: (*s_etat_processus).erreur_systeme = 3019: d_es_allocation_memoire; 3020: return; 3021: } 3022: 3023: (*((integer8 *) (*(*(*((struct_liste_chainee *) 3024: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 3025: (integer8) ntohs(adresse_ipv6.sin6_port); 3026: 3027: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3028: .suivant).suivant = NULL; 3029: # else 3030: if ((*s_etat_processus).langue == 'F') 3031: { 3032: printf("+++Attention : Support du protocole" 3033: " IPv6 indisponible\n"); 3034: } 3035: else 3036: { 3037: printf("+++Warning : IPv6 support " 3038: "unavailable\n"); 3039: } 3040: # endif 3041: } 3042: else 3043: { 3044: longueur_adresse = 0; 3045: recvfrom((*((struct_socket *) 3046: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3047: (size_t) position_finale, MSG_DONTWAIT, 3048: NULL, &longueur_adresse); 3049: } 3050: 3051: free(tampon_lecture); 3052: 3053: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3054: s_objet_resultat) == d_erreur) 3055: { 3056: return; 3057: } 3058: } 3059: else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire 3060: == 'Y') 3061: { // socket non formatée 3062: longueur_questure = 4096; 3063: longueur_effective = 0; 3064: tampon_lecture = NULL; 3065: 3066: attente.tv_sec = 0; 3067: attente.tv_nsec = GRANULARITE_us * 1000; 3068: 3069: trame_complete = d_faux; 3070: position_initiale = 0; 3071: position_finale = 0; 3072: 3073: do 3074: { 3075: presence_indicateur = d_faux; 3076: 3077: if ((tampon_lecture = realloc(tampon_lecture, 3078: ((size_t) (longueur_effective + longueur_questure) + 1) 3079: * sizeof(unsigned char))) == NULL) 3080: { 3081: (*s_etat_processus).erreur_systeme = 3082: d_es_allocation_memoire; 3083: return; 3084: } 3085: 3086: # ifndef SEMAPHORES_NOMMES 3087: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 3088: # else 3089: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 3090: # endif 3091: { 3092: (*s_etat_processus).erreur_systeme = d_es_processus; 3093: return; 3094: } 3095: 3096: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3097: .domaine == PF_UNIX) 3098: { 3099: longueur_adresse = sizeof(adresse_unix); 3100: 3101: do 3102: { 3103: ios = (int) recvfrom((*((struct_socket *) 3104: (*s_objet_argument_1).objet)).socket, 3105: tampon_lecture, (size_t) 3106: (longueur_effective + longueur_questure), 3107: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 3108: &adresse_unix, &longueur_adresse); 3109: } while((ios == -1) && (errno == EINTR)); 3110: } 3111: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3112: .domaine == PF_INET) 3113: { 3114: longueur_adresse = sizeof(adresse_ipv4); 3115: 3116: do 3117: { 3118: ios = (int) recvfrom((*((struct_socket *) 3119: (*s_objet_argument_1).objet)).socket, 3120: tampon_lecture, (size_t) 3121: (longueur_effective + longueur_questure), 3122: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 3123: &adresse_ipv4, &longueur_adresse); 3124: } while((ios == -1) && (errno == EINTR)); 3125: } 3126: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3127: .domaine == PF_INET6) 3128: { 3129: # ifdef IPV6 3130: longueur_adresse = sizeof(adresse_ipv6); 3131: 3132: do 3133: { 3134: ios = (int) recvfrom((*((struct_socket *) 3135: (*s_objet_argument_1).objet)).socket, 3136: tampon_lecture, (size_t) 3137: (longueur_effective + longueur_questure), 3138: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 3139: &adresse_ipv6, &longueur_adresse); 3140: } while((ios == -1) && (errno == EINTR)); 3141: # else 3142: if ((*s_etat_processus).langue == 'F') 3143: { 3144: printf("+++Attention : Support du protocole" 3145: " IPv6 indisponible\n"); 3146: } 3147: else 3148: { 3149: printf("+++Warning : IPv6 support " 3150: "unavailable\n"); 3151: } 3152: 3153: longueur_adresse = 0; 3154: longueur_effective = 0; 3155: ios = 0; 3156: # endif 3157: } 3158: else 3159: { 3160: free(tampon_lecture); 3161: liberation(s_etat_processus, s_objet_argument_1); 3162: 3163: # ifndef SEMAPHORES_NOMMES 3164: while(sem_wait(&((*s_etat_processus) 3165: .semaphore_fork)) != 0) 3166: # else 3167: while(sem_wait((*s_etat_processus) 3168: .semaphore_fork) != 0) 3169: # endif 3170: { 3171: (*s_etat_processus).erreur_systeme = 3172: d_es_processus; 3173: } 3174: 3175: (*s_etat_processus).erreur_execution = 3176: d_ex_erreur_acces_fichier; 3177: return; 3178: } 3179: 3180: if (ios <= 0) 3181: { 3182: nanosleep(&attente, NULL); 3183: INCR_GRANULARITE(attente.tv_nsec); 3184: } 3185: else 3186: { 3187: attente.tv_sec = 0; 3188: attente.tv_nsec = GRANULARITE_us * 1000; 3189: } 3190: 3191: scrutation_injection(s_etat_processus); 3192: 3193: if ((*s_etat_processus).var_volatile_requete_arret == -1) 3194: { 3195: if (ios >= 0) 3196: { 3197: longueur_effective += ios; 3198: } 3199: 3200: break; 3201: } 3202: 3203: // Une donnée a été reçue. 3204: 3205: if (ios == (longueur_effective + longueur_questure)) 3206: { 3207: longueur_effective = ios; 3208: position_initiale = 0; 3209: presence_indicateur = d_faux; 3210: } 3211: else if (ios > 0) 3212: { 3213: // On retire une trame du buffer. 3214: 3215: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3216: .domaine == PF_UNIX) 3217: { 3218: do 3219: { 3220: longueur_adresse = sizeof(adresse_unix); 3221: recvfrom((*((struct_socket *) 3222: (*s_objet_argument_1).objet)).socket, 3223: tampon_lecture, (size_t) longueur_effective, 3224: 0, (struct sockaddr *) 3225: &adresse_unix, &longueur_adresse); 3226: } while((ios == -1) && (errno == EINTR)); 3227: } 3228: else if ((*((struct_socket *) (*s_objet_argument_1) 3229: .objet)).domaine == PF_INET) 3230: { 3231: do 3232: { 3233: longueur_adresse = sizeof(adresse_ipv4); 3234: recvfrom((*((struct_socket *) 3235: (*s_objet_argument_1).objet)).socket, 3236: tampon_lecture, (size_t) longueur_effective, 3237: 0, (struct sockaddr *) 3238: &adresse_ipv4, &longueur_adresse); 3239: } while((ios == -1) && (errno == EINTR)); 3240: } 3241: else if ((*((struct_socket *) (*s_objet_argument_1) 3242: .objet)) .domaine == PF_INET6) 3243: { 3244: # ifdef IPV6 3245: do 3246: { 3247: longueur_adresse = sizeof(adresse_ipv6); 3248: recvfrom((*((struct_socket *) 3249: (*s_objet_argument_1).objet)).socket, 3250: tampon_lecture, (size_t) longueur_effective, 3251: 0, (struct sockaddr *) 3252: &adresse_ipv6, &longueur_adresse); 3253: } while((ios == -1) && (errno == EINTR)); 3254: # else 3255: if ((*s_etat_processus).langue == 'F') 3256: { 3257: printf("+++Attention : Support du protocole" 3258: " IPv6 indisponible\n"); 3259: } 3260: else 3261: { 3262: printf("+++Warning : IPv6 support " 3263: "unavailable\n"); 3264: } 3265: # endif 3266: } 3267: 3268: longueur_effective = ios; 3269: trame_complete = d_vrai; 3270: } 3271: 3272: # ifndef SEMAPHORES_NOMMES 3273: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) 3274: # else 3275: while(sem_wait((*s_etat_processus).semaphore_fork) != 0) 3276: # endif 3277: { 3278: if (errno == EINTR) 3279: { 3280: (*s_etat_processus).erreur_systeme = d_es_processus; 3281: return; 3282: } 3283: } 3284: 3285: if ((*s_etat_processus).var_volatile_requete_arret == -1) 3286: { 3287: 3288: /* 3289: * Si le père tue le processus courant grâce au signal 3290: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement 3291: * correspond à l'utilisation de STOP sur le processus 3292: * en cours. La variable longueur_effective vaut '-1'. 3293: */ 3294: 3295: free(tampon_lecture); 3296: liberation(s_etat_processus, s_objet_argument_1); 3297: return; 3298: } 3299: 3300: if (longueur_effective == -1) 3301: { 3302: free(tampon_lecture); 3303: liberation(s_etat_processus, s_objet_argument_1); 3304: 3305: (*s_etat_processus).erreur_execution = 3306: d_ex_erreur_acces_fichier; 3307: return; 3308: } 3309: } while(trame_complete == d_faux); 3310: 3311: /* 3312: * Création de la liste de sortie 3313: */ 3314: 3315: ptr = tampon_lecture; 3316: 3317: if ((s_objet_type = lecture_fichier_non_formate(s_etat_processus, 3318: &ptr, longueur_effective, d_faux)) == NULL) 3319: { 3320: free(tampon_lecture); 3321: 3322: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 3323: return; 3324: } 3325: 3326: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 3327: == NULL) 3328: { 3329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3330: return; 3331: } 3332: 3333: if (((*s_objet_resultat).objet = 3334: allocation_maillon(s_etat_processus)) == NULL) 3335: { 3336: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3337: return; 3338: } 3339: 3340: (*((struct_liste_chainee *) (*s_objet_resultat).objet)) 3341: .donnee = s_objet_type; 3342: 3343: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) 3344: .suivant = allocation_maillon(s_etat_processus)) == NULL) 3345: { 3346: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3347: return; 3348: } 3349: 3350: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 3351: .suivant = NULL; 3352: 3353: if ((s_objet_adresse = allocation(s_etat_processus, LST)) 3354: == NULL) 3355: { 3356: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3357: return; 3358: } 3359: 3360: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 3361: .donnee = s_objet_adresse; 3362: 3363: /* 3364: * Les informations concernant la cible sont valides si 3365: * la socket est non connectée et des domaines INET ou INET6. 3366: * Dans tous les autres cas, on renvoie une liste vide. 3367: */ 3368: 3369: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine 3370: == PF_UNIX) || (strcmp((*((struct_socket *) 3371: (*s_objet_argument_1).objet)).type, "STREAM") == 0) || 3372: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) 3373: .type, "SEQUENTIAL DATAGRAM") == 0)) 3374: { 3375: (*s_objet_adresse).objet = NULL; 3376: } 3377: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3378: .domaine == PF_INET) 3379: { 3380: if (((*s_objet_adresse).objet = 3381: allocation_maillon(s_etat_processus)) == NULL) 3382: { 3383: (*s_etat_processus).erreur_systeme = 3384: d_es_allocation_memoire; 3385: return; 3386: } 3387: 3388: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3389: .donnee = allocation(s_etat_processus, VIN)) == NULL) 3390: { 3391: (*s_etat_processus).erreur_systeme = 3392: d_es_allocation_memoire; 3393: return; 3394: } 3395: 3396: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 3397: (*s_objet_adresse).objet)).donnee).objet)).taille = 4; 3398: 3399: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 3400: (*s_objet_adresse).objet)).donnee).objet)).tableau = 3401: malloc(4 * sizeof(integer8))) == NULL) 3402: { 3403: (*s_etat_processus).erreur_systeme = 3404: d_es_allocation_memoire; 3405: return; 3406: } 3407: 3408: ((integer8 *) (*((struct_vecteur *) 3409: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3410: .objet)).donnee).objet)).tableau)[0] = 3411: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; 3412: ((integer8 *) (*((struct_vecteur *) 3413: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3414: .objet)).donnee).objet)).tableau)[1] = 3415: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; 3416: ((integer8 *) (*((struct_vecteur *) 3417: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3418: .objet)).donnee).objet)).tableau)[2] = 3419: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; 3420: ((integer8 *) (*((struct_vecteur *) 3421: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3422: .objet)).donnee).objet)).tableau)[3] = 3423: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; 3424: 3425: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3426: .suivant = allocation_maillon(s_etat_processus)) 3427: == NULL) 3428: { 3429: (*s_etat_processus).erreur_systeme = 3430: d_es_allocation_memoire; 3431: return; 3432: } 3433: 3434: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3435: .suivant).donnee = allocation(s_etat_processus, INT)) 3436: == NULL) 3437: { 3438: (*s_etat_processus).erreur_systeme = 3439: d_es_allocation_memoire; 3440: return; 3441: } 3442: 3443: (*((integer8 *) (*(*(*((struct_liste_chainee *) 3444: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 3445: (integer8) ntohs(adresse_ipv4.sin_port); 3446: 3447: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3448: .suivant).suivant = NULL; 3449: } 3450: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3451: .domaine == PF_INET6) 3452: { 3453: # ifdef IPV6 3454: if (((*s_objet_adresse).objet = 3455: allocation_maillon(s_etat_processus)) == NULL) 3456: { 3457: (*s_etat_processus).erreur_systeme = 3458: d_es_allocation_memoire; 3459: return; 3460: } 3461: 3462: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3463: .donnee = allocation(s_etat_processus, VIN)) == NULL) 3464: { 3465: (*s_etat_processus).erreur_systeme = 3466: d_es_allocation_memoire; 3467: return; 3468: } 3469: 3470: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 3471: (*s_objet_adresse).objet)).donnee).objet)).taille = 16; 3472: 3473: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 3474: (*s_objet_adresse).objet)).donnee).objet)).tableau = 3475: malloc(16 * sizeof(integer8))) == NULL) 3476: { 3477: (*s_etat_processus).erreur_systeme = 3478: d_es_allocation_memoire; 3479: return; 3480: } 3481: 3482: for(i = 0; i < 16; i++) 3483: { 3484: ((integer8 *) (*((struct_vecteur *) 3485: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3486: .objet)).donnee).objet)).tableau)[0] = 3487: adresse_ipv6.sin6_addr.s6_addr[i]; 3488: } 3489: 3490: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3491: .suivant = allocation_maillon(s_etat_processus)) 3492: == NULL) 3493: { 3494: (*s_etat_processus).erreur_systeme = 3495: d_es_allocation_memoire; 3496: return; 3497: } 3498: 3499: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3500: .suivant).donnee = allocation(s_etat_processus, INT)) 3501: == NULL) 3502: { 3503: (*s_etat_processus).erreur_systeme = 3504: d_es_allocation_memoire; 3505: return; 3506: } 3507: 3508: (*((integer8 *) (*(*(*((struct_liste_chainee *) 3509: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 3510: (integer8) ntohs(adresse_ipv6.sin6_port); 3511: 3512: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3513: .suivant).suivant = NULL; 3514: # else 3515: if ((*s_etat_processus).langue == 'F') 3516: { 3517: printf("+++Attention : Support du protocole" 3518: " IPv6 indisponible\n"); 3519: } 3520: else 3521: { 3522: printf("+++Warning : IPv6 support " 3523: "unavailable\n"); 3524: } 3525: # endif 3526: } 3527: else 3528: { 3529: longueur_adresse = 0; 3530: recvfrom((*((struct_socket *) 3531: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3532: (size_t) position_finale, MSG_DONTWAIT, 3533: NULL, &longueur_adresse); 3534: } 3535: 3536: free(tampon_lecture); 3537: 3538: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3539: s_objet_resultat) == d_erreur) 3540: { 3541: return; 3542: } 3543: } 3544: else 3545: { // FLOW 3546: longueur_questure = 256; 3547: 3548: do 3549: { 3550: if ((tampon_lecture = malloc((((size_t) longueur_questure) + 1) 3551: * sizeof(unsigned char))) == NULL) 3552: { 3553: (*s_etat_processus).erreur_systeme = 3554: d_es_allocation_memoire; 3555: return; 3556: } 3557: 3558: # ifndef SEMAPHORES_NOMMES 3559: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 3560: # else 3561: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 3562: # endif 3563: { 3564: (*s_etat_processus).erreur_systeme = d_es_processus; 3565: return; 3566: } 3567: 3568: attente.tv_sec = 0; 3569: attente.tv_nsec = GRANULARITE_us * 1000; 3570: 3571: for(;;) 3572: { 3573: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3574: .domaine == PF_UNIX) 3575: { 3576: longueur_adresse = sizeof(adresse_unix); 3577: longueur_effective = recvfrom((*((struct_socket *) 3578: (*s_objet_argument_1).objet)).socket, 3579: tampon_lecture, (long unsigned int) 3580: longueur_questure, 3581: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 3582: &adresse_unix, &longueur_adresse); 3583: } 3584: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3585: .domaine == PF_INET) 3586: { 3587: longueur_adresse = sizeof(adresse_ipv4); 3588: longueur_effective = recvfrom((*((struct_socket *) 3589: (*s_objet_argument_1).objet)).socket, 3590: tampon_lecture, (long unsigned int) 3591: longueur_questure, 3592: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 3593: &adresse_ipv4, &longueur_adresse); 3594: } 3595: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3596: .domaine == PF_INET6) 3597: { 3598: # ifdef IPV6 3599: longueur_adresse = sizeof(adresse_ipv6); 3600: longueur_effective = recvfrom((*((struct_socket *) 3601: (*s_objet_argument_1).objet)).socket, 3602: tampon_lecture, (long unsigned int) 3603: longueur_questure, 3604: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 3605: &adresse_ipv6, &longueur_adresse); 3606: # else 3607: if ((*s_etat_processus).langue == 'F') 3608: { 3609: printf("+++Attention : Support du protocole" 3610: " IPv6 indisponible\n"); 3611: } 3612: else 3613: { 3614: printf("+++Warning : IPv6 support " 3615: "unavailable\n"); 3616: } 3617: 3618: longueur_adresse = 0; 3619: longueur_effective = 0; 3620: # endif 3621: } 3622: else 3623: { 3624: free(tampon_lecture); 3625: liberation(s_etat_processus, s_objet_argument_1); 3626: 3627: # ifndef SEMAPHORES_NOMMES 3628: while(sem_wait(&((*s_etat_processus) 3629: .semaphore_fork)) != 0) 3630: # else 3631: while(sem_wait((*s_etat_processus) 3632: .semaphore_fork) != 0) 3633: # endif 3634: { 3635: if (errno != EINTR) 3636: { 3637: (*s_etat_processus).erreur_systeme = 3638: d_es_processus; 3639: return; 3640: } 3641: } 3642: 3643: (*s_etat_processus).erreur_execution = 3644: d_ex_erreur_acces_fichier; 3645: return; 3646: } 3647: 3648: if (longueur_effective < 0) 3649: { 3650: nanosleep(&attente, NULL); 3651: INCR_GRANULARITE(attente.tv_nsec); 3652: scrutation_injection(s_etat_processus); 3653: } 3654: 3655: if (((*s_etat_processus).var_volatile_requete_arret == -1) 3656: || (longueur_effective >= 0)) 3657: { 3658: break; 3659: } 3660: } 3661: 3662: # ifndef SEMAPHORES_NOMMES 3663: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) 3664: # else 3665: while(sem_wait((*s_etat_processus).semaphore_fork) != 0) 3666: # endif 3667: { 3668: if (errno != EINTR) 3669: { 3670: (*s_etat_processus).erreur_systeme = d_es_processus; 3671: return; 3672: } 3673: } 3674: 3675: if ((*s_etat_processus).var_volatile_requete_arret == -1) 3676: { 3677: 3678: /* 3679: * Si le père tue le processus courant grâce au signal 3680: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement 3681: * correspond à l'utilisation de STOP sur le processus 3682: * en cours. La variable longueur_effective vaut '-1'. 3683: */ 3684: 3685: free(tampon_lecture); 3686: liberation(s_etat_processus, s_objet_argument_1); 3687: return; 3688: } 3689: 3690: if (longueur_effective == -1) 3691: { 3692: free(tampon_lecture); 3693: liberation(s_etat_processus, s_objet_argument_1); 3694: 3695: (*s_etat_processus).erreur_execution = 3696: d_ex_erreur_acces_fichier; 3697: return; 3698: } 3699: 3700: if (longueur_effective == longueur_questure) 3701: { 3702: free(tampon_lecture); 3703: longueur_questure *= 2; 3704: } 3705: } while(longueur_effective == longueur_questure); 3706: 3707: longueur_enregistrement = 1; 3708: 3709: for(i = 0; i < longueur_effective; i++) 3710: { 3711: if (isprint(tampon_lecture[i]) != 0) 3712: { 3713: longueur_enregistrement += 4; 3714: } 3715: else 3716: { 3717: longueur_enregistrement++; 3718: } 3719: } 3720: 3721: /* 3722: * Création de la liste de sortie 3723: */ 3724: 3725: if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL) 3726: { 3727: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3728: return; 3729: } 3730: 3731: if (((*s_objet_type).objet = malloc((size_t) longueur_enregistrement 3732: * sizeof(unsigned char))) == NULL) 3733: { 3734: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3735: return; 3736: } 3737: 3738: ptr = (*s_objet_type).objet; 3739: 3740: for(i = 0; i < longueur_effective; i++) 3741: { 3742: if (isprint(tampon_lecture[i]) != 0) 3743: { 3744: (*ptr) = tampon_lecture[i]; 3745: ptr++; 3746: } 3747: else 3748: { 3749: (*ptr) = '\\'; 3750: ptr++; 3751: (*ptr) = 'x'; 3752: ptr++; 3753: sprintf(ptr, "%02X", tampon_lecture[i]); 3754: ptr += 2; 3755: } 3756: } 3757: 3758: (*ptr) = d_code_fin_chaine; 3759: 3760: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 3761: == NULL) 3762: { 3763: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3764: return; 3765: } 3766: 3767: if (((*s_objet_resultat).objet = 3768: allocation_maillon(s_etat_processus)) == NULL) 3769: { 3770: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3771: return; 3772: } 3773: 3774: (*((struct_liste_chainee *) (*s_objet_resultat).objet)) 3775: .donnee = s_objet_type; 3776: 3777: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) 3778: .suivant = allocation_maillon(s_etat_processus)) == NULL) 3779: { 3780: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3781: return; 3782: } 3783: 3784: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 3785: .suivant = NULL; 3786: 3787: if ((s_objet_adresse = allocation(s_etat_processus, LST)) 3788: == NULL) 3789: { 3790: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3791: return; 3792: } 3793: 3794: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 3795: .donnee = s_objet_adresse; 3796: 3797: /* 3798: * Les informations concernant la cible sont valides si 3799: * la socket est non connectée et que les domaines sont 3800: * INET ou INET6. 3801: * Dans tous les autres cas, on renvoie une liste vide. 3802: */ 3803: 3804: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine 3805: == PF_UNIX) || (strcmp((*((struct_socket *) 3806: (*s_objet_argument_1).objet)).type, "STREAM") == 0) || 3807: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) 3808: .type, "SEQUENTIAL DATAGRAM") == 0)) 3809: { 3810: // POSITION_FINALE peut être utilisée sans être initialisée ! 3811: // virer position_finale pour longueur_effective 3812: longueur_adresse = 0; 3813: recvfrom((*((struct_socket *) 3814: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3815: (long unsigned int) longueur_effective, MSG_DONTWAIT, 3816: NULL, &longueur_adresse); 3817: 3818: (*s_objet_adresse).objet = NULL; 3819: } 3820: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3821: .domaine == PF_INET) 3822: { 3823: longueur_adresse = sizeof(adresse_ipv4); 3824: recvfrom((*((struct_socket *) 3825: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3826: (long unsigned int) longueur_effective, MSG_DONTWAIT, 3827: (struct sockaddr *) &adresse_ipv4, &longueur_adresse); 3828: 3829: if (((*s_objet_adresse).objet = 3830: allocation_maillon(s_etat_processus)) == NULL) 3831: { 3832: (*s_etat_processus).erreur_systeme = 3833: d_es_allocation_memoire; 3834: return; 3835: } 3836: 3837: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3838: .donnee = allocation(s_etat_processus, VIN)) == NULL) 3839: { 3840: (*s_etat_processus).erreur_systeme = 3841: d_es_allocation_memoire; 3842: return; 3843: } 3844: 3845: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 3846: (*s_objet_adresse).objet)).donnee).objet)).taille = 4; 3847: 3848: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 3849: (*s_objet_adresse).objet)).donnee).objet)).tableau = 3850: malloc(4 * sizeof(integer8))) == NULL) 3851: { 3852: (*s_etat_processus).erreur_systeme = 3853: d_es_allocation_memoire; 3854: return; 3855: } 3856: 3857: ((integer8 *) (*((struct_vecteur *) 3858: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3859: .objet)).donnee).objet)).tableau)[0] = 3860: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; 3861: ((integer8 *) (*((struct_vecteur *) 3862: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3863: .objet)).donnee).objet)).tableau)[1] = 3864: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; 3865: ((integer8 *) (*((struct_vecteur *) 3866: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3867: .objet)).donnee).objet)).tableau)[2] = 3868: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; 3869: ((integer8 *) (*((struct_vecteur *) 3870: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3871: .objet)).donnee).objet)).tableau)[3] = 3872: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; 3873: 3874: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3875: .suivant = allocation_maillon(s_etat_processus)) 3876: == NULL) 3877: { 3878: (*s_etat_processus).erreur_systeme = 3879: d_es_allocation_memoire; 3880: return; 3881: } 3882: 3883: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3884: .suivant).donnee = allocation(s_etat_processus, INT)) 3885: == NULL) 3886: { 3887: (*s_etat_processus).erreur_systeme = 3888: d_es_allocation_memoire; 3889: return; 3890: } 3891: 3892: (*((integer8 *) (*(*(*((struct_liste_chainee *) 3893: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 3894: (integer8) ntohs(adresse_ipv4.sin_port); 3895: 3896: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3897: .suivant).suivant = NULL; 3898: } 3899: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3900: .domaine == PF_INET6) 3901: { 3902: # ifdef IPV6 3903: longueur_adresse = sizeof(adresse_ipv6); 3904: recvfrom((*((struct_socket *) 3905: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3906: (long unsigned int) longueur_effective, MSG_DONTWAIT, 3907: (struct sockaddr *) &adresse_ipv6, &longueur_adresse); 3908: 3909: if (((*s_objet_adresse).objet = 3910: allocation_maillon(s_etat_processus)) == NULL) 3911: { 3912: (*s_etat_processus).erreur_systeme = 3913: d_es_allocation_memoire; 3914: return; 3915: } 3916: 3917: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3918: .donnee = allocation(s_etat_processus, VIN)) == NULL) 3919: { 3920: (*s_etat_processus).erreur_systeme = 3921: d_es_allocation_memoire; 3922: return; 3923: } 3924: 3925: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 3926: (*s_objet_adresse).objet)).donnee).objet)).taille = 16; 3927: 3928: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 3929: (*s_objet_adresse).objet)).donnee).objet)).tableau = 3930: malloc(16 * sizeof(integer8))) == NULL) 3931: { 3932: (*s_etat_processus).erreur_systeme = 3933: d_es_allocation_memoire; 3934: return; 3935: } 3936: 3937: for(i = 0; i < 16; i++) 3938: { 3939: ((integer8 *) (*((struct_vecteur *) 3940: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3941: .objet)).donnee).objet)).tableau)[0] = 3942: adresse_ipv6.sin6_addr.s6_addr[i]; 3943: } 3944: 3945: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3946: .suivant = allocation_maillon(s_etat_processus)) 3947: == NULL) 3948: { 3949: (*s_etat_processus).erreur_systeme = 3950: d_es_allocation_memoire; 3951: return; 3952: } 3953: 3954: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3955: .suivant).donnee = allocation(s_etat_processus, INT)) 3956: == NULL) 3957: { 3958: (*s_etat_processus).erreur_systeme = 3959: d_es_allocation_memoire; 3960: return; 3961: } 3962: 3963: (*((integer8 *) (*(*(*((struct_liste_chainee *) 3964: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 3965: (integer8) ntohs(adresse_ipv6.sin6_port); 3966: 3967: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3968: .suivant).suivant = NULL; 3969: # else 3970: if ((*s_etat_processus).langue == 'F') 3971: { 3972: printf("+++Attention : Support du protocole" 3973: " IPv6 indisponible\n"); 3974: } 3975: else 3976: { 3977: printf("+++Warning : IPv6 support " 3978: "unavailable\n"); 3979: } 3980: # endif 3981: } 3982: else 3983: { 3984: longueur_adresse = 0; 3985: recvfrom((*((struct_socket *) 3986: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3987: (long unsigned int) longueur_effective, MSG_DONTWAIT, 3988: NULL, &longueur_adresse); 3989: } 3990: 3991: free(tampon_lecture); 3992: 3993: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3994: s_objet_resultat) == d_erreur) 3995: { 3996: return; 3997: } 3998: } 3999: } 4000: else 4001: { 4002: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 4003: return; 4004: } 4005: 4006: liberation(s_etat_processus, s_objet_argument_1); 4007: 4008: return; 4009: } 4010: 4011: // vim: ts=4