![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 Dr. BERTRAND Joël 5: 6: This file is part of RPL/2. 7: 8: RPL/2 is free software; you can redistribute it and/or modify it 9: under the terms of the CeCILL V2 License as published by the french 10: CEA, CNRS and INRIA. 11: 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License 15: for more details. 16: 17: You should have received a copy of the CeCILL License 18: along with RPL/2. If not, write to info@cecill.info. 19: ================================================================================ 20: */ 21: 22: 23: #include "rpl-conv.h" 24: 25: 26: /* 27: ================================================================================ 28: Fonction '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)) = (*((integer8 *) 100: (*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: 854: integer8 element; 855: integer8 id; 856: integer8 position_clef; 857: 858: logical1 indicateur_48; 859: logical1 presence_chaine; 860: logical1 presence_indicateur; 861: 862: long i; 863: long longueur_effective; 864: long longueur_enregistrement; 865: long longueur_questure; 866: long niveau; 867: long pointeur; 868: long position_finale; 869: long position_initiale; 870: 871: socklen_t longueur_adresse; 872: 873: sqlite3_stmt *ppStmt; 874: 875: struct flock lock; 876: 877: struct sockaddr_un adresse_unix; 878: struct sockaddr_in adresse_ipv4; 879: # ifdef IPV6 880: struct sockaddr_in6 adresse_ipv6; 881: # endif 882: 883: struct timespec attente; 884: 885: struct_descripteur_fichier *descripteur; 886: 887: struct_liste_chainee *l_element_courant; 888: struct_liste_chainee *l_element_inclus; 889: 890: struct_objet *s_objet_adresse; 891: struct_objet *s_objet_argument_1; 892: struct_objet *s_objet_argument_2; 893: struct_objet *s_objet_resultat; 894: struct_objet *s_objet_type; 895: 896: unsigned char caractere; 897: unsigned char *clef_utf8; 898: unsigned char *commande; 899: unsigned char *ptr; 900: unsigned char *tampon_lecture; 901: unsigned char *tampon; 902: unsigned char *tampon2; 903: 904: (*s_etat_processus).erreur_execution = d_ex; 905: 906: if ((*s_etat_processus).affichage_arguments == 'Y') 907: { 908: printf("\n READ "); 909: 910: if ((*s_etat_processus).langue == 'F') 911: { 912: printf("(lecture d'un enregistrement d'un fichier)\n\n"); 913: } 914: else 915: { 916: printf("(read a record of a file)\n\n"); 917: } 918: 919: printf(" 1: %s, %s\n\n", d_FCH, d_SCK); 920: 921: printf(" 2: %s, %s\n", d_INT, d_CHN); 922: printf(" 1: %s\n", d_FCH); 923: return; 924: } 925: else if ((*s_etat_processus).test_instruction == 'Y') 926: { 927: (*s_etat_processus).nombre_arguments = -1; 928: return; 929: } 930: 931: if (test_cfsf(s_etat_processus, 31) == d_vrai) 932: { 933: if ((*s_etat_processus).l_base_pile == NULL) 934: { 935: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 936: return; 937: } 938: 939: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH) 940: { 941: if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile) 942: .donnee).objet)).acces == 'S') 943: { 944: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 945: { 946: return; 947: } 948: } 949: else 950: { 951: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 952: { 953: return; 954: } 955: } 956: } 957: else 958: { 959: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 960: { 961: return; 962: } 963: } 964: } 965: 966: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 967: &s_objet_argument_1) == d_erreur) 968: { 969: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 970: return; 971: } 972: 973: if ((*s_objet_argument_1).type == FCH) 974: { 975: if ((descripteur = descripteur_fichier(s_etat_processus, 976: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL) 977: { 978: return; 979: } 980: 981: /* 982: * Vérification des verrous 983: */ 984: 985: lock.l_type = F_RDLCK; 986: lock.l_whence = SEEK_SET; 987: lock.l_start = 0; 988: lock.l_len = 0; 989: lock.l_pid = getpid(); 990: 991: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock) 992: == -1) 993: { 994: liberation(s_etat_processus, s_objet_argument_1); 995: 996: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 997: return; 998: } 999: 1000: if (lock.l_type != F_UNLCK) 1001: { 1002: liberation(s_etat_processus, s_objet_argument_1); 1003: 1004: (*s_etat_processus).erreur_execution = 1005: d_ex_fichier_verrouille; 1006: return; 1007: } 1008: 1009: /* 1010: * Vérification de l'autorisation de lecture 1011: */ 1012: 1013: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection 1014: == 'W') 1015: { 1016: liberation(s_etat_processus, s_objet_argument_1); 1017: 1018: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; 1019: return; 1020: } 1021: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection 1022: == 'N') 1023: { 1024: if ((*descripteur).type == 'C') 1025: { 1026: if (fflush((*descripteur).descripteur_c) != 0) 1027: { 1028: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1029: return; 1030: } 1031: } 1032: } 1033: 1034: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N') 1035: { 1036: /* 1037: * Fichiers formatés 1038: */ 1039: 1040: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 1041: == 'S') 1042: { 1043: /* 1044: * Fichiers séquentiels 1045: */ 1046: 1047: longueur_questure = 256; 1048: 1049: if ((tampon_lecture = malloc(longueur_questure * 1050: sizeof(unsigned char))) == NULL) 1051: { 1052: (*s_etat_processus).erreur_systeme = 1053: d_es_allocation_memoire; 1054: return; 1055: } 1056: 1057: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); 1058: 1059: if ((position_initiale = ftell((*descripteur).descripteur_c)) 1060: == -1) 1061: { 1062: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1063: return; 1064: } 1065: 1066: do 1067: { 1068: longueur_effective = fread(tampon_lecture, 1069: (size_t) sizeof(unsigned char), longueur_questure, 1070: (*descripteur).descripteur_c); 1071: 1072: pointeur = 0; 1073: presence_indicateur = d_faux; 1074: 1075: while(pointeur < longueur_effective) 1076: { 1077: if (tampon_lecture[pointeur] == '{') 1078: { 1079: presence_indicateur = d_vrai; 1080: break; 1081: } 1082: 1083: position_initiale++; 1084: pointeur++; 1085: } 1086: 1087: if (presence_indicateur == d_vrai) 1088: { 1089: break; 1090: } 1091: } while(longueur_effective == longueur_questure); 1092: 1093: if (presence_indicateur == d_faux) 1094: { 1095: liberation(s_etat_processus, s_objet_argument_1); 1096: free(tampon_lecture); 1097: 1098: (*s_etat_processus).erreur_execution = 1099: d_ex_fin_de_fichier_atteinte; 1100: return; 1101: } 1102: 1103: position_finale = position_initiale + 1; 1104: presence_chaine = d_faux; 1105: niveau = 1; 1106: 1107: if (fseek((*descripteur).descripteur_c, position_finale, 1108: SEEK_SET) != 0) 1109: { 1110: liberation(s_etat_processus, s_objet_argument_1); 1111: free(tampon_lecture); 1112: 1113: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1114: return; 1115: } 1116: 1117: do 1118: { 1119: longueur_effective = fread(tampon_lecture, 1120: (size_t) sizeof(unsigned char), longueur_questure, 1121: (*descripteur).descripteur_c); 1122: 1123: pointeur = 0; 1124: presence_indicateur = d_faux; 1125: 1126: while(pointeur < longueur_effective) 1127: { 1128: if (tampon_lecture[pointeur] == '"') 1129: { 1130: if (pointeur > 0) 1131: { 1132: if (tampon_lecture[pointeur - 1] != '\\') 1133: { 1134: presence_chaine = (presence_chaine == 1135: d_vrai) ? d_faux : d_vrai; 1136: } 1137: } 1138: else 1139: { 1140: presence_chaine = (presence_chaine == d_vrai) 1141: ? d_faux : d_vrai; 1142: } 1143: } 1144: else 1145: { 1146: if (presence_chaine == d_faux) 1147: { 1148: if (tampon_lecture[pointeur] == '{') 1149: { 1150: niveau++; 1151: } 1152: else if (tampon_lecture[pointeur] == '}') 1153: { 1154: niveau--; 1155: } 1156: } 1157: } 1158: 1159: position_finale++; 1160: pointeur++; 1161: 1162: if (niveau == 0) 1163: { 1164: presence_indicateur = d_vrai; 1165: break; 1166: } 1167: } 1168: 1169: if (presence_indicateur == d_vrai) 1170: { 1171: break; 1172: } 1173: } while(longueur_effective == longueur_questure); 1174: 1175: if (presence_indicateur == d_faux) 1176: { 1177: liberation(s_etat_processus, s_objet_argument_1); 1178: free(tampon_lecture); 1179: 1180: (*s_etat_processus).erreur_execution = 1181: d_ex_fin_de_fichier_atteinte; 1182: return; 1183: } 1184: 1185: free(tampon_lecture); 1186: longueur_enregistrement = position_finale - position_initiale; 1187: 1188: if ((tampon_lecture = malloc((longueur_enregistrement + 1) * 1189: sizeof(unsigned char))) == NULL) 1190: { 1191: (*s_etat_processus).erreur_systeme = 1192: d_es_allocation_memoire; 1193: return; 1194: } 1195: 1196: if (fseek((*descripteur).descripteur_c, position_initiale, 1197: SEEK_SET) != 0) 1198: { 1199: liberation(s_etat_processus, s_objet_argument_1); 1200: free(tampon_lecture); 1201: 1202: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1203: return; 1204: } 1205: 1206: longueur_effective = fread(tampon_lecture, 1207: (size_t) sizeof(unsigned char), 1208: (size_t) longueur_enregistrement, 1209: (*descripteur).descripteur_c); 1210: 1211: if (longueur_effective != longueur_enregistrement) 1212: { 1213: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1214: return; 1215: } 1216: 1217: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine; 1218: tampon = (*s_etat_processus).instruction_courante; 1219: 1220: if (((*s_etat_processus).instruction_courante = 1221: transliteration(s_etat_processus, tampon_lecture, 1222: "UTF-8", d_locale)) == NULL) 1223: { 1224: (*s_etat_processus).instruction_courante = tampon; 1225: liberation(s_etat_processus, s_objet_argument_1); 1226: free(tampon_lecture); 1227: return; 1228: } 1229: 1230: indicateur_48 = test_cfsf(s_etat_processus, 48); 1231: cf(s_etat_processus, 48); 1232: 1233: recherche_type(s_etat_processus); 1234: free((*s_etat_processus).instruction_courante); 1235: 1236: if ((*s_etat_processus).erreur_execution != d_ex) 1237: { 1238: if (indicateur_48 == d_vrai) 1239: { 1240: sf(s_etat_processus, 48); 1241: } 1242: else 1243: { 1244: cf(s_etat_processus, 48); 1245: } 1246: 1247: (*s_etat_processus).instruction_courante = tampon; 1248: free(tampon_lecture); 1249: 1250: liberation(s_etat_processus, s_objet_argument_1); 1251: return; 1252: } 1253: 1254: if (indicateur_48 == d_vrai) 1255: { 1256: sf(s_etat_processus, 48); 1257: } 1258: else 1259: { 1260: cf(s_etat_processus, 48); 1261: } 1262: 1263: (*s_etat_processus).instruction_courante = tampon; 1264: free(tampon_lecture); 1265: } 1266: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 1267: == 'D') 1268: { 1269: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); 1270: 1271: if (depilement(s_etat_processus, &((*s_etat_processus) 1272: .l_base_pile), &s_objet_argument_2) == d_erreur) 1273: { 1274: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1275: return; 1276: } 1277: 1278: if ((*s_objet_argument_2).type != INT) 1279: { 1280: liberation(s_etat_processus, s_objet_argument_1); 1281: liberation(s_etat_processus, s_objet_argument_2); 1282: 1283: (*s_etat_processus).erreur_execution = 1284: d_ex_erreur_type_argument; 1285: return; 1286: } 1287: 1288: if (alsprintf(&commande, "select data from data where " 1289: "id = %lld", (*((integer8 *) (*s_objet_argument_2) 1290: .objet))) < 0) 1291: { 1292: (*s_etat_processus).erreur_systeme = 1293: d_es_allocation_memoire; 1294: return; 1295: } 1296: 1297: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1298: commande, strlen(commande), &ppStmt, &queue) 1299: != SQLITE_OK) 1300: { 1301: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1302: return; 1303: } 1304: 1305: switch(sqlite3_step(ppStmt)) 1306: { 1307: case SQLITE_ROW: 1308: { 1309: // Résultat attendu 1310: break; 1311: } 1312: 1313: case SQLITE_DONE: 1314: { 1315: // Aucun enregistrement 1316: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1317: { 1318: (*s_etat_processus).erreur_systeme = 1319: d_es_erreur_fichier; 1320: return; 1321: } 1322: 1323: free(commande); 1324: 1325: liberation(s_etat_processus, s_objet_argument_1); 1326: liberation(s_etat_processus, s_objet_argument_2); 1327: 1328: (*s_etat_processus).erreur_execution = 1329: d_ex_enregistrement_inexistant; 1330: return; 1331: } 1332: 1333: default: 1334: { 1335: (*s_etat_processus).erreur_systeme = 1336: d_es_erreur_fichier; 1337: return; 1338: } 1339: } 1340: 1341: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) 1342: { 1343: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1344: return; 1345: } 1346: 1347: tampon = (*s_etat_processus).instruction_courante; 1348: 1349: if ((tampon_lecture = (unsigned char *) 1350: sqlite3_column_text(ppStmt, 0)) == NULL) 1351: { 1352: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1353: return; 1354: } 1355: 1356: if (((*s_etat_processus).instruction_courante = 1357: transliteration(s_etat_processus, tampon_lecture, 1358: "UTF-8", d_locale)) == NULL) 1359: { 1360: (*s_etat_processus).instruction_courante = tampon; 1361: 1362: liberation(s_etat_processus, s_objet_argument_1); 1363: liberation(s_etat_processus, s_objet_argument_2); 1364: free(commande); 1365: return; 1366: } 1367: 1368: indicateur_48 = test_cfsf(s_etat_processus, 48); 1369: cf(s_etat_processus, 48); 1370: 1371: recherche_type(s_etat_processus); 1372: 1373: if ((*s_etat_processus).erreur_execution != d_ex) 1374: { 1375: if (indicateur_48 == d_vrai) 1376: { 1377: sf(s_etat_processus, 48); 1378: } 1379: else 1380: { 1381: cf(s_etat_processus, 48); 1382: } 1383: 1384: liberation(s_etat_processus, s_objet_argument_1); 1385: liberation(s_etat_processus, s_objet_argument_2); 1386: 1387: free((*s_etat_processus).instruction_courante); 1388: free(commande); 1389: 1390: (*s_etat_processus).instruction_courante = tampon; 1391: return; 1392: } 1393: 1394: if (indicateur_48 == d_vrai) 1395: { 1396: sf(s_etat_processus, 48); 1397: } 1398: else 1399: { 1400: cf(s_etat_processus, 48); 1401: } 1402: 1403: free((*s_etat_processus).instruction_courante); 1404: liberation(s_etat_processus, s_objet_argument_2); 1405: (*s_etat_processus).instruction_courante = tampon; 1406: 1407: if (sqlite3_step(ppStmt) != SQLITE_DONE) 1408: { 1409: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1410: return; 1411: } 1412: 1413: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1414: { 1415: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1416: return; 1417: } 1418: 1419: free(commande); 1420: } 1421: else 1422: { 1423: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); 1424: 1425: if (depilement(s_etat_processus, &((*s_etat_processus) 1426: .l_base_pile), &s_objet_argument_2) == d_erreur) 1427: { 1428: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1429: return; 1430: } 1431: 1432: if ((*s_objet_argument_2).type != CHN) 1433: { 1434: liberation(s_etat_processus, s_objet_argument_1); 1435: liberation(s_etat_processus, s_objet_argument_2); 1436: 1437: (*s_etat_processus).erreur_execution = 1438: d_ex_erreur_type_argument; 1439: return; 1440: } 1441: 1442: // Récupération de la position de la clef 1443: 1444: if (alsprintf(&commande, "select key from control " 1445: "where id = 1") < 0) 1446: { 1447: (*s_etat_processus).erreur_systeme = 1448: d_es_allocation_memoire; 1449: return; 1450: } 1451: 1452: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1453: commande, strlen(commande), &ppStmt, &queue) 1454: != SQLITE_OK) 1455: { 1456: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1457: return; 1458: } 1459: 1460: if (sqlite3_step(ppStmt) != SQLITE_ROW) 1461: { 1462: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1463: return; 1464: } 1465: 1466: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) 1467: { 1468: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1469: return; 1470: } 1471: 1472: position_clef = sqlite3_column_int64(ppStmt, 0); 1473: 1474: if (sqlite3_step(ppStmt) != SQLITE_DONE) 1475: { 1476: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1477: return; 1478: } 1479: 1480: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1481: { 1482: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1483: return; 1484: } 1485: 1486: free(commande); 1487: 1488: if ((clef_utf8 = transliteration(s_etat_processus, 1489: (unsigned char *) (*s_objet_argument_2).objet, 1490: d_locale, "UTF-8")) == NULL) 1491: { 1492: liberation(s_etat_processus, s_objet_argument_1); 1493: liberation(s_etat_processus, s_objet_argument_2); 1494: 1495: return; 1496: } 1497: 1498: // Récupération de l'identifiant de la clef 1499: 1500: if (alsprintf(&commande, "select id from key where key = " 1501: "'{ \"%s\" }'", clef_utf8) < 0) 1502: { 1503: (*s_etat_processus).erreur_systeme = 1504: d_es_allocation_memoire; 1505: return; 1506: } 1507: 1508: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1509: commande, strlen(commande), &ppStmt, &queue) 1510: != SQLITE_OK) 1511: { 1512: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1513: return; 1514: } 1515: 1516: switch(sqlite3_step(ppStmt)) 1517: { 1518: case SQLITE_ROW: 1519: { 1520: // Résultat attendu : une clef correspond. 1521: break; 1522: } 1523: 1524: case SQLITE_DONE: 1525: { 1526: // Aucun enregistrement 1527: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1528: { 1529: (*s_etat_processus).erreur_systeme = 1530: d_es_erreur_fichier; 1531: return; 1532: } 1533: 1534: free(clef_utf8); 1535: free(commande); 1536: 1537: liberation(s_etat_processus, s_objet_argument_1); 1538: liberation(s_etat_processus, s_objet_argument_2); 1539: 1540: (*s_etat_processus).erreur_execution = 1541: d_ex_enregistrement_inexistant; 1542: return; 1543: } 1544: 1545: default: 1546: { 1547: (*s_etat_processus).erreur_systeme = 1548: d_es_erreur_fichier; 1549: return; 1550: } 1551: } 1552: 1553: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) 1554: { 1555: free(clef_utf8); 1556: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1557: return; 1558: } 1559: 1560: id = sqlite3_column_int64(ppStmt, 0); 1561: 1562: if (sqlite3_step(ppStmt) != SQLITE_DONE) 1563: { 1564: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1565: return; 1566: } 1567: 1568: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1569: { 1570: (*s_etat_processus).erreur_systeme = 1571: d_es_erreur_fichier; 1572: return; 1573: } 1574: 1575: free(commande); 1576: 1577: if (alsprintf(&commande, "select data from data where " 1578: "key_id = %lld order by sequence asc", id) < 0) 1579: { 1580: (*s_etat_processus).erreur_systeme = 1581: d_es_allocation_memoire; 1582: return; 1583: } 1584: 1585: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1586: commande, strlen(commande), &ppStmt, &queue) 1587: != SQLITE_OK) 1588: { 1589: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1590: return; 1591: } 1592: 1593: element = 1; 1594: 1595: do 1596: { 1597: switch(ios = sqlite3_step(ppStmt)) 1598: { 1599: case SQLITE_ROW: 1600: { 1601: // Donnée supplémentaire 1602: 1603: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) 1604: { 1605: (*s_etat_processus).erreur_systeme = 1606: d_es_erreur_fichier; 1607: return; 1608: } 1609: 1610: tampon = (*s_etat_processus).instruction_courante; 1611: 1612: if ((tampon_lecture = (unsigned char *) 1613: sqlite3_column_text(ppStmt, 0)) == NULL) 1614: { 1615: (*s_etat_processus).erreur_systeme = 1616: d_es_erreur_fichier; 1617: return; 1618: } 1619: 1620: if (((*s_etat_processus).instruction_courante = 1621: transliteration(s_etat_processus, 1622: tampon_lecture, 1623: "UTF-8", d_locale)) == NULL) 1624: { 1625: (*s_etat_processus).instruction_courante = 1626: tampon; 1627: 1628: liberation(s_etat_processus, 1629: s_objet_argument_1); 1630: liberation(s_etat_processus, 1631: s_objet_argument_2); 1632: 1633: free(commande); 1634: free(clef_utf8); 1635: return; 1636: } 1637: 1638: indicateur_48 = test_cfsf(s_etat_processus, 48); 1639: cf(s_etat_processus, 48); 1640: 1641: recherche_type(s_etat_processus); 1642: 1643: if ((*s_etat_processus).erreur_execution != d_ex) 1644: { 1645: if (indicateur_48 == d_vrai) 1646: { 1647: sf(s_etat_processus, 48); 1648: } 1649: else 1650: { 1651: cf(s_etat_processus, 48); 1652: } 1653: 1654: liberation(s_etat_processus, 1655: s_objet_argument_1); 1656: liberation(s_etat_processus, 1657: s_objet_argument_2); 1658: 1659: free((*s_etat_processus).instruction_courante); 1660: free(commande); 1661: free(clef_utf8); 1662: 1663: (*s_etat_processus).instruction_courante = 1664: tampon; 1665: return; 1666: } 1667: 1668: if (indicateur_48 == d_vrai) 1669: { 1670: sf(s_etat_processus, 48); 1671: } 1672: else 1673: { 1674: cf(s_etat_processus, 48); 1675: } 1676: 1677: free((*s_etat_processus).instruction_courante); 1678: (*s_etat_processus).instruction_courante = tampon; 1679: 1680: element++; 1681: 1682: // Inscription de la clef 1683: 1684: if (element == position_clef) 1685: { 1686: if (((*s_etat_processus).instruction_courante = 1687: transliteration(s_etat_processus, 1688: clef_utf8, "UTF-8", d_locale)) == NULL) 1689: { 1690: (*s_etat_processus).instruction_courante = 1691: tampon; 1692: 1693: liberation(s_etat_processus, 1694: s_objet_argument_1); 1695: liberation(s_etat_processus, 1696: s_objet_argument_2); 1697: 1698: free(commande); 1699: free(clef_utf8); 1700: return; 1701: } 1702: 1703: if (alsprintf(&tampon2, "{ \"%s\" }", 1704: (*s_etat_processus) 1705: .instruction_courante) < 0) 1706: { 1707: (*s_etat_processus).erreur_systeme = 1708: d_es_allocation_memoire; 1709: return; 1710: } 1711: 1712: free((*s_etat_processus).instruction_courante); 1713: (*s_etat_processus).instruction_courante 1714: = tampon2; 1715: 1716: indicateur_48 = test_cfsf(s_etat_processus, 48); 1717: cf(s_etat_processus, 48); 1718: 1719: recherche_type(s_etat_processus); 1720: 1721: if ((*s_etat_processus).erreur_execution 1722: != d_ex) 1723: { 1724: if (indicateur_48 == d_vrai) 1725: { 1726: sf(s_etat_processus, 48); 1727: } 1728: else 1729: { 1730: cf(s_etat_processus, 48); 1731: } 1732: 1733: liberation(s_etat_processus, 1734: s_objet_argument_1); 1735: liberation(s_etat_processus, 1736: s_objet_argument_2); 1737: 1738: free((*s_etat_processus) 1739: .instruction_courante); 1740: free(commande); 1741: free(clef_utf8); 1742: 1743: (*s_etat_processus).instruction_courante = 1744: tampon; 1745: return; 1746: } 1747: 1748: if (indicateur_48 == d_vrai) 1749: { 1750: sf(s_etat_processus, 48); 1751: } 1752: else 1753: { 1754: cf(s_etat_processus, 48); 1755: } 1756: 1757: free((*s_etat_processus).instruction_courante); 1758: (*s_etat_processus).instruction_courante = 1759: tampon; 1760: 1761: element++; 1762: } 1763: 1764: break; 1765: } 1766: 1767: case SQLITE_DONE: 1768: { 1769: // Fin de la liste 1770: break; 1771: } 1772: 1773: default: 1774: { 1775: (*s_etat_processus).erreur_systeme = 1776: d_es_erreur_fichier; 1777: return; 1778: } 1779: } 1780: 1781: } while(ios != SQLITE_DONE); 1782: 1783: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1784: { 1785: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1786: return; 1787: } 1788: 1789: free(commande); 1790: free(clef_utf8); 1791: 1792: liberation(s_etat_processus, s_objet_argument_2); 1793: 1794: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 1795: == NULL) 1796: { 1797: (*s_etat_processus).erreur_systeme = 1798: d_es_allocation_memoire; 1799: return; 1800: } 1801: 1802: l_element_courant = NULL; 1803: l_element_inclus = NULL; 1804: 1805: for(element--; element > 0; element--) 1806: { 1807: if (depilement(s_etat_processus, &((*s_etat_processus) 1808: .l_base_pile), &s_objet_argument_2) == d_erreur) 1809: { 1810: (*s_etat_processus).erreur_systeme = 1811: d_es_erreur_fichier; 1812: return; 1813: } 1814: 1815: if ((*s_objet_argument_2).type != LST) 1816: { 1817: (*s_etat_processus).erreur_systeme = 1818: d_es_erreur_fichier; 1819: return; 1820: } 1821: 1822: l_element_inclus = (*s_objet_argument_2).objet; 1823: 1824: if (l_element_inclus != NULL) 1825: { 1826: while(l_element_inclus != NULL) 1827: { 1828: if ((*l_element_inclus).suivant == NULL) 1829: { 1830: (*l_element_inclus).suivant = l_element_courant; 1831: break; 1832: } 1833: 1834: l_element_inclus = (*l_element_inclus).suivant; 1835: } 1836: 1837: l_element_courant = (*s_objet_argument_2).objet; 1838: (*s_objet_argument_2).objet = NULL; 1839: } 1840: 1841: liberation(s_etat_processus, s_objet_argument_2); 1842: } 1843: 1844: (*s_objet_resultat).objet = l_element_inclus; 1845: 1846: if (empilement(s_etat_processus, 1847: &((*s_etat_processus).l_base_pile), 1848: s_objet_resultat) == d_erreur) 1849: { 1850: return; 1851: } 1852: } 1853: } 1854: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire 1855: == 'Y') 1856: { 1857: /* 1858: * Fichiers non formatés 1859: */ 1860: } 1861: else 1862: { 1863: /* 1864: * Fichiers de type FLOW 1865: */ 1866: 1867: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 1868: == 'S') 1869: { 1870: /* 1871: * Fichiers séquentiels 1872: */ 1873: 1874: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); 1875: longueur_enregistrement = 0; 1876: 1877: if ((position_initiale = ftell((*descripteur).descripteur_c)) 1878: == -1) 1879: { 1880: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1881: return; 1882: } 1883: 1884: do 1885: { 1886: c = getc((*descripteur).descripteur_c); 1887: longueur_enregistrement++; 1888: } while((c != '\n') && (c != EOF)); 1889: 1890: if (fseek((*descripteur).descripteur_c, position_initiale, 1891: SEEK_SET) != 0) 1892: { 1893: liberation(s_etat_processus, s_objet_argument_1); 1894: 1895: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1896: return; 1897: } 1898: 1899: if ((tampon_lecture = malloc((longueur_enregistrement + 1) 1900: * sizeof(unsigned char))) == NULL) 1901: { 1902: (*s_etat_processus).erreur_systeme = 1903: d_es_allocation_memoire; 1904: return; 1905: } 1906: 1907: longueur_effective = fread(tampon_lecture, 1908: (size_t) sizeof(unsigned char), 1909: (size_t) longueur_enregistrement, 1910: (*descripteur).descripteur_c); 1911: 1912: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 1913: == NULL) 1914: { 1915: (*s_etat_processus).erreur_systeme = 1916: d_es_allocation_memoire; 1917: return; 1918: } 1919: 1920: if (((*s_objet_resultat).objet = 1921: allocation_maillon(s_etat_processus)) == NULL) 1922: { 1923: (*s_etat_processus).erreur_systeme = 1924: d_es_allocation_memoire; 1925: return; 1926: } 1927: 1928: (*((struct_liste_chainee *) (*s_objet_resultat).objet)) 1929: .suivant = NULL; 1930: 1931: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) 1932: .donnee = allocation(s_etat_processus, CHN)) == NULL) 1933: { 1934: (*s_etat_processus).erreur_systeme = 1935: d_es_allocation_memoire; 1936: return; 1937: } 1938: 1939: longueur_enregistrement = 1; 1940: 1941: for(i = 0; i < longueur_effective; i++) 1942: { 1943: if (isprint(tampon_lecture[i]) != 0) 1944: { 1945: longueur_enregistrement += 4; 1946: } 1947: else 1948: { 1949: longueur_enregistrement++; 1950: } 1951: } 1952: 1953: if ((tampon = malloc(longueur_enregistrement * 1954: sizeof(unsigned char))) == NULL) 1955: { 1956: (*s_etat_processus).erreur_systeme = 1957: d_es_allocation_memoire; 1958: return; 1959: } 1960: 1961: ptr = tampon; 1962: 1963: for(i = 0; i < longueur_effective; i++) 1964: { 1965: if (isprint(tampon_lecture[i]) != 0) 1966: { 1967: (*ptr) = tampon_lecture[i]; 1968: ptr++; 1969: } 1970: else 1971: { 1972: (*ptr) = '\\'; 1973: ptr++; 1974: (*ptr) = 'x'; 1975: ptr++; 1976: sprintf(ptr, "%02X", tampon_lecture[i]); 1977: ptr += 2; 1978: } 1979: } 1980: 1981: (*ptr) = d_code_fin_chaine; 1982: free(tampon_lecture); 1983: ((*(*((struct_liste_chainee *) (*s_objet_resultat).objet)) 1984: .donnee)).objet = tampon; 1985: 1986: if (empilement(s_etat_processus, 1987: &((*s_etat_processus).l_base_pile), 1988: s_objet_resultat) == d_erreur) 1989: { 1990: return; 1991: } 1992: } 1993: else 1994: { 1995: liberation(s_etat_processus, s_objet_argument_1); 1996: 1997: (*s_etat_processus).erreur_execution = 1998: d_ex_erreur_type_fichier; 1999: return; 2000: } 2001: } 2002: } 2003: else if ((*s_objet_argument_1).type == SCK) 2004: { 2005: /* 2006: * Vérification de l'autorisation de lecture 2007: */ 2008: 2009: if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection 2010: == 'W') 2011: { 2012: liberation(s_etat_processus, s_objet_argument_1); 2013: 2014: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; 2015: return; 2016: } 2017: 2018: /* 2019: * Vérification de l'écoute de la socket si celle-ci est connectée 2020: */ 2021: 2022: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, 2023: "STREAM") == 0) || (strcmp((*((struct_socket *) 2024: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM") 2025: == 0)) 2026: { 2027: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2028: .socket_en_ecoute == 'Y') 2029: { 2030: liberation(s_etat_processus, s_objet_argument_1); 2031: 2032: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute; 2033: return; 2034: } 2035: } 2036: 2037: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N') 2038: { // Socket formatée 2039: longueur_questure = 256; 2040: 2041: do 2042: { 2043: if ((tampon_lecture = malloc((longueur_questure + 1) * 2044: sizeof(unsigned char))) == NULL) 2045: { 2046: (*s_etat_processus).erreur_systeme = 2047: d_es_allocation_memoire; 2048: return; 2049: } 2050: 2051: # ifndef SEMAPHORES_NOMMES 2052: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 2053: { 2054: (*s_etat_processus).erreur_systeme = d_es_processus; 2055: return; 2056: } 2057: # else 2058: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 2059: { 2060: (*s_etat_processus).erreur_systeme = d_es_processus; 2061: return; 2062: } 2063: # endif 2064: 2065: attente.tv_sec = 0; 2066: attente.tv_nsec = GRANULARITE_us * 1000; 2067: 2068: for(;;) 2069: { 2070: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2071: .domaine == PF_UNIX) 2072: { 2073: longueur_adresse = sizeof(adresse_unix); 2074: longueur_effective = recvfrom((*((struct_socket *) 2075: (*s_objet_argument_1).objet)).socket, 2076: tampon_lecture, longueur_questure, 2077: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2078: &adresse_unix, &longueur_adresse); 2079: } 2080: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2081: .domaine == PF_INET) 2082: { 2083: longueur_adresse = sizeof(adresse_ipv4); 2084: longueur_effective = recvfrom((*((struct_socket *) 2085: (*s_objet_argument_1).objet)).socket, 2086: tampon_lecture, longueur_questure, 2087: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2088: &adresse_ipv4, &longueur_adresse); 2089: } 2090: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2091: .domaine == PF_INET6) 2092: { 2093: # ifdef IPV6 2094: longueur_adresse = sizeof(adresse_ipv6); 2095: longueur_effective = recvfrom((*((struct_socket *) 2096: (*s_objet_argument_1).objet)).socket, 2097: tampon_lecture, longueur_questure, 2098: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2099: &adresse_ipv6, &longueur_adresse); 2100: 2101: # else 2102: if ((*s_etat_processus).langue == 'F') 2103: { 2104: printf("+++Attention : Support du protocole" 2105: " IPv6 indisponible\n"); 2106: } 2107: else 2108: { 2109: printf("+++Warning : IPv6 support " 2110: "unavailable\n"); 2111: } 2112: # endif 2113: } 2114: else 2115: { 2116: free(tampon_lecture); 2117: liberation(s_etat_processus, s_objet_argument_1); 2118: 2119: # ifndef SEMAPHORES_NOMMES 2120: while(sem_wait(&((*s_etat_processus) 2121: .semaphore_fork)) == -1) 2122: # else 2123: while(sem_wait((*s_etat_processus) 2124: .semaphore_fork) == -1) 2125: # endif 2126: { 2127: if (errno != EINTR) 2128: { 2129: (*s_etat_processus).erreur_systeme = 2130: d_es_processus; 2131: return; 2132: } 2133: } 2134: 2135: (*s_etat_processus).erreur_execution = 2136: d_ex_erreur_acces_fichier; 2137: return; 2138: } 2139: 2140: if (longueur_effective < 0) 2141: { 2142: nanosleep(&attente, NULL); 2143: INCR_GRANULARITE(attente.tv_nsec); 2144: scrutation_injection(s_etat_processus); 2145: } 2146: 2147: // Une donnée a été reçue. 2148: 2149: if (((*s_etat_processus).var_volatile_requete_arret == -1) 2150: || (longueur_effective >= 0)) 2151: { 2152: break; 2153: } 2154: } 2155: 2156: # ifndef SEMAPHORES_NOMMES 2157: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 2158: # else 2159: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 2160: # endif 2161: { 2162: if (errno != EINTR) 2163: { 2164: (*s_etat_processus).erreur_systeme = d_es_processus; 2165: return; 2166: } 2167: } 2168: 2169: if ((*s_etat_processus).var_volatile_requete_arret == -1) 2170: { 2171: 2172: /* 2173: * Si le père tue le processus courant grâce au signal 2174: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement 2175: * correspond à l'utilisation de STOP sur le processus 2176: * en cours. La variable longueur_effective vaut '-1'. 2177: */ 2178: 2179: free(tampon_lecture); 2180: liberation(s_etat_processus, s_objet_argument_1); 2181: return; 2182: } 2183: 2184: if (longueur_effective == -1) 2185: { 2186: free(tampon_lecture); 2187: liberation(s_etat_processus, s_objet_argument_1); 2188: 2189: (*s_etat_processus).erreur_execution = 2190: d_ex_erreur_acces_fichier; 2191: return; 2192: } 2193: 2194: position_initiale = 0; 2195: presence_indicateur = d_faux; 2196: 2197: do 2198: { 2199: if (tampon_lecture[position_initiale] == '{') 2200: { 2201: presence_indicateur = d_vrai; 2202: break; 2203: } 2204: 2205: position_initiale++; 2206: } while(position_initiale < longueur_effective); 2207: 2208: 2209: if (presence_indicateur == d_vrai) 2210: { 2211: position_finale = position_initiale + 1; 2212: presence_chaine = d_faux; 2213: presence_indicateur = d_faux; 2214: niveau = 1; 2215: 2216: while(position_finale < longueur_effective) 2217: { 2218: caractere = tampon_lecture[position_finale]; 2219: 2220: if (caractere == '"') 2221: { 2222: presence_chaine = (presence_chaine == d_vrai) 2223: ? d_faux : d_vrai; 2224: } 2225: else 2226: { 2227: if (presence_chaine == d_faux) 2228: { 2229: if (caractere == '{') 2230: { 2231: niveau++; 2232: } 2233: else if (caractere == '}') 2234: { 2235: niveau--; 2236: } 2237: } 2238: } 2239: 2240: if (niveau == 0) 2241: { 2242: presence_indicateur = d_vrai; 2243: break; 2244: } 2245: 2246: position_finale++; 2247: } 2248: } 2249: 2250: if (presence_indicateur == d_faux) 2251: { 2252: if (longueur_effective < longueur_questure) 2253: { 2254: liberation(s_etat_processus, s_objet_argument_1); 2255: free(tampon_lecture); 2256: 2257: (*s_etat_processus).erreur_execution = 2258: d_ex_fin_de_fichier_atteinte; 2259: return; 2260: } 2261: 2262: free(tampon_lecture); 2263: longueur_questure *= 2; 2264: } 2265: } while(presence_indicateur == d_faux); 2266: 2267: tampon_lecture[++position_finale] = d_code_fin_chaine; 2268: tampon = (*s_etat_processus).instruction_courante; 2269: (*s_etat_processus).instruction_courante = &(tampon_lecture 2270: [position_initiale]); 2271: 2272: indicateur_48 = test_cfsf(s_etat_processus, 48); 2273: cf(s_etat_processus, 48); 2274: 2275: recherche_type(s_etat_processus); 2276: 2277: if ((*s_etat_processus).erreur_execution != d_ex) 2278: { 2279: (*s_etat_processus).instruction_courante = tampon; 2280: free(tampon_lecture); 2281: 2282: liberation(s_etat_processus, s_objet_argument_1); 2283: return; 2284: } 2285: 2286: if (indicateur_48 == d_vrai) 2287: { 2288: sf(s_etat_processus, 48); 2289: } 2290: else 2291: { 2292: cf(s_etat_processus, 48); 2293: } 2294: 2295: (*s_etat_processus).instruction_courante = tampon; 2296: 2297: /* 2298: * Création de la liste de sortie 2299: */ 2300: 2301: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2302: &s_objet_type) == d_erreur) 2303: { 2304: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 2305: return; 2306: } 2307: 2308: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 2309: == NULL) 2310: { 2311: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2312: return; 2313: } 2314: 2315: if (((*s_objet_resultat).objet = 2316: allocation_maillon(s_etat_processus)) == NULL) 2317: { 2318: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2319: return; 2320: } 2321: 2322: (*((struct_liste_chainee *) (*s_objet_resultat).objet)) 2323: .donnee = s_objet_type; 2324: 2325: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) 2326: .suivant = allocation_maillon(s_etat_processus)) == NULL) 2327: { 2328: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2329: return; 2330: } 2331: 2332: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 2333: .suivant = NULL; 2334: 2335: if ((s_objet_adresse = allocation(s_etat_processus, LST)) 2336: == NULL) 2337: { 2338: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2339: return; 2340: } 2341: 2342: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 2343: .donnee = s_objet_adresse; 2344: 2345: /* 2346: * Les informations concernant la cible sont valides si 2347: * la socket est non connectée et des domaines INET ou INET6. 2348: * Dans tous les autres cas, on renvoie une liste vide. 2349: */ 2350: 2351: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine 2352: == PF_UNIX) || (strcmp((*((struct_socket *) 2353: (*s_objet_argument_1).objet)).type, "STREAM") == 0) || 2354: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) 2355: .type, "SEQUENTIAL DATAGRAM") == 0)) 2356: { 2357: longueur_adresse = 0; 2358: recvfrom((*((struct_socket *) 2359: (*s_objet_argument_1).objet)).socket, tampon_lecture, 2360: longueur_effective, MSG_DONTWAIT, 2361: NULL, &longueur_adresse); 2362: 2363: (*s_objet_adresse).objet = NULL; 2364: } 2365: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2366: .domaine == PF_INET) 2367: { 2368: longueur_adresse = sizeof(adresse_ipv4); 2369: recvfrom((*((struct_socket *) 2370: (*s_objet_argument_1).objet)).socket, tampon_lecture, 2371: longueur_effective, MSG_DONTWAIT, 2372: (struct sockaddr *) &adresse_ipv4, &longueur_adresse); 2373: 2374: if (((*s_objet_adresse).objet = 2375: allocation_maillon(s_etat_processus)) == NULL) 2376: { 2377: (*s_etat_processus).erreur_systeme = 2378: d_es_allocation_memoire; 2379: return; 2380: } 2381: 2382: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2383: .donnee = allocation(s_etat_processus, VIN)) == NULL) 2384: { 2385: (*s_etat_processus).erreur_systeme = 2386: d_es_allocation_memoire; 2387: return; 2388: } 2389: 2390: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 2391: (*s_objet_adresse).objet)).donnee).objet)).taille = 4; 2392: 2393: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 2394: (*s_objet_adresse).objet)).donnee).objet)).tableau = 2395: malloc(4 * sizeof(integer8))) == NULL) 2396: { 2397: (*s_etat_processus).erreur_systeme = 2398: d_es_allocation_memoire; 2399: return; 2400: } 2401: 2402: ((integer8 *) (*((struct_vecteur *) 2403: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2404: .objet)).donnee).objet)).tableau)[0] = 2405: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; 2406: ((integer8 *) (*((struct_vecteur *) 2407: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2408: .objet)).donnee).objet)).tableau)[1] = 2409: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; 2410: ((integer8 *) (*((struct_vecteur *) 2411: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2412: .objet)).donnee).objet)).tableau)[2] = 2413: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; 2414: ((integer8 *) (*((struct_vecteur *) 2415: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2416: .objet)).donnee).objet)).tableau)[3] = 2417: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; 2418: 2419: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2420: .suivant = allocation_maillon(s_etat_processus)) 2421: == NULL) 2422: { 2423: (*s_etat_processus).erreur_systeme = 2424: d_es_allocation_memoire; 2425: return; 2426: } 2427: 2428: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2429: .suivant).donnee = allocation(s_etat_processus, INT)) 2430: == NULL) 2431: { 2432: (*s_etat_processus).erreur_systeme = 2433: d_es_allocation_memoire; 2434: return; 2435: } 2436: 2437: (*((integer8 *) (*(*(*((struct_liste_chainee *) 2438: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 2439: (integer8) ntohs(adresse_ipv4.sin_port); 2440: 2441: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2442: .suivant).suivant = NULL; 2443: } 2444: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2445: .domaine == PF_INET6) 2446: { 2447: # ifdef IPV6 2448: longueur_adresse = sizeof(adresse_ipv6); 2449: recvfrom((*((struct_socket *) 2450: (*s_objet_argument_1).objet)).socket, tampon_lecture, 2451: longueur_effective, MSG_DONTWAIT, 2452: (struct sockaddr *) &adresse_ipv6, &longueur_adresse); 2453: 2454: if (((*s_objet_adresse).objet = 2455: allocation_maillon(s_etat_processus)) == NULL) 2456: { 2457: (*s_etat_processus).erreur_systeme = 2458: d_es_allocation_memoire; 2459: return; 2460: } 2461: 2462: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2463: .donnee = allocation(s_etat_processus, VIN)) == NULL) 2464: { 2465: (*s_etat_processus).erreur_systeme = 2466: d_es_allocation_memoire; 2467: return; 2468: } 2469: 2470: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 2471: (*s_objet_adresse).objet)).donnee).objet)).taille = 16; 2472: 2473: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 2474: (*s_objet_adresse).objet)).donnee).objet)).tableau = 2475: malloc(16 * sizeof(integer8))) == NULL) 2476: { 2477: (*s_etat_processus).erreur_systeme = 2478: d_es_allocation_memoire; 2479: return; 2480: } 2481: 2482: for(i = 0; i < 16; i++) 2483: { 2484: ((integer8 *) (*((struct_vecteur *) 2485: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2486: .objet)).donnee).objet)).tableau)[0] = 2487: adresse_ipv6.sin6_addr.s6_addr[i]; 2488: } 2489: 2490: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2491: .suivant = allocation_maillon(s_etat_processus)) 2492: == NULL) 2493: { 2494: (*s_etat_processus).erreur_systeme = 2495: d_es_allocation_memoire; 2496: return; 2497: } 2498: 2499: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2500: .suivant).donnee = allocation(s_etat_processus, INT)) 2501: == NULL) 2502: { 2503: (*s_etat_processus).erreur_systeme = 2504: d_es_allocation_memoire; 2505: return; 2506: } 2507: 2508: (*((integer8 *) (*(*(*((struct_liste_chainee *) 2509: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 2510: (integer8) ntohs(adresse_ipv6.sin6_port); 2511: 2512: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2513: .suivant).suivant = NULL; 2514: # else 2515: if ((*s_etat_processus).langue == 'F') 2516: { 2517: printf("+++Attention : Support du protocole" 2518: " IPv6 indisponible\n"); 2519: } 2520: else 2521: { 2522: printf("+++Warning : IPv6 support " 2523: "unavailable\n"); 2524: } 2525: # endif 2526: } 2527: else 2528: { 2529: longueur_adresse = 0; 2530: recvfrom((*((struct_socket *) 2531: (*s_objet_argument_1).objet)).socket, tampon_lecture, 2532: position_finale, MSG_DONTWAIT, 2533: NULL, &longueur_adresse); 2534: } 2535: 2536: free(tampon_lecture); 2537: 2538: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2539: s_objet_resultat) == d_erreur) 2540: { 2541: return; 2542: } 2543: } 2544: else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire 2545: == 'Y') 2546: { // UNFORMATTED 2547: } 2548: else 2549: { // FLOW 2550: longueur_questure = 256; 2551: 2552: do 2553: { 2554: if ((tampon_lecture = malloc((longueur_questure + 1) * 2555: sizeof(unsigned char))) == NULL) 2556: { 2557: (*s_etat_processus).erreur_systeme = 2558: d_es_allocation_memoire; 2559: return; 2560: } 2561: 2562: # ifndef SEMAPHORES_NOMMES 2563: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 2564: { 2565: (*s_etat_processus).erreur_systeme = d_es_processus; 2566: return; 2567: } 2568: # else 2569: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 2570: { 2571: (*s_etat_processus).erreur_systeme = d_es_processus; 2572: return; 2573: } 2574: # endif 2575: 2576: attente.tv_sec = 0; 2577: attente.tv_nsec = GRANULARITE_us * 1000; 2578: 2579: for(;;) 2580: { 2581: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2582: .domaine == PF_UNIX) 2583: { 2584: longueur_adresse = sizeof(adresse_unix); 2585: longueur_effective = recvfrom((*((struct_socket *) 2586: (*s_objet_argument_1).objet)).socket, 2587: tampon_lecture, longueur_questure, 2588: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2589: &adresse_unix, &longueur_adresse); 2590: } 2591: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2592: .domaine == PF_INET) 2593: { 2594: longueur_adresse = sizeof(adresse_ipv4); 2595: longueur_effective = recvfrom((*((struct_socket *) 2596: (*s_objet_argument_1).objet)).socket, 2597: tampon_lecture, longueur_questure, 2598: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2599: &adresse_ipv4, &longueur_adresse); 2600: } 2601: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2602: .domaine == PF_INET6) 2603: { 2604: # ifdef IPV6 2605: longueur_adresse = sizeof(adresse_ipv6); 2606: longueur_effective = recvfrom((*((struct_socket *) 2607: (*s_objet_argument_1).objet)).socket, 2608: tampon_lecture, longueur_questure, 2609: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2610: &adresse_ipv6, &longueur_adresse); 2611: # else 2612: if ((*s_etat_processus).langue == 'F') 2613: { 2614: printf("+++Attention : Support du protocole" 2615: " IPv6 indisponible\n"); 2616: } 2617: else 2618: { 2619: printf("+++Warning : IPv6 support " 2620: "unavailable\n"); 2621: } 2622: # endif 2623: } 2624: else 2625: { 2626: free(tampon_lecture); 2627: liberation(s_etat_processus, s_objet_argument_1); 2628: 2629: # ifndef SEMAPHORES_NOMMES 2630: while(sem_wait(&((*s_etat_processus) 2631: .semaphore_fork)) == -1) 2632: # else 2633: while(sem_wait((*s_etat_processus) 2634: .semaphore_fork) == -1) 2635: # endif 2636: { 2637: if (errno != EINTR) 2638: { 2639: (*s_etat_processus).erreur_systeme = 2640: d_es_processus; 2641: return; 2642: } 2643: } 2644: 2645: (*s_etat_processus).erreur_execution = 2646: d_ex_erreur_acces_fichier; 2647: return; 2648: } 2649: 2650: if (longueur_effective < 0) 2651: { 2652: nanosleep(&attente, NULL); 2653: INCR_GRANULARITE(attente.tv_nsec); 2654: scrutation_injection(s_etat_processus); 2655: } 2656: 2657: if (((*s_etat_processus).var_volatile_requete_arret == -1) 2658: || (longueur_effective >= 0)) 2659: { 2660: break; 2661: } 2662: } 2663: 2664: # ifndef SEMAPHORES_NOMMES 2665: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 2666: # else 2667: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 2668: # endif 2669: { 2670: if (errno != EINTR) 2671: { 2672: (*s_etat_processus).erreur_systeme = d_es_processus; 2673: return; 2674: } 2675: } 2676: 2677: if ((*s_etat_processus).var_volatile_requete_arret == -1) 2678: { 2679: 2680: /* 2681: * Si le père tue le processus courant grâce au signal 2682: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement 2683: * correspond à l'utilisation de STOP sur le processus 2684: * en cours. La variable longueur_effective vaut '-1'. 2685: */ 2686: 2687: free(tampon_lecture); 2688: liberation(s_etat_processus, s_objet_argument_1); 2689: return; 2690: } 2691: 2692: if (longueur_effective == -1) 2693: { 2694: free(tampon_lecture); 2695: liberation(s_etat_processus, s_objet_argument_1); 2696: 2697: (*s_etat_processus).erreur_execution = 2698: d_ex_erreur_acces_fichier; 2699: return; 2700: } 2701: 2702: if (longueur_effective == longueur_questure) 2703: { 2704: free(tampon_lecture); 2705: longueur_questure *= 2; 2706: } 2707: } while(longueur_effective == longueur_questure); 2708: 2709: longueur_enregistrement = 1; 2710: 2711: for(i = 0; i < longueur_effective; i++) 2712: { 2713: if (isprint(tampon_lecture[i]) != 0) 2714: { 2715: longueur_enregistrement += 4; 2716: } 2717: else 2718: { 2719: longueur_enregistrement++; 2720: } 2721: } 2722: 2723: /* 2724: * Création de la liste de sortie 2725: */ 2726: 2727: if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL) 2728: { 2729: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2730: return; 2731: } 2732: 2733: if (((*s_objet_type).objet = malloc(longueur_enregistrement * 2734: sizeof(unsigned char))) == NULL) 2735: { 2736: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2737: return; 2738: } 2739: 2740: ptr = (*s_objet_type).objet; 2741: 2742: for(i = 0; i < longueur_effective; i++) 2743: { 2744: if (isprint(tampon_lecture[i]) != 0) 2745: { 2746: (*ptr) = tampon_lecture[i]; 2747: ptr++; 2748: } 2749: else 2750: { 2751: (*ptr) = '\\'; 2752: ptr++; 2753: (*ptr) = 'x'; 2754: ptr++; 2755: sprintf(ptr, "%02X", tampon_lecture[i]); 2756: ptr += 2; 2757: } 2758: } 2759: 2760: (*ptr) = d_code_fin_chaine; 2761: 2762: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 2763: == NULL) 2764: { 2765: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2766: return; 2767: } 2768: 2769: if (((*s_objet_resultat).objet = 2770: allocation_maillon(s_etat_processus)) == NULL) 2771: { 2772: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2773: return; 2774: } 2775: 2776: (*((struct_liste_chainee *) (*s_objet_resultat).objet)) 2777: .donnee = s_objet_type; 2778: 2779: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) 2780: .suivant = allocation_maillon(s_etat_processus)) == NULL) 2781: { 2782: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2783: return; 2784: } 2785: 2786: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 2787: .suivant = NULL; 2788: 2789: if ((s_objet_adresse = allocation(s_etat_processus, LST)) 2790: == NULL) 2791: { 2792: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2793: return; 2794: } 2795: 2796: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 2797: .donnee = s_objet_adresse; 2798: 2799: /* 2800: * Les informations concernant la cible sont valides si 2801: * la socket est non connectée et que les domaines sont 2802: * INET ou INET6. 2803: * Dans tous les autres cas, on renvoie une liste vide. 2804: */ 2805: 2806: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine 2807: == PF_UNIX) || (strcmp((*((struct_socket *) 2808: (*s_objet_argument_1).objet)).type, "STREAM") == 0) || 2809: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) 2810: .type, "SEQUENTIAL DATAGRAM") == 0)) 2811: { 2812: // POSITION_FINALE peut être utilisée sans être initialisée ! 2813: // virer position_finale pour longueur_effective 2814: longueur_adresse = 0; 2815: recvfrom((*((struct_socket *) 2816: (*s_objet_argument_1).objet)).socket, tampon_lecture, 2817: position_finale, MSG_DONTWAIT, 2818: NULL, &longueur_adresse); 2819: 2820: (*s_objet_adresse).objet = NULL; 2821: } 2822: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2823: .domaine == PF_INET) 2824: { 2825: longueur_adresse = sizeof(adresse_ipv4); 2826: recvfrom((*((struct_socket *) 2827: (*s_objet_argument_1).objet)).socket, tampon_lecture, 2828: position_finale, MSG_DONTWAIT, 2829: (struct sockaddr *) &adresse_ipv4, &longueur_adresse); 2830: 2831: if (((*s_objet_adresse).objet = 2832: allocation_maillon(s_etat_processus)) == NULL) 2833: { 2834: (*s_etat_processus).erreur_systeme = 2835: d_es_allocation_memoire; 2836: return; 2837: } 2838: 2839: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2840: .donnee = allocation(s_etat_processus, VIN)) == NULL) 2841: { 2842: (*s_etat_processus).erreur_systeme = 2843: d_es_allocation_memoire; 2844: return; 2845: } 2846: 2847: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 2848: (*s_objet_adresse).objet)).donnee).objet)).taille = 4; 2849: 2850: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 2851: (*s_objet_adresse).objet)).donnee).objet)).tableau = 2852: malloc(4 * sizeof(integer8))) == NULL) 2853: { 2854: (*s_etat_processus).erreur_systeme = 2855: d_es_allocation_memoire; 2856: return; 2857: } 2858: 2859: ((integer8 *) (*((struct_vecteur *) 2860: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2861: .objet)).donnee).objet)).tableau)[0] = 2862: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; 2863: ((integer8 *) (*((struct_vecteur *) 2864: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2865: .objet)).donnee).objet)).tableau)[1] = 2866: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; 2867: ((integer8 *) (*((struct_vecteur *) 2868: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2869: .objet)).donnee).objet)).tableau)[2] = 2870: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; 2871: ((integer8 *) (*((struct_vecteur *) 2872: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2873: .objet)).donnee).objet)).tableau)[3] = 2874: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; 2875: 2876: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2877: .suivant = allocation_maillon(s_etat_processus)) 2878: == NULL) 2879: { 2880: (*s_etat_processus).erreur_systeme = 2881: d_es_allocation_memoire; 2882: return; 2883: } 2884: 2885: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2886: .suivant).donnee = allocation(s_etat_processus, INT)) 2887: == NULL) 2888: { 2889: (*s_etat_processus).erreur_systeme = 2890: d_es_allocation_memoire; 2891: return; 2892: } 2893: 2894: (*((integer8 *) (*(*(*((struct_liste_chainee *) 2895: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 2896: (integer8) ntohs(adresse_ipv4.sin_port); 2897: 2898: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2899: .suivant).suivant = NULL; 2900: } 2901: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2902: .domaine == PF_INET6) 2903: { 2904: # ifdef IPV6 2905: longueur_adresse = sizeof(adresse_ipv6); 2906: recvfrom((*((struct_socket *) 2907: (*s_objet_argument_1).objet)).socket, tampon_lecture, 2908: position_finale, MSG_DONTWAIT, 2909: (struct sockaddr *) &adresse_ipv6, &longueur_adresse); 2910: 2911: if (((*s_objet_adresse).objet = 2912: allocation_maillon(s_etat_processus)) == NULL) 2913: { 2914: (*s_etat_processus).erreur_systeme = 2915: d_es_allocation_memoire; 2916: return; 2917: } 2918: 2919: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2920: .donnee = allocation(s_etat_processus, VIN)) == NULL) 2921: { 2922: (*s_etat_processus).erreur_systeme = 2923: d_es_allocation_memoire; 2924: return; 2925: } 2926: 2927: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 2928: (*s_objet_adresse).objet)).donnee).objet)).taille = 16; 2929: 2930: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 2931: (*s_objet_adresse).objet)).donnee).objet)).tableau = 2932: malloc(16 * sizeof(integer8))) == NULL) 2933: { 2934: (*s_etat_processus).erreur_systeme = 2935: d_es_allocation_memoire; 2936: return; 2937: } 2938: 2939: for(i = 0; i < 16; i++) 2940: { 2941: ((integer8 *) (*((struct_vecteur *) 2942: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2943: .objet)).donnee).objet)).tableau)[0] = 2944: adresse_ipv6.sin6_addr.s6_addr[i]; 2945: } 2946: 2947: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2948: .suivant = allocation_maillon(s_etat_processus)) 2949: == NULL) 2950: { 2951: (*s_etat_processus).erreur_systeme = 2952: d_es_allocation_memoire; 2953: return; 2954: } 2955: 2956: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2957: .suivant).donnee = allocation(s_etat_processus, INT)) 2958: == NULL) 2959: { 2960: (*s_etat_processus).erreur_systeme = 2961: d_es_allocation_memoire; 2962: return; 2963: } 2964: 2965: (*((integer8 *) (*(*(*((struct_liste_chainee *) 2966: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 2967: (integer8) ntohs(adresse_ipv6.sin6_port); 2968: 2969: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2970: .suivant).suivant = NULL; 2971: # else 2972: if ((*s_etat_processus).langue == 'F') 2973: { 2974: printf("+++Attention : Support du protocole" 2975: " IPv6 indisponible\n"); 2976: } 2977: else 2978: { 2979: printf("+++Warning : IPv6 support " 2980: "unavailable\n"); 2981: } 2982: # endif 2983: } 2984: else 2985: { 2986: longueur_adresse = 0; 2987: recvfrom((*((struct_socket *) 2988: (*s_objet_argument_1).objet)).socket, tampon_lecture, 2989: position_finale, MSG_DONTWAIT, 2990: NULL, &longueur_adresse); 2991: } 2992: 2993: free(tampon_lecture); 2994: 2995: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2996: s_objet_resultat) == d_erreur) 2997: { 2998: return; 2999: } 3000: } 3001: } 3002: else 3003: { 3004: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 3005: return; 3006: } 3007: 3008: liberation(s_etat_processus, s_objet_argument_1); 3009: 3010: return; 3011: } 3012: 3013: // vim: ts=4