/* C_OpenSession() * opens a session between an application and a token in a particular slot. * slotID is the slot’s ID; flags indicates the type of session; pApplication is an * application defined pointer to be passed to the notification callback; Notify is * the address of the notification */ CK_DEFINE_FUNCTION(CK_RV, C_OpenSession)( CK_SLOT_ID slotID, /* the slot's ID */ CK_FLAGS flags, /* from CK_SESSION_INFO */ CK_VOID_PTR pApplication, /* passed to callback */ CK_NOTIFY Notify, /* callback function */ CK_SESSION_HANDLE_PTR phSession) /* gets session handle */ { // Check that the library has been initialized if (!LibraryIsInitialized()) return CKR_CRYPTOKI_NOT_INITIALIZED; // Check that the session handle pointer is not NULL if (phSession == NULL) return CKR_ARGUMENTS_BAD; // Check that the slotID is valid if (slotID != 0) return CKR_SLOT_ID_INVALID; // Check that CKF_SERIAL_SESSION flag is set (for legacy reasons) if ((flags & CKF_SERIAL_SESSION) == 0) return CKR_SESSION_PARALLEL_NOT_SUPPORTED; // Try to create a new session std::pair<SessionMap::iterator, bool> iNew = CreateNewSession(); if (!iNew.second) return CKR_GENERAL_ERROR; // Set the session handle and notification callbacks *phSession = iNew.first->first; iNew.first->second.SetNotificationCallbacks(Notify, pApplication); return CKR_OK; }
void CPrivateSendServer::ProcessMessage(CNode* pfrom, std::string& strCommand, CDataStream& vRecv, CConnman& connman) { if(!fMasterNode) return; if(fLiteMode) return; // ignore all Monoeci related functionality if(!masternodeSync.IsBlockchainSynced()) return; if(strCommand == NetMsgType::DSACCEPT) { if(pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) { LogPrintf("DSACCEPT -- incompatible version! nVersion: %d\n", pfrom->nVersion); PushStatus(pfrom, STATUS_REJECTED, ERR_VERSION, connman); return; } if(IsSessionReady()) { // too many users in this session already, reject new ones LogPrintf("DSACCEPT -- queue is already full!\n"); PushStatus(pfrom, STATUS_ACCEPTED, ERR_QUEUE_FULL, connman); return; } int nDenom; CTransaction txCollateral; vRecv >> nDenom >> txCollateral; LogPrint("privatesend", "DSACCEPT -- nDenom %d (%s) txCollateral %s", nDenom, CPrivateSend::GetDenominationsToString(nDenom), txCollateral.ToString()); masternode_info_t mnInfo; if(!mnodeman.GetMasternodeInfo(activeMasternode.outpoint, mnInfo)) { PushStatus(pfrom, STATUS_REJECTED, ERR_MN_LIST, connman); return; } if(vecSessionCollaterals.size() == 0 && mnInfo.nLastDsq != 0 && mnInfo.nLastDsq + mnodeman.CountEnabled(MIN_PRIVATESEND_PEER_PROTO_VERSION)/5 > mnodeman.nDsqCount) { LogPrintf("DSACCEPT -- last dsq too recent, must wait: addr=%s\n", pfrom->addr.ToString()); PushStatus(pfrom, STATUS_REJECTED, ERR_RECENT, connman); return; } PoolMessage nMessageID = MSG_NOERR; bool fResult = nSessionID == 0 ? CreateNewSession(nDenom, txCollateral, nMessageID, connman) : AddUserToExistingSession(nDenom, txCollateral, nMessageID); if(fResult) { LogPrintf("DSACCEPT -- is compatible, please submit!\n"); PushStatus(pfrom, STATUS_ACCEPTED, nMessageID, connman); return; } else { LogPrintf("DSACCEPT -- not compatible with existing transactions!\n"); PushStatus(pfrom, STATUS_REJECTED, nMessageID, connman); return; } } else if(strCommand == NetMsgType::DSQUEUE) {
CNetCom* CNetMgr::AddSession( const GUID *guidId ) {_STT(); // Acquire lock CTlLocalLock ll( *this ); if ( !ll.IsLocked() ) return NULL; // Create new session CNetCom* pNc = CreateNewSession(); if ( pNc == NULL ) return NULL; // Add to the list return AddSession( guidId, pNc ); }
void SessionServer::OnStart(DWORD dwArgc, PWSTR *pszArgv) { InitializeFileLogger(); // Log out an obvious piece of text to help distinguish between server sessions. LogInfo("***********************************"); LogInfo("****** Sharing Service OnStart ******"); LogInfo("***********************************"); // Log a service start message to the Application log. WriteEventLogEntry(L"Sharing Server starting", EVENTLOG_INFORMATION_TYPE); LogInfo("Server Info: \n\tBuild Version: %ls \n\tSchema Version: %i", XTOOLS_VERSION_STRING, kXToolsSchemaVersion); // TODO: use different machines, etc, based on command line parameters XT_UNREFERENCED_PARAM(dwArgc); XT_UNREFERENCED_PARAM(pszArgv); // Start listening for new connections m_listenerReceipt = m_socketMgr->AcceptConnections(kSessionServerPort, kSessionServerMaxConnections, this); LogInfo("Listening for session list connections on port %i of all network devices of the local machine.", kSessionServerPort); LogInfo("Local IP addresses are:"); IPAddressList addressList = m_socketMgr->GetLocalMachineAddresses(); for (size_t i = 0; i < addressList.size(); ++i) { LogInfo("\t%s", addressList[i].ToString().c_str()); } // Allocate a pool of ports to use for sessions m_portPool = new PortPool(kSessionServerPort-1, 256); // TODO: Read from a configuration file for persistent sessions. XTVERIFY(CreateNewSession("Default", SessionType::PERSISTENT) != NULL); // Start a thread to run the main service logic. m_serverThread = new MemberFuncThread(&SessionServer::ServerThreadFunc, this); }
void SessionServer::OnNewSessionRequest(const NewSessionRequest& request, const NetworkConnectionPtr& connection) { std::string name = request.GetSessionName(); XSessionImplPtr session; std::string failureReason; // Cannot create a session with a name that is too short if (name.length() < kMinSessionNameLength) { failureReason = "Session name must have at least " + std::to_string(kMinSessionNameLength) + " letters"; } // Cannot create a session with a name that is too long else if (name.length() > kMaxSessionNameLength) { failureReason = "Session name cannot be more than " + std::to_string(kMaxSessionNameLength) + " letters"; } else { // Check to make sure that the requested session name is not already taken for (size_t i = 0; i < m_sessions.size(); ++i) { if (m_sessions[i]->GetName() == name) { failureReason = "A session with that name already exists"; break; } } } if (failureReason.empty()) { session = CreateNewSession(name, request.GetSessionType()); } // If the session was successfully created... if (session) { // Report success. std::string address = m_socketMgr->GetLocalAddressForRemoteClient(connection->GetSocket()); uint16 port = session->GetPort(); NewSessionReply reply( session->GetId(), session->GetType(), name, address, port); NetworkOutMessagePtr response = connection->CreateMessage(MessageID::SessionControl); response->Write(reply.ToJSONString()); connection->Send(response); } else { // Report failure NewSessionReply reply(failureReason); NetworkOutMessagePtr response = connection->CreateMessage(MessageID::SessionControl); response->Write(reply.ToJSONString()); connection->Send(response); } }