void attendClient(int sock) { MESSAGE msg; while(-1 != waitMessage(sock, &msg)) { switch(msg.type) { case GCD: sendAnswer(sock,gcd(msg.param1,msg.param2)); break; case LCM: sendAnswer(sock,lcm(msg.param1,msg.param2)); break; } } close(sock); }
void ESP8266::callSerialResponseMethod(uint8_t serialResponseStatus){ uint8_t lastState = state; state = STATE_IDLE; switch (lastState) { case STATE_joinAP: ProcessResponse_joinAP(serialResponseStatus); break; case STATE_createTCP: ProcessResponse_createTCP(serialResponseStatus); break; } strcpy(buffer, ""); bufferCursor = 0; Serial.print("state "); Serial.println(state); if(state == STATE_IDLE){ waitMessage(); } }
void ZLQtDialogManager::wait(const ZLResourceKey &key, ZLRunnable &runnable) const { ZLQtWaitMessage waitMessage(waitMessageText(key)); runnable.run(); }
int main(int argc, char *argv[]) { // Déclaration des variables du client int sock; // socket de connexion au serveur struct sockaddr_in chatserver; // Infos réseaux du serveur char pseudo[PSEUDOSIZE]; // Pseudonyme de l'utilisateur pthread_t listen; // Thread de réception des messages // Vérification des paramètres d'adresse IP, message et port TCP if (argc < 2) { fprintf(stderr, "\nERROR: Paramètres attendus non trouvés, merci de préciser les bons paramètres \nExemple : clientchat [IP] [PORT]\n"); //fprintf(stderr, "ERROR: \n\tAguments expected, please provide needed parameters. \n\nNAME: \n\tchat \n\nDESCRIPTION: \n\tCreate a new chat or join an existing chat. \n\nSYNOPSIS: \n\t chat [OPTION] [ARGS_LIST] \n\nOPTIONS: \n\t-s \tCreate a new chat server \n\t-r \tConnect to chat server without authentification. Only read access. \n\t-w \tConnect to chat server with authentification. Read and write access. Need a login. \n\nUSAGE: \n\t./chat -s [server_port] \n\t./chat -r [server_ip] [server_port] \n\t./chat -w [server_ip] [server_port] [login]\n"); exit(1); } // Création du socket TCP if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { Die("Impossible de créer le socket de connexion au serveur"); } // Paramètrage du socket dans une structure sockaddr_in memset(&chatserver, 0, sizeof(chatserver)); // Effacement de la structure du socket serveur chatserver.sin_family = AF_INET; // Paramètre de type Internet IP chatserver.sin_addr.s_addr = inet_addr(argv[1]); // Paramètre de l'ecoute sur toutes les interfaces chatserver.sin_port = htons(atoi(argv[2])); // Paramètre du port TCP // Tentative du connexion au serveur if (connect(sock, (struct sockaddr *) &chatserver, sizeof(chatserver)) < 0) { Die("Impossible de se connecter au serveur"); } // Capture du pseudonyme de l'utilisateur fprintf(stdout, "Choisissez un pseudonyme : \n"); fgets(pseudo, sizeof pseudo, stdin); if (pseudo[0] == 10) { // Si l'utilisateur ne choisit pas de pseudonyme (touche entrer direct) fprintf(stdout, "Authentification en mode spectateur, permission en lecture uniquement\n\n"); // Fonction de réception des messages waitMessage((void*) &sock); } else { // Si l'utilisateur a choisit un pseudonyme (écriture possible) // Création d'un thread de réception des messages if (pthread_create(&listen, NULL, waitMessage, &sock)) { Die("pthread_create"); } // Suppression des "\n" dans le pseudo (au cas où) clean(pseudo); fprintf(stdout, "Authentification en tant que : %s\n\n",pseudo); // Contenu du message à envoyer au serveur char in[BUFFSIZE]; // Message en entier contenant le pseudo et "dit : " et le contenu du message char message[BUFFSIZE+PSEUDOSIZE+sizeof(" dit: ")]; unsigned int messlen; // Taille du message // Boucle infinie pour la capture du message de utilisateur while (1) { // Effacement de la variable in memset(in,0,sizeof(in)); // Capture du message de l'utilisateur fgets(in, sizeof in, stdin); if (in[0] != 10) { // Si l'utilisateur a saisie quelque chose // Effacement de la variable message memset(message,0,sizeof(message)); // Ajout du pseudo au message complet strcat(message,pseudo); // Ajout du texte " dit : " au message complet strcat(message," dit: "); // Effacement des "\n" dans de la saisie du contenu du message clean(in); // Ajout du contenu du message au message complet strcat(message,in); // Calcul de la taille du message complet messlen = strlen(message); // Envoi du message au serveur if (send(sock, message, messlen, 0) != messlen) { Die("Impossible d'envoyer le message au serveur"); } } else { // Si l'utilisateur n'a rien saisi fprintf(stdout, "C'est absurde d'envoyer un message vide ...\n"); } } } // Fermeture du socket de connexion close(sock); // Fermeture du programme exit(0); }
void GtkDialogManager::wait(ZLRunnable &runnable, const std::string &message) const { GtkWaitMessage waitMessage(myWindow, message); runnable.run(); }
void QDialogManager::wait(ZLRunnable &runnable, const std::string &message) const { QWaitMessage waitMessage(message); runnable.run(); }
void receiveMessages () { cleanBuffers (); do { if (! atLeastOneActiveThread ()) { waitMessage (); } int src, tag; while (probeMessage (src, tag)) { receiveMessage (src, tag); initMessage (); switch (tag) { case RUNNER_STOP_TAG: unpackTerminationOfRunner (); break; case SYNCHRONIZE_REQ_TAG: unpackSynchronRequest (); break; case SYNCHRONIZED_TAG: { RUNNER_ID runner_id; unpack (runner_id); COOP_ID coop_id; unpack (coop_id); getCooperative (coop_id) -> notifySynchronized (); break; } case COOP_TAG: COOP_ID coop_id; unpack (coop_id); getCooperative (coop_id) -> unpack (); getCooperative (coop_id) -> notifyReceiving (); break; case SCHED_REQUEST_TAG: unpackResourceRequest (); break; case SCHED_RESULT_TAG: { /* Unpacking the resource */ SERVICE_ID serv_id; unpack (serv_id); Service * serv = getService (serv_id); int dest; unpack (dest); WORKER_ID worker_id; unpack (worker_id); /* Going back ... */ initMessage (); pack (worker_id); pack (serv_id); serv -> packData (); serv -> notifySendingData (); sendMessage (dest, TASK_DATA_TAG); break; } case TASK_DATA_TAG: { WORKER_ID worker_id; unpack (worker_id); Worker * worker = getWorker (worker_id); worker -> setSource (src); worker -> unpackData (); worker -> wakeUp (); break; } case TASK_RESULT_TAG: { SERVICE_ID serv_id; unpack (serv_id); Service * serv = getService (serv_id); serv -> unpackResult (); break; } case TASK_DONE_TAG: unpackTaskDone (); break; default: ; }; } } while ( ! atLeastOneActiveThread () && atLeastOneActiveRunner () /*&& ! allResourcesFree ()*/ ); }