void *Routine(void *arg) { Baton *baton(reinterpret_cast<Baton *>(arg)); const mach_header_xx *dyld(Library(baton, "/usr/lib/system/libdyld.dylib")); Dynamic dynamic; cyset(dynamic.dlerror, "_dlerror", dyld); cyset(dynamic.dlsym, "_dlsym", dyld); int (*pthread_detach)(pthread_t); dlset(&dynamic, pthread_detach, "pthread_detach"); pthread_t (*pthread_self)(); dlset(&dynamic, pthread_self, "pthread_self"); pthread_detach(pthread_self()); void *(*dlopen)(const char *, int); dlset(&dynamic, dlopen, "dlopen"); void *handle(dlopen(baton->library, RTLD_LAZY | RTLD_LOCAL)); if (handle == NULL) { dynamic.dlerror(); return NULL; } void (*CYHandleServer)(pid_t); dlset(&dynamic, CYHandleServer, "CYHandleServer", handle); if (CYHandleServer == NULL) { dynamic.dlerror(); return NULL; } CYHandleServer(baton->pid); return NULL; }
void InjectLibrary(pid_t pid) { const char *library(CY_LIBRARY); static const size_t Stack_(8 * 1024); size_t length(strlen(library) + 1), depth(sizeof(Baton) + length); depth = (depth + sizeof(uintptr_t) + 1) / sizeof(uintptr_t) * sizeof(uintptr_t); CYPool pool; uint8_t *local(reinterpret_cast<uint8_t *>(apr_palloc(pool, depth))); Baton *baton(reinterpret_cast<Baton *>(local)); baton->__pthread_set_self = &__pthread_set_self; baton->pthread_create = &pthread_create; baton->pthread_join = &pthread_join; baton->dlopen = &dlopen; baton->dlerror = &dlerror; baton->dlsym = &dlsym; baton->mach_thread_self = &mach_thread_self; baton->thread_terminate = &thread_terminate; baton->pid = getpid(); memcpy(baton->library, library, length); vm_size_t size(depth + Stack_); mach_port_t self(mach_task_self()), task; _krncall(task_for_pid(self, pid, &task)); vm_address_t stack; _krncall(vm_allocate(task, &stack, size, true)); vm_address_t data(stack + Stack_); vm_write(task, data, reinterpret_cast<vm_address_t>(baton), depth); thread_act_t thread; _krncall(thread_create(task, &thread)); thread_state_flavor_t flavor; mach_msg_type_number_t count; size_t push; Trampoline *trampoline; #if defined(__arm__) trampoline = &Trampoline_arm_; arm_thread_state_t state; flavor = ARM_THREAD_STATE; count = ARM_THREAD_STATE_COUNT; push = 0; #elif defined(__i386__) trampoline = &Trampoline_i386_; i386_thread_state_t state; flavor = i386_THREAD_STATE; count = i386_THREAD_STATE_COUNT; push = 5; #elif defined(__x86_64__) trampoline = &Trampoline_x86_64_; x86_thread_state64_t state; flavor = x86_THREAD_STATE64; count = x86_THREAD_STATE64_COUNT; push = 2; #else #error XXX: implement #endif vm_address_t code; _krncall(vm_allocate(task, &code, trampoline->size_, true)); vm_write(task, code, reinterpret_cast<vm_address_t>(trampoline->data_), trampoline->size_); _krncall(vm_protect(task, code, trampoline->size_, false, VM_PROT_READ | VM_PROT_EXECUTE)); /* printf("_ptss:%p\n", baton->__pthread_set_self); printf("dlsym:%p\n", baton->dlsym); printf("code:%zx\n", (size_t) code); */ uint32_t frame[push]; if (sizeof(frame) != 0) memset(frame, 0, sizeof(frame)); memset(&state, 0, sizeof(state)); mach_msg_type_number_t read(count); _krncall(thread_get_state(thread, flavor, reinterpret_cast<thread_state_t>(&state), &read)); _assert(count == count); #if defined(__arm__) state.r[0] = data; state.sp = stack + Stack_; state.pc = code + trampoline->entry_; if ((state.pc & 0x1) != 0) { state.pc &= ~0x1; state.cpsr |= 0x20; } #elif defined(__i386__) frame[1] = data; state.__eip = code + trampoline->entry_; state.__esp = stack + Stack_ - sizeof(frame); #elif defined(__x86_64__) frame[0] = 0xdeadbeef; state.__rdi = data; state.__rip = code + trampoline->entry_; state.__rsp = stack + Stack_ - sizeof(frame); #else #error XXX: implement #endif if (sizeof(frame) != 0) vm_write(task, stack + Stack_ - sizeof(frame), reinterpret_cast<vm_address_t>(frame), sizeof(frame)); _krncall(thread_set_state(thread, flavor, reinterpret_cast<thread_state_t>(&state), count)); _krncall(thread_resume(thread)); _krncall(mach_port_deallocate(self, task)); }
Py::Object pysvn_client::cmd_get_changelist( const Py::Tuple &a_args, const Py::Dict &a_kws ) { static argument_description args_desc[] = { { true, name_path }, { false, name_depth }, { false, name_changelists }, { false, NULL } }; FunctionArguments args( "get_changelists", args_desc, a_args, a_kws ); args.check(); std::string type_error_message; SvnPool pool( m_context ); try { std::string path( args.getUtf8String( name_path ) ); std::string norm_path( svnNormalisedIfPath( path, pool ) ); apr_array_header_t *changelists = NULL; if( args.hasArg( name_changelists ) ) { changelists = arrayOfStringsFromListOfStrings( args.getArg( name_changelists ), pool ); //for (int j = 0; j < changelists->nelts; ++j) //{ // const char *name = ((const char **)changelists->elts)[j]; // std::cout << "QQQ: get changelist=" << name << std::endl; //} } svn_depth_t depth = args.getDepth( name_depth, svn_depth_files ); Py::List changelist_list; try { checkThreadPermission(); PythonAllowThreads permission( m_context ); ChangelistBaton baton( &permission, pool, changelist_list ); svn_error_t *error = svn_client_get_changelists ( norm_path.c_str(), changelists, depth, changelistReceiver, reinterpret_cast<void *>( &baton ), m_context, pool ); permission.allowThisThread(); if( error != NULL ) throw SvnException( error ); } catch( SvnException &e ) { // use callback error over ClientException m_context.checkForError( m_module.client_error ); throw_client_error( e ); } return changelist_list; } catch( Py::TypeError & ) { throw Py::TypeError( type_error_message ); } return Py::None(); }
int main(int argc, char* argv[]) { if(argc < 2){ ADDRESS = "localhost"; }else{ std::string line = argv[1]; int colon_pos = line.find(":"); if(colon_pos != std::string::npos){ ADDRESS = line.substr(0, colon_pos); PORT = std::stoi(line.substr(colon_pos + 1, std::string::npos)); }else{ ADDRESS = line; } } std::cout << ADDRESS << std::endl; std::cout << PORT << std::endl; //start ros thread XInitThreads(); std::thread ros_thread(ros_stuff); //Initialize OSC stuff UdpTransmitSocket transmit_socket( IpEndpointName( ADDRESS.c_str(), PORT ) ); listener = new LRPacketListener(); //listener->registerStringCallback(nothing); listener->registerTransportCallback(sync); listener->registerPlaybackCallback(playbackChanged); listener->registerClipUpdateCallback(loadClip); receive_socket = new UdpListeningReceiveSocket(IpEndpointName( IpEndpointName::ANY_ADDRESS, PORT ), listener); //Set up threads std::thread listen_thread(listen); //interupt quits signal(SIGINT, [](int signum){std::cout << "okay" << std::endl; quit = true; receive_socket->Break(); receive_socket->AsynchronousBreak();}); //conductor listener->registerTransportCallback(update_baton); //SFML sf::Font font; if (!font.loadFromFile("Ubuntu-R.ttf")) { std::cout << "where's the font?" << std::endl; } play_shape.rotate(90); play_shape.setPosition(700, 10); play_shape.setFillColor(sf::Color::Green); stop_shape.setPosition(700, 10); stop_shape.setFillColor(sf::Color::Red); for(int i = 0; i < 50; i++){ sf::CircleShape baton(8, 20); sf::Color color(255, i*255/50, 0, 51*(i-50)*(i-50)/500); baton.setFillColor(color); baton.setPosition(400, 300); baton_trail.push_back(baton); } // select the font transport_text.setFont(font); // font is a sf::Font time_text.setFont(font); offset_text.setFont(font); debug_text.setFont(font); transport_text.setCharacterSize(24); // in pixels, not points! time_text.setCharacterSize(24); offset_text.setCharacterSize(24); debug_text.setCharacterSize(24); transport_text.setColor(sf::Color::White); time_text.setColor(sf::Color::White); offset_text.setColor(sf::Color::White); debug_text.setColor(sf::Color::White); transport_text.setPosition(10, 10); time_text.setPosition(10, 40); offset_text.setPosition(10, 70); debug_text.setPosition(400, 70); // set the string to display transport_text.setString("Hello world"); time_text.setString("waiting..."); offset_text.setString("no offset"); //sfml window sf::ContextSettings settings; settings.antialiasingLevel = 8; sf::RenderWindow window(sf::VideoMode(800, 600), "Terpsichore", sf::Style::Default, settings); window.setVerticalSyncEnabled(true); //request initial information send("/terpsichore", (int)1, transmit_socket); // run the program as long as the window is open while (window.isOpen()) { // check all the window's events that were triggered since the last iteration of the loop sf::Event event; while (window.pollEvent(event)) { // "close requested" event: we close the window if (event.type == sf::Event::Closed){ window.close(); quit = true; receive_socket->Break(); receive_socket->AsynchronousBreak(); } } // clear the window with black color window.clear(sf::Color::Black); // draw everything here... // draw the notes of the currently playing clips double y = 100.0; double scale = 50.0; for(std::map<int, Clip*>::iterator clip_it = listener->clips.begin(); clip_it != listener->clips.end(); clip_it++){ Clip* c = clip_it->second; for(std::multimap<Position, Note>::iterator note_it = c->notes.begin(); note_it != c->notes.end(); note_it++){ Position p = note_it->first; Note n = note_it->second; double x = p.toFloat(listener->transport.timeSignature) * scale + 10; double w = n.duration * scale; double h = n.pitch; sf::RectangleShape noteRect(sf::Vector2f(w, h)); noteRect.setFillColor(sf::Color::Blue); noteRect.setOutlineThickness(2); noteRect.setOutlineColor(sf::Color::Cyan); noteRect.setPosition(x, y); window.draw(noteRect); } y += 80; debug_text.setString(std::to_string(y)); } // window.draw(...); transport_text.setString(transport_string); time_text.setString(time_string); window.draw(time_text); offset_text.setString(offset_string); window.draw(offset_text); window.draw(debug_text); if(playing){ window.draw(play_shape); }else{ window.draw(stop_shape); } //draw the baton point; for(int i = baton_trail.size() - 1; i >= 0; i--){ window.draw(baton_trail.at(i)); } window.draw(transport_text); // end the current frame window.display(); } //stopping threads std::cout << "attempting to join\n"; listen_thread.join(); ros_thread.join(); delete receive_socket; delete listener; return 0; }
// PYSVN_HAS_CLIENT_LOG, PYSVN_HAS_CLIENT_LOG2, PYSVN_HAS_CLIENT_LOG3 version Py::Object pysvn_client::cmd_log( const Py::Tuple &a_args, const Py::Dict &a_kws ) { static argument_description args_desc[] = { { true, name_url_or_path }, { false, name_revision_start }, { false, name_revision_end }, { false, name_discover_changed_paths }, { false, name_strict_node_history }, #if defined( PYSVN_HAS_CLIENT_LOG2 ) || defined( PYSVN_HAS_CLIENT_LOG3 ) { false, name_limit }, #endif #if defined( PYSVN_HAS_CLIENT_LOG3 ) { false, name_peg_revision }, #endif #if defined( PYSVN_HAS_CLIENT_LOG4 ) { false, name_include_merged_revisions }, { false, name_revprops }, #endif { false, NULL } }; FunctionArguments args( "log", args_desc, a_args, a_kws ); args.check(); svn_opt_revision_t revision_start = args.getRevision( name_revision_start, svn_opt_revision_head ); svn_opt_revision_t revision_end = args.getRevision( name_revision_end, svn_opt_revision_number ); bool discover_changed_paths = args.getBoolean( name_discover_changed_paths, false ); bool strict_node_history = args.getBoolean( name_strict_node_history, true ); int limit = args.getInteger( name_limit, 0 ); #if defined( PYSVN_HAS_CLIENT_LOG3 ) svn_opt_revision_t peg_revision = args.getRevision( name_peg_revision, svn_opt_revision_unspecified ); #endif #if defined( PYSVN_HAS_CLIENT_LOG4 ) svn_boolean_t include_merged_revisions = args.getBoolean( name_include_merged_revisions, false ); apr_array_header_t *revprops = NULL; Py::Object py_revprop = args.getArg( name_revprops ); if( py_revprop is not None ) { revprops = arrayOfStringsFromListOfStrings( py_revprop. pool ); } #endif Py::Object url_or_path_obj = args.getArg( name_url_or_path ); Py::List url_or_path_list; if( url_or_path_obj.isList() ) { url_or_path_list = url_or_path_obj; } else { Py::List py_list; py_list.append( url_or_path_obj ); url_or_path_list = py_list; } for( size_t i=0; i<url_or_path_list.size(); i++ ) { Py::Bytes py_path( asUtf8Bytes( url_or_path_list[ i ] ) ); std::string path( py_path.as_std_string() ); bool is_url = is_svn_url( path ); // std::cout << "peg_revision " << peg_revision.kind << " " << peg_revision.value.number << std::endl; // std::cout << "revision_start " << revision_start.kind << " " << revision_start.value.number << std::endl; // std::cout << "revision_end " << revision_end.kind << " " << revision_end.value.number << std::endl; #if defined( PYSVN_HAS_CLIENT_LOG3 ) revisionKindCompatibleCheck( is_url, peg_revision, name_peg_revision, name_url_or_path ); #endif revisionKindCompatibleCheck( is_url, revision_start, name_revision_start, name_url_or_path ); revisionKindCompatibleCheck( is_url, revision_end, name_revision_end, name_url_or_path ); } SvnPool pool( m_context ); apr_array_header_t *targets = targetsFromStringOrList( url_or_path_list, pool ); #if defined( PYSVN_HAS_CLIENT_LOG4 ) Log4Baton baton( permission, pool ); #else std::list<LogEntryInfo> all_entries; #endif try { checkThreadPermission(); PythonAllowThreads permission( m_context ); #if defined( PYSVN_HAS_CLIENT_LOG4 ) svn_error_t *error = svn_client_log4 ( targets, &peg_revision, &revision_start, &revision_end, limit, discover_changed_paths, strict_node_history, include_merged_revisions, revprops, logReceiver, &all_entries, m_context, pool ); #elif defined( PYSVN_HAS_CLIENT_LOG3 ) svn_error_t *error = svn_client_log3 ( targets, &peg_revision, &revision_start, &revision_end, limit, discover_changed_paths, strict_node_history, logReceiver, &all_entries, m_context, pool ); #elif defined( PYSVN_HAS_CLIENT_LOG2 ) svn_error_t *error = svn_client_log2 ( targets, &revision_start, &revision_end, limit, discover_changed_paths, strict_node_history, logReceiver, &all_entries, m_context, pool ); #else svn_error_t *error = svn_client_log ( targets, &revision_start, &revision_end, discover_changed_paths, strict_node_history, logReceiver, &all_entries, m_context, pool ); #endif permission.allowThisThread(); if( error != NULL ) throw SvnException( error ); } catch( SvnException &e ) { // use callback error over ClientException m_context.checkForError( m_module.client_error ); throw_client_error( e ); } apr_time_t now = apr_time_now(); // convert the entries into python objects Py::List entries_list; std::list<LogEntryInfo>::const_iterator entry_it = all_entries.begin(); while( entry_it != all_entries.end() ) { const LogEntryInfo &entry = *entry_it; ++entry_it; Py::Dict entry_dict; entry_dict[name_author] = Py::String( entry.m_author, name_utf8 ); entry_dict[name_date] = toObject( convertStringToTime( entry.m_date, now, pool ) ); entry_dict[name_message] = Py::String( entry.m_message, name_utf8 ); entry_dict[name_revision] = Py::asObject( new pysvn_revision( svn_opt_revision_number, 0, entry.m_revision ) ); Py::List changed_paths_list; std::list<LogChangePathInfo>::const_iterator changed_paths_it = entry.m_changed_paths.begin(); while( changed_paths_it != entry.m_changed_paths.end() ) { const LogChangePathInfo &change_entry = *changed_paths_it; ++changed_paths_it; Py::Dict changed_entry_dict; changed_entry_dict[name_path] = Py::String( change_entry.m_path, name_utf8 ); changed_entry_dict[name_action] = Py::String( &change_entry.m_action, 1 ); changed_entry_dict[name_copyfrom_path] = utf8_string_or_none( change_entry.m_copy_from_path ); if( SVN_IS_VALID_REVNUM( change_entry.m_copy_from_revision ) ) changed_entry_dict[name_copyfrom_revision] = Py::asObject( new pysvn_revision( svn_opt_revision_number, 0, change_entry.m_copy_from_revision ) ); else changed_entry_dict[name_copyfrom_revision] = Py::None(); changed_paths_list.append( m_wrapper_log_changed_path.wrapDict( changed_entry_dict ) ); } entry_dict[name_changed_paths] = changed_paths_list; entries_list.append( m_wrapper_log.wrapDict( entry_dict ) ); } return entries_list; }
// PYSVN_HAS_CLIENT_LOG4 version Py::Object pysvn_client::cmd_log( const Py::Tuple &a_args, const Py::Dict &a_kws ) { static argument_description args_desc[] = { { true, name_url_or_path }, { false, name_revision_start }, { false, name_revision_end }, { false, name_discover_changed_paths }, { false, name_strict_node_history }, { false, name_limit }, { false, name_peg_revision }, { false, name_include_merged_revisions }, { false, name_revprops }, { false, NULL } }; FunctionArguments args( "log", args_desc, a_args, a_kws ); args.check(); SvnPool pool( m_context ); svn_opt_revision_t revision_start = args.getRevision( name_revision_start, svn_opt_revision_head ); svn_opt_revision_t revision_end = args.getRevision( name_revision_end, svn_opt_revision_number ); bool discover_changed_paths = args.getBoolean( name_discover_changed_paths, false ); bool strict_node_history = args.getBoolean( name_strict_node_history, true ); int limit = args.getInteger( name_limit, 0 ); svn_opt_revision_t peg_revision = args.getRevision( name_peg_revision, svn_opt_revision_unspecified ); svn_boolean_t include_merged_revisions = args.getBoolean( name_include_merged_revisions, false ); apr_array_header_t *revprops = NULL; if( args.hasArg( name_revprops ) ) { Py::Object py_revprop = args.getArg( name_revprops ); if( !py_revprop.isNone() ) { revprops = arrayOfStringsFromListOfStrings( py_revprop, pool ); } } Py::Object url_or_path_obj = args.getArg( name_url_or_path ); Py::List url_or_path_list; if( url_or_path_obj.isList() ) { url_or_path_list = url_or_path_obj; } else { Py::List py_list; py_list.append( url_or_path_obj ); url_or_path_list = py_list; } for( size_t i=0; i<url_or_path_list.size(); i++ ) { Py::Bytes py_path( asUtf8Bytes( url_or_path_list[ i ] ) ); std::string path( py_path.as_std_string() ); bool is_url = is_svn_url( path ); revisionKindCompatibleCheck( is_url, peg_revision, name_peg_revision, name_url_or_path ); revisionKindCompatibleCheck( is_url, revision_start, name_revision_start, name_url_or_path ); revisionKindCompatibleCheck( is_url, revision_end, name_revision_end, name_url_or_path ); } apr_array_header_t *targets = targetsFromStringOrList( url_or_path_list, pool ); Py::List log_list; try { checkThreadPermission(); PythonAllowThreads permission( m_context ); Log4Baton baton( &permission, pool, log_list ); baton.m_wrapper_log = &m_wrapper_log; baton.m_wrapper_log_changed_path = &m_wrapper_log_changed_path; #if defined( PYSVN_HAS_CLIENT_LOG5 ) apr_array_header_t *revision_ranges = apr_array_make( pool, 0, sizeof(svn_opt_revision_range_t *) ); svn_opt_revision_range_t *range = reinterpret_cast<svn_opt_revision_range_t *>( apr_palloc( pool, sizeof(*range) ) ); range->start = revision_start; range->end = revision_end; APR_ARRAY_PUSH( revision_ranges, svn_opt_revision_range_t * ) = range; svn_error_t *error = svn_client_log5 ( targets, &peg_revision, revision_ranges, limit, discover_changed_paths, strict_node_history, include_merged_revisions, revprops, log4Receiver, reinterpret_cast<void *>( &baton ), m_context, pool ); #else svn_error_t *error = svn_client_log4 ( targets, &peg_revision, &revision_start, &revision_end, limit, discover_changed_paths, strict_node_history, include_merged_revisions, revprops, log4Receiver, reinterpret_cast<void *>( &baton ), m_context, pool ); #endif permission.allowThisThread(); if( error != NULL ) throw SvnException( error ); } catch( SvnException &e ) { // use callback error over ClientException m_context.checkForError( m_module.client_error ); throw_client_error( e ); } return log_list; }