void Init_gsl_integration(VALUE module) { VALUE mgsl_integ; mgsl_integ = rb_define_module_under(module, "Integration"); rb_gsl_integration_define_symbols(mgsl_integ); rb_define_method(cgsl_function, "integration_qng", rb_gsl_integration_qng, -1); rb_define_method(cgsl_function, "integration_qag", rb_gsl_integration_qag, -1); rb_define_method(cgsl_function, "integration_qags", rb_gsl_integration_qags, -1); rb_define_method(cgsl_function, "integration_qagp", rb_gsl_integration_qagp, -1); rb_define_method(cgsl_function, "integration_qagi", rb_gsl_integration_qagi, -1); rb_define_method(cgsl_function, "integration_qagiu", rb_gsl_integration_qagiu, -1); rb_define_method(cgsl_function, "integration_qagil", rb_gsl_integration_qagil, -1); rb_define_method(cgsl_function, "integration_qawc", rb_gsl_integration_qawc, -1); rb_define_alias(cgsl_function, "qng", "integration_qng"); rb_define_alias(cgsl_function, "qag", "integration_qag"); rb_define_alias(cgsl_function, "qags", "integration_qags"); rb_define_alias(cgsl_function, "qagp", "integration_qagp"); rb_define_alias(cgsl_function, "qagi", "integration_qagi"); rb_define_alias(cgsl_function, "qagiu", "integration_qagiu"); rb_define_alias(cgsl_function, "qagil", "integration_qagil"); rb_define_alias(cgsl_function, "qawc", "integration_qawc"); cgsl_integration_qaws_table = rb_define_class_under(mgsl_integ, "QAWS_Table", cGSL_Object); rb_define_singleton_method(cgsl_integration_qaws_table, "alloc", rb_gsl_integration_qaws_table_alloc, -1); /* rb_define_singleton_method(cgsl_integration_qaws_table, "new", rb_gsl_integration_qaws_table_alloc, -1);*/ rb_define_method(cgsl_integration_qaws_table, "to_a", rb_gsl_integration_qaws_table_to_a, 0); rb_define_method(cgsl_integration_qaws_table, "set", rb_gsl_integration_qaws_table_set, -1); rb_define_method(rb_cArray, "to_gsl_integration_qaws_table", rb_gsl_ary_to_integration_qaws_table, 0); rb_define_alias(rb_cArray, "to_qaws_table", "to_gsl_integration_qaws_table"); rb_define_method(cgsl_function, "integration_qaws", rb_gsl_integration_qaws, -1); rb_define_alias(cgsl_function, "qaws", "integration_qaws"); cgsl_integration_qawo_table = rb_define_class_under(mgsl_integ, "QAWO_Table", cGSL_Object); rb_define_singleton_method(cgsl_integration_qawo_table, "alloc", rb_gsl_integration_qawo_table_alloc, -1); /* rb_define_singleton_method(cgsl_integration_qawo_table, "new", rb_gsl_integration_qawo_table_alloc, -1);*/ rb_define_method(cgsl_integration_qawo_table, "to_a", rb_gsl_integration_qawo_table_to_a, 0); rb_define_method(rb_cArray, "to_gsl_integration_qawo_table", rb_gsl_ary_to_integration_qawo_table, 0); rb_define_method(cgsl_integration_qawo_table, "set", rb_gsl_integration_qawo_table_set, -1); rb_define_method(cgsl_integration_qawo_table, "set_length", rb_gsl_integration_qawo_table_set_length, 1); rb_define_method(cgsl_function, "integration_qawo", rb_gsl_integration_qawo, -1); rb_define_method(cgsl_function, "integration_qawf", rb_gsl_integration_qawf, -1); rb_define_alias(cgsl_function, "qawo", "integration_qawo"); rb_define_alias(cgsl_function, "qawf", "integration_qawf"); cgsl_integration_workspace = rb_define_class_under(mgsl_integ, "Workspace", cGSL_Object); /* rb_define_singleton_method(cgsl_integration_workspace, "new", rb_gsl_integration_workspace_alloc, -1);*/ rb_define_singleton_method(cgsl_integration_workspace, "alloc", rb_gsl_integration_workspace_alloc, -1); rb_define_method(cgsl_integration_workspace, "limit", rb_gsl_integration_workspace_limit, 0); rb_define_method(cgsl_integration_workspace, "size", rb_gsl_integration_workspace_size, 0); rb_define_method(cgsl_integration_workspace, "nrmax", rb_gsl_integration_workspace_nrmax, 0); rb_define_method(cgsl_integration_workspace, "i", rb_gsl_integration_workspace_i, 0); rb_define_method(cgsl_integration_workspace, "maximum_level", rb_gsl_integration_workspace_maximum_level, 0); rb_define_method(cgsl_integration_workspace, "to_a", rb_gsl_integration_workspace_to_a, 0); rb_define_method(cgsl_integration_workspace, "alist", rb_gsl_integration_workspace_alist, 0); rb_define_method(cgsl_integration_workspace, "blist", rb_gsl_integration_workspace_blist, 0); rb_define_method(cgsl_integration_workspace, "rlist", rb_gsl_integration_workspace_rlist, 0); rb_define_method(cgsl_integration_workspace, "elist", rb_gsl_integration_workspace_elist, 0); /*****/ rb_define_module_function(mgsl_integ, "qng", rb_gsl_integration_qng, -1); rb_define_module_function(mgsl_integ, "qag", rb_gsl_integration_qag, -1); rb_define_module_function(mgsl_integ, "qags", rb_gsl_integration_qags, -1); rb_define_module_function(mgsl_integ, "qagp", rb_gsl_integration_qagp, -1); rb_define_module_function(mgsl_integ, "qagi", rb_gsl_integration_qagi, -1); rb_define_module_function(mgsl_integ, "qagiu", rb_gsl_integration_qagiu, -1); rb_define_module_function(mgsl_integ, "qagil", rb_gsl_integration_qagil, -1); rb_define_module_function(mgsl_integ, "qawc", rb_gsl_integration_qawc, -1); rb_define_module_function(mgsl_integ, "qaws", rb_gsl_integration_qaws, -1); rb_define_module_function(mgsl_integ, "qawo", rb_gsl_integration_qawo, -1); rb_define_module_function(mgsl_integ, "qawf", rb_gsl_integration_qawf, -1); }
void Init_shadow() { rb_sPasswdEntry = rb_struct_define("PasswdEntry", "sp_namp","sp_pwdp","sp_lstchg", "sp_min","sp_max","sp_warn", "sp_inact","sp_expire","sp_flag",0); rb_sGroupEntry = rb_struct_define("GroupEntry", "sg_name","sg_passwd", "sg_adm","sg_mem",0); rb_mShadow = rb_define_module("Shadow"); rb_eFileLock = rb_define_class_under(rb_mShadow,"FileLock",rb_eException); rb_mPasswd = rb_define_module_under(rb_mShadow,"Passwd"); rb_define_const(rb_mPasswd,"Entry",rb_sPasswdEntry); rb_mGroup = rb_define_module_under(rb_mShadow,"Group"); rb_define_const(rb_mGroup,"Entry",rb_sGroupEntry); rb_define_module_function(rb_mPasswd,"setspent",rb_shadow_setspent,0); rb_define_module_function(rb_mPasswd,"endspent",rb_shadow_endspent,0); #ifndef SOLARIS rb_define_module_function(rb_mPasswd,"sgetspent",rb_shadow_sgetspent,1); #endif rb_define_module_function(rb_mPasswd,"fgetspent",rb_shadow_fgetspent,1); rb_define_module_function(rb_mPasswd,"getspent",rb_shadow_getspent,0); rb_define_module_function(rb_mPasswd,"getspnam",rb_shadow_getspnam,1); rb_define_module_function(rb_mPasswd,"putspent",rb_shadow_putspent,2); rb_define_module_function(rb_mPasswd,"lckpwdf",rb_shadow_lckpwdf,0); rb_define_module_function(rb_mPasswd,"lock",rb_shadow_lock,0); rb_define_module_function(rb_mPasswd,"ulckpwdf",rb_shadow_ulckpwdf,0); rb_define_module_function(rb_mPasswd,"unlock",rb_shadow_unlock,0); rb_define_module_function(rb_mPasswd,"lock?",rb_shadow_lock_p,0); };
/* * Some functions to put data to the network with high performance. */ void Init_io2io_c() { M_io2io= rb_define_module("IO2IO"); rb_define_module_function(M_io2io, "do_c", t_do, 3); }
extern "C" void Init_rubyeventmachine() { // Lookup Process::Status for get_subprocess_status VALUE rb_mProcess = rb_const_get(rb_cObject, rb_intern("Process")); rb_cProcStatus = rb_const_get(rb_mProcess, rb_intern("Status")); // Tuck away some symbol values so we don't have to look 'em up every time we need 'em. Intern_at_signature = rb_intern ("@signature"); Intern_at_timers = rb_intern ("@timers"); Intern_at_conns = rb_intern ("@conns"); Intern_at_error_handler = rb_intern("@error_handler"); Intern_event_callback = rb_intern ("event_callback"); Intern_run_deferred_callbacks = rb_intern ("run_deferred_callbacks"); Intern_delete = rb_intern ("delete"); Intern_call = rb_intern ("call"); Intern_receive_data = rb_intern ("receive_data"); Intern_ssl_handshake_completed = rb_intern ("ssl_handshake_completed"); Intern_ssl_verify_peer = rb_intern ("ssl_verify_peer"); Intern_notify_readable = rb_intern ("notify_readable"); Intern_notify_writable = rb_intern ("notify_writable"); Intern_proxy_target_unbound = rb_intern ("proxy_target_unbound"); Intern_proxy_completed = rb_intern ("proxy_completed"); Intern_connection_completed = rb_intern ("connection_completed"); // INCOMPLETE, we need to define class Connections inside module EventMachine // run_machine and run_machine_without_threads are now identical. // Must deprecate the without_threads variant. EmModule = rb_define_module ("EventMachine"); EmConnection = rb_define_class_under (EmModule, "Connection", rb_cObject); rb_define_class_under (EmModule, "NoHandlerForAcceptedConnection", rb_eRuntimeError); EM_eConnectionError = rb_define_class_under (EmModule, "ConnectionError", rb_eRuntimeError); EM_eConnectionNotBound = rb_define_class_under (EmModule, "ConnectionNotBound", rb_eRuntimeError); EM_eUnknownTimerFired = rb_define_class_under (EmModule, "UnknownTimerFired", rb_eRuntimeError); EM_eUnsupported = rb_define_class_under (EmModule, "Unsupported", rb_eRuntimeError); rb_define_module_function (EmModule, "initialize_event_machine", (VALUE(*)(...))t_initialize_event_machine, 0); rb_define_module_function (EmModule, "run_machine", (VALUE(*)(...))t_run_machine_without_threads, 0); rb_define_module_function (EmModule, "run_machine_without_threads", (VALUE(*)(...))t_run_machine_without_threads, 0); rb_define_module_function (EmModule, "add_oneshot_timer", (VALUE(*)(...))t_add_oneshot_timer, 1); rb_define_module_function (EmModule, "start_tcp_server", (VALUE(*)(...))t_start_server, 2); rb_define_module_function (EmModule, "stop_tcp_server", (VALUE(*)(...))t_stop_server, 1); rb_define_module_function (EmModule, "start_unix_server", (VALUE(*)(...))t_start_unix_server, 1); rb_define_module_function (EmModule, "set_tls_parms", (VALUE(*)(...))t_set_tls_parms, 6); rb_define_module_function (EmModule, "start_tls", (VALUE(*)(...))t_start_tls, 1); rb_define_module_function (EmModule, "get_peer_cert", (VALUE(*)(...))t_get_peer_cert, 1); rb_define_module_function (EmModule, "send_data", (VALUE(*)(...))t_send_data, 3); rb_define_module_function (EmModule, "send_datagram", (VALUE(*)(...))t_send_datagram, 5); rb_define_module_function (EmModule, "close_connection", (VALUE(*)(...))t_close_connection, 2); rb_define_module_function (EmModule, "report_connection_error_status", (VALUE(*)(...))t_report_connection_error_status, 1); rb_define_module_function (EmModule, "connect_server", (VALUE(*)(...))t_connect_server, 2); rb_define_module_function (EmModule, "bind_connect_server", (VALUE(*)(...))t_bind_connect_server, 4); rb_define_module_function (EmModule, "connect_unix_server", (VALUE(*)(...))t_connect_unix_server, 1); rb_define_module_function (EmModule, "attach_fd", (VALUE (*)(...))t_attach_fd, 2); rb_define_module_function (EmModule, "detach_fd", (VALUE (*)(...))t_detach_fd, 1); rb_define_module_function (EmModule, "get_sock_opt", (VALUE (*)(...))t_get_sock_opt, 3); rb_define_module_function (EmModule, "set_sock_opt", (VALUE (*)(...))t_set_sock_opt, 4); rb_define_module_function (EmModule, "set_notify_readable", (VALUE (*)(...))t_set_notify_readable, 2); rb_define_module_function (EmModule, "set_notify_writable", (VALUE (*)(...))t_set_notify_writable, 2); rb_define_module_function (EmModule, "is_notify_readable", (VALUE (*)(...))t_is_notify_readable, 1); rb_define_module_function (EmModule, "is_notify_writable", (VALUE (*)(...))t_is_notify_writable, 1); rb_define_module_function (EmModule, "pause_connection", (VALUE (*)(...))t_pause, 1); rb_define_module_function (EmModule, "resume_connection", (VALUE (*)(...))t_resume, 1); rb_define_module_function (EmModule, "connection_paused?", (VALUE (*)(...))t_paused_p, 1); rb_define_module_function (EmModule, "num_close_scheduled", (VALUE (*)(...))t_num_close_scheduled, 0); rb_define_module_function (EmModule, "start_proxy", (VALUE (*)(...))t_start_proxy, 4); rb_define_module_function (EmModule, "stop_proxy", (VALUE (*)(...))t_stop_proxy, 1); rb_define_module_function (EmModule, "get_proxied_bytes", (VALUE (*)(...))t_proxied_bytes, 1); rb_define_module_function (EmModule, "watch_filename", (VALUE (*)(...))t_watch_filename, 1); rb_define_module_function (EmModule, "unwatch_filename", (VALUE (*)(...))t_unwatch_filename, 1); rb_define_module_function (EmModule, "watch_pid", (VALUE (*)(...))t_watch_pid, 1); rb_define_module_function (EmModule, "unwatch_pid", (VALUE (*)(...))t_unwatch_pid, 1); rb_define_module_function (EmModule, "current_time", (VALUE(*)(...))t_get_loop_time, 0); rb_define_module_function (EmModule, "open_udp_socket", (VALUE(*)(...))t_open_udp_socket, 2); rb_define_module_function (EmModule, "read_keyboard", (VALUE(*)(...))t_read_keyboard, 0); rb_define_module_function (EmModule, "release_machine", (VALUE(*)(...))t_release_machine, 0); rb_define_module_function (EmModule, "stop", (VALUE(*)(...))t_stop, 0); rb_define_module_function (EmModule, "signal_loopbreak", (VALUE(*)(...))t_signal_loopbreak, 0); rb_define_module_function (EmModule, "library_type", (VALUE(*)(...))t_library_type, 0); rb_define_module_function (EmModule, "set_timer_quantum", (VALUE(*)(...))t_set_timer_quantum, 1); rb_define_module_function (EmModule, "get_max_timer_count", (VALUE(*)(...))t_get_max_timer_count, 0); rb_define_module_function (EmModule, "set_max_timer_count", (VALUE(*)(...))t_set_max_timer_count, 1); rb_define_module_function (EmModule, "setuid_string", (VALUE(*)(...))t_setuid_string, 1); rb_define_module_function (EmModule, "invoke_popen", (VALUE(*)(...))t_invoke_popen, 1); rb_define_module_function (EmModule, "send_file_data", (VALUE(*)(...))t_send_file_data, 2); rb_define_module_function (EmModule, "get_heartbeat_interval", (VALUE(*)(...))t_get_heartbeat_interval, 0); rb_define_module_function (EmModule, "set_heartbeat_interval", (VALUE(*)(...))t_set_heartbeat_interval, 1); rb_define_module_function (EmModule, "get_idle_time", (VALUE(*)(...))t_get_idle_time, 1); rb_define_module_function (EmModule, "get_peername", (VALUE(*)(...))t_get_peername, 1); rb_define_module_function (EmModule, "get_sockname", (VALUE(*)(...))t_get_sockname, 1); rb_define_module_function (EmModule, "get_subprocess_pid", (VALUE(*)(...))t_get_subprocess_pid, 1); rb_define_module_function (EmModule, "get_subprocess_status", (VALUE(*)(...))t_get_subprocess_status, 1); rb_define_module_function (EmModule, "get_comm_inactivity_timeout", (VALUE(*)(...))t_get_comm_inactivity_timeout, 1); rb_define_module_function (EmModule, "set_comm_inactivity_timeout", (VALUE(*)(...))t_set_comm_inactivity_timeout, 2); rb_define_module_function (EmModule, "get_pending_connect_timeout", (VALUE(*)(...))t_get_pending_connect_timeout, 1); rb_define_module_function (EmModule, "set_pending_connect_timeout", (VALUE(*)(...))t_set_pending_connect_timeout, 2); rb_define_module_function (EmModule, "set_rlimit_nofile", (VALUE(*)(...))t_set_rlimit_nofile, 1); rb_define_module_function (EmModule, "get_connection_count", (VALUE(*)(...))t_get_connection_count, 0); rb_define_module_function (EmModule, "epoll", (VALUE(*)(...))t__epoll, 0); rb_define_module_function (EmModule, "epoll=", (VALUE(*)(...))t__epoll_set, 1); rb_define_module_function (EmModule, "epoll?", (VALUE(*)(...))t__epoll_p, 0); rb_define_module_function (EmModule, "kqueue", (VALUE(*)(...))t__kqueue, 0); rb_define_module_function (EmModule, "kqueue=", (VALUE(*)(...))t__kqueue_set, 1); rb_define_module_function (EmModule, "kqueue?", (VALUE(*)(...))t__kqueue_p, 0); rb_define_module_function (EmModule, "ssl?", (VALUE(*)(...))t__ssl_p, 0); rb_define_method (EmConnection, "get_outbound_data_size", (VALUE(*)(...))conn_get_outbound_data_size, 0); rb_define_method (EmConnection, "associate_callback_target", (VALUE(*)(...))conn_associate_callback_target, 1); rb_define_const (EmModule, "TimerFired", INT2NUM(100)); rb_define_const (EmModule, "ConnectionData", INT2NUM(101)); rb_define_const (EmModule, "ConnectionUnbound", INT2NUM(102)); rb_define_const (EmModule, "ConnectionAccepted", INT2NUM(103)); rb_define_const (EmModule, "ConnectionCompleted", INT2NUM(104)); rb_define_const (EmModule, "LoopbreakSignalled", INT2NUM(105)); rb_define_const (EmModule, "ConnectionNotifyReadable", INT2NUM(106)); rb_define_const (EmModule, "ConnectionNotifyWritable", INT2NUM(107)); rb_define_const (EmModule, "SslHandshakeCompleted", INT2NUM(108)); }
void Init_gsl_sf_gamma(VALUE module) { rb_define_const(module, "GAMMA_XMAX", NUM2DBL(GSL_SF_GAMMA_XMAX)); rb_define_module_function(module, "gamma", rb_gsl_sf_gamma, 1); rb_define_module_function(module, "gamma_e", rb_gsl_sf_gamma_e, 1); rb_define_module_function(module, "lngamma", rb_gsl_sf_lngamma, 1); rb_define_module_function(module, "lngamma_e", rb_gsl_sf_lngamma_e, 1); rb_define_module_function(module, "lngamma_sgn_e", rb_gsl_sf_lngamma_sgn_e, 1); rb_define_module_function(module, "gammastar", rb_gsl_sf_gammastar, 1); rb_define_module_function(module, "gammastar_e", rb_gsl_sf_gammastar_e, 1); rb_define_module_function(module, "gammainv", rb_gsl_sf_gammainv, 1); rb_define_module_function(module, "gammainv_e", rb_gsl_sf_gammainv_e, 1); rb_define_module_function(module, "lngamma_complex_e", rb_gsl_sf_lngamma_complex_e, -1); rb_define_module_function(module, "taylorcoeff", rb_gsl_sf_taylorcoeff, 2); rb_define_module_function(module, "taylorcoeff_e", rb_gsl_sf_taylorcoeff_e, 2); rb_define_module_function(module, "fact", rb_gsl_sf_fact, 1); rb_define_module_function(module, "fact_e", rb_gsl_sf_fact_e, 1); rb_define_module_function(module, "doublefact", rb_gsl_sf_doublefact, 1); rb_define_module_function(module, "doublefact_e", rb_gsl_sf_doublefact_e, 1); rb_define_module_function(module, "lnfact", rb_gsl_sf_lnfact, 1); rb_define_module_function(module, "lnfact_e", rb_gsl_sf_lnfact_e, 1); rb_define_module_function(module, "lndoublefact", rb_gsl_sf_lndoublefact, 1); rb_define_module_function(module, "lndoublefact_e", rb_gsl_sf_lndoublefact_e, 1); rb_define_module_function(module, "choose", rb_gsl_sf_choose, 2); rb_define_module_function(module, "choose_e", rb_gsl_sf_choose_e, 2); rb_define_module_function(module, "lnchoose", rb_gsl_sf_lnchoose, 2); rb_define_module_function(module, "lnchoose_e", rb_gsl_sf_lnchoose_e, 2); rb_define_module_function(module, "poch", rb_gsl_sf_poch, 2); rb_define_module_function(module, "poch_e", rb_gsl_sf_poch_e, 2); rb_define_module_function(module, "lnpoch", rb_gsl_sf_lnpoch, 2); rb_define_module_function(module, "lnpoch_e", rb_gsl_sf_lnpoch_e, 2); rb_define_module_function(module, "lnpoch_sgn_e", rb_gsl_sf_lnpoch_sgn_e, 2); rb_define_module_function(module, "pochrel", rb_gsl_sf_pochrel, 2); rb_define_module_function(module, "pochrel_e", rb_gsl_sf_pochrel_e, 2); rb_define_module_function(module, "gamma_inc_P", rb_gsl_sf_gamma_inc_P, 2); rb_define_module_function(module, "gamma_inc_P_e", rb_gsl_sf_gamma_inc_P_e, 2); rb_define_module_function(module, "gamma_inc_Q", rb_gsl_sf_gamma_inc_Q, 2); rb_define_module_function(module, "gamma_inc_Q_e", rb_gsl_sf_gamma_inc_Q_e, 2); rb_define_module_function(module, "gamma_inc", rb_gsl_sf_gamma_inc, 2); #ifdef GSL_1_4_LATER rb_define_module_function(module, "gamma_inc_e", rb_gsl_sf_gamma_inc_e, 2); #endif rb_define_module_function(module, "beta", rb_gsl_sf_beta, 2); rb_define_module_function(module, "beta_e", rb_gsl_sf_beta_e, 2); rb_define_module_function(module, "lnbeta", rb_gsl_sf_lnbeta, 2); rb_define_module_function(module, "lnbeta_e", rb_gsl_sf_lnbeta_e, 2); rb_define_module_function(module, "beta_inc", rb_gsl_sf_beta_inc, 3); rb_define_module_function(module, "beta_inc_e", rb_gsl_sf_beta_inc_e, 3); rb_define_module_function(module, "bincoef", rb_gsl_sf_bincoef, 2); }
void Init_usbbasics() { module = rb_define_module("USB"); cException = rb_define_class_under(module, "UsbException", rb_eStandardError); cDevice = rb_define_class_under(module, "Device", rb_cObject); rb_define_module_function(module, "load_devices", load_devices, 0); rb_define_method(cDevice, "filename", device_filename, 0); rb_define_method(cDevice, "dirname", device_dirname, 0); rb_define_method(cDevice, "device_num", device_device_num, 0); rb_define_method(cDevice, "location", device_location, 0); rb_define_method(cDevice, "children", device_children, 0); rb_define_method(cDevice, "usb_version", device_usb_version, 0); rb_define_method(cDevice, "device_version", device_device_version, 0); rb_define_method(cDevice, "vendor_id", device_vendor_id, 0); rb_define_method(cDevice, "product_id", device_product_id, 0); rb_define_method(cDevice, "device_class", device_device_class, 0); rb_define_method(cDevice, "device_subclass", device_device_subclass, 0); rb_define_method(cDevice, "device_protocol", device_device_protocol, 0); rb_define_method(cDevice, "product_name", device_product_name, 0); rb_define_method(cDevice, "manufacturer", device_manufacturer, 0); rb_define_method(cDevice, "serial_number", device_serial_number, 0); rb_define_method(cDevice, "max_packet_size_for_endpoint_0", device_max_packet_size_for_endpoint_0, 0); rb_define_method(cDevice, "load_configurations", device_configurations, 0); rb_define_method(cDevice, "current_configuration_value", device_current_configuration_value, 0); rb_define_method(cDevice, "open?", device_is_open, 0); rb_define_method(cDevice, "open", device_open, 0); rb_define_method(cDevice, "close", device_close, 0); cEndpoint = rb_define_class_under(module, "Endpoint", rb_cObject); rb_define_method(cEndpoint, "type", endpoint_type, 0); rb_define_method(cEndpoint, "output?", endpoint_is_output, 0); rb_define_method(cEndpoint, "input?", endpoint_is_input, 0); rb_define_method(cEndpoint, "number", endpoint_number, 0); rb_define_method(cEndpoint, "max_packet_size", endpoint_max_packet_size, 0); rb_define_method(cEndpoint, "interval", endpoint_interval, 0); rb_define_method(cEndpoint, "start_interrupt_listening", endpoint_start_listening, 0); rb_define_method(cEndpoint, "stop_interrupt_listening", endpoint_stop_listening, 0); rb_define_method(cEndpoint, "next_interrupt_or_nil", endpoint_next_interrupt_or_nil, 0); cInterface = rb_define_class_under(module, "Interface", rb_cObject); rb_define_method(cInterface, "load_endpoints", interface_endpoints, 0); rb_define_method(cInterface, "interface_class", interface_interface_class, 0); rb_define_method(cInterface, "current_alternative", interface_current_alternative, 0); rb_define_method(cInterface, "interface_string", interface_interface_string, 0); rb_define_method(cInterface, "subclass", interface_subclass, 0); rb_define_method(cInterface, "protocol", interface_protocol, 0); rb_define_method(cInterface, "alternate_setting", interface_alternate_setting, 0); rb_define_method(cInterface, "number", interface_number, 0); rb_define_method(cInterface, "claimable?", interface_is_claimable, 0); rb_define_method(cInterface, "detach_kernel", interface_detach_kernel, 0); cConfiguration = rb_define_class_under(module, "Configuration", rb_cObject); rb_define_method(cConfiguration, "load_interfaces", configuration_interfaces, 0); rb_define_method(cConfiguration, "value", configuration_value, 0); rb_define_method(cConfiguration, "self_powered?", configuration_is_self_powered, 0); rb_define_method(cConfiguration, "remote_wakeup?", configuration_supports_remote_wakeup, 0); rb_define_method(cConfiguration, "max_power", configuration_max_power, 0); MACRO_MAP_CLASS(cDevice); NEW_MACRO_MAP(cDevice, "class_codes"); ADD_MACRO_MAPPING(cDevice, "class_codes", USB_CLASS_PER_INTERFACE); ADD_MACRO_MAPPING(cDevice, "class_codes", USB_CLASS_AUDIO); ADD_MACRO_MAPPING(cDevice, "class_codes", USB_CLASS_COMM); ADD_MACRO_MAPPING(cDevice, "class_codes", USB_CLASS_HID); ADD_MACRO_MAPPING(cDevice, "class_codes", USB_CLASS_PRINTER); ADD_MACRO_MAPPING(cDevice, "class_codes", USB_CLASS_PTP); ADD_MACRO_MAPPING(cDevice, "class_codes", USB_CLASS_MASS_STORAGE); ADD_MACRO_MAPPING(cDevice, "class_codes", USB_CLASS_HUB); ADD_MACRO_MAPPING(cDevice, "class_codes", USB_CLASS_DATA); ADD_MACRO_MAPPING(cDevice, "class_codes", USB_CLASS_VENDOR_SPEC); NEW_MACRO_MAP(cDevice, "endpoint_types"); ADD_MACRO_MAPPING(cDevice, "endpoint_types", USB_ENDPOINT_TYPE_CONTROL); ADD_MACRO_MAPPING(cDevice, "endpoint_types", USB_ENDPOINT_TYPE_ISOCHRONOUS); ADD_MACRO_MAPPING(cDevice, "endpoint_types", USB_ENDPOINT_TYPE_BULK); ADD_MACRO_MAPPING(cDevice, "endpoint_types", USB_ENDPOINT_TYPE_INTERRUPT); usb_init(); }
void Init_tag_parser() { TagParser = rb_define_module("TagParser"); rb_define_module_function(TagParser, "parse_tags", parse_tags, 3); }
/* * INIT */ void Init_ossl_cipher(void) { #if 0 mOSSL = rb_define_module("OpenSSL"); /* let rdoc know about mOSSL */ #endif /* Document-class: OpenSSL::Cipher * * Provides symmetric algorithms for encryption and decryption. The * algorithms that are available depend on the particular version * of OpenSSL that is installed. * * === Listing all supported algorithms * * A list of supported algorithms can be obtained by * * puts OpenSSL::Cipher.ciphers * * === Instantiating a Cipher * * There are several ways to create a Cipher instance. Generally, a * Cipher algorithm is categorized by its name, the key length in bits * and the cipher mode to be used. The most generic way to create a * Cipher is the following * * cipher = OpenSSL::Cipher.new('<name>-<key length>-<mode>') * * That is, a string consisting of the hyphenated concatenation of the * individual components name, key length and mode. Either all uppercase * or all lowercase strings may be used, for example: * * cipher = OpenSSL::Cipher.new('AES-128-CBC') * * For each algorithm supported, there is a class defined under the * Cipher class that goes by the name of the cipher, e.g. to obtain an * instance of AES, you could also use * * # these are equivalent * cipher = OpenSSL::Cipher::AES.new(128, :CBC) * cipher = OpenSSL::Cipher::AES.new(128, 'CBC') * cipher = OpenSSL::Cipher::AES.new('128-CBC') * * Finally, due to its wide-spread use, there are also extra classes * defined for the different key sizes of AES * * cipher = OpenSSL::Cipher::AES128.new(:CBC) * cipher = OpenSSL::Cipher::AES192.new(:CBC) * cipher = OpenSSL::Cipher::AES256.new(:CBC) * * === Choosing either encryption or decryption mode * * Encryption and decryption are often very similar operations for * symmetric algorithms, this is reflected by not having to choose * different classes for either operation, both can be done using the * same class. Still, after obtaining a Cipher instance, we need to * tell the instance what it is that we intend to do with it, so we * need to call either * * cipher.encrypt * * or * * cipher.decrypt * * on the Cipher instance. This should be the first call after creating * the instance, otherwise configuration that has already been set could * get lost in the process. * * === Choosing a key * * Symmetric encryption requires a key that is the same for the encrypting * and for the decrypting party and after initial key establishment should * be kept as private information. There are a lot of ways to create * insecure keys, the most notable is to simply take a password as the key * without processing the password further. A simple and secure way to * create a key for a particular Cipher is * * cipher = OpenSSL::AES256.new(:CFB) * cipher.encrypt * key = cipher.random_key # also sets the generated key on the Cipher * * If you absolutely need to use passwords as encryption keys, you * should use Password-Based Key Derivation Function 2 (PBKDF2) by * generating the key with the help of the functionality provided by * OpenSSL::PKCS5.pbkdf2_hmac_sha1 or OpenSSL::PKCS5.pbkdf2_hmac. * * Although there is Cipher#pkcs5_keyivgen, its use is deprecated and * it should only be used in legacy applications because it does not use * the newer PKCS#5 v2 algorithms. * * === Choosing an IV * * The cipher modes CBC, CFB, OFB and CTR all need an "initialization * vector", or short, IV. ECB mode is the only mode that does not require * an IV, but there is almost no legitimate use case for this mode * because of the fact that it does not sufficiently hide plaintext * patterns. Therefore * * <b>You should never use ECB mode unless you are absolutely sure that * you absolutely need it</b> * * Because of this, you will end up with a mode that explicitly requires * an IV in any case. Note that for backwards compatibility reasons, * setting an IV is not explicitly mandated by the Cipher API. If not * set, OpenSSL itself defaults to an all-zeroes IV ("\\0", not the * character). Although the IV can be seen as public information, i.e. * it may be transmitted in public once generated, it should still stay * unpredictable to prevent certain kinds of attacks. Therefore, ideally * * <b>Always create a secure random IV for every encryption of your * Cipher</b> * * A new, random IV should be created for every encryption of data. Think * of the IV as a nonce (number used once) - it's public but random and * unpredictable. A secure random IV can be created as follows * * cipher = ... * cipher.encrypt * key = cipher.random_key * iv = cipher.random_iv # also sets the generated IV on the Cipher * * Although the key is generally a random value, too, it is a bad choice * as an IV. There are elaborate ways how an attacker can take advantage * of such an IV. As a general rule of thumb, exposing the key directly * or indirectly should be avoided at all cost and exceptions only be * made with good reason. * * === Calling Cipher#final * * ECB (which should not be used) and CBC are both block-based modes. * This means that unlike for the other streaming-based modes, they * operate on fixed-size blocks of data, and therefore they require a * "finalization" step to produce or correctly decrypt the last block of * data by appropriately handling some form of padding. Therefore it is * essential to add the output of OpenSSL::Cipher#final to your * encryption/decryption buffer or you will end up with decryption errors * or truncated data. * * Although this is not really necessary for streaming-mode ciphers, it is * still recommended to apply the same pattern of adding the output of * Cipher#final there as well - it also enables you to switch between * modes more easily in the future. * * === Encrypting and decrypting some data * * data = "Very, very confidential data" * * cipher = OpenSSL::Cipher::AES.new(128, :CBC) * cipher.encrypt * key = cipher.random_key * iv = cipher.random_iv * * encrypted = cipher.update(data) + cipher.final * ... * decipher = OpenSSL::Cipher::AES.new(128, :CBC) * decipher.decrypt * decipher.key = key * decipher.iv = iv * * plain = decipher.update(encrypted) + decipher.final * * puts data == plain #=> true * * === Authenticated Encryption and Associated Data (AEAD) * * If the OpenSSL version used supports it, an Authenticated Encryption * mode (such as GCM or CCM) should always be preferred over any * unauthenticated mode. Currently, OpenSSL supports AE only in combination * with Associated Data (AEAD) where additional associated data is included * in the encryption process to compute a tag at the end of the encryption. * This tag will also be used in the decryption process and by verifying * its validity, the authenticity of a given ciphertext is established. * * This is superior to unauthenticated modes in that it allows to detect * if somebody effectively changed the ciphertext after it had been * encrypted. This prevents malicious modifications of the ciphertext that * could otherwise be exploited to modify ciphertexts in ways beneficial to * potential attackers. * * If no associated data is needed for encryption and later decryption, * the OpenSSL library still requires a value to be set - "" may be used in * case none is available. An example using the GCM (Galois Counter Mode): * * cipher = OpenSSL::Cipher::AES.new(128, :GCM) * cipher.encrypt * key = cipher.random_key * iv = cipher.random_iv * cipher.auth_data = "" * * encrypted = cipher.update(data) + cipher.final * tag = cipher.auth_tag * * decipher = OpenSSL::Cipher::AES.new(128, :GCM) * decipher.decrypt * decipher.key = key * decipher.iv = iv * decipher.auth_tag = tag * decipher.auth_data = "" * * plain = decipher.update(encrypted) + decipher.final * * puts data == plain #=> true */ cCipher = rb_define_class_under(mOSSL, "Cipher", rb_cObject); eCipherError = rb_define_class_under(cCipher, "CipherError", eOSSLError); rb_define_alloc_func(cCipher, ossl_cipher_alloc); rb_define_copy_func(cCipher, ossl_cipher_copy); rb_define_module_function(cCipher, "ciphers", ossl_s_ciphers, 0); rb_define_method(cCipher, "initialize", ossl_cipher_initialize, 1); rb_define_method(cCipher, "reset", ossl_cipher_reset, 0); rb_define_method(cCipher, "encrypt", ossl_cipher_encrypt, -1); rb_define_method(cCipher, "decrypt", ossl_cipher_decrypt, -1); rb_define_method(cCipher, "pkcs5_keyivgen", ossl_cipher_pkcs5_keyivgen, -1); rb_define_method(cCipher, "update", ossl_cipher_update, -1); rb_define_method(cCipher, "final", ossl_cipher_final, 0); rb_define_method(cCipher, "name", ossl_cipher_name, 0); rb_define_method(cCipher, "key=", ossl_cipher_set_key, 1); rb_define_method(cCipher, "auth_data=", ossl_cipher_set_auth_data, 1); rb_define_method(cCipher, "auth_tag=", ossl_cipher_set_auth_tag, 1); rb_define_method(cCipher, "auth_tag", ossl_cipher_get_auth_tag, -1); rb_define_method(cCipher, "authenticated?", ossl_cipher_is_authenticated, 0); rb_define_method(cCipher, "key_len=", ossl_cipher_set_key_length, 1); rb_define_method(cCipher, "key_len", ossl_cipher_key_length, 0); rb_define_method(cCipher, "iv=", ossl_cipher_set_iv, 1); rb_define_method(cCipher, "iv_len", ossl_cipher_iv_length, 0); rb_define_method(cCipher, "block_size", ossl_cipher_block_size, 0); rb_define_method(cCipher, "padding=", ossl_cipher_set_padding, 1); }
void Init_chaos_calendar() { mChaosCalendar = rb_define_module("ChaosCalendar"); rb_define_module_function(mChaosCalendar, "occurrences", occurrences, 3); rb_define_module_function(mChaosCalendar, "duration_to_fixnum", duration_to_fixnum, 1); }
void Init_msp_curvy_slider(VALUE mNewton) { VALUE mCurvySlider = rb_define_module_under(mNewton, "CurvySlider"); rb_define_module_function(mCurvySlider, "is_valid?", VALUEFUNC(MSNewton::CurvySlider::is_valid), 1); rb_define_module_function(mCurvySlider, "create", VALUEFUNC(MSNewton::CurvySlider::create), 1); rb_define_module_function(mCurvySlider, "add_point", VALUEFUNC(MSNewton::CurvySlider::add_point), 2); rb_define_module_function(mCurvySlider, "remove_point", VALUEFUNC(MSNewton::CurvySlider::remove_point), 2); rb_define_module_function(mCurvySlider, "get_points", VALUEFUNC(MSNewton::CurvySlider::get_points), 1); rb_define_module_function(mCurvySlider, "get_points_size", VALUEFUNC(MSNewton::CurvySlider::get_points), 1); rb_define_module_function(mCurvySlider, "clear_points", VALUEFUNC(MSNewton::CurvySlider::clear_points), 2); rb_define_module_function(mCurvySlider, "get_point_position", VALUEFUNC(MSNewton::CurvySlider::get_point_position), 2); rb_define_module_function(mCurvySlider, "set_point_position", VALUEFUNC(MSNewton::CurvySlider::set_point_position), 3); rb_define_module_function(mCurvySlider, "get_length", VALUEFUNC(MSNewton::CurvySlider::get_length), 1); rb_define_module_function(mCurvySlider, "get_cur_position", VALUEFUNC(MSNewton::CurvySlider::get_cur_position), 1); rb_define_module_function(mCurvySlider, "get_cur_velocity", VALUEFUNC(MSNewton::CurvySlider::get_cur_velocity), 1); rb_define_module_function(mCurvySlider, "get_cur_acceleration", VALUEFUNC(MSNewton::CurvySlider::get_cur_acceleration), 1); rb_define_module_function(mCurvySlider, "get_cur_point", VALUEFUNC(MSNewton::CurvySlider::get_cur_point), 1); rb_define_module_function(mCurvySlider, "get_cur_vector", VALUEFUNC(MSNewton::CurvySlider::get_cur_vector), 1); rb_define_module_function(mCurvySlider, "get_cur_tangent", VALUEFUNC(MSNewton::CurvySlider::get_cur_tangent), 1); rb_define_module_function(mCurvySlider, "get_linear_friction", VALUEFUNC(MSNewton::CurvySlider::get_linear_friction), 1); rb_define_module_function(mCurvySlider, "set_linear_friction", VALUEFUNC(MSNewton::CurvySlider::set_linear_friction), 2); rb_define_module_function(mCurvySlider, "get_angular_friction", VALUEFUNC(MSNewton::CurvySlider::get_angular_friction), 1); rb_define_module_function(mCurvySlider, "set_angular_friction", VALUEFUNC(MSNewton::CurvySlider::set_angular_friction), 2); rb_define_module_function(mCurvySlider, "get_controller", VALUEFUNC(MSNewton::CurvySlider::get_controller), 1); rb_define_module_function(mCurvySlider, "set_controller", VALUEFUNC(MSNewton::CurvySlider::set_controller), 2); rb_define_module_function(mCurvySlider, "loop_enabled?", VALUEFUNC(MSNewton::CurvySlider::loop_enabled), 1); rb_define_module_function(mCurvySlider, "enable_loop", VALUEFUNC(MSNewton::CurvySlider::enable_loop), 2); rb_define_module_function(mCurvySlider, "alignment_enabled?", VALUEFUNC(MSNewton::CurvySlider::alignment_enabled), 1); rb_define_module_function(mCurvySlider, "enable_alignment", VALUEFUNC(MSNewton::CurvySlider::enable_alignment), 2); rb_define_module_function(mCurvySlider, "rotation_enabled?", VALUEFUNC(MSNewton::CurvySlider::rotation_enabled), 1); rb_define_module_function(mCurvySlider, "enable_rotation", VALUEFUNC(MSNewton::CurvySlider::enable_rotation), 2); rb_define_module_function(mCurvySlider, "get_info_by_pos", VALUEFUNC(MSNewton::CurvySlider::get_info_by_pos), 2); }
void InitVM_Math(void) { rb_mMath = rb_define_module("Math"); rb_eMathDomainError = rb_define_class_under(rb_mMath, "DomainError", rb_eStandardError); #ifdef M_PI /* Definition of the mathematical constant PI as a Float number. */ rb_define_const(rb_mMath, "PI", DBL2NUM(M_PI)); #else rb_define_const(rb_mMath, "PI", DBL2NUM(atan(1.0)*4.0)); #endif #ifdef M_E /* Definition of the mathematical constant E (e) as a Float number. */ rb_define_const(rb_mMath, "E", DBL2NUM(M_E)); #else rb_define_const(rb_mMath, "E", DBL2NUM(exp(1.0))); #endif rb_define_module_function(rb_mMath, "atan2", math_atan2, 2); rb_define_module_function(rb_mMath, "cos", math_cos, 1); rb_define_module_function(rb_mMath, "sin", math_sin, 1); rb_define_module_function(rb_mMath, "tan", math_tan, 1); rb_define_module_function(rb_mMath, "acos", math_acos, 1); rb_define_module_function(rb_mMath, "asin", math_asin, 1); rb_define_module_function(rb_mMath, "atan", math_atan, 1); rb_define_module_function(rb_mMath, "cosh", math_cosh, 1); rb_define_module_function(rb_mMath, "sinh", math_sinh, 1); rb_define_module_function(rb_mMath, "tanh", math_tanh, 1); rb_define_module_function(rb_mMath, "acosh", math_acosh, 1); rb_define_module_function(rb_mMath, "asinh", math_asinh, 1); rb_define_module_function(rb_mMath, "atanh", math_atanh, 1); rb_define_module_function(rb_mMath, "exp", math_exp, 1); rb_define_module_function(rb_mMath, "log", math_log, -1); rb_define_module_function(rb_mMath, "log2", math_log2, 1); rb_define_module_function(rb_mMath, "log10", math_log10, 1); rb_define_module_function(rb_mMath, "sqrt", math_sqrt, 1); rb_define_module_function(rb_mMath, "cbrt", math_cbrt, 1); rb_define_module_function(rb_mMath, "frexp", math_frexp, 1); rb_define_module_function(rb_mMath, "ldexp", math_ldexp, 2); rb_define_module_function(rb_mMath, "hypot", math_hypot, 2); rb_define_module_function(rb_mMath, "erf", math_erf, 1); rb_define_module_function(rb_mMath, "erfc", math_erfc, 1); rb_define_module_function(rb_mMath, "gamma", math_gamma, 1); rb_define_module_function(rb_mMath, "lgamma", math_lgamma, 1); }
/* * OpenSSL provides SSL, TLS and general purpose cryptography. It wraps the * OpenSSL[http://www.openssl.org/] library. * * = Install * * OpenSSL comes bundled with the Standard Library of Ruby. * * This means the OpenSSL extension is compiled with Ruby and packaged on * build. During compile time, Ruby will need to link against the OpenSSL * library on your system. However, you cannot use openssl provided by Apple to * build standard library openssl. * * If you use OSX, you should install another openssl and run ```./configure * --with-openssl-dir=/path/to/another-openssl```. For Homebrew user, run `brew * install openssl` and then ```./configure --with-openssl-dir=`brew --prefix * openssl` ```. * * = Examples * * All examples assume you have loaded OpenSSL with: * * require 'openssl' * * These examples build atop each other. For example the key created in the * next is used in throughout these examples. * * == Keys * * === Creating a Key * * This example creates a 2048 bit RSA keypair and writes it to the current * directory. * * key = OpenSSL::PKey::RSA.new 2048 * * open 'private_key.pem', 'w' do |io| io.write key.to_pem end * open 'public_key.pem', 'w' do |io| io.write key.public_key.to_pem end * * === Exporting a Key * * Keys saved to disk without encryption are not secure as anyone who gets * ahold of the key may use it unless it is encrypted. In order to securely * export a key you may export it with a pass phrase. * * cipher = OpenSSL::Cipher.new 'AES-128-CBC' * pass_phrase = 'my secure pass phrase goes here' * * key_secure = key.export cipher, pass_phrase * * open 'private.secure.pem', 'w' do |io| * io.write key_secure * end * * OpenSSL::Cipher.ciphers returns a list of available ciphers. * * === Loading a Key * * A key can also be loaded from a file. * * key2 = OpenSSL::PKey::RSA.new File.read 'private_key.pem' * key2.public? # => true * * or * * key3 = OpenSSL::PKey::RSA.new File.read 'public_key.pem' * key3.private? # => false * * === Loading an Encrypted Key * * OpenSSL will prompt you for your pass phrase when loading an encrypted key. * If you will not be able to type in the pass phrase you may provide it when * loading the key: * * key4_pem = File.read 'private.secure.pem' * key4 = OpenSSL::PKey::RSA.new key4_pem, pass_phrase * * == RSA Encryption * * RSA provides encryption and decryption using the public and private keys. * You can use a variety of padding methods depending upon the intended use of * encrypted data. * * === Encryption & Decryption * * Asymmetric public/private key encryption is slow and victim to attack in * cases where it is used without padding or directly to encrypt larger chunks * of data. Typical use cases for RSA encryption involve "wrapping" a symmetric * key with the public key of the recipient who would "unwrap" that symmetric * key again using their private key. * The following illustrates a simplified example of such a key transport * scheme. It shouldn't be used in practice, though, standardized protocols * should always be preferred. * * wrapped_key = key.public_encrypt key * * A symmetric key encrypted with the public key can only be decrypted with * the corresponding private key of the recipient. * * original_key = key.private_decrypt wrapped_key * * By default PKCS#1 padding will be used, but it is also possible to use * other forms of padding, see PKey::RSA for further details. * * === Signatures * * Using "private_encrypt" to encrypt some data with the private key is * equivalent to applying a digital signature to the data. A verifying * party may validate the signature by comparing the result of decrypting * the signature with "public_decrypt" to the original data. However, * OpenSSL::PKey already has methods "sign" and "verify" that handle * digital signatures in a standardized way - "private_encrypt" and * "public_decrypt" shouldn't be used in practice. * * To sign a document, a cryptographically secure hash of the document is * computed first, which is then signed using the private key. * * digest = OpenSSL::Digest::SHA256.new * signature = key.sign digest, document * * To validate the signature, again a hash of the document is computed and * the signature is decrypted using the public key. The result is then * compared to the hash just computed, if they are equal the signature was * valid. * * digest = OpenSSL::Digest::SHA256.new * if key.verify digest, signature, document * puts 'Valid' * else * puts 'Invalid' * end * * == PBKDF2 Password-based Encryption * * If supported by the underlying OpenSSL version used, Password-based * Encryption should use the features of PKCS5. If not supported or if * required by legacy applications, the older, less secure methods specified * in RFC 2898 are also supported (see below). * * PKCS5 supports PBKDF2 as it was specified in PKCS#5 * v2.0[http://www.rsa.com/rsalabs/node.asp?id=2127]. It still uses a * password, a salt, and additionally a number of iterations that will * slow the key derivation process down. The slower this is, the more work * it requires being able to brute-force the resulting key. * * === Encryption * * The strategy is to first instantiate a Cipher for encryption, and * then to generate a random IV plus a key derived from the password * using PBKDF2. PKCS #5 v2.0 recommends at least 8 bytes for the salt, * the number of iterations largely depends on the hardware being used. * * cipher = OpenSSL::Cipher.new 'AES-128-CBC' * cipher.encrypt * iv = cipher.random_iv * * pwd = 'some hopefully not to easily guessable password' * salt = OpenSSL::Random.random_bytes 16 * iter = 20000 * key_len = cipher.key_len * digest = OpenSSL::Digest::SHA256.new * * key = OpenSSL::PKCS5.pbkdf2_hmac(pwd, salt, iter, key_len, digest) * cipher.key = key * * Now encrypt the data: * * encrypted = cipher.update document * encrypted << cipher.final * * === Decryption * * Use the same steps as before to derive the symmetric AES key, this time * setting the Cipher up for decryption. * * cipher = OpenSSL::Cipher.new 'AES-128-CBC' * cipher.decrypt * cipher.iv = iv # the one generated with #random_iv * * pwd = 'some hopefully not to easily guessable password' * salt = ... # the one generated above * iter = 20000 * key_len = cipher.key_len * digest = OpenSSL::Digest::SHA256.new * * key = OpenSSL::PKCS5.pbkdf2_hmac(pwd, salt, iter, key_len, digest) * cipher.key = key * * Now decrypt the data: * * decrypted = cipher.update encrypted * decrypted << cipher.final * * == PKCS #5 Password-based Encryption * * PKCS #5 is a password-based encryption standard documented at * RFC2898[http://www.ietf.org/rfc/rfc2898.txt]. It allows a short password or * passphrase to be used to create a secure encryption key. If possible, PBKDF2 * as described above should be used if the circumstances allow it. * * PKCS #5 uses a Cipher, a pass phrase and a salt to generate an encryption * key. * * pass_phrase = 'my secure pass phrase goes here' * salt = '8 octets' * * === Encryption * * First set up the cipher for encryption * * encryptor = OpenSSL::Cipher.new 'AES-128-CBC' * encryptor.encrypt * encryptor.pkcs5_keyivgen pass_phrase, salt * * Then pass the data you want to encrypt through * * encrypted = encryptor.update 'top secret document' * encrypted << encryptor.final * * === Decryption * * Use a new Cipher instance set up for decryption * * decryptor = OpenSSL::Cipher.new 'AES-128-CBC' * decryptor.decrypt * decryptor.pkcs5_keyivgen pass_phrase, salt * * Then pass the data you want to decrypt through * * plain = decryptor.update encrypted * plain << decryptor.final * * == X509 Certificates * * === Creating a Certificate * * This example creates a self-signed certificate using an RSA key and a SHA1 * signature. * * name = OpenSSL::X509::Name.parse 'CN=nobody/DC=example' * * cert = OpenSSL::X509::Certificate.new * cert.version = 2 * cert.serial = 0 * cert.not_before = Time.now * cert.not_after = Time.now + 3600 * * cert.public_key = key.public_key * cert.subject = name * * === Certificate Extensions * * You can add extensions to the certificate with * OpenSSL::SSL::ExtensionFactory to indicate the purpose of the certificate. * * extension_factory = OpenSSL::X509::ExtensionFactory.new nil, cert * * cert.add_extension \ * extension_factory.create_extension('basicConstraints', 'CA:FALSE', true) * * cert.add_extension \ * extension_factory.create_extension( * 'keyUsage', 'keyEncipherment,dataEncipherment,digitalSignature') * * cert.add_extension \ * extension_factory.create_extension('subjectKeyIdentifier', 'hash') * * The list of supported extensions (and in some cases their possible values) * can be derived from the "objects.h" file in the OpenSSL source code. * * === Signing a Certificate * * To sign a certificate set the issuer and use OpenSSL::X509::Certificate#sign * with a digest algorithm. This creates a self-signed cert because we're using * the same name and key to sign the certificate as was used to create the * certificate. * * cert.issuer = name * cert.sign key, OpenSSL::Digest::SHA1.new * * open 'certificate.pem', 'w' do |io| io.write cert.to_pem end * * === Loading a Certificate * * Like a key, a cert can also be loaded from a file. * * cert2 = OpenSSL::X509::Certificate.new File.read 'certificate.pem' * * === Verifying a Certificate * * Certificate#verify will return true when a certificate was signed with the * given public key. * * raise 'certificate can not be verified' unless cert2.verify key * * == Certificate Authority * * A certificate authority (CA) is a trusted third party that allows you to * verify the ownership of unknown certificates. The CA issues key signatures * that indicate it trusts the user of that key. A user encountering the key * can verify the signature by using the CA's public key. * * === CA Key * * CA keys are valuable, so we encrypt and save it to disk and make sure it is * not readable by other users. * * ca_key = OpenSSL::PKey::RSA.new 2048 * * cipher = OpenSSL::Cipher::Cipher.new 'AES-128-CBC' * * open 'ca_key.pem', 'w', 0400 do |io| * io.write ca_key.export(cipher, pass_phrase) * end * * === CA Certificate * * A CA certificate is created the same way we created a certificate above, but * with different extensions. * * ca_name = OpenSSL::X509::Name.parse 'CN=ca/DC=example' * * ca_cert = OpenSSL::X509::Certificate.new * ca_cert.serial = 0 * ca_cert.version = 2 * ca_cert.not_before = Time.now * ca_cert.not_after = Time.now + 86400 * * ca_cert.public_key = ca_key.public_key * ca_cert.subject = ca_name * ca_cert.issuer = ca_name * * extension_factory = OpenSSL::X509::ExtensionFactory.new * extension_factory.subject_certificate = ca_cert * extension_factory.issuer_certificate = ca_cert * * ca_cert.add_extension \ * extension_factory.create_extension('subjectKeyIdentifier', 'hash') * * This extension indicates the CA's key may be used as a CA. * * ca_cert.add_extension \ * extension_factory.create_extension('basicConstraints', 'CA:TRUE', true) * * This extension indicates the CA's key may be used to verify signatures on * both certificates and certificate revocations. * * ca_cert.add_extension \ * extension_factory.create_extension( * 'keyUsage', 'cRLSign,keyCertSign', true) * * Root CA certificates are self-signed. * * ca_cert.sign ca_key, OpenSSL::Digest::SHA1.new * * The CA certificate is saved to disk so it may be distributed to all the * users of the keys this CA will sign. * * open 'ca_cert.pem', 'w' do |io| * io.write ca_cert.to_pem * end * * === Certificate Signing Request * * The CA signs keys through a Certificate Signing Request (CSR). The CSR * contains the information necessary to identify the key. * * csr = OpenSSL::X509::Request.new * csr.version = 0 * csr.subject = name * csr.public_key = key.public_key * csr.sign key, OpenSSL::Digest::SHA1.new * * A CSR is saved to disk and sent to the CA for signing. * * open 'csr.pem', 'w' do |io| * io.write csr.to_pem * end * * === Creating a Certificate from a CSR * * Upon receiving a CSR the CA will verify it before signing it. A minimal * verification would be to check the CSR's signature. * * csr = OpenSSL::X509::Request.new File.read 'csr.pem' * * raise 'CSR can not be verified' unless csr.verify csr.public_key * * After verification a certificate is created, marked for various usages, * signed with the CA key and returned to the requester. * * csr_cert = OpenSSL::X509::Certificate.new * csr_cert.serial = 0 * csr_cert.version = 2 * csr_cert.not_before = Time.now * csr_cert.not_after = Time.now + 600 * * csr_cert.subject = csr.subject * csr_cert.public_key = csr.public_key * csr_cert.issuer = ca_cert.subject * * extension_factory = OpenSSL::X509::ExtensionFactory.new * extension_factory.subject_certificate = csr_cert * extension_factory.issuer_certificate = ca_cert * * csr_cert.add_extension \ * extension_factory.create_extension('basicConstraints', 'CA:FALSE') * * csr_cert.add_extension \ * extension_factory.create_extension( * 'keyUsage', 'keyEncipherment,dataEncipherment,digitalSignature') * * csr_cert.add_extension \ * extension_factory.create_extension('subjectKeyIdentifier', 'hash') * * csr_cert.sign ca_key, OpenSSL::Digest::SHA1.new * * open 'csr_cert.pem', 'w' do |io| * io.write csr_cert.to_pem * end * * == SSL and TLS Connections * * Using our created key and certificate we can create an SSL or TLS connection. * An SSLContext is used to set up an SSL session. * * context = OpenSSL::SSL::SSLContext.new * * === SSL Server * * An SSL server requires the certificate and private key to communicate * securely with its clients: * * context.cert = cert * context.key = key * * Then create an SSLServer with a TCP server socket and the context. Use the * SSLServer like an ordinary TCP server. * * require 'socket' * * tcp_server = TCPServer.new 5000 * ssl_server = OpenSSL::SSL::SSLServer.new tcp_server, context * * loop do * ssl_connection = ssl_server.accept * * data = connection.gets * * response = "I got #{data.dump}" * puts response * * connection.puts "I got #{data.dump}" * connection.close * end * * === SSL client * * An SSL client is created with a TCP socket and the context. * SSLSocket#connect must be called to initiate the SSL handshake and start * encryption. A key and certificate are not required for the client socket. * * require 'socket' * * tcp_client = TCPSocket.new 'localhost', 5000 * ssl_client = OpenSSL::SSL::SSLSocket.new client_socket, context * ssl_client.connect * * ssl_client.puts "hello server!" * puts ssl_client.gets * * === Peer Verification * * An unverified SSL connection does not provide much security. For enhanced * security the client or server can verify the certificate of its peer. * * The client can be modified to verify the server's certificate against the * certificate authority's certificate: * * context.ca_file = 'ca_cert.pem' * context.verify_mode = OpenSSL::SSL::VERIFY_PEER * * require 'socket' * * tcp_client = TCPSocket.new 'localhost', 5000 * ssl_client = OpenSSL::SSL::SSLSocket.new client_socket, context * ssl_client.connect * * ssl_client.puts "hello server!" * puts ssl_client.gets * * If the server certificate is invalid or <tt>context.ca_file</tt> is not set * when verifying peers an OpenSSL::SSL::SSLError will be raised. * */ void Init_openssl(void) { /* * Init timezone info */ #if 0 tzset(); #endif /* * Init all digests, ciphers */ /* CRYPTO_malloc_init(); */ /* ENGINE_load_builtin_engines(); */ OpenSSL_add_ssl_algorithms(); OpenSSL_add_all_algorithms(); ERR_load_crypto_strings(); SSL_load_error_strings(); /* * FIXME: * On unload do: */ #if 0 CONF_modules_unload(1); destroy_ui_method(); EVP_cleanup(); ENGINE_cleanup(); CRYPTO_cleanup_all_ex_data(); ERR_remove_state(0); ERR_free_strings(); #endif /* * Init main module */ mOSSL = rb_define_module("OpenSSL"); rb_global_variable(&mOSSL); /* * OpenSSL ruby extension version */ rb_define_const(mOSSL, "VERSION", rb_str_new2(OSSL_VERSION)); /* * Version of OpenSSL the ruby OpenSSL extension was built with */ rb_define_const(mOSSL, "OPENSSL_VERSION", rb_str_new2(OPENSSL_VERSION_TEXT)); /* * Version of OpenSSL the ruby OpenSSL extension is running with */ rb_define_const(mOSSL, "OPENSSL_LIBRARY_VERSION", rb_str_new2(SSLeay_version(SSLEAY_VERSION))); /* * Version number of OpenSSL the ruby OpenSSL extension was built with * (base 16) */ rb_define_const(mOSSL, "OPENSSL_VERSION_NUMBER", INT2NUM(OPENSSL_VERSION_NUMBER)); /* * Boolean indicating whether OpenSSL is FIPS-enabled or not */ #ifdef HAVE_OPENSSL_FIPS rb_define_const(mOSSL, "OPENSSL_FIPS", Qtrue); #else rb_define_const(mOSSL, "OPENSSL_FIPS", Qfalse); #endif rb_define_module_function(mOSSL, "fips_mode=", ossl_fips_mode_set, 1); /* * Generic error, * common for all classes under OpenSSL module */ eOSSLError = rb_define_class_under(mOSSL,"OpenSSLError",rb_eStandardError); rb_global_variable(&eOSSLError); /* * Verify callback Proc index for ext-data */ if ((ossl_verify_cb_idx = X509_STORE_CTX_get_ex_new_index(0, (void *)"ossl_verify_cb_idx", 0, 0, 0)) < 0) ossl_raise(eOSSLError, "X509_STORE_CTX_get_ex_new_index"); /* * Init debug core */ dOSSL = Qfalse; rb_global_variable(&dOSSL); rb_define_module_function(mOSSL, "debug", ossl_debug_get, 0); rb_define_module_function(mOSSL, "debug=", ossl_debug_set, 1); rb_define_module_function(mOSSL, "errors", ossl_get_errors, 0); /* * Get ID of to_der */ ossl_s_to_der = rb_intern("to_der"); Init_ossl_locks(); /* * Init components */ Init_ossl_bn(); Init_ossl_cipher(); Init_ossl_config(); Init_ossl_digest(); Init_ossl_hmac(); Init_ossl_ns_spki(); Init_ossl_pkcs12(); Init_ossl_pkcs7(); Init_ossl_pkcs5(); Init_ossl_pkey(); Init_ossl_rand(); Init_ossl_ssl(); Init_ossl_x509(); Init_ossl_ocsp(); Init_ossl_engine(); Init_ossl_asn1(); }
void define_ruby_module() { if (rb_module) return; rb_module = rb_define_module("OpenCV"); /* OpenCV version */ rb_define_const(rb_module, "CV_VERSION", rb_str_new2(CV_VERSION)); rb_define_const(rb_module, "CV_MAJOR_VERSION", INT2FIX(CV_MAJOR_VERSION)); rb_define_const(rb_module, "CV_MINOR_VERSION", INT2FIX(CV_MINOR_VERSION)); rb_define_const(rb_module, "CV_SUBMINOR_VERSION", INT2FIX(CV_SUBMINOR_VERSION)); rb_define_const(rb_module, "CV_VERSION_EPOCH", INT2FIX(CV_VERSION_EPOCH)); rb_define_const(rb_module, "CV_VERSION_MAJOR", INT2FIX(CV_VERSION_MAJOR)); rb_define_const(rb_module, "CV_VERSION_MINOR", INT2FIX(CV_VERSION_MINOR)); rb_define_const(rb_module, "CV_VERSION_REVISION", INT2FIX(CV_VERSION_REVISION)); /* 0: 8bit unsigned */ rb_define_const(rb_module, "CV_8U", INT2FIX(CV_8U)); /* 1: 8bit signed */ rb_define_const(rb_module, "CV_8S", INT2FIX(CV_8S)); /* 2: 16bit unsigned */ rb_define_const(rb_module, "CV_16U", INT2FIX(CV_16U)); /* 3: 16bit signed */ rb_define_const(rb_module, "CV_16S", INT2FIX(CV_16S)); /* 4: 32bit signed */ rb_define_const(rb_module, "CV_32S", INT2FIX(CV_32S)); /* 5: 32bit floating-point */ rb_define_const(rb_module, "CV_32F", INT2FIX(CV_32F)); /* 6: 64bit floating-point */ rb_define_const(rb_module, "CV_64F", INT2FIX(CV_64F)); /* Color types of loaded images */ rb_define_const(rb_module, "CV_LOAD_IMAGE_UNCHANGED", INT2FIX(CV_LOAD_IMAGE_UNCHANGED)); rb_define_const(rb_module, "CV_LOAD_IMAGE_GRAYSCALE", INT2FIX(CV_LOAD_IMAGE_GRAYSCALE)); rb_define_const(rb_module, "CV_LOAD_IMAGE_COLOR", INT2FIX(CV_LOAD_IMAGE_COLOR)); rb_define_const(rb_module, "CV_LOAD_IMAGE_ANYDEPTH", INT2FIX(CV_LOAD_IMAGE_ANYDEPTH)); rb_define_const(rb_module, "CV_LOAD_IMAGE_ANYCOLOR", INT2FIX(CV_LOAD_IMAGE_ANYCOLOR)); /* Format-specific save parameters */ rb_define_const(rb_module, "CV_IMWRITE_JPEG_QUALITY", INT2FIX(CV_IMWRITE_JPEG_QUALITY)); rb_define_const(rb_module, "CV_IMWRITE_PNG_COMPRESSION", INT2FIX(CV_IMWRITE_PNG_COMPRESSION)); rb_define_const(rb_module, "CV_IMWRITE_PNG_STRATEGY", INT2FIX(CV_IMWRITE_PNG_STRATEGY)); rb_define_const(rb_module, "CV_IMWRITE_PNG_STRATEGY_DEFAULT", INT2FIX(CV_IMWRITE_PNG_STRATEGY_DEFAULT)); rb_define_const(rb_module, "CV_IMWRITE_PNG_STRATEGY_FILTERED", INT2FIX(CV_IMWRITE_PNG_STRATEGY_FILTERED)); rb_define_const(rb_module, "CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY", INT2FIX(CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY)); rb_define_const(rb_module, "CV_IMWRITE_PNG_STRATEGY_RLE", INT2FIX(CV_IMWRITE_PNG_STRATEGY_RLE)); rb_define_const(rb_module, "CV_IMWRITE_PNG_STRATEGY_FIXED", INT2FIX(CV_IMWRITE_PNG_STRATEGY_FIXED)); rb_define_const(rb_module, "CV_IMWRITE_PXM_BINARY", INT2FIX(CV_IMWRITE_PXM_BINARY)); /* Types of morphological operations */ rb_define_const(rb_module, "CV_MOP_OPEN", INT2FIX(CV_MOP_OPEN)); rb_define_const(rb_module, "CV_MOP_CLOSE", INT2FIX(CV_MOP_CLOSE)); rb_define_const(rb_module, "CV_MOP_GRADIENT", INT2FIX(CV_MOP_GRADIENT)); rb_define_const(rb_module, "CV_MOP_TOPHAT", INT2FIX(CV_MOP_TOPHAT)); rb_define_const(rb_module, "CV_MOP_BLACKHAT", INT2FIX(CV_MOP_BLACKHAT)); /* Shape of the structuring elements */ rb_define_const(rb_module, "CV_SHAPE_RECT", INT2FIX(CV_SHAPE_RECT)); rb_define_const(rb_module, "CV_SHAPE_CROSS", INT2FIX(CV_SHAPE_CROSS)); rb_define_const(rb_module, "CV_SHAPE_ELLIPSE", INT2FIX(CV_SHAPE_ELLIPSE)); rb_define_const(rb_module, "CV_SHAPE_CUSTOM", INT2FIX(CV_SHAPE_CUSTOM)); /* Types of the smoothing */ rb_define_const(rb_module, "CV_BLUR_NO_SCALE", INT2FIX(CV_BLUR_NO_SCALE)); rb_define_const(rb_module, "CV_BLUR", INT2FIX(CV_BLUR)); rb_define_const(rb_module, "CV_GAUSSIAN", INT2FIX(CV_GAUSSIAN)); rb_define_const(rb_module, "CV_MEDIAN", INT2FIX(CV_MEDIAN)); rb_define_const(rb_module, "CV_BILATERAL", INT2FIX(CV_BILATERAL)); /* Thresholding types */ rb_define_const(rb_module, "CV_THRESH_BINARY", INT2FIX(CV_THRESH_BINARY)); rb_define_const(rb_module, "CV_THRESH_BINARY_INV", INT2FIX(CV_THRESH_BINARY_INV)); rb_define_const(rb_module, "CV_THRESH_TRUNC", INT2FIX(CV_THRESH_TRUNC)); rb_define_const(rb_module, "CV_THRESH_TOZERO", INT2FIX(CV_THRESH_TOZERO)); rb_define_const(rb_module, "CV_THRESH_TOZERO_INV", INT2FIX(CV_THRESH_TOZERO_INV)); rb_define_const(rb_module, "CV_THRESH_OTSU", INT2FIX(CV_THRESH_OTSU)); /* Adaptive methods */ rb_define_const(rb_module, "CV_ADAPTIVE_THRESH_MEAN_C", INT2FIX(CV_ADAPTIVE_THRESH_MEAN_C)); rb_define_const(rb_module, "CV_ADAPTIVE_THRESH_GAUSSIAN_C", INT2FIX(CV_ADAPTIVE_THRESH_GAUSSIAN_C)); /* Border type */ rb_define_const(rb_module, "IPL_BORDER_CONSTANT", INT2FIX(IPL_BORDER_CONSTANT)); rb_define_const(rb_module, "IPL_BORDER_REPLICATE", INT2FIX(IPL_BORDER_REPLICATE)); /* Retrieval mode */ rb_define_const(rb_module, "CV_RETR_EXTERNAL", INT2FIX(CV_RETR_EXTERNAL)); rb_define_const(rb_module, "CV_RETR_LIST", INT2FIX(CV_RETR_LIST)); rb_define_const(rb_module, "CV_RETR_CCOMP", INT2FIX(CV_RETR_CCOMP)); rb_define_const(rb_module, "CV_RETR_TREE", INT2FIX(CV_RETR_TREE)); /* Approximation method */ rb_define_const(rb_module, "CV_CHAIN_CODE", INT2FIX(CV_CHAIN_CODE)); rb_define_const(rb_module, "CV_CHAIN_APPROX_NONE", INT2FIX(CV_CHAIN_APPROX_NONE)); rb_define_const(rb_module, "CV_CHAIN_APPROX_SIMPLE", INT2FIX(CV_CHAIN_APPROX_SIMPLE)); rb_define_const(rb_module, "CV_CHAIN_APPROX_TC89_L1", INT2FIX(CV_CHAIN_APPROX_TC89_L1)); rb_define_const(rb_module, "CV_CHAIN_APPROX_TC89_KCOS", INT2FIX(CV_CHAIN_APPROX_TC89_KCOS)); rb_define_const(rb_module, "CV_LINK_RUNS", INT2FIX(CV_LINK_RUNS)); /* Termination criteria for iterative algorithms */ rb_define_const(rb_module, "CV_TERMCRIT_ITER", INT2FIX(CV_TERMCRIT_ITER)); rb_define_const(rb_module, "CV_TERMCRIT_NUMBER", INT2FIX(CV_TERMCRIT_NUMBER)); rb_define_const(rb_module, "CV_TERMCRIT_EPS", INT2FIX(CV_TERMCRIT_EPS)); /* Hough transform method */ rb_define_const(rb_module, "CV_HOUGH_STANDARD", INT2FIX(CV_HOUGH_STANDARD)); rb_define_const(rb_module, "CV_HOUGH_PROBABILISTIC", INT2FIX(CV_HOUGH_PROBABILISTIC)); rb_define_const(rb_module, "CV_HOUGH_MULTI_SCALE", INT2FIX(CV_HOUGH_MULTI_SCALE)); rb_define_const(rb_module, "CV_HOUGH_GRADIENT", INT2FIX(CV_HOUGH_GRADIENT)); /* Inpaint method */ rb_define_const(rb_module, "CV_INPAINT_NS", INT2FIX(CV_INPAINT_NS)); rb_define_const(rb_module, "CV_INPAINT_TELEA", INT2FIX(CV_INPAINT_TELEA)); /* Match template method */ rb_define_const(rb_module, "CV_TM_SQDIFF", INT2FIX(CV_TM_SQDIFF)); rb_define_const(rb_module, "CV_TM_SQDIFF_NORMED", INT2FIX(CV_TM_SQDIFF_NORMED)); rb_define_const(rb_module, "CV_TM_CCORR", INT2FIX(CV_TM_CCORR)); rb_define_const(rb_module, "CV_TM_CCORR_NORMED", INT2FIX(CV_TM_CCORR_NORMED)); rb_define_const(rb_module, "CV_TM_CCOEFF", INT2FIX(CV_TM_CCOEFF)); rb_define_const(rb_module, "CV_TM_CCOEFF_NORMED", INT2FIX(CV_TM_CCOEFF_NORMED)); /* Comparison method */ rb_define_const(rb_module, "CV_CONTOURS_MATCH_I1", INT2FIX(CV_CONTOURS_MATCH_I1)); rb_define_const(rb_module, "CV_CONTOURS_MATCH_I2", INT2FIX(CV_CONTOURS_MATCH_I2)); rb_define_const(rb_module, "CV_CONTOURS_MATCH_I3", INT2FIX(CV_CONTOURS_MATCH_I3)); /* Fundamental matrix computing methods */ rb_define_const(rb_module, "CV_FM_7POINT", INT2FIX(CV_FM_7POINT)); rb_define_const(rb_module, "CV_FM_8POINT", INT2FIX(CV_FM_8POINT)); rb_define_const(rb_module, "CV_FM_RANSAC", INT2FIX(CV_FM_RANSAC)); rb_define_const(rb_module, "CV_FM_LMEDS", INT2FIX(CV_FM_LMEDS)); /* Flags of window */ rb_define_const(rb_module, "CV_WINDOW_AUTOSIZE", INT2FIX(CV_WINDOW_AUTOSIZE)); /* Object detection mode */ rb_define_const(rb_module, "CV_HAAR_DO_CANNY_PRUNING", INT2FIX(CV_HAAR_DO_CANNY_PRUNING)); /* Interpolation methods */ rb_define_const(rb_module, "CV_INTER_NN", INT2FIX(CV_INTER_NN)); rb_define_const(rb_module, "CV_INTER_LINEAR", INT2FIX(CV_INTER_LINEAR)); rb_define_const(rb_module, "CV_INTER_AREA", INT2FIX(CV_INTER_AREA)); rb_define_const(rb_module, "CV_INTER_CUBIC", INT2FIX(CV_INTER_CUBIC)); rb_define_const(rb_module, "CV_INTER_LANCZOS4", INT2FIX(CV_INTER_LANCZOS4)); /* Warp affine optional flags */ rb_define_const(rb_module, "CV_WARP_FILL_OUTLIERS", INT2FIX(CV_WARP_FILL_OUTLIERS)); rb_define_const(rb_module, "CV_WARP_INVERSE_MAP", INT2FIX(CV_WARP_INVERSE_MAP)); /* SVD optional flags */ rb_define_const(rb_module, "CV_SVD_MODIFY_A", INT2FIX(CV_SVD_MODIFY_A)); rb_define_const(rb_module, "CV_SVD_U_T", INT2FIX(CV_SVD_U_T)); rb_define_const(rb_module, "CV_SVD_V_T", INT2FIX(CV_SVD_V_T)); /* Norm types */ rb_define_const(rb_module, "CV_NORM_INF", INT2FIX(cv::NORM_INF)); rb_define_const(rb_module, "CV_NORM_L1", INT2FIX(cv::NORM_L1)); rb_define_const(rb_module, "CV_NORM_L2", INT2FIX(cv::NORM_L2)); rb_define_const(rb_module, "CV_NORM_MINMAX", INT2FIX(cv::NORM_MINMAX)); /* Histogram representation format */ rb_define_const(rb_module, "CV_HIST_ARRAY", INT2FIX(CV_HIST_ARRAY)); rb_define_const(rb_module, "CV_HIST_SPARSE", INT2FIX(CV_HIST_SPARSE)); rb_define_const(rb_module, "CV_HIST_TREE", INT2FIX(CV_HIST_TREE)); rb_define_const(rb_module, "CV_HIST_UNIFORM", INT2FIX(CV_HIST_UNIFORM)); /* Histogram comparison method */ rb_define_const(rb_module, "CV_COMP_CORREL", INT2FIX(CV_COMP_CORREL)); rb_define_const(rb_module, "CV_COMP_CHISQR", INT2FIX(CV_COMP_CHISQR)); rb_define_const(rb_module, "CV_COMP_INTERSECT", INT2FIX(CV_COMP_INTERSECT)); rb_define_const(rb_module, "CV_COMP_BHATTACHARYYA", INT2FIX(CV_COMP_BHATTACHARYYA)); /* DFT and DCT flags */ rb_define_const(rb_module, "CV_DXT_FORWARD", INT2FIX(CV_DXT_FORWARD)); rb_define_const(rb_module, "CV_DXT_INVERSE", INT2FIX(CV_DXT_INVERSE)); rb_define_const(rb_module, "CV_DXT_SCALE", INT2FIX(CV_DXT_SCALE)); rb_define_const(rb_module, "CV_DXT_INV_SCALE", INT2FIX(CV_DXT_INV_SCALE)); rb_define_const(rb_module, "CV_DXT_INVERSE_SCALE", INT2FIX(CV_DXT_INVERSE_SCALE)); rb_define_const(rb_module, "CV_DXT_ROWS", INT2FIX(CV_DXT_ROWS)); /* FindChessboardCorners flags */ rb_define_const(rb_module, "CV_CALIB_CB_ADAPTIVE_THRESH", INT2FIX(CV_CALIB_CB_ADAPTIVE_THRESH)); rb_define_const(rb_module, "CV_CALIB_CB_NORMALIZE_IMAGE", INT2FIX(CV_CALIB_CB_NORMALIZE_IMAGE)); rb_define_const(rb_module, "CV_CALIB_CB_FILTER_QUADS", INT2FIX(CV_CALIB_CB_FILTER_QUADS)); rb_define_const(rb_module, "CV_CALIB_CB_FAST_CHECK", INT2FIX(CV_CALIB_CB_FAST_CHECK)); VALUE inversion_method = rb_hash_new(); /* {:lu, :svd, :svd_sym(:svd_symmetric)}: Inversion method */ rb_define_const(rb_module, "INVERSION_METHOD", inversion_method); REGISTER_HASH(inversion_method, "lu", CV_LU); REGISTER_HASH(inversion_method, "svd", CV_SVD); REGISTER_HASH(inversion_method, "svd_sym", CV_SVD_SYM); REGISTER_HASH(inversion_method, "svd_symmetric", CV_SVD_SYM); VALUE homography_calc_method = rb_hash_new(); /* {:all, :ransac, :lmeds}: Methods used to computed homography matrix */ rb_define_const(rb_module, "HOMOGRAPHY_CALC_METHOD", homography_calc_method); REGISTER_HASH(homography_calc_method, "all", 0); REGISTER_HASH(homography_calc_method, "ransac", CV_RANSAC); REGISTER_HASH(homography_calc_method, "lmeds", CV_LMEDS); VALUE depth = rb_hash_new(); /* {:cv8u, :cv8s, :cv16u, :cv16s, :cv32s, :cv32f, :cv64f}: Depth of each pixel. */ rb_define_const(rb_module, "DEPTH", depth); REGISTER_HASH(depth, "cv8u", CV_8U); REGISTER_HASH(depth, "cv8s", CV_8S); REGISTER_HASH(depth, "cv16u", CV_16U); REGISTER_HASH(depth, "cv16s", CV_16S); REGISTER_HASH(depth, "cv32s", CV_32S); REGISTER_HASH(depth, "cv32f", CV_32F); REGISTER_HASH(depth, "cv64f", CV_64F); VALUE connectivity = rb_hash_new(); /* {:aa(:anti_alias)}: Determined by the closeness of pixel values */ rb_define_const(rb_module, "CONNECTIVITY", connectivity); REGISTER_HASH(connectivity, "aa", CV_AA); REGISTER_HASH(connectivity, "anti_alias", CV_AA); VALUE structuring_element_shape = rb_hash_new(); /* {:rect, :cross, :ellipse, :custom}: Shape of the structuring elements */ rb_define_const(rb_module, "STRUCTURING_ELEMENT_SHAPE", structuring_element_shape); REGISTER_HASH(structuring_element_shape, "rect", CV_SHAPE_RECT); REGISTER_HASH(structuring_element_shape, "cross", CV_SHAPE_CROSS); REGISTER_HASH(structuring_element_shape, "ellipse", CV_SHAPE_ELLIPSE); REGISTER_HASH(structuring_element_shape, "custom", CV_SHAPE_CUSTOM); VALUE retrieval_mode = rb_hash_new(); /* {:external, :list, :ccomp, :tree}: Retrieval mode */ rb_define_const(rb_module, "RETRIEVAL_MODE", retrieval_mode); REGISTER_HASH(retrieval_mode, "external", CV_RETR_EXTERNAL); REGISTER_HASH(retrieval_mode, "list", CV_RETR_LIST); REGISTER_HASH(retrieval_mode, "ccomp", CV_RETR_CCOMP); REGISTER_HASH(retrieval_mode, "tree", CV_RETR_TREE); VALUE approx_chain_method = rb_hash_new(); /* {:code, :approx_none, :approx_simple, :apporx_tc89_11, :approx_tc89_kcos}: Approximation method */ rb_define_const(rb_module, "APPROX_CHAIN_METHOD", approx_chain_method); REGISTER_HASH(approx_chain_method, "code", CV_CHAIN_CODE); REGISTER_HASH(approx_chain_method, "approx_none", CV_CHAIN_APPROX_NONE); REGISTER_HASH(approx_chain_method, "approx_simple", CV_CHAIN_APPROX_SIMPLE); REGISTER_HASH(approx_chain_method, "approx_tc89_l1", CV_CHAIN_APPROX_TC89_L1); REGISTER_HASH(approx_chain_method, "approx_tc89_kcos", CV_CHAIN_APPROX_TC89_KCOS); VALUE approx_poly_method = rb_hash_new(); /* {:dp}: Approximation method (polygon) */ rb_define_const(rb_module, "APPROX_POLY_METHOD", approx_poly_method); REGISTER_HASH(approx_poly_method, "dp", CV_POLY_APPROX_DP); VALUE match_template_method = rb_hash_new(); /* {:sqdiff, :sqdiff_normed, :ccorr, :ccorr_normed, :ccoeff, :ccoeff_normed}: Match template method */ rb_define_const(rb_module, "MATCH_TEMPLATE_METHOD", match_template_method); REGISTER_HASH(match_template_method, "sqdiff", CV_TM_SQDIFF); REGISTER_HASH(match_template_method, "sqdiff_normed", CV_TM_SQDIFF_NORMED); REGISTER_HASH(match_template_method, "ccorr", CV_TM_CCORR); REGISTER_HASH(match_template_method, "ccorr_normed", CV_TM_CCORR_NORMED); REGISTER_HASH(match_template_method, "ccoeff", CV_TM_CCOEFF); REGISTER_HASH(match_template_method, "ccoeff_normed", CV_TM_CCOEFF_NORMED); VALUE morphological_operation = rb_hash_new(); /* {:open, :close, :gradient, :tophat, :blackhat}: Types of morphological operations */ rb_define_const(rb_module, "MORPHOLOGICAL_OPERATION", morphological_operation); REGISTER_HASH(morphological_operation, "open", CV_MOP_OPEN); REGISTER_HASH(morphological_operation, "close", CV_MOP_CLOSE); REGISTER_HASH(morphological_operation, "gradient", CV_MOP_GRADIENT); REGISTER_HASH(morphological_operation, "tophat", CV_MOP_TOPHAT); REGISTER_HASH(morphological_operation, "blackhat", CV_MOP_BLACKHAT); VALUE smoothing_type = rb_hash_new(); /* {:blur_no_scale, :blur, :gaussian, :median, :bilateral}: Types of smoothing */ rb_define_const(rb_module, "SMOOTHING_TYPE", smoothing_type); REGISTER_HASH(smoothing_type, "blur_no_scale", CV_BLUR_NO_SCALE); REGISTER_HASH(smoothing_type, "blur", CV_BLUR); REGISTER_HASH(smoothing_type, "gaussian", CV_GAUSSIAN); REGISTER_HASH(smoothing_type, "median", CV_MEDIAN); REGISTER_HASH(smoothing_type, "bilateral", CV_BILATERAL); VALUE adaptive_method = rb_hash_new(); /* {:mean_c, :gaussian_c}: Adaptive thresholding algorithm */ rb_define_const(rb_module, "ADAPTIVE_METHOD", adaptive_method); REGISTER_HASH(adaptive_method, "mean_c", CV_ADAPTIVE_THRESH_MEAN_C); REGISTER_HASH(adaptive_method, "gaussian_c", CV_ADAPTIVE_THRESH_GAUSSIAN_C); VALUE threshold_type = rb_hash_new(); /* {:binary, :binary_inv, :trunc, :tozero, :tozero_inv, :otsu} : Thresholding types */ rb_define_const(rb_module, "THRESHOLD_TYPE", threshold_type); REGISTER_HASH(threshold_type, "binary", CV_THRESH_BINARY); REGISTER_HASH(threshold_type, "binary_inv", CV_THRESH_BINARY_INV); REGISTER_HASH(threshold_type, "trunc", CV_THRESH_TRUNC); REGISTER_HASH(threshold_type, "tozero", CV_THRESH_TOZERO); REGISTER_HASH(threshold_type, "tozero_inv", CV_THRESH_TOZERO_INV); REGISTER_HASH(threshold_type, "otsu", CV_THRESH_OTSU); VALUE hough_transform_method = rb_hash_new(); /* {:standard, :probabilistic, :multi_scale} : Hough transform method */ rb_define_const(rb_module, "HOUGH_TRANSFORM_METHOD", hough_transform_method); REGISTER_HASH(hough_transform_method, "standard", CV_HOUGH_STANDARD); REGISTER_HASH(hough_transform_method, "probabilistic", CV_HOUGH_PROBABILISTIC); REGISTER_HASH(hough_transform_method, "multi_scale", CV_HOUGH_MULTI_SCALE); REGISTER_HASH(hough_transform_method, "gradient", CV_HOUGH_GRADIENT); VALUE inpaint_method = rb_hash_new(); /* {:ns, :telea} : Inpaint method */ rb_define_const(rb_module, "INPAINT_METHOD", inpaint_method); REGISTER_HASH(inpaint_method, "ns", CV_INPAINT_NS); REGISTER_HASH(inpaint_method, "telea", CV_INPAINT_TELEA); VALUE comparison_method = rb_hash_new(); /* Comparison method */ rb_define_const(rb_module, "COMPARISON_METHOD", comparison_method); REGISTER_HASH(comparison_method, "i1", CV_CONTOURS_MATCH_I1); REGISTER_HASH(comparison_method, "i2", CV_CONTOURS_MATCH_I2); REGISTER_HASH(comparison_method, "i3", CV_CONTOURS_MATCH_I3); /* color convert methods */ rb_define_module_function(rb_module, "BGR2BGRA", RUBY_METHOD_FUNC(rb_BGR2BGRA), 1); rb_define_module_function(rb_module, "RGB2RGBA", RUBY_METHOD_FUNC(rb_RGB2RGBA), 1); rb_define_module_function(rb_module, "BGRA2BGR", RUBY_METHOD_FUNC(rb_BGRA2BGR), 1); rb_define_module_function(rb_module, "RGBA2RGB", RUBY_METHOD_FUNC(rb_RGBA2RGB), 1); rb_define_module_function(rb_module, "BGR2RGBA", RUBY_METHOD_FUNC(rb_BGR2RGBA), 1); rb_define_module_function(rb_module, "RGB2BGRA", RUBY_METHOD_FUNC(rb_RGB2BGRA), 1); rb_define_module_function(rb_module, "RGBA2BGR", RUBY_METHOD_FUNC(rb_RGBA2BGR), 1); rb_define_module_function(rb_module, "BGRA2RGB", RUBY_METHOD_FUNC(rb_BGRA2RGB), 1); rb_define_module_function(rb_module, "BGR2RGB", RUBY_METHOD_FUNC(rb_BGR2RGB), 1); rb_define_module_function(rb_module, "RGB2BGR", RUBY_METHOD_FUNC(rb_RGB2BGR), 1); rb_define_module_function(rb_module, "BGRA2RGBA", RUBY_METHOD_FUNC(rb_BGRA2RGBA), 1); rb_define_module_function(rb_module, "RGBA2BGRA", RUBY_METHOD_FUNC(rb_RGBA2BGRA), 1); rb_define_module_function(rb_module, "BGR2GRAY", RUBY_METHOD_FUNC(rb_BGR2GRAY), 1); rb_define_module_function(rb_module, "RGB2GRAY", RUBY_METHOD_FUNC(rb_RGB2GRAY), 1); rb_define_module_function(rb_module, "GRAY2BGR", RUBY_METHOD_FUNC(rb_GRAY2BGR), 1); rb_define_module_function(rb_module, "GRAY2RGB", RUBY_METHOD_FUNC(rb_GRAY2RGB), 1); rb_define_module_function(rb_module, "GRAY2BGRA", RUBY_METHOD_FUNC(rb_GRAY2BGRA), 1); rb_define_module_function(rb_module, "GRAY2RGBA", RUBY_METHOD_FUNC(rb_GRAY2RGBA), 1); rb_define_module_function(rb_module, "BGRA2GRAY", RUBY_METHOD_FUNC(rb_BGRA2GRAY), 1); rb_define_module_function(rb_module, "RGBA2GRAY", RUBY_METHOD_FUNC(rb_RGBA2GRAY), 1); rb_define_module_function(rb_module, "BGR2BGR565", RUBY_METHOD_FUNC(rb_BGR2BGR565), 1); rb_define_module_function(rb_module, "RGB2BGR565", RUBY_METHOD_FUNC(rb_RGB2BGR565), 1); rb_define_module_function(rb_module, "BGR5652BGR", RUBY_METHOD_FUNC(rb_BGR5652BGR), 1); rb_define_module_function(rb_module, "BGR5652RGB", RUBY_METHOD_FUNC(rb_BGR5652RGB), 1); rb_define_module_function(rb_module, "BGRA2BGR565", RUBY_METHOD_FUNC(rb_BGRA2BGR565), 1); rb_define_module_function(rb_module, "RGBA2BGR565", RUBY_METHOD_FUNC(rb_RGBA2BGR565), 1); rb_define_module_function(rb_module, "BGR5652BGRA", RUBY_METHOD_FUNC(rb_BGR5652BGRA), 1); rb_define_module_function(rb_module, "BGR5652RGBA", RUBY_METHOD_FUNC(rb_BGR5652RGBA), 1); rb_define_module_function(rb_module, "GRAY2BGR565", RUBY_METHOD_FUNC(rb_GRAY2BGR565), 1); rb_define_module_function(rb_module, "BGR5652GRAY", RUBY_METHOD_FUNC(rb_BGR5652GRAY), 1); rb_define_module_function(rb_module, "BGR2BGR555", RUBY_METHOD_FUNC(rb_BGR2BGR555), 1); rb_define_module_function(rb_module, "RGB2BGR555", RUBY_METHOD_FUNC(rb_RGB2BGR555), 1); rb_define_module_function(rb_module, "BGR5552BGR", RUBY_METHOD_FUNC(rb_BGR5552BGR), 1); rb_define_module_function(rb_module, "BGR5552RGB", RUBY_METHOD_FUNC(rb_BGR5552RGB), 1); rb_define_module_function(rb_module, "BGRA2BGR555", RUBY_METHOD_FUNC(rb_BGRA2BGR555), 1); rb_define_module_function(rb_module, "RGBA2BGR555", RUBY_METHOD_FUNC(rb_RGBA2BGR555), 1); rb_define_module_function(rb_module, "BGR5552BGRA", RUBY_METHOD_FUNC(rb_BGR5552BGRA), 1); rb_define_module_function(rb_module, "BGR5552RGBA", RUBY_METHOD_FUNC(rb_BGR5552RGBA), 1); rb_define_module_function(rb_module, "GRAY2BGR555", RUBY_METHOD_FUNC(rb_GRAY2BGR555), 1); rb_define_module_function(rb_module, "BGR5552GRAY", RUBY_METHOD_FUNC(rb_BGR5552GRAY), 1); rb_define_module_function(rb_module, "BGR2XYZ", RUBY_METHOD_FUNC(rb_BGR2XYZ), 1); rb_define_module_function(rb_module, "RGB2XYZ", RUBY_METHOD_FUNC(rb_RGB2XYZ), 1); rb_define_module_function(rb_module, "XYZ2BGR", RUBY_METHOD_FUNC(rb_XYZ2BGR), 1); rb_define_module_function(rb_module, "XYZ2RGB", RUBY_METHOD_FUNC(rb_XYZ2RGB), 1); rb_define_module_function(rb_module, "BGR2YCrCb", RUBY_METHOD_FUNC(rb_BGR2YCrCb), 1); rb_define_module_function(rb_module, "RGB2YCrCb", RUBY_METHOD_FUNC(rb_RGB2YCrCb), 1); rb_define_module_function(rb_module, "YCrCb2BGR", RUBY_METHOD_FUNC(rb_YCrCb2BGR), 1); rb_define_module_function(rb_module, "YCrCb2RGB", RUBY_METHOD_FUNC(rb_YCrCb2RGB), 1); rb_define_module_function(rb_module, "BGR2HSV", RUBY_METHOD_FUNC(rb_BGR2HSV), 1); rb_define_module_function(rb_module, "RGB2HSV", RUBY_METHOD_FUNC(rb_RGB2HSV), 1); rb_define_module_function(rb_module, "BGR2Lab", RUBY_METHOD_FUNC(rb_BGR2Lab), 1); rb_define_module_function(rb_module, "RGB2Lab", RUBY_METHOD_FUNC(rb_RGB2Lab), 1); rb_define_module_function(rb_module, "BayerBG2BGR", RUBY_METHOD_FUNC(rb_BayerBG2BGR), 1); rb_define_module_function(rb_module, "BayerGB2BGR", RUBY_METHOD_FUNC(rb_BayerGB2BGR), 1); rb_define_module_function(rb_module, "BayerRG2BGR", RUBY_METHOD_FUNC(rb_BayerRG2BGR), 1); rb_define_module_function(rb_module, "BayerGR2BGR", RUBY_METHOD_FUNC(rb_BayerGR2BGR), 1); rb_define_module_function(rb_module, "BayerBG2RGB", RUBY_METHOD_FUNC(rb_BayerBG2RGB), 1); rb_define_module_function(rb_module, "BayerGB2RGB", RUBY_METHOD_FUNC(rb_BayerGB2RGB), 1); rb_define_module_function(rb_module, "BayerRG2RGB", RUBY_METHOD_FUNC(rb_BayerRG2RGB), 1); rb_define_module_function(rb_module, "BayerGR2RGB", RUBY_METHOD_FUNC(rb_BayerGR2RGB), 1); rb_define_module_function(rb_module, "BGR2Luv", RUBY_METHOD_FUNC(rb_BGR2Luv), 1); rb_define_module_function(rb_module, "RGB2Luv", RUBY_METHOD_FUNC(rb_RGB2Luv), 1); rb_define_module_function(rb_module, "BGR2HLS", RUBY_METHOD_FUNC(rb_BGR2HLS), 1); rb_define_module_function(rb_module, "RGB2HLS", RUBY_METHOD_FUNC(rb_RGB2HLS), 1); rb_define_module_function(rb_module, "HSV2BGR", RUBY_METHOD_FUNC(rb_HSV2BGR), 1); rb_define_module_function(rb_module, "HSV2RGB", RUBY_METHOD_FUNC(rb_HSV2RGB), 1); rb_define_module_function(rb_module, "Lab2BGR", RUBY_METHOD_FUNC(rb_Lab2BGR), 1); rb_define_module_function(rb_module, "Lab2RGB", RUBY_METHOD_FUNC(rb_Lab2RGB), 1); rb_define_module_function(rb_module, "Luv2BGR", RUBY_METHOD_FUNC(rb_Luv2BGR), 1); rb_define_module_function(rb_module, "Luv2RGB", RUBY_METHOD_FUNC(rb_Luv2RGB), 1); rb_define_module_function(rb_module, "HLS2BGR", RUBY_METHOD_FUNC(rb_HLS2BGR), 1); rb_define_module_function(rb_module, "HLS2RGB", RUBY_METHOD_FUNC(rb_HLS2RGB), 1); rb_define_module_function(rb_module, "build_information", RUBY_METHOD_FUNC(rb_build_information), 0); }
void Init_llvmruby() { cLLVMRuby = rb_define_module("LLVM"); cLLVMType = rb_define_class_under(cLLVMRuby, "Type", rb_cObject); cLLVMPointerType = rb_define_class_under(cLLVMRuby, "PointerType", cLLVMType); cLLVMStructType = rb_define_class_under(cLLVMRuby, "StructType", cLLVMType); cLLVMArrayType = rb_define_class_under(cLLVMRuby, "ArrayType", cLLVMType); cLLVMVectorType = rb_define_class_under(cLLVMRuby, "VectorType", cLLVMType); cLLVMFunctionType = rb_define_class_under(cLLVMRuby, "FunctionType", cLLVMType); cLLVMValue = rb_define_class_under(cLLVMRuby, "Value", rb_cObject); cLLVMUser = rb_define_class_under(cLLVMRuby, "User", cLLVMValue); cLLVMUse = rb_define_class_under(cLLVMRuby, "Use", rb_cObject); cLLVMModule = rb_define_class_under(cLLVMRuby, "Module", rb_cObject); cLLVMFunction = rb_define_class_under(cLLVMRuby, "Function", rb_cObject); cLLVMBasicBlock = rb_define_class_under(cLLVMRuby, "BasicBlock", cLLVMValue); cLLVMBuilder = rb_define_class_under(cLLVMRuby, "Builder", rb_cObject); cLLVMInstruction = rb_define_class_under(cLLVMRuby, "Instruction", cLLVMUser); cLLVMUnaryInstruction = rb_define_class_under(cLLVMRuby, "UnaryInstruction", cLLVMInstruction); cLLVMBinaryOperator = rb_define_class_under(cLLVMRuby, "BinaryOperator", cLLVMInstruction); cLLVMTerminatorInst = rb_define_class_under(cLLVMRuby, "TerminatorInst", cLLVMInstruction); cLLVMAllocationInst = rb_define_class_under(cLLVMRuby, "AllocationInst", cLLVMInstruction); cLLVMBinaryOps = rb_define_class_under(cLLVMInstruction, "BinaryOps", rb_cObject); #define HANDLE_TERM_INST(Num, Opcode, Klass) cLLVM##Klass = rb_define_class_under(cLLVMRuby, #Klass, cLLVMTerminatorInst); #include "llvm/Instruction.def" cLLVMLoadInst = rb_define_class_under(cLLVMRuby, "LoadInst", cLLVMUnaryInstruction); cLLVMStoreInst = rb_define_class_under(cLLVMRuby, "StoreInst", cLLVMInstruction); cLLVMFreeInst = rb_define_class_under(cLLVMRuby, "FreeInst", cLLVMUnaryInstruction); cLLVMGetElementPtrInst = rb_define_class_under(cLLVMRuby, "GetElementPtrInst", cLLVMInstruction); cLLVMAllocaInst = rb_define_class_under(cLLVMRuby, "AllocaInst", cLLVMAllocationInst); cLLVMMallocInst = rb_define_class_under(cLLVMRuby, "MallocInst", cLLVMAllocationInst); cLLVMCmpInst = rb_define_class_under(cLLVMRuby, "CmpInst", cLLVMInstruction); cLLVMICmpInst = rb_define_class_under(cLLVMRuby, "ICmpInst", cLLVMCmpInst); cLLVMFCmpInst = rb_define_class_under(cLLVMRuby, "FCmpInst", cLLVMCmpInst); cLLVMPhi = rb_define_class_under(cLLVMRuby, "Phi", cLLVMValue); cLLVMPassManager = rb_define_class_under(cLLVMRuby, "PassManager", rb_cObject); cLLVMExecutionEngine = rb_define_class_under(cLLVMRuby, "ExecutionEngine", rb_cObject); init_types(); rb_define_module_function(cLLVMType, "pointer", llvm_type_pointer, 1); rb_define_module_function(cLLVMType, "struct", llvm_type_struct, 1); rb_define_module_function(cLLVMType, "array", llvm_type_array, 2); rb_define_module_function(cLLVMType, "vector", llvm_type_vector, 2); rb_define_module_function(cLLVMType, "function", llvm_type_function, -1); rb_define_method(cLLVMType, "to_s", llvm_type_to_s, 0); rb_define_method(cLLVMType, "type_id", llvm_type_type_id, 0); rb_define_module_function(cLLVMValue, "get_constant", llvm_value_get_constant, 2); rb_define_module_function(cLLVMValue, "get_float_constant", llvm_value_get_float_constant, 1); rb_define_module_function(cLLVMValue, "get_double_constant", llvm_value_get_double_constant, 1); rb_define_module_function(cLLVMValue, "get_immediate_constant", llvm_value_get_immediate_constant, 1); rb_define_module_function(cLLVMValue, "get_struct_constant", llvm_value_get_struct_constant, -1); rb_define_method(cLLVMValue, "name", llvm_value_name, 0); rb_define_method(cLLVMValue, "name=", llvm_value_set_name, 1); rb_define_method(cLLVMValue, "type", llvm_value_type, 0); rb_define_method(cLLVMValue, "num_uses", llvm_value_num_uses, 0); rb_define_method(cLLVMValue, "used_in_basic_block?", llvm_value_used_in_basic_block, 1); rb_define_method(cLLVMValue, "replace_all_uses_with", llvm_value_replace_all_uses_with, 1); rb_define_method(cLLVMValue, "is_constant", llvm_value_is_constant, 0); rb_define_method(cLLVMValue, "is_int_constant", llvm_value_is_int_constant, 0); rb_define_method(cLLVMValue, "is_float_constant", llvm_value_is_float_constant, 0); rb_define_method(cLLVMValue, "get_int_constant_value", llvm_value_get_int_constant_value, 0); rb_define_method(cLLVMValue, "get_float_constant_value", llvm_value_get_float_constant_value, 0); rb_define_method(cLLVMValue, "is_null", llvm_value_is_null, 0); rb_define_method(cLLVMValue, "is_undef", llvm_value_is_undef, 0); rb_define_method(cLLVMUser, "get_operand_list", llvm_user_get_operand_list, 0); rb_define_method(cLLVMUser, "get_num_operands", llvm_user_get_num_operands, 0); rb_define_method(cLLVMUser, "get_operand", llvm_user_get_operand, 1); rb_define_method(cLLVMUser, "set_operand", llvm_user_set_operand, 2); rb_define_method(cLLVMUser, "drop_all_references", llvm_user_drop_all_references, 0); rb_define_method(cLLVMUser, "replace_uses_of_with", llvm_user_replace_uses_of_with, 2); init_instructions(); rb_define_alloc_func(cLLVMModule, llvm_module_allocate); rb_define_module_function(cLLVMModule, "read_assembly", llvm_module_read_assembly, 1); rb_define_module_function(cLLVMModule, "read_bitcode", llvm_module_read_bitcode, 1); rb_define_method(cLLVMModule, "initialize", llvm_module_initialize, 1); rb_define_method(cLLVMModule, "get_or_insert_function", llvm_module_get_or_insert_function, 2); rb_define_method(cLLVMModule, "get_function", llvm_module_get_function, 1); rb_define_method(cLLVMModule, "global_constant", llvm_module_global_constant, 2); rb_define_method(cLLVMModule, "global_variable", llvm_module_global_variable, 2); rb_define_method(cLLVMModule, "external_function", llvm_module_external_function, 2); rb_define_method(cLLVMModule, "write_bitcode", llvm_module_write_bitcode, 1); rb_define_method(cLLVMModule, "inspect", llvm_module_inspect, 0); rb_define_method(cLLVMFunction, "create_block", llvm_function_create_block, 0); rb_define_method(cLLVMFunction, "arguments", llvm_function_arguments, 0); rb_define_method(cLLVMFunction, "inspect", llvm_function_inspect, 0); rb_define_method(cLLVMFunction, "get_basic_block_list", llvm_function_get_basic_block_list, 0); rb_define_method(cLLVMFunction, "set_gc", llvm_function_set_gc, 1); rb_define_method(cLLVMBasicBlock, "builder", llvm_basic_block_builder, 0); rb_define_method(cLLVMBasicBlock, "size", llvm_basic_block_size, 0); rb_define_method(cLLVMBasicBlock, "get_instruction_list", llvm_basic_block_get_instruction_list, 0); rb_define_method(cLLVMInstruction, "inspect", llvm_instruction_inspect, 0); rb_define_method(cLLVMInstruction, "get_opcode_name", llvm_instruction_get_opcode_name, 0); rb_define_method(cLLVMInstruction, "may_read_from_memory?", llvm_instruction_may_read_from_memory, 0); rb_define_method(cLLVMInstruction, "may_write_to_memory?", llvm_instruction_may_write_to_memory, 0); rb_define_method(cLLVMInstruction, "identical_to?", llvm_instruction_is_identical_to, 1); rb_define_method(cLLVMInstruction, "same_operation_as?", llvm_instruction_is_same_operation_as, 1); rb_define_method(cLLVMInstruction, "used_outside_of_block?", llvm_instruction_is_used_outside_of_block, 1); rb_define_method(cLLVMTerminatorInst, "num_successors", llvm_terminator_inst_num_successors, 0); rb_define_method(cLLVMTerminatorInst, "get_successor", llvm_terminator_inst_get_successor, 1); rb_define_method(cLLVMTerminatorInst, "set_successor", llvm_terminator_inst_set_successor, 2); rb_define_method(cLLVMBranchInst, "conditional?", llvm_branch_inst_is_conditional, 0); rb_define_method(cLLVMBranchInst, "unconditional?", llvm_branch_inst_is_unconditional, 0); rb_define_method(cLLVMBranchInst, "condition", llvm_branch_inst_get_condition, 0); rb_define_method(cLLVMBranchInst, "condition=", llvm_branch_inst_set_condition, 1); rb_define_method(cLLVMSwitchInst, "get_default_dest", llvm_switch_inst_get_default_dest, 0); rb_define_method(cLLVMSwitchInst, "get_num_cases", llvm_switch_inst_get_num_cases, 0); rb_define_method(cLLVMSwitchInst, "add_case", llvm_switch_inst_add_case, 2); rb_define_method(cLLVMAllocationInst, "array_allocation?", llvm_allocation_inst_is_array_allocation, 0); rb_define_method(cLLVMAllocationInst, "array_size", llvm_allocation_inst_array_size, 0); rb_define_method(cLLVMAllocationInst, "allocated_type", llvm_allocation_inst_allocated_type, 0); rb_define_method(cLLVMAllocationInst, "alignment", llvm_allocation_inst_alignment, 0); rb_define_method(cLLVMBuilder, "set_insert_point", llvm_builder_set_insert_point, 1); rb_define_method(cLLVMBuilder, "bin_op", llvm_builder_bin_op, 3); rb_define_method(cLLVMBuilder, "phi", llvm_builder_phi, 1); rb_define_method(cLLVMBuilder, "return", llvm_builder_return, 1); rb_define_method(cLLVMBuilder, "br", llvm_builder_br, 1); rb_define_method(cLLVMBuilder, "cond_br", llvm_builder_cond_br, 3); rb_define_method(cLLVMBuilder, "switch", llvm_builder_switch, 2); rb_define_method(cLLVMBuilder, "invoke", llvm_builder_invoke, -1); rb_define_method(cLLVMBuilder, "unwind", llvm_builder_unwind, 0); rb_define_method(cLLVMBuilder, "malloc", llvm_builder_malloc, 2); rb_define_method(cLLVMBuilder, "free", llvm_builder_free, 1); rb_define_method(cLLVMBuilder, "alloca", llvm_builder_alloca, 2); rb_define_method(cLLVMBuilder, "load", llvm_builder_load, -1); rb_define_method(cLLVMBuilder, "store", llvm_builder_store, -1); rb_define_method(cLLVMBuilder, "icmp", llvm_builder_icmp, 3); rb_define_method(cLLVMBuilder, "fcmp", llvm_builder_fcmp, 3); rb_define_method(cLLVMBuilder, "gep", llvm_builder_gep, 2); rb_define_method(cLLVMBuilder, "struct_gep", llvm_builder_struct_gep, 2); rb_define_method(cLLVMBuilder, "cast", llvm_builder_cast, 3); rb_define_method(cLLVMBuilder, "int_cast", llvm_builder_int_cast, 3); rb_define_method(cLLVMBuilder, "call", llvm_builder_call, -1); rb_define_method(cLLVMBuilder, "insert_element", llvm_builder_insert_element, 3); rb_define_method(cLLVMBuilder, "extract_element", llvm_builder_extract_element, 2); rb_define_method(cLLVMBuilder, "get_global", llvm_builder_get_global, 0); rb_define_method(cLLVMBuilder, "create_global_string_ptr", llvm_builder_create_global_string_ptr, 1); rb_define_method(cLLVMPhi, "add_incoming", llvm_phi_add_incoming, 2); rb_define_alloc_func(cLLVMModule, llvm_pass_manager_allocate); rb_define_method(cLLVMPassManager, "initialize", llvm_pass_manager_initialize, 0); rb_define_method(cLLVMPassManager, "run", llvm_pass_manager_run, 1); rb_define_module_function(cLLVMExecutionEngine, "get", llvm_execution_engine_get, 1); rb_define_module_function(cLLVMExecutionEngine, "run_function", llvm_execution_engine_run_function, -1); rb_define_module_function(cLLVMExecutionEngine, "run_autoconvert", llvm_execution_engine_run_autoconvert, 1); /* printf("sizeof long: %d\n", (int)sizeof(long)); printf("sizeof ptr: %d\n", (int)sizeof(long*)); printf("sizeof value: %d\n", (int)sizeof(VALUE)); printf("sizeof array: %d\n", (int)sizeof(struct RArray)); printf("sizeof int: %d\n", (int)sizeof(int)); printf("sizeof char: %d\n", (int)sizeof(char)); */ }
static VALUE module_specs_rb_define_module_function(VALUE self, VALUE cls, VALUE str_name) { rb_define_module_function(cls, RSTRING_PTR(str_name), module_specs_test_method, 0); return Qnil; }
void Init_msp_servo(VALUE mNewton) { VALUE mServo = rb_define_module_under(mNewton, "Servo"); rb_define_module_function(mServo, "is_valid?", VALUEFUNC(MSNewton::Servo::is_valid), 1); rb_define_module_function(mServo, "create", VALUEFUNC(MSNewton::Servo::create), 1); rb_define_module_function(mServo, "get_cur_angle", VALUEFUNC(MSNewton::Servo::get_cur_angle), 1); rb_define_module_function(mServo, "get_cur_omega", VALUEFUNC(MSNewton::Servo::get_cur_omega), 1); rb_define_module_function(mServo, "get_cur_acceleration", VALUEFUNC(MSNewton::Servo::get_cur_acceleration), 1); rb_define_module_function(mServo, "get_min", VALUEFUNC(MSNewton::Servo::get_min), 1); rb_define_module_function(mServo, "set_min", VALUEFUNC(MSNewton::Servo::set_min), 2); rb_define_module_function(mServo, "get_max", VALUEFUNC(MSNewton::Servo::get_max), 1); rb_define_module_function(mServo, "set_max", VALUEFUNC(MSNewton::Servo::set_max), 2); rb_define_module_function(mServo, "enable_limits", VALUEFUNC(MSNewton::Servo::enable_limits), 2); rb_define_module_function(mServo, "limits_enabled?", VALUEFUNC(MSNewton::Servo::limits_enabled), 1); rb_define_module_function(mServo, "get_rate", VALUEFUNC(MSNewton::Servo::get_rate), 1); rb_define_module_function(mServo, "set_rate", VALUEFUNC(MSNewton::Servo::set_rate), 2); rb_define_module_function(mServo, "get_power", VALUEFUNC(MSNewton::Servo::get_power), 1); rb_define_module_function(mServo, "set_power", VALUEFUNC(MSNewton::Servo::set_power), 2); rb_define_module_function(mServo, "get_reduction_ratio", VALUEFUNC(MSNewton::Servo::get_reduction_ratio), 1); rb_define_module_function(mServo, "set_reduction_ratio", VALUEFUNC(MSNewton::Servo::set_reduction_ratio), 2); rb_define_module_function(mServo, "get_controller", VALUEFUNC(MSNewton::Servo::get_controller), 1); rb_define_module_function(mServo, "set_controller", VALUEFUNC(MSNewton::Servo::set_controller), 2); }
void Init_gsl_sf_fermi_dirac(VALUE module) { VALUE mgsl_sf_fermi; rb_define_module_function(module, "fermi_dirac_m1", rb_gsl_sf_fermi_dirac_m1, 1); rb_define_module_function(module, "fermi_dirac_m1_e", rb_gsl_sf_fermi_dirac_m1_e, 1); rb_define_module_function(module, "fermi_dirac_0", rb_gsl_sf_fermi_dirac_0, 1); rb_define_module_function(module, "fermi_dirac_0_e", rb_gsl_sf_fermi_dirac_0_e, 1); rb_define_module_function(module, "fermi_dirac_1", rb_gsl_sf_fermi_dirac_1, 1); rb_define_module_function(module, "fermi_dirac_1_e", rb_gsl_sf_fermi_dirac_1_e, 1); rb_define_module_function(module, "fermi_dirac_2", rb_gsl_sf_fermi_dirac_2, 1); rb_define_module_function(module, "fermi_dirac_2_e", rb_gsl_sf_fermi_dirac_2_e, 1); rb_define_module_function(module, "fermi_dirac_int", rb_gsl_sf_fermi_dirac_int, 2); rb_define_module_function(module, "fermi_dirac_int_e", rb_gsl_sf_fermi_dirac_int_e, 2); rb_define_module_function(module, "fermi_dirac_mhalf", rb_gsl_sf_fermi_dirac_mhalf, 1); rb_define_module_function(module, "fermi_dirac_mhalf_e", rb_gsl_sf_fermi_dirac_mhalf_e, 1); rb_define_module_function(module, "fermi_dirac_half", rb_gsl_sf_fermi_dirac_half, 1); rb_define_module_function(module, "fermi_dirac_half_e", rb_gsl_sf_fermi_dirac_half_e, 1); rb_define_module_function(module, "fermi_dirac_3half", rb_gsl_sf_fermi_dirac_3half, 1); rb_define_module_function(module, "fermi_dirac_3half_e", rb_gsl_sf_fermi_dirac_3half_e, 1); rb_define_module_function(module, "fermi_dirac_inc_0", rb_gsl_sf_fermi_dirac_inc_0, 2); rb_define_module_function(module, "fermi_dirac_inc_0_e", rb_gsl_sf_fermi_dirac_inc_0_e, 2); mgsl_sf_fermi = rb_define_module_under(module, "Fermi_Dirac"); rb_define_module_function(mgsl_sf_fermi, "m1", rb_gsl_sf_fermi_dirac_m1, 1); rb_define_module_function(mgsl_sf_fermi, "m1_e", rb_gsl_sf_fermi_dirac_m1_e, 1); rb_define_module_function(mgsl_sf_fermi, "zero", rb_gsl_sf_fermi_dirac_0, 1); rb_define_module_function(mgsl_sf_fermi, "zero_e", rb_gsl_sf_fermi_dirac_0_e, 1); rb_define_module_function(mgsl_sf_fermi, "one", rb_gsl_sf_fermi_dirac_1, 1); rb_define_module_function(mgsl_sf_fermi, "one_e", rb_gsl_sf_fermi_dirac_1_e, 1); rb_define_module_function(mgsl_sf_fermi, "two", rb_gsl_sf_fermi_dirac_2, 1); rb_define_module_function(mgsl_sf_fermi, "two_e", rb_gsl_sf_fermi_dirac_2_e, 1); rb_define_module_function(mgsl_sf_fermi, "int", rb_gsl_sf_fermi_dirac_int, 2); rb_define_module_function(mgsl_sf_fermi, "int_e", rb_gsl_sf_fermi_dirac_int_e, 2); rb_define_module_function(mgsl_sf_fermi, "mhalf", rb_gsl_sf_fermi_dirac_mhalf, 1); rb_define_module_function(mgsl_sf_fermi, "mhalf_e", rb_gsl_sf_fermi_dirac_mhalf_e, 1); rb_define_module_function(mgsl_sf_fermi, "half", rb_gsl_sf_fermi_dirac_half, 1); rb_define_module_function(mgsl_sf_fermi, "half_e", rb_gsl_sf_fermi_dirac_half_e, 1); rb_define_module_function(mgsl_sf_fermi, "threehalf", rb_gsl_sf_fermi_dirac_3half, 1); rb_define_module_function(mgsl_sf_fermi, "threehalf_e", rb_gsl_sf_fermi_dirac_3half_e, 1); rb_define_module_function(mgsl_sf_fermi, "inc_0", rb_gsl_sf_fermi_dirac_inc_0, 2); rb_define_module_function(mgsl_sf_fermi, "inc_0_e", rb_gsl_sf_fermi_dirac_inc_0_e, 2); }
void Init_Math(void) { rb_mMath = rb_define_module("Math"); #ifdef M_PI rb_define_const(rb_mMath, "PI", DBL2NUM(M_PI)); #else rb_define_const(rb_mMath, "PI", DBL2NUM(atan(1.0)*4.0)); #endif #ifdef M_E rb_define_const(rb_mMath, "E", DBL2NUM(M_E)); #else rb_define_const(rb_mMath, "E", DBL2NUM(exp(1.0))); #endif rb_define_module_function(rb_mMath, "atan2", math_atan2, 2); rb_define_module_function(rb_mMath, "cos", math_cos, 1); rb_define_module_function(rb_mMath, "sin", math_sin, 1); rb_define_module_function(rb_mMath, "tan", math_tan, 1); rb_define_module_function(rb_mMath, "acos", math_acos, 1); rb_define_module_function(rb_mMath, "asin", math_asin, 1); rb_define_module_function(rb_mMath, "atan", math_atan, 1); rb_define_module_function(rb_mMath, "cosh", math_cosh, 1); rb_define_module_function(rb_mMath, "sinh", math_sinh, 1); rb_define_module_function(rb_mMath, "tanh", math_tanh, 1); rb_define_module_function(rb_mMath, "acosh", math_acosh, 1); rb_define_module_function(rb_mMath, "asinh", math_asinh, 1); rb_define_module_function(rb_mMath, "atanh", math_atanh, 1); rb_define_module_function(rb_mMath, "exp", math_exp, 1); rb_define_module_function(rb_mMath, "log", math_log, -1); rb_define_module_function(rb_mMath, "log2", math_log2, 1); rb_define_module_function(rb_mMath, "log10", math_log10, 1); rb_define_module_function(rb_mMath, "sqrt", math_sqrt, 1); rb_define_module_function(rb_mMath, "cbrt", math_cbrt, 1); rb_define_module_function(rb_mMath, "frexp", math_frexp, 1); rb_define_module_function(rb_mMath, "ldexp", math_ldexp, 2); rb_define_module_function(rb_mMath, "hypot", math_hypot, 2); rb_define_module_function(rb_mMath, "erf", math_erf, 1); rb_define_module_function(rb_mMath, "erfc", math_erfc, 1); rb_define_module_function(rb_mMath, "gamma", math_gamma, 1); rb_define_module_function(rb_mMath, "lgamma", math_lgamma, 1); }
/* * Many operating systems allow signals to be sent to running * processes. Some signals have a defined effect on the process, while * others may be trapped at the code level and acted upon. For * example, your process may trap the USR1 signal and use it to toggle * debugging, and may use TERM to initiate a controlled shutdown. * * pid = fork do * Signal.trap("USR1") do * $debug = !$debug * puts "Debug now: #$debug" * end * Signal.trap("TERM") do * puts "Terminating..." * shutdown() * end * # . . . do some work . . . * end * * Process.detach(pid) * * # Controlling program: * Process.kill("USR1", pid) * # ... * Process.kill("USR1", pid) * # ... * Process.kill("TERM", pid) * * produces: * Debug now: true * Debug now: false * Terminating... * * The list of available signal names and their interpretation is * system dependent. Signal delivery semantics may also vary between * systems; in particular signal delivery may not always be reliable. */ void Init_signal(void) { VALUE mSignal = rb_define_module("Signal"); rb_define_global_function("trap", sig_trap, -1); rb_define_module_function(mSignal, "trap", sig_trap, -1); rb_define_module_function(mSignal, "list", sig_list, 0); rb_define_module_function(mSignal, "signame", sig_signame, 1); rb_define_method(rb_eSignal, "initialize", esignal_init, -1); rb_define_method(rb_eSignal, "signo", esignal_signo, 0); rb_alias(rb_eSignal, rb_intern_const("signm"), rb_intern_const("message")); rb_define_method(rb_eInterrupt, "initialize", interrupt_init, -1); /* At this time, there is no subthread. Then sigmask guarantee atomics. */ rb_disable_interrupt(); install_sighandler(SIGINT, sighandler); #ifdef SIGHUP install_sighandler(SIGHUP, sighandler); #endif #ifdef SIGQUIT install_sighandler(SIGQUIT, sighandler); #endif #ifdef SIGTERM install_sighandler(SIGTERM, sighandler); #endif #ifdef SIGALRM install_sighandler(SIGALRM, sighandler); #endif #ifdef SIGUSR1 install_sighandler(SIGUSR1, sighandler); #endif #ifdef SIGUSR2 install_sighandler(SIGUSR2, sighandler); #endif if (!ruby_enable_coredump) { #ifdef SIGBUS install_sighandler(SIGBUS, (sighandler_t)sigbus); #endif #ifdef SIGILL install_sighandler(SIGILL, (sighandler_t)sigill); #endif #ifdef SIGSEGV # ifdef USE_SIGALTSTACK rb_register_sigaltstack(GET_THREAD()); # endif install_sighandler(SIGSEGV, (sighandler_t)sigsegv); #endif } #ifdef SIGPIPE install_sighandler(SIGPIPE, SIG_IGN); #endif #if defined(SIGCLD) init_sigchld(SIGCLD); #elif defined(SIGCHLD) init_sigchld(SIGCHLD); #endif rb_enable_interrupt(); }
void Init_svd() { VALUE module = rb_define_module("SVD\n"); rb_define_module_function(module, "decompose", decompose, 3); }
void Init_dl(void) { void Init_dlhandle(void); void Init_dlcfunc(void); void Init_dlptr(void); rbdl_id_cdecl = rb_intern_const("cdecl"); rbdl_id_stdcall = rb_intern_const("stdcall"); /* Document-module: DL * * A bridge to the dlopen() or dynamic library linker function. * * == Example * * bash $> cat > sum.c <<EOF * double sum(double *arry, int len) * { * double ret = 0; * int i; * for(i = 0; i < len; i++){ * ret = ret + arry[i]; * } * return ret; * } * * double split(double num) * { * double ret = 0; * ret = num / 2; * return ret; * } * EOF * bash $> gcc -o libsum.so -shared sum.c * bash $> cat > sum.rb <<EOF * require 'dl' * require 'dl/import' * * module LibSum * extend DL::Importer * dlload './libsum.so' * extern 'double sum(double*, int)' * extern 'double split(double)' * end * * a = [2.0, 3.0, 4.0] * * sum = LibSum.sum(a.pack("d*"), a.count) * p LibSum.split(sum) * EOF * bash $> ruby sum.rb * 4.5 * * WIN! :-) */ rb_mDL = rb_define_module("DL"); /* * Document-class: DL::DLError * * standard dynamic load exception */ rb_eDLError = rb_define_class_under(rb_mDL, "DLError", rb_eStandardError); /* * Document-class: DL::DLTypeError * * dynamic load incorrect type exception */ rb_eDLTypeError = rb_define_class_under(rb_mDL, "DLTypeError", rb_eDLError); /* Document-const: MAX_CALLBACK * * Maximum number of callbacks */ rb_define_const(rb_mDL, "MAX_CALLBACK", INT2NUM(MAX_CALLBACK)); /* Document-const: DLSTACK_SIZE * * Dynamic linker stack size */ rb_define_const(rb_mDL, "DLSTACK_SIZE", INT2NUM(DLSTACK_SIZE)); rb_dl_init_callbacks(rb_mDL); /* Document-const: RTLD_GLOBAL * * rtld DL::Handle flag. * * The symbols defined by this library will be made available for symbol * resolution of subsequently loaded libraries. */ rb_define_const(rb_mDL, "RTLD_GLOBAL", INT2NUM(RTLD_GLOBAL)); /* Document-const: RTLD_LAZY * * rtld DL::Handle flag. * * Perform lazy binding. Only resolve symbols as the code that references * them is executed. If the symbol is never referenced, then it is never * resolved. (Lazy binding is only performed for function references; * references to variables are always immediately bound when the library * is loaded.) */ rb_define_const(rb_mDL, "RTLD_LAZY", INT2NUM(RTLD_LAZY)); /* Document-const: RTLD_NOW * * rtld DL::Handle flag. * * If this value is specified or the environment variable LD_BIND_NOW is * set to a nonempty string, all undefined symbols in the library are * resolved before dlopen() returns. If this cannot be done an error is * returned. */ rb_define_const(rb_mDL, "RTLD_NOW", INT2NUM(RTLD_NOW)); /* Document-const: TYPE_VOID * * DL::CFunc type - void */ rb_define_const(rb_mDL, "TYPE_VOID", INT2NUM(DLTYPE_VOID)); /* Document-const: TYPE_VOIDP * * DL::CFunc type - void* */ rb_define_const(rb_mDL, "TYPE_VOIDP", INT2NUM(DLTYPE_VOIDP)); /* Document-const: TYPE_CHAR * * DL::CFunc type - char */ rb_define_const(rb_mDL, "TYPE_CHAR", INT2NUM(DLTYPE_CHAR)); /* Document-const: TYPE_SHORT * * DL::CFunc type - short */ rb_define_const(rb_mDL, "TYPE_SHORT", INT2NUM(DLTYPE_SHORT)); /* Document-const: TYPE_INT * * DL::CFunc type - int */ rb_define_const(rb_mDL, "TYPE_INT", INT2NUM(DLTYPE_INT)); /* Document-const: TYPE_LONG * * DL::CFunc type - long */ rb_define_const(rb_mDL, "TYPE_LONG", INT2NUM(DLTYPE_LONG)); #if HAVE_LONG_LONG /* Document-const: TYPE_LONG_LONG * * DL::CFunc type - long long */ rb_define_const(rb_mDL, "TYPE_LONG_LONG", INT2NUM(DLTYPE_LONG_LONG)); #endif /* Document-const: TYPE_FLOAT * * DL::CFunc type - float */ rb_define_const(rb_mDL, "TYPE_FLOAT", INT2NUM(DLTYPE_FLOAT)); /* Document-const: TYPE_DOUBLE * * DL::CFunc type - double */ rb_define_const(rb_mDL, "TYPE_DOUBLE", INT2NUM(DLTYPE_DOUBLE)); /* Document-const: TYPE_SIZE_T * * DL::CFunc type - size_t */ rb_define_const(rb_mDL, "TYPE_SIZE_T", INT2NUM(DLTYPE_SIZE_T)); /* Document-const: TYPE_SSIZE_T * * DL::CFunc type - ssize_t */ rb_define_const(rb_mDL, "TYPE_SSIZE_T", INT2NUM(DLTYPE_SSIZE_T)); /* Document-const: TYPE_PTRDIFF_T * * DL::CFunc type - ptrdiff_t */ rb_define_const(rb_mDL, "TYPE_PTRDIFF_T", INT2NUM(DLTYPE_PTRDIFF_T)); /* Document-const: TYPE_INTPTR_T * * DL::CFunc type - intptr_t */ rb_define_const(rb_mDL, "TYPE_INTPTR_T", INT2NUM(DLTYPE_INTPTR_T)); /* Document-const: TYPE_UINTPTR_T * * DL::CFunc type - uintptr_t */ rb_define_const(rb_mDL, "TYPE_UINTPTR_T", INT2NUM(DLTYPE_UINTPTR_T)); /* Document-const: ALIGN_VOIDP * * The alignment size of a void* */ rb_define_const(rb_mDL, "ALIGN_VOIDP", INT2NUM(ALIGN_VOIDP)); /* Document-const: ALIGN_CHAR * * The alignment size of a char */ rb_define_const(rb_mDL, "ALIGN_CHAR", INT2NUM(ALIGN_CHAR)); /* Document-const: ALIGN_SHORT * * The alignment size of a short */ rb_define_const(rb_mDL, "ALIGN_SHORT", INT2NUM(ALIGN_SHORT)); /* Document-const: ALIGN_INT * * The alignment size of an int */ rb_define_const(rb_mDL, "ALIGN_INT", INT2NUM(ALIGN_INT)); /* Document-const: ALIGN_LONG * * The alignment size of a long */ rb_define_const(rb_mDL, "ALIGN_LONG", INT2NUM(ALIGN_LONG)); #if HAVE_LONG_LONG /* Document-const: ALIGN_LONG_LONG * * The alignment size of a long long */ rb_define_const(rb_mDL, "ALIGN_LONG_LONG", INT2NUM(ALIGN_LONG_LONG)); #endif /* Document-const: ALIGN_FLOAT * * The alignment size of a float */ rb_define_const(rb_mDL, "ALIGN_FLOAT", INT2NUM(ALIGN_FLOAT)); /* Document-const: ALIGN_DOUBLE * * The alignment size of a double */ rb_define_const(rb_mDL, "ALIGN_DOUBLE",INT2NUM(ALIGN_DOUBLE)); /* Document-const: ALIGN_SIZE_T * * The alignment size of a size_t */ rb_define_const(rb_mDL, "ALIGN_SIZE_T", INT2NUM(ALIGN_OF(size_t))); /* Document-const: ALIGN_SSIZE_T * * The alignment size of a ssize_t */ rb_define_const(rb_mDL, "ALIGN_SSIZE_T", INT2NUM(ALIGN_OF(size_t))); /* same as size_t */ /* Document-const: ALIGN_PTRDIFF_T * * The alignment size of a ptrdiff_t */ rb_define_const(rb_mDL, "ALIGN_PTRDIFF_T", INT2NUM(ALIGN_OF(ptrdiff_t))); /* Document-const: ALIGN_INTPTR_T * * The alignment size of a intptr_t */ rb_define_const(rb_mDL, "ALIGN_INTPTR_T", INT2NUM(ALIGN_OF(intptr_t))); /* Document-const: ALIGN_UINTPTR_T * * The alignment size of a uintptr_t */ rb_define_const(rb_mDL, "ALIGN_UINTPTR_T", INT2NUM(ALIGN_OF(uintptr_t))); /* Document-const: SIZEOF_VOIDP * * size of a void* */ rb_define_const(rb_mDL, "SIZEOF_VOIDP", INT2NUM(sizeof(void*))); /* Document-const: SIZEOF_CHAR * * size of a char */ rb_define_const(rb_mDL, "SIZEOF_CHAR", INT2NUM(sizeof(char))); /* Document-const: SIZEOF_SHORT * * size of a short */ rb_define_const(rb_mDL, "SIZEOF_SHORT", INT2NUM(sizeof(short))); /* Document-const: SIZEOF_INT * * size of an int */ rb_define_const(rb_mDL, "SIZEOF_INT", INT2NUM(sizeof(int))); /* Document-const: SIZEOF_LONG * * size of a long */ rb_define_const(rb_mDL, "SIZEOF_LONG", INT2NUM(sizeof(long))); #if HAVE_LONG_LONG /* Document-const: SIZEOF_LONG_LONG * * size of a long long */ rb_define_const(rb_mDL, "SIZEOF_LONG_LONG", INT2NUM(sizeof(LONG_LONG))); #endif /* Document-const: SIZEOF_FLOAT * * size of a float */ rb_define_const(rb_mDL, "SIZEOF_FLOAT", INT2NUM(sizeof(float))); /* Document-const: SIZEOF_DOUBLE * * size of a double */ rb_define_const(rb_mDL, "SIZEOF_DOUBLE",INT2NUM(sizeof(double))); /* Document-const: SIZEOF_SIZE_T * * size of a size_t */ rb_define_const(rb_mDL, "SIZEOF_SIZE_T", INT2NUM(sizeof(size_t))); /* Document-const: SIZEOF_SSIZE_T * * size of a ssize_t */ rb_define_const(rb_mDL, "SIZEOF_SSIZE_T", INT2NUM(sizeof(size_t))); /* same as size_t */ /* Document-const: SIZEOF_PTRDIFF_T * * size of a ptrdiff_t */ rb_define_const(rb_mDL, "SIZEOF_PTRDIFF_T", INT2NUM(sizeof(ptrdiff_t))); /* Document-const: SIZEOF_INTPTR_T * * size of a intptr_t */ rb_define_const(rb_mDL, "SIZEOF_INTPTR_T", INT2NUM(sizeof(intptr_t))); /* Document-const: SIZEOF_UINTPTR_T * * size of a intptr_t */ rb_define_const(rb_mDL, "SIZEOF_UINTPTR_T", INT2NUM(sizeof(uintptr_t))); rb_define_module_function(rb_mDL, "dlwrap", rb_dl_value2ptr, 1); rb_define_module_function(rb_mDL, "dlunwrap", rb_dl_ptr2value, 1); rb_define_module_function(rb_mDL, "dlopen", rb_dl_dlopen, -1); rb_define_module_function(rb_mDL, "malloc", rb_dl_malloc, 1); rb_define_module_function(rb_mDL, "realloc", rb_dl_realloc, 2); rb_define_module_function(rb_mDL, "free", rb_dl_free, 1); /* Document-const: RUBY_FREE * * Address of the ruby_xfree() function */ rb_define_const(rb_mDL, "RUBY_FREE", PTR2NUM(ruby_xfree)); /* Document-const: BUILD_RUBY_PLATFORM * * Platform built against (i.e. "x86_64-linux", etc.) * * See also RUBY_PLATFORM */ rb_define_const(rb_mDL, "BUILD_RUBY_PLATFORM", rb_str_new2(RUBY_PLATFORM)); /* Document-const: BUILD_RUBY_VERSION * * Ruby Version built. (i.e. "1.9.3") * * See also RUBY_VERSION */ rb_define_const(rb_mDL, "BUILD_RUBY_VERSION", rb_str_new2(RUBY_VERSION)); Init_dlhandle(); Init_dlcfunc(); Init_dlptr(); }
/* * INIT */ void Init_ossl_pkey() { #if 0 mOSSL = rb_define_module("OpenSSL"); /* let rdoc know about mOSSL */ #endif /* Document-module: OpenSSL::PKey * * == Asymmetric Public Key Algorithms * * Asymmetric public key algorithms solve the problem of establishing and * sharing secret keys to en-/decrypt messages. The key in such an * algorithm consists of two parts: a public key that may be distributed * to others and a private key that needs to remain secret. * * Messages encrypted with a public key can only be encrypted by * recipients that are in possession of the associated private key. * Since public key algorithms are considerably slower than symmetric * key algorithms (cf. OpenSSL::Cipher) they are often used to establish * a symmetric key shared between two parties that are in possession of * each other's public key. * * Asymmetric algorithms offer a lot of nice features that are used in a * lot of different areas. A very common application is the creation and * validation of digital signatures. To sign a document, the signatory * generally uses a message digest algorithm (cf. OpenSSL::Digest) to * compute a digest of the document that is then encrypted (i.e. signed) * using the private key. Anyone in possession of the public key may then * verify the signature by computing the message digest of the original * document on their own, decrypting the signature using the signatory's * public key and comparing the result to the message digest they * previously computed. The signature is valid if and only if the * decrypted signature is equal to this message digest. * * The PKey module offers support for three popular public/private key * algorithms: * * RSA (OpenSSL::PKey::RSA) * * DSA (OpenSSL::PKey::DSA) * * Elliptic Curve Cryptography (OpenSSL::PKey::EC) * Each of these implementations is in fact a sub-class of the abstract * PKey class which offers the interface for supporting digital signatures * in the form of PKey#sign and PKey#verify. * * == Diffie-Hellman Key Exchange * * Finally PKey also features OpenSSL::PKey::DH, an implementation of * the Diffie-Hellman key exchange protocol based on discrete logarithms * in finite fields, the same basis that DSA is built on. * The Diffie-Hellman protocol can be used to exchange (symmetric) keys * over insecure channels without needing any prior joint knowledge * between the participating parties. As the security of DH demands * relatively long "public keys" (i.e. the part that is overtly * transmitted between participants) DH tends to be quite slow. If * security or speed is your primary concern, OpenSSL::PKey::EC offers * another implementation of the Diffie-Hellman protocol. * */ mPKey = rb_define_module_under(mOSSL, "PKey"); /* Document-class: OpenSSL::PKey::PKeyError * *Raised when errors occur during PKey#sign or PKey#verify. */ ePKeyError = rb_define_class_under(mPKey, "PKeyError", eOSSLError); /* Document-class: OpenSSL::PKey::PKey * * An abstract class that bundles signature creation (PKey#sign) and * validation (PKey#verify) that is common to all implementations except * OpenSSL::PKey::DH * * OpenSSL::PKey::RSA * * OpenSSL::PKey::DSA * * OpenSSL::PKey::EC */ cPKey = rb_define_class_under(mPKey, "PKey", rb_cObject); rb_define_module_function(mPKey, "read", ossl_pkey_new_from_data, -1); rb_define_alloc_func(cPKey, ossl_pkey_alloc); rb_define_method(cPKey, "initialize", ossl_pkey_initialize, 0); rb_define_method(cPKey, "sign", ossl_pkey_sign, 2); rb_define_method(cPKey, "verify", ossl_pkey_verify, 3); id_private_q = rb_intern("private?"); /* * INIT rsa, dsa, dh, ec */ Init_ossl_rsa(); Init_ossl_dsa(); Init_ossl_dh(); Init_ossl_ec(); }
/*! * Defines a global function * \param name name of the function * \param func the method body * \param argc the number of parameters, or -1 or -2. see \ref defmethod. */ void rb_define_global_function(const char *name, VALUE (*func)(ANYARGS), int argc) { rb_define_module_function(rb_mKernel, name, func, argc); }
void Init_RRD( ) { mRRD = rb_define_module("RRD"); rb_eRRDError = rb_define_class("RRDError", rb_eStandardError); rb_define_module_function(mRRD, "create", rb_rrd_create, -2); rb_define_module_function(mRRD, "dump", rb_rrd_dump, -2); rb_define_module_function(mRRD, "fetch", rb_rrd_fetch, -2); rb_define_module_function(mRRD, "graph", rb_rrd_graph, -2); rb_define_module_function(mRRD, "last", rb_rrd_last, -2); rb_define_module_function(mRRD, "resize", rb_rrd_resize, -2); rb_define_module_function(mRRD, "restore", rb_rrd_restore, -2); rb_define_module_function(mRRD, "tune", rb_rrd_tune, -2); rb_define_module_function(mRRD, "update", rb_rrd_update, -2); rb_define_module_function(mRRD, "flushcached", rb_rrd_flushcached, -2); rb_define_module_function(mRRD, "info", rb_rrd_info, -2); rb_define_module_function(mRRD, "updatev", rb_rrd_updatev, -2); rb_define_module_function(mRRD, "graphv", rb_rrd_graphv, -2); rb_define_module_function(mRRD, "xport", rb_rrd_xport, -2); }
void Init_talib() { TA_Initialize(); /* * Ruby extension for technical functions library api. */ rb_mTaLib = rb_define_module("TaLib"); rb_define_const(rb_mTaLib, "TA_Input_Price", INT2FIX(TA_Input_Price)); rb_define_const(rb_mTaLib, "TA_Input_Real", INT2FIX(TA_Input_Real)); rb_define_const(rb_mTaLib, "TA_Input_Integer", INT2FIX(TA_Input_Integer)); rb_define_const(rb_mTaLib, "TA_IN_PRICE_OPEN", INT2FIX(TA_IN_PRICE_OPEN)); rb_define_const(rb_mTaLib, "TA_IN_PRICE_HIGH", INT2FIX(TA_IN_PRICE_HIGH)); rb_define_const(rb_mTaLib, "TA_IN_PRICE_LOW", INT2FIX(TA_IN_PRICE_LOW)); rb_define_const(rb_mTaLib, "TA_IN_PRICE_CLOSE", INT2FIX(TA_IN_PRICE_CLOSE)); rb_define_const(rb_mTaLib, "TA_IN_PRICE_VOLUME", INT2FIX(TA_IN_PRICE_VOLUME)); rb_define_const(rb_mTaLib, "TA_IN_PRICE_OPENINTEREST", INT2FIX(TA_IN_PRICE_OPENINTEREST)); rb_define_const(rb_mTaLib, "TA_IN_PRICE_TIMESTAMP", INT2FIX(TA_IN_PRICE_TIMESTAMP)); rb_define_const(rb_mTaLib, "TA_OptInput_RealRange", INT2FIX(TA_OptInput_RealRange)); rb_define_const(rb_mTaLib, "TA_OptInput_RealList", INT2FIX(TA_OptInput_RealList)); rb_define_const(rb_mTaLib, "TA_OptInput_IntegerRange", INT2FIX(TA_OptInput_IntegerRange)); rb_define_const(rb_mTaLib, "TA_OptInput_IntegerList", INT2FIX(TA_OptInput_IntegerList)); rb_define_const(rb_mTaLib, "TA_OPTIN_IS_PERCENT", INT2FIX(TA_OPTIN_IS_PERCENT)); rb_define_const(rb_mTaLib, "TA_OPTIN_IS_DEGREE", INT2FIX(TA_OPTIN_IS_DEGREE)); rb_define_const(rb_mTaLib, "TA_OPTIN_IS_CURRENCY", INT2FIX(TA_OPTIN_IS_CURRENCY)); rb_define_const(rb_mTaLib, "TA_OPTIN_ADVANCED", INT2FIX(TA_OPTIN_ADVANCED)); rb_define_const(rb_mTaLib, "TA_Output_Real", INT2FIX(TA_Output_Real)); rb_define_const(rb_mTaLib, "TA_Output_Integer", INT2FIX(TA_Output_Integer)); rb_define_const(rb_mTaLib, "TA_OUT_LINE", INT2FIX(TA_OUT_LINE)); rb_define_const(rb_mTaLib, "TA_OUT_DOT_LINE", INT2FIX(TA_OUT_DOT_LINE)); rb_define_const(rb_mTaLib, "TA_OUT_DASH_LINE", INT2FIX(TA_OUT_DASH_LINE)); rb_define_const(rb_mTaLib, "TA_OUT_DOT", INT2FIX(TA_OUT_DOT)); rb_define_const(rb_mTaLib, "TA_OUT_HISTO", INT2FIX(TA_OUT_HISTO)); rb_define_const(rb_mTaLib, "TA_OUT_PATTERN_BOOL", INT2FIX(TA_OUT_PATTERN_BOOL)); rb_define_const(rb_mTaLib, "TA_OUT_PATTERN_BULL_BEAR", INT2FIX(TA_OUT_PATTERN_BULL_BEAR)); rb_define_const(rb_mTaLib, "TA_OUT_PATTERN_STRENGTH", INT2FIX(TA_OUT_PATTERN_STRENGTH)); rb_define_const(rb_mTaLib, "TA_OUT_POSITIVE", INT2FIX(TA_OUT_POSITIVE)); rb_define_const(rb_mTaLib, "TA_OUT_NEGATIVE", INT2FIX(TA_OUT_NEGATIVE)); rb_define_const(rb_mTaLib, "TA_OUT_ZERO", INT2FIX(TA_OUT_ZERO)); rb_define_const(rb_mTaLib, "TA_OUT_UPPER_LIMIT", INT2FIX(TA_OUT_UPPER_LIMIT)); rb_define_const(rb_mTaLib, "TA_OUT_LOWER_LIMIT", INT2FIX(TA_OUT_LOWER_LIMIT)); rb_define_const(rb_mTaLib, "TA_MAType_SMA", INT2FIX((int)(TA_MAType_SMA))); rb_define_const(rb_mTaLib, "TA_MAType_EMA", INT2FIX((int)(TA_MAType_EMA))); rb_define_const(rb_mTaLib, "TA_MAType_WMA", INT2FIX((int)(TA_MAType_WMA))); rb_define_const(rb_mTaLib, "TA_MAType_DEMA", INT2FIX((int)(TA_MAType_DEMA))); rb_define_const(rb_mTaLib, "TA_MAType_TEMA", INT2FIX((int)(TA_MAType_TEMA))); rb_define_const(rb_mTaLib, "TA_MAType_TRIMA", INT2FIX((int)(TA_MAType_TRIMA))); rb_define_const(rb_mTaLib, "TA_MAType_KAMA", INT2FIX((int)(TA_MAType_KAMA))); rb_define_const(rb_mTaLib, "TA_MAType_MAMA", INT2FIX((int)(TA_MAType_MAMA))); rb_define_const(rb_mTaLib, "TA_MAType_T3", INT2FIX((int)(TA_MAType_T3))); rb_struct_define("TA_RealRange", "min", "max", "precision", NULL); rb_struct_define("TA_IntegerRange", "min", "max", NULL ); rb_struct_define("TA_RealDataPair", "value", "string", NULL ); rb_struct_define("TA_IntegerDataPair", "value", "string", NULL ); rb_struct_define("TA_RealList", "data", "nb_element", NULL ); rb_struct_define("TA_IntegerList", "data", "nb_element", NULL ); rb_sInParamInfo = rb_struct_define("TA_InputParameterInfo", "type", "param_name", "flags", NULL ); rb_sOptInParamInfo = rb_struct_define("TA_OutInputParameterInfo", "type", "param_name", "flags", "display_name", "data_set", "default_value", "hint", "help_file", NULL ); rb_sOutParamInfo = rb_struct_define("TA_OutputParameterInfo", "type", "param_name", "flags", NULL ); /* * Class for technical analysis function. */ rb_cTAFunction = rb_define_class_under(rb_mTaLib, "Function", rb_cObject); rb_define_alloc_func(rb_cTAFunction, ta_func_alloc); rb_define_method(rb_cTAFunction, "initialize", ta_func_initialize, 1); rb_define_attr(rb_cTAFunction, "result", 1, 1); rb_define_module_function( rb_cTAFunction, "groups", ta_func_get_groups, 0 ); rb_define_module_function( rb_cTAFunction, "functions", ta_func_get_functions, 0 ); rb_define_method( rb_cTAFunction, "ins", ta_func_get_input_count, 0 ); rb_define_method( rb_cTAFunction, "outs", ta_func_get_output_count, 0 ); rb_define_method( rb_cTAFunction, "opts", ta_func_get_option_input_count, 0 ); rb_define_method( rb_cTAFunction, "in", ta_func_input_param_info, 1); rb_define_method( rb_cTAFunction, "opt", ta_func_option_param_info, 1); rb_define_method( rb_cTAFunction, "out", ta_func_output_param_info, 1); rb_define_method( rb_cTAFunction, "in_int", ta_func_setup_in_integer, 2); rb_define_method( rb_cTAFunction, "in_real", ta_func_setup_in_real, 2); rb_define_method( rb_cTAFunction, "in_price", ta_func_setup_in_price, 7); rb_define_method( rb_cTAFunction, "opt_int", ta_func_setup_opt_in_integer, 2); rb_define_method( rb_cTAFunction, "opt_real", ta_func_setup_opt_in_real, 2); rb_define_method( rb_cTAFunction, "out_int", ta_func_setup_out_integer, 2); rb_define_method( rb_cTAFunction, "out_real", ta_func_setup_out_real, 2); rb_define_method( rb_cTAFunction, "lookback", ta_func_lookback, 0); rb_define_method( rb_cTAFunction, "call", ta_func_call, 2); }
void Init_simple_hash(void) { rb_mFairySimpleHash = rb_define_module_under(rb_mFairy, "SimpleHash"); rb_define_module_function(rb_mFairySimpleHash, "hash", rb_fairy_simple_hash, 1); }
/* * OpenSSL provides SSL, TLS and general purpose cryptography. It wraps the * OpenSSL[http://www.openssl.org/] library. * * = Examples * * All examples assume you have loaded OpenSSL with: * * require 'openssl' * * These examples build atop each other. For example the key created in the * next is used in throughout these examples. * * == Keys * * === Creating a Key * * This example creates a 2048 bit RSA keypair and writes it to the current * directory. * * key = OpenSSL::PKey::RSA.new 2048 * * open 'private_key.pem', 'w' do |io| io.write key.to_pem end * open 'public_key.pem', 'w' do |io| io.write key.public_key.to_pem end * * === Exporting a Key * * Keys saved to disk without encryption are not secure as anyone who gets * ahold of the key may use it unless it is encrypted. In order to securely * export a key you may export it with a pass phrase. * * cipher = OpenSSL::Cipher::Cipher.new 'AES-128-CBC' * pass_phrase = 'my secure pass phrase goes here' * * key_secure = key.export cipher, pass_phrase * * open 'private.secure.pem', 'w' do |io| * io.write key_secure * end * * OpenSSL::Cipher.ciphers returns a list of available ciphers. * * === Loading a Key * * A key can also be loaded from a file. * * key2 = OpenSSL::PKey::RSA.new File.read 'private_key.pem' * key2.public? # => true * * or * * key3 = OpenSSL::PKey::RSA.new File.read 'public_key.pem' * key3.private? # => false * * === Loading an Encrypted Key * * OpenSSL will prompt you for your pass phrase when loading an encrypted key. * If you will not be able to type in the pass phrase you may provide it when * loading the key: * * key4_pem = File.read 'private.secure.pem' * key4 = OpenSSL::PKey::RSA.new key4_pem, pass_phrase * * == RSA Encryption * * RSA provides ecryption and decryption using the public and private keys. * You can use a variety of padding methods depending upon the intended use of * encrypted data. * * === Encryption * * Documents encrypted with the public key can only be decrypted with the * private key. * * public_encrypted = key.public_encrypt 'top secret document' * * Documents encrypted with the private key can only be decrypted with the * public key. * * private_encrypted = key.private_encrypt 'public release document' * * === Decryption * * Use the opposite key type do decrypt the document * * top_secret = key.public_decrypt public_encrypted * * public_release = key.private_decrypt private_encrypted * * == PKCS #5 Password-based Encryption * * PKCS #5 is a password-based encryption standard documented at * RFC2898[http://www.ietf.org/rfc/rfc2898.txt]. It allows a short password or * passphrase to be used to create a secure encryption key. * * PKCS #5 uses a Cipher, a pass phrase and a salt to generate an encryption * key. * * pass_phrase = 'my secure pass phrase goes here' * salt = '8 octets' * * === Encryption * * First set up the cipher for encryption * * encrypter = OpenSSL::Cipher::Cipher.new 'AES-128-CBC' * encrypter.encrypt * encrypter.pkcs5_keyivgen pass_phrase, salt * * Then pass the data you want to encrypt through * * encrypted = encrypter.update 'top secret document' * encrypted << encrypter.final * * === Decryption * * Use a new Cipher instance set up for decryption * * decrypter = OpenSSL::Cipher::Cipher.new 'AES-128-CBC' * decrypter.decrypt * decrypter.pkcs5_keyivgen pass_phrase, salt * * Then pass the data you want to decrypt through * * plain = decrypter.update encrypted * plain << decrypter.final * * == X509 Certificates * * === Creating a Certificate * * This example creates a self-signed certificate using an RSA key and a SHA1 * signature. * * name = OpenSSL::X509::Name.parse 'CN=nobody/DC=example' * * cert = OpenSSL::X509::Certificate.new * cert.version = 2 * cert.serial = 0 * cert.not_before = Time.now * cert.not_after = Time.now + 3600 * * cert.public_key = key.public_key * cert.subject = name * * === Certificate Extensions * * You can add extensions to the certificate with * OpenSSL::SSL::ExtensionFactory to indicate the purpose of the certificate. * * extension_factory = OpenSSL::X509::ExtensionFactory.new nil, cert * * extension_factory.create_extension 'basicConstraints', 'CA:FALSE' * extension_factory.create_extension 'keyUsage', * 'keyEncipherment,dataEncipherment,digitalSignature' * extension_factory.create_extension 'subjectKeyIdentifier', 'hash' * * === Signing a Certificate * * To sign a certificate set the issuer and use OpenSSL::X509::Certificate#sign * with a digest algorithm. This creates a self-signed cert because we're using * the same name and key to sign the certificate as was used to create the * certificate. * * cert.issuer = name * cert.sign key, OpenSSL::Digest::SHA1.new * * open 'certificate.pem', 'w' do |io| io.write cert.to_pem end * * === Loading a Certificate * * Like a key, a cert can also be loaded from a file. * * cert2 = OpenSSL::X509::Certificate.new File.read 'certificate.pem' * * === Verifying a Certificate * * Certificate#verify will return true when a certificate was signed with the * given public key. * * raise 'certificate can not be verified' unless cert2.verify key * * == Certificate Authority * * A certificate authority (CA) is a trusted third party that allows you to * verify the ownership of unknown certificates. The CA issues key signatures * that indicate it trusts the user of that key. A user encountering the key * can verify the signature by using the CA's public key. * * === CA Key * * CA keys are valuable, so we encrypt and save it to disk and make sure it is * not readable by other users. * * ca_key = OpenSSL::PKey::RSA.new 2048 * * cipher = OpenSSL::Cipher::Cipher.new 'AES-128-CBC' * * open 'ca_key.pem', 'w', 0400 do |io| * io.write key.export(cipher, pass_phrase) * end * * === CA Certificate * * A CA certificate is created the same way we created a certificate above, but * with different extensions. * * ca_name = OpenSSL::X509::Name.parse 'CN=ca/DC=example' * * ca_cert = OpenSSL::X509::Certificate.new * ca_cert.serial = 0 * ca_cert.version = 2 * ca_cert.not_before = Time.now * ca_cert.not_after = Time.now + 86400 * * ca_cert.public_key = ca_key.public_key * ca_cert.subject = ca_name * ca_cert.issuer = ca_name * * extension_factory = OpenSSL::X509::ExtensionFactory.new * extension_factory.subject_certificate = ca_cert * extension_factory.issuer_certificate = ca_cert * * extension_factory.create_extension 'subjectKeyIdentifier', 'hash' * * This extension indicates the CA's key may be used as a CA. * * extension_factory.create_extension 'basicConstraints', 'CA:TRUE', true * * This extension indicates the CA's key may be used to verify signatures on * both certificates and certificate revocations. * * extension_factory.create_extension 'keyUsage', 'cRLSign,keyCertSign', true * * Root CA certificates are self-signed. * * ca_cert.sign ca_key, OpenSSL::Digest::SHA1.new * * The CA certificate is saved to disk so it may be distributed to all the * users of the keys this CA will sign. * * open 'ca_cert.pem', 'w' do |io| * io.write ca_cert.to_pem * end * * === Certificate Signing Request * * The CA signs keys through a Certificate Signing Request (CSR). The CSR * contains the information necessary to identify the key. * * csr = OpenSSL::X509::Request.new * csr.version = 0 * csr.subject = name * csr.public_key = key.public_key * csr.sign key, OpenSSL::Digest::SHA1.new * * A CSR is saved to disk and sent to the CA for signing. * * open 'csr.pem', 'w' do |io| * io.write csr.to_pem * end * * === Creating a Certificate from a CSR * * Upon receiving a CSR the CA will verify it before signing it. A minimal * verification would be to check the CSR's signature. * * csr = OpenSSL::X509::Request.new File.read 'csr.pem' * * raise 'CSR can not be verified' unless csr.verify csr.public_key * * After verification a certificate is created, marked for various usages, * signed with the CA key and returned to the requester. * * csr_cert = OpenSSL::X509::Certificate.new * csr_cert.serial = 0 * csr_cert.version = 2 * csr_cert.not_before = Time.now * csr_cert.not_after = Time.now + 600 * * csr_cert.subject = csr.subject * csr_cert.public_key = csr.public_key * csr_cert.issuer = ca_cert.subject * * extension_factory = OpenSSL::X509::ExtensionFactory.new * extension_factory.subject_certificate = csr_cert * extension_factory.issuer_certificate = ca_cert * * extension_factory.create_extension 'basicConstraints', 'CA:FALSE' * extension_factory.create_extension 'keyUsage', * 'keyEncipherment,dataEncipherment,digitalSignature' * extension_factory.create_extension 'subjectKeyIdentifier', 'hash' * * csr_cert.sign ca_key, OpenSSL::Digest::SHA1.new * * open 'csr_cert.pem', 'w' do |io| * io.write csr_cert.to_pem * end * * == SSL and TLS Connections * * Using our created key and certificate we can create an SSL or TLS connection. * An SSLContext is used to set up an SSL session. * * context = OpenSSL::SSL::SSLContext.new * * === SSL Server * * An SSL server requires the certificate and private key to communicate * securely with its clients: * * context.cert = cert * context.key = key * * Then create an SSLServer with a TCP server socket and the context. Use the * SSLServer like an ordinary TCP server. * * require 'socket' * * tcp_server = TCPServer.new 5000 * ssl_server = OpenSSL::SSL::SSLServer.new tcp_server, context * * loop do * ssl_connection = ssl_server.accept * * data = connection.gets * * response = "I got #{data.dump}" * puts response * * connection.puts "I got #{data.dump}" * connection.close * end * * === SSL client * * An SSL client is created with a TCP socket and the context. * SSLSocket#connect must be called to initiate the SSL handshake and start * encryption. A key and certificate are not required for the client socket. * * require 'socket' * * tcp_client = TCPSocket.new 'localhost', 5000 * ssl_client = OpenSSL::SSL::SSLSocket.new client_socket, context * ssl_client.connect * * ssl_client.puts "hello server!" * puts ssl_client.gets * * === Peer Verification * * An unverified SSL connection does not provide much security. For enhanced * security the client or server can verify the certificate the of its peer. * * The client can be modified to verify the server's certificate against the * certificate authority's certificate: * * context.ca_file = 'ca_cert.pem' * context.verify_mode = OpenSSL::SSL::VERIFY_PEER * * require 'socket' * * tcp_client = TCPSocket.new 'localhost', 5000 * ssl_client = OpenSSL::SSL::SSLSocket.new client_socket, context * ssl_client.connect * * ssl_client.puts "hello server!" * puts ssl_client.gets * * If the server certificate is invalid or <tt>context.ca_file</tt> is not set * when verifying peers an OpenSSL::SSL::SSLError will be raised. * */ void Init_openssl() { /* * Init timezone info */ #if 0 tzset(); #endif /* * Init all digests, ciphers */ /* CRYPTO_malloc_init(); */ /* ENGINE_load_builtin_engines(); */ OpenSSL_add_ssl_algorithms(); OpenSSL_add_all_algorithms(); ERR_load_crypto_strings(); SSL_load_error_strings(); /* * FIXME: * On unload do: */ #if 0 CONF_modules_unload(1); destroy_ui_method(); EVP_cleanup(); ENGINE_cleanup(); CRYPTO_cleanup_all_ex_data(); ERR_remove_state(0); ERR_free_strings(); #endif /* * Init main module */ mOSSL = rb_define_module("OpenSSL"); /* * Constants */ rb_define_const(mOSSL, "VERSION", rb_str_new2(OSSL_VERSION)); rb_define_const(mOSSL, "OPENSSL_VERSION", rb_str_new2(OPENSSL_VERSION_TEXT)); rb_define_const(mOSSL, "OPENSSL_VERSION_NUMBER", INT2NUM(OPENSSL_VERSION_NUMBER)); /* * Generic error, * common for all classes under OpenSSL module */ eOSSLError = rb_define_class_under(mOSSL,"OpenSSLError",rb_eStandardError); /* * Verify callback Proc index for ext-data */ if ((ossl_verify_cb_idx = X509_STORE_CTX_get_ex_new_index(0, (void *)"ossl_verify_cb_idx", 0, 0, 0)) < 0) ossl_raise(eOSSLError, "X509_STORE_CTX_get_ex_new_index"); /* * Init debug core */ dOSSL = Qfalse; rb_define_module_function(mOSSL, "debug", ossl_debug_get, 0); rb_define_module_function(mOSSL, "debug=", ossl_debug_set, 1); rb_define_module_function(mOSSL, "errors", ossl_get_errors, 0); /* * Get ID of to_der */ ossl_s_to_der = rb_intern("to_der"); /* * Init components */ Init_ossl_bn(); Init_ossl_cipher(); Init_ossl_config(); Init_ossl_digest(); Init_ossl_hmac(); Init_ossl_ns_spki(); Init_ossl_pkcs12(); Init_ossl_pkcs7(); Init_ossl_pkcs5(); Init_ossl_pkey(); Init_ossl_rand(); Init_ossl_ssl(); Init_ossl_x509(); Init_ossl_ocsp(); Init_ossl_engine(); Init_ossl_asn1(); }
void Init_rugged(void) { rb_mRugged = rb_define_module("Rugged"); /* Initialize the Error classes */ { int i; rb_eRuggedError = rb_define_class_under(rb_mRugged, "Error", rb_eStandardError); rb_eRuggedErrors[0] = Qnil; /* 0 return value -- no exception */ rb_eRuggedErrors[1] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[1], rb_eNoMemError); rb_eRuggedErrors[2] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[2], rb_eIOError); rb_eRuggedErrors[3] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[3], rb_eArgError); for (i = 4; i < RUGGED_ERROR_COUNT; ++i) { rb_eRuggedErrors[i] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[i], rb_eRuggedError); } } rb_define_module_function(rb_mRugged, "libgit2_version", rb_git_libgit2_version, 0); rb_define_module_function(rb_mRugged, "features", rb_git_features, 0); rb_define_module_function(rb_mRugged, "valid_full_oid?", rb_git_valid_full_oid, 1); rb_define_module_function(rb_mRugged, "hex_to_raw", rb_git_hex_to_raw, 1); rb_define_module_function(rb_mRugged, "raw_to_hex", rb_git_raw_to_hex, 1); rb_define_module_function(rb_mRugged, "minimize_oid", rb_git_minimize_oid, -1); rb_define_module_function(rb_mRugged, "prettify_message", rb_git_prettify_message, -1); rb_define_module_function(rb_mRugged, "__cache_usage__", rb_git_cache_usage, 0); Init_rugged_reference(); Init_rugged_reference_collection(); Init_rugged_object(); Init_rugged_commit(); Init_rugged_tree(); Init_rugged_tag(); Init_rugged_tag_collection(); Init_rugged_blob(); Init_rugged_index(); Init_rugged_repo(); Init_rugged_revwalk(); Init_rugged_branch(); Init_rugged_branch_collection(); Init_rugged_config(); Init_rugged_remote(); Init_rugged_remote_collection(); Init_rugged_notes(); Init_rugged_settings(); Init_rugged_submodule(); Init_rugged_submodule_collection(); Init_rugged_diff(); Init_rugged_patch(); Init_rugged_diff_delta(); Init_rugged_diff_hunk(); Init_rugged_diff_line(); Init_rugged_blame(); Init_rugged_cred(); Init_rugged_backend(); /* * Sort the repository contents in no particular ordering; * this sorting is arbitrary, implementation-specific * and subject to change at any time. * This is the default sorting for new walkers. */ rb_define_const(rb_mRugged, "SORT_NONE", INT2FIX(GIT_SORT_NONE)); /* * Sort the repository contents in topological order * (parents before children); this sorting mode * can be combined with time sorting. */ rb_define_const(rb_mRugged, "SORT_TOPO", INT2FIX(GIT_SORT_TOPOLOGICAL)); /* * Sort the repository contents by commit time; * this sorting mode can be combined with * topological sorting. */ rb_define_const(rb_mRugged, "SORT_DATE", INT2FIX(GIT_SORT_TIME)); /* * Iterate through the repository contents in reverse * order; this sorting mode can be combined with * any of the above. */ rb_define_const(rb_mRugged, "SORT_REVERSE", INT2FIX(GIT_SORT_REVERSE)); /* Initialize libgit2 */ git_libgit2_init(); /* Hook a global object to cleanup the library * on shutdown */ rb_mShutdownHook = Data_Wrap_Struct(rb_cObject, NULL, &cleanup_cb, NULL); rb_global_variable(&rb_mShutdownHook); }
void Init_digest(void) { id_reset = rb_intern("reset"); id_update = rb_intern("update"); id_finish = rb_intern("finish"); id_digest = rb_intern("digest"); id_hexdigest = rb_intern("hexdigest"); id_digest_length = rb_intern("digest_length"); /* * module Digest */ rb_mDigest = rb_define_module("Digest"); /* module functions */ rb_define_module_function(rb_mDigest, "hexencode", rb_digest_s_hexencode, 1); /* * module Digest::Instance */ rb_mDigest_Instance = rb_define_module_under(rb_mDigest, "Instance"); /* instance methods that should be overridden */ rb_define_method(rb_mDigest_Instance, "update", rb_digest_instance_update, 1); rb_define_method(rb_mDigest_Instance, "<<", rb_digest_instance_update, 1); rb_define_private_method(rb_mDigest_Instance, "finish", rb_digest_instance_finish, 0); rb_define_method(rb_mDigest_Instance, "reset", rb_digest_instance_reset, 0); rb_define_method(rb_mDigest_Instance, "digest_length", rb_digest_instance_digest_length, 0); rb_define_method(rb_mDigest_Instance, "block_length", rb_digest_instance_block_length, 0); /* instance methods that may be overridden */ rb_define_method(rb_mDigest_Instance, "==", rb_digest_instance_equal, 1); rb_define_method(rb_mDigest_Instance, "inspect", rb_digest_instance_inspect, 0); /* instance methods that need not usually be overridden */ rb_define_method(rb_mDigest_Instance, "new", rb_digest_instance_new, 0); rb_define_method(rb_mDigest_Instance, "digest", rb_digest_instance_digest, -1); rb_define_method(rb_mDigest_Instance, "digest!", rb_digest_instance_digest_bang, 0); rb_define_method(rb_mDigest_Instance, "hexdigest", rb_digest_instance_hexdigest, -1); rb_define_method(rb_mDigest_Instance, "hexdigest!", rb_digest_instance_hexdigest_bang, 0); rb_define_method(rb_mDigest_Instance, "to_s", rb_digest_instance_to_s, 0); rb_define_method(rb_mDigest_Instance, "length", rb_digest_instance_length, 0); rb_define_method(rb_mDigest_Instance, "size", rb_digest_instance_length, 0); /* * class Digest::Class */ rb_cDigest_Class = rb_define_class_under(rb_mDigest, "Class", rb_cObject); rb_define_method(rb_cDigest_Class, "initialize", rb_digest_class_init, 0); rb_include_module(rb_cDigest_Class, rb_mDigest_Instance); /* class methods */ rb_define_singleton_method(rb_cDigest_Class, "digest", rb_digest_class_s_digest, -1); rb_define_singleton_method(rb_cDigest_Class, "hexdigest", rb_digest_class_s_hexdigest, -1); id_metadata = rb_intern("metadata"); /* class Digest::Base < Digest::Class */ rb_cDigest_Base = rb_define_class_under(rb_mDigest, "Base", rb_cDigest_Class); rb_define_alloc_func(rb_cDigest_Base, rb_digest_base_alloc); rb_define_method(rb_cDigest_Base, "initialize_copy", rb_digest_base_copy, 1); rb_define_method(rb_cDigest_Base, "reset", rb_digest_base_reset, 0); rb_define_method(rb_cDigest_Base, "update", rb_digest_base_update, 1); rb_define_method(rb_cDigest_Base, "<<", rb_digest_base_update, 1); rb_define_private_method(rb_cDigest_Base, "finish", rb_digest_base_finish, 0); rb_define_method(rb_cDigest_Base, "digest_length", rb_digest_base_digest_length, 0); rb_define_method(rb_cDigest_Base, "block_length", rb_digest_base_block_length, 0); }
void init_gmpbench_timing() { mGMP = rb_define_module("GMP"); rb_define_module_function(mGMP, "cputime", r_gmpmod_cputime, 0); rb_define_module_function(mGMP, "time", r_gmpmod_time, 0); }