//-----------------------------------------------------------------------------
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;
}
