Annotation of rpl/src/instructions_w1.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 4: Copyright (C) 1989-2010 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 'while'
! 29: ================================================================================
! 30: Entrées :
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_while(struct_processus *s_etat_processus)
! 40: {
! 41: (*s_etat_processus).erreur_execution = d_ex;
! 42:
! 43: if ((*s_etat_processus).affichage_arguments == 'Y')
! 44: {
! 45: printf("\n WHILE ");
! 46:
! 47: if ((*s_etat_processus).langue == 'F')
! 48: {
! 49: printf("(structure de contrôle)\n\n");
! 50: printf(" Utilisation :\n\n");
! 51: }
! 52: else
! 53: {
! 54: printf("(control statement)\n\n");
! 55: printf(" Usage:\n\n");
! 56: }
! 57:
! 58: printf(" WHILE\n");
! 59: printf(" (clause)\n");
! 60: printf(" REPEAT\n");
! 61: printf(" (expression 1)\n");
! 62: printf(" EXIT\n");
! 63: printf(" (expression 2)\n");
! 64: printf(" END\n\n");
! 65:
! 66: printf(" WHILE\n");
! 67: printf(" (clause)\n");
! 68: printf(" REPEAT\n");
! 69: printf(" (expression)\n");
! 70: printf(" END\n");
! 71:
! 72: return;
! 73: }
! 74: else if ((*s_etat_processus).test_instruction == 'Y')
! 75: {
! 76: (*s_etat_processus).nombre_arguments = -1;
! 77: return;
! 78: }
! 79:
! 80: empilement_pile_systeme(s_etat_processus);
! 81:
! 82: if ((*s_etat_processus).erreur_systeme != d_es)
! 83: {
! 84: return;
! 85: }
! 86:
! 87: (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'W';
! 88: (*(*s_etat_processus).l_base_pile_systeme).clause = 'W';
! 89:
! 90: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 91: {
! 92: (*(*s_etat_processus).l_base_pile_systeme).adresse_retour =
! 93: (*s_etat_processus).position_courante;
! 94: }
! 95: else
! 96: {
! 97: if ((*s_etat_processus).expression_courante == NULL)
! 98: {
! 99: (*s_etat_processus).erreur_execution =
! 100: d_ex_erreur_traitement_boucle;
! 101: return;
! 102: }
! 103:
! 104: (*(*s_etat_processus).l_base_pile_systeme).pointeur_objet_retour =
! 105: (*s_etat_processus).expression_courante;
! 106: }
! 107:
! 108: return;
! 109: }
! 110:
! 111:
! 112: /*
! 113: ================================================================================
! 114: Fonction 'warranty'
! 115: ================================================================================
! 116: Entrées :
! 117: --------------------------------------------------------------------------------
! 118: Sorties :
! 119: --------------------------------------------------------------------------------
! 120: Effets de bord : néant
! 121: ================================================================================
! 122: */
! 123:
! 124: void
! 125: instruction_warranty(struct_processus *s_etat_processus)
! 126: {
! 127: # include "garanties.conv.h"
! 128:
! 129: (*s_etat_processus).erreur_execution = d_ex;
! 130:
! 131: if ((*s_etat_processus).affichage_arguments == 'Y')
! 132: {
! 133: printf("\n WARRANTY ");
! 134:
! 135: if ((*s_etat_processus).langue == 'F')
! 136: {
! 137: printf("(garantie)\n\n");
! 138: printf(" Aucun argument\n");
! 139: }
! 140: else
! 141: {
! 142: printf("(warranty)\n\n");
! 143: printf(" No argument\n");
! 144: }
! 145:
! 146: return;
! 147: }
! 148: else if ((*s_etat_processus).test_instruction == 'Y')
! 149: {
! 150: (*s_etat_processus).nombre_arguments = -1;
! 151: return;
! 152: }
! 153:
! 154: printf("%s\n", warranty);
! 155:
! 156: if ((*s_etat_processus).hauteur_pile_operationnelle == 0)
! 157: {
! 158: printf("\n");
! 159: }
! 160:
! 161: return;
! 162: }
! 163:
! 164:
! 165: /*
! 166: ================================================================================
! 167: Fonction 'wait'
! 168: ================================================================================
! 169: Entrées :
! 170: --------------------------------------------------------------------------------
! 171: Sorties :
! 172: --------------------------------------------------------------------------------
! 173: Effets de bord : néant
! 174: ================================================================================
! 175: */
! 176:
! 177: void
! 178: instruction_wait(struct_processus *s_etat_processus)
! 179: {
! 180: int code_retour;
! 181: int erreur;
! 182:
! 183: real8 attente;
! 184:
! 185: struct_objet *s_objet;
! 186:
! 187: struct timespec temporisation;
! 188:
! 189: (*s_etat_processus).erreur_execution = d_ex;
! 190:
! 191: if ((*s_etat_processus).affichage_arguments == 'Y')
! 192: {
! 193: printf("\n WAIT ");
! 194:
! 195: if ((*s_etat_processus).langue == 'F')
! 196: {
! 197: printf("(attente exprimée en secondes)\n\n");
! 198: }
! 199: else
! 200: {
! 201: printf("(wait a number of seconds)\n\n");
! 202: }
! 203:
! 204: printf(" 1: %s, %s\n", d_INT, d_REL);
! 205:
! 206: return;
! 207: }
! 208: else if ((*s_etat_processus).test_instruction == 'Y')
! 209: {
! 210: (*s_etat_processus).nombre_arguments = -1;
! 211: return;
! 212: }
! 213:
! 214: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 215: {
! 216: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 217: {
! 218: return;
! 219: }
! 220: }
! 221:
! 222: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 223: &s_objet) == d_erreur)
! 224: {
! 225: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 226: return;
! 227: }
! 228:
! 229: if (((*s_objet).type == INT) ||
! 230: ((*s_objet).type == REL))
! 231: {
! 232: if ((*s_objet).type == INT)
! 233: {
! 234: attente = (real8) (*((integer8 *) (*s_objet).objet));
! 235: }
! 236: else
! 237: {
! 238: attente = (*((real8 *) (*s_objet).objet));
! 239: }
! 240:
! 241: if (attente < 0)
! 242: {
! 243: liberation(s_etat_processus, s_objet);
! 244:
! 245: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 246: return;
! 247: }
! 248:
! 249: temporisation.tv_sec = (long) floor((double) attente);
! 250: temporisation.tv_nsec = (attente - temporisation.tv_sec) *
! 251: (long) 1000000000;
! 252:
! 253: if ((*s_etat_processus).profilage == d_vrai)
! 254: {
! 255: profilage(s_etat_processus, "Sleep function (WAIT)");
! 256:
! 257: if ((*s_etat_processus).erreur_systeme != d_es)
! 258: {
! 259: return;
! 260: }
! 261: }
! 262:
! 263: do
! 264: {
! 265: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 266: {
! 267: (*s_etat_processus).erreur_systeme = d_es_processus;
! 268: return;
! 269: }
! 270:
! 271: code_retour = nanosleep(&temporisation, &temporisation);
! 272: erreur = errno;
! 273:
! 274: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 275: {
! 276: if (errno != EINTR)
! 277: {
! 278: (*s_etat_processus).erreur_systeme = d_es_processus;
! 279: return;
! 280: }
! 281: }
! 282:
! 283: scrutation_injection(s_etat_processus);
! 284:
! 285: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
! 286: {
! 287: affectation_interruptions_logicielles(s_etat_processus);
! 288: }
! 289:
! 290: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
! 291: {
! 292: traitement_interruptions_logicielles(s_etat_processus);
! 293: }
! 294: } while(((code_retour == -1) && (erreur == EINTR))
! 295: && ((*s_etat_processus).var_volatile_requete_arret == 0));
! 296:
! 297: if ((*s_etat_processus).profilage == d_vrai)
! 298: {
! 299: profilage(s_etat_processus, NULL);
! 300: }
! 301: }
! 302: else
! 303: {
! 304: liberation(s_etat_processus, s_objet);
! 305:
! 306: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 307: return;
! 308: }
! 309:
! 310: liberation(s_etat_processus, s_objet);
! 311:
! 312: return;
! 313: }
! 314:
! 315:
! 316: /*
! 317: ================================================================================
! 318: Fonction 'wireframe' (passe en mode d'affichage échantillonné)
! 319: ================================================================================
! 320: Entrées : structure processus
! 321: --------------------------------------------------------------------------------
! 322: Sorties :
! 323: --------------------------------------------------------------------------------
! 324: Effets de bord : néant
! 325: ================================================================================
! 326: */
! 327:
! 328: void
! 329: instruction_wireframe(struct_processus *s_etat_processus)
! 330: {
! 331: (*s_etat_processus).erreur_execution = d_ex;
! 332:
! 333: if ((*s_etat_processus).affichage_arguments == 'Y')
! 334: {
! 335: printf("\n WIREFRAME ");
! 336:
! 337: if ((*s_etat_processus).langue == 'F')
! 338: {
! 339: printf("(graphique tridimensionnel grillagé)\n\n");
! 340: printf(" Aucun argument\n");
! 341: }
! 342: else
! 343: {
! 344: printf("(wireframe 3D graph)\n\n");
! 345: printf(" No argument\n");
! 346: }
! 347:
! 348: return;
! 349: }
! 350: else if ((*s_etat_processus).test_instruction == 'Y')
! 351: {
! 352: (*s_etat_processus).nombre_arguments = -1;
! 353: return;
! 354: }
! 355:
! 356: strcpy((*s_etat_processus).type_trace_eq, "GRILLE 3D");
! 357:
! 358: return;
! 359: }
! 360:
! 361:
! 362: /*
! 363: ================================================================================
! 364: Fonction 'write'
! 365: ================================================================================
! 366: Entrées : structure processus
! 367: --------------------------------------------------------------------------------
! 368: Sorties :
! 369: --------------------------------------------------------------------------------
! 370: Effets de bord : néant
! 371: ================================================================================
! 372: */
! 373:
! 374: void
! 375: instruction_write(struct_processus *s_etat_processus)
! 376: {
! 377: file *descripteur;
! 378:
! 379: int adresse[16];
! 380: int port;
! 381:
! 382: long longueur_effective;
! 383: long recursivite;
! 384:
! 385: ssize_t ios;
! 386:
! 387: struct_objet *s_objet_argument_2;
! 388: struct_objet *s_objet_argument_1;
! 389:
! 390: struct sigaction action;
! 391: struct sigaction registre;
! 392:
! 393: struct sockaddr_in adresse_ipv4;
! 394: struct sockaddr_in6 adresse_ipv6;
! 395: struct sockaddr_un adresse_unix;
! 396:
! 397: struct flock lock;
! 398:
! 399: uint32_t calcul_adresse;
! 400:
! 401: unsigned char *chaine;
! 402:
! 403: unsigned long i;
! 404:
! 405: (*s_etat_processus).erreur_execution = d_ex;
! 406:
! 407: if ((*s_etat_processus).affichage_arguments == 'Y')
! 408: {
! 409: printf("\n WRITE ");
! 410:
! 411: if ((*s_etat_processus).langue == 'F')
! 412: {
! 413: printf("(écriture d'un enregistrement d'un fichier)\n\n");
! 414: }
! 415: else
! 416: {
! 417: printf("(write a record of a file)\n\n");
! 418: }
! 419:
! 420: printf(" 2: %s\n", d_LST);
! 421: printf(" 1: %s, %s\n", d_FCH, d_SCK);
! 422:
! 423: return;
! 424: }
! 425: else if ((*s_etat_processus).test_instruction == 'Y')
! 426: {
! 427: (*s_etat_processus).nombre_arguments = -1;
! 428: return;
! 429: }
! 430:
! 431: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 432: {
! 433: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 434: {
! 435: return;
! 436: }
! 437: }
! 438:
! 439: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 440: &s_objet_argument_1) == d_erreur)
! 441: {
! 442: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 443: return;
! 444: }
! 445:
! 446: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 447: &s_objet_argument_2) == d_erreur)
! 448: {
! 449: liberation(s_etat_processus, s_objet_argument_1);
! 450:
! 451: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 452: return;
! 453: }
! 454:
! 455: if (((*s_objet_argument_2).type == LST) &&
! 456: ((*s_objet_argument_1).type == FCH))
! 457: {
! 458: /*
! 459: * Vérification des verrous
! 460: */
! 461:
! 462: lock.l_type = F_WRLCK;
! 463: lock.l_whence = SEEK_SET;
! 464: lock.l_start = 0;
! 465: lock.l_len = 0;
! 466: lock.l_pid = getpid();
! 467: recursivite = 0;
! 468:
! 469: if ((descripteur = descripteur_fichier(s_etat_processus,
! 470: (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
! 471: {
! 472: return;
! 473: }
! 474:
! 475: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
! 476: {
! 477: liberation(s_etat_processus, s_objet_argument_2);
! 478: liberation(s_etat_processus, s_objet_argument_1);
! 479:
! 480: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 481: return;
! 482: }
! 483:
! 484: if (lock.l_type != F_UNLCK)
! 485: {
! 486: liberation(s_etat_processus, s_objet_argument_2);
! 487: liberation(s_etat_processus, s_objet_argument_1);
! 488:
! 489: (*s_etat_processus).erreur_execution =
! 490: d_ex_fichier_verrouille;
! 491: return;
! 492: }
! 493:
! 494: /*
! 495: * Vérification de l'autorisation d'écriture
! 496: */
! 497:
! 498: if ((*((struct_fichier *) (*s_objet_argument_1).objet))
! 499: .protection == 'R')
! 500: {
! 501: liberation(s_etat_processus, s_objet_argument_2);
! 502: liberation(s_etat_processus, s_objet_argument_1);
! 503:
! 504: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
! 505: return;
! 506: }
! 507:
! 508: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
! 509: {
! 510: /*
! 511: * Fichiers formatés
! 512: */
! 513:
! 514: if ((chaine = formateur_fichier(s_etat_processus,
! 515: s_objet_argument_2, (*((struct_fichier *)
! 516: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
! 517: &longueur_effective, &recursivite)) == NULL)
! 518: {
! 519: liberation(s_etat_processus, s_objet_argument_2);
! 520: liberation(s_etat_processus, s_objet_argument_1);
! 521:
! 522: return;
! 523: }
! 524:
! 525: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
! 526: == 'S')
! 527: {
! 528: if (fseek(descripteur, (long) 0, SEEK_END) != 0)
! 529: {
! 530: liberation(s_etat_processus, s_objet_argument_2);
! 531: liberation(s_etat_processus, s_objet_argument_1);
! 532:
! 533: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 534: return;
! 535: }
! 536:
! 537: if (fprintf(descripteur, "%s\n", chaine) < 0)
! 538: {
! 539: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 540: return;
! 541: }
! 542: }
! 543: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
! 544: == 'D')
! 545: {
! 546: }
! 547: else
! 548: {
! 549: /* Fichiers indexés : panique totale ! */
! 550: }
! 551:
! 552: free(chaine);
! 553: }
! 554: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
! 555: == 'Y')
! 556: {
! 557: /*
! 558: * Fichiers non formatés
! 559: */
! 560:
! 561: if ((chaine = formateur_fichier(s_etat_processus,
! 562: s_objet_argument_2, (*((struct_fichier *)
! 563: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
! 564: &longueur_effective, &recursivite)) == NULL)
! 565: {
! 566: liberation(s_etat_processus, s_objet_argument_2);
! 567: liberation(s_etat_processus, s_objet_argument_1);
! 568:
! 569: return;
! 570: }
! 571:
! 572: if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
! 573: == 'S')
! 574: {
! 575: if (fseek(descripteur, (long) 0, SEEK_END) != 0)
! 576: {
! 577: liberation(s_etat_processus, s_objet_argument_2);
! 578: liberation(s_etat_processus, s_objet_argument_1);
! 579:
! 580: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 581: return;
! 582: }
! 583:
! 584: if (fwrite(chaine, sizeof(unsigned char), longueur_effective,
! 585: descripteur) != (size_t) longueur_effective)
! 586: {
! 587: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 588: return;
! 589: }
! 590: }
! 591: else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
! 592: == 'D')
! 593: {
! 594: }
! 595: else
! 596: {
! 597: /* Fichiers indexés : panique totale ! */
! 598: }
! 599:
! 600: free(chaine);
! 601: }
! 602: else
! 603: {
! 604: /*
! 605: * Fichiers de type FLOW
! 606: */
! 607: }
! 608: }
! 609: else if (((*s_objet_argument_2).type == LST) &&
! 610: ((*s_objet_argument_1).type == SCK))
! 611: {
! 612: /*
! 613: * Vérification de l'autorisation d'écriture
! 614: */
! 615:
! 616: if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 617: .protection == 'R')
! 618: {
! 619: liberation(s_etat_processus, s_objet_argument_2);
! 620: liberation(s_etat_processus, s_objet_argument_1);
! 621:
! 622: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
! 623: return;
! 624: }
! 625:
! 626: if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
! 627: {
! 628: /*
! 629: * Sockets formatées
! 630: */
! 631:
! 632: if ((chaine = formateur_fichier(s_etat_processus,
! 633: s_objet_argument_2, (*((struct_socket *)
! 634: (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
! 635: &longueur_effective, &recursivite)) == NULL)
! 636: {
! 637: liberation(s_etat_processus, s_objet_argument_2);
! 638: liberation(s_etat_processus, s_objet_argument_1);
! 639:
! 640: return;
! 641: }
! 642:
! 643: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
! 644: "STREAM") == 0) || (strcmp((*((struct_socket *)
! 645: (*s_objet_argument_1).objet)).type,
! 646: "SEQUENTIAL DATAGRAM") == 0))
! 647: { // Sockets connectées
! 648:
! 649: action.sa_handler = SIG_IGN;
! 650: action.sa_flags = SA_ONSTACK;
! 651:
! 652: if (sigaction(SIGPIPE, &action, ®istre) != 0)
! 653: {
! 654: (*s_etat_processus).erreur_systeme = d_es_signal;
! 655: return;
! 656: }
! 657:
! 658: if (sem_post(&((*s_etat_processus).semaphore_fork))
! 659: != 0)
! 660: {
! 661: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
! 662: {
! 663: (*s_etat_processus).erreur_systeme = d_es_signal;
! 664: return;
! 665: }
! 666:
! 667: (*s_etat_processus).erreur_systeme = d_es_processus;
! 668: return;
! 669: }
! 670:
! 671: if (send((*((struct_socket *) (*s_objet_argument_1).objet))
! 672: .socket, chaine, strlen(chaine), 0) < 0)
! 673: {
! 674: ios = errno;
! 675:
! 676: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
! 677: {
! 678: (*s_etat_processus).erreur_systeme = d_es_signal;
! 679: return;
! 680: }
! 681:
! 682: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 683: {
! 684: if (errno != EINTR)
! 685: {
! 686: (*s_etat_processus).erreur_systeme = d_es_processus;
! 687: return;
! 688: }
! 689: }
! 690:
! 691: if (ios == EPIPE)
! 692: {
! 693: (*s_etat_processus).erreur_execution =
! 694: d_ex_erreur_acces_fichier;
! 695: return;
! 696: }
! 697:
! 698: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 699: return;
! 700: }
! 701:
! 702: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 703: {
! 704: if (errno != EINTR)
! 705: {
! 706: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
! 707: {
! 708: (*s_etat_processus).erreur_systeme = d_es_signal;
! 709: return;
! 710: }
! 711:
! 712: (*s_etat_processus).erreur_systeme = d_es_processus;
! 713: return;
! 714: }
! 715: }
! 716:
! 717: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
! 718: {
! 719: (*s_etat_processus).erreur_systeme = d_es_signal;
! 720: return;
! 721: }
! 722: }
! 723: else
! 724: { // Sockets non connectées
! 725:
! 726: /*
! 727: * Vérification de l'adresse distante
! 728: */
! 729:
! 730: if (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
! 731: .adresse_distante, "") == 0)
! 732: {
! 733: liberation(s_etat_processus, s_objet_argument_1);
! 734: liberation(s_etat_processus, s_objet_argument_2);
! 735:
! 736: (*s_etat_processus).erreur_execution =
! 737: d_ex_erreur_acces_fichier;
! 738: return;
! 739: }
! 740:
! 741: /*
! 742: * Création de l'adresse logique
! 743: */
! 744:
! 745: if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 746: .domaine == PF_UNIX)
! 747: {
! 748: adresse_unix.sun_family = AF_UNIX;
! 749: strncpy(adresse_unix.sun_path, (*((struct_socket *)
! 750: (*s_objet_argument_1).objet)).adresse_distante,
! 751: 108);
! 752: adresse_unix.sun_path[108 - 1] = d_code_fin_chaine;
! 753:
! 754: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 755: {
! 756: (*s_etat_processus).erreur_systeme = d_es_processus;
! 757: return;
! 758: }
! 759:
! 760: if (sendto((*((struct_socket *)
! 761: (*s_objet_argument_1).objet)).socket, chaine,
! 762: strlen(chaine), 0, (struct sockaddr *)
! 763: &adresse_unix, sizeof(adresse_unix)) < 0)
! 764: {
! 765: while(sem_wait(&((*s_etat_processus)
! 766: .semaphore_fork)) == -1)
! 767: {
! 768: if (errno != EINTR)
! 769: {
! 770: (*s_etat_processus).erreur_systeme =
! 771: d_es_processus;
! 772: return;
! 773: }
! 774: }
! 775:
! 776: (*s_etat_processus).erreur_systeme =
! 777: d_es_erreur_fichier;
! 778: return;
! 779: }
! 780:
! 781: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 782: {
! 783: if (errno != EINTR)
! 784: {
! 785: (*s_etat_processus).erreur_systeme = d_es_processus;
! 786: return;
! 787: }
! 788: }
! 789: }
! 790: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 791: .domaine == PF_INET)
! 792: {
! 793: if (sscanf((*((struct_socket *)
! 794: (*s_objet_argument_1).objet))
! 795: .adresse_distante, "%d.%d.%d.%d(%d)",
! 796: &(adresse[0]), &(adresse[1]), &(adresse[2]),
! 797: &(adresse[3]), &port) == 5)
! 798: { // Adresse IPv4
! 799: calcul_adresse = 0;
! 800: for(i = 0; i < 4; calcul_adresse =
! 801: (256 * calcul_adresse) + adresse[i++]);
! 802:
! 803: memset(&adresse_ipv4, 0, sizeof(adresse_ipv4));
! 804: adresse_ipv4.sin_family = AF_INET;
! 805: adresse_ipv4.sin_port = htons(port);
! 806: adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
! 807:
! 808: if (sem_post(&((*s_etat_processus)
! 809: .semaphore_fork)) != 0)
! 810: {
! 811: (*s_etat_processus).erreur_systeme = d_es_processus;
! 812: return;
! 813: }
! 814:
! 815: if (sendto((*((struct_socket *)
! 816: (*s_objet_argument_1).objet)).socket, chaine,
! 817: strlen(chaine), 0, (struct sockaddr *)
! 818: &adresse_ipv4, sizeof(adresse_ipv4)) < 0)
! 819: {
! 820: while(sem_wait(&((*s_etat_processus)
! 821: .semaphore_fork)) == -1)
! 822: {
! 823: if (errno != EINTR)
! 824: {
! 825: (*s_etat_processus).erreur_systeme =
! 826: d_es_processus;
! 827: return;
! 828: }
! 829: }
! 830:
! 831: (*s_etat_processus).erreur_systeme =
! 832: d_es_erreur_fichier;
! 833: return;
! 834: }
! 835:
! 836: while(sem_wait(&((*s_etat_processus)
! 837: .semaphore_fork)) == -1)
! 838: {
! 839: if (errno != EINTR)
! 840: {
! 841: (*s_etat_processus).erreur_systeme =
! 842: d_es_processus;
! 843: return;
! 844: }
! 845: }
! 846: }
! 847: else
! 848: {
! 849: liberation(s_etat_processus, s_objet_argument_1);
! 850: liberation(s_etat_processus, s_objet_argument_2);
! 851:
! 852: (*s_etat_processus).erreur_execution =
! 853: d_ex_erreur_parametre_fichier;
! 854: return;
! 855: }
! 856: }
! 857: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 858: .domaine == PF_INET6)
! 859: {
! 860: if (sscanf((*((struct_socket *) (*s_objet_argument_1)
! 861: .objet)).adresse_distante, "%X:%X:%X:%X:%X:"
! 862: "%X:%X:%X:%X:%X:%X:%X:%X:%X:%X:%X(%d)",
! 863: &(adresse[0]), &(adresse[1]), &(adresse[2]),
! 864: &(adresse[3]), &(adresse[4]), &(adresse[5]),
! 865: &(adresse[6]), &(adresse[7]), &(adresse[8]),
! 866: &(adresse[9]), &(adresse[10]), &(adresse[11]),
! 867: &(adresse[12]), &(adresse[13]), &(adresse[14]),
! 868: &(adresse[15]), &port)== 17)
! 869: { // Adresse IPv6
! 870: memset(&adresse_ipv6, 0, sizeof(adresse_ipv6));
! 871: adresse_ipv6.sin6_family = AF_INET6;
! 872: adresse_ipv6.sin6_port = htons((uint16_t) port);
! 873:
! 874: for(i = 0; i < 16;
! 875: adresse_ipv6.sin6_addr.s6_addr[i] =
! 876: adresse[i], i++);
! 877:
! 878: if (sem_post(&((*s_etat_processus)
! 879: .semaphore_fork)) != 0)
! 880: {
! 881: (*s_etat_processus).erreur_systeme = d_es_processus;
! 882: return;
! 883: }
! 884:
! 885: if (sendto((*((struct_socket *)
! 886: (*s_objet_argument_1).objet)).socket, chaine,
! 887: strlen(chaine), 0, (struct sockaddr *)
! 888: &adresse_ipv6, sizeof(adresse_ipv6)) < 0)
! 889: {
! 890: while(sem_wait(&((*s_etat_processus)
! 891: .semaphore_fork)) == -1)
! 892: {
! 893: if (errno != EINTR)
! 894: {
! 895: (*s_etat_processus).erreur_systeme =
! 896: d_es_processus;
! 897: return;
! 898: }
! 899: }
! 900:
! 901: (*s_etat_processus).erreur_systeme =
! 902: d_es_erreur_fichier;
! 903: return;
! 904: }
! 905:
! 906: while(sem_wait(&((*s_etat_processus)
! 907: .semaphore_fork)) == -1)
! 908: {
! 909: if (errno != EINTR)
! 910: {
! 911: (*s_etat_processus).erreur_systeme =
! 912: d_es_processus;
! 913: return;
! 914: }
! 915: }
! 916: }
! 917: else
! 918: {
! 919: liberation(s_etat_processus, s_objet_argument_1);
! 920: liberation(s_etat_processus, s_objet_argument_2);
! 921:
! 922: (*s_etat_processus).erreur_execution =
! 923: d_ex_erreur_parametre_fichier;
! 924: return;
! 925: }
! 926: }
! 927: else
! 928: {
! 929: liberation(s_etat_processus, s_objet_argument_1);
! 930: liberation(s_etat_processus, s_objet_argument_2);
! 931:
! 932: (*s_etat_processus).erreur_execution =
! 933: d_ex_erreur_parametre_fichier;
! 934: return;
! 935: }
! 936: }
! 937:
! 938: free(chaine);
! 939: }
! 940: else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
! 941: == 'Y')
! 942: {
! 943: /*
! 944: * Sockets non formatées
! 945: */
! 946: }
! 947: else
! 948: {
! 949: /*
! 950: * Sockets de type FLOW
! 951: */
! 952: }
! 953: }
! 954: else
! 955: {
! 956: liberation(s_etat_processus, s_objet_argument_2);
! 957: liberation(s_etat_processus, s_objet_argument_1);
! 958:
! 959: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 960: return;
! 961: }
! 962:
! 963: liberation(s_etat_processus, s_objet_argument_2);
! 964: liberation(s_etat_processus, s_objet_argument_1);
! 965:
! 966: return;
! 967: }
! 968:
! 969:
! 970: /*
! 971: ================================================================================
! 972: Fonction 'wflock'
! 973: ================================================================================
! 974: Entrées : pointeur sur une structure struct_processus
! 975: --------------------------------------------------------------------------------
! 976: Sorties :
! 977: --------------------------------------------------------------------------------
! 978: Effets de bord : néant
! 979: ================================================================================
! 980: */
! 981:
! 982: void
! 983: instruction_wflock(struct_processus *s_etat_processus)
! 984: {
! 985: file *descripteur;
! 986:
! 987: logical1 drapeau;
! 988:
! 989: struct flock lock;
! 990:
! 991: struct timespec attente;
! 992:
! 993: struct_objet *s_objet_argument_1;
! 994: struct_objet *s_objet_argument_2;
! 995:
! 996: unsigned char *chaine;
! 997: unsigned char registre_instruction_valide;
! 998:
! 999: attente.tv_sec = 0;
! 1000: attente.tv_nsec = GRANULARITE_us * 1000;
! 1001:
! 1002: (*s_etat_processus).erreur_execution = d_ex;
! 1003:
! 1004: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1005: {
! 1006: printf("\n WFLOCK ");
! 1007:
! 1008: if ((*s_etat_processus).langue == 'F')
! 1009: {
! 1010: printf("(attente du positionnement d'un verrou sur un fichier)"
! 1011: "\n\n");
! 1012: }
! 1013: else
! 1014: {
! 1015: printf("(wait for file lock)\n\n");
! 1016: }
! 1017:
! 1018: printf(" 2: %s\n", d_FCH);
! 1019: printf(" 1: %s (READ/WRITE/NONE)\n", d_CHN);
! 1020:
! 1021: return;
! 1022: }
! 1023: else if ((*s_etat_processus).test_instruction == 'Y')
! 1024: {
! 1025: (*s_etat_processus).nombre_arguments = -1;
! 1026: return;
! 1027: }
! 1028:
! 1029: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1030: {
! 1031: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 1032: {
! 1033: return;
! 1034: }
! 1035: }
! 1036:
! 1037: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1038: &s_objet_argument_1) == d_erreur)
! 1039: {
! 1040: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1041: return;
! 1042: }
! 1043:
! 1044: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1045: &s_objet_argument_2) == d_erreur)
! 1046: {
! 1047: liberation(s_etat_processus, s_objet_argument_1);
! 1048:
! 1049: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1050: return;
! 1051: }
! 1052:
! 1053: if (((*s_objet_argument_2).type == FCH) &&
! 1054: ((*s_objet_argument_1).type == CHN))
! 1055: {
! 1056: drapeau = d_faux;
! 1057:
! 1058: do
! 1059: {
! 1060: if ((chaine = conversion_majuscule((unsigned char *)
! 1061: (*s_objet_argument_1).objet)) == NULL)
! 1062: {
! 1063: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1064: return;
! 1065: }
! 1066:
! 1067: if (strcmp(chaine, "WRITE") == 0)
! 1068: {
! 1069: lock.l_type = F_WRLCK;
! 1070: }
! 1071: else if (strcmp(chaine, "READ") == 0)
! 1072: {
! 1073: lock.l_type = F_RDLCK;
! 1074: }
! 1075: else if (strcmp(chaine, "NONE") == 0)
! 1076: {
! 1077: lock.l_type = F_UNLCK;
! 1078: }
! 1079: else
! 1080: {
! 1081: free(chaine);
! 1082:
! 1083: liberation(s_etat_processus, s_objet_argument_1);
! 1084: liberation(s_etat_processus, s_objet_argument_2);
! 1085:
! 1086: (*s_etat_processus).erreur_execution = d_ex_verrou_indefini;
! 1087: return;
! 1088: }
! 1089:
! 1090: free(chaine);
! 1091:
! 1092: lock.l_whence = SEEK_SET;
! 1093: lock.l_start = 0;
! 1094: lock.l_len = 0;
! 1095: lock.l_pid = getpid();
! 1096:
! 1097: if ((descripteur = descripteur_fichier(s_etat_processus,
! 1098: (struct_fichier *) (*s_objet_argument_2).objet)) == NULL)
! 1099: {
! 1100: return;
! 1101: }
! 1102:
! 1103: if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
! 1104: {
! 1105: liberation(s_etat_processus, s_objet_argument_1);
! 1106: liberation(s_etat_processus, s_objet_argument_2);
! 1107:
! 1108: (*s_etat_processus).erreur_execution = d_ex_fichier_verrouille;
! 1109: return;
! 1110: }
! 1111:
! 1112: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1113: {
! 1114: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1115: return;
! 1116: }
! 1117:
! 1118: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1119: {
! 1120: if (errno != EINTR)
! 1121: {
! 1122: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1123: return;
! 1124: }
! 1125: }
! 1126:
! 1127: if (lock.l_type == F_UNLCK)
! 1128: {
! 1129: drapeau = d_vrai;
! 1130: }
! 1131: else
! 1132: {
! 1133: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
! 1134: {
! 1135: affectation_interruptions_logicielles(s_etat_processus);
! 1136: }
! 1137:
! 1138: if ((*s_etat_processus).nombre_interruptions_en_queue
! 1139: != 0)
! 1140: {
! 1141: registre_instruction_valide =
! 1142: (*s_etat_processus).instruction_valide;
! 1143: traitement_interruptions_logicielles(
! 1144: s_etat_processus);
! 1145: (*s_etat_processus).instruction_valide =
! 1146: registre_instruction_valide;
! 1147: }
! 1148:
! 1149: nanosleep(&attente, NULL);
! 1150: scrutation_injection(s_etat_processus);
! 1151:
! 1152: INCR_GRANULARITE(attente.tv_nsec);
! 1153: }
! 1154: } while((drapeau == d_faux) && ((*s_etat_processus)
! 1155: .var_volatile_requete_arret != -1));
! 1156: }
! 1157: else
! 1158: {
! 1159: liberation(s_etat_processus, s_objet_argument_1);
! 1160: liberation(s_etat_processus, s_objet_argument_2);
! 1161:
! 1162: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1163: return;
! 1164: }
! 1165:
! 1166: return;
! 1167: }
! 1168:
! 1169:
! 1170: /*
! 1171: ================================================================================
! 1172: Fonction 'wfproc'
! 1173: ================================================================================
! 1174: Entrées : pointeur sur une structure struct_processus
! 1175: --------------------------------------------------------------------------------
! 1176: Sorties :
! 1177: --------------------------------------------------------------------------------
! 1178: Effets de bord : néant
! 1179: ================================================================================
! 1180: */
! 1181:
! 1182: void
! 1183: instruction_wfproc(struct_processus *s_etat_processus)
! 1184: {
! 1185: logical1 drapeau_fin;
! 1186:
! 1187: struct_liste_chainee *l_element_courant;
! 1188:
! 1189: struct_objet *s_objet_argument;
! 1190:
! 1191: struct timespec attente;
! 1192:
! 1193: unsigned char registre_instruction_valide;
! 1194:
! 1195: (*s_etat_processus).erreur_execution = d_ex;
! 1196:
! 1197: attente.tv_sec = 0;
! 1198: attente.tv_nsec = GRANULARITE_us * 1000;
! 1199:
! 1200: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1201: {
! 1202: printf("\n WFPROC ");
! 1203:
! 1204: if ((*s_etat_processus).langue == 'F')
! 1205: {
! 1206: printf("(attente de la fin d'un processus fils)\n\n");
! 1207: }
! 1208: else
! 1209: {
! 1210: printf("(wait for child process end)\n\n");
! 1211: }
! 1212:
! 1213: printf(" 1: %s\n", d_PRC);
! 1214:
! 1215: return;
! 1216: }
! 1217: else if ((*s_etat_processus).test_instruction == 'Y')
! 1218: {
! 1219: (*s_etat_processus).nombre_arguments = -1;
! 1220: return;
! 1221: }
! 1222:
! 1223: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1224: {
! 1225: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1226: {
! 1227: return;
! 1228: }
! 1229: }
! 1230:
! 1231: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1232: &s_objet_argument) == d_erreur)
! 1233: {
! 1234: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1235: return;
! 1236: }
! 1237:
! 1238: if ((*s_objet_argument).type == PRC)
! 1239: {
! 1240: drapeau_fin = d_faux;
! 1241:
! 1242: if ((*s_etat_processus).profilage == d_vrai)
! 1243: {
! 1244: profilage(s_etat_processus, "Interprocess or interthread "
! 1245: "communications (WFPROC)");
! 1246:
! 1247: if ((*s_etat_processus).erreur_systeme != d_es)
! 1248: {
! 1249: return;
! 1250: }
! 1251: }
! 1252:
! 1253: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
! 1254: {
! 1255: if ((*s_etat_processus).profilage == d_vrai)
! 1256: {
! 1257: profilage(s_etat_processus, NULL);
! 1258: }
! 1259:
! 1260: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1261: return;
! 1262: }
! 1263:
! 1264: while(drapeau_fin == d_faux)
! 1265: {
! 1266: l_element_courant = (struct_liste_chainee *)
! 1267: (*s_etat_processus).l_base_pile_processus;
! 1268:
! 1269: while(l_element_courant != NULL)
! 1270: {
! 1271: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
! 1272: .donnee).objet)).thread).processus_detache == d_vrai)
! 1273: {
! 1274: if ((*(*((struct_processus_fils *)
! 1275: (*s_objet_argument).objet)).thread)
! 1276: .processus_detache == d_vrai)
! 1277: {
! 1278: if ((*(*((struct_processus_fils *)
! 1279: (*(*l_element_courant)
! 1280: .donnee).objet)).thread).pid ==
! 1281: (*(*((struct_processus_fils *)
! 1282: (*s_objet_argument).objet)).thread).pid)
! 1283: {
! 1284: break;
! 1285: }
! 1286: }
! 1287: }
! 1288: else
! 1289: {
! 1290: if ((*(*((struct_processus_fils *)
! 1291: (*s_objet_argument).objet)).thread)
! 1292: .processus_detache == d_faux)
! 1293: {
! 1294: if ((pthread_equal((*(*((struct_processus_fils *)
! 1295: (*(*l_element_courant).donnee).objet)).thread)
! 1296: .tid, (*(*((struct_processus_fils *)
! 1297: (*s_objet_argument).objet)).thread).tid) != 0)
! 1298: && ((*(*((struct_processus_fils *)
! 1299: (*(*l_element_courant).donnee).objet)).thread)
! 1300: .pid == (*(*((struct_processus_fils *)
! 1301: (*s_objet_argument).objet)).thread).pid))
! 1302: {
! 1303: break;
! 1304: }
! 1305: }
! 1306: }
! 1307:
! 1308: l_element_courant = (*l_element_courant).suivant;
! 1309: }
! 1310:
! 1311: if ((*s_etat_processus).var_volatile_requete_arret != 0)
! 1312: {
! 1313: if ((*s_etat_processus).profilage == d_vrai)
! 1314: {
! 1315: profilage(s_etat_processus, NULL);
! 1316: }
! 1317:
! 1318: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 1319: {
! 1320: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1321: return;
! 1322: }
! 1323:
! 1324: liberation(s_etat_processus, s_objet_argument);
! 1325: return;
! 1326: }
! 1327:
! 1328: if (l_element_courant == NULL)
! 1329: {
! 1330: /*
! 1331: * Si l_element_courant vaut NULL, le processus n'existe plus.
! 1332: */
! 1333:
! 1334: drapeau_fin = d_vrai;
! 1335: }
! 1336: else
! 1337: {
! 1338: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
! 1339: .donnee).objet)).thread).processus_detache == d_vrai)
! 1340: {
! 1341: if (kill((*(*((struct_processus_fils *)
! 1342: (*(*l_element_courant).donnee).objet)).thread).pid,
! 1343: 0) != 0)
! 1344: {
! 1345: drapeau_fin = d_vrai;
! 1346: }
! 1347: else
! 1348: {
! 1349: drapeau_fin = d_faux;
! 1350: }
! 1351: }
! 1352: else
! 1353: {
! 1354: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
! 1355: (*(*l_element_courant).donnee).objet)).thread)
! 1356: .mutex)) != 0)
! 1357: {
! 1358: if ((*s_etat_processus).profilage == d_vrai)
! 1359: {
! 1360: profilage(s_etat_processus, NULL);
! 1361: }
! 1362:
! 1363: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1364: return;
! 1365: }
! 1366:
! 1367: if ((*(*((struct_processus_fils *)
! 1368: (*(*l_element_courant).donnee).objet)).thread)
! 1369: .thread_actif == d_faux)
! 1370: {
! 1371: drapeau_fin = d_vrai;
! 1372: }
! 1373: else
! 1374: {
! 1375: drapeau_fin = d_faux;
! 1376: }
! 1377:
! 1378: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
! 1379: (*(*l_element_courant).donnee).objet)).thread)
! 1380: .mutex)) != 0)
! 1381: {
! 1382: if ((*s_etat_processus).profilage == d_vrai)
! 1383: {
! 1384: profilage(s_etat_processus, NULL);
! 1385: }
! 1386:
! 1387: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1388: return;
! 1389: }
! 1390: }
! 1391:
! 1392: if (drapeau_fin == d_faux)
! 1393: {
! 1394: /*
! 1395: * Le processus n'est pas terminé
! 1396: */
! 1397:
! 1398: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 1399: {
! 1400: if ((*s_etat_processus).profilage == d_vrai)
! 1401: {
! 1402: profilage(s_etat_processus, NULL);
! 1403: }
! 1404:
! 1405: (*s_etat_processus).erreur_systeme =
! 1406: d_es_processus;
! 1407: return;
! 1408: }
! 1409:
! 1410: if ((*s_etat_processus).nombre_interruptions_non_affectees
! 1411: != 0)
! 1412: {
! 1413: affectation_interruptions_logicielles(s_etat_processus);
! 1414: }
! 1415:
! 1416: if ((*s_etat_processus).nombre_interruptions_en_queue
! 1417: != 0)
! 1418: {
! 1419: registre_instruction_valide =
! 1420: (*s_etat_processus).instruction_valide;
! 1421: traitement_interruptions_logicielles(
! 1422: s_etat_processus);
! 1423: (*s_etat_processus).instruction_valide =
! 1424: registre_instruction_valide;
! 1425: }
! 1426:
! 1427: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1428: {
! 1429: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1430: return;
! 1431: }
! 1432:
! 1433: nanosleep(&attente, NULL);
! 1434:
! 1435: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1436: {
! 1437: if (errno != EINTR)
! 1438: {
! 1439: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1440: return;
! 1441: }
! 1442: }
! 1443:
! 1444: scrutation_injection(s_etat_processus);
! 1445:
! 1446: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
! 1447: {
! 1448: if ((*s_etat_processus).profilage == d_vrai)
! 1449: {
! 1450: profilage(s_etat_processus, NULL);
! 1451: }
! 1452:
! 1453: (*s_etat_processus).erreur_systeme =
! 1454: d_es_processus;
! 1455: return;
! 1456: }
! 1457: }
! 1458: }
! 1459:
! 1460: INCR_GRANULARITE(attente.tv_nsec);
! 1461: }
! 1462:
! 1463: if ((*s_etat_processus).profilage == d_vrai)
! 1464: {
! 1465: profilage(s_etat_processus, NULL);
! 1466: }
! 1467:
! 1468: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 1469: {
! 1470: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1471: return;
! 1472: }
! 1473: }
! 1474: else
! 1475: {
! 1476: liberation(s_etat_processus, s_objet_argument);
! 1477:
! 1478: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1479: return;
! 1480: }
! 1481:
! 1482: liberation(s_etat_processus, s_objet_argument);
! 1483:
! 1484: return;
! 1485: }
! 1486:
! 1487:
! 1488: /*
! 1489: ================================================================================
! 1490: Fonction 'wfdata'
! 1491: ================================================================================
! 1492: Entrées : pointeur sur une structure struct_processus
! 1493: --------------------------------------------------------------------------------
! 1494: Sorties :
! 1495: --------------------------------------------------------------------------------
! 1496: Effets de bord : néant
! 1497: ================================================================================
! 1498: */
! 1499:
! 1500: void
! 1501: instruction_wfdata(struct_processus *s_etat_processus)
! 1502: {
! 1503: logical1 drapeau_fin;
! 1504:
! 1505: struct_liste_chainee *l_element_courant;
! 1506:
! 1507: struct_objet *s_objet_argument;
! 1508:
! 1509: struct timespec attente;
! 1510:
! 1511: unsigned char registre_instruction_valide;
! 1512:
! 1513: (*s_etat_processus).erreur_execution = d_ex;
! 1514:
! 1515: attente.tv_sec = 0;
! 1516: attente.tv_nsec = GRANULARITE_us * 1000;
! 1517:
! 1518: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1519: {
! 1520: printf("\n WFDATA ");
! 1521:
! 1522: if ((*s_etat_processus).langue == 'F')
! 1523: {
! 1524: printf("(attente de données d'un processus fils)\n\n");
! 1525: }
! 1526: else
! 1527: {
! 1528: printf("(wait for data from child process)\n\n");
! 1529: }
! 1530:
! 1531: printf(" 1: %s\n", d_PRC);
! 1532:
! 1533: return;
! 1534: }
! 1535: else if ((*s_etat_processus).test_instruction == 'Y')
! 1536: {
! 1537: (*s_etat_processus).nombre_arguments = -1;
! 1538: return;
! 1539: }
! 1540:
! 1541: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1542: {
! 1543: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1544: {
! 1545: return;
! 1546: }
! 1547: }
! 1548:
! 1549: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1550: &s_objet_argument) == d_erreur)
! 1551: {
! 1552: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1553: return;
! 1554: }
! 1555:
! 1556: if ((*s_objet_argument).type == PRC)
! 1557: {
! 1558: drapeau_fin = d_faux;
! 1559:
! 1560: if ((*s_etat_processus).profilage == d_vrai)
! 1561: {
! 1562: profilage(s_etat_processus, "Interprocess or interthread "
! 1563: "communications (WFDATA)");
! 1564:
! 1565: if ((*s_etat_processus).erreur_systeme != d_es)
! 1566: {
! 1567: return;
! 1568: }
! 1569: }
! 1570:
! 1571: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
! 1572: {
! 1573: if ((*s_etat_processus).profilage == d_vrai)
! 1574: {
! 1575: profilage(s_etat_processus, NULL);
! 1576: }
! 1577:
! 1578: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1579: return;
! 1580: }
! 1581:
! 1582: while(drapeau_fin == d_faux)
! 1583: {
! 1584: l_element_courant = (struct_liste_chainee *)
! 1585: (*s_etat_processus).l_base_pile_processus;
! 1586:
! 1587: while(l_element_courant != NULL)
! 1588: {
! 1589: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
! 1590: .donnee).objet)).thread).processus_detache == d_vrai)
! 1591: {
! 1592: if (((*(*((struct_processus_fils *) (*(*l_element_courant)
! 1593: .donnee).objet)).thread).pid ==
! 1594: (*(*((struct_processus_fils *)
! 1595: (*s_objet_argument).objet)).thread).pid)
! 1596: && ((*(*((struct_processus_fils *)
! 1597: (*s_objet_argument).objet)).thread)
! 1598: .processus_detache == d_vrai))
! 1599: {
! 1600: break;
! 1601: }
! 1602: }
! 1603: else
! 1604: {
! 1605: if ((pthread_equal((*(*((struct_processus_fils *)
! 1606: (*(*l_element_courant).donnee).objet)).thread).tid,
! 1607: (*(*((struct_processus_fils *) (*s_objet_argument)
! 1608: .objet)).thread).tid) != 0) &&
! 1609: ((*(*((struct_processus_fils *)
! 1610: (*(*l_element_courant).donnee).objet)).thread).pid
! 1611: == (*(*((struct_processus_fils *)
! 1612: (*s_objet_argument).objet)).thread).pid) &&
! 1613: ((*(*((struct_processus_fils *)
! 1614: (*s_objet_argument).objet)).thread)
! 1615: .processus_detache == d_faux))
! 1616: {
! 1617: break;
! 1618: }
! 1619: }
! 1620:
! 1621: l_element_courant = (*l_element_courant).suivant;
! 1622: }
! 1623:
! 1624: if ((*s_etat_processus).var_volatile_requete_arret != 0)
! 1625: {
! 1626: if ((*s_etat_processus).profilage == d_vrai)
! 1627: {
! 1628: profilage(s_etat_processus, NULL);
! 1629: }
! 1630:
! 1631: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 1632: {
! 1633: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1634: return;
! 1635: }
! 1636:
! 1637: liberation(s_etat_processus, s_objet_argument);
! 1638: return;
! 1639: }
! 1640:
! 1641: if (l_element_courant != NULL)
! 1642: {
! 1643: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
! 1644: (*(*l_element_courant).donnee).objet)).thread).mutex))
! 1645: != 0)
! 1646: {
! 1647: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1648: return;
! 1649: }
! 1650:
! 1651: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
! 1652: .donnee).objet)).thread).nombre_objets_dans_pipe != 0)
! 1653: {
! 1654: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
! 1655: (*(*l_element_courant).donnee).objet)).thread)
! 1656: .mutex)) != 0)
! 1657: {
! 1658: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1659: return;
! 1660: }
! 1661:
! 1662: drapeau_fin = d_vrai;
! 1663: }
! 1664: else
! 1665: {
! 1666: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
! 1667: (*(*l_element_courant).donnee).objet)).thread)
! 1668: .mutex)) != 0)
! 1669: {
! 1670: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1671: return;
! 1672: }
! 1673:
! 1674: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 1675: {
! 1676: if ((*s_etat_processus).profilage == d_vrai)
! 1677: {
! 1678: profilage(s_etat_processus, NULL);
! 1679: }
! 1680:
! 1681: (*s_etat_processus).erreur_systeme =
! 1682: d_es_processus;
! 1683: return;
! 1684: }
! 1685:
! 1686: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1687: {
! 1688: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1689: return;
! 1690: }
! 1691:
! 1692: nanosleep(&attente, NULL);
! 1693:
! 1694: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1695: {
! 1696: if (errno != EINTR)
! 1697: {
! 1698: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1699: return;
! 1700: }
! 1701: }
! 1702:
! 1703: scrutation_injection(s_etat_processus);
! 1704:
! 1705: if ((*s_etat_processus).nombre_interruptions_non_affectees
! 1706: != 0)
! 1707: {
! 1708: affectation_interruptions_logicielles(s_etat_processus);
! 1709: }
! 1710:
! 1711: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
! 1712: {
! 1713: registre_instruction_valide =
! 1714: (*s_etat_processus).instruction_valide;
! 1715: traitement_interruptions_logicielles(s_etat_processus);
! 1716: (*s_etat_processus).instruction_valide =
! 1717: registre_instruction_valide;
! 1718: }
! 1719:
! 1720: if ((*s_etat_processus).var_volatile_requete_arret != 0)
! 1721: {
! 1722: if ((*s_etat_processus).profilage == d_vrai)
! 1723: {
! 1724: profilage(s_etat_processus, NULL);
! 1725: }
! 1726:
! 1727: return;
! 1728: }
! 1729:
! 1730: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
! 1731: {
! 1732: if ((*s_etat_processus).profilage == d_vrai)
! 1733: {
! 1734: profilage(s_etat_processus, NULL);
! 1735: }
! 1736:
! 1737: (*s_etat_processus).erreur_systeme =
! 1738: d_es_processus;
! 1739: return;
! 1740: }
! 1741: }
! 1742: }
! 1743: else
! 1744: {
! 1745: drapeau_fin = d_vrai;
! 1746: (*s_etat_processus).erreur_execution = d_ex_processus;
! 1747: }
! 1748:
! 1749: INCR_GRANULARITE(attente.tv_nsec);
! 1750: }
! 1751:
! 1752: if ((*s_etat_processus).profilage == d_vrai)
! 1753: {
! 1754: profilage(s_etat_processus, NULL);
! 1755: }
! 1756:
! 1757: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 1758: {
! 1759: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1760: return;
! 1761: }
! 1762: }
! 1763: else
! 1764: {
! 1765: liberation(s_etat_processus, s_objet_argument);
! 1766:
! 1767: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1768: return;
! 1769: }
! 1770:
! 1771: liberation(s_etat_processus, s_objet_argument);
! 1772:
! 1773: return;
! 1774: }
! 1775:
! 1776:
! 1777: /*
! 1778: ================================================================================
! 1779: Fonction 'wfsock'
! 1780: ================================================================================
! 1781: Entrées : pointeur sur une structure struct_processus
! 1782: --------------------------------------------------------------------------------
! 1783: Sorties :
! 1784: --------------------------------------------------------------------------------
! 1785: Effets de bord : néant
! 1786: ================================================================================
! 1787: */
! 1788:
! 1789: void
! 1790: instruction_wfsock(struct_processus *s_etat_processus)
! 1791: {
! 1792: int erreur;
! 1793:
! 1794: logical1 drapeau;
! 1795:
! 1796: socklen_t longueur;
! 1797:
! 1798: struct_liste_chainee *l_element_courant;
! 1799:
! 1800: struct_objet *s_objet_argument;
! 1801: struct_objet *s_objet_resultat;
! 1802:
! 1803: struct sockaddr_in adresse_ipv4;
! 1804: struct sockaddr_in6 adresse_ipv6;
! 1805:
! 1806: unsigned long i;
! 1807:
! 1808: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1809: {
! 1810: printf("\n WFSOCK ");
! 1811:
! 1812: if ((*s_etat_processus).langue == 'F')
! 1813: {
! 1814: printf("(attente d'une connexion sur une socket)\n\n");
! 1815: }
! 1816: else
! 1817: {
! 1818: printf("(wait for connection on a socket)\n\n");
! 1819: }
! 1820:
! 1821: printf(" 1: %s\n", d_SCK);
! 1822: printf("-> 2: %s\n", d_SCK);
! 1823: printf(" 1: %s\n", d_SCK);
! 1824:
! 1825: return;
! 1826: }
! 1827: else if ((*s_etat_processus).test_instruction == 'Y')
! 1828: {
! 1829: (*s_etat_processus).nombre_arguments = -1;
! 1830: return;
! 1831: }
! 1832:
! 1833: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1834: {
! 1835: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1836: {
! 1837: return;
! 1838: }
! 1839: }
! 1840:
! 1841: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1842: &s_objet_argument) == d_erreur)
! 1843: {
! 1844: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1845: return;
! 1846: }
! 1847:
! 1848: if ((*s_objet_argument).type == SCK)
! 1849: {
! 1850: if ((strcmp((*((struct_socket *) (*s_objet_argument).objet)).type,
! 1851: "STREAM") != 0) && (strcmp((*((struct_socket *)
! 1852: (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") != 0))
! 1853: {
! 1854: liberation(s_etat_processus, s_objet_argument);
! 1855:
! 1856: (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
! 1857: return;
! 1858: }
! 1859:
! 1860: if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument,
! 1861: 'O')) == NULL)
! 1862: {
! 1863: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1864: return;
! 1865: }
! 1866:
! 1867: (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute = 'N';
! 1868: (*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';
! 1869:
! 1870: if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine == PF_INET)
! 1871: {
! 1872: longueur = sizeof(adresse_ipv4);
! 1873:
! 1874: do
! 1875: {
! 1876: drapeau = d_vrai;
! 1877:
! 1878: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1879: {
! 1880: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1881: return;
! 1882: }
! 1883:
! 1884: if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
! 1885: accept((*((struct_socket *) (*s_objet_argument).objet))
! 1886: .socket, (struct sockaddr *) &adresse_ipv4, &longueur))
! 1887: < 0)
! 1888: {
! 1889: erreur = errno;
! 1890:
! 1891: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1892: {
! 1893: if (errno != EINTR)
! 1894: {
! 1895: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1896: return;
! 1897: }
! 1898: }
! 1899:
! 1900: if (erreur != EINTR)
! 1901: {
! 1902: liberation(s_etat_processus, s_objet_argument);
! 1903: liberation(s_etat_processus, s_objet_resultat);
! 1904:
! 1905: (*s_etat_processus).erreur_execution =
! 1906: d_ex_erreur_acces_fichier;
! 1907: return;
! 1908: }
! 1909:
! 1910: scrutation_injection(s_etat_processus);
! 1911:
! 1912: if ((*s_etat_processus).var_volatile_requete_arret != 0)
! 1913: {
! 1914: drapeau = d_vrai;
! 1915: }
! 1916: else
! 1917: {
! 1918: drapeau = d_faux;
! 1919: }
! 1920: }
! 1921: else
! 1922: {
! 1923: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1924: {
! 1925: if (errno != EINTR)
! 1926: {
! 1927: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1928: return;
! 1929: }
! 1930: }
! 1931: }
! 1932: } while(drapeau == d_faux);
! 1933:
! 1934: if (((*((struct_socket *) (*s_objet_resultat).objet))
! 1935: .adresse_distante = malloc(22 *
! 1936: sizeof(unsigned char))) == NULL)
! 1937: {
! 1938: (*s_etat_processus).erreur_systeme =
! 1939: d_es_allocation_memoire;
! 1940: return;
! 1941: }
! 1942:
! 1943: sprintf((*((struct_socket *) (*s_objet_resultat).objet))
! 1944: .adresse_distante, "%d.%d.%d.%d(%d)",
! 1945: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF,
! 1946: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF,
! 1947: (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF,
! 1948: ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF,
! 1949: ntohs(adresse_ipv4.sin_port));
! 1950: }
! 1951: else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
! 1952: PF_INET6)
! 1953: {
! 1954: longueur = sizeof(adresse_ipv6);
! 1955:
! 1956: do
! 1957: {
! 1958: drapeau = d_vrai;
! 1959:
! 1960: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1961: {
! 1962: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1963: return;
! 1964: }
! 1965:
! 1966: if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
! 1967: accept((*((struct_socket *) (*s_objet_argument).objet))
! 1968: .socket, (struct sockaddr *) &adresse_ipv6, &longueur))
! 1969: < 0)
! 1970: {
! 1971: erreur = errno;
! 1972:
! 1973: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1974: {
! 1975: if (errno != EINTR)
! 1976: {
! 1977: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1978: return;
! 1979: }
! 1980: }
! 1981:
! 1982: if (erreur != EINTR)
! 1983: {
! 1984: liberation(s_etat_processus, s_objet_argument);
! 1985: liberation(s_etat_processus, s_objet_resultat);
! 1986:
! 1987: (*s_etat_processus).erreur_execution =
! 1988: d_ex_erreur_acces_fichier;
! 1989: return;
! 1990: }
! 1991:
! 1992: scrutation_injection(s_etat_processus);
! 1993:
! 1994: if ((*s_etat_processus).var_volatile_requete_arret != 0)
! 1995: {
! 1996: drapeau = d_vrai;
! 1997: }
! 1998: else
! 1999: {
! 2000: drapeau = d_faux;
! 2001: }
! 2002: }
! 2003: else
! 2004: {
! 2005: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 2006: {
! 2007: if (errno != EINTR)
! 2008: {
! 2009: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2010: return;
! 2011: }
! 2012: }
! 2013: }
! 2014: } while(drapeau == d_faux);
! 2015:
! 2016: if (((*((struct_socket *) (*s_objet_resultat).objet))
! 2017: .adresse_distante = malloc(55 *
! 2018: sizeof(unsigned char))) == NULL)
! 2019: {
! 2020: (*s_etat_processus).erreur_systeme =
! 2021: d_es_allocation_memoire;
! 2022: return;
! 2023: }
! 2024:
! 2025: (*((struct_socket *) (*s_objet_resultat).objet))
! 2026: .adresse_distante = d_code_fin_chaine;
! 2027:
! 2028: for(i = 0; i < 16; i++)
! 2029: {
! 2030: sprintf((*((struct_socket *) (*s_objet_resultat)
! 2031: .objet)).adresse_distante, (i == 0) ? "%s%X" : "%s:%X",
! 2032: (*((struct_socket *) (*s_objet_resultat)
! 2033: .objet)).adresse_distante,
! 2034: adresse_ipv6.sin6_addr.s6_addr[i]);
! 2035: }
! 2036:
! 2037: sprintf((*((struct_socket *) (*s_objet_resultat)
! 2038: .objet)).adresse_distante, "%s(%u)",
! 2039: (*((struct_socket *) (*s_objet_resultat)
! 2040: .objet)).adresse_distante, ntohs(adresse_ipv6.sin6_port));
! 2041: }
! 2042: else
! 2043: {
! 2044: longueur = 0;
! 2045:
! 2046: do
! 2047: {
! 2048: drapeau = d_vrai;
! 2049:
! 2050: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 2051: {
! 2052: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2053: return;
! 2054: }
! 2055:
! 2056: if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
! 2057: accept((*((struct_socket *) (*s_objet_argument).objet))
! 2058: .socket, NULL, &longueur)) < 0)
! 2059: {
! 2060: erreur = errno;
! 2061:
! 2062: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 2063: {
! 2064: if (errno != EINTR)
! 2065: {
! 2066: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2067: return;
! 2068: }
! 2069: }
! 2070:
! 2071: if (erreur != EINTR)
! 2072: {
! 2073: liberation(s_etat_processus, s_objet_argument);
! 2074: liberation(s_etat_processus, s_objet_resultat);
! 2075:
! 2076: (*s_etat_processus).erreur_execution =
! 2077: d_ex_erreur_acces_fichier;
! 2078: return;
! 2079: }
! 2080:
! 2081: scrutation_injection(s_etat_processus);
! 2082:
! 2083: if ((*s_etat_processus).var_volatile_requete_arret != 0)
! 2084: {
! 2085: drapeau = d_vrai;
! 2086: }
! 2087: else
! 2088: {
! 2089: drapeau = d_faux;
! 2090: }
! 2091: }
! 2092: else
! 2093: {
! 2094: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 2095: {
! 2096: if (errno != EINTR)
! 2097: {
! 2098: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2099: return;
! 2100: }
! 2101: }
! 2102: }
! 2103: } while(drapeau == d_faux);
! 2104: }
! 2105:
! 2106: // Si accept() renvoie une erreur non récupérée, il ne peut s'agir
! 2107: // que de EINTR sachant qu'une requête d'arrêt est en court de
! 2108: // traitement.
! 2109:
! 2110: if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)
! 2111: {
! 2112: l_element_courant = (*s_etat_processus).s_sockets;
! 2113:
! 2114: if (l_element_courant == NULL)
! 2115: {
! 2116: if (((*s_etat_processus).s_sockets =
! 2117: allocation_maillon(s_etat_processus)) == NULL)
! 2118: {
! 2119: (*s_etat_processus).erreur_systeme =
! 2120: d_es_allocation_memoire;
! 2121: return;
! 2122: }
! 2123:
! 2124: (*(*s_etat_processus).s_sockets).suivant = NULL;
! 2125: l_element_courant = (*s_etat_processus).s_sockets;
! 2126: }
! 2127: else
! 2128: {
! 2129: /*
! 2130: * Ajout d'un élément à la fin de la liste chaînée
! 2131: */
! 2132:
! 2133: while((*l_element_courant).suivant != NULL)
! 2134: {
! 2135: l_element_courant = (*l_element_courant).suivant;
! 2136: }
! 2137:
! 2138: if (((*l_element_courant).suivant =
! 2139: allocation_maillon(s_etat_processus)) == NULL)
! 2140: {
! 2141: (*s_etat_processus).erreur_systeme =
! 2142: d_es_allocation_memoire;
! 2143: return;
! 2144: }
! 2145:
! 2146: l_element_courant = (*l_element_courant).suivant;
! 2147: (*l_element_courant).suivant = NULL;
! 2148: }
! 2149:
! 2150: if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
! 2151: s_objet_resultat, 'O')) == NULL)
! 2152: {
! 2153: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2154: return;
! 2155: }
! 2156: }
! 2157:
! 2158: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2159: s_objet_argument) == d_erreur)
! 2160: {
! 2161: return;
! 2162: }
! 2163:
! 2164: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2165: s_objet_resultat) == d_erreur)
! 2166: {
! 2167: return;
! 2168: }
! 2169: }
! 2170: else
! 2171: {
! 2172: liberation(s_etat_processus, s_objet_argument);
! 2173:
! 2174: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2175: return;
! 2176: }
! 2177:
! 2178: return;
! 2179: }
! 2180:
! 2181:
! 2182: /*
! 2183: ================================================================================
! 2184: Fonction 'wfswi'
! 2185: ================================================================================
! 2186: Entrées : pointeur sur une structure struct_processus
! 2187: --------------------------------------------------------------------------------
! 2188: Sorties :
! 2189: --------------------------------------------------------------------------------
! 2190: Effets de bord : néant
! 2191: ================================================================================
! 2192: */
! 2193:
! 2194: void
! 2195: instruction_wfswi(struct_processus *s_etat_processus)
! 2196: {
! 2197: integer8 interruption;
! 2198:
! 2199: logical1 drapeau_fin;
! 2200:
! 2201: struct_objet *s_objet_argument;
! 2202:
! 2203: struct timespec attente;
! 2204:
! 2205: (*s_etat_processus).erreur_execution = d_ex;
! 2206:
! 2207: attente.tv_sec = 0;
! 2208: attente.tv_nsec = GRANULARITE_us * 1000;
! 2209:
! 2210: if ((*s_etat_processus).affichage_arguments == 'Y')
! 2211: {
! 2212: printf("\n WFSWI ");
! 2213:
! 2214: if ((*s_etat_processus).langue == 'F')
! 2215: {
! 2216: printf("(attente d'une interruption)\n\n");
! 2217: }
! 2218: else
! 2219: {
! 2220: printf("(wait for interrupt)\n\n");
! 2221: }
! 2222:
! 2223: printf(" 1: %s\n", d_INT);
! 2224:
! 2225: return;
! 2226: }
! 2227: else if ((*s_etat_processus).test_instruction == 'Y')
! 2228: {
! 2229: (*s_etat_processus).nombre_arguments = -1;
! 2230: return;
! 2231: }
! 2232:
! 2233: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2234: {
! 2235: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 2236: {
! 2237: return;
! 2238: }
! 2239: }
! 2240:
! 2241: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2242: &s_objet_argument) == d_erreur)
! 2243: {
! 2244: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 2245: return;
! 2246: }
! 2247:
! 2248: if ((*s_objet_argument).type == INT)
! 2249: {
! 2250: drapeau_fin = d_faux;
! 2251:
! 2252: interruption = (*((integer8 *) (*s_objet_argument).objet));
! 2253:
! 2254: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
! 2255: {
! 2256: liberation(s_etat_processus, s_objet_argument);
! 2257:
! 2258: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
! 2259: return;
! 2260: }
! 2261:
! 2262: while(drapeau_fin == d_faux)
! 2263: {
! 2264: if ((*s_etat_processus).var_volatile_requete_arret != 0)
! 2265: {
! 2266: liberation(s_etat_processus, s_objet_argument);
! 2267: return;
! 2268: }
! 2269:
! 2270: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
! 2271: {
! 2272: affectation_interruptions_logicielles(s_etat_processus);
! 2273: }
! 2274:
! 2275: if ((*s_etat_processus).queue_interruptions[interruption - 1] > 0)
! 2276: {
! 2277: drapeau_fin = d_vrai;
! 2278: }
! 2279: else
! 2280: {
! 2281: nanosleep(&attente, NULL);
! 2282: scrutation_injection(s_etat_processus);
! 2283: INCR_GRANULARITE(attente.tv_nsec);
! 2284: }
! 2285: }
! 2286: }
! 2287: else
! 2288: {
! 2289: liberation(s_etat_processus, s_objet_argument);
! 2290:
! 2291: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2292: return;
! 2293: }
! 2294:
! 2295: liberation(s_etat_processus, s_objet_argument);
! 2296:
! 2297: return;
! 2298: }
! 2299:
! 2300:
! 2301: /*
! 2302: ================================================================================
! 2303: Fonction 'wfpoke'
! 2304: ================================================================================
! 2305: Entrées : pointeur sur une structure struct_processus
! 2306: --------------------------------------------------------------------------------
! 2307: Sorties :
! 2308: --------------------------------------------------------------------------------
! 2309: Effets de bord : néant
! 2310: ================================================================================
! 2311: */
! 2312:
! 2313: void
! 2314: instruction_wfpoke(struct_processus *s_etat_processus)
! 2315: {
! 2316: struct timespec attente;
! 2317:
! 2318: unsigned char registre_instruction_valide;
! 2319:
! 2320: (*s_etat_processus).erreur_execution = d_ex;
! 2321:
! 2322: attente.tv_sec = 0;
! 2323: attente.tv_nsec = GRANULARITE_us * 1000;
! 2324:
! 2325: if ((*s_etat_processus).affichage_arguments == 'Y')
! 2326: {
! 2327: printf("\n WFPOKE ");
! 2328:
! 2329: if ((*s_etat_processus).langue == 'F')
! 2330: {
! 2331: printf("(attente de données en provenance du processus père)\n\n");
! 2332: printf(" Aucun argument\n");
! 2333: }
! 2334: else
! 2335: {
! 2336: printf("(wait for data from parent process)\n\n");
! 2337: printf(" No argument\n");
! 2338: }
! 2339:
! 2340: return;
! 2341: }
! 2342: else if ((*s_etat_processus).test_instruction == 'Y')
! 2343: {
! 2344: (*s_etat_processus).nombre_arguments = -1;
! 2345: return;
! 2346: }
! 2347:
! 2348: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2349: {
! 2350: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 2351: {
! 2352: return;
! 2353: }
! 2354: }
! 2355:
! 2356: if ((*s_etat_processus).presence_pipes == d_faux)
! 2357: {
! 2358: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
! 2359: return;
! 2360: }
! 2361:
! 2362: if ((*s_etat_processus).nombre_objets_injectes > 0)
! 2363: {
! 2364: return;
! 2365: }
! 2366:
! 2367: if ((*s_etat_processus).profilage == d_vrai)
! 2368: {
! 2369: profilage(s_etat_processus, "Interprocess or interthread "
! 2370: "communications (WFPOKE)");
! 2371:
! 2372: if ((*s_etat_processus).erreur_systeme != d_es)
! 2373: {
! 2374: return;
! 2375: }
! 2376: }
! 2377:
! 2378: do
! 2379: {
! 2380: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 2381: {
! 2382: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2383: return;
! 2384: }
! 2385:
! 2386: nanosleep(&attente, NULL);
! 2387:
! 2388: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 2389: {
! 2390: if (errno != EINTR)
! 2391: {
! 2392: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2393: return;
! 2394: }
! 2395: }
! 2396:
! 2397: scrutation_injection(s_etat_processus);
! 2398:
! 2399: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
! 2400: {
! 2401: affectation_interruptions_logicielles(s_etat_processus);
! 2402: }
! 2403:
! 2404: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
! 2405: {
! 2406: registre_instruction_valide =
! 2407: (*s_etat_processus).instruction_valide;
! 2408: traitement_interruptions_logicielles(s_etat_processus);
! 2409: (*s_etat_processus).instruction_valide =
! 2410: registre_instruction_valide;
! 2411: }
! 2412:
! 2413: if ((*s_etat_processus).var_volatile_requete_arret != 0)
! 2414: {
! 2415: if ((*s_etat_processus).profilage == d_vrai)
! 2416: {
! 2417: profilage(s_etat_processus, NULL);
! 2418: }
! 2419:
! 2420: return;
! 2421: }
! 2422:
! 2423: INCR_GRANULARITE(attente.tv_nsec);
! 2424: } while((*s_etat_processus).nombre_objets_injectes == 0);
! 2425:
! 2426: return;
! 2427: }
! 2428:
! 2429:
! 2430: /*
! 2431: ================================================================================
! 2432: Fonction 'wfack'
! 2433: ================================================================================
! 2434: Entrées : pointeur sur une structure struct_processus
! 2435: --------------------------------------------------------------------------------
! 2436: Sorties :
! 2437: --------------------------------------------------------------------------------
! 2438: Effets de bord : néant
! 2439: ================================================================================
! 2440: */
! 2441:
! 2442: void
! 2443: instruction_wfack(struct_processus *s_etat_processus)
! 2444: {
! 2445: struct timespec attente;
! 2446:
! 2447: unsigned char registre_instruction_valide;
! 2448:
! 2449: (*s_etat_processus).erreur_execution = d_ex;
! 2450:
! 2451: attente.tv_sec = 0;
! 2452: attente.tv_nsec = GRANULARITE_us * 1000;
! 2453:
! 2454: if ((*s_etat_processus).affichage_arguments == 'Y')
! 2455: {
! 2456: printf("\n WFACK ");
! 2457:
! 2458: if ((*s_etat_processus).langue == 'F')
! 2459: {
! 2460: printf("(attente des acquittements de lecture)\n\n");
! 2461: printf(" Aucun argument\n");
! 2462: }
! 2463: else
! 2464: {
! 2465: printf("(wait for reading of data acknowledgement)\n\n");
! 2466: printf(" No argument\n");
! 2467: }
! 2468:
! 2469: return;
! 2470: }
! 2471: else if ((*s_etat_processus).test_instruction == 'Y')
! 2472: {
! 2473: (*s_etat_processus).nombre_arguments = -1;
! 2474: return;
! 2475: }
! 2476:
! 2477: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2478: {
! 2479: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 2480: {
! 2481: return;
! 2482: }
! 2483: }
! 2484:
! 2485: if ((*s_etat_processus).presence_pipes == d_faux)
! 2486: {
! 2487: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
! 2488: return;
! 2489: }
! 2490:
! 2491: if ((*s_etat_processus).profilage == d_vrai)
! 2492: {
! 2493: profilage(s_etat_processus, "Interprocess or interthread communications"
! 2494: " (WFACK)");
! 2495:
! 2496: if ((*s_etat_processus).erreur_systeme != d_es)
! 2497: {
! 2498: return;
! 2499: }
! 2500: }
! 2501:
! 2502: while((*s_etat_processus).nombre_objets_envoyes_non_lus != 0)
! 2503: {
! 2504: scrutation_injection(s_etat_processus);
! 2505:
! 2506: if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
! 2507: {
! 2508: affectation_interruptions_logicielles(s_etat_processus);
! 2509: }
! 2510:
! 2511: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
! 2512: {
! 2513: registre_instruction_valide =
! 2514: (*s_etat_processus).instruction_valide;
! 2515: traitement_interruptions_logicielles(s_etat_processus);
! 2516: (*s_etat_processus).instruction_valide =
! 2517: registre_instruction_valide;
! 2518: }
! 2519:
! 2520: if ((*s_etat_processus).var_volatile_requete_arret != 0)
! 2521: {
! 2522: if ((*s_etat_processus).profilage == d_vrai)
! 2523: {
! 2524: profilage(s_etat_processus, NULL);
! 2525: }
! 2526:
! 2527: return;
! 2528: }
! 2529:
! 2530: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 2531: {
! 2532: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2533: return;
! 2534: }
! 2535:
! 2536: nanosleep(&attente, NULL);
! 2537: INCR_GRANULARITE(attente.tv_nsec);
! 2538:
! 2539: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 2540: {
! 2541: if (errno != EINTR)
! 2542: {
! 2543: (*s_etat_processus).erreur_systeme = d_es_processus;
! 2544: return;
! 2545: }
! 2546: }
! 2547: }
! 2548:
! 2549: if ((*s_etat_processus).profilage == d_vrai)
! 2550: {
! 2551: profilage(s_etat_processus, NULL);
! 2552: }
! 2553:
! 2554: return;
! 2555: }
! 2556:
! 2557: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_w1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src