//----------------------------------------------------------------------------- worker_c::error_e worker_c::service_handshake_request( Reveal::Core::authorization_ptr auth ) { Reveal::Core::session_ptr session; Reveal::Core::user_ptr user; Reveal::Core::authorization_c::type_e type = auth->get_type(); if( type == Reveal::Core::authorization_c::TYPE_IDENTIFIED ) { // validate user credentials printf( "client requested identified authorization: id[%s]\n", auth->get_user().c_str() ); // TODO : Logging if( is_user_valid( auth, user ) ) { if( create_session( auth, session ) ) { printf( "created session: " ); session->print(); auth->set_error( Reveal::Core::authorization_c::ERROR_NONE ); auth->set_user( user->id ); auth->set_type( Reveal::Core::authorization_c::TYPE_SESSION ); auth->set_session( session->session_id ); send_valid_handshake_response( auth ); } else { // TODO : handle failed session insert into database } } else { printf( "ERROR: failed to find %s in user table\n", auth->get_user().c_str() ); // failed query and failed authentication auth->set_error( Reveal::Core::authorization_c::ERROR_INVALID_IDENTITY ); send_invalid_handshake_response( auth ); } } else if( type == Reveal::Core::authorization_c::TYPE_ANONYMOUS ) { printf( "client requested anonymous authorization\n" ); // TODO : Logging if( create_session( auth, session ) ) { printf( "created session: " ); session->print(); auth->set_type( Reveal::Core::authorization_c::TYPE_SESSION ); auth->set_session( session->session_id ); send_valid_handshake_response( auth ); } else { // TODO : handle failed session insert into database } } else if( type == Reveal::Core::authorization_c::TYPE_SESSION ) { // this should only occur if a session was disrupted to the point that // the client is trying to resume after being completely disconnected // from the server. This is the most suspicious case though and // probably should be denied as it is possible to session hijack if allowed. } return ERROR_NONE; }
int main(int argc, char* argv[]) { schd = create_scheduler(); initialize_scheduler(schd, NULL); session_1 = create_session(); initialize_session(session_1, "222.214.218.237", 6601, "1299880", 0); set_session_index(session_1, 0); add_session(schd, session_1); session_2 = create_session(); initialize_session(session_2, "222.214.218.237", 6601, "1299880", 1); set_session_index(session_2, 1); add_session(schd, session_2); set_surface_mode(schd->surface, mode_2); scheduler_start(schd); session_start(session_1); session_start(session_2); scheduler_wait(schd); session_stop(session_1); session_stop(session_2); destroy_session(session_1); destroy_session(session_2); return 0; }
bool register_tests(test_suite *suite, node n) { ELLIPTICS_TEST_CASE(test_write_order_execution, create_session(n, { 1 }, 0, 0)); ELLIPTICS_TEST_CASE(test_oplock, create_session(n, { 1 }, 0, 0)); return true; }
int main (int argc, char ** argv) { gchar* filename; QofSession* session_1; qof_init(); cashobjects_register(); qof_load_backend_library ("../.libs/", GNC_LIB_NAME); // Create a session with data session_1 = create_session(); filename = tempnam( "/tmp", "test-sqlite3-" ); printf( "Using filename: %s\n", filename ); test_dbi_store_and_reload( "sqlite3", session_1, filename ); #if 0 printf( "TEST_MYSQL_URL='%s'\n", TEST_MYSQL_URL ); if ( strlen( TEST_MYSQL_URL ) > 0 ) { session_1 = create_session(); test_dbi_store_and_reload( "mysql", session_1, TEST_MYSQL_URL ); } printf( "TEST_PGSQL_URL='%s'\n", TEST_PGSQL_URL ); if ( strlen( TEST_PGSQL_URL ) > 0 ) { session_1 = create_session(); test_dbi_store_and_reload( "pgsql", session_1, TEST_PGSQL_URL ); } #endif print_test_results(); qof_close(); exit(get_rv()); }
bool register_tests(test_suite *suite, node n) { ELLIPTICS_TEST_CASE(test_cache_records_sizes, create_session(n, { 5 }, 0, DNET_IO_FLAGS_CACHE | DNET_IO_FLAGS_CACHE_ONLY)); ELLIPTICS_TEST_CASE(test_cache_overflow, create_session(n, { 5 }, 0, DNET_IO_FLAGS_CACHE | DNET_IO_FLAGS_CACHE_ONLY)); ELLIPTICS_TEST_CASE(test_cache_overflow, create_session(n, { 5 }, 0, DNET_IO_FLAGS_CACHE)); return true; }
bool register_tests(test_suite *suite, node n) { ELLIPTICS_TEST_CASE(upload_application, global_data->locator_port, global_data->directory.path()); ELLIPTICS_TEST_CASE(start_application, create_session(n, { 1 }, 0, 0), "dnet_cpp_srw_test_app"); ELLIPTICS_TEST_CASE(init_application, create_session(n, { 1 }, 0, 0), "dnet_cpp_srw_test_app"); ELLIPTICS_TEST_CASE(send_echo, create_session(n, { 1 }, 0, 0), "dnet_cpp_srw_test_app", "some-data"); ELLIPTICS_TEST_CASE(send_echo, create_session(n, { 1 }, 0, 0), "dnet_cpp_srw_test_app", "some-data and long-data.. like this"); return true; }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Interactive render session constructor ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// BlenderSession::BlenderSession(BL::RenderEngine b_engine_, BL::UserPreferences b_userpref_, BL::BlendData b_data_, BL::Scene b_scene_, BL::SpaceView3D b_v3d_, BL::RegionView3D b_rv3d_, int width_, int height_) : b_engine(b_engine_), b_userpref(b_userpref_), b_data(b_data_), b_scene(b_scene_), b_v3d(b_v3d_), b_rv3d(b_rv3d_) { for(int i = 0; i < Passes::NUM_PASSES; ++i) { if(pass_buffers[i]) pass_buffers[i] = 0; } for(int i = 0; i < Passes::NUM_PASSES; ++i) { if(mb_pass_buffers[i]) mb_pass_buffers[i] = 0; } // 3d view render width = width_; height = height_; interactive = true; last_redraw_time = 0.0f; create_session(); if(motion_blur && mb_type == INTERNAL) { bool stop_render; session->start("Interactive", false, load_internal_mb_sequence(stop_render), 0); } else { motion_blur = false; session->start("Interactive", false, 0, 0); } } //BlenderSession(BL::RenderEngine b_engine_, BL::UserPreferences b_userpref_, BL::BlendData b_data_, BL::Scene b_scene_, BL::SpaceView3D b_v3d_, BL::RegionView3D b_rv3d_, int width_, int height_)
SESSION_t *session_begin(LISTEN_t * thiz,UDP_PKT_H_t *uph,u_int32_t len,int sock_fd,u_int32_t ip,u_int16_t port) { SESSION_t *s; u_int32_t radom; _RUDPA_DEBUG("session_begin>>in \n"); if (len != UDPH_LEN + sizeof(u_int32_t)) return NULL; radom = *(u_int32_t*)uph->data; if ((s = query_old_session((radom))) == NULL) { if ((s = create_session(uph->session_id)) == NULL) return NULL; NEW_SESSION_t ns; ns.session = s; ns.radom = radom; ListenerEventCall(thiz,LEvent_New_Session,(void *)&ns,sizeof(ns)); _RUDPA_DEBUG("session:%x\r\n",s); _RUDPA_TRACE("\033[31m new session id=====0x%x\r\n\033[0m",s->session_id); } s->fd = sock_fd; s->ip = ip; s->port = port; s->tick = uph->tick; s->radom = radom; _RUDPA_DEBUG("session_begin>>out\n"); return s; }
int API::api_read(Json::Value &request, Json::Value &response, Json::Value &errors) { if (validate_read(request["data"], errors) < 0) { response["status"] = Json::Value(STATUS_STRUCTURE); return -1; } int user = authenticate(request["auth"]); if (user == -1) { response["status"] = STATUS_AUTH; errors.append(Json::Value("Authentication failed")); return -1; } create_session(response, user); Json::Value call_data; if (strcmp(request["data"]["view"].asCString(), "list") == 0) { if (strcmp(request["data"]["type"].asCString(), "profile") == 0) call_data = read_profile_list(request["data"], user, errors); else if (strcmp(request["data"]["type"].asCString(), "department") == 0) call_data = read_department_list(request["data"], user, errors); else if (strcmp(request["data"]["type"].asCString(), "user") == 0) call_data = read_user_list(request["data"], user, errors); else if (strcmp(request["data"]["type"].asCString(), "pictogram") == 0) call_data = read_pictogram_list(request["data"], user, errors); else if (strcmp(request["data"]["type"].asCString(), "application") == 0) call_data = read_application_list(request["data"], user, errors); else if (strcmp(request["data"]["type"].asCString(), "category") == 0) call_data = read_category_list(request["data"], user, errors); else { response["status"] = STATUS_STRUCTURE; errors.append(Json::Value("Invalid data type requested")); } } else { if (strcmp(request["data"]["type"].asCString(), "profile") == 0) call_data = read_profile_details(request["data"], user, errors); else if (strcmp(request["data"]["type"].asCString(), "department") == 0) call_data = read_department_details(request["data"], user, errors); else if (strcmp(request["data"]["type"].asCString(), "user") == 0) call_data = read_user_details(request["data"], user, errors); else if (strcmp(request["data"]["type"].asCString(), "pictogram") == 0) call_data = read_pictogram_details(request["data"], user, errors); else if (strcmp(request["data"]["type"].asCString(), "application") == 0) call_data = read_application_details(request["data"], user, errors); else if (strcmp(request["data"]["type"].asCString(), "category") == 0) call_data = read_category_details(request["data"], user, errors); else { response["status"] = STATUS_STRUCTURE; errors.append(Json::Value("Invalid data type requested")); } } if (!errors.empty()) { response["status"] = Json::Value(STATUS_ACCESS); return -1; } response["data"] = call_data; return 0; }
int runpartialgetresponsetest(char *hostname, char *username, char *password) { int session_id = -1; int i = 0; int total= 100; int batchsize = 10; char *batchid = "batchid"; char *request[total]; char *userdata[total]; for(; i < total; i++) { request[i] = malloc(1024); sprintf(request[i], "req%d", i); userdata[i] = malloc(1024); sprintf(userdata[i], "userdata%d", i); } init_client(hostname, username, password); session_id = create_session(); send_request(session_id, batchid, request, userdata, total, true); get_response(session_id, batchid, "", "", batchsize, true); i = 1; for(; i < 9; i++) { get_response(session_id, batchid, "", "", batchsize, false); } close_session(session_id); return 0; }
bool Server::init() { if(m_server_type == SERVER_TYPE_USER){ m_com_contacts = new CompanyContactsKeeper(m_mongodb_addr,m_company_list_filename); if(m_com_contacts->init()==false){ return false; } } if(m_server_type == SERVER_TYPE_JOB){ m_com_score = new CompanyScoreKeeper(m_company_score_filename); if(m_com_score->init()==false){ return false; } } pthread_mutex_init(&m_db_lock,0); pthread_cond_init(&m_db_cond,0); for(size_t i=0;i<db_pool_size;i++){ m_dbs.push_back(new Xapian::Database(m_index_dir)); m_dbs_busy.push_back(false); } Session* new_session = create_session(); new_session->init(); acceptor_.async_accept(new_session->socket(), boost::bind(&Server::handle_accept, this, new_session, boost::asio::placeholders::error)); return true; }
int main(int argc, char **argv) { int server_socket; struct sockaddr_in serv_addr; if(argc != 5){ perror("argc :"); exit(2); } bzero(&serv_addr, sizeof(serv_addr)); serv_addr.sin_family = PF_INET; serv_addr.sin_port = htons(atoi(argv[2])); if ((server_socket = socket(PF_INET, SOCK_STREAM, 0)) == -1){ perror("Client: socket(): "); exit(2); } if (connect(server_socket, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1){ perror("Client: connect(): "); exit(2); } create_session(argv[3], argv[4], server_socket, &serv_addr); close(server_socket); return 0; }
/* * If requested via GET, serves the login page. * If requested via POST (form submission), checks password and logs user in. */ static void login_handler(struct mg_connection *nc, int ev, void *p) { struct http_message *hm = (struct http_message *) p; if (mg_vcmp(&hm->method, "POST") != 0) { /* Serve login.html */ mg_serve_http(nc, (struct http_message *) p, s_http_server_opts); } else { /* Perform password check. */ char user[50], pass[50]; int ul = mg_get_http_var(&hm->body, "user", user, sizeof(user)); int pl = mg_get_http_var(&hm->body, "pass", pass, sizeof(pass)); if (ul > 0 && pl > 0) { if (check_pass(user, pass)) { struct session *s = create_session(user, hm); mg_printf(nc, "HTTP/1.0 302 Found\r\n"); set_session_cookie(nc, s); mg_printf(nc, "Location: /\r\n"); mg_printf(nc, "\r\nHello, %s!\r\n", s->user); fprintf(stderr, "%s logged in, sid %" INT64_X_FMT "\n", s->user, s->id); } else { mg_printf(nc, "HTTP/1.0 403 Unauthorized\r\n\r\nWrong password.\r\n"); } } else { mg_printf(nc, "HTTP/1.0 400 Bad Request\r\n\r\nuser, pass required.\r\n"); } nc->flags |= MG_F_SEND_AND_CLOSE; } (void) ev; }
void BlenderSession::create() { create_session(); if(b_v3d) session->start(); }
int process_msg_general(worker_data *wd, message *msg) { //Basic sanity checks if (msg == NULL || wd == NULL || msg->destination_id != wd->id || msg->destination_type != WORKER) { return -1; } //If the message comes from a thread, we check that it has the correct format if (msg->origin_type == THREAD) { int errcode = check_thread_message_args(msg); if (errcode != 0) { message *answer = create_error_message(WORKER, wd->id, THREAD, msg->thread_id, msg->thread_id, ANSWER, ERROR, errcode); send_message(answer); delete_message(answer); return 0; } } //We check if there is an existing session for the thread associated to this message, and if not, we create it session *s = create_session(wd, msg->thread_id); //If it comes from a thread if (msg->origin_type == THREAD) { process_thread_request(wd, msg, s); } //Else, if it comes from another worker and its an request for something else if (msg->origin_type == WORKER && msg->msg_type == REQUEST) { process_worker_request(wd, msg, s); } //Else, if it comes from another worker, but its an answer to something we requested else if (msg->origin_type == WORKER && msg->msg_type == ANSWER) { process_worker_answer(wd, msg, s); } return 0; }
static void server_work(struct work_struct *work) { struct socket *server_socket; struct socket *slave_socket; kkv_server *server; kkv_session *session; server=container_of(work,kkv_server,work); server_socket=server->socket; again: slave_socket=accept_socket(server_socket); if (!slave_socket) return; session=create_session(session_work_socket,slave_socket); if(!session) { #ifdef DEBUG_KKV_NETWORK printk("create_session() failed\n"); #endif goto out; } set_slave_sk_callbacks(slave_socket,session); goto again; out: slave_socket->ops->shutdown(slave_socket,SHUT_RDWR); sock_release(slave_socket); }
session& connection::default_session() { struct connection_context& ctx = connection_context::get(pn_cast(this)); if (!ctx.default_session) { ctx.default_session = &create_session(); ctx.default_session->open(); } return *ctx.default_session; }
bool register_tests(test_suite *suite, node n) { ELLIPTICS_TEST_CASE(test_error_message, create_session(n, {2}, 0, 0), "non-existen-key", -ENOENT); ELLIPTICS_TEST_CASE_NOARGS(test_error_null_message); ELLIPTICS_TEST_CASE_NOARGS(test_data_buffer); return true; }
SingleSessionTest::SingleSessionTest(unsigned int num_nodes_dc1, unsigned int num_nodes_dc2, unsigned int protocol_version, bool isSSL /* = false */) : MultipleNodesTest(num_nodes_dc1, num_nodes_dc2, protocol_version, isSSL), session(NULL), ssl(NULL) { //SSL verification flags must be set before establishing session if (!isSSL) { create_session(); } else { ssl = cass_ssl_new(); } }
/* Create a pad for receiving RTP for the session in @name */ static GstPad * create_recv_rtp (GstRDTManager * rdtmanager, GstPadTemplate * templ, const gchar * name) { guint sessid; GstRDTManagerSession *session; /* first get the session number */ if (name == NULL || sscanf (name, "recv_rtp_sink_%u", &sessid) != 1) goto no_name; GST_DEBUG_OBJECT (rdtmanager, "finding session %d", sessid); /* get or create session */ session = find_session_by_id (rdtmanager, sessid); if (!session) { GST_DEBUG_OBJECT (rdtmanager, "creating session %d", sessid); /* create session now */ session = create_session (rdtmanager, sessid); if (session == NULL) goto create_error; } /* check if pad was requested */ if (session->recv_rtp_sink != NULL) goto existed; GST_DEBUG_OBJECT (rdtmanager, "getting RTP sink pad"); session->recv_rtp_sink = gst_pad_new_from_template (templ, name); gst_pad_set_element_private (session->recv_rtp_sink, session); gst_pad_set_event_function (session->recv_rtp_sink, gst_rdt_manager_event_rdt); gst_pad_set_chain_function (session->recv_rtp_sink, gst_rdt_manager_chain_rdt); gst_pad_set_active (session->recv_rtp_sink, TRUE); gst_element_add_pad (GST_ELEMENT_CAST (rdtmanager), session->recv_rtp_sink); return session->recv_rtp_sink; /* ERRORS */ no_name: { g_warning ("rdtmanager: invalid name given"); return NULL; } create_error: { /* create_session already warned */ return NULL; } existed: { g_warning ("rdtmanager: recv_rtp pad already requested for session %d", sessid); return NULL; } }
void attach_process(PGW &pgw){ if(pgw.subtype == 3){ create_session(pgw); } else{ cout << "Incorrect subtype for type 1 -> " << pgw.subtype << endl; } }
static gboolean gst_mir_sink_start (GstBaseSink * bsink) { GstMirSink *sink = (GstMirSink *) bsink; GST_DEBUG_OBJECT (sink, "start"); /* If we start playback again after an EOS, make sure we have a new valid * SurfaceTextureClientHybris instance to use and pass to the decoder. */ if (!sink->surface_texture_client && sink->texture_id > 0) { GST_DEBUG_OBJECT (sink, "Creating new SurfaceTextureClientHybris instance"); gst_mir_sink_create_surface_texture (G_OBJECT (bsink)); } #if 0 /* If we are using a texture_id, there's no need to use the Ubuntu * Platform API to create an EGLNativeWindowType */ if (sink->texture_id) return TRUE; /* Create a new Ubuntu Application API session */ if (sink->session == NULL) sink->session = create_session (); if (sink->session == NULL) { GST_ELEMENT_ERROR (bsink, RESOURCE, OPEN_READ_WRITE, ("Could not initialize Mir output"), ("Could not start a Mir app session")); return FALSE; } if (sink->display == NULL) sink->display = create_display (); if (sink->display == NULL) { GST_ELEMENT_ERROR (bsink, RESOURCE, OPEN_READ_WRITE, ("Could not initialize Mir output"), ("Could not create a Mir display")); return FALSE; } /* Create an EGLNativeWindowType instance so that a pure playbin * scenario will render video */ if (sink->window == NULL) { sink->video_width = sink->display->width; sink->video_height = sink->display->height; GST_DEBUG_OBJECT (sink, "video_width: %d, video_height: %d", sink->video_width, sink->video_height); create_window (sink, sink->display, sink->video_width, sink->video_height); sink->surface_texture_client = surface_texture_client_create (sink->window->egl_native_window); } #endif return TRUE; }
void BlenderSession::reset_session(BL::BlendData b_data_, BL::Scene b_scene_) { b_data = b_data_; b_render = b_engine.render(); b_scene = b_scene_; SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background); const bool is_cpu = session_params.device.type == DEVICE_CPU; SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background, is_cpu); width = render_resolution_x(b_render); height = render_resolution_y(b_render); if(scene->params.modified(scene_params) || session->params.modified(session_params) || !scene_params.persistent_data) { /* if scene or session parameters changed, it's easier to simply re-create * them rather than trying to distinguish which settings need to be updated */ delete session; create_session(); return; } session->progress.reset(); scene->reset(); session->tile_manager.set_tile_order(session_params.tile_order); /* peak memory usage should show current render peak, not peak for all renders * made by this render session */ session->stats.mem_peak = session->stats.mem_used; /* sync object should be re-created */ sync = new BlenderSync(b_engine, b_data, b_scene, scene, !background, session->progress, is_cpu); /* for final render we will do full data sync per render layer, only * do some basic syncing here, no objects or materials for speed */ sync->sync_render_layers(b_v3d, NULL); sync->sync_integrator(); sync->sync_camera(b_render, b_engine.camera_override(), width, height); BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, PointerRNA_NULL, PointerRNA_NULL, scene->camera, width, height); session->reset(buffer_params, session_params.samples); b_engine.use_highlight_tiles(session_params.progressive_refine == false); /* reset time */ start_resize_time = 0.0; }
GabbleJingleSession * gabble_jingle_factory_create_session (GabbleJingleFactory *fac, const gchar *jid, JingleDialect dialect, gboolean local_hold) { GabbleJingleSession *session = create_session (fac, NULL, jid, dialect, local_hold); g_signal_emit (fac, signals[NEW_SESSION], 0, session, TRUE); return session; }
int make_listen_bind(uint32 ip, uint16 port) { struct sockaddr_in server_address; int fd; int result; fd = sSocket(AF_INET, SOCK_STREAM, 0); if( fd == -1 ) { ShowError("make_listen_bind: criacao de socket falhou (codigo %d)!\n", sErrno); exit(EXIT_FAILURE); } if( fd == 0 ) {// reserved ShowError("make_listen_bind: Socket #0 e reservado - Favor reportar isso!!!\n"); sClose(fd); return -1; } if( fd >= FD_SETSIZE ) {// socket number too big ShowError("make_listen_bind: Novo socket #%d e maior do que suportamos! aumente o valor de FD_SETSIZE (atualmente %d) para seu SO consertar isso!\n", fd, FD_SETSIZE); sClose(fd); return -1; } setsocketopts(fd); set_nonblocking(fd, 1); server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = htonl(ip); server_address.sin_port = htons(port); result = sBind(fd, (struct sockaddr*)&server_address, sizeof(server_address)); if( result == SOCKET_ERROR ) { ShowError("make_listen_bind: vinculacao falhou (socket #%d, codigo %d)!\n", fd, sErrno); exit(EXIT_FAILURE); } result = sListen(fd,5); if( result == SOCKET_ERROR ) { ShowError("make_listen_bind: listen falhou (socket #%d, codigo %d)!\n", fd, sErrno); exit(EXIT_FAILURE); } if(fd_max <= fd) fd_max = fd + 1; sFD_SET(fd, &readfds); create_session(fd, connect_client, null_send, null_parse); session[fd]->client_addr = 0; // just listens session[fd]->rdata_tick = 0; // disable timeouts on this socket return fd; }
void BlenderSession::synchronize() { /* only used for viewport render */ if(!b_v3d) return; /* on session/scene parameter changes, we recreate session entirely */ SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background); SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background); if(session->params.modified(session_params) || scene->params.modified(scene_params)) { free_session(); create_session(); session->start(); return; } /* increase samples, but never decrease */ session->set_samples(session_params.samples); session->set_pause(BlenderSync::get_session_pause(b_scene, background)); /* copy recalc flags, outside of mutex so we can decide to do the real * synchronization at a later time to not block on running updates */ sync->sync_recalc(); /* try to acquire mutex. if we don't want to or can't, come back later */ if(!session->ready_to_reset() || !session->scene->mutex.try_lock()) { tag_update(); return; } /* data and camera synchronize */ sync->sync_data(b_v3d, b_engine.camera_override(), &python_thread_state); if(b_rv3d) sync->sync_view(b_v3d, b_rv3d, width, height); else sync->sync_camera(b_render, b_engine.camera_override(), width, height); /* unlock */ session->scene->mutex.unlock(); /* reset if needed */ if(scene->need_reset()) { BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, b_scene, b_v3d, b_rv3d, scene->camera, width, height); session->reset(buffer_params, session_params.samples); /* reset time */ start_resize_time = 0.0; } }
int make_listen_bind(uint32 ip, uint16 port) { struct sockaddr_in server_address; int fd; int result; fd = sSocket(AF_INET, SOCK_STREAM, 0); if( fd == -1 ) { ShowError("make_listen_bind: socket creation failed (%s)!\n", error_msg()); exit(EXIT_FAILURE); } if( fd == 0 ) { // reserved ShowError("make_listen_bind: Socket #0 is reserved - Please report this!!!\n"); sClose(fd); return -1; } if( fd >= FD_SETSIZE ) { // socket number too big ShowError("make_listen_bind: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE); sClose(fd); return -1; } setsocketopts(fd,0); set_nonblocking(fd, 1); server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = htonl(ip); server_address.sin_port = htons(port); result = sBind(fd, (struct sockaddr*)&server_address, sizeof(server_address)); if( result == SOCKET_ERROR ) { ShowError("make_listen_bind: bind failed (socket #%d, %s)!\n", fd, error_msg()); exit(EXIT_FAILURE); } result = sListen(fd,5); if( result == SOCKET_ERROR ) { ShowError("make_listen_bind: listen failed (socket #%d, %s)!\n", fd, error_msg()); exit(EXIT_FAILURE); } if(fd_max <= fd) fd_max = fd + 1; sFD_SET(fd, &readfds); create_session(fd, connect_client, null_send, null_parse); session[fd]->client_addr = 0; // just listens session[fd]->rdata_tick = 0; // disable timeouts on this socket return fd; }
/* * * LOGIN SECTION * */ int32 connect_client_login(int32 listenfd) { int32 fd = 0; struct sockaddr_in client_address; if ((fd = connect_client(listenfd, client_address)) != -1) { create_session(fd, recv_to_fifo, send_from_fifo, login_parse); session[fd]->client_addr = ntohl(client_address.sin_addr.s_addr); return fd; } return -1; }
int make_listen_bind(uint32 ip, uint16 port) { struct sockaddr_in server_address; int fd; int result; fd = sSocket(AF_INET, SOCK_STREAM, 0); if(fd == -1) { ShowError(read_message("Source.common.make_listen_bind"), error_msg()); exit(EXIT_FAILURE); } if(fd == 0) { // reserved ShowError(read_message("Source.common.make_listen_bind2")); sClose(fd); return -1; } if(fd >= FD_SETSIZE) { // socket number too big ShowError(read_message("Source.common.make_listen_bind3"), fd, FD_SETSIZE); sClose(fd); return -1; } setsocketopts(fd); set_nonblocking(fd, 1); server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = htonl(ip); server_address.sin_port = htons(port); result = sBind(fd, (struct sockaddr *)&server_address, sizeof(server_address)); if(result == SOCKET_ERROR) { ShowError(read_message("Source.common.make_listen_bind4"), fd, error_msg()); exit(EXIT_FAILURE); } result = sListen(fd,5); if(result == SOCKET_ERROR) { ShowError(read_message("Source.common.make_listen_bind5"), fd, error_msg()); exit(EXIT_FAILURE); } if(fd_max <= fd) fd_max = fd + 1; sFD_SET(fd, &readfds); create_session(fd, connect_client, null_send, null_parse); session[fd]->client_addr = 0; // just listens session[fd]->rdata_tick = 0; // disable timeouts on this socket return fd; }
int make_connection(uint32 ip, uint16 port, bool silent) { struct sockaddr_in remote_address; int fd; int result; fd = sSocket(AF_INET, SOCK_STREAM, 0); if(fd == -1) { ShowError(read_message("Source.common.make_connection"), error_msg()); return -1; } if(fd == 0) { // reserved ShowError(read_message("Source.common.make_connection2")); sClose(fd); return -1; } if(fd >= FD_SETSIZE) { // socket number too big ShowError("make_connection: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE); sClose(fd); return -1; } setsocketopts(fd); remote_address.sin_family = AF_INET; remote_address.sin_addr.s_addr = htonl(ip); remote_address.sin_port = htons(port); if(!silent) ShowStatus(read_message("Source.common.make_connect"), CONVIP(ip), port); result = sConnect(fd, (struct sockaddr *)(&remote_address), sizeof(struct sockaddr_in)); if(result == SOCKET_ERROR) { if(!silent) ShowError(read_message("Source.common.make_sConnect"), fd, error_msg()); do_close(fd); return -1; } //Now the socket can be made non-blocking. [Skotlex] set_nonblocking(fd, 1); if(fd_max <= fd) fd_max = fd + 1; sFD_SET(fd,&readfds); create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse); session[fd]->client_addr = ntohl(remote_address.sin_addr.s_addr); return fd; }