ServeurLabyrinthe::ServeurLabyrinthe()
: m_socketServeur{ INVALID_SOCKET },
m_socketClient{ INVALID_SOCKET },
m_Carte{ 0.1, 40, 20 }
{
const long VERSION_DEMANDEE = MAKEWORD(2, 2);
WSAData configWinsock;
if (WSAStartup(VERSION_DEMANDEE, &configWinsock) != 0)
exit(erreur("Demarrage"));
}
void teste( int bits, double c1, int e1, double c2, int e2 )
{
int exact = arrondi(c1*e1+c2*e2) ;
Coef coef1(bits), coef2(bits) ;
coef1 = c1 ;
coef2 = c2 ;
int approx = coef1*e1 + coef2*e2 ;
erreur(bits,exact,approx) ;
std::cout<<std::endl ;
}
void teste( int bits, double c1, int e1, double c2, int e2 )
{
int exact = arrondi(c1*e1+c2*e2) ;
Coef coef1(bits), coef2(bits) ;
coef1.approxime(c1) ;
coef2.approxime(c2) ;
int approx = coef1.multiplie(e1) + coef2.multiplie(e2) ;
erreur(bits,exact,approx) ;
std::cout<<std::endl ;
}
void teste( double c1, int e1, double c2, int e2 )
{
c1_.approxime(c1) ;
c2_.approxime(c2) ;
int exact, approx ;
exact = arrondi(c1*e1+c2*e2) ;
approx = c1_.multiplie(e1) + c2_.multiplie(e2) ;
erreur(c1_.lit_bits(),exact,approx) ;
std::cout<<std::endl ;
}
int veriFonction(char* fonction,int nbArg,int sock){
if(strcmp(fonction,"plus")==0){
if(nbArg > 1 && nbArg < 5)
return 1;
else{
erreur(MAUVAIS_ARGUMENTS,sock);
return -1;
}
}
else if(strcmp(fonction,"moins")==0){
if(nbArg > 1 && nbArg < 5)
return 2;
else{
erreur(MAUVAIS_ARGUMENTS,sock);
return -1;
}
}
else if(strcmp(fonction,"multiplie")==0){
if(nbArg > 1 && nbArg < 5)
return 3;
else{
erreur(MAUVAIS_ARGUMENTS,sock);
return -1;
}
}
if(strcmp(fonction,"divise")==0){
if(nbArg > 1 && nbArg < 5)
return 4;
else{
erreur(MAUVAIS_ARGUMENTS,sock);
return -1;
}
}
if(strcmp(fonction,"concat")==0){
if(nbArg > 1 && nbArg < 5)
return 5;
else{
erreur(MAUVAIS_ARGUMENTS,sock);
return -1;
}
}
if(strcmp(fonction,"boucle")==0){
if(nbArg == 0)
return 6;
else{
erreur(MAUVAIS_ARGUMENTS,sock);
return -1;
}
return 6;
}
else{
erreur(FONCTION_INCONNUE,sock);
return -1;
}
}
virtual void execute( int bits )
{
Coef<U> c(bits) ;
for ( int i=0 ; i<nb_ ; ++i )
{
c = num_[i] ;
exact_[i] = num_[i] ;
approx_[i] = arrondi(c,6) ;
}
erreur(bits) ;
}
virtual void execute( int bits )
{
Coef<U> coef1(bits), coef2(bits) ;
for ( int i=0 ; i<nb_ ; ++i )
{
coef1 = num_[i] ; coef2 = (1-num_[i]) ;
exact_[i] = 200. ;
approx_[i] = arrondi(coef1*U(exact_[i]) + coef2*U(exact_[i]),3) ;
}
erreur(bits) ;
}
//--repete la saisie et le error message tant que condition = (!true)--
void acquisition(int *jnaiss, int *mnaiss, int *anaiss, int *jpred, int *mpred,
int *apred) {
do {
saisie(jnaiss, mnaiss, anaiss, jpred, mpred, apred);
erreur(controle(*jnaiss, *mnaiss, *anaiss, *jpred, *mpred, *apred));
} while (
((((*jnaiss < 0) || (*jnaiss > 31)) ||
((*mnaiss < 0) || (*mnaiss > 12))) ||
((*anaiss < 1000) || (*anaiss > 10000))) ||
((((*jpred < 0) || (*jpred > 31)) || ((*mpred < 0) || (*mpred > 12))) ||
((*apred < 1000) || (*apred > 10000))));
}
void fils(int fd){
char c;
pid_t pid=getpid();
int ret;
while((ret=read(fd,&c,sizeof(char)))>0){
printf("%d : '%c'\n",pid,c);
}
if(ret==-1){
erreur("read");
}
exit(EXIT_SUCCESS);
}
int main(int argc,char* argv[])
{
int msgid, tailleMsg;;
tMessage req, rep;
char carte[20]={'\0'};
;
tailleMsg = sizeof(tMessage) - sizeof(long);
if (argc-1 != 0) {
fprintf(stderr,"Appel %s <desc MSG>",argv[0]);
exit(1);
};
if ((msgid = msgget(cle, 0)) == -1) // creation de l'identifiant
erreur("Pb msgget dans Badge1");
while(1){
printf("Inserez votre badge : \n");
scanf("%s",carte);
sleep(1);
/* construction message req */
req.type = 1;
strcpy(req.num, carte);
req.numBadge=1;
printf("*** Message built.\n");
sleep(3);
/* ... */
/* envoi message req */
msgsnd(msgid, &req, tailleMsg, 0);
printf("*** Message sent.\n");
sleep(3);
/* ... */
/* reponse message rep */
msgrcv(msgid, &rep, tailleMsg, 2, 0);
if (rep.numBadge==1) printf("\nVehicule entre !\n");
printf("*** ACK received from COMPTEUR.\n");
sleep(10);
system("clear");
/* ... */
}
exit(0);
}
int main(int argc,char* argv[])
{
int msgid, tailleMsg;;
tMessage req, rep;
char carte[20];
;
tailleMsg = sizeof(tMessage) - sizeof(long);
if (argc-1 != 0) {
fprintf(stderr,"Appel %s <desc MSG>",argv[0]);
exit(1);
};
if ((msgid = msgget(cle, 0)) == -1)
erreur("Pb msgget dans vehicule");
while(1){
/* reception message rep */
msgrcv(msgid, &rep, tailleMsg, 2, 0); //reception compteur
/* ... */
printf("demande de central : %s\n",rep.num);
fflush(stdout);
printf("répondre : \n");
scanf("%s",carte);
sleep(3);
/* construction message req */
req.type = 1;
strcpy(req.num, carte);
req.numDesti=2;
printf("*** Message built.\n");
sleep(3);
/* ... */
/* envoi message req */
msgsnd(msgid, &req, tailleMsg, 0);
printf("*** Message sent.\n");
sleep(3);
/* ... */
}
exit(0);
}
//----------------------------------------------
// SECTION 5: END SECTION (ES)
//----------------------------------------------
bool GribV1Record::readGribSection5_ES(ZUFILE* file) {
char str[4];
if (zu_read(file, str, 4) != 4) {
ok = false;
eof = true;
return false;
}
if (strncmp(str, "7777", 4) != 0) {
erreur("Final 7777 not read: %c%c%c%c",str[0],str[1],str[2],str[3]);
ok = false;
return false;
}
return ok;
}
void
ouvrir_fichier(void)
{
int choix,nb_champs; // nb_champs est le nombre de champs convertis par fscanf
double x; // utilisé pour vérifier si les données sont au format attendu
donnees = open_r(quel_nom(),0);
if(!donnees)
{
if(!OF_abandon) // l'utilisateur n'as pas abandonné, c'est donc une erreur système
{
erreur("Une erreur système est survenue lors de l\'ouverture du ficher");
info("Désolé pour le désagrément");
info("Description système");
perror("");
}
menu();
return; // plus rien à faire ici
}
// A ce stade, le fichier est correctement ouvert
// Basic sanity test, profitons-en pour calculer le nombre de points
n = 0;
nb_champs = 2;
while(!feof(donnees) && nb_champs == 2)
{
nb_champs = fscanf(donnees,"%lf\t%lf\n", &x, &x);
n ++;
}
if(!feof(donnees)) // on n'est toujours pas à la fin du fichier, il est donc mal formatté
{
info("Le fichier ne contient pas des données au format attendu");
invite("Réessayer? (0 = non, 1 = oui):");
scanf("%d",&choix);
vider_stdin();
if(choix == 0)
menu();
else
ouvrir_fichier();
return; // plus rien a faire ici, sortir
}
// Tout est normal, on a terminé
rewind(donnees); //Comme sur le magnétophone! ce sacré Ritchie!
}
//Attends que le joueur correspondant mise
void Table::methodeMiser(){
cout<<"methodeMiser()"<<endl;
cout<<"Le prochaine à miser est: "<<prochainAMiser<<endl;
if(!actif[prochainAMiser]){
joueurMiseInactif(prochainAMiser);
aJouer=true;
}
else{
FD_ZERO(&desc_en_lect);
FD_SET(descTable,&desc_en_lect);
if(isServeur)
FD_SET(descRecu,&desc_en_lect);
cout<<"Avant le select de methodeMiser"<<endl;
for(int i=0;i<spectacteurs.size();i++){
FD_SET(spectacteurs[i]->getDesc(),&desc_en_lect);
}
cout<<"Après le select de methodeMiser"<<endl;
int sel=select(descMax+1,&desc_en_lect,NULL,NULL,NULL);
//Si erreur au select
if(sel==-1){
erreur();
}
else{
if(FD_ISSET(descTable,&desc_en_lect)){
addSpectateur();
}
else{
if(isServeur && FD_ISSET(descRecu,&desc_en_lect)){
actionServeur();
}
else{
cout<<"Action d'un spectateur"<<endl;
int parcourSpec=0;
bool sortieParcours=true;
while(sortieParcours && parcourSpec<spectacteurs.size()){
if(FD_ISSET(spectacteurs[parcourSpec]->getDesc(),&desc_en_lect)){
actionSpecJoueur(parcourSpec);
sortieParcours=false;
}
else{
parcourSpec++;
}
}
}
}
}
}
cout<<"sortie methodeMiser()"<<endl;
}
void* musician_management(void* arg)
{
//Déclarations des variables
DataSpec * data = (DataSpec *) arg; //On caste le pointeur passé en argument pour retrouver un DataSpec (au lieu d'un void*)
int arret = FALSE, nblus; //On initialise le booléen qui arrêtera la boucle
char texte[LIGNE_MAX];
//Gestion des musiciens
printf("worker %d: waiting for channel.\n", data->tid);
while(TRUE)
{
if (sem_wait(&data->sem) != 0) //Les semaphores associés aux workers sont initialisés à 0, donc bloqués par la fonction sem_wait, en l'attente d'un passage à 1 (c-à-d de l'affectation du thread)
{
erreur_pthread_IO("sem_wait");
}
data->libre = FALSE; //Une fois l'attente terminée, on marque le thread comme occupé
printf("worker %d: reading channel %d.\n", data->tid, data->canal);
arret = FALSE;
while (arret == FALSE) //Boucle d'exécution du thread
{
nblus = lireLigne (data->canal, texte); //On lit les commandes de l'utilisateur
if (nblus <= 0 || nblus == LIGNE_MAX)
{
erreur("lireLigne\n");
}
if (strcmp(texte, "/end") == 0)
{
printf("worker %d: ask for disconnection.\n", data->tid);
arret = TRUE;
continue;//On reboucle, et arret = TRUE donc on ne repasse pas par le while, on passe à la suite
}
}
if (close(data->canal) == -1) //On ferme le canal
{
erreur_IO("close");
}
data->canal = -1; //On réinitialise les paramètres
data->libre = TRUE; //On indique que le thread est dispo
if (sem_post(&sem_libres) != 0) //On marque le sémaphore
{
erreur_pthread_IO("sem_post");
}
}//En rebouclant, on attend une nouvelle connexion
pthread_exit(NULL); //On libère le thread
}
FILE *ouvrirFichier(const char *chemin, const char *mode, const char *messageErreur)
{
FILE *testFichier;
testFichier = NULL;
testFichier = fopen(chemin, mode);
if(testFichier == NULL)
{
printf("ouvrirFichier : \n");
erreur(messageErreur);
}
return testFichier;
}
int main(int argc, char **argv)
{
int fd;
time_t t;
t_data *val;
val = malloc(sizeof(t_data));
if (argc == 4)
{
val->nb_1 = ft_atoi(argv[1]);
val->nb_2 = ft_atoi(argv[2]);
val->nb_3 = ft_atoi(argv[3]);
if (argc != 4 || val->nb_2 % 2 == 0)
{
return (erreur());
}
srand((unsigned) time(&t));
fd = open("map", O_CREAT | O_RDWR, 0777);
ft_init(val);
return (generateur(fd,val));
}
return (erreur());
}
main()
{
if (pipe(tube1) == -1) erreur("pipe tube1");
if (pipe(tube2) == -1) erreur("pipe tube2");
switch (fork()) {
case -1 : erreur("fork"); break;
case 0 : {
char* arg[4]; /* fils transforme */
close(tube1[1]);
close(tube2[0]);
arg[0] = "prog4_p2";
arg[1] = (char*) malloc(3);sprintf(arg[1],"%d",tube1[0]);
arg[2] = (char*) malloc(3);sprintf(arg[2],"%d",tube2[1]);
arg[3] = NULL;
execv("prg3Aux",arg);
}
default : /* pere gere clavier */
close(tube1[0]);
close(tube2[1]);
au_boulot(tube2[0],tube1[1]);
}
}
int parametrage(FILE* file_image, int* bool_erreur)
{
int int_result;
int int_test;
int_result = 0;
sauterCommentaire(file_image);
int_test = fscanf(file_image, "%d", &int_result);
if (int_test != 1)
{
erreur(IMAGE_CORROMPUE,NO_EXIT);
*bool_erreur = 1;
}
return (int_result);
}
void ServeurLabyrinthe::envoyer(std::string msg)
{
// Note : Pas besoin de htons vu que les strings contiennent des chars de 8 bits,
// qui sont donc toujours dans le bon ordre.
msg += DELIMITEUR_FIN;
while (!msg.empty())
{
auto plus_recent = send(
m_socketClient, msg.c_str(), static_cast<int>(msg.size()), 0
);
if (est_erreur(plus_recent))
exit(erreur("Envoi"));
msg = msg.substr(plus_recent);
}
}
void my_malloc(void)
{
if(resultats)
free(resultats);
resultats = (point *) malloc(n * sizeof(point));
if(!resultats)
{
erreur("Une erreur système s\'est produite "
"lors de l\'allocation de la mémoire");
info("Vous pouvez continuer, mais la sauvegarde "
"des résultats dans un fichier peut "
"s'avérer impossible - désolé.");
pause();
}
}
void Audio::jouerMusique() throw(Audio::Exc_Son) {
if(_canalMusique) {
FMOD_BOOL pause;
FMOD_Channel_GetPaused(_canalMusique, &pause);
if(!pause)
return;
}
resultat = FMOD_System_PlaySound(_systeme, FMOD_CHANNEL_FREE, _musique, false, &_canalMusique);
erreur(resultat, 8);
int nb;
FMOD_Channel_GetIndex(_canalMusique, &nb);
_canaux[nb] = _canalMusique;
FMOD_Channel_SetVolume(_canalMusique, Parametres::volumeMusique());
}
void Audio::jouerSon(audio_t son, bool boucle) throw(Audio::Exc_Son) {
if(boucle)
FMOD_Sound_SetLoopCount(son, -1);
else
FMOD_Sound_SetLoopCount(son, 0);
FMOD_CHANNEL *c = 0;
resultat = FMOD_System_PlaySound(_systeme, FMOD_CHANNEL_FREE, son, false, &c);
erreur(resultat, 7);
int nb;
FMOD_Channel_GetIndex(c, &nb);
_canaux[nb] = c;
FMOD_Channel_SetCallback(c, &sonStoppe);
FMOD_Channel_SetVolume(c, Parametres::volumeEffets());
}
///////////////////////////////// ////////////////////////////
////////////////////////////////Methode de lancement de jeu/////////////////////////////
/////////////////////////////// /////////////////////////
void Table::run(){
cout<<"Table lancé"<<endl;
while(isServeur){
//Initialise à faux l'ensemble de lecture à surveiller et positionne à vrai les descripteurs à surveiller
FD_ZERO(&desc_en_lect);
FD_SET(descTable,&desc_en_lect);
if(isServeur)
FD_SET(descRecu,&desc_en_lect);
for(int i=0;i<spectacteurs.size();i++){
FD_SET(spectacteurs[i]->getDesc(),&desc_en_lect);
}
int sel=select(descMax+1,&desc_en_lect,NULL,NULL,NULL);
cout<<"On a reçu un paquet "<<brPub.returnPort()<<endl;
//Si erreur au select
if(sel==-1){
cout<<"Erreur au select"<<endl;
erreur();
}
else{
//si c'est un nouveau client se connectant sur la table
if(FD_ISSET(descTable,&desc_en_lect)){
cout<<"New spec"<<endl;
addSpectateur();
}
else{
if(isServeur && FD_ISSET(descRecu,&desc_en_lect)){
actionServeur();
}
else{
//Si c'est un client à l'origine de la sortie du select
int parcourSpec=0;
bool sortieParcours=true;
while(sortieParcours && parcourSpec!=nbSpec){
if(FD_ISSET(spectacteurs[parcourSpec]->getDesc(),&desc_en_lect)){
actionSpec(parcourSpec);
sortieParcours=false;
}
else{
parcourSpec++;
}
}
}
}
}
}
}
// traite le fichier ligne par ligne.
void lecture( char * nom_fichier)
{
char tab[80];
FILE * fichier = NULL;
if((fichier = fopen (nom_fichier, "r")) != NULL)
{
while(fgets(tab,80,fichier))
{
if((tab[0]=='#')||(tab[0]=='\n')||(tab[0]=='\r'))
continue; // lignes à ignorer, on passe à la suivante
decodage_ligne(tab);
}
printf("fin de la lecture\n");
}
else erreur(LECTURE_OUVERTURE);
}
std::string ServeurLabyrinthe::recevoir()
{
const int CAPACITE = 64; // arbitraire
char tampon[CAPACITE];
std::string message_recu;
bool reception_completee = false;
do
{
auto n = recv(m_socketClient, tampon, CAPACITE, 0);
if (est_erreur(n))
exit(erreur("Réception"));
message_recu.append(tampon + 0, tampon + n);
if (tampon[n - 1] == DELIMITEUR_FIN)
reception_completee = true;
} while (!reception_completee);
if (!message_recu.empty()) message_recu.pop_back(); // éliminer le délimiteur
return message_recu;
}
int main()
{
pid_t pid;
if ((pid = fork()) < 0)
erreur("Erreur lors de la creation du processus fils");
if (pid == 0)
execlp("clear","clear",NULL);
wait(NULL);
initJeu();
affJeu();
//initSDL();
//affJeuSDL();
boucle();
return 0;
}
int main(int argc, char **argv) {
FILE *fp;
struct record enreg;
char c;
short found = 0, num;
if(argc != 4) {
fprintf(stderr,"Erreur mauvais nombre d'arguments\nUsage : %s fichier [options] critere\nOptions : -c / -m",argv[0]);
exit(1);
}
if((fp = fopen(argv[1],"r")) == NULL) {
erreur(argv[1]);
exit(2);
}
c = toupper(*(*(argv+2)+1));
switch(c) {
case 'M':
fseek(fp,0,SEEK_SET);
while((fread(&enreg,sizeof(struct record),1,fp)) && (!found)) {
if(strcmp(argv[3],enreg.nom) == 0) {
found = 1;
affiche(enreg);
}
}
break;
case 'C':
num = atoi(argv[3]);
fseek(fp,0,SEEK_SET);
while((fread(&enreg,sizeof(struct record),1,fp)) && (!found)) {
if((enreg.num % 10) == num) {
found = 1;
affiche(enreg);
}
}
break;
default :
printf("Erreur");
exit(1);
}
return 0;
}
n_prog * programme(void)
{
n_l_dec *variables, *fonctions;
////affiche_balise_ouvrante__func__, TRACE_XML);
if (est_premier(_optDecVariables_, uniteCourante)
|| est_premier(_listeDecFonctions_, uniteCourante)
|| est_suivant(_programme_, uniteCourante)) {
variables=optDecVariables();
fonctions=listeDecFonctions();
goto end;
}
erreur("erreur");
end:
////affiche_balise_fermante(__func__, TRACE_XML);
return cree_n_prog(variables, fonctions);
}
//-------------------------------------------------------------------------------
// Lecture complète d'un fichier GRIB
//-------------------------------------------------------------------------------
void GribReader::openFile(const wxString fname)
{
debug("Open file: %s", (const char *)fname.mb_str());
fileName = fname;
ok = false;
clean_all_vectors();
//--------------------------------------------------------
// Open the file
//--------------------------------------------------------
file = zu_open((const char *)fname.mb_str(), "rb", ZU_COMPRESS_AUTO);
if (file == NULL) {
erreur("Can't open file: %s", (const char *)fname.mb_str());
return;
}
readGribFileContent();
// Look for compressed files with alternate extensions
if (! ok) {
if (file != NULL)
zu_close(file);
file = zu_open((const char *)fname.mb_str(), "rb", ZU_COMPRESS_BZIP);
if (file != NULL)
readGribFileContent();
}
if (! ok) {
if (file != NULL)
zu_close(file);
file = zu_open((const char *)fname.mb_str(), "rb", ZU_COMPRESS_GZIP);
if (file != NULL)
readGribFileContent();
}
if (! ok) {
if (file != NULL)
zu_close(file);
file = zu_open((const char *)fname.mb_str(), "rb", ZU_COMPRESS_NONE);
if (file != NULL)
readGribFileContent();
}
}
