cool.io 1.9.0 → 1.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e56b06dac89092ba3fb69d7705788b4aecb51a205075b47afa6b8ff946f8bfa6
-  data.tar.gz: d9ff9ac907b8eb86d3158d893acdcc0f64c58985ae2ccfeeafbcc9c2a5e366a4
+  metadata.gz: 3da0843b8a62fd01aab297ce31f885a5856b4326bef2fb3c90d363f9576fe9a3
+  data.tar.gz: d073dd104500ccc2c1b62411c8f02c083df004353f9d2798ccf8ae41166effbd
 SHA512:
-  metadata.gz: b9d3c85e07f9f439c86be0572d4c455a429fbb2b8fd5b1cbdb87cd0fdca1c629060515074751eecb92357b365edf05c8b0cc79ce63ca4d6188e4eeca903cf95e
-  data.tar.gz: 942c188b705d59f6aa0c9d028d87b17722f9cba55c317cfb1be8f7548562c68e1467c8ec5664297cbb575fd1f6997875311d1a35d76efb772c4f50c87c20aa94
+  metadata.gz: b3f2fab2151abdbd3e0762aa04675cab8b4d196990227bf5d068f12360a62c87e669480f50e70b47b289a9c0f29deeddb28836590422faafe5d0a5ecaf6173fb
+  data.tar.gz: 233ea14784f4390b6b1f1b8fb131d5b1d20d14d0b78f9f1fd3b39f89bd25d34be505267d23d1b5647be2febcd5216e33a459c0e135ee49737334a06a0626bb47

data/.github/workflows/test.yaml

@@ -5,9 +5,6 @@ on: [push, pull_request]
 permissions:
   contents: read
 
-env:
-  CONSOLE_OUTPUT: XTerm
-
 jobs:
   test:
     name: ${{matrix.ruby}} on ${{matrix.os}}
@@ -20,35 +17,27 @@ jobs:
         os:
           - ubuntu
           - macos
-          - windows
         
         ruby:
-          - "3.0"
-          - "3.1"
           - "3.2"
           - "3.3"
-          - "head"
+          - "3.4"
+          - "4.0"
         
         experimental: [false]
         
-        # include:
-        #   - os: ubuntu
-        #     ruby: truffleruby
-        #     experimental: true
-        #   - os: ubuntu
-        #     ruby: jruby
-        #     experimental: true
-        #   - os: ubuntu
-        #     ruby: head
-        #     experimental: true
+        include:
+          - os: ubuntu
+            ruby: head
+            experimental: true
     
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v6
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{matrix.ruby}}
         bundler-cache: true
     
     - name: Run tests
-      timeout-minutes: 2
+      timeout-minutes: 10
       run: bundle exec rake

data/.github/workflows/valgrind.yaml

@@ -0,0 +1,44 @@
+name: Memcheck
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: ${{matrix.ruby}} on ${{matrix.os}}
+    runs-on: ${{matrix.os}}-latest
+    continue-on-error: ${{matrix.experimental}}
+    
+    strategy:
+      matrix:
+        os:
+          - ubuntu
+        
+        ruby:
+          - "3.2"
+          - "3.3"
+          - "3.4"
+          - "4.0"
+        
+        experimental: [false]
+        
+        include:
+          - os: ubuntu
+            ruby: head
+            experimental: true
+    
+    steps:
+    - uses: actions/checkout@v6
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{matrix.ruby}}
+        bundler-cache: true
+    - name: Install Valgrind
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y valgrind
+    - name: Run tests
+      timeout-minutes: 10
+      run: bundle exec rake spec:valgrind

data/Rakefile

@@ -22,7 +22,7 @@ end
 
 require 'rake/extensiontask'
 
-spec = eval(File.read("cool.io.gemspec"))
+spec = Gem::Specification.load("cool.io.gemspec")
 
 def configure_cross_compilation(ext)
   unless RUBY_PLATFORM =~ /mswin|mingw/
@@ -48,24 +48,11 @@ namespace :build do
   end
 end
 
-# adapted from http://flavoriffic.blogspot.com/2009/06/easily-valgrind-gdb-your-ruby-c.html
-def specs_command
-  require "find"
-  files = []
-  Find.find("spec") do |f|
-    files << f if File.basename(f) =~ /.*spec.*\.rb$/
-  end
-  cmdline = "#{RUBY} -I.:lib:ext:spec \
-               -e '%w[#{files.join(' ')}].each { |f| require f }'"
-end
-
-namespace :spec do
-  desc "run specs with valgrind"
-  task :valgrind => :compile do
-    system "valgrind --num-callers=15 \
-      --partial-loads-ok=yes --undef-value-errors=no \
-      --tool=memcheck --leak-check=yes --track-fds=yes \
-      --show-reachable=yes #{specs_command}"
+if RUBY_PLATFORM.include?('linux')
+  require 'ruby_memcheck'
+  require 'ruby_memcheck/rspec/rake_task'
+  namespace :spec do
+    RubyMemcheck::RSpec::RakeTask.new(valgrind: :compile)
   end
 end
 

data/cool.io.gemspec

@@ -1,6 +1,4 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "cool.io/version"
+require_relative "lib/cool.io/version"
 
 Gem::Specification.new do |s|
   s.name        = "cool.io"

data/ext/cool.io/buffer.c

@@ -28,17 +28,22 @@
 
 /* Default number of bytes in each node's buffer.  Should be >= MTU */
 #define DEFAULT_NODE_SIZE 16384
-static unsigned default_node_size = DEFAULT_NODE_SIZE;
+static size_t default_node_size = DEFAULT_NODE_SIZE;
 
+/*
+ * Byte counts are kept in size_t so the accounting cannot wrap while the
+ * buffer itself still holds the data.  node_size is capped at MAX_BUFFER_SIZE,
+ * but size grows with whatever the buffer is asked to hold.
+ */
 struct buffer {
-    unsigned size, node_size;
+    size_t size, node_size;
     struct buffer_node *head, *tail;
     struct buffer_node *pool_head, *pool_tail;
 
 };
 
 struct buffer_node {
-    unsigned start, end;
+    size_t start, end;
     struct buffer_node *next;
     unsigned char   data[0];
 };
@@ -47,8 +52,8 @@ static VALUE    mCoolio = Qnil;
 static VALUE    cCoolio_Buffer = Qnil;
 
 static VALUE    Coolio_Buffer_allocate(VALUE klass);
-static void     Coolio_Buffer_mark(struct buffer *);
-static void     Coolio_Buffer_free(struct buffer *);
+static void     Coolio_Buffer_mark(void *);
+static void     Coolio_Buffer_free(void *);
 
 static VALUE    Coolio_Buffer_default_node_size(VALUE klass);
 static VALUE    Coolio_Buffer_set_default_node_size(VALUE klass, VALUE size);
@@ -64,17 +69,17 @@ static VALUE    Coolio_Buffer_to_str(VALUE self);
 static VALUE    Coolio_Buffer_read_from(VALUE self, VALUE io);
 static VALUE    Coolio_Buffer_write_to(VALUE self, VALUE io);
 
-static struct buffer *buffer_new(void);
+static struct buffer *buffer_init(struct buffer *);
 static void     buffer_clear(struct buffer * buf);
 static void     buffer_free(struct buffer * buf);
 static void     buffer_free_pool(struct buffer * buf);
-static void     buffer_prepend(struct buffer * buf, char *str, unsigned len);
-static void     buffer_append(struct buffer * buf, char *str, unsigned len);
-static void     buffer_read(struct buffer * buf, char *str, unsigned len);
+static void     buffer_prepend(struct buffer * buf, char *str, size_t len);
+static void     buffer_append(struct buffer * buf, char *str, size_t len);
+static void     buffer_read(struct buffer * buf, char *str, size_t len);
 static int      buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark);
-static void     buffer_copy(struct buffer * buf, char *str, unsigned len);
-static int      buffer_read_from(struct buffer * buf, int fd);
-static int      buffer_write_to(struct buffer * buf, int fd);
+static void     buffer_copy(struct buffer * buf, char *str, size_t len);
+static ssize_t  buffer_read_from(struct buffer * buf, int fd);
+static ssize_t  buffer_write_to(struct buffer * buf, int fd);
 
 /*
  * High-performance I/O buffer intended for use in non-blocking programs
@@ -86,8 +91,6 @@ static int      buffer_write_to(struct buffer * buf, int fd);
 void
 Init_coolio_buffer()
 {
-    VALUE cCoolio_IO;
-
     mCoolio = rb_define_module("Coolio");
     cCoolio_Buffer = rb_define_class_under(mCoolio, "Buffer", rb_cObject);
     rb_define_alloc_func(cCoolio_Buffer, Coolio_Buffer_allocate);
@@ -114,42 +117,54 @@ Init_coolio_buffer()
     rb_define_const(cCoolio_Buffer, "MAX_SIZE", INT2NUM(MAX_BUFFER_SIZE));
 }
 
+static const rb_data_type_t Coolio_Buffer_type = {
+    "Coolio::Buffer",
+    {
+        Coolio_Buffer_mark,
+        Coolio_Buffer_free,
+    }
+};
+
 static VALUE
 Coolio_Buffer_allocate(VALUE klass)
 {
-    return Data_Wrap_Struct(klass, Coolio_Buffer_mark, Coolio_Buffer_free, buffer_new());
+    struct buffer *buf;
+    VALUE buffer = TypedData_Make_Struct(klass, struct buffer, &Coolio_Buffer_type, buf);
+
+    buffer_init(buf);
+    return buffer;
 }
 
 static void
-Coolio_Buffer_mark(struct buffer * buf)
+Coolio_Buffer_mark(void *buf)
 {
     /* Naively discard the memory pool whenever Ruby garbage collects */
     buffer_free_pool(buf);
 }
 
 static void
-Coolio_Buffer_free(struct buffer * buf)
+Coolio_Buffer_free(void * buf)
 {
     buffer_free(buf);
 }
 
 /**
  * call-seq:
- *   Coolio::Buffer.default_node_size -> 4096
+ *   Coolio::Buffer.default_node_size -> 16384
  *
  * Retrieves the current value of the default node size.
  */
 static VALUE
 Coolio_Buffer_default_node_size(VALUE klass)
 {
-    return UINT2NUM(default_node_size);
+    return SIZET2NUM(default_node_size);
 }
 
 /*
  * safely converts node sizes from Ruby numerics to C and raising
  * ArgumentError or RangeError on invalid sizes
  */
-static unsigned
+static size_t
 convert_node_size(VALUE size)
 {
     if (
@@ -158,7 +173,7 @@ convert_node_size(VALUE size)
     )
         rb_raise(rb_eArgError, "invalid buffer size");
 
-    return (unsigned) NUM2INT(size);
+    return NUM2SIZET(size);
 }
 
 /**
@@ -188,7 +203,7 @@ Coolio_Buffer_initialize(int argc, VALUE * argv, VALUE self)
     struct buffer *buf;
 
     if (rb_scan_args(argc, argv, "01", &node_size_obj) == 1) {
-        Data_Get_Struct(self, struct buffer, buf);
+        TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
         /*
          * Make sure we're not changing the buffer size after data
@@ -212,7 +227,7 @@ static VALUE
 Coolio_Buffer_clear(VALUE self)
 {
     struct buffer *buf;
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     buffer_clear(buf);
 
@@ -229,9 +244,9 @@ static VALUE
 Coolio_Buffer_size(VALUE self)
 {
     struct buffer *buf;
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
-    return INT2NUM(buf->size);
+    return SIZET2NUM(buf->size);
 }
 
 /**
@@ -244,7 +259,7 @@ static VALUE
 Coolio_Buffer_empty(VALUE self)
 {
     struct buffer *buf;
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     return buf->size > 0 ? Qfalse : Qtrue;
 }
@@ -259,7 +274,7 @@ static VALUE
 Coolio_Buffer_append(VALUE self, VALUE data)
 {
     struct buffer *buf;
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     /* Is this needed?  Never seen anyone else do it... */
     data = rb_convert_type(data, T_STRING, "String", "to_str");
@@ -278,7 +293,7 @@ static VALUE
 Coolio_Buffer_prepend(VALUE self, VALUE data)
 {
     struct buffer *buf;
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     data = rb_convert_type(data, T_STRING, "String", "to_str");
     buffer_prepend(buf, RSTRING_PTR(data), RSTRING_LEN(data));
@@ -301,15 +316,18 @@ static VALUE
 Coolio_Buffer_read(int argc, VALUE * argv, VALUE self)
 {
     VALUE  length_obj, str;
-    int    length;
+    size_t length;
     struct buffer *buf;
 
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     if (rb_scan_args(argc, argv, "01", &length_obj) == 1) {
-        length = NUM2INT(length_obj);
-        if(length < 1)
+        /* Read signed so a negative argument still raises ArgumentError here
+         * rather than RangeError out of the conversion */
+        long requested = NUM2LONG(length_obj);
+        if(requested < 1)
           rb_raise(rb_eArgError, "length must be greater than zero");
+        length = (size_t) requested;
         if(length > buf->size)
           length = buf->size;
     } else
@@ -318,7 +336,7 @@ Coolio_Buffer_read(int argc, VALUE * argv, VALUE self)
     if(buf->size == 0)
         return rb_str_new2("");
 
-    str = rb_str_new(0, length);
+    str = rb_str_new(0, (long) length);
     buffer_read(buf, RSTRING_PTR(str), length);
 
     return str;
@@ -340,7 +358,10 @@ Coolio_Buffer_read_frame(VALUE self, VALUE data, VALUE mark)
     char mark_c = (char) NUM2INT(mark);
     struct buffer *buf;
 
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
+
+    StringValue(data);
+    rb_str_modify(data);
 
     if (buffer_read_frame(buf, data, mark_c)) {
         return Qtrue;
@@ -361,9 +382,9 @@ Coolio_Buffer_to_str(VALUE self)
     VALUE          str;
     struct buffer *buf;
 
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
-    str = rb_str_new(0, buf->size);
+    str = rb_str_new(0, (long) buf->size);
     buffer_copy(buf, RSTRING_PTR(str), buf->size);
 
     return str;
@@ -381,14 +402,14 @@ static VALUE
 Coolio_Buffer_read_from(VALUE self, VALUE io)
 {
     struct buffer  *buf;
-    int             ret;
+    ssize_t         ret;
 #if defined(HAVE_RB_IO_T) || defined(HAVE_RB_IO_DESCRIPTOR)
     rb_io_t        *fptr;
 #else
     OpenFile       *fptr;
 #endif
 
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
     io = rb_convert_type(io, T_FILE, "IO", "to_io");
     GetOpenFile(io, fptr);
     rb_io_set_nonblock(fptr);
@@ -398,7 +419,7 @@ Coolio_Buffer_read_from(VALUE self, VALUE io)
 #else
     ret = buffer_read_from(buf, FPTR_TO_FD(fptr));
 #endif
-    return ret == -1 ? Qnil : INT2NUM(ret);
+    return ret == -1 ? Qnil : SSIZET2NUM(ret);
 }
 
 /**
@@ -419,15 +440,15 @@ Coolio_Buffer_write_to(VALUE self, VALUE io)
     OpenFile       *fptr;
 #endif
 
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
     io = rb_convert_type(io, T_FILE, "IO", "to_io");
     GetOpenFile(io, fptr);
     rb_io_set_nonblock(fptr);
 
 #ifdef HAVE_RB_IO_DESCRIPTOR
-    return INT2NUM(buffer_write_to(buf, rb_io_descriptor(io)));
+    return SSIZET2NUM(buffer_write_to(buf, rb_io_descriptor(io)));
 #else
-    return INT2NUM(buffer_write_to(buf, FPTR_TO_FD(fptr)));
+    return SSIZET2NUM(buffer_write_to(buf, FPTR_TO_FD(fptr)));
 #endif
 }
 
@@ -438,11 +459,8 @@ Coolio_Buffer_write_to(VALUE self, VALUE io)
 
 /* Create a new buffer */
 static struct buffer *
-buffer_new(void)
+buffer_init(struct buffer *buf)
 {
-    struct buffer *buf;
-
-    buf = (struct buffer *) xmalloc(sizeof(struct buffer));
     buf->head = buf->tail = buf->pool_head = buf->pool_tail = 0;
     buf->size = 0;
     buf->node_size = default_node_size;
@@ -472,7 +490,7 @@ buffer_free(struct buffer * buf)
     buffer_clear(buf);
     buffer_free_pool(buf);
 
-    free(buf);
+    xfree(buf);
 }
 
 /* Free the memory pool */
@@ -484,7 +502,7 @@ buffer_free_pool(struct buffer * buf)
     while (buf->pool_head) {
         tmp = buf->pool_head;
         buf->pool_head = tmp->next;
-        free(tmp);
+        xfree(tmp);
     }
 
     buf->pool_tail = 0;
@@ -528,7 +546,7 @@ buffer_node_free(struct buffer * buf, struct buffer_node * node)
 
 /* Prepend data to the front of the buffer */
 static void
-buffer_prepend(struct buffer * buf, char *str, unsigned len)
+buffer_prepend(struct buffer * buf, char *str, size_t len)
 {
     struct buffer_node *node, *tmp;
     buf->size += len;
@@ -569,9 +587,9 @@ buffer_prepend(struct buffer * buf, char *str, unsigned len)
 
 /* Append data to the front of the buffer */
 static void
-buffer_append(struct buffer * buf, char *str, unsigned len)
+buffer_append(struct buffer * buf, char *str, size_t len)
 {
-    unsigned nbytes;
+    size_t nbytes;
     buf->size += len;
 
     /* If it fits in the remaining space in the tail */
@@ -606,9 +624,9 @@ buffer_append(struct buffer * buf, char *str, unsigned len)
 
 /* Read data from the buffer (and clear what we've read) */
 static void
-buffer_read(struct buffer * buf, char *str, unsigned len)
+buffer_read(struct buffer * buf, char *str, size_t len)
 {
-    unsigned nbytes;
+    size_t nbytes;
     struct buffer_node *tmp;
 
     while (buf->size > 0 && len > 0) {
@@ -642,7 +660,7 @@ buffer_read(struct buffer * buf, char *str, unsigned len)
 static int
 buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark)
 {
-    unsigned nbytes = 0;
+    size_t nbytes = 0;
     struct buffer_node *tmp;
 
     while (buf->size > 0) {
@@ -657,7 +675,7 @@ buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark)
         }
 
         /* Copy less than everything if we found a frame byte */
-        rb_str_cat(str, s, nbytes);
+        rb_str_cat(str, s, (long) nbytes);
 
         /* Fixup the buffer pointers to indicate the bytes were consumed */
         head->start += nbytes;
@@ -681,9 +699,9 @@ buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark)
 
 /* Copy data from the buffer without clearing it */
 static void
-buffer_copy(struct buffer * buf, char *str, unsigned len)
+buffer_copy(struct buffer * buf, char *str, size_t len)
 {
-    unsigned nbytes;
+    size_t nbytes;
     struct buffer_node *node;
 
     node = buf->head;
@@ -702,10 +720,10 @@ buffer_copy(struct buffer * buf, char *str, unsigned len)
 }
 
 /* Write data from the buffer to a file descriptor */
-static int
+static ssize_t
 buffer_write_to(struct buffer * buf, int fd)
 {
-    int bytes_written, total_bytes_written = 0;
+    ssize_t bytes_written, total_bytes_written = 0;
     struct buffer_node *tmp;
 
     while (buf->head) {
@@ -723,7 +741,7 @@ buffer_write_to(struct buffer * buf, int fd)
         buf->size -= bytes_written;
 
         /* If the write blocked... */
-        if (bytes_written < buf->head->end - buf->head->start) {
+        if ((size_t) bytes_written < buf->head->end - buf->head->start) {
             buf->head->start += bytes_written;
             return total_bytes_written;
         }
@@ -741,11 +759,11 @@ buffer_write_to(struct buffer * buf, int fd)
 
 /* Read data from a file descriptor to a buffer */
 /* Append data to the front of the buffer */
-static int
+static ssize_t
 buffer_read_from(struct buffer * buf, int fd)
 {
-    int      bytes_read, total_bytes_read = 0;
-    unsigned nbytes;
+    ssize_t bytes_read, total_bytes_read = 0;
+    size_t  nbytes;
 
     /* Empty list needs initialized */
     if (!buf->head) {
@@ -775,7 +793,7 @@ buffer_read_from(struct buffer * buf, int fd)
             buf->tail->next = buffer_node_new(buf);
             buf->tail = buf->tail->next;
         }
-    } while (bytes_read == nbytes);
+    } while ((size_t) bytes_read == nbytes);
 
     return total_bytes_read;
 }

data/ext/cool.io/cool.io.h

@@ -55,6 +55,12 @@ struct Coolio_Watcher
   int enabled;
   VALUE loop;
 
+  /* Stable copy of the watched path for ev_stat watchers.  libev retains the
+   * path pointer passed to ev_stat_init() for the lifetime of the watcher, so
+   * it must not point into a Ruby String whose buffer GC.compact may relocate.
+   * NULL for watcher types that don't use it. */
+  char *stat_path;
+
   void (*dispatch_callback)(VALUE self, int revents);
 };
 
@@ -68,4 +74,7 @@ void Init_coolio_timer_watcher();
 void Init_coolio_stat_watcher();
 void Init_coolio_utils();
 
+struct Coolio_Loop *Coolio_Loop_ptr(VALUE loop);
+struct Coolio_Watcher *Coolio_Watcher_ptr(VALUE watcher);
+
 #endif

data/ext/cool.io/extconf.rb

@@ -11,7 +11,6 @@ have_func('rb_thread_alone')
 have_func('rb_str_set_len')
 have_library('rt', 'clock_gettime')
 
-have_func("rb_io_descriptor")
 have_library("c", "main")
 if have_macro("HAVE_RB_IO_T", "ruby/io.h")
   have_struct_member("rb_io_t", "fd", "ruby/io.h")

data/ext/cool.io/iowatcher.c

@@ -82,7 +82,7 @@ static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self)
   else
     rb_raise(rb_eArgError, "invalid event type: '%s' (must be 'r', 'w', or 'rw')", flags_str);
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
   io = rb_convert_type(io, T_FILE, "IO", "to_io");
 
   watcher_data->dispatch_callback = Coolio_IOWatcher_dispatch_callback;