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 ()*/ );
}
