static void zs_connecter( int fd, void* udata ) {
zsocket_t* zs = zs_get_by_fd( fd );
ssize_t n;
if ( zs->connect.ssl ) {
n = SSL_connect( zs->connect.ssl );
if ( n < 0 ) {
int err = SSL_get_error( zs->connect.ssl, n );
switch ( err ) {
case SSL_ERROR_WANT_READ:
FL_SET( zs->connect.status, ZS_STAT_WANT_READ_FROM_CONNECT );
return;
case SSL_ERROR_WANT_WRITE:
FL_SET( zs->connect.status, ZS_STAT_WANT_WRITE_FROM_CONNECT );
return;
}
ERR_print_errors_fp( stderr );
zs->connect.read.rw_errno = EPROTO;
zs->connect.write.rw_errno = EPROTO;
}
}
if ( FD_ISSET( fd, &active_write_fd_set ) && !FL_ISSET( zs->general.status, ZS_STAT_WRITABLE ) )
n_selectable++;
FL_SET( zs->connect.status, ZS_STAT_CONNECTED | ZS_STAT_WRITABLE );
FL_CLR( zs->general.status, ZS_STAT_CONNECTING );
}
static void zs_accepter( int fd, void* udata ) {
zsocket_t* zs = zs_get_by_fd( fd );
zsocket_t* zs_parent = zs_get_by_fd( zs->connect.parent_fd );
/* printf( "zs_accepter: %d: START\n", zs->general.sockfd );
ssize_t n;
if ( zs->connect.ssl ) {
n = SSL_accept( zs->connect.ssl );
if ( n < 0 ) {
int err = SSL_get_error( zs->connect.ssl, n );
printf("zs_accepter: %d: SSL_accept error %d ( %d, %d )\n", zs->general.sockfd, err, SSL_ERROR_WANT_READ, SSL_ERROR_WANT_WRITE );
switch ( err ) {
case SSL_ERROR_WANT_READ:
FL_SET( zs->connect.status, ZS_STAT_WANT_READ_FROM_ACCEPT );
return;
case SSL_ERROR_WANT_WRITE:
FL_SET( zs->connect.status, ZS_STAT_WANT_WRITE_FROM_ACCEPT );
return;
}
ERR_print_errors_fp( stderr );
zs_close( fd );
zs_parent->listen.accepted_fd = -1;
zs_parent->listen.accepted_errno = EPROTO;
}
printf( "zs_accepter: %d: SSL_accept accepted!\n", zs->general.sockfd );
}*/
if ( FD_ISSET( zs_parent->general.sockfd, &active_read_fd_set ) && !FL_ISSET( zs_parent->general.status, ZS_STAT_READABLE ) )
n_selectable++;
FL_SET( zs_parent->general.status, ZS_STAT_READABLE );
FL_CLR( zs_parent->general.status, ZS_STAT_ACCEPTING );
if ( zs_parent->listen.accepted_fd != -1 ) {
if ( FD_ISSET( fd, &active_write_fd_set ) && !FL_ISSET( zs->general.status, ZS_STAT_WRITABLE ) )
n_selectable++;
FL_SET( zs->connect.status, ZS_STAT_CONNECTED | ZS_STAT_WRITABLE );
if ( zs_is_ssl( fd ) )
FL_SET( zs->connect.status, ZS_STAT_ACCEPTING );
}
// Must call this inside zs_accepter because the
// parent zsocket's state update may not be called by
// the caller on return from calling zs_accepter,
// it may only call it for the child
zs_update_fd_state( zs_parent->general.sockfd, NULL );
}
static int
include_modules_at(const VALUE klass, VALUE c, VALUE module)
{
VALUE p, iclass;
int method_changed = 0, constant_changed = 0;
const st_table *const klass_m_tbl = RCLASS_M_TBL(RCLASS_ORIGIN(klass));
while (module) {
int superclass_seen = FALSE;
if (RCLASS_ORIGIN(module) != module)
goto skip;
if (klass_m_tbl && klass_m_tbl == RCLASS_M_TBL(module))
return -1;
/* ignore if the module included already in superclasses */
for (p = RCLASS_SUPER(klass); p; p = RCLASS_SUPER(p)) {
switch (BUILTIN_TYPE(p)) {
case T_ICLASS:
if (RCLASS_M_TBL_WRAPPER(p) == RCLASS_M_TBL_WRAPPER(module)) {
if (!superclass_seen) {
c = p; /* move insertion point */
}
goto skip;
}
break;
case T_CLASS:
superclass_seen = TRUE;
break;
}
}
iclass = rb_include_class_new(module, RCLASS_SUPER(c));
c = RCLASS_SET_SUPER(c, iclass);
if (BUILTIN_TYPE(module) == T_ICLASS) {
rb_module_add_to_subclasses_list(RBASIC(module)->klass, iclass);
} else {
rb_module_add_to_subclasses_list(module, iclass);
}
if (FL_TEST(klass, RMODULE_IS_REFINEMENT)) {
VALUE refined_class =
rb_refinement_module_get_refined_class(klass);
st_foreach(RMODULE_M_TBL(module), add_refined_method_entry_i,
(st_data_t) refined_class);
FL_SET(c, RMODULE_INCLUDED_INTO_REFINEMENT);
}
if (RMODULE_M_TBL(module) && RMODULE_M_TBL(module)->num_entries)
method_changed = 1;
if (RMODULE_CONST_TBL(module) && RMODULE_CONST_TBL(module)->num_entries)
constant_changed = 1;
skip:
module = RCLASS_SUPER(module);
}
if (method_changed) rb_clear_method_cache_by_class(klass);
if (constant_changed) rb_clear_constant_cache();
return method_changed;
}
/*!
* Creates a metaclass of \a klass
* \param klass a class
* \return created metaclass for the class
* \pre \a klass is a Class object
* \pre \a klass has no singleton class.
* \post the class of \a klass is the returned class.
* \post the returned class is meta^(n+1)-class when \a klass is a meta^(n)-klass for n >= 0
*/
static inline VALUE
make_metaclass(VALUE klass)
{
VALUE super;
VALUE metaclass = rb_class_boot(Qundef);
FL_SET(metaclass, FL_SINGLETON);
rb_singleton_class_attached(metaclass, klass);
if (META_CLASS_OF_CLASS_CLASS_P(klass)) {
METACLASS_OF(klass) = METACLASS_OF(metaclass) = metaclass;
}
else {
VALUE tmp = METACLASS_OF(klass); /* for a meta^(n)-class klass, tmp is meta^(n)-class of Class class */
METACLASS_OF(klass) = metaclass;
METACLASS_OF(metaclass) = ENSURE_EIGENCLASS(tmp);
}
super = RCLASS_SUPER(klass);
while (RB_TYPE_P(super, T_ICLASS)) super = RCLASS_SUPER(super);
RCLASS_SUPER(metaclass) = super ? ENSURE_EIGENCLASS(super) : rb_cClass;
OBJ_INFECT(metaclass, RCLASS_SUPER(metaclass));
return metaclass;
}
VALUE
rb_singleton_class_clone(VALUE obj)
{
VALUE klass = RBASIC(obj)->klass;
if (!FL_TEST(klass, FL_SINGLETON))
return klass;
else {
struct clone_method_data data;
/* copy singleton(unnamed) class */
VALUE clone = class_alloc(RBASIC(klass)->flags, 0);
if (BUILTIN_TYPE(obj) == T_CLASS) {
RBASIC(clone)->klass = (VALUE)clone;
}
else {
RBASIC(clone)->klass = rb_singleton_class_clone(klass);
}
RCLASS_SUPER(clone) = RCLASS_SUPER(klass);
if (RCLASS_IV_TBL(klass)) {
RCLASS_IV_TBL(clone) = st_copy(RCLASS_IV_TBL(klass));
}
RCLASS_M_TBL(clone) = st_init_numtable();
data.tbl = RCLASS_M_TBL(clone);
data.klass = (VALUE)clone;
st_foreach(RCLASS_M_TBL(klass), clone_method,
(st_data_t)&data);
rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);
FL_SET(clone, FL_SINGLETON);
return (VALUE)clone;
}
}
static VALUE
singleton_class_clone_int(VALUE obj, VALUE nklass)
{
VALUE klass = RBASIC(obj)->klass;
if (!FL_TEST(klass, FL_SINGLETON))
return klass;
else {
/* copy singleton(unnamed) class */
NEWOBJ(clone, struct RClass);
OBJSETUP(clone, 0, RBASIC(klass)->flags);
if (BUILTIN_TYPE(obj) == T_CLASS) {
RBASIC(clone)->klass = (VALUE)clone;
}
else {
RBASIC(clone)->klass = rb_singleton_class_clone(klass);
}
clone->super = RCLASS(klass)->super;
clone->iv_tbl = 0;
clone->m_tbl = 0;
if (RCLASS(klass)->iv_tbl) {
clone->iv_tbl = st_copy(RCLASS(klass)->iv_tbl);
}
clone->m_tbl = st_init_numtable();
st_foreach(RCLASS(klass)->m_tbl, (int (*)(...))clone_method, NIL_P(nklass) ? (VALUE)clone : nklass);
rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);
FL_SET(clone, FL_SINGLETON);
return (VALUE)clone;
}
}
/*!
* Creates a meta^(n+1)-class for a meta^(n)-class.
* \param metaclass a class of a class
* \return the created meta^(n+1)-class.
* \pre \a metaclass is a metaclass
* \post the class of \a metaclass is the returned class.
*/
static VALUE
make_metametaclass(VALUE metaclass)
{
VALUE metametaclass, super_of_metaclass;
if (RBASIC(metaclass)->klass == metaclass) { /* for meta^(n)-class of Class */
metametaclass = rb_class_boot(Qnil);
RBASIC(metametaclass)->klass = metametaclass;
}
else {
metametaclass = rb_class_boot(Qnil);
RBASIC(metametaclass)->klass =
(RBASIC(RBASIC(metaclass)->klass)->klass == RBASIC(metaclass)->klass)
? make_metametaclass(RBASIC(metaclass)->klass)
: RBASIC(RBASIC(metaclass)->klass)->klass;
}
FL_SET(metametaclass, FL_SINGLETON);
rb_singleton_class_attached(metametaclass, metaclass);
RBASIC(metaclass)->klass = metametaclass;
super_of_metaclass = RCLASS_SUPER(metaclass);
while (FL_TEST(super_of_metaclass, T_ICLASS)) {
super_of_metaclass = RCLASS_SUPER(super_of_metaclass);
}
RCLASS_SUPER(metametaclass) =
rb_iv_get(RBASIC(super_of_metaclass)->klass, "__attached__") == super_of_metaclass
? RBASIC(super_of_metaclass)->klass
: make_metametaclass(super_of_metaclass);
OBJ_INFECT(metametaclass, RCLASS_SUPER(metametaclass));
return metametaclass;
}
/* call-seq:
* to_class(klass=Object) -> Class
*
* Makes a copy of the module, converts the copy to a class, and returns it. The
* returned class can then have instances created from it. The +klass+ argument
* sets the superclass of the returned class. If +klass+ is not a Class,
* raises +TypeError+. */
static VALUE evilr_to_class(int argc, VALUE *argv, VALUE self) {
VALUE klass = evilr__optional_class(argc, argv);
self = rb_obj_clone(self);
RBASIC_SET_KLASS(self, rb_singleton_class(klass));
RCLASS_SET_SUPER(self, klass);
FL_UNSET(self, T_MASK);
FL_SET(self, T_CLASS);
return self;
}
static void zs_internal_read( int fd, void* udata ) {
zsocket_t* zs = zs_get_by_fd( fd );
assert( zs->type == ZSOCK_CONNECT );
if ( FL_ISSET( zs->connect.status, ZS_STAT_CONNECTED ) ) {
if ( !FL_ARESOMESET( zs->connect.status, ZS_STAT_WANT_READ_FROM_READ | ZS_STAT_WANT_READ_FROM_WRITE ) ) {
FL_SET( zs->connect.status, ZS_STAT_READING );
FL_SET( zs->connect.status, ZS_STAT_WANT_READ_FROM_READ );
}
if ( FL_ISSET( zs->connect.status, ZS_STAT_WANT_READ_FROM_READ ) ) {
// clear write_from_write, if read_from_write is not set clear fd select flag
FL_CLR( zs->connect.status, ZS_STAT_WANT_READ_FROM_READ );
zs_reader( fd, udata );
}
if ( FL_ISSET( zs->connect.status, ZS_STAT_WANT_READ_FROM_WRITE ) ) {
// clear write_from_read, if read_from_read is not set and read is not set clear fd select flag
FL_CLR( zs->connect.status, ZS_STAT_WANT_READ_FROM_WRITE );
zs_writer( fd, udata );
// zs_writer sometimes will call zs_close
if ( !zs_get_by_fd( fd ) ) return;
}
} else if ( FL_ISSET( zs->connect.status, ZS_STAT_CONNECTING ) ) {
FL_CLR( zs->connect.status, ZS_STAT_WANT_READ_FROM_CONNECT );
zs_connecter( fd, udata );
} else {
FL_CLR( zs->connect.status, ZS_STAT_WANT_READ_FROM_ACCEPT );
zs_accepter( fd, udata );
// zs_accpeter sometimes will call zclose
// if this happens we must return before
// before zs_update_fd_state tries to use it
if ( !zs_get_by_fd( fd ) ) return;
}
zs_update_fd_state( fd, udata );
}
/*!
* Creates a singleton class for \a obj.
* \pre \a obj must not a immediate nor a special const.
* \pre \a obj must not a Class object.
* \pre \a obj has no singleton class.
*/
static inline VALUE
make_singleton_class(VALUE obj)
{
VALUE orig_class = RBASIC(obj)->klass;
VALUE klass = rb_class_boot(orig_class);
FL_SET(klass, FL_SINGLETON);
RBASIC(obj)->klass = klass;
rb_singleton_class_attached(klass, obj);
METACLASS_OF(klass) = METACLASS_OF(rb_class_real(orig_class));
return klass;
}
static VALUE
ary_subseq(VALUE ary, int beg, int len)
{
VALUE ret;
if (len == 0)
return Qnil;
ret = ary_alloc();
FL_SET(ret, ELTS_SHARED);
RARRAY(ret)->aux.shared = ary;
RARRAY(ret)->ptr = RARRAY(ary)->ptr + beg;
RARRAY(ret)->len = len;
return ret;
}
int zs_close( int fd ) {
zsocket_t* p = zsockets[ fd ];
if ( !p ) {
errno = EBADF;
return -1;
}
if ( p->type == ZSOCK_LISTEN ) {
p->listen.n_open--;
if ( p->listen.n_open > 0 )
return 0;
} else {
if ( FL_ISSET( p->general.status, ZS_STAT_WRITING ) ) {
zs_clr_read( fd );
zs_clr_write( fd );
FL_SET( p->general.status, ZS_STAT_CLOSED );
return 0;
}
}
zfd_clr( fd, ZFD_R );
zfd_clr( fd, ZFD_W );
zs_clr_read( fd );
zs_clr_write( fd );
zsockets[ fd ] = NULL;
if ( p->type == ZSOCK_LISTEN ) {
close( p->listen.sockfd );
if ( p->listen.ssl_ctx )
SSL_CTX_free( p->listen.ssl_ctx );
} else if ( p->type == ZSOCK_CONNECT ) {
// Closing
if ( p->connect.ssl )
SSL_shutdown( p->connect.ssl );
close( p->connect.sockfd );
// Freeing
free( p->connect.read.buffer );
if ( p->connect.ssl )
SSL_free( p->connect.ssl );
if ( p->connect.write.buffer )
free( p->connect.write.buffer );
}
free( p );
return 0;
}
static VALUE
bug_str_s_cstr_noembed(VALUE self, VALUE str)
{
VALUE str2 = rb_str_new(NULL, 0);
long capacity = RSTRING_LEN(str) + TERM_LEN(str);
char *buf = ALLOC_N(char, capacity);
Check_Type(str, T_STRING);
FL_SET((str2), STR_NOEMBED);
memcpy(buf, RSTRING_PTR(str), capacity);
RBASIC(str2)->flags &= ~RSTRING_EMBED_LEN_MASK;
RSTRING(str2)->as.heap.aux.capa = capacity;
RSTRING(str2)->as.heap.ptr = buf;
RSTRING(str2)->as.heap.len = RSTRING_LEN(str);
TERM_FILL(RSTRING_END(str2), TERM_LEN(str));
return str2;
}
static VALUE
queue_do_close(VALUE self, int is_szq)
{
if (!queue_closed_p(self)) {
FL_SET(self, QUEUE_CLOSED);
if (queue_num_waiting(self) > 0) {
VALUE waiters = GET_QUEUE_WAITERS(self);
wakeup_all_threads(waiters);
}
if (is_szq && szqueue_num_waiting_producer(self) > 0) {
VALUE waiters = GET_SZQUEUE_WAITERS(self);
wakeup_all_threads(waiters);
}
}
return self;
}
/* note: this code is magical: */
static VALUE rb_str_new_move(char* data, size_t length)
{
NEWOBJ(str, struct RString);
OBJSETUP(str, rb_cString, T_STRING);
str->as.heap.ptr = data;
str->as.heap.len = length;
str->as.heap.aux.capa = length;
FL_SET(str, FL_USER1); /* set STR_NOEMBED */
RBASIC(str)->flags &= ~RSTRING_EMBED_LEN_MASK;
/* this is safe. see msgpack_postmem_alloc() */
data[length] = '\0';
/* ???: unknown whether this is needed or not */
OBJ_FREEZE(str);
return (VALUE) str;
}
VALUE
rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach)
{
VALUE klass = RBASIC(obj)->klass;
if (!FL_TEST(klass, FL_SINGLETON))
return klass;
else {
/* copy singleton(unnamed) class */
VALUE clone = class_alloc(RBASIC(klass)->flags, 0);
if (BUILTIN_TYPE(obj) == T_CLASS) {
RBASIC_SET_CLASS(clone, clone);
}
else {
RBASIC_SET_CLASS(clone, rb_singleton_class_clone(klass));
}
RCLASS_SET_SUPER(clone, RCLASS_SUPER(klass));
RCLASS_EXT(clone)->allocator = RCLASS_EXT(klass)->allocator;
if (RCLASS_IV_TBL(klass)) {
RCLASS_IV_TBL(clone) = rb_st_copy(clone, RCLASS_IV_TBL(klass));
}
if (RCLASS_CONST_TBL(klass)) {
struct clone_const_arg arg;
RCLASS_CONST_TBL(clone) = st_init_numtable();
arg.klass = clone;
arg.tbl = RCLASS_CONST_TBL(clone);
st_foreach(RCLASS_CONST_TBL(klass), clone_const_i, (st_data_t)&arg);
}
if (attach != Qundef) {
rb_singleton_class_attached(clone, attach);
}
RCLASS_M_TBL_INIT(clone);
st_foreach(RCLASS_M_TBL(klass), clone_method_i, (st_data_t)clone);
rb_singleton_class_attached(RBASIC(clone)->klass, clone);
FL_SET(clone, FL_SINGLETON);
return clone;
}
}
ssize_t zs_write( int fd, const void* buf, size_t nbyte ) {
zsocket_t* zs = zs_get_by_fd( fd );
if ( !zs || zs->type != ZSOCK_CONNECT || FL_ISSET( zs->general.status, ZS_STAT_CLOSED ) ) {
errno = EBADF;
fprintf( stderr, "%d: %d, bad\n", fd, zs->type );
return -1;
}
if ( !FL_ISSET( zs->connect.status, ZS_STAT_WRITABLE ) ) {
errno = EAGAIN;
return -1;
}
assert( !zs->connect.write.buffer );
if ( FD_ISSET( fd, &active_write_fd_set ) && FL_ISSET( zs->general.status, ZS_STAT_WRITABLE ) )
n_selectable--;
FL_CLR( zs->connect.status, ZS_STAT_WRITABLE );
if ( zs->connect.write.rw_errno ) {
errno = zs->connect.write.rw_errno || zs->connect.read.rw_errno;
zs->connect.write.rw_errno = 0;
nbyte = -1;
} else {
zs->connect.write.buffer = malloc( nbyte );
memcpy( zs->connect.write.buffer, buf, nbyte );
zs->connect.write.size = nbyte;
zs->connect.write.used = nbyte;
zs->connect.write.pos = 0;
FL_SET( zs->connect.status, ZS_STAT_WRITING | ZS_STAT_WANT_WRITE_FROM_WRITE );
}
zs_update_fd_state( fd, NULL );
return nbyte;
}
static VALUE
define_final(VALUE os, SEL sel, int argc, VALUE *argv)
{
VALUE obj, block, table;
if (__os_finalizers == NULL)
__os_finalizers = CFDictionaryCreateMutable(NULL, 0, NULL,
&kCFTypeDictionaryValueCallBacks);
rb_scan_args(argc, argv, "11", &obj, &block);
if (argc == 1) {
block = rb_block_proc();
}
else if (!rb_respond_to(block, rb_intern("call"))) {
rb_raise(rb_eArgError, "wrong type argument %s (should be callable)",
rb_obj_classname(block));
}
table = (VALUE)CFDictionaryGetValue((CFDictionaryRef)__os_finalizers,
(const void *)obj);
if (table == 0) {
table = rb_ary_new();
CFDictionarySetValue(__os_finalizers, (const void *)obj,
(const void *)table);
}
rb_ary_push(table, block);
if (NATIVE(obj)) {
rb_objc_flag_set((void *)obj, FL_FINALIZE, true);
}
else {
FL_SET(obj, FL_FINALIZE);
}
VALUE ret = rb_ary_new3(2, INT2FIX(rb_safe_level()), block);
OBJ_FREEZE(ret);
return ret;
}
int zsocket( in_addr_t addr, int portno, int type, void (*zs_event_hdlr)( int fd, int event ), bool ssl ) {
assert( initialized );
zsocket_t* p;
if ( type == ZSOCK_LISTEN ) {
p = zs_get_by_info( addr, portno );
if ( p ) {
p->listen.n_open++;
return p->listen.sockfd;
}
}
struct sockaddr_in serv_addr;
memset( &serv_addr, 0, sizeof( serv_addr ) );
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = addr;
serv_addr.sin_port = htons( portno );
int sockfd = zs_new( &serv_addr, portno, type );
if ( sockfd == -1 )
return -1;
SSL_CTX* ssl_ctx = NULL;
if ( ssl ) {
if ( type == ZSOCK_LISTEN )
ssl_ctx = SSL_CTX_new( SSLv23_server_method() );
else
ssl_ctx = client_ctx;
}
p = zs_type_init( sockfd, type, &serv_addr, portno, zs_event_hdlr, ssl_ctx );
if ( p && type == ZSOCK_CONNECT ) {
FL_SET( p->general.status, ZS_STAT_CONNECTING );
if ( ssl ) SSL_set_connect_state( p->connect.ssl );
zs_connecter( sockfd, NULL );
zs_update_fd_state( sockfd, NULL );
}
return p ? sockfd : -1;
}
/*!
* \internal
* Creates a singleton class for an object.
*
* \note DO NOT USE the function in an extension libraries. Use rb_singleton_class.
* \param obj An object.
* \param super A class from which the singleton class derives.
* \note \a super is ignored if \a obj is a metaclass.
* \return The singleton class of the object.
*/
VALUE
rb_make_metaclass(VALUE obj, VALUE super)
{
if (BUILTIN_TYPE(obj) == T_CLASS && FL_TEST(obj, FL_SINGLETON)) { /* obj is a metaclass */
return make_metametaclass(obj);
}
else {
VALUE metasuper;
VALUE klass = rb_class_boot(super);
FL_SET(klass, FL_SINGLETON);
RBASIC(obj)->klass = klass;
rb_singleton_class_attached(klass, obj);
metasuper = RBASIC(rb_class_real(super))->klass;
/* metaclass of a superclass may be NULL at boot time */
if (metasuper) {
RBASIC(klass)->klass = metasuper;
}
return klass;
}
}
/* call-seq:
* to_module -> Module
*
* Makes a copy of the class, converts the copy to a module, and returns it. The
* returned module can be included in other classes. */
static VALUE evilr_to_module(VALUE klass) {
VALUE mod, iclass;
if (IS_SINGLETON_CLASS(klass)) {
if((mod = evilr_singleton_class_instance(klass))) {
mod = rb_singleton_class_clone(mod);
(void)evilr_detach_singleton(mod);
} else {
rb_raise(rb_eTypeError, "singleton class without attached instance");
}
} else {
mod = rb_obj_clone(klass);
}
RBASIC_SET_KLASS(mod, rb_cModule);
iclass = RCLASS_SUPER(mod);
RCLASS_SET_SUPER(mod, NULL);
FL_UNSET(mod, T_MASK);
FL_SET(mod, T_MODULE);
evilr__include_iclasses(mod, iclass);
return mod;
}
static void zs_internal_accept( int fd, void* udata ) {
int newsockfd;
struct sockaddr_in cli_addr;
socklen_t cli_len = sizeof( struct sockaddr_in );
zsocket_t* zs = zs_get_by_fd( fd );
FL_SET( zs->general.status, ZS_STAT_ACCEPTING );
// Connection request on original socket.
if ( ( newsockfd = accept( fd, (struct sockaddr*) &cli_addr, &cli_len ) ) == -1 ) {
zs->listen.accepted_fd = -1;
zs->listen.accepted_errno = errno;
FL_CLR( zs->general.status, ZS_STAT_ACCEPTING );
zs_update_fd_state( fd, NULL );
return;
}
fcntl( newsockfd, F_SETFL, fcntl( newsockfd, F_GETFL, 0 ) | O_NONBLOCK );
if ( !zs_type_init( newsockfd, ZSOCK_CONNECT, &cli_addr,
zs->general.portno, zs->general.event_hdlr, zs->listen.ssl_ctx ) ) {
zs->listen.accepted_fd = -1;
zs->listen.accepted_errno = EPROTO;
FL_CLR( zs->general.status, ZS_STAT_ACCEPTING );
zs_update_fd_state( fd, NULL );
return;
}
zsocket_t* zs_child = zs_get_by_fd( newsockfd );
zs->listen.accepted_fd = newsockfd;
zs_child->connect.parent_fd = fd;
zs_accepter( newsockfd, NULL );
if ( zs_get_by_fd( newsockfd ) ) zs_update_fd_state( newsockfd, NULL );
zs_update_fd_state( fd, NULL );
}
static void zs_reader( int fd, void* udata ) {
zsocket_t* zs = zs_get_by_fd( fd );
ssize_t n;
if ( zs->connect.ssl ) {
if ( FL_ISSET( zs->general.status, ZS_STAT_ACCEPTING ) )
n = SSL_accept( zs->connect.ssl );
else
n = SSL_read( zs->connect.ssl, zs->connect.read.buffer + zs->connect.read.used,
zs->connect.read.size - zs->connect.read.used );
//fprintf( stderr, "%d of %d zs_reader\n", n, zs->connect.read.size - zs->connect.read.used );
if ( n < 0 ) {
int err = SSL_get_error( zs->connect.ssl, n );
switch ( err ) {
case SSL_ERROR_WANT_READ:
FL_SET( zs->connect.status, ZS_STAT_WANT_READ_FROM_READ );
return;
case SSL_ERROR_WANT_WRITE:
FL_SET( zs->connect.status, ZS_STAT_WANT_WRITE_FROM_READ );
return;
}
ERR_print_errors_fp( stderr );
zs->connect.read.rw_errno = EPROTO;
}
if ( FL_ISSET( zs->general.status, ZS_STAT_ACCEPTING ) ) {
FL_CLR( zs->general.status, ZS_STAT_ACCEPTING );
if ( FL_ISSET( zs->connect.status, ZS_STAT_READING ) )
FL_SET( zs->connect.status, ZS_STAT_WANT_READ_FROM_READ );
else if ( FL_ISSET( zs->connect.status, ZS_STAT_WRITING ) )
FL_SET( zs->connect.status, ZS_STAT_WANT_WRITE_FROM_WRITE );
return;
}
} else {
n = read( fd, zs->connect.read.buffer + zs->connect.read.used,
zs->connect.read.size - zs->connect.read.used );
//fprintf( stderr, "%d of %d zs_reader\n", n, zs->connect.read.size - zs->connect.read.used );
if ( n == -1 ) {
if ( errno == EAGAIN ) {
//puts( "EAGAIN: zreader" );
FL_SET( zs->connect.status, ZS_STAT_WANT_READ_FROM_READ );
return;
}
zs->connect.read.rw_errno = errno;
}
}
if ( n > 0 )
zs->connect.read.used += n;
else if ( n == -1 )
zs->connect.read.used = -1;
else
FL_SET( zs->general.status, ZS_STAT_EOF );
if ( FD_ISSET( fd, &active_read_fd_set ) && !FL_ISSET( zs->general.status, ZS_STAT_READABLE ) )
n_selectable++;
FL_SET( zs->general.status, ZS_STAT_READABLE );
FL_CLR( zs->general.status, ZS_STAT_READING );
}
/* Make the given klass the singleton class of self. */
void evilr__make_singleton(VALUE self, VALUE klass) {
FL_SET(klass, FL_SINGLETON);
RBASIC_SET_KLASS(self, klass);
rb_singleton_class_attached(klass, self);
}
void driver::input::keyboard::SetBackgroundAccessBit(int bit)
{
FL_SET(backgroundInputBits, 1<<bit);
UpdateBackgroundAccess(backgroundInputBits != 0);
}
int main( int argc, char* argv[ ] ) {
int ret = EXIT_SUCCESS;
int make_daemon = 1, daemon_flags = 0;
bool force_stop = false;
///////////////////////////////////////////////
// parse command line options
int i;
for ( i = 1; i < argc; i++ ) {
if ( argv[i][0] != '-' ) break;
if ( strcmp( argv[i], "--no-daemon" ) == 0 )
make_daemon = 0;
else if ( strcmp( argv[i], "--force" ) == 0 ) {
daemon_flags |= D_NOLOCKCHECK;
force_stop = true;
} else if ( strcmp( argv[i], "--no-lockfile" ) == 0 ) {
daemon_flags |= D_NOLOCKFILE;
} else {
if ( strcmp( argv[i], "--help" ) != 0 && strcmp( argv[i], "-h" ) != 0 )
printf( "\nUnknown Option: %s\n", argv[i] );
print_usage();
exit(0);
}
}
if ( i == argc ) {
print_usage();
exit(0);
}
if ( i != argc - 1 ) {
printf( "Error: Invalid Command\n\n" );
print_usage();
exit(0);
}
// parse command line commands
if ( strcmp( argv[i], "start" ) != 0 ) {
if ( strcmp( argv[i], "stop" ) == 0 ) {
if ( !daemon_stop( force_stop ) ) exit( EXIT_FAILURE );
exit( EXIT_SUCCESS );
} else if ( strcmp( argv[i], "restart" ) == 0 ) {
if ( !daemon_stop( force_stop ) ) exit( EXIT_FAILURE );
} else {
printf( "Error: Unknown Command: %s\n\n", argv[i] );
print_usage();
exit(0);
}
}
/////////////////////////////////////////////////
if ( make_daemon ) {
if ( !daemon_init( daemon_flags ) ) {
exit(0);
}
}
zcnf_daemon_t* daemon_cnf = zcnf_daemon_load();
if ( !daemon_cnf ) {
fprintf( stderr, "failed to load config.\n" );
exit( EXIT_FAILURE );
}
// Trap SIGPIPE
signal( SIGPIPE, signal_handler );
// call any needed library init functions
website_init();
zs_init( daemon_cnf->ssl_cert_path, daemon_cnf->ssl_key_path );
memset( connections, 0, sizeof( connections ) );
for ( i = 0; i < daemon_cnf->n; i++ ) {
int sockfd = zsocket( inet_addr( daemon_cnf->proxies[ i ].ip ), daemon_cnf->proxies[ i ].port, ZSOCK_LISTEN, insock_event_hdlr, false );
if ( sockfd == -1 ) {
ret = EXIT_FAILURE;
fprintf( stderr, "Proxy failed on %s:%d\n", daemon_cnf->proxies[ i ].ip, daemon_cnf->proxies[ i ].port );
goto quit;
}
zs_set_read( sockfd );
printf( " * started listening on %s:%d\n", daemon_cnf->proxies[ i ].ip, daemon_cnf->proxies[ i ].port );
}
FL_SET( daemon_flags, D_KEEPSTDIO );
#if defined(DEBUG)
FL_SET( daemon_flags, D_NOCD );
setlogmask( LOG_UPTO( LOG_DEBUG ) );
openlog( DAEMON_NAME, LOG_CONS | LOG_NDELAY | LOG_PERROR | LOG_PID, LOG_USER );
#else
setlogmask( LOG_UPTO( LOG_INFO ) );
openlog( DAEMON_NAME, LOG_CONS, LOG_USER );
#endif
// daemonize
if ( make_daemon ) {
if ( !daemon_detach( daemon_flags ) ) {
ret = EXIT_FAILURE;
goto quit;
}
}
#ifndef DEBUG
daemon_redirect_stdio();
#endif
syslog( LOG_INFO, "initialized." );
// starts a select() loop and calls
// the associated file descriptor handlers
// when they are ready to read/write
do {
do {
msg_switch_select();
zs_select();
} while ( msg_switch_need_select() || zs_need_select() );
} while ( zfd_select(2) );
quit:
// cleanup
zcnf_daemon_free( daemon_cnf );
if ( ret == EXIT_FAILURE ) {
syslog( LOG_INFO, "exit: failure" );
} else {
syslog( LOG_INFO, "exit: success" );
}
closelog();
return ret;
}
static void zs_writer( int fd, void* udata ) {
zsocket_t* zs = zs_get_by_fd( fd );
ssize_t n;
if ( zs->connect.ssl ) {
if ( FL_ISSET( zs->general.status, ZS_STAT_ACCEPTING ) )
n = SSL_accept( zs->connect.ssl );
else
n = SSL_write( zs->connect.ssl, zs->connect.write.buffer + zs->connect.write.pos,
zs->connect.write.used - zs->connect.write.pos );
//fprintf( stderr, "%d of %d zs_writer\n", n, zs->connect.write.used - zs->connect.write.pos );
if ( n < 0 ) {
int err = SSL_get_error( zs->connect.ssl, n );
switch ( err ) {
case SSL_ERROR_WANT_READ:
FL_SET( zs->connect.status, ZS_STAT_WANT_READ_FROM_WRITE );
return;
case SSL_ERROR_WANT_WRITE:
FL_SET( zs->connect.status, ZS_STAT_WANT_WRITE_FROM_WRITE );
return;
}
ERR_print_errors_fp( stderr );
zs->connect.write.rw_errno = EPROTO;
}
if ( FL_ISSET( zs->general.status, ZS_STAT_ACCEPTING ) ) {
FL_CLR( zs->general.status, ZS_STAT_ACCEPTING );
if ( FL_ISSET( zs->connect.status, ZS_STAT_READING ) )
FL_SET( zs->connect.status, ZS_STAT_WANT_READ_FROM_READ );
else if ( FL_ISSET( zs->connect.status, ZS_STAT_WRITING ) )
FL_SET( zs->connect.status, ZS_STAT_WANT_WRITE_FROM_WRITE );
return;
}
} else {
n = write( fd, zs->connect.write.buffer + zs->connect.write.pos,
zs->connect.write.used - zs->connect.write.pos );
//fprintf( stderr, "%d of %d zs_writer\n", n, zs->connect.write.used - zs->connect.write.pos );
if ( n == -1 ) {
if ( errno == EAGAIN ) {
FL_SET( zs->connect.status, ZS_STAT_WANT_WRITE_FROM_WRITE );
return;
}
zs->connect.write.rw_errno = errno;
}
}
if ( n > 0 ) {
zs->connect.write.pos += n;
if ( zs->connect.write.used - zs->connect.write.pos ) {
FL_SET( zs->connect.status, ZS_STAT_WANT_WRITE_FROM_WRITE );
return;
}
}
free( zs->connect.write.buffer );
zs->connect.write.buffer = NULL;
if ( FD_ISSET( fd, &active_write_fd_set ) && !FL_ISSET( zs->general.status, ZS_STAT_WRITABLE ) )
n_selectable++;
FL_SET( zs->general.status, ZS_STAT_WRITABLE );
FL_CLR( zs->general.status, ZS_STAT_WRITING );
if ( FL_ISSET( zs->general.status, ZS_STAT_CLOSED ) )
zs_close( fd );
}
ssize_t zs_read( int fd, void* buf, size_t nbyte ) {
zsocket_t* zs = zs_get_by_fd( fd );
if ( !zs || zs->type != ZSOCK_CONNECT || FL_ISSET( zs->general.status, ZS_STAT_CLOSED ) ) {
errno = EBADF;
return -1;
}
if ( !FL_ISSET( zs->connect.status, ZS_STAT_READABLE ) ) {
errno = EAGAIN;
return -1;
}
ssize_t used = (ssize_t)nbyte > zs->connect.read.used ? zs->connect.read.used : nbyte;
if ( zs->connect.read.rw_errno ) {
errno = zs->connect.read.rw_errno;
goto quit;
}
if ( zs->connect.read.used == 0 ) {
assert( FL_ISSET( zs->connect.status, ZS_STAT_EOF ) );
goto quit;
}
memcpy( buf, zs->connect.read.buffer + zs->connect.read.pos, used );
zs->connect.read.pos += used;
zs->connect.read.used -= used;
quit:
if ( !zs->connect.read.used && !FL_ISSET( zs->connect.status, ZS_STAT_EOF ) ) {
if ( FD_ISSET( fd, &active_read_fd_set ) && FL_ISSET( zs->general.status, ZS_STAT_READABLE ) )
n_selectable--;
zs->connect.read.pos = 0;
zs->connect.read.used = 0;
FL_CLR( zs->connect.status, ZS_STAT_READABLE );
//////////////////////////////////////////////////////////////////////////////////
/* This section is a fix for when the ssl lib has read more than the zsocket read buffer
size and has data cached. The problem is that zsocket will go into the select loop
before checking for more read data available. Since the data has already been read
and cached, there is no data available and the select will hang. This is a fix to
try and read data and setting things back after.
*/
bool want_read = FL_ISSET( zs->general.status, ZS_STAT_WANT_READ_FROM_READ );
bool want_write = FL_ISSET( zs->general.status, ZS_STAT_WANT_WRITE_FROM_READ );
zs_reader( fd, NULL );
if ( want_read ) FL_SET( zs->general.status, ZS_STAT_WANT_READ_FROM_READ );
else FL_CLR( zs->general.status, ZS_STAT_WANT_READ_FROM_READ );
if ( want_write ) FL_SET( zs->general.status, ZS_STAT_WANT_WRITE_FROM_READ );
else FL_CLR( zs->general.status, ZS_STAT_WANT_WRITE_FROM_READ );
//////////////////////////////////////////////////////////////////////////////////
zs_update_fd_state( fd, NULL );
}
return used;
}
