int sem_wait_reply(void *request){
char send = FALSE;
struct request_header reply;
struct sem *find;
struct req_node_info node;
node.id = ((struct sem_req*)request)->req.src_node;
node.seq_number = ((struct sem_req*)request)->req.src_seq_number;
*(char*)(request+sizeof(struct sem_req)+((struct sem_req*)request)->name_len)=0;
find = hashTableSearch(g_group.sem_table, ((struct sem_req*)request)->hash_id, (request+sizeof(struct sem_req)));
reply.seq_number = node.seq_number;
if(find == NULL){
reply.msg_type = MSG_SEM_FAILED;
sendTo(node.id, (void*)&reply, sizeof(struct request_header));
return -1;
}
pthread_mutex_lock(&find->lock);
if(find->value >0){
send=TRUE;
find->value--;
}
else
queuePush(find->queue, (void*)&node);
pthread_mutex_unlock(&find->lock);
if(send==TRUE){
reply.msg_type = MSG_SEM_OK;
sendTo(node.id, (void*)&reply, sizeof(struct request_header));
}
return 1;
}
// Fonction de gestion lors de la connexion
Joueur *connex(int sock, ListeJoueurs *liste) {
char buf[TBUF];
char *pseudo = strtok(NULL, "/");
pthread_mutex_lock(&(liste->mutex));
if(pseudo_deja_present(liste, pseudo)) {
pthread_mutex_unlock(&(liste->mutex));
printf("[Pseudo deja present] %s\n", pseudo);
return NULL;
}
pthread_mutex_unlock(&(liste->mutex));
Joueur *myJoueur = create_joueur(pseudo, sock);
addJoueurListe(liste, myJoueur);
/* Validation de la connexion a user */
sprintf(buf, "BIENVENUE/%s/\n", pseudoJoueur(myJoueur));
sendTo(buf, liste, myJoueur, 1);
///
sprintf(buf, "COMPATIBLEAFFICHAGE/\n");
sendTo(buf, liste, myJoueur, 1); // Pour dire que le serveur effectue un temps d'affichage
/* Signalement connexion user aux autres joueurs */
sprintf(buf, "CONNECTE/%s/\n", pseudoJoueur(myJoueur));
sendToAll(buf, liste, myJoueur, 1); // All sauf myJoueur
return myJoueur;
}
void header(int fd,int contentLength) {
char buffer[255]; // completely arbritray, should be enough.
sendTo(fd, "Server: Test/Testing\n");
sendTo(fd, "Content-Type: text/plain\n");
if(contentLength > 0) {
sprintf(buffer,"Content-Length: %d\n", contentLength);
sendTo(fd, buffer);
}
sendTo(fd,"\n\n");
}
__kextdll bool __cdecl ping(mod_pipe * monPipe, vector<wstring> * mesArguments)
{
bool sendOk = sendTo(monPipe, L"pong");
for(vector<wstring>::iterator monArgument = mesArguments->begin(); monArgument != mesArguments->end() && sendOk; monArgument++)
{
wstring maReponse = L" - argument:";
maReponse.append(*monArgument);
sendOk = sendTo(monPipe, maReponse);
}
if(sendOk)
sendOk = sendTo(monPipe, L"\n");
return sendOk;
}
void GroupObjectImplementation::addMember(SceneObject* newMember) {
Locker locker(_this.get());
GroupObjectDeltaMessage6* grp = new GroupObjectDeltaMessage6(_this.get());
grp->startUpdate(1);
groupMembers.add(newMember, grp);
grp->close();
broadcastMessage(grp);
if (newMember->isPlayerCreature())
{
ManagedReference<CreatureObject*> playerCreature = cast<CreatureObject*>(newMember);
sendTo(playerCreature, true);
if (hasSquadLeader()) {
addGroupModifiers(playerCreature);
}
scheduleUpdateNearestMissionForGroup(playerCreature->getPlanetCRC());
}
calcGroupLevel();
}
// Broadcast this pdu to all players in 'container'.
int CPDU::broadcast(SOCKET except_this_sd)
{
int rc = 0;
for (LoungeIterator li = CLB::Inst()->getLounges();
li.more();
li.next())
{
CLounge* lounge = li.current();
if (lounge && lounge->getSocket() != except_this_sd)
{
if (!lounge->getNetworkError())
{
rc = sendTo(lounge->getSocket());
if (rc == -1)
{
Err::Log() << "CPDU::broadcast: Lounge connection ("
<< lounge->getSocket() << ") has died.\n";
lounge->setNetworkError(true);
}
}
}
}
return rc;
};
// Broadcast this pdu to all players.
int Cpdu::broadcastToPlayers(CPlayer* except)
{
int rc = 0;
for (PlayerIterator p = CLounge::Inst()->allPlayers();
p.more();
p.next())
{
CPlayer* player = p.current();
if (player != except)
{
if (!player->getNetworkError())
{
// Testing: Don't send to 'bot_X' players
if (player->getSocket() == -1)
{
continue;
}
int rc = sendTo(player->getSocket());
if (rc == -1)
{
char s[200];
sprintf(s, "Cpdu::broadcast: Player %s connection has died.", player->getUsername());
Sys_LogError(s);
player->setNetworkError(true);
}
}
}
}
return rc;
};
int sem_post_reply(void *request){
struct sem *find;
struct req_node_info *get;
struct reply_header reply;
*(char*)(request+sizeof(struct sem_req)+((struct sem_req*)request)->name_len)=0;
find = hashTableSearch(g_group.sem_table, ((struct sem_req*)request)->hash_id, (request+sizeof(struct sem_req)));
if(find == NULL){
return -1;
}
reply.msg_type = MSG_SEM_OK;
pthread_mutex_lock(&find->lock);
find->value++; //MAX = 65535 maybe over!! need check
if(find->value >0){
get = queuePop(find->queue);
if(get!=NULL){
find->value--;
// if(get->id == g_group.coordinator.sem_id)
// sem_post(get->sem);
// else{
reply.seq_number = get->seq_number;
sendTo(get->id, (void*)&reply, sizeof(struct request_header));
// }
}
}
pthread_mutex_unlock(&find->lock);
return 1;
}
// Fonction de gestion lors de la phase de reflexion
void trouve(Session *s, Joueur *myJoueur) {
int nbCoup;
char buf[TBUF];
strtok(NULL, "/"); /* Le nom */
char *tmp = strtok(NULL, "/");
if(tmp == NULL) {
printf("[WARNING] fonction trouve reponse vide\n");
return;
}
nbCoup = atoi(tmp);
pthread_mutex_lock(&(s->mutex));
if(s->tempsReflexionFini) { // Au cas ou plrs j propose en meme temps, (et que le temps de traiter un le chrono est fini je crois
printf("Attention : temps reflexion fini, gestion_client[%d]\n", __LINE__);
// trop tard
// Je sais plus quoi mettre
}
else {
s->tempsReflexionFini = 1;
s->timerOut = 0;
myJoueur->enchere = nbCoup;
if(pthread_cancel(s->timerThread)) {
perror("pthread_cancel");
}
sprintf(buf, "ILATROUVE/%s/%d\n", pseudoJoueur(myJoueur), nbCoup);
sendToAllActif(buf, s->liste, myJoueur, 1);
sprintf(buf, "TUASTROUVE/\n");
sendTo(buf, s->liste, myJoueur, 1);
pthread_cond_signal(&(s->condFinReflexion));
}
pthread_mutex_unlock(&(s->mutex));
}
bool ActiveThread::executeWithin(const std::string &atName, std::function<void()> lambda)
{
auto msg = safeNew<LambdaMessage>();
msg->lambda = lambda;
return sendTo(atName, msg);
}
int CpduCreditCardReply::sendCards(const list<pdu_creditcard>& cards,
CPlayer* player)
{
length_ += cards.size() * sizeof(pdu_creditcard);
stuffHeader();
char* buf = value_ + PDU_HEADER_SIZE;
u_int16_t numCards = htons(cards.size());
memcpy(buf, &numCards, sizeof(numCards));
buf += sizeof(numCards);
int c = 0;
for (list<pdu_creditcard>::const_iterator i = cards.begin(),
e = cards.end();
i != e;
++i, ++c)
{
if (length_ + (c + 1) * sizeof(pdu_creditcard) >= MAXBUFFERSIZE)
{
Sys_LogError("CpduCreditCardReply: buffer size too small!\n");
break;
}
const pdu_creditcard& card = *i;
memcpy(buf, &card, sizeof(card));
buf += sizeof(card);
}
return sendTo(player->getSocket());
}
int CpduTournamentParams::sendTournamentParams(CBaseTournamentQueue* queue,
u_int16_t flag,
u_int32_t p1,
u_int32_t p2)
{
int rc = 0;
pdu_tournamentparams pdu;
memset(&pdu, 0, sizeof(pdu));
pdu.flag = htons(flag);
pdu.param1 = htonl(p1);
pdu.param2 = htonl(p2);
memcpy(value_ + PDU_HEADER_SIZE, &pdu, sizeof(pdu));
TableList& tl = queue->getTableList();
for (TableList::iterator tb = tl.begin(),
te = tl.end();
tb != te;
++tb)
{
rc = sendTo((*tb)->getSocket());
}
return rc;
}
void BuffImplementation::activate(bool applyModifiers) {
//info("activating buff with crc " + String::hexvalueOf((int)buffCRC), true);
try {
if (applyModifiers) {
applyAttributeModifiers();
applySkillModifiers();
applyStates();
}
buffEvent = new BuffDurationEvent(creature.get(), _this.get());
buffEvent->schedule((int) (buffDuration * 1000));
//nextExecutionTime = buffEvent->getNextExecutionTime();
Core::getTaskManager()->getNextExecutionTime(buffEvent, nextExecutionTime);
//info("nextExecutionTime miliDifference:" + String::valueOf(nextExecutionTime.miliDifference()), true);
if (creature.get()->isPlayerCreature())
sendTo((cast<CreatureObject*>(creature.get().get())));
if (!startMessage.isEmpty())
creature.get()->sendSystemMessage(startMessage);
if (!startFlyFile.isEmpty())
creature.get()->showFlyText(startFlyFile, startFlyAux, startFlyRed, startFlyGreen, startFlyBlue);
} catch (Exception& e) {
error(e.getMessage());
e.printStackTrace();
}
}
bool ActiveThread::executeWithin(ActiveThread *at, std::function<void()> lambda)
{
auto msg = safeNew<LambdaMessage>();
msg->lambda = lambda;
return sendTo(at, msg);
}
__kextdll bool __cdecl getCredmanFunctions(mod_pipe * monPipe, vector<wstring> * mesArguments)
{
wostringstream monStream;
monStream << L"** lsasrv.dll ** ; Statut recherche : " << (searchCredmanFuncs() ? L"OK :)" : L"KO :(") << endl << endl <<
L"@CredIEnumerate = " << CredIEnumerate << endl <<
L"@LsaUnprotectMemory = " << SeckPkgFunctionTable->LsaUnprotectMemory << endl;
return sendTo(monPipe, monStream.str());
}
__kextdll bool __cdecl getWDigestFunctions(mod_pipe * monPipe, vector<wstring> * mesArguments)
{
wostringstream monStream;
monStream << L"** wdigest.dll/lsasrv.dll ** ; Research Status : " << (searchWDigestEntryList() ? L"OK :)" : L"KO :(") << endl << endl <<
L"@l_LogSessList = " << l_LogSessList << endl <<
L"@LsaUnprotectMemory = " << SeckPkgFunctionTable->LsaUnprotectMemory << endl;
return sendTo(monPipe, monStream.str());
}
int main(int argc, char *argv[])
{
if (argc < 2) {
perror("argument less");
exit(EXIT_FAILURE);
}
initGrid(argv[1]);
int sfd;
char ip[32];
memset(ip, 0, 32);
int port = 0;
Msg msg_recv;
memset(&msg_recv, 0, sizeof(Msg));
if (atoi(argv[1]) == 1) {
sfd = initUdpServer(IP, PORT);
while (recvFrom(sfd, &msg_recv, sizeof(Msg), ip, &port) != 0) {
hebing(&msg_recv);
if (win(msg_recv)) {
printf("YOU LOSE!\n");
break;
}
move();
sendTo(sfd, &msg, sizeof(Msg), ip, port);
if (win(msg)) {
printf("YOU WIN!\n");
break;
}
}
} else {
sfd = initUdpClient();
while (move(), sendTo(sfd, &msg, sizeof(Msg), IP, PORT) != 0) {
if (win(msg)) {
printf("YOU WIN\n");
break;
}
recvFrom(sfd, &msg_recv, sizeof(Msg), ip, &port);
hebing(&msg_recv);
if (win(msg_recv)) {
printf("YOU LOSE!\n");
break;
}
}
}
close(sfd);
return 0;
}
int Socket::sendTo(const uint8_t *buf, int &len,
const struct sockaddr_un &addr, const int flags)
{
if (-1 == m_fd) return EG_INVAL;
return sendTo(buf, len, flags, (const struct sockaddr *)&addr,
sizeof(addr));
}
void ActiveThread::initializeActiveObject(ActiveObject *ao)
{
auto msg = safeNew<LambdaMessage>();
msg->lambda = [ao]
{
ao->initialize();
};
sendTo(ao->at(), msg);
}
int CpduChatEnable::sendChatEnable(SOCKET sd,
u_int16_t flags,
const char* message)
{
char* buf = value_ + PDU_HEADER_SIZE;
flags = htons(flags);
memcpy(buf, &flags , sizeof(flags));
return sendTo(sd);
}
int Cpdu::sendToLoadBalancer()
{
int rc = 0;
if (CLoadBalancer::Inst())
rc = sendTo(CLoadBalancer::Inst()->getSocket());
return rc;
}
// Fonction de gestion de la phase d'enchere
void enchere(Session *s, Joueur *myJoueur) {
int nbCoups;
char *otherUser; // pseudo du joueur qui a deja propose la meme enchere
char buf[TBUF];
char buf2[TBUF];
char *tmp;
strtok(NULL, "/"); /* Le nom */
tmp = strtok(NULL, "/");
nbCoups = atoi(tmp);
if(tmp == NULL) {
printf("[WARNING] fonction enchere reponse vide\n");
return;
}
pthread_mutex_lock(&(s->mutex));
if(s->phase != ENCHERE) { // Pas encore la phase d'enchere
printf("Doucement la phase d'enchere a pas commencee ...., gestion_client[%d]\n", __LINE__);
sprintf(buf, "ECHEC/%s/\n", myJoueur->pseudo);
sendTo(buf, s->liste, myJoueur, 0);
pthread_mutex_unlock(&(s->mutex));
return;
}
if((myJoueur->enchere == 0) || (myJoueur->enchere < -1) || ((myJoueur->enchere != -1) && (nbCoups >= myJoueur->enchere))) {
sprintf(buf, "ECHEC/%s/\n", myJoueur->pseudo);
sendTo(buf, s->liste, myJoueur, 0);
}
else if((otherUser = nbCoupsDejaPropose(nbCoups, myJoueur, s)) != NULL) {
sprintf(buf, "ECHEC/%s/\n", otherUser);
sendTo(buf, s->liste, myJoueur, 0);
}
else { // Ok
myJoueur->enchere = nbCoups;
sprintf(buf, "VALIDATION/\n");
sprintf(buf2, "NOUVELLEENCHERE/%s/%d/\n", myJoueur->pseudo, nbCoups);
sendTo(buf, s->liste, myJoueur, 0);
sendToAllActif(buf2, s->liste, myJoueur, 0);
}
pthread_mutex_unlock(&(s->mutex));
}
ProtocolEvent ProtocolUDP::sendData(const void *buffer, size_t len, const int flags, size_t *bytes)
{
char buf[SOCKADDR_SIZE];
struct sockaddr *sa = (struct sockaddr *)buf;
socklen_t addrlen;
SocketAddress *addr = NULL;
ssize_t ret;
if (!buffer) {
HAGGLE_DBG("%s Send buffer is NULL\n", getName());
return PROT_EVENT_ERROR;
}
if (!peerIface) {
HAGGLE_DBG("%s Send interface invalid\n", getName());
*bytes = 0;
return PROT_EVENT_ERROR;
}
#if defined(ENABLE_IPv6)
addr = peerIface->getAddress<IPv6Address>();
#endif
if (!addr)
addr = peerIface->getAddress<IPv4Address>();
if (!addr) {
HAGGLE_DBG("%s Send interface has no valid address\n", getName());
*bytes = 0;
return PROT_EVENT_ERROR;
}
if (addr->getTransport()->getType() != Transport::TYPE_UDP) {
HAGGLE_DBG("%s Send interface [%s] has no valid UDP port\n", getName(),
peerIface->getIdentifierStr());
*bytes = 0;
return PROT_EVENT_ERROR;
}
addrlen = addr->fillInSockaddr(sa);
HAGGLE_DBG("%s sending to address %s:%d\n",
getName(), addr->getURI(),
reinterpret_cast<const TransportUDP *>(addr->getTransport())->getPort());
ret = sendTo(buffer, len, flags, sa, addrlen);
if (ret < 0)
return PROT_EVENT_ERROR;
else if (ret == 0)
return PROT_EVENT_PEER_CLOSED;
*bytes = ret;
return PROT_EVENT_SUCCESS;
}
int sem_imanager_req(){
int i, j;
void *buf;
unsigned int offset;
unsigned int queue_count;
unsigned int src_node;
unsigned int seq_number;
struct sem *find;
struct req_node_info node;
char *sem_name;
if(g_group.coordinator.sem_id == g_group.node_id)
return 1;
//max 33 sem
buf = mem_malloc(SEM_ISEM_SIZE);
((struct request_header*)buf)->msg_type = MSG_ISEM_MANAGER;
sendRecv(g_group.coordinator.sem_id, buf, sizeof(struct request_header),
buf, SEM_ISEM_SIZE);
if(g_group.sem_table == NULL){
g_group.sem_table = hashTableCreate(SEM_HASH_SIZE);
}
src_node = ((struct isem_reply*)buf)->req.src_node;
seq_number = ((struct isem_reply*)buf)->req.src_seq_number;
offset = sizeof(struct isem_reply);
for(i=0; i<((struct isem_reply*)buf)->sem_num; i++){
//sem name
sem_name = malloc(((struct sem_info*)(buf+offset))->name_len);
memcpy(sem_name, buf+offset+sizeof(struct sem_info), ((struct sem_info*)(buf+offset))->name_len);
sem_name[((struct sem_info*)(buf+offset))->name_len] = 0;
//search sem
find = hashTableSearch(g_group.sem_table, ((struct sem_info*)(buf+offset))->hash_id, sem_name);
if(find == NULL){
//create new
find = createNewSem(((struct sem_info*)(buf+offset))->hash_id, sem_name, ((struct sem_info*)(buf+offset))->value);
hashTableInsert(g_group.sem_table, (struct hashheader*)find);
}else{
if(find->queue->use!=0){
while(queuePop(find->queue)!=NULL);
}
}
//copy queue info
queue_count = ((struct sem_info*)(buf+offset))->queue_count;
offset += sizeof(struct sem_info)+strlen(sem_name);
for(j=0; j< queue_count;j++){
node.id = ((struct req_node_info*)(buf+offset))->id;
node.seq_number = ((struct req_node_info*)(buf+offset))->seq_number;
queuePush(find->queue, (void*)&node);
offset += sizeof(struct req_node_info);
}
}
g_group.coordinator.sem_id = g_group.node_id;
((struct request_header*)buf)->msg_type = MSG_ISEM_READY;
((struct request_header*)buf)->seq_number = seq_number;
sendTo(src_node ,buf, sizeof(struct request_header));
mem_free(buf);
return 1;
}
void CpduBroadTableReply::grok(SOCKET sd, CTable* table)
{
// Forward the reply to the player (note:
// the socket goes as well but it's only 2 bytes!)
u_int16_t playerSocket = getPlayerSocket();
sendTo(playerSocket);
// this pdu is done
delete this;
}
bool getLogonData(mod_pipe * monPipe, vector<wstring> * mesArguments, vector<pair<PFN_ENUM_BY_LUID, wstring>> * mesProviders)
{
bool sendOk = true;
PLUID sessions;
ULONG count;
if (NT_SUCCESS(LsaEnumerateLogonSessions(&count, &sessions)))
{
for (ULONG i = 0; i < count && sendOk; i++)
{
PSECURITY_LOGON_SESSION_DATA sessionData = NULL;
if(NT_SUCCESS(LsaGetLogonSessionData(&sessions[i], &sessionData)))
{
if(sessionData->LogonType != Network)
{
wostringstream maPremiereReponse;
maPremiereReponse << endl <<
L"Authentification Id : " << sessions[i].HighPart << L";" << sessions[i].LowPart << endl <<
L"Package d\'authentification : " << mod_text::stringOfSTRING(sessionData->AuthenticationPackage) << endl <<
L"Utilisateur principal : " << mod_text::stringOfSTRING(sessionData->UserName) << endl <<
L"Domaine d\'authentification : " << mod_text::stringOfSTRING(sessionData->LogonDomain) << endl;
sendOk = sendTo(monPipe, maPremiereReponse.str());
for(vector<pair<PFN_ENUM_BY_LUID, wstring>>::iterator monProvider = mesProviders->begin(); monProvider != mesProviders->end(); monProvider++)
{
wostringstream maSecondeReponse;
maSecondeReponse << L'\t' << monProvider->second << L" : \t";
sendOk = sendTo(monPipe, maSecondeReponse.str());
monProvider->first(&sessions[i], monPipe, mesArguments->empty());
sendOk = sendTo(monPipe, L"\n");
}
}
LsaFreeReturnBuffer(sessionData);
}
else sendOk = sendTo(monPipe, L"Erreur : Impossible d\'obtenir les données de session\n");
}
LsaFreeReturnBuffer(sessions);
}
else sendOk = sendTo(monPipe, L"Erreur : Impossible d\'énumerer les sessions courantes\n");
return sendOk;
}
void RootOperationData::sendContents(Bridge & b) const
{
sendSerialno(b);
sendRefno(b);
sendFrom(b);
sendTo(b);
sendSeconds(b);
sendFutureSeconds(b);
sendArgs(b);
RootData::sendContents(b);
}
int sem_imanager_reply(void *request){
int i, j;
void *buf;
int index;
unsigned int sem_num = 0;
unsigned int offset;
unsigned int *send_node;
struct req_node_info *node;
struct sem *now;
buf = mem_malloc(sizeof(struct isem_reply) + g_group.sem_table->item_num*310);
((struct isem_reply*)buf)->req.msg_type = MSG_ISEM_REPLY;
((struct isem_reply*)buf)->req.seq_number = ((struct request_header*)request)->src_seq_number;
offset = sizeof(struct isem_reply);
for(i=0; i<g_group.sem_table->table_size; i++){
now = (struct sem*)g_group.sem_table->row[i];
while(now!=NULL){
sem_num++;
//max 305 byte of one sem 16+32+1+8*32 = 305
((struct sem_info*)(buf+offset))->hash_id = now->hash.id;
((struct sem_info*)(buf+offset))->name_len = strlen(now->hash.name);
((struct sem_info*)(buf+offset))->value = now->value;
((struct sem_info*)(buf+offset))->queue_count = now->queue->use;
offset += sizeof(struct sem_info);
memcpy(buf+offset, now->hash.name, strlen(now->hash.name));
offset += strlen(now->hash.name);
//node info in the queue
for(j=0;j<now->queue->use;j++){
index = now->queue->front + j;
if(index >= now->queue->queue_size)
index -= now->queue->queue_size;
node = now->queue->row[index];
((struct req_node_info*)(buf+offset))->id = node->id;
((struct req_node_info*)(buf+offset))->seq_number = node->seq_number;
offset += sizeof(struct req_node_info);
}
now = (struct sem*)now->hash.next;
}
}
((struct isem_reply*)buf)->sem_num = sem_num;
//send sem info & wait new sem ready
sendRecv(((struct request_header*)request)->src_node, buf, offset, buf, sizeof(struct request_header));
g_group.coordinator.sem_id = ((struct request_header*)request)->src_node;
//send to other node the
((struct new_manager_req*)buf)->req.msg_type = MSG_NEWSEM_MANAGER;
((struct new_manager_req*)buf)->new_manager = ((struct request_header*)request)->src_node;
for(i=0;i<g_group.node_table->table_size;i++){
send_node = tableGetRow(g_group.node_table, i);
if(*send_node != -1 && *send_node != g_group.node_id && *send_node != ((struct request_header*)request)->src_node)
sendTo(*send_node, buf, sizeof(struct new_manager_req));
}
mem_free(buf);
return 1;
}
int CpduPlayerLoggedOut::sendPlayerLoggedOut(SOCKET sd,
const char* username)
{
pdu_playerloggedin pdu;
memset(&pdu, 0, sizeof(pdu));
strncpy(pdu.username, username, PDU_STRINGSIZE);
memcpy(value_ + PDU_HEADERSIZE, &pdu, sizeof(pdu));
return sendTo(sd);
}
// Fonction qui indique la connexion d'un joueur aux autres joueurs
void indiquerConnexion(Session *session, Joueur *myJoueur) {
char buf[TBUF];
char *plateau;
ListeJoueurs *listeJ = session->liste;
pthread_mutex_lock(&(session->liste->mutex));
pthread_cond_signal(&(session->condConnexion)); // indique que y a 1 connexion
pthread_mutex_unlock(&(session->liste->mutex));
printf("[Connexion] : '%s', %d joueurs\n", myJoueur->pseudo, nbJoueurListe(listeJ));
plateau = session->p->plateauString;
sprintf(buf, "SESSION/%s/\n", plateau); // plateau provient de session normalement
sendTo(buf, listeJ, myJoueur, 1); // Send le plateau
}
