SessionData* SessionManager::getSession( const Falcon::String& sSID, uint32 token ) { SessionData* sd = 0; bool bCreated; // Should we start a new thread for this? if( timeout() > 0 ) expireOldSessions(); m_mtx.lock(); SessionMap::iterator iter = m_smap.find( sSID ); if( iter != m_smap.end() ) { sd = iter->second; if ( sd == 0 || sd->isAssigned() ) { m_mtx.unlock(); return 0; } sd->assign( token ); // We must manipulate m_susers in the lock to prevent concurrent update // from other threads. m_susers[token].push_back( sd->getWeakRef() ); // now that the session is assigned, we are free to manipulate it outside the lock. m_mtx.unlock(); bCreated = false; } else { // create the session (fast) sd = createSession( sSID ); // assign to our maps m_smap[sSID] = sd; m_susers[token].push_back( sd->getWeakRef() ); // assign the session sd->assign( token ); // try to resume after unlock m_mtx.unlock(); bCreated = true; } // can we resume this session? if( ! sd->resume() ) { // all useless work. m_mtx.lock(); m_smap.erase( sSID ); sd->clearRefs(); m_mtx.unlock(); //If the session was created, we should have done it. if( ! bCreated ) { sd->setInvalid(); } else { delete sd; sd = 0; } } return sd; }
void setUp(void){ s1 = createSession(); s2 = createSession(); }
// Fonction qu'execute les threads de gestion de client void *gestionClient(void *argThread) { ArgThread *arg = (ArgThread *)argThread; int sock = arg->socket; Session *session = NULL;// = arg->session; ListeJoueurs *listeJ = NULL;//session->liste; pthread_t tmp; char *nomSession; int nbRead; char buf[TBUF]; char *req; int cpt=0; int decoProprement = 0; Joueur *myJoueur = NULL; /* Joueur du thread courant */ free(arg); while((!decoProprement) && (cpt<TBUF) && (nbRead=read(sock, &buf[cpt++], 1)) > 0) { /* Lecture d'une ligne */ if(buf[cpt-1] != '\n') continue; buf[cpt-1] = '\0'; cpt = 0; printf("[Receive] : %s\n", buf); req = strtok(buf, "/"); switch(hash_protocole(req)) { case 1: /* CONNEX */ pthread_mutex_lock(&mutexAllSession); // Au cas ou une destruction en cours pthread_mutex_lock(&(sessionDeBase->mutex)); session = sessionDeBase; listeJ = session->liste; myJoueur = connex(sock, listeJ); if(myJoueur == NULL) { pthread_mutex_unlock(&(sessionDeBase->mutex)); pthread_mutex_unlock(&mutexAllSession); sprintf(buf, "Erreur/Pseudo deja present/\n"); write(sock, buf, strlen(buf)); break; } indiquerConnexion(session, myJoueur); // Aux autres joueurs de la session pthread_mutex_unlock(&(sessionDeBase->mutex)); pthread_mutex_unlock(&mutexAllSession); break; case 2: /* SORT */ printf("[Deconnexion] '%s'\n", myJoueur->pseudo); sort(listeJ, myJoueur); decoProprement = 1; break; case 3: // SOLUTION // Reflexion ou resolution pthread_mutex_lock(&(session->mutex)); if(session->phase == REFLEXION) { pthread_mutex_unlock(&(session->mutex)); trouve(session, myJoueur); } else if(session->phase == RESOLUTION) { pthread_mutex_unlock(&(session->mutex)); resolution(session, myJoueur); } else { printf("WHAT not reflexion or resolution... bad client...\n"); // Client mal fait } break; case 4: // ENCHERE enchere(session, myJoueur); break; case 6: // CHAT chat(session, myJoueur); break; case 7: // CREERSESSION session = creerSession(arg->listeSession, myJoueur); if(session == NULL) { sprintf(buf, "Erreur/Session deja existante/\n"); write(sock, buf, strlen(buf)); break; } printf("[Creation Session] name = %s, mdp = %s\n", session->nomSession, session->mdp); pthread_create(&tmp, NULL, gestionSession, session); // On lance le thread de gestion session->thread = tmp; listeJ = session->liste; myJoueur = connex(sock, listeJ); indiquerConnexion(session, myJoueur); // Au cas ou une connexion entre temps break; case 8: // CONNEXIONPRIVEE nomSession = strtok(NULL, "/"); char *mdp = strtok(NULL, "/"); printf("[Connexion privee] nomSession = %s, mdp = %s\n", nomSession, mdp); pthread_mutex_lock(&mutexAllSession); ////////////////////////////// session = getSession(arg->listeSession, nomSession); if(session == NULL) { pthread_mutex_unlock(&mutexAllSession); //////////////////////////////// sprintf(buf, "Erreur/Session inexistante/\n"); write(sock, buf, strlen(buf)); break; } if(strcmp(mdp, session->mdp)) { pthread_mutex_unlock(&mutexAllSession); sprintf(buf, "Erreur/Mauvais mot de passe/\n"); write(sock, buf, strlen(buf)); break; } pthread_mutex_lock(&(session->mutex)); ///////////////: listeJ = session->liste; myJoueur = connex(sock, listeJ); if(myJoueur == NULL) { pthread_mutex_unlock(&(session->mutex)); pthread_mutex_unlock(&mutexAllSession); sprintf(buf, "Erreur/Pseudo deja present/\n"); write(sock, buf, strlen(buf)); break; } indiquerConnexion(session, myJoueur); pthread_mutex_unlock(&(session->mutex)); pthread_mutex_unlock(&mutexAllSession); break; default: printf("[Requete inconnue] '%s'\n", req); break; } } if(myJoueur == NULL || myJoueur->pseudo == NULL) { printf("Un truc est null WARNING !!!\n"); return NULL; } if(!decoProprement) { /* Cas ou fermeture socket sans SORT */ printf("[Deconnexion] '%s'\n", myJoueur->pseudo); sort(listeJ, myJoueur); } pthread_mutex_lock(&mutexAllSession); pthread_mutex_lock(&(session->mutex)); if(session->liste->nbJoueur == 0) { // Dernier joueur de la session Faudrait un mutex global pthread_mutex_unlock(&(session->mutex)); printf("[Dernier joueur] destruction de la session '%s'\n", session->nomSession); pthread_cancel(session->thread); // Annuler le thread de gestion de la session if(session != sessionDeBase) suppSessionListe(arg->listeSession, session); // Si pas la public, on la supprime de la liste des session privees // Si sessionDeBase on le reinitialise pour pas devoir attendre la fin du tour lors des prochaines connexions if(session == sessionDeBase) { // Prendre le mutex de sessionDeBase ou je sais pas quoi printf("[Re-init session public]\n"); sessionDeBase = createSession("Session_1", ""); pthread_create(&tmp, NULL, gestionSession, sessionDeBase); sessionDeBase->thread = tmp; } } else { pthread_mutex_unlock(&(session->mutex)); } pthread_mutex_unlock(&mutexAllSession); printf("Quit\n"); return NULL; }
/********************************************************************** *%FUNCTION: relayHandlePADS *%ARGUMENTS: * iface -- interface on which packet was received * packet -- the PADS packet *%RETURNS: * Nothing *%DESCRIPTION: * Receives and processes a PADS packet. ***********************************************************************/ void relayHandlePADS(PPPoEInterface const *iface, PPPoEPacket *packet, int size) { PPPoETag tag; unsigned char *loc; int ifIndex; int acIndex; PPPoESession *ses = NULL; SessionHash *sh; /* Can a server legally be behind this interface? */ if (!iface->acOK) { syslog(LOG_ERR, "PADS packet from %02x:%02x:%02x:%02x:%02x:%02x on interface %s not permitted", packet->ethHdr.h_source[0], packet->ethHdr.h_source[1], packet->ethHdr.h_source[2], packet->ethHdr.h_source[3], packet->ethHdr.h_source[4], packet->ethHdr.h_source[5], iface->name); return; } acIndex = iface - Interfaces; /* Source address must be unicast */ if (NOT_UNICAST(packet->ethHdr.h_source)) { syslog(LOG_ERR, "PADS packet from %02x:%02x:%02x:%02x:%02x:%02x on interface %s not from a unicast address", packet->ethHdr.h_source[0], packet->ethHdr.h_source[1], packet->ethHdr.h_source[2], packet->ethHdr.h_source[3], packet->ethHdr.h_source[4], packet->ethHdr.h_source[5], iface->name); return; } /* Destination address must be interface's MAC address */ if (memcmp(packet->ethHdr.h_dest, iface->mac, ETH_ALEN)) { return; } /* Find relay tag */ loc = findTag(packet, TAG_RELAY_SESSION_ID, &tag); if (!loc) { syslog(LOG_ERR, "PADS packet from %02x:%02x:%02x:%02x:%02x:%02x on interface %s does not have Relay-Session-Id tag", packet->ethHdr.h_source[0], packet->ethHdr.h_source[1], packet->ethHdr.h_source[2], packet->ethHdr.h_source[3], packet->ethHdr.h_source[4], packet->ethHdr.h_source[5], iface->name); return; } /* If it's the wrong length, ignore it */ if (ntohs(tag.length) != MY_RELAY_TAG_LEN) { syslog(LOG_ERR, "PADS packet from %02x:%02x:%02x:%02x:%02x:%02x on interface %s does not have correct length Relay-Session-Id tag", packet->ethHdr.h_source[0], packet->ethHdr.h_source[1], packet->ethHdr.h_source[2], packet->ethHdr.h_source[3], packet->ethHdr.h_source[4], packet->ethHdr.h_source[5], iface->name); return; } /* Extract interface index */ memcpy(&ifIndex, tag.payload, sizeof(ifIndex)); if (ifIndex < 0 || ifIndex >= NumInterfaces || !Interfaces[ifIndex].clientOK || iface == &Interfaces[ifIndex]) { syslog(LOG_ERR, "PADS packet from %02x:%02x:%02x:%02x:%02x:%02x on interface %s has invalid interface in Relay-Session-Id tag", packet->ethHdr.h_source[0], packet->ethHdr.h_source[1], packet->ethHdr.h_source[2], packet->ethHdr.h_source[3], packet->ethHdr.h_source[4], packet->ethHdr.h_source[5], iface->name); return; } /* If session ID is zero, it's the AC respoding with an error. Just relay it; do not create a session */ if (packet->session != htons(0)) { /* Check for existing session */ sh = findSession(packet->ethHdr.h_source, packet->session); if (sh) ses = sh->ses; /* If already an existing session, assume it's a duplicate PADS. Send the frame, but do not create a new session. Is this the right thing to do? Arguably, should send an error to the client and a PADT to the server, because this could happen due to a server crash and reboot. */ if (!ses) { /* Create a new session */ ses = createSession(iface, &Interfaces[ifIndex], packet->ethHdr.h_source, loc + TAG_HDR_SIZE + sizeof(ifIndex), packet->session); if (!ses) { /* Can't allocate session -- send error PADS to client and PADT to server */ PPPoETag hostUniq, *hu; if (findTag(packet, TAG_HOST_UNIQ, &hostUniq)) { hu = &hostUniq; } else { hu = NULL; } relaySendError(CODE_PADS, htons(0), &Interfaces[ifIndex], loc + TAG_HDR_SIZE + sizeof(ifIndex), hu, "RP-PPPoE: Relay: Unable to allocate session"); relaySendError(CODE_PADT, packet->session, iface, packet->ethHdr.h_source, NULL, "RP-PPPoE: Relay: Unable to allocate session"); return; } } /* Replace session number */ packet->session = ses->sesNum; } /* Remove relay-ID tag */ removeBytes(packet, loc, MY_RELAY_TAG_LEN + TAG_HDR_SIZE); size -= (MY_RELAY_TAG_LEN + TAG_HDR_SIZE); /* Set destination address to MAC address in relay ID */ memcpy(packet->ethHdr.h_dest, tag.payload + sizeof(ifIndex), ETH_ALEN); /* Set source address to MAC address of interface */ memcpy(packet->ethHdr.h_source, Interfaces[ifIndex].mac, ETH_ALEN); /* Send the PADS to the proper client */ sendPacket(NULL, Interfaces[ifIndex].discoverySock, packet, size); }
void AmSessionContainer::startSessionUAS(AmSipRequest& req) { try { // Call-ID and From-Tag are unknown: it's a new session auto_ptr<AmSession> session; string app_name; session.reset(createSession(req,app_name)); if(session.get() != 0){ // update session's local tag (ID) if not already set session->setLocalTag(); const string& local_tag = session->getLocalTag(); // by default each session is in its own callgroup session->setCallgroup(local_tag); if (AmConfig::LogSessions) { INFO("Starting UAS session %s\n", local_tag.c_str()); } switch(addSession(req.callid,req.from_tag,local_tag, req.via_branch,session.get())) { case AmSessionContainer::Inserted: // successful case break; case AmSessionContainer::ShutDown: throw AmSession::Exception(AmConfig::ShutdownModeErrCode, AmConfig::ShutdownModeErrReason); case AmSessionContainer::AlreadyExist: throw AmSession::Exception(482, SIP_REPLY_LOOP_DETECTED); default: ERROR("adding session to session container\n"); throw string(SIP_REPLY_SERVER_INTERNAL_ERROR); } MONITORING_LOG4(local_tag.c_str(), "dir", "in", "from", req.from.c_str(), "to", req.to.c_str(), "ruri", req.r_uri.c_str()); try { session->start(); } catch (...) { AmEventDispatcher::instance()-> delEventQueue(local_tag); throw; } session->postEvent(new AmSipRequestEvent(req)); session.release(); } } catch(const AmSession::Exception& e){ ERROR("%i %s %s\n",e.code,e.reason.c_str(), e.hdrs.c_str()); AmSipDialog::reply_error(req,e.code,e.reason, e.hdrs); } catch(const string& err){ ERROR("startSession: %s\n",err.c_str()); AmSipDialog::reply_error(req,500,err); } catch(...){ ERROR("unexpected exception\n"); AmSipDialog::reply_error(req,500,"unexpected exception"); } }
string AmSessionContainer::startSessionUAC(const AmSipRequest& req, string& app_name, AmArg* session_params) { auto_ptr<AmSession> session; try { session.reset(createSession(req, app_name, session_params)); if(session.get() != 0) { session->dlg->initFromLocalRequest(req); session->setCallgroup(req.from_tag); switch(addSession(req.from_tag,session.get())) { case AmSessionContainer::Inserted: // successful case break; case AmSessionContainer::ShutDown: throw AmSession::Exception(AmConfig::ShutdownModeErrCode, AmConfig::ShutdownModeErrReason); case AmSessionContainer::AlreadyExist: throw AmSession::Exception(482, SIP_REPLY_LOOP_DETECTED); default: ERROR("adding session to session container\n"); throw string(SIP_REPLY_SERVER_INTERNAL_ERROR); } MONITORING_LOG5(req.from_tag, "app", app_name.c_str(), "dir", "out", "from", req.from.c_str(), "to", req.to.c_str(), "ruri", req.r_uri.c_str()); if (int err = session->sendInvite(req.hdrs)) { ERROR("INVITE could not be sent: error code = %d.\n", err); AmEventDispatcher::instance()->delEventQueue(req.from_tag); MONITORING_MARK_FINISHED(req.from_tag.c_str()); return ""; } if (AmConfig::LogSessions) { INFO("Starting UAC session %s app %s\n", req.from_tag.c_str(), app_name.c_str()); } try { session->start(); } catch (...) { AmEventDispatcher::instance()->delEventQueue(req.from_tag); throw; } } } catch(const AmSession::Exception& e){ ERROR("%i %s\n",e.code,e.reason.c_str()); return ""; } catch(const string& err){ ERROR("startSession: %s\n",err.c_str()); return ""; } catch(...){ ERROR("unexpected exception\n"); return ""; } session.release(); return req.from_tag; }
KSession::KSession(QObject *parent) : QObject(parent), m_session(createSession("KSession")) { connect(m_session, SIGNAL(finished()), this, SLOT(sessionFinished())); connect(m_session, SIGNAL(titleChanged()), this, SIGNAL(titleChanged())); }
enum ccn_upcall_res andana_server_session_listener( struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { int res; struct andana_server *server = selfp->data; const unsigned char * const_encrypted = NULL; unsigned char *encrypted = NULL; size_t enc_size; /* * Extract the client's randomness (aka the symmetric key it sent us. * Should be the last component of the incoming Interest. */ struct ccn_charbuf *request_name = NULL; struct ccn_indexbuf *request_comps = NULL; DEBUG_PRINT("IN %d %s\n", __LINE__, __func__); switch (kind) { case CCN_UPCALL_INTEREST: DEBUG_PRINT("%d %s received session request\n", __LINE__, __func__); break; case CCN_UPCALL_INTEREST_TIMED_OUT: DEBUG_PRINT("%d %s received session request time out\n", __LINE__, __func__); /* Fall through */ default: DEBUG_PRINT("OUT %d %s\n", __LINE__, __func__); return(CCN_UPCALL_RESULT_OK); } printf("here now mk?\n"); res = ccn_util_extract_name(info->interest_ccnb, info->interest_comps, &request_name, &request_comps); if (res < 0) { DEBUG_PRINT("%d %s Failed to extract session request name\n", __LINE__, __func__); ccn_charbuf_destroy(&request_name); ccn_indexbuf_destroy(&request_comps); return(CCN_UPCALL_RESULT_ERR); } printf("passed util extract name\n"); res = ccn_name_comp_get(request_name->buf, request_comps, (unsigned int)request_comps->n - 2, &const_encrypted, &enc_size); if (res < 0) { DEBUG_PRINT("%d %s Failed to extract session creation data\n", __LINE__, __func__); ccn_charbuf_destroy(&request_name); ccn_indexbuf_destroy(&request_comps); return(CCN_UPCALL_RESULT_ERR); } encrypted = calloc(enc_size, sizeof(unsigned char)); printf("encryption size = %d\n", enc_size); if (encrypted == NULL) printf("invalid pointer return from calloc\n"); memcpy(encrypted, const_encrypted, enc_size); struct ccn_pkey *symkey = NULL; struct ccn_charbuf *decrypted = NULL; struct ccn_indexbuf *decrypted_comps = ccn_indexbuf_create(); printf("trying asymmetric decryption\n"); ccn_crypto_name_asym_decrypt(server->privkey, encrypted, &symkey, &decrypted, &decrypted_comps); // ccn_crypto_name_sym_decrypt(server->node_key, encrypted, encrypted_size, &decrypted, &decrypted_comps); /* cn_crypto_name_sym_decrypt(server->node_key, encrypted, encrypted_size, &symkey, &decrypted, &decrypted_comps); */ printf("good - now creating a session\n"); unsigned char *session_id = NULL; unsigned char *session_key = NULL; unsigned char *server_rand = NULL; /* * Create a new session id and session key using the client's randomness. * The server is also responsible for contributing randomness of its own for security. */ createSession(&session_id, &session_key, &server_rand, ccn_crypto_symkey_key(symkey), (unsigned int)ccn_crypto_symkey_bytes(symkey), ccn_crypto_symkey_key(server->node_key)); printf("Session made!\n"); /* Construct the response message using a ccn name (for convenience). */ struct ccn_charbuf *session_info = ccn_charbuf_create(); ccn_name_init(session_info); ccn_name_append(session_info, session_id, SESSIONID_LENGTH); ccn_name_append(session_info, session_key, SESSION_KEYLEN); ccn_name_append(session_info, server_rand, SESSIONRAND_LENGTH); /** * Encrypt the response message using the symmetric key * provided by the client and send it out. */ unsigned char *enc_info = NULL; ccn_crypto_content_encrypt(symkey, session_info->buf, session_info->length, &enc_info, &enc_size); struct ccn_charbuf *signed_enc_info = ccn_charbuf_create(); struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT; sp.type = CCN_CONTENT_DATA; res = ccn_sign_content(server->proxy->handle, signed_enc_info, request_name, &sp, enc_info, enc_size); if (res < 0) { DEBUG_PRINT("%d %s Failed to signed session creation response\n", __LINE__, __func__); } else { res = ccn_put(server->proxy->handle, signed_enc_info->buf, signed_enc_info->length); } ccn_charbuf_destroy(&decrypted); ccn_indexbuf_destroy(&decrypted_comps); ccn_crypto_symkey_destroy(&symkey); free(session_id); free(session_key); free(server_rand); free(enc_info); ccn_charbuf_destroy(&signed_enc_info); if (res < 0) { DEBUG_PRINT("%d %s Error writing session creation response\n", __LINE__, __func__); return(CCN_UPCALL_RESULT_ERR); } DEBUG_PRINT("OUT %d %s Created new session. Response sent\n", __LINE__, __func__); return(CCN_UPCALL_RESULT_INTEREST_CONSUMED); }