![]() ![]() | ![]() |
Ajout du support des sockets non formatées.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.13 4: Copyright (C) 1989-2013 Dr. BERTRAND Joël 5: 6: This file is part of RPL/2. 7: 8: RPL/2 is free software; you can redistribute it and/or modify it 9: under the terms of the CeCILL V2 License as published by the french 10: CEA, CNRS and INRIA. 11: 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License 15: for more details. 16: 17: You should have received a copy of the CeCILL License 18: along with RPL/2. If not, write to info@cecill.info. 19: ================================================================================ 20: */ 21: 22: 23: #include "rpl-conv.h" 24: 25: 26: /* 27: ================================================================================ 28: Fonction '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 i; 856: integer8 id; 857: integer8 position_clef; 858: integer8 longueur_effective; 859: integer8 longueur_enregistrement; 860: integer8 longueur_questure; 861: integer8 niveau; 862: integer8 pointeur; 863: integer8 position_finale; 864: integer8 position_initiale; 865: 866: logical1 format_degenere; 867: logical1 indicateur_48; 868: logical1 presence_chaine; 869: logical1 presence_indicateur; 870: logical1 trame_complete; 871: 872: long longueur; 873: 874: socklen_t longueur_adresse; 875: 876: sqlite3_stmt *ppStmt; 877: 878: struct flock lock; 879: 880: struct sockaddr_un adresse_unix; 881: struct sockaddr_in adresse_ipv4; 882: # ifdef IPV6 883: struct sockaddr_in6 adresse_ipv6; 884: # endif 885: 886: struct pollfd poll_fd; 887: 888: struct timespec attente; 889: 890: struct_descripteur_fichier *descripteur; 891: 892: struct_liste_chainee *l_element_courant; 893: struct_liste_chainee *l_element_courant_format; 894: struct_liste_chainee *l_element_inclus; 895: 896: struct_objet *s_objet_adresse; 897: struct_objet *s_objet_argument_1; 898: struct_objet *s_objet_argument_2; 899: struct_objet *s_objet_resultat; 900: struct_objet *s_objet_type; 901: 902: unsigned char caractere; 903: unsigned char *clef_utf8; 904: unsigned char *commande; 905: unsigned char *format_chaine; 906: unsigned char *ptr; 907: unsigned char *tampon_lecture; 908: unsigned char *tampon; 909: unsigned char *tampon2; 910: 911: (*s_etat_processus).erreur_execution = d_ex; 912: 913: if ((*s_etat_processus).affichage_arguments == 'Y') 914: { 915: printf("\n READ "); 916: 917: if ((*s_etat_processus).langue == 'F') 918: { 919: printf("(lecture d'un enregistrement d'un fichier)\n\n"); 920: } 921: else 922: { 923: printf("(read a record of a file)\n\n"); 924: } 925: 926: printf(" 1: %s, %s\n\n", d_FCH, d_SCK); 927: 928: printf(" 2: %s, %s\n", d_INT, d_CHN); 929: printf(" 1: %s\n", d_FCH); 930: return; 931: } 932: else if ((*s_etat_processus).test_instruction == 'Y') 933: { 934: (*s_etat_processus).nombre_arguments = -1; 935: return; 936: } 937: 938: if (test_cfsf(s_etat_processus, 31) == d_vrai) 939: { 940: if ((*s_etat_processus).l_base_pile == NULL) 941: { 942: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 943: return; 944: } 945: 946: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH) 947: { 948: if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile) 949: .donnee).objet)).acces == 'S') 950: { 951: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 952: { 953: return; 954: } 955: } 956: else 957: { 958: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 959: { 960: return; 961: } 962: } 963: } 964: else 965: { 966: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 967: { 968: return; 969: } 970: } 971: } 972: 973: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 974: &s_objet_argument_1) == d_erreur) 975: { 976: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 977: return; 978: } 979: 980: if ((*s_objet_argument_1).type == FCH) 981: { 982: if ((descripteur = descripteur_fichier(s_etat_processus, 983: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL) 984: { 985: return; 986: } 987: 988: /* 989: * Vérification des verrous 990: */ 991: 992: lock.l_type = F_RDLCK; 993: lock.l_whence = SEEK_SET; 994: lock.l_start = 0; 995: lock.l_len = 0; 996: lock.l_pid = getpid(); 997: 998: if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock) 999: == -1) 1000: { 1001: liberation(s_etat_processus, s_objet_argument_1); 1002: 1003: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1004: return; 1005: } 1006: 1007: if (lock.l_type != F_UNLCK) 1008: { 1009: liberation(s_etat_processus, s_objet_argument_1); 1010: 1011: (*s_etat_processus).erreur_execution = 1012: d_ex_fichier_verrouille; 1013: return; 1014: } 1015: 1016: /* 1017: * Vérification de l'autorisation de lecture 1018: */ 1019: 1020: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection 1021: == 'W') 1022: { 1023: liberation(s_etat_processus, s_objet_argument_1); 1024: 1025: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; 1026: return; 1027: } 1028: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection 1029: == 'N') 1030: { 1031: if ((*descripteur).type == 'C') 1032: { 1033: if (fflush((*descripteur).descripteur_c) != 0) 1034: { 1035: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1036: return; 1037: } 1038: } 1039: } 1040: 1041: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N') 1042: { 1043: /* 1044: * Fichiers formatés 1045: */ 1046: 1047: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 1048: == 'S') 1049: { 1050: /* 1051: * Fichiers séquentiels 1052: */ 1053: 1054: longueur_questure = 256; 1055: 1056: if ((tampon_lecture = malloc(longueur_questure * 1057: sizeof(unsigned char))) == NULL) 1058: { 1059: (*s_etat_processus).erreur_systeme = 1060: d_es_allocation_memoire; 1061: return; 1062: } 1063: 1064: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); 1065: 1066: if ((position_initiale = ftell((*descripteur).descripteur_c)) 1067: == -1) 1068: { 1069: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1070: return; 1071: } 1072: 1073: do 1074: { 1075: longueur_effective = fread(tampon_lecture, 1076: (size_t) sizeof(unsigned char), longueur_questure, 1077: (*descripteur).descripteur_c); 1078: 1079: pointeur = 0; 1080: presence_indicateur = d_faux; 1081: 1082: while(pointeur < longueur_effective) 1083: { 1084: if (tampon_lecture[pointeur] == '{') 1085: { 1086: presence_indicateur = d_vrai; 1087: break; 1088: } 1089: 1090: position_initiale++; 1091: pointeur++; 1092: } 1093: 1094: if (presence_indicateur == d_vrai) 1095: { 1096: break; 1097: } 1098: } while(longueur_effective == longueur_questure); 1099: 1100: if (presence_indicateur == d_faux) 1101: { 1102: liberation(s_etat_processus, s_objet_argument_1); 1103: free(tampon_lecture); 1104: 1105: (*s_etat_processus).erreur_execution = 1106: d_ex_fin_de_fichier_atteinte; 1107: return; 1108: } 1109: 1110: position_finale = position_initiale + 1; 1111: presence_chaine = d_faux; 1112: niveau = 1; 1113: 1114: if (fseek((*descripteur).descripteur_c, position_finale, 1115: SEEK_SET) != 0) 1116: { 1117: liberation(s_etat_processus, s_objet_argument_1); 1118: free(tampon_lecture); 1119: 1120: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1121: return; 1122: } 1123: 1124: do 1125: { 1126: longueur_effective = fread(tampon_lecture, 1127: (size_t) sizeof(unsigned char), longueur_questure, 1128: (*descripteur).descripteur_c); 1129: 1130: pointeur = 0; 1131: presence_indicateur = d_faux; 1132: 1133: while(pointeur < longueur_effective) 1134: { 1135: if (tampon_lecture[pointeur] == '"') 1136: { 1137: if (pointeur > 0) 1138: { 1139: if (tampon_lecture[pointeur - 1] != '\\') 1140: { 1141: presence_chaine = (presence_chaine == 1142: d_vrai) ? d_faux : d_vrai; 1143: } 1144: } 1145: else 1146: { 1147: presence_chaine = (presence_chaine == d_vrai) 1148: ? d_faux : d_vrai; 1149: } 1150: } 1151: else 1152: { 1153: if (presence_chaine == d_faux) 1154: { 1155: if (tampon_lecture[pointeur] == '{') 1156: { 1157: niveau++; 1158: } 1159: else if (tampon_lecture[pointeur] == '}') 1160: { 1161: niveau--; 1162: } 1163: } 1164: } 1165: 1166: position_finale++; 1167: pointeur++; 1168: 1169: if (niveau == 0) 1170: { 1171: presence_indicateur = d_vrai; 1172: break; 1173: } 1174: } 1175: 1176: if (presence_indicateur == d_vrai) 1177: { 1178: break; 1179: } 1180: } while(longueur_effective == longueur_questure); 1181: 1182: if (presence_indicateur == d_faux) 1183: { 1184: liberation(s_etat_processus, s_objet_argument_1); 1185: free(tampon_lecture); 1186: 1187: (*s_etat_processus).erreur_execution = 1188: d_ex_fin_de_fichier_atteinte; 1189: return; 1190: } 1191: 1192: free(tampon_lecture); 1193: longueur_enregistrement = position_finale - position_initiale; 1194: 1195: if ((tampon_lecture = malloc((longueur_enregistrement + 1) * 1196: sizeof(unsigned char))) == NULL) 1197: { 1198: (*s_etat_processus).erreur_systeme = 1199: d_es_allocation_memoire; 1200: return; 1201: } 1202: 1203: if (fseek((*descripteur).descripteur_c, position_initiale, 1204: SEEK_SET) != 0) 1205: { 1206: liberation(s_etat_processus, s_objet_argument_1); 1207: free(tampon_lecture); 1208: 1209: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1210: return; 1211: } 1212: 1213: longueur_effective = fread(tampon_lecture, 1214: (size_t) sizeof(unsigned char), 1215: (size_t) longueur_enregistrement, 1216: (*descripteur).descripteur_c); 1217: 1218: if (longueur_effective != longueur_enregistrement) 1219: { 1220: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1221: return; 1222: } 1223: 1224: tampon_lecture[longueur_enregistrement] = d_code_fin_chaine; 1225: tampon = (*s_etat_processus).instruction_courante; 1226: 1227: if (((*s_etat_processus).instruction_courante = 1228: transliteration(s_etat_processus, tampon_lecture, 1229: "UTF-8", d_locale)) == NULL) 1230: { 1231: (*s_etat_processus).instruction_courante = tampon; 1232: liberation(s_etat_processus, s_objet_argument_1); 1233: free(tampon_lecture); 1234: return; 1235: } 1236: 1237: indicateur_48 = test_cfsf(s_etat_processus, 48); 1238: cf(s_etat_processus, 48); 1239: 1240: recherche_type(s_etat_processus); 1241: free((*s_etat_processus).instruction_courante); 1242: 1243: if ((*s_etat_processus).erreur_execution != d_ex) 1244: { 1245: if (indicateur_48 == d_vrai) 1246: { 1247: sf(s_etat_processus, 48); 1248: } 1249: else 1250: { 1251: cf(s_etat_processus, 48); 1252: } 1253: 1254: (*s_etat_processus).instruction_courante = tampon; 1255: free(tampon_lecture); 1256: 1257: liberation(s_etat_processus, s_objet_argument_1); 1258: return; 1259: } 1260: 1261: if (indicateur_48 == d_vrai) 1262: { 1263: sf(s_etat_processus, 48); 1264: } 1265: else 1266: { 1267: cf(s_etat_processus, 48); 1268: } 1269: 1270: (*s_etat_processus).instruction_courante = tampon; 1271: free(tampon_lecture); 1272: } 1273: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 1274: == 'D') 1275: { 1276: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); 1277: 1278: if (depilement(s_etat_processus, &((*s_etat_processus) 1279: .l_base_pile), &s_objet_argument_2) == d_erreur) 1280: { 1281: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1282: return; 1283: } 1284: 1285: if ((*s_objet_argument_2).type != INT) 1286: { 1287: liberation(s_etat_processus, s_objet_argument_1); 1288: liberation(s_etat_processus, s_objet_argument_2); 1289: 1290: (*s_etat_processus).erreur_execution = 1291: d_ex_erreur_type_argument; 1292: return; 1293: } 1294: 1295: if (alsprintf(&commande, "select data from data where " 1296: "id = %lld", (*((integer8 *) (*s_objet_argument_2) 1297: .objet))) < 0) 1298: { 1299: (*s_etat_processus).erreur_systeme = 1300: d_es_allocation_memoire; 1301: return; 1302: } 1303: 1304: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1305: commande, strlen(commande), &ppStmt, &queue) 1306: != SQLITE_OK) 1307: { 1308: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1309: return; 1310: } 1311: 1312: attente.tv_sec = 0; 1313: attente.tv_nsec = GRANULARITE_us * 1000; 1314: 1315: do 1316: { 1317: ios = sqlite3_step(ppStmt); 1318: 1319: switch(ios) 1320: { 1321: case SQLITE_ROW: 1322: { 1323: // Résultat attendu 1324: break; 1325: } 1326: 1327: case SQLITE_DONE: 1328: { 1329: // Aucun enregistrement 1330: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1331: { 1332: (*s_etat_processus).erreur_systeme = 1333: d_es_erreur_fichier; 1334: return; 1335: } 1336: 1337: free(commande); 1338: 1339: liberation(s_etat_processus, s_objet_argument_1); 1340: liberation(s_etat_processus, s_objet_argument_2); 1341: 1342: (*s_etat_processus).erreur_execution = 1343: d_ex_enregistrement_inexistant; 1344: return; 1345: } 1346: 1347: case SQLITE_BUSY: 1348: case SQLITE_LOCKED: 1349: { 1350: nanosleep(&attente, NULL); 1351: INCR_GRANULARITE(attente.tv_nsec); 1352: break; 1353: } 1354: 1355: default: 1356: { 1357: (*s_etat_processus).erreur_systeme = 1358: d_es_erreur_fichier; 1359: return; 1360: } 1361: } 1362: } while(ios != SQLITE_ROW); 1363: 1364: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) 1365: { 1366: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1367: return; 1368: } 1369: 1370: tampon = (*s_etat_processus).instruction_courante; 1371: 1372: if ((tampon_lecture = (unsigned char *) 1373: sqlite3_column_text(ppStmt, 0)) == NULL) 1374: { 1375: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1376: return; 1377: } 1378: 1379: if (((*s_etat_processus).instruction_courante = 1380: transliteration(s_etat_processus, tampon_lecture, 1381: "UTF-8", d_locale)) == NULL) 1382: { 1383: (*s_etat_processus).instruction_courante = tampon; 1384: 1385: liberation(s_etat_processus, s_objet_argument_1); 1386: liberation(s_etat_processus, s_objet_argument_2); 1387: free(commande); 1388: return; 1389: } 1390: 1391: indicateur_48 = test_cfsf(s_etat_processus, 48); 1392: cf(s_etat_processus, 48); 1393: 1394: recherche_type(s_etat_processus); 1395: 1396: if ((*s_etat_processus).erreur_execution != d_ex) 1397: { 1398: if (indicateur_48 == d_vrai) 1399: { 1400: sf(s_etat_processus, 48); 1401: } 1402: else 1403: { 1404: cf(s_etat_processus, 48); 1405: } 1406: 1407: liberation(s_etat_processus, s_objet_argument_1); 1408: liberation(s_etat_processus, s_objet_argument_2); 1409: 1410: free((*s_etat_processus).instruction_courante); 1411: free(commande); 1412: 1413: (*s_etat_processus).instruction_courante = tampon; 1414: return; 1415: } 1416: 1417: if (indicateur_48 == d_vrai) 1418: { 1419: sf(s_etat_processus, 48); 1420: } 1421: else 1422: { 1423: cf(s_etat_processus, 48); 1424: } 1425: 1426: free((*s_etat_processus).instruction_courante); 1427: liberation(s_etat_processus, s_objet_argument_2); 1428: (*s_etat_processus).instruction_courante = tampon; 1429: 1430: if (sqlite3_step(ppStmt) != SQLITE_DONE) 1431: { 1432: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1433: return; 1434: } 1435: 1436: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1437: { 1438: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1439: return; 1440: } 1441: 1442: free(commande); 1443: } 1444: else 1445: { 1446: BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); 1447: 1448: if (depilement(s_etat_processus, &((*s_etat_processus) 1449: .l_base_pile), &s_objet_argument_2) == d_erreur) 1450: { 1451: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1452: return; 1453: } 1454: 1455: if ((*s_objet_argument_2).type != CHN) 1456: { 1457: liberation(s_etat_processus, s_objet_argument_1); 1458: liberation(s_etat_processus, s_objet_argument_2); 1459: 1460: (*s_etat_processus).erreur_execution = 1461: d_ex_erreur_type_argument; 1462: return; 1463: } 1464: 1465: // Récupération de la position de la clef 1466: 1467: if (alsprintf(&commande, "select key from control " 1468: "where id = 1") < 0) 1469: { 1470: (*s_etat_processus).erreur_systeme = 1471: d_es_allocation_memoire; 1472: return; 1473: } 1474: 1475: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1476: commande, strlen(commande), &ppStmt, &queue) 1477: != SQLITE_OK) 1478: { 1479: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1480: return; 1481: } 1482: 1483: attente.tv_sec = 0; 1484: attente.tv_nsec = GRANULARITE_us * 1000; 1485: 1486: do 1487: { 1488: ios = sqlite3_step(ppStmt); 1489: 1490: if (ios == SQLITE_ROW) 1491: { 1492: break; 1493: } 1494: else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED)) 1495: { 1496: nanosleep(&attente, NULL); 1497: INCR_GRANULARITE(attente.tv_nsec); 1498: } 1499: else 1500: { 1501: (*s_etat_processus).erreur_systeme = 1502: d_es_erreur_fichier; 1503: return; 1504: } 1505: } while(ios != SQLITE_ROW); 1506: 1507: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) 1508: { 1509: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1510: return; 1511: } 1512: 1513: position_clef = sqlite3_column_int64(ppStmt, 0); 1514: 1515: if (sqlite3_step(ppStmt) != SQLITE_DONE) 1516: { 1517: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1518: return; 1519: } 1520: 1521: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1522: { 1523: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1524: return; 1525: } 1526: 1527: free(commande); 1528: 1529: if ((clef_utf8 = transliteration(s_etat_processus, 1530: (unsigned char *) (*s_objet_argument_2).objet, 1531: d_locale, "UTF-8")) == NULL) 1532: { 1533: liberation(s_etat_processus, s_objet_argument_1); 1534: liberation(s_etat_processus, s_objet_argument_2); 1535: 1536: return; 1537: } 1538: 1539: // Récupération de l'identifiant de la clef 1540: 1541: if (alsprintf(&commande, "select id from key where key = " 1542: "'{ \"%s\" }'", clef_utf8) < 0) 1543: { 1544: (*s_etat_processus).erreur_systeme = 1545: d_es_allocation_memoire; 1546: return; 1547: } 1548: 1549: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1550: commande, strlen(commande), &ppStmt, &queue) 1551: != SQLITE_OK) 1552: { 1553: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1554: return; 1555: } 1556: 1557: attente.tv_sec = 0; 1558: attente.tv_nsec = GRANULARITE_us * 1000; 1559: 1560: do 1561: { 1562: ios = sqlite3_step(ppStmt); 1563: 1564: switch(ios) 1565: { 1566: case SQLITE_ROW: 1567: { 1568: // Résultat attendu : une clef correspond. 1569: break; 1570: } 1571: 1572: case SQLITE_DONE: 1573: { 1574: // Aucun enregistrement 1575: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1576: { 1577: (*s_etat_processus).erreur_systeme = 1578: d_es_erreur_fichier; 1579: return; 1580: } 1581: 1582: free(clef_utf8); 1583: free(commande); 1584: 1585: liberation(s_etat_processus, s_objet_argument_1); 1586: liberation(s_etat_processus, s_objet_argument_2); 1587: 1588: (*s_etat_processus).erreur_execution = 1589: d_ex_enregistrement_inexistant; 1590: return; 1591: } 1592: 1593: case SQLITE_BUSY: 1594: case SQLITE_LOCKED: 1595: { 1596: nanosleep(&attente, NULL); 1597: INCR_GRANULARITE(attente.tv_nsec); 1598: break; 1599: } 1600: 1601: default: 1602: { 1603: (*s_etat_processus).erreur_systeme = 1604: d_es_erreur_fichier; 1605: return; 1606: } 1607: } 1608: } while(ios != SQLITE_ROW); 1609: 1610: if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) 1611: { 1612: free(clef_utf8); 1613: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1614: return; 1615: } 1616: 1617: id = sqlite3_column_int64(ppStmt, 0); 1618: 1619: if (sqlite3_step(ppStmt) != SQLITE_DONE) 1620: { 1621: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1622: return; 1623: } 1624: 1625: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1626: { 1627: (*s_etat_processus).erreur_systeme = 1628: d_es_erreur_fichier; 1629: return; 1630: } 1631: 1632: free(commande); 1633: 1634: if (alsprintf(&commande, "select data from data where " 1635: "key_id = %lld order by sequence asc", id) < 0) 1636: { 1637: (*s_etat_processus).erreur_systeme = 1638: d_es_allocation_memoire; 1639: return; 1640: } 1641: 1642: if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, 1643: commande, strlen(commande), &ppStmt, &queue) 1644: != SQLITE_OK) 1645: { 1646: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1647: return; 1648: } 1649: 1650: element = 1; 1651: 1652: attente.tv_sec = 0; 1653: attente.tv_nsec = GRANULARITE_us * 1000; 1654: 1655: do 1656: { 1657: switch(ios = sqlite3_step(ppStmt)) 1658: { 1659: case SQLITE_ROW: 1660: { 1661: // Donnée supplémentaire 1662: 1663: if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) 1664: { 1665: (*s_etat_processus).erreur_systeme = 1666: d_es_erreur_fichier; 1667: return; 1668: } 1669: 1670: tampon = (*s_etat_processus).instruction_courante; 1671: 1672: if ((tampon_lecture = (unsigned char *) 1673: sqlite3_column_text(ppStmt, 0)) == NULL) 1674: { 1675: (*s_etat_processus).erreur_systeme = 1676: d_es_erreur_fichier; 1677: return; 1678: } 1679: 1680: if (((*s_etat_processus).instruction_courante = 1681: transliteration(s_etat_processus, 1682: tampon_lecture, 1683: "UTF-8", d_locale)) == NULL) 1684: { 1685: (*s_etat_processus).instruction_courante = 1686: tampon; 1687: 1688: liberation(s_etat_processus, 1689: s_objet_argument_1); 1690: liberation(s_etat_processus, 1691: s_objet_argument_2); 1692: 1693: free(commande); 1694: free(clef_utf8); 1695: return; 1696: } 1697: 1698: indicateur_48 = test_cfsf(s_etat_processus, 48); 1699: cf(s_etat_processus, 48); 1700: 1701: recherche_type(s_etat_processus); 1702: 1703: if ((*s_etat_processus).erreur_execution != d_ex) 1704: { 1705: if (indicateur_48 == d_vrai) 1706: { 1707: sf(s_etat_processus, 48); 1708: } 1709: else 1710: { 1711: cf(s_etat_processus, 48); 1712: } 1713: 1714: liberation(s_etat_processus, 1715: s_objet_argument_1); 1716: liberation(s_etat_processus, 1717: s_objet_argument_2); 1718: 1719: free((*s_etat_processus).instruction_courante); 1720: free(commande); 1721: free(clef_utf8); 1722: 1723: (*s_etat_processus).instruction_courante = 1724: tampon; 1725: return; 1726: } 1727: 1728: if (indicateur_48 == d_vrai) 1729: { 1730: sf(s_etat_processus, 48); 1731: } 1732: else 1733: { 1734: cf(s_etat_processus, 48); 1735: } 1736: 1737: free((*s_etat_processus).instruction_courante); 1738: (*s_etat_processus).instruction_courante = tampon; 1739: 1740: element++; 1741: 1742: // Inscription de la clef 1743: 1744: if (element == position_clef) 1745: { 1746: if (((*s_etat_processus).instruction_courante = 1747: transliteration(s_etat_processus, 1748: clef_utf8, "UTF-8", d_locale)) == NULL) 1749: { 1750: (*s_etat_processus).instruction_courante = 1751: tampon; 1752: 1753: liberation(s_etat_processus, 1754: s_objet_argument_1); 1755: liberation(s_etat_processus, 1756: s_objet_argument_2); 1757: 1758: free(commande); 1759: free(clef_utf8); 1760: return; 1761: } 1762: 1763: if (alsprintf(&tampon2, "{ \"%s\" }", 1764: (*s_etat_processus) 1765: .instruction_courante) < 0) 1766: { 1767: (*s_etat_processus).erreur_systeme = 1768: d_es_allocation_memoire; 1769: return; 1770: } 1771: 1772: free((*s_etat_processus).instruction_courante); 1773: (*s_etat_processus).instruction_courante 1774: = tampon2; 1775: 1776: indicateur_48 = test_cfsf(s_etat_processus, 48); 1777: cf(s_etat_processus, 48); 1778: 1779: recherche_type(s_etat_processus); 1780: 1781: if ((*s_etat_processus).erreur_execution 1782: != d_ex) 1783: { 1784: if (indicateur_48 == d_vrai) 1785: { 1786: sf(s_etat_processus, 48); 1787: } 1788: else 1789: { 1790: cf(s_etat_processus, 48); 1791: } 1792: 1793: liberation(s_etat_processus, 1794: s_objet_argument_1); 1795: liberation(s_etat_processus, 1796: s_objet_argument_2); 1797: 1798: free((*s_etat_processus) 1799: .instruction_courante); 1800: free(commande); 1801: free(clef_utf8); 1802: 1803: (*s_etat_processus).instruction_courante = 1804: tampon; 1805: return; 1806: } 1807: 1808: if (indicateur_48 == d_vrai) 1809: { 1810: sf(s_etat_processus, 48); 1811: } 1812: else 1813: { 1814: cf(s_etat_processus, 48); 1815: } 1816: 1817: free((*s_etat_processus).instruction_courante); 1818: (*s_etat_processus).instruction_courante = 1819: tampon; 1820: 1821: element++; 1822: } 1823: 1824: break; 1825: } 1826: 1827: case SQLITE_DONE: 1828: { 1829: // Fin de la liste 1830: break; 1831: } 1832: 1833: case SQLITE_BUSY: 1834: case SQLITE_LOCKED: 1835: { 1836: nanosleep(&attente, NULL); 1837: INCR_GRANULARITE(attente.tv_nsec); 1838: break; 1839: } 1840: 1841: default: 1842: { 1843: (*s_etat_processus).erreur_systeme = 1844: d_es_erreur_fichier; 1845: return; 1846: } 1847: } 1848: } while(ios != SQLITE_DONE); 1849: 1850: if (sqlite3_finalize(ppStmt) != SQLITE_OK) 1851: { 1852: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1853: return; 1854: } 1855: 1856: free(commande); 1857: free(clef_utf8); 1858: 1859: liberation(s_etat_processus, s_objet_argument_2); 1860: 1861: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 1862: == NULL) 1863: { 1864: (*s_etat_processus).erreur_systeme = 1865: d_es_allocation_memoire; 1866: return; 1867: } 1868: 1869: l_element_courant = NULL; 1870: l_element_inclus = NULL; 1871: 1872: for(element--; element > 0; element--) 1873: { 1874: if (depilement(s_etat_processus, &((*s_etat_processus) 1875: .l_base_pile), &s_objet_argument_2) == d_erreur) 1876: { 1877: (*s_etat_processus).erreur_systeme = 1878: d_es_erreur_fichier; 1879: return; 1880: } 1881: 1882: if ((*s_objet_argument_2).type != LST) 1883: { 1884: (*s_etat_processus).erreur_systeme = 1885: d_es_erreur_fichier; 1886: return; 1887: } 1888: 1889: l_element_inclus = (*s_objet_argument_2).objet; 1890: 1891: if (l_element_inclus != NULL) 1892: { 1893: while(l_element_inclus != NULL) 1894: { 1895: if ((*l_element_inclus).suivant == NULL) 1896: { 1897: (*l_element_inclus).suivant = l_element_courant; 1898: break; 1899: } 1900: 1901: l_element_inclus = (*l_element_inclus).suivant; 1902: } 1903: 1904: l_element_courant = (*s_objet_argument_2).objet; 1905: (*s_objet_argument_2).objet = NULL; 1906: } 1907: 1908: liberation(s_etat_processus, s_objet_argument_2); 1909: } 1910: 1911: (*s_objet_resultat).objet = l_element_inclus; 1912: 1913: if (empilement(s_etat_processus, 1914: &((*s_etat_processus).l_base_pile), 1915: s_objet_resultat) == d_erreur) 1916: { 1917: return; 1918: } 1919: } 1920: } 1921: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire 1922: == 'Y') 1923: { 1924: /* 1925: * Fichiers non formatés 1926: */ 1927: 1928: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 1929: == 'S') 1930: { 1931: /* 1932: * Fichiers séquentiels 1933: * 1934: * Les fichiers séquentiels non formatés contiennent comme 1935: * les fichiers séquentiels formatés leurs enregistrements 1936: * sous la forme de listes les unes derrières les autres. 1937: * 1938: * Le quartet de poids fort du premier octet à lire 1939: * doit donc être égal à 0100. Si ce n'est pas le cas, 1940: * il sera impossible de lire le fichier et on renvoie 1941: * immédiatement une erreur. Si on lit dans le fichier 1942: * la valeur attendue, on récupère la longueur en octet 1943: * de l'enregistrement puis on le lit. 1944: */ 1945: 1946: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); 1947: 1948: if ((s_objet_resultat = lecture_fichier_non_formate( 1949: s_etat_processus, (*descripteur).descripteur_c, -1, 1950: d_faux)) == NULL) 1951: { 1952: return; 1953: } 1954: 1955: if (empilement(s_etat_processus, 1956: &((*s_etat_processus).l_base_pile), 1957: s_objet_resultat) == d_erreur) 1958: { 1959: return; 1960: } 1961: } 1962: } 1963: else 1964: { 1965: /* 1966: * Fichiers de type FLOW 1967: */ 1968: 1969: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces 1970: == 'S') 1971: { 1972: /* 1973: * Fichiers séquentiels 1974: */ 1975: 1976: BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); 1977: longueur_enregistrement = 0; 1978: 1979: if ((position_initiale = ftell((*descripteur).descripteur_c)) 1980: == -1) 1981: { 1982: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 1983: return; 1984: } 1985: 1986: l_element_courant_format = (struct_liste_chainee *) 1987: (*(*((struct_fichier *) (*s_objet_argument_1).objet)) 1988: .format).objet; 1989: l_element_courant = NULL; 1990: 1991: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 1992: == NULL) 1993: { 1994: (*s_etat_processus).erreur_systeme = 1995: d_es_allocation_memoire; 1996: return; 1997: } 1998: 1999: while(l_element_courant_format != NULL) 2000: { 2001: if ((*(*l_element_courant_format).donnee).type != CHN) 2002: { 2003: liberation(s_etat_processus, s_objet_argument_1); 2004: liberation(s_etat_processus, s_objet_resultat); 2005: 2006: (*s_etat_processus).erreur_execution = 2007: d_ex_erreur_type_argument; 2008: return; 2009: } 2010: 2011: if ((format_chaine = conversion_majuscule((unsigned char *) 2012: (*(*l_element_courant_format).donnee).objet)) 2013: == NULL) 2014: { 2015: (*s_etat_processus).erreur_systeme = 2016: d_es_allocation_memoire; 2017: return; 2018: } 2019: 2020: if (strncmp("LENGTH*(", format_chaine, 8) != 0) 2021: { 2022: liberation(s_etat_processus, s_objet_argument_1); 2023: liberation(s_etat_processus, s_objet_resultat); 2024: free(format_chaine); 2025: 2026: (*s_etat_processus).erreur_execution = 2027: d_ex_erreur_format_fichier; 2028: return; 2029: } 2030: 2031: longueur = strlen(format_chaine); 2032: 2033: if (format_chaine[longueur - 1] != ')') 2034: { 2035: liberation(s_etat_processus, s_objet_argument_1); 2036: liberation(s_etat_processus, s_objet_resultat); 2037: free(format_chaine); 2038: 2039: (*s_etat_processus).erreur_execution = 2040: d_ex_erreur_format_fichier; 2041: return; 2042: } 2043: 2044: format_chaine[longueur] = d_code_fin_chaine; 2045: 2046: if (format_chaine[8] == '*') 2047: { 2048: format_degenere = d_vrai; 2049: } 2050: else 2051: { 2052: // Détermination de la longueur 2053: format_degenere = d_faux; 2054: 2055: if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1) 2056: { 2057: liberation(s_etat_processus, s_objet_argument_1); 2058: liberation(s_etat_processus, s_objet_resultat); 2059: free(format_chaine); 2060: 2061: (*s_etat_processus).erreur_execution = 2062: d_ex_erreur_format_fichier; 2063: return; 2064: } 2065: } 2066: 2067: free(format_chaine); 2068: 2069: if (format_degenere == d_vrai) 2070: { 2071: do 2072: { 2073: c = getc((*descripteur).descripteur_c); 2074: longueur_enregistrement++; 2075: } while((c != '\n') && (c != EOF)); 2076: 2077: if (fseek((*descripteur).descripteur_c, 2078: position_initiale, SEEK_SET) != 0) 2079: { 2080: liberation(s_etat_processus, s_objet_argument_1); 2081: liberation(s_etat_processus, s_objet_resultat); 2082: 2083: (*s_etat_processus).erreur_systeme = 2084: d_es_erreur_fichier; 2085: return; 2086: } 2087: } 2088: else 2089: { 2090: longueur_enregistrement = longueur; 2091: } 2092: 2093: if ((tampon_lecture = malloc((longueur_enregistrement) 2094: * sizeof(unsigned char))) == NULL) 2095: { 2096: (*s_etat_processus).erreur_systeme = 2097: d_es_allocation_memoire; 2098: return; 2099: } 2100: 2101: longueur_effective = fread(tampon_lecture, 2102: (size_t) sizeof(unsigned char), 2103: (size_t) longueur_enregistrement, 2104: (*descripteur).descripteur_c); 2105: 2106: if (l_element_courant == NULL) 2107: { 2108: // Premier maillon de la liste 2109: if (((*s_objet_resultat).objet = 2110: allocation_maillon(s_etat_processus)) == NULL) 2111: { 2112: (*s_etat_processus).erreur_systeme = 2113: d_es_allocation_memoire; 2114: return; 2115: } 2116: 2117: l_element_courant = (*s_objet_resultat).objet; 2118: } 2119: else 2120: { 2121: if (((*l_element_courant).suivant = 2122: allocation_maillon(s_etat_processus)) == NULL) 2123: { 2124: (*s_etat_processus).erreur_systeme = 2125: d_es_allocation_memoire; 2126: return; 2127: } 2128: 2129: l_element_courant = (*l_element_courant).suivant; 2130: } 2131: 2132: (*l_element_courant).suivant = NULL; 2133: 2134: if (((*l_element_courant).donnee = 2135: allocation(s_etat_processus, CHN)) == NULL) 2136: { 2137: (*s_etat_processus).erreur_systeme = 2138: d_es_allocation_memoire; 2139: return; 2140: } 2141: 2142: if (format_degenere == d_vrai) 2143: { 2144: if (((*(*l_element_courant).donnee).objet = 2145: analyse_flux(s_etat_processus, tampon_lecture, 2146: longueur_enregistrement - 1)) == NULL) 2147: { 2148: return; 2149: } 2150: } 2151: else 2152: { 2153: if (((*(*l_element_courant).donnee).objet = 2154: analyse_flux(s_etat_processus, tampon_lecture, 2155: longueur_enregistrement)) == NULL) 2156: { 2157: return; 2158: } 2159: } 2160: 2161: free(tampon_lecture); 2162: 2163: l_element_courant_format = 2164: (*l_element_courant_format).suivant; 2165: } 2166: 2167: if (empilement(s_etat_processus, 2168: &((*s_etat_processus).l_base_pile), 2169: s_objet_resultat) == d_erreur) 2170: { 2171: return; 2172: } 2173: } 2174: else 2175: { 2176: liberation(s_etat_processus, s_objet_argument_1); 2177: 2178: (*s_etat_processus).erreur_execution = 2179: d_ex_erreur_type_fichier; 2180: return; 2181: } 2182: } 2183: } 2184: else if ((*s_objet_argument_1).type == SCK) 2185: { 2186: /* 2187: * Vérification de l'autorisation de lecture 2188: */ 2189: 2190: if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection 2191: == 'W') 2192: { 2193: liberation(s_etat_processus, s_objet_argument_1); 2194: 2195: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; 2196: return; 2197: } 2198: 2199: /* 2200: * Vérification de l'écoute de la socket si celle-ci est connectée 2201: */ 2202: 2203: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, 2204: "STREAM") == 0) || (strcmp((*((struct_socket *) 2205: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM") 2206: == 0)) 2207: { 2208: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2209: .socket_en_ecoute == 'Y') 2210: { 2211: liberation(s_etat_processus, s_objet_argument_1); 2212: 2213: (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute; 2214: return; 2215: } 2216: } 2217: 2218: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N') 2219: { // Socket formatée 2220: longueur_questure = 4096; 2221: longueur_effective = 0; 2222: tampon_lecture = NULL; 2223: 2224: attente.tv_sec = 0; 2225: attente.tv_nsec = GRANULARITE_us * 1000; 2226: 2227: trame_complete = d_faux; 2228: position_initiale = 0; 2229: position_finale = 0; 2230: 2231: do 2232: { 2233: presence_indicateur = d_faux; 2234: 2235: if ((tampon_lecture = realloc(tampon_lecture, 2236: (longueur_effective + longueur_questure + 1) 2237: * sizeof(unsigned char))) == NULL) 2238: { 2239: (*s_etat_processus).erreur_systeme = 2240: d_es_allocation_memoire; 2241: return; 2242: } 2243: 2244: # ifndef SEMAPHORES_NOMMES 2245: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 2246: # else 2247: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 2248: # endif 2249: { 2250: (*s_etat_processus).erreur_systeme = d_es_processus; 2251: return; 2252: } 2253: 2254: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2255: .domaine == PF_UNIX) 2256: { 2257: longueur_adresse = sizeof(adresse_unix); 2258: 2259: do 2260: { 2261: ios = recvfrom((*((struct_socket *) 2262: (*s_objet_argument_1).objet)).socket, 2263: tampon_lecture, 2264: longueur_effective + longueur_questure, 2265: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2266: &adresse_unix, &longueur_adresse); 2267: } while((ios == -1) && (errno == EINTR)); 2268: } 2269: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2270: .domaine == PF_INET) 2271: { 2272: longueur_adresse = sizeof(adresse_ipv4); 2273: 2274: do 2275: { 2276: ios = recvfrom((*((struct_socket *) 2277: (*s_objet_argument_1).objet)).socket, 2278: tampon_lecture, 2279: longueur_effective + longueur_questure, 2280: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2281: &adresse_ipv4, &longueur_adresse); 2282: } while((ios == -1) && (errno == EINTR)); 2283: } 2284: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2285: .domaine == PF_INET6) 2286: { 2287: # ifdef IPV6 2288: longueur_adresse = sizeof(adresse_ipv6); 2289: 2290: do 2291: { 2292: ios = recvfrom((*((struct_socket *) 2293: (*s_objet_argument_1).objet)).socket, 2294: tampon_lecture, 2295: longueur_effective + longueur_questure, 2296: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2297: &adresse_ipv6, &longueur_adresse); 2298: } while((ios == -1) && (errno == EINTR)); 2299: # else 2300: if ((*s_etat_processus).langue == 'F') 2301: { 2302: printf("+++Attention : Support du protocole" 2303: " IPv6 indisponible\n"); 2304: } 2305: else 2306: { 2307: printf("+++Warning : IPv6 support " 2308: "unavailable\n"); 2309: } 2310: 2311: longueur_adresse = 0; 2312: longueur_effective = 0; 2313: ios = 0; 2314: # endif 2315: } 2316: else 2317: { 2318: free(tampon_lecture); 2319: liberation(s_etat_processus, s_objet_argument_1); 2320: 2321: # ifndef SEMAPHORES_NOMMES 2322: while(sem_wait(&((*s_etat_processus) 2323: .semaphore_fork)) != 0) 2324: # else 2325: while(sem_wait((*s_etat_processus) 2326: .semaphore_fork) != 0) 2327: # endif 2328: { 2329: (*s_etat_processus).erreur_systeme = 2330: d_es_processus; 2331: } 2332: 2333: (*s_etat_processus).erreur_execution = 2334: d_ex_erreur_acces_fichier; 2335: return; 2336: } 2337: 2338: if (ios <= 0) 2339: { 2340: nanosleep(&attente, NULL); 2341: INCR_GRANULARITE(attente.tv_nsec); 2342: } 2343: else 2344: { 2345: attente.tv_sec = 0; 2346: attente.tv_nsec = GRANULARITE_us * 1000; 2347: } 2348: 2349: scrutation_injection(s_etat_processus); 2350: 2351: if ((*s_etat_processus).var_volatile_requete_arret == -1) 2352: { 2353: if (ios >= 0) 2354: { 2355: longueur_effective = ios; 2356: } 2357: 2358: break; 2359: } 2360: 2361: // Une donnée a été reçue. 2362: 2363: if (ios >= 0) 2364: { 2365: longueur_effective = ios; 2366: position_initiale = 0; 2367: presence_indicateur = d_faux; 2368: 2369: do 2370: { 2371: if (tampon_lecture[position_initiale] == '{') 2372: { 2373: presence_indicateur = d_vrai; 2374: break; 2375: } 2376: 2377: position_initiale++; 2378: } while(position_initiale < longueur_effective); 2379: 2380: if (presence_indicateur == d_vrai) 2381: { 2382: position_finale = position_initiale + 1; 2383: presence_chaine = d_faux; 2384: presence_indicateur = d_faux; 2385: niveau = 1; 2386: 2387: while(position_finale < longueur_effective) 2388: { 2389: caractere = tampon_lecture[position_finale]; 2390: 2391: if (caractere == '"') 2392: { 2393: if (position_finale > 0) 2394: { 2395: if (tampon_lecture[position_finale - 1] 2396: != '\\') 2397: { 2398: presence_chaine = (presence_chaine == 2399: d_vrai) ? d_faux : d_vrai; 2400: } 2401: } 2402: else 2403: { 2404: presence_chaine = 2405: (presence_chaine == d_vrai) 2406: ? d_faux : d_vrai; 2407: } 2408: } 2409: else 2410: { 2411: if (presence_chaine == d_faux) 2412: { 2413: if (caractere == '{') 2414: { 2415: niveau++; 2416: } 2417: else if (caractere == '}') 2418: { 2419: niveau--; 2420: } 2421: } 2422: } 2423: 2424: if (niveau == 0) 2425: { 2426: presence_indicateur = d_vrai; 2427: trame_complete = d_vrai; 2428: break; 2429: } 2430: 2431: position_finale++; 2432: } 2433: } 2434: 2435: // On retire une trame du buffer. 2436: 2437: if (trame_complete == d_vrai) 2438: { 2439: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2440: .domaine == PF_UNIX) 2441: { 2442: do 2443: { 2444: longueur_adresse = sizeof(adresse_unix); 2445: recvfrom((*((struct_socket *) 2446: (*s_objet_argument_1).objet)).socket, 2447: tampon_lecture, longueur_effective, 2448: 0, (struct sockaddr *) 2449: &adresse_unix, &longueur_adresse); 2450: } while((ios == -1) && (errno == EINTR)); 2451: } 2452: else if ((*((struct_socket *) (*s_objet_argument_1) 2453: .objet)).domaine == PF_INET) 2454: { 2455: do 2456: { 2457: longueur_adresse = sizeof(adresse_ipv4); 2458: recvfrom((*((struct_socket *) 2459: (*s_objet_argument_1).objet)).socket, 2460: tampon_lecture, longueur_effective, 2461: 0, (struct sockaddr *) 2462: &adresse_ipv4, &longueur_adresse); 2463: } while((ios == -1) && (errno == EINTR)); 2464: } 2465: else if ((*((struct_socket *) (*s_objet_argument_1) 2466: .objet)) .domaine == PF_INET6) 2467: { 2468: # ifdef IPV6 2469: do 2470: { 2471: longueur_adresse = sizeof(adresse_ipv6); 2472: recvfrom((*((struct_socket *) 2473: (*s_objet_argument_1).objet)).socket, 2474: tampon_lecture, longueur_effective, 2475: 0, (struct sockaddr *) 2476: &adresse_ipv6, &longueur_adresse); 2477: } while((ios == -1) && (errno == EINTR)); 2478: # else 2479: if ((*s_etat_processus).langue == 'F') 2480: { 2481: printf("+++Attention : Support du protocole" 2482: " IPv6 indisponible\n"); 2483: } 2484: else 2485: { 2486: printf("+++Warning : IPv6 support " 2487: "unavailable\n"); 2488: } 2489: 2490: # endif 2491: } 2492: 2493: longueur_effective = ios; 2494: } 2495: else 2496: { 2497: // Installation d'un timeout pour sortir de 2498: // l'instruction dans le cas où la transmission serait 2499: // invalide et que la trame reçue serait erronée. 2500: 2501: poll_fd.fd = (*((struct_socket *) 2502: (*s_objet_argument_1).objet)).socket; 2503: poll_fd.events = POLLIN; 2504: 2505: while((ios = poll(&poll_fd, 1, 10000)) <= 0) 2506: { 2507: // La fin de la trame n'est pas atteinte. 2508: 2509: switch(ios) 2510: { 2511: case EINTR: 2512: { 2513: if ((*s_etat_processus) 2514: .var_volatile_requete_arret == -1) 2515: { 2516: liberation(s_etat_processus, 2517: s_objet_argument_1); 2518: free(tampon_lecture); 2519: return; 2520: } 2521: 2522: break; 2523: } 2524: 2525: case 0: 2526: { 2527: liberation(s_etat_processus, 2528: s_objet_argument_1); 2529: free(tampon_lecture); 2530: 2531: (*s_etat_processus).erreur_execution = 2532: d_ex_fin_de_fichier_atteinte; 2533: return; 2534: } 2535: } 2536: } 2537: } 2538: } 2539: 2540: # ifndef SEMAPHORES_NOMMES 2541: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) 2542: # else 2543: while(sem_wait((*s_etat_processus).semaphore_fork) != 0) 2544: # endif 2545: { 2546: if (errno == EINTR) 2547: { 2548: (*s_etat_processus).erreur_systeme = d_es_processus; 2549: return; 2550: } 2551: } 2552: 2553: if ((*s_etat_processus).var_volatile_requete_arret == -1) 2554: { 2555: 2556: /* 2557: * Si le père tue le processus courant grâce au signal 2558: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement 2559: * correspond à l'utilisation de STOP sur le processus 2560: * en cours. La variable longueur_effective vaut '-1'. 2561: */ 2562: 2563: free(tampon_lecture); 2564: liberation(s_etat_processus, s_objet_argument_1); 2565: return; 2566: } 2567: 2568: if (longueur_effective == -1) 2569: { 2570: free(tampon_lecture); 2571: liberation(s_etat_processus, s_objet_argument_1); 2572: 2573: (*s_etat_processus).erreur_execution = 2574: d_ex_erreur_acces_fichier; 2575: return; 2576: } 2577: } while(trame_complete == d_faux); 2578: 2579: tampon_lecture[++position_finale] = d_code_fin_chaine; 2580: tampon = (*s_etat_processus).instruction_courante; 2581: (*s_etat_processus).instruction_courante = tampon_lecture; 2582: 2583: indicateur_48 = test_cfsf(s_etat_processus, 48); 2584: cf(s_etat_processus, 48); 2585: 2586: recherche_type(s_etat_processus); 2587: 2588: if ((*s_etat_processus).erreur_execution != d_ex) 2589: { 2590: (*s_etat_processus).instruction_courante = tampon; 2591: free(tampon_lecture); 2592: 2593: if (indicateur_48 == d_vrai) 2594: { 2595: sf(s_etat_processus, 48); 2596: } 2597: else 2598: { 2599: cf(s_etat_processus, 48); 2600: } 2601: 2602: if ((*s_etat_processus).var_volatile_requete_arret == -1) 2603: { 2604: (*s_etat_processus).erreur_execution = d_ex; 2605: } 2606: 2607: liberation(s_etat_processus, s_objet_argument_1); 2608: return; 2609: } 2610: 2611: if (indicateur_48 == d_vrai) 2612: { 2613: sf(s_etat_processus, 48); 2614: } 2615: else 2616: { 2617: cf(s_etat_processus, 48); 2618: } 2619: 2620: (*s_etat_processus).instruction_courante = tampon; 2621: 2622: /* 2623: * Création de la liste de sortie 2624: */ 2625: 2626: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2627: &s_objet_type) == d_erreur) 2628: { 2629: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 2630: return; 2631: } 2632: 2633: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 2634: == NULL) 2635: { 2636: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2637: return; 2638: } 2639: 2640: if (((*s_objet_resultat).objet = 2641: allocation_maillon(s_etat_processus)) == NULL) 2642: { 2643: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2644: return; 2645: } 2646: 2647: (*((struct_liste_chainee *) (*s_objet_resultat).objet)) 2648: .donnee = s_objet_type; 2649: 2650: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) 2651: .suivant = allocation_maillon(s_etat_processus)) == NULL) 2652: { 2653: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2654: return; 2655: } 2656: 2657: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 2658: .suivant = NULL; 2659: 2660: if ((s_objet_adresse = allocation(s_etat_processus, LST)) 2661: == NULL) 2662: { 2663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2664: return; 2665: } 2666: 2667: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 2668: .donnee = s_objet_adresse; 2669: 2670: /* 2671: * Les informations concernant la cible sont valides si 2672: * la socket est non connectée et des domaines INET ou INET6. 2673: * Dans tous les autres cas, on renvoie une liste vide. 2674: */ 2675: 2676: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine 2677: == PF_UNIX) || (strcmp((*((struct_socket *) 2678: (*s_objet_argument_1).objet)).type, "STREAM") == 0) || 2679: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) 2680: .type, "SEQUENTIAL DATAGRAM") == 0)) 2681: { 2682: (*s_objet_adresse).objet = NULL; 2683: } 2684: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2685: .domaine == PF_INET) 2686: { 2687: if (((*s_objet_adresse).objet = 2688: allocation_maillon(s_etat_processus)) == NULL) 2689: { 2690: (*s_etat_processus).erreur_systeme = 2691: d_es_allocation_memoire; 2692: return; 2693: } 2694: 2695: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2696: .donnee = allocation(s_etat_processus, VIN)) == NULL) 2697: { 2698: (*s_etat_processus).erreur_systeme = 2699: d_es_allocation_memoire; 2700: return; 2701: } 2702: 2703: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 2704: (*s_objet_adresse).objet)).donnee).objet)).taille = 4; 2705: 2706: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 2707: (*s_objet_adresse).objet)).donnee).objet)).tableau = 2708: malloc(4 * sizeof(integer8))) == NULL) 2709: { 2710: (*s_etat_processus).erreur_systeme = 2711: d_es_allocation_memoire; 2712: return; 2713: } 2714: 2715: ((integer8 *) (*((struct_vecteur *) 2716: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2717: .objet)).donnee).objet)).tableau)[0] = 2718: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; 2719: ((integer8 *) (*((struct_vecteur *) 2720: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2721: .objet)).donnee).objet)).tableau)[1] = 2722: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; 2723: ((integer8 *) (*((struct_vecteur *) 2724: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2725: .objet)).donnee).objet)).tableau)[2] = 2726: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; 2727: ((integer8 *) (*((struct_vecteur *) 2728: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2729: .objet)).donnee).objet)).tableau)[3] = 2730: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; 2731: 2732: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2733: .suivant = allocation_maillon(s_etat_processus)) 2734: == NULL) 2735: { 2736: (*s_etat_processus).erreur_systeme = 2737: d_es_allocation_memoire; 2738: return; 2739: } 2740: 2741: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2742: .suivant).donnee = allocation(s_etat_processus, INT)) 2743: == NULL) 2744: { 2745: (*s_etat_processus).erreur_systeme = 2746: d_es_allocation_memoire; 2747: return; 2748: } 2749: 2750: (*((integer8 *) (*(*(*((struct_liste_chainee *) 2751: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 2752: (integer8) ntohs(adresse_ipv4.sin_port); 2753: 2754: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2755: .suivant).suivant = NULL; 2756: } 2757: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2758: .domaine == PF_INET6) 2759: { 2760: # ifdef IPV6 2761: if (((*s_objet_adresse).objet = 2762: allocation_maillon(s_etat_processus)) == NULL) 2763: { 2764: (*s_etat_processus).erreur_systeme = 2765: d_es_allocation_memoire; 2766: return; 2767: } 2768: 2769: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2770: .donnee = allocation(s_etat_processus, VIN)) == NULL) 2771: { 2772: (*s_etat_processus).erreur_systeme = 2773: d_es_allocation_memoire; 2774: return; 2775: } 2776: 2777: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 2778: (*s_objet_adresse).objet)).donnee).objet)).taille = 16; 2779: 2780: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 2781: (*s_objet_adresse).objet)).donnee).objet)).tableau = 2782: malloc(16 * sizeof(integer8))) == NULL) 2783: { 2784: (*s_etat_processus).erreur_systeme = 2785: d_es_allocation_memoire; 2786: return; 2787: } 2788: 2789: for(i = 0; i < 16; i++) 2790: { 2791: ((integer8 *) (*((struct_vecteur *) 2792: (*(*((struct_liste_chainee *) (*s_objet_adresse) 2793: .objet)).donnee).objet)).tableau)[0] = 2794: adresse_ipv6.sin6_addr.s6_addr[i]; 2795: } 2796: 2797: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2798: .suivant = allocation_maillon(s_etat_processus)) 2799: == NULL) 2800: { 2801: (*s_etat_processus).erreur_systeme = 2802: d_es_allocation_memoire; 2803: return; 2804: } 2805: 2806: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2807: .suivant).donnee = allocation(s_etat_processus, INT)) 2808: == NULL) 2809: { 2810: (*s_etat_processus).erreur_systeme = 2811: d_es_allocation_memoire; 2812: return; 2813: } 2814: 2815: (*((integer8 *) (*(*(*((struct_liste_chainee *) 2816: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 2817: (integer8) ntohs(adresse_ipv6.sin6_port); 2818: 2819: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 2820: .suivant).suivant = NULL; 2821: # else 2822: if ((*s_etat_processus).langue == 'F') 2823: { 2824: printf("+++Attention : Support du protocole" 2825: " IPv6 indisponible\n"); 2826: } 2827: else 2828: { 2829: printf("+++Warning : IPv6 support " 2830: "unavailable\n"); 2831: } 2832: # endif 2833: } 2834: else 2835: { 2836: longueur_adresse = 0; 2837: recvfrom((*((struct_socket *) 2838: (*s_objet_argument_1).objet)).socket, tampon_lecture, 2839: position_finale, MSG_DONTWAIT, 2840: NULL, &longueur_adresse); 2841: } 2842: 2843: free(tampon_lecture); 2844: 2845: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2846: s_objet_resultat) == d_erreur) 2847: { 2848: return; 2849: } 2850: } 2851: else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire 2852: == 'Y') 2853: { // socket non formatée 2854: longueur_questure = 4096; 2855: longueur_effective = 0; 2856: tampon_lecture = NULL; 2857: 2858: attente.tv_sec = 0; 2859: attente.tv_nsec = GRANULARITE_us * 1000; 2860: 2861: trame_complete = d_faux; 2862: position_initiale = 0; 2863: position_finale = 0; 2864: 2865: do 2866: { 2867: presence_indicateur = d_faux; 2868: 2869: if ((tampon_lecture = realloc(tampon_lecture, 2870: (longueur_effective + longueur_questure + 1) 2871: * sizeof(unsigned char))) == NULL) 2872: { 2873: (*s_etat_processus).erreur_systeme = 2874: d_es_allocation_memoire; 2875: return; 2876: } 2877: 2878: # ifndef SEMAPHORES_NOMMES 2879: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 2880: # else 2881: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 2882: # endif 2883: { 2884: (*s_etat_processus).erreur_systeme = d_es_processus; 2885: return; 2886: } 2887: 2888: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2889: .domaine == PF_UNIX) 2890: { 2891: longueur_adresse = sizeof(adresse_unix); 2892: 2893: do 2894: { 2895: ios = recvfrom((*((struct_socket *) 2896: (*s_objet_argument_1).objet)).socket, 2897: tampon_lecture, 2898: longueur_effective + longueur_questure, 2899: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2900: &adresse_unix, &longueur_adresse); 2901: } while((ios == -1) && (errno == EINTR)); 2902: } 2903: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2904: .domaine == PF_INET) 2905: { 2906: longueur_adresse = sizeof(adresse_ipv4); 2907: 2908: do 2909: { 2910: ios = recvfrom((*((struct_socket *) 2911: (*s_objet_argument_1).objet)).socket, 2912: tampon_lecture, 2913: longueur_effective + longueur_questure, 2914: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2915: &adresse_ipv4, &longueur_adresse); 2916: } while((ios == -1) && (errno == EINTR)); 2917: } 2918: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2919: .domaine == PF_INET6) 2920: { 2921: # ifdef IPV6 2922: longueur_adresse = sizeof(adresse_ipv6); 2923: 2924: do 2925: { 2926: ios = recvfrom((*((struct_socket *) 2927: (*s_objet_argument_1).objet)).socket, 2928: tampon_lecture, 2929: longueur_effective + longueur_questure, 2930: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 2931: &adresse_ipv6, &longueur_adresse); 2932: } while((ios == -1) && (errno == EINTR)); 2933: # else 2934: if ((*s_etat_processus).langue == 'F') 2935: { 2936: printf("+++Attention : Support du protocole" 2937: " IPv6 indisponible\n"); 2938: } 2939: else 2940: { 2941: printf("+++Warning : IPv6 support " 2942: "unavailable\n"); 2943: } 2944: 2945: longueur_adresse = 0; 2946: longueur_effective = 0; 2947: ios = 0; 2948: # endif 2949: } 2950: else 2951: { 2952: free(tampon_lecture); 2953: liberation(s_etat_processus, s_objet_argument_1); 2954: 2955: # ifndef SEMAPHORES_NOMMES 2956: while(sem_wait(&((*s_etat_processus) 2957: .semaphore_fork)) != 0) 2958: # else 2959: while(sem_wait((*s_etat_processus) 2960: .semaphore_fork) != 0) 2961: # endif 2962: { 2963: (*s_etat_processus).erreur_systeme = 2964: d_es_processus; 2965: } 2966: 2967: (*s_etat_processus).erreur_execution = 2968: d_ex_erreur_acces_fichier; 2969: return; 2970: } 2971: 2972: if (ios <= 0) 2973: { 2974: nanosleep(&attente, NULL); 2975: INCR_GRANULARITE(attente.tv_nsec); 2976: } 2977: else 2978: { 2979: attente.tv_sec = 0; 2980: attente.tv_nsec = GRANULARITE_us * 1000; 2981: } 2982: 2983: scrutation_injection(s_etat_processus); 2984: 2985: if ((*s_etat_processus).var_volatile_requete_arret == -1) 2986: { 2987: if (ios >= 0) 2988: { 2989: longueur_effective += ios; 2990: } 2991: 2992: break; 2993: } 2994: 2995: // Une donnée a été reçue. 2996: 2997: if (ios == (longueur_effective + longueur_questure)) 2998: { 2999: longueur_effective = ios; 3000: position_initiale = 0; 3001: presence_indicateur = d_faux; 3002: } 3003: else if (ios > 0) 3004: { 3005: // On retire une trame du buffer. 3006: 3007: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3008: .domaine == PF_UNIX) 3009: { 3010: do 3011: { 3012: longueur_adresse = sizeof(adresse_unix); 3013: recvfrom((*((struct_socket *) 3014: (*s_objet_argument_1).objet)).socket, 3015: tampon_lecture, longueur_effective, 3016: 0, (struct sockaddr *) 3017: &adresse_unix, &longueur_adresse); 3018: } while((ios == -1) && (errno == EINTR)); 3019: } 3020: else if ((*((struct_socket *) (*s_objet_argument_1) 3021: .objet)).domaine == PF_INET) 3022: { 3023: do 3024: { 3025: longueur_adresse = sizeof(adresse_ipv4); 3026: recvfrom((*((struct_socket *) 3027: (*s_objet_argument_1).objet)).socket, 3028: tampon_lecture, longueur_effective, 3029: 0, (struct sockaddr *) 3030: &adresse_ipv4, &longueur_adresse); 3031: } while((ios == -1) && (errno == EINTR)); 3032: } 3033: else if ((*((struct_socket *) (*s_objet_argument_1) 3034: .objet)) .domaine == PF_INET6) 3035: { 3036: # ifdef IPV6 3037: do 3038: { 3039: longueur_adresse = sizeof(adresse_ipv6); 3040: recvfrom((*((struct_socket *) 3041: (*s_objet_argument_1).objet)).socket, 3042: tampon_lecture, longueur_effective, 3043: 0, (struct sockaddr *) 3044: &adresse_ipv6, &longueur_adresse); 3045: } while((ios == -1) && (errno == EINTR)); 3046: # else 3047: if ((*s_etat_processus).langue == 'F') 3048: { 3049: printf("+++Attention : Support du protocole" 3050: " IPv6 indisponible\n"); 3051: } 3052: else 3053: { 3054: printf("+++Warning : IPv6 support " 3055: "unavailable\n"); 3056: } 3057: # endif 3058: } 3059: 3060: longueur_effective = ios; 3061: trame_complete = d_vrai; 3062: } 3063: 3064: # ifndef SEMAPHORES_NOMMES 3065: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) 3066: # else 3067: while(sem_wait((*s_etat_processus).semaphore_fork) != 0) 3068: # endif 3069: { 3070: if (errno == EINTR) 3071: { 3072: (*s_etat_processus).erreur_systeme = d_es_processus; 3073: return; 3074: } 3075: } 3076: 3077: if ((*s_etat_processus).var_volatile_requete_arret == -1) 3078: { 3079: 3080: /* 3081: * Si le père tue le processus courant grâce au signal 3082: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement 3083: * correspond à l'utilisation de STOP sur le processus 3084: * en cours. La variable longueur_effective vaut '-1'. 3085: */ 3086: 3087: free(tampon_lecture); 3088: liberation(s_etat_processus, s_objet_argument_1); 3089: return; 3090: } 3091: 3092: if (longueur_effective == -1) 3093: { 3094: free(tampon_lecture); 3095: liberation(s_etat_processus, s_objet_argument_1); 3096: 3097: (*s_etat_processus).erreur_execution = 3098: d_ex_erreur_acces_fichier; 3099: return; 3100: } 3101: } while(trame_complete == d_faux); 3102: 3103: /* 3104: * Création de la liste de sortie 3105: */ 3106: 3107: ptr = tampon_lecture; 3108: 3109: if ((s_objet_type = lecture_fichier_non_formate(s_etat_processus, 3110: &ptr, longueur_effective, d_faux)) == NULL) 3111: { 3112: free(tampon_lecture); 3113: 3114: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 3115: return; 3116: } 3117: 3118: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 3119: == NULL) 3120: { 3121: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3122: return; 3123: } 3124: 3125: if (((*s_objet_resultat).objet = 3126: allocation_maillon(s_etat_processus)) == NULL) 3127: { 3128: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3129: return; 3130: } 3131: 3132: (*((struct_liste_chainee *) (*s_objet_resultat).objet)) 3133: .donnee = s_objet_type; 3134: 3135: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) 3136: .suivant = allocation_maillon(s_etat_processus)) == NULL) 3137: { 3138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3139: return; 3140: } 3141: 3142: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 3143: .suivant = NULL; 3144: 3145: if ((s_objet_adresse = allocation(s_etat_processus, LST)) 3146: == NULL) 3147: { 3148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3149: return; 3150: } 3151: 3152: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 3153: .donnee = s_objet_adresse; 3154: 3155: /* 3156: * Les informations concernant la cible sont valides si 3157: * la socket est non connectée et des domaines INET ou INET6. 3158: * Dans tous les autres cas, on renvoie une liste vide. 3159: */ 3160: 3161: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine 3162: == PF_UNIX) || (strcmp((*((struct_socket *) 3163: (*s_objet_argument_1).objet)).type, "STREAM") == 0) || 3164: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) 3165: .type, "SEQUENTIAL DATAGRAM") == 0)) 3166: { 3167: (*s_objet_adresse).objet = NULL; 3168: } 3169: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3170: .domaine == PF_INET) 3171: { 3172: if (((*s_objet_adresse).objet = 3173: allocation_maillon(s_etat_processus)) == NULL) 3174: { 3175: (*s_etat_processus).erreur_systeme = 3176: d_es_allocation_memoire; 3177: return; 3178: } 3179: 3180: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3181: .donnee = allocation(s_etat_processus, VIN)) == NULL) 3182: { 3183: (*s_etat_processus).erreur_systeme = 3184: d_es_allocation_memoire; 3185: return; 3186: } 3187: 3188: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 3189: (*s_objet_adresse).objet)).donnee).objet)).taille = 4; 3190: 3191: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 3192: (*s_objet_adresse).objet)).donnee).objet)).tableau = 3193: malloc(4 * sizeof(integer8))) == NULL) 3194: { 3195: (*s_etat_processus).erreur_systeme = 3196: d_es_allocation_memoire; 3197: return; 3198: } 3199: 3200: ((integer8 *) (*((struct_vecteur *) 3201: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3202: .objet)).donnee).objet)).tableau)[0] = 3203: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; 3204: ((integer8 *) (*((struct_vecteur *) 3205: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3206: .objet)).donnee).objet)).tableau)[1] = 3207: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; 3208: ((integer8 *) (*((struct_vecteur *) 3209: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3210: .objet)).donnee).objet)).tableau)[2] = 3211: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; 3212: ((integer8 *) (*((struct_vecteur *) 3213: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3214: .objet)).donnee).objet)).tableau)[3] = 3215: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; 3216: 3217: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3218: .suivant = allocation_maillon(s_etat_processus)) 3219: == NULL) 3220: { 3221: (*s_etat_processus).erreur_systeme = 3222: d_es_allocation_memoire; 3223: return; 3224: } 3225: 3226: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3227: .suivant).donnee = allocation(s_etat_processus, INT)) 3228: == NULL) 3229: { 3230: (*s_etat_processus).erreur_systeme = 3231: d_es_allocation_memoire; 3232: return; 3233: } 3234: 3235: (*((integer8 *) (*(*(*((struct_liste_chainee *) 3236: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 3237: (integer8) ntohs(adresse_ipv4.sin_port); 3238: 3239: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3240: .suivant).suivant = NULL; 3241: } 3242: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3243: .domaine == PF_INET6) 3244: { 3245: # ifdef IPV6 3246: if (((*s_objet_adresse).objet = 3247: allocation_maillon(s_etat_processus)) == NULL) 3248: { 3249: (*s_etat_processus).erreur_systeme = 3250: d_es_allocation_memoire; 3251: return; 3252: } 3253: 3254: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3255: .donnee = allocation(s_etat_processus, VIN)) == NULL) 3256: { 3257: (*s_etat_processus).erreur_systeme = 3258: d_es_allocation_memoire; 3259: return; 3260: } 3261: 3262: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 3263: (*s_objet_adresse).objet)).donnee).objet)).taille = 16; 3264: 3265: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 3266: (*s_objet_adresse).objet)).donnee).objet)).tableau = 3267: malloc(16 * sizeof(integer8))) == NULL) 3268: { 3269: (*s_etat_processus).erreur_systeme = 3270: d_es_allocation_memoire; 3271: return; 3272: } 3273: 3274: for(i = 0; i < 16; i++) 3275: { 3276: ((integer8 *) (*((struct_vecteur *) 3277: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3278: .objet)).donnee).objet)).tableau)[0] = 3279: adresse_ipv6.sin6_addr.s6_addr[i]; 3280: } 3281: 3282: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3283: .suivant = allocation_maillon(s_etat_processus)) 3284: == NULL) 3285: { 3286: (*s_etat_processus).erreur_systeme = 3287: d_es_allocation_memoire; 3288: return; 3289: } 3290: 3291: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3292: .suivant).donnee = allocation(s_etat_processus, INT)) 3293: == NULL) 3294: { 3295: (*s_etat_processus).erreur_systeme = 3296: d_es_allocation_memoire; 3297: return; 3298: } 3299: 3300: (*((integer8 *) (*(*(*((struct_liste_chainee *) 3301: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 3302: (integer8) ntohs(adresse_ipv6.sin6_port); 3303: 3304: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3305: .suivant).suivant = NULL; 3306: # else 3307: if ((*s_etat_processus).langue == 'F') 3308: { 3309: printf("+++Attention : Support du protocole" 3310: " IPv6 indisponible\n"); 3311: } 3312: else 3313: { 3314: printf("+++Warning : IPv6 support " 3315: "unavailable\n"); 3316: } 3317: # endif 3318: } 3319: else 3320: { 3321: longueur_adresse = 0; 3322: recvfrom((*((struct_socket *) 3323: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3324: position_finale, MSG_DONTWAIT, 3325: NULL, &longueur_adresse); 3326: } 3327: 3328: free(tampon_lecture); 3329: 3330: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3331: s_objet_resultat) == d_erreur) 3332: { 3333: return; 3334: } 3335: } 3336: else 3337: { // FLOW 3338: #if 0 3339: longueur_questure = 256; 3340: 3341: do 3342: { 3343: if ((tampon_lecture = malloc((longueur_questure + 1) * 3344: sizeof(unsigned char))) == NULL) 3345: { 3346: (*s_etat_processus).erreur_systeme = 3347: d_es_allocation_memoire; 3348: return; 3349: } 3350: 3351: # ifndef SEMAPHORES_NOMMES 3352: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 3353: # else 3354: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 3355: # endif 3356: { 3357: (*s_etat_processus).erreur_systeme = d_es_processus; 3358: return; 3359: } 3360: 3361: attente.tv_sec = 0; 3362: attente.tv_nsec = GRANULARITE_us * 1000; 3363: 3364: for(;;) 3365: { 3366: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3367: .domaine == PF_UNIX) 3368: { 3369: longueur_adresse = sizeof(adresse_unix); 3370: longueur_effective = recvfrom((*((struct_socket *) 3371: (*s_objet_argument_1).objet)).socket, 3372: tampon_lecture, longueur_questure, 3373: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 3374: &adresse_unix, &longueur_adresse); 3375: } 3376: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3377: .domaine == PF_INET) 3378: { 3379: longueur_adresse = sizeof(adresse_ipv4); 3380: longueur_effective = recvfrom((*((struct_socket *) 3381: (*s_objet_argument_1).objet)).socket, 3382: tampon_lecture, longueur_questure, 3383: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 3384: &adresse_ipv4, &longueur_adresse); 3385: } 3386: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3387: .domaine == PF_INET6) 3388: { 3389: # ifdef IPV6 3390: longueur_adresse = sizeof(adresse_ipv6); 3391: longueur_effective = recvfrom((*((struct_socket *) 3392: (*s_objet_argument_1).objet)).socket, 3393: tampon_lecture, longueur_questure, 3394: MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) 3395: &adresse_ipv6, &longueur_adresse); 3396: # else 3397: if ((*s_etat_processus).langue == 'F') 3398: { 3399: printf("+++Attention : Support du protocole" 3400: " IPv6 indisponible\n"); 3401: } 3402: else 3403: { 3404: printf("+++Warning : IPv6 support " 3405: "unavailable\n"); 3406: } 3407: 3408: longueur_adresse = 0; 3409: longueur_effective = 0; 3410: # endif 3411: } 3412: else 3413: { 3414: free(tampon_lecture); 3415: liberation(s_etat_processus, s_objet_argument_1); 3416: 3417: # ifndef SEMAPHORES_NOMMES 3418: while(sem_wait(&((*s_etat_processus) 3419: .semaphore_fork)) != 0) 3420: # else 3421: while(sem_wait((*s_etat_processus) 3422: .semaphore_fork) != 0) 3423: # endif 3424: { 3425: if (errno != EINTR) 3426: { 3427: (*s_etat_processus).erreur_systeme = 3428: d_es_processus; 3429: return; 3430: } 3431: } 3432: 3433: (*s_etat_processus).erreur_execution = 3434: d_ex_erreur_acces_fichier; 3435: return; 3436: } 3437: 3438: if (longueur_effective < 0) 3439: { 3440: nanosleep(&attente, NULL); 3441: INCR_GRANULARITE(attente.tv_nsec); 3442: scrutation_injection(s_etat_processus); 3443: } 3444: 3445: if (((*s_etat_processus).var_volatile_requete_arret == -1) 3446: || (longueur_effective >= 0)) 3447: { 3448: break; 3449: } 3450: } 3451: 3452: # ifndef SEMAPHORES_NOMMES 3453: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) 3454: # else 3455: while(sem_wait((*s_etat_processus).semaphore_fork) != 0) 3456: # endif 3457: { 3458: if (errno != EINTR) 3459: { 3460: (*s_etat_processus).erreur_systeme = d_es_processus; 3461: return; 3462: } 3463: } 3464: 3465: if ((*s_etat_processus).var_volatile_requete_arret == -1) 3466: { 3467: 3468: /* 3469: * Si le père tue le processus courant grâce au signal 3470: * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement 3471: * correspond à l'utilisation de STOP sur le processus 3472: * en cours. La variable longueur_effective vaut '-1'. 3473: */ 3474: 3475: free(tampon_lecture); 3476: liberation(s_etat_processus, s_objet_argument_1); 3477: return; 3478: } 3479: 3480: if (longueur_effective == -1) 3481: { 3482: free(tampon_lecture); 3483: liberation(s_etat_processus, s_objet_argument_1); 3484: 3485: (*s_etat_processus).erreur_execution = 3486: d_ex_erreur_acces_fichier; 3487: return; 3488: } 3489: 3490: if (longueur_effective == longueur_questure) 3491: { 3492: free(tampon_lecture); 3493: longueur_questure *= 2; 3494: } 3495: } while(longueur_effective == longueur_questure); 3496: 3497: longueur_enregistrement = 1; 3498: 3499: for(i = 0; i < longueur_effective; i++) 3500: { 3501: if (isprint(tampon_lecture[i]) != 0) 3502: { 3503: longueur_enregistrement += 4; 3504: } 3505: else 3506: { 3507: longueur_enregistrement++; 3508: } 3509: } 3510: 3511: /* 3512: * Création de la liste de sortie 3513: */ 3514: 3515: if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL) 3516: { 3517: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3518: return; 3519: } 3520: 3521: if (((*s_objet_type).objet = malloc(longueur_enregistrement * 3522: sizeof(unsigned char))) == NULL) 3523: { 3524: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3525: return; 3526: } 3527: 3528: ptr = (*s_objet_type).objet; 3529: 3530: for(i = 0; i < longueur_effective; i++) 3531: { 3532: if (isprint(tampon_lecture[i]) != 0) 3533: { 3534: (*ptr) = tampon_lecture[i]; 3535: ptr++; 3536: } 3537: else 3538: { 3539: (*ptr) = '\\'; 3540: ptr++; 3541: (*ptr) = 'x'; 3542: ptr++; 3543: sprintf(ptr, "%02X", tampon_lecture[i]); 3544: ptr += 2; 3545: } 3546: } 3547: 3548: (*ptr) = d_code_fin_chaine; 3549: 3550: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 3551: == NULL) 3552: { 3553: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3554: return; 3555: } 3556: 3557: if (((*s_objet_resultat).objet = 3558: allocation_maillon(s_etat_processus)) == NULL) 3559: { 3560: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3561: return; 3562: } 3563: 3564: (*((struct_liste_chainee *) (*s_objet_resultat).objet)) 3565: .donnee = s_objet_type; 3566: 3567: if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) 3568: .suivant = allocation_maillon(s_etat_processus)) == NULL) 3569: { 3570: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3571: return; 3572: } 3573: 3574: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 3575: .suivant = NULL; 3576: 3577: if ((s_objet_adresse = allocation(s_etat_processus, LST)) 3578: == NULL) 3579: { 3580: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3581: return; 3582: } 3583: 3584: (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) 3585: .donnee = s_objet_adresse; 3586: 3587: /* 3588: * Les informations concernant la cible sont valides si 3589: * la socket est non connectée et que les domaines sont 3590: * INET ou INET6. 3591: * Dans tous les autres cas, on renvoie une liste vide. 3592: */ 3593: 3594: if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine 3595: == PF_UNIX) || (strcmp((*((struct_socket *) 3596: (*s_objet_argument_1).objet)).type, "STREAM") == 0) || 3597: (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) 3598: .type, "SEQUENTIAL DATAGRAM") == 0)) 3599: { 3600: // POSITION_FINALE peut être utilisée sans être initialisée ! 3601: // virer position_finale pour longueur_effective 3602: longueur_adresse = 0; 3603: recvfrom((*((struct_socket *) 3604: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3605: position_finale, MSG_DONTWAIT, 3606: NULL, &longueur_adresse); 3607: 3608: (*s_objet_adresse).objet = NULL; 3609: } 3610: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3611: .domaine == PF_INET) 3612: { 3613: longueur_adresse = sizeof(adresse_ipv4); 3614: recvfrom((*((struct_socket *) 3615: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3616: position_finale, MSG_DONTWAIT, 3617: (struct sockaddr *) &adresse_ipv4, &longueur_adresse); 3618: 3619: if (((*s_objet_adresse).objet = 3620: allocation_maillon(s_etat_processus)) == NULL) 3621: { 3622: (*s_etat_processus).erreur_systeme = 3623: d_es_allocation_memoire; 3624: return; 3625: } 3626: 3627: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3628: .donnee = allocation(s_etat_processus, VIN)) == NULL) 3629: { 3630: (*s_etat_processus).erreur_systeme = 3631: d_es_allocation_memoire; 3632: return; 3633: } 3634: 3635: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 3636: (*s_objet_adresse).objet)).donnee).objet)).taille = 4; 3637: 3638: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 3639: (*s_objet_adresse).objet)).donnee).objet)).tableau = 3640: malloc(4 * sizeof(integer8))) == NULL) 3641: { 3642: (*s_etat_processus).erreur_systeme = 3643: d_es_allocation_memoire; 3644: return; 3645: } 3646: 3647: ((integer8 *) (*((struct_vecteur *) 3648: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3649: .objet)).donnee).objet)).tableau)[0] = 3650: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; 3651: ((integer8 *) (*((struct_vecteur *) 3652: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3653: .objet)).donnee).objet)).tableau)[1] = 3654: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; 3655: ((integer8 *) (*((struct_vecteur *) 3656: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3657: .objet)).donnee).objet)).tableau)[2] = 3658: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; 3659: ((integer8 *) (*((struct_vecteur *) 3660: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3661: .objet)).donnee).objet)).tableau)[3] = 3662: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; 3663: 3664: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3665: .suivant = allocation_maillon(s_etat_processus)) 3666: == NULL) 3667: { 3668: (*s_etat_processus).erreur_systeme = 3669: d_es_allocation_memoire; 3670: return; 3671: } 3672: 3673: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3674: .suivant).donnee = allocation(s_etat_processus, INT)) 3675: == NULL) 3676: { 3677: (*s_etat_processus).erreur_systeme = 3678: d_es_allocation_memoire; 3679: return; 3680: } 3681: 3682: (*((integer8 *) (*(*(*((struct_liste_chainee *) 3683: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 3684: (integer8) ntohs(adresse_ipv4.sin_port); 3685: 3686: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3687: .suivant).suivant = NULL; 3688: } 3689: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 3690: .domaine == PF_INET6) 3691: { 3692: # ifdef IPV6 3693: longueur_adresse = sizeof(adresse_ipv6); 3694: recvfrom((*((struct_socket *) 3695: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3696: position_finale, MSG_DONTWAIT, 3697: (struct sockaddr *) &adresse_ipv6, &longueur_adresse); 3698: 3699: if (((*s_objet_adresse).objet = 3700: allocation_maillon(s_etat_processus)) == NULL) 3701: { 3702: (*s_etat_processus).erreur_systeme = 3703: d_es_allocation_memoire; 3704: return; 3705: } 3706: 3707: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3708: .donnee = allocation(s_etat_processus, VIN)) == NULL) 3709: { 3710: (*s_etat_processus).erreur_systeme = 3711: d_es_allocation_memoire; 3712: return; 3713: } 3714: 3715: (*((struct_vecteur *) (*(*((struct_liste_chainee *) 3716: (*s_objet_adresse).objet)).donnee).objet)).taille = 16; 3717: 3718: if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) 3719: (*s_objet_adresse).objet)).donnee).objet)).tableau = 3720: malloc(16 * sizeof(integer8))) == NULL) 3721: { 3722: (*s_etat_processus).erreur_systeme = 3723: d_es_allocation_memoire; 3724: return; 3725: } 3726: 3727: for(i = 0; i < 16; i++) 3728: { 3729: ((integer8 *) (*((struct_vecteur *) 3730: (*(*((struct_liste_chainee *) (*s_objet_adresse) 3731: .objet)).donnee).objet)).tableau)[0] = 3732: adresse_ipv6.sin6_addr.s6_addr[i]; 3733: } 3734: 3735: if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3736: .suivant = allocation_maillon(s_etat_processus)) 3737: == NULL) 3738: { 3739: (*s_etat_processus).erreur_systeme = 3740: d_es_allocation_memoire; 3741: return; 3742: } 3743: 3744: if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3745: .suivant).donnee = allocation(s_etat_processus, INT)) 3746: == NULL) 3747: { 3748: (*s_etat_processus).erreur_systeme = 3749: d_es_allocation_memoire; 3750: return; 3751: } 3752: 3753: (*((integer8 *) (*(*(*((struct_liste_chainee *) 3754: (*s_objet_adresse).objet)).suivant).donnee).objet)) = 3755: (integer8) ntohs(adresse_ipv6.sin6_port); 3756: 3757: (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) 3758: .suivant).suivant = NULL; 3759: # else 3760: if ((*s_etat_processus).langue == 'F') 3761: { 3762: printf("+++Attention : Support du protocole" 3763: " IPv6 indisponible\n"); 3764: } 3765: else 3766: { 3767: printf("+++Warning : IPv6 support " 3768: "unavailable\n"); 3769: } 3770: # endif 3771: } 3772: else 3773: { 3774: longueur_adresse = 0; 3775: recvfrom((*((struct_socket *) 3776: (*s_objet_argument_1).objet)).socket, tampon_lecture, 3777: position_finale, MSG_DONTWAIT, 3778: NULL, &longueur_adresse); 3779: } 3780: 3781: free(tampon_lecture); 3782: 3783: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3784: s_objet_resultat) == d_erreur) 3785: { 3786: return; 3787: } 3788: #endif 3789: } 3790: } 3791: else 3792: { 3793: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 3794: return; 3795: } 3796: 3797: liberation(s_etat_processus, s_objet_argument_1); 3798: 3799: return; 3800: } 3801: 3802: // vim: ts=4