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();
}
Beispiel #4
0
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();
}
Beispiel #7
0
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 ()*/ );
}