void session::start(int flags, settings_pack const& pack, io_service* ios) { bool const internal_executor = ios == nullptr; if (internal_executor) { // the user did not provide an executor, we have to use our own m_io_service = boost::make_shared<io_service>(); ios = m_io_service.get(); } m_impl = boost::make_shared<session_impl>(boost::ref(*ios)); *static_cast<session_handle*>(this) = session_handle(m_impl.get()); #ifndef TORRENT_DISABLE_EXTENSIONS if (flags & add_default_plugins) { add_extension(create_ut_pex_plugin); add_extension(create_ut_metadata_plugin); add_extension(create_smart_ban_plugin); } #else TORRENT_UNUSED(flags); #endif m_impl->start_session(pack); if (internal_executor) { // start a thread for the message pump m_thread = std::make_shared<std::thread>( [&]() { m_io_service->run(); }); } }
SessionHandle IEServer::InitializeSession() { LOG(TRACE) << "Entering IEServer::InitializeSession"; SessionHandle session_handle(new IESession()); SessionParameters params; params.port = this->port(); session_handle->Initialize(reinterpret_cast<void*>(¶ms)); return session_handle; }
std::wstring Server::CreateSession() { // TODO: make this generic and not tightly bound to the IESession class SessionHandle session_handle(new IESession(this->port_)); std::wstring session_id = session_handle->Initialize(); this->sessions_[session_id] = session_handle; return session_id; }
SessionHandle IEServer::InitializeSession() { LOG(TRACE) << "Entering IEServer::InitializeSession"; SessionHandle session_handle(new IESession()); SessionParameters params; params.port = this->port(); params.implementation = IESession::ConvertDriverEngine(this->driver_implementation_); session_handle->Initialize(reinterpret_cast<void*>(¶ms)); return session_handle; }
static inline int session_send_evt_to_thread (void *data, void *args, u32 thread_index, session_evt_type_t evt_type) { session_event_t *evt; svm_msg_q_msg_t msg; svm_msg_q_t *mq; u32 tries = 0, max_tries; mq = session_main_get_vpp_event_queue (thread_index); while (svm_msg_q_try_lock (mq)) { max_tries = vlib_get_current_process (vlib_get_main ())? 1e6 : 3; if (tries++ == max_tries) { SESSION_DBG ("failed to enqueue evt"); return -1; } } if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING))) { svm_msg_q_unlock (mq); return -2; } msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING); if (PREDICT_FALSE (svm_msg_q_msg_is_invalid (&msg))) { svm_msg_q_unlock (mq); return -2; } evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg); evt->event_type = evt_type; switch (evt_type) { case SESSION_CTRL_EVT_RPC: evt->rpc_args.fp = data; evt->rpc_args.arg = args; break; case SESSION_IO_EVT_TX: case SESSION_IO_EVT_TX_FLUSH: case SESSION_IO_EVT_BUILTIN_RX: evt->session_index = *(u32 *) data; break; case SESSION_IO_EVT_BUILTIN_TX: case SESSION_CTRL_EVT_CLOSE: evt->session_handle = session_handle ((session_t *) data); break; default: clib_warning ("evt unhandled!"); svm_msg_q_unlock (mq); return -1; } svm_msg_q_add_and_unlock (mq, &msg); return 0; }
static void session_program_transport_close (session_t * s) { u32 thread_index = vlib_get_thread_index (); session_worker_t *wrk; session_event_t *evt; /* If we are in the handler thread, or being called with the worker barrier * held, just append a new event to pending disconnects vector. */ if (vlib_thread_is_main_w_barrier () || thread_index == s->thread_index) { wrk = session_main_get_worker (s->thread_index); vec_add2 (wrk->pending_disconnects, evt, 1); clib_memset (evt, 0, sizeof (*evt)); evt->session_handle = session_handle (s); evt->event_type = SESSION_CTRL_EVT_CLOSE; } else session_send_ctrl_evt_to_thread (s, SESSION_CTRL_EVT_CLOSE); }
void session::start(int flags, settings_pack const& pack, io_service* ios) { #if defined _MSC_VER && defined TORRENT_DEBUG // workaround for microsofts // hardware exceptions that makes // it hard to debug stuff ::_set_se_translator(straight_to_debugger); #endif bool internal_executor = ios == NULL; if (internal_executor) { // the user did not provide an executor, we have to use our own m_io_service = boost::make_shared<io_service>(); ios = m_io_service.get(); } m_impl = boost::make_shared<session_impl>(boost::ref(*ios)); *static_cast<session_handle*>(this) = session_handle(m_impl.get()); #ifndef TORRENT_DISABLE_EXTENSIONS if (flags & add_default_plugins) { add_extension(create_ut_pex_plugin); add_extension(create_ut_metadata_plugin); add_extension(create_smart_ban_plugin); } #else TORRENT_UNUSED(flags); #endif m_impl->start_session(pack); if (internal_executor) { // start a thread for the message pump m_thread = boost::make_shared<thread>(boost::bind(&io_service::run , m_io_service.get())); } }
SessionHandle IEServer::InitializeSession() { SessionHandle session_handle(new IESession()); int port = this->port(); session_handle->Initialize(&port); return session_handle; }
/* * 1.Learn the port number through which the session will send the data. * 2.Spawn a new thread to send the data and give the control back to the above layer */ void *session_transfer(void *ptr) { /* Extract the data from the above layer */ session_data *s_data; s_data = (session_data *) ptr; while (1) { /* Allocate the session */ session_t session; /* Fill the session structure */ session_build_parameters(s_data->ip, s_data->host_name, &session); /* Send the hello packets to get the port number */ int ret = 0; ret = learn_new_port(&session); if (ret == -1) { printf("No port assigned.\n"); continue; } /* Change the port number of the address since the new port will be used for further communication */ session.address.sin_port = htons(session.port); log_mesg("SESSION connected to Port %d\n", session.port); printf("SESSION connected to Port %d\n", session.port); /* Connection is established. Lets read from the stdin and transfer the data */ char session_data[SESSION_SIZE + MAX_RECORD_SIZE] = {0}; char *success; int num_bytes = 0; while (1) { /* Read the data from standard input. Read SESSION_SIZE bytes and send the data */ while(1) { printf("Read %d bytes..\n", num_bytes); success = fgets(session_data + num_bytes, MAX_RECORD_SIZE, stdin); num_bytes = strlen(session_data); if (!success) { /* Nothing to read. BREAK. */ printf("No data to read. \n"); break; } if (num_bytes >= SESSION_SIZE) { printf("Session Full ...\n"); break; } } /* No data. Lets sleep for sometime */ if (strlen(session_data) == 0 ) { printf("No data to send. \n"); sleep(10); continue; } else { printf("Sending data ...\n"); memcpy(session.file_name, "DATA.txt", sizeof(session.file_name)); session.no_of_bytes = strlen(session_data); session.total_no_of_bytes = session.no_of_bytes; /* Calculate the number of data packets in the session */ session.no_of_packets = session.no_of_bytes/MAX_FRAME_SIZE; /* One more packet is required if some more bytes are left */ if (session.no_of_bytes % MAX_FRAME_SIZE) { session.no_of_packets++; } /* Initialize the sequence number for the data packets*/ session.next_frame_number = 0; /* Handle session */ session_handle(&session, session_data); printf("Send Over... \n"); /* Reset the buffer */ bzero(session_data, SESSION_SIZE + MAX_RECORD_SIZE); num_bytes = 0; } } } }