extern "C" void evma_start_tls (const unsigned long binding) { ensure_eventmachine("evma_start_tls"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) ed->StartTls(); }
extern "C" void evma_set_tls_parms (const unsigned long binding, const char *privatekey_filename, const char *certchain_filename, int verify_peer) { ensure_eventmachine("evma_set_tls_parms"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) ed->SetTlsParms (privatekey_filename, certchain_filename, (verify_peer == 1 ? true : false)); }
extern "C" void evma_start_proxy (const unsigned long from, const unsigned long to, const unsigned long bufsize) { ensure_eventmachine("evma_start_proxy"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (from)); if (ed) ed->StartProxy(to, bufsize); }
extern "C" void evma_accept_ssl_peer (const unsigned long binding) { ensure_eventmachine("evma_accept_ssl_peer"); ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding)); if (cd) cd->AcceptSslPeer(); }
extern "C" void evma_close_connection (const unsigned long binding, int after_writing) { ensure_eventmachine("evma_close_connection"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) ed->ScheduleClose (after_writing ? true : false); }
extern "C" void evma_stop_proxy (const unsigned long from) { ensure_eventmachine("evma_stop_proxy"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (from)); if (ed) ed->StopProxy(); }
extern "C" int evma_send_file_data_to_connection (const unsigned long binding, const char *filename) { /* This is a sugaring over send_data_to_connection that reads a file into a * locally-allocated buffer, and sends the file data to the remote peer. * Return the number of bytes written to the caller. * TODO, needs to impose a limit on the file size. This is intended only for * small files. (I don't know, maybe 8K or less.) For larger files, use interleaved * I/O to avoid slowing the rest of the system down. * TODO: we should return a code rather than barf, in case of file-not-found. * TODO, does this compile on Windows? * TODO, given that we want this to work only with small files, how about allocating * the buffer on the stack rather than the heap? * * Modified 25Jul07. This now returns -1 on file-too-large; 0 for success, and a positive * errno in case of other errors. * * Contributed by Kirk Haines. */ char data[32*1024]; int r; ensure_eventmachine("evma_send_file_data_to_connection"); int Fd = open (filename, O_RDONLY); if (Fd < 0) return errno; // From here on, all early returns MUST close Fd. struct stat st; if (fstat (Fd, &st)) { int e = errno; close (Fd); return e; } off_t filesize = st.st_size; if (filesize <= 0) { close (Fd); return 0; } else if (filesize > (off_t) sizeof(data)) { close (Fd); return -1; } r = read (Fd, data, filesize); if (r != filesize) { int e = errno; close (Fd); return e; } evma_send_data_to_connection (binding, data, r); close (Fd); return 0; }
extern "C" X509 *evma_get_peer_cert (const unsigned long binding) { ensure_eventmachine("evma_get_peer_cert"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) return ed->GetPeerCert(); return NULL; }
extern "C" int evma_report_connection_error_status (const unsigned long binding) { ensure_eventmachine("evma_report_connection_error_status"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) return ed->ReportErrorStatus(); return -1; }
extern "C" int evma_send_datagram (const unsigned long binding, const char *data, int data_length, const char *address, int port) { ensure_eventmachine("evma_send_datagram"); DatagramDescriptor *dd = dynamic_cast <DatagramDescriptor*> (Bindable_t::GetObject (binding)); if (dd) return dd->SendOutboundDatagram(data, data_length, address, port); return -1; }
extern "C" int evma_send_data_to_connection (const unsigned long binding, const char *data, int data_length) { ensure_eventmachine("evma_send_data_to_connection"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) return ed->SendOutboundData(data, data_length); return -1; }
extern "C" unsigned long evma_proxied_bytes (const unsigned long from) { ensure_eventmachine("evma_proxied_bytes"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (from)); if (ed) return ed->GetProxiedBytes(); else return 0; }
extern "C" uint64_t evma_get_last_activity_time(const unsigned long from) { ensure_eventmachine("evma_get_last_activity_time"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (from)); if (ed) return ed->GetLastActivity(); else return 0; }
extern "C" int evma_set_comm_inactivity_timeout (const unsigned long binding, float value) { ensure_eventmachine("evma_set_comm_inactivity_timeout"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) { return ed->SetCommInactivityTimeout ((uint64_t)(value * 1000)); } else return 0; //Perhaps this should be an exception. Access to an unknown binding. }
extern "C" int evma_get_subprocess_status (const unsigned long binding, int *status) { ensure_eventmachine("evma_get_subprocess_status"); if (status) { *status = EventMachine->SubprocessExitStatus; return 1; } else return 0; }
extern "C" int evma_get_sockname (const unsigned long binding, struct sockaddr *sa) { ensure_eventmachine("evma_get_sockname"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) { return ed->GetSockname (sa) ? 1 : 0; } else return 0; }
extern "C" float evma_get_pending_connect_timeout (const unsigned long binding) { ensure_eventmachine("evma_get_pending_connect_timeout"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) { return ((float)ed->GetPendingConnectTimeout() / 1000); } else return 0.0; }
extern "C" int evma_set_pending_connect_timeout (const unsigned long binding, float value) { ensure_eventmachine("evma_set_pending_connect_timeout"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) { return ed->SetPendingConnectTimeout ((uint64_t)(value * 1000)); } else return 0; }
extern "C" float evma_get_comm_inactivity_timeout (const unsigned long binding) { ensure_eventmachine("evma_get_comm_inactivity_timeout"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) { return ((float)ed->GetCommInactivityTimeout() / 1000); } else return 0.0; //Perhaps this should be an exception. Access to an unknown binding. }
extern "C" int evma_get_file_descriptor (const unsigned long binding) { ensure_eventmachine("evma_get_file_descriptor"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) return ed->GetSocket(); else #ifdef BUILD_FOR_RUBY rb_raise(rb_eRuntimeError, "invalid binding to get_fd"); #else throw std::runtime_error ("invalid binding to get_fd"); #endif }
extern "C" int evma_detach_fd (const unsigned long binding) { ensure_eventmachine("evma_detach_fd"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); if (ed) return EventMachine->DetachFD (ed); else #ifdef BUILD_FOR_RUBY rb_raise(rb_eRuntimeError, "invalid binding to detach"); #else throw std::runtime_error ("invalid binding to detach"); #endif return -1; }
extern "C" int evma_get_subprocess_pid (const unsigned long binding, pid_t *pid) { ensure_eventmachine("evma_get_subprocess_pid"); #ifdef OS_UNIX PipeDescriptor *pd = dynamic_cast <PipeDescriptor*> (Bindable_t::GetObject (binding)); if (pd) { return pd->GetSubprocessPid (pid) ? 1 : 0; } else if (pid && EventMachine->SubprocessPid) { *pid = EventMachine->SubprocessPid; return 1; } else return 0; #else return 0; #endif }
extern "C" const unsigned long evma_install_oneshot_timer (int seconds) { ensure_eventmachine("evma_install_oneshot_timer"); return EventMachine->InstallOneshotTimer (seconds); }
extern "C" void evma_run_machine() { ensure_eventmachine("evma_run_machine"); EventMachine->Run(); }
extern "C" uint64_t evma_get_current_loop_time() { ensure_eventmachine("evma_get_current_loop_time"); return EventMachine->GetCurrentTime(); }
extern "C" int evma_set_heartbeat_interval(float interval) { ensure_eventmachine("evma_set_heartbeat_interval"); return EventMachine->SetHeartbeatInterval(interval); }
extern "C" float evma_get_heartbeat_interval() { ensure_eventmachine("evma_get_heartbeat_interval"); return EventMachine->GetHeartbeatInterval(); }
extern "C" void evma_release_library() { ensure_eventmachine("evma_release_library"); delete EventMachine; EventMachine = NULL; }
extern "C" const unsigned long evma_popen (char * const*cmd_strings) { ensure_eventmachine("evma_popen"); return EventMachine->Socketpair (cmd_strings); }
extern "C" int evma_get_outbound_data_size (const unsigned long binding) { ensure_eventmachine("evma_get_outbound_data_size"); EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding)); return ed ? ed->GetOutboundDataSize() : 0; }