static VALUE rb_lzfx_compress(VALUE self, VALUE input) {
unsigned char *compressed, *data;
int out_length, data_length;
int retcode;
VALUE retval;
Check_Type(input, T_STRING);
data = StringValuePtr(input);
data_length = RSTRING_LEN(input);
if (data_length < 1) {
return Qnil;
}
out_length = data_length * COFFICIENT_OF_BUFFER;
compressed = malloc(out_length);
retcode = lzfx_compress(data, data_length, compressed, &out_length);
if(retcode < 0) {
ruby_xfree(compressed);
return Qnil;
}
retval = rb_str_new(compressed, out_length);
ruby_xfree(compressed);
return retval;
}
static void
backtrace_free(void *ptr)
{
if (ptr) {
rb_backtrace_t *bt = (rb_backtrace_t *)ptr;
if (bt->backtrace) ruby_xfree(bt->backtrace_base);
ruby_xfree(bt);
}
}
static void State_free(JSON_Generator_State *state)
{
if (state->indent) ruby_xfree(state->indent);
if (state->space) ruby_xfree(state->space);
if (state->space_before) ruby_xfree(state->space_before);
if (state->object_nl) ruby_xfree(state->object_nl);
if (state->array_nl) ruby_xfree(state->array_nl);
if (state->array_delim) fbuffer_free(state->array_delim);
if (state->object_delim) fbuffer_free(state->object_delim);
if (state->object_delim2)
static void
xthread_fifo_free(void *ptr)
{
xthread_fifo_t *fifo = (xthread_fifo_t*)ptr;
if (fifo->elements) {
ruby_xfree(fifo->elements);
}
ruby_xfree(ptr);
}
static void
cont_free(void *ptr)
{
RUBY_FREE_ENTER("cont");
if (ptr) {
rb_context_t *cont = ptr;
RUBY_FREE_UNLESS_NULL(cont->saved_thread.stack); fflush(stdout);
#if FIBER_USE_NATIVE
if (cont->type == CONTINUATION_CONTEXT) {
/* cont */
ruby_xfree(cont->ensure_array);
RUBY_FREE_UNLESS_NULL(cont->machine.stack);
}
else {
/* fiber */
rb_fiber_t *fib = (rb_fiber_t*)cont;
#ifdef _WIN32
if (GET_THREAD()->fiber != fib && cont->type != ROOT_FIBER_CONTEXT) {
/* don't delete root fiber handle */
rb_fiber_t *fib = (rb_fiber_t*)cont;
if (fib->fib_handle) {
DeleteFiber(fib->fib_handle);
}
}
#else /* not WIN32 */
if (GET_THREAD()->fiber != fib) {
rb_fiber_t *fib = (rb_fiber_t*)cont;
if (fib->ss_sp) {
if (cont->type == ROOT_FIBER_CONTEXT) {
rb_bug("Illegal root fiber parameter");
}
munmap((void*)fib->ss_sp, fib->ss_size);
}
}
else {
/* It may reached here when finalize */
/* TODO examine whether it is a bug */
/* rb_bug("cont_free: release self"); */
}
#endif
}
#else /* not FIBER_USE_NATIVE */
ruby_xfree(cont->ensure_array);
RUBY_FREE_UNLESS_NULL(cont->machine.stack);
#endif
#ifdef __ia64
RUBY_FREE_UNLESS_NULL(cont->machine.register_stack);
#endif
RUBY_FREE_UNLESS_NULL(cont->vm_stack);
/* free rb_cont_t or rb_fiber_t */
ruby_xfree(ptr);
}
RUBY_FREE_LEAVE("cont");
}
static void rb_smbdir_data_free(RB_SMBFILE_DATA *data)
{
RB_SMB_DEBUG("data=%p smbcctx=%p smbcfile=%p\n", data, data->smbcctx, data->smbcfile);
if (data->smbcfile != NULL) {
rb_smbdir_close_and_deref_by_data(data);
}
ruby_xfree(data->url);
ruby_xfree(data);
}
/*
* call-seq:
* XML.features -> ["feature", ..., "feature"]
*
* Obtains an array of strings representing features supported
* (and enabled) by the installed libxml.
*/
static VALUE rxml_features(VALUE klass)
{
VALUE arr, str;
int i, len = MAX_LIBXML_FEATURES_LEN;
char **list = NULL;
list = ALLOC_N(char *,MAX_LIBXML_FEATURES_LEN);
MEMZERO(list, char *, MAX_LIBXML_FEATURES_LEN);
arr = rb_ary_new();
if (xmlGetFeaturesList(&len, (const char **) list) == -1)
return Qnil;
for (i = 0; i < len; i++)
{
str = rb_str_new2((const char *) list[i]);
rb_gc_unregister_address(&str);
rb_ary_push(arr, str);
}
if (len == MAX_LIBXML_FEATURES_LEN)
rb_warn(
"Please contact [email protected] and ask to have the \"MAX_LIBXML_FEATURES_LEN increased\" because you could possibly be seeing an incomplete list");
ruby_xfree(list);
return (arr);
}
void rb_ShMemutex_free(ShMemutex *ptr)
{
if(ptr)
ptr->~ShMemutex();
ruby_xfree(ptr);
}
void
free_request(request *req)
{
uint32_t i;
header *h;
if(req->path){
free_buffer(req->path);
req->path = NULL;
}
if(req->uri){
free_buffer(req->uri);
req->uri = NULL;
}
if(req->query_string){
free_buffer(req->query_string);
req->query_string = NULL;
}
if(req->fragment){
free_buffer(req->fragment);
req->fragment = NULL;
}
for(i = 0; i < req->num_headers+1; i++){
h = req->headers[i];
if(h){
free_buffer(h->field);
free_buffer(h->value);
free_header(h);
req->headers[i] = NULL;
}
}
ruby_xfree(req);
}
int
ruby_vm_destruct(rb_vm_t *vm)
{
RUBY_FREE_ENTER("vm");
if (vm) {
rb_thread_t *th = vm->main_thread;
#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
struct rb_objspace *objspace = vm->objspace;
#endif
rb_gc_force_recycle(vm->self);
vm->main_thread = 0;
if (th) {
thread_free(th);
}
if (vm->living_threads) {
st_free_table(vm->living_threads);
vm->living_threads = 0;
}
#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
if (objspace) {
rb_objspace_free(objspace);
}
#endif
ruby_vm_run_at_exit_hooks(vm);
rb_vm_gvl_destroy(vm);
ruby_xfree(vm);
ruby_current_vm = 0;
}
RUBY_FREE_LEAVE("vm");
return 0;
}
/*
* @overload read(count, is_stderr: false, timeout: -1)
* Read data from a channel.
* @since 0.1.0
* @param [Fixnum] count The count of bytes to be read.
* @param [Boolean] is_stderr Read from the stderr flow or not.
* @param [Fixnum] timeout A timeout in seconds. +-1+ means infinite timeout.
* @return [String] Data read from the channel.
* @see http://api.libssh.org/stable/group__libssh__channel.html
* ssh_channel_read_timeout
*/
static VALUE m_read(int argc, VALUE *argv, VALUE self) {
ChannelHolder *holder;
VALUE count, opts;
const ID table[] = {id_stderr, id_timeout};
VALUE kwvals[sizeof(table) / sizeof(*table)];
struct nogvl_read_args args;
VALUE ret;
TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
rb_scan_args(argc, argv, "10:", &count, &opts);
Check_Type(count, T_FIXNUM);
rb_get_kwargs(opts, table, 0, 2, kwvals);
if (kwvals[0] == Qundef) {
args.is_stderr = 0;
} else {
args.is_stderr = RTEST(kwvals[0]) ? 1 : 0;
}
if (kwvals[1] == Qundef) {
args.timeout = -1;
} else {
Check_Type(kwvals[1], T_FIXNUM);
args.timeout = FIX2INT(kwvals[1]);
}
args.channel = holder->channel;
args.count = FIX2UINT(count);
args.buf = ALLOC_N(char, args.count);
rb_thread_call_without_gvl(nogvl_read, &args, RUBY_UBF_IO, NULL);
ret = rb_utf8_str_new(args.buf, args.rc);
ruby_xfree(args.buf);
return ret;
}
int
ruby_vm_destruct(void *ptr)
{
RUBY_FREE_ENTER("vm");
if (ptr) {
rb_vm_t *vm = ptr;
rb_thread_t *th = vm->main_thread;
#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
struct rb_objspace *objspace = vm->objspace;
#endif
rb_gc_force_recycle(vm->self);
vm->main_thread = 0;
if (th) {
thread_free(th);
}
if (vm->living_threads) {
st_free_table(vm->living_threads);
vm->living_threads = 0;
}
rb_thread_lock_unlock(&vm->global_vm_lock);
rb_thread_lock_destroy(&vm->global_vm_lock);
ruby_xfree(vm);
ruby_current_vm = 0;
#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
if (objspace) {
rb_objspace_free(objspace);
}
#endif
}
RUBY_FREE_LEAVE("vm");
return 0;
}
static void WSF_CALL
wsf_free_wrapper (
axutil_allocator_t * allocator,
void *ptr)
{
ruby_xfree(ptr);
}
static void
close_conn(client_t *cli, picoev_loop* loop)
{
if(!cli->keep_alive){
picoev_del(loop, cli->fd);
clean_cli(cli);
close(cli->fd);
#ifdef DEBUG
printf("close fd %d \n", cli->fd);
#endif
ruby_xfree(cli);
}else{
clean_cli(cli);
disable_cork(cli);
cli->keep_alive = 1;
cli->environ = Qnil;
cli->http_status = Qnil;
cli->headers = Qnil;
cli->header_done = 0;
cli->body_type = BODY_TYPE_NONE;
cli->status_code = 0;
cli->response = Qnil;
cli->content_length_set = 0;
cli->content_length = 0;
cli->write_bytes = 0;
cli->response_closed = 0;
cli->bad_request_code = 0;
init_parser(cli, server_name, server_port);
}
}
static void
free_sdbm(struct dbmdata *dbmp)
{
if (dbmp->di_dbm) sdbm_close(dbmp->di_dbm);
ruby_xfree(dbmp);
}
static void
location_free(void *ptr)
{
if (ptr) {
rb_backtrace_location_t *fi = (rb_backtrace_location_t *)ptr;
ruby_xfree(fi);
}
}
/** :nodoc: */
void rb_blink1_free(struct Blink1Instance *ins) {
if(ins->opened == 1) {
blink1_close(ins->dev);
ins->opened = 0;
}
// free(ins);
ruby_xfree(ins);
}
/*
* call-seq: Fiddle.free(addr)
*
* Free the memory at address +addr+
*/
VALUE
rb_fiddle_free(VALUE self, VALUE addr)
{
void *ptr = NUM2PTR(addr);
ruby_xfree(ptr);
return Qnil;
}
/*
* PRIVATE
*/
static void
ossl_cipher_free(EVP_CIPHER_CTX *ctx)
{
if (ctx) {
EVP_CIPHER_CTX_cleanup(ctx);
ruby_xfree(ctx);
}
}
static void c_CompletionResult_struct_free(CompletionResult_t *s)
{
if (s)
{
ruby_xfree(s);
}
}
/*
* call-seq: array_nl=(array_nl)
*
* This string is put at the end of a line that holds a JSON array.
*/
static VALUE cState_array_nl_set(VALUE self, VALUE array_nl)
{
unsigned long len;
GET_STATE(self);
Check_Type(array_nl, T_STRING);
len = RSTRING_LEN(array_nl);
if (len == 0) {
if (state->array_nl) {
ruby_xfree(state->array_nl);
state->array_nl = NULL;
}
} else {
if (state->array_nl) ruby_xfree(state->array_nl);
state->array_nl = strdup(RSTRING_PTR(array_nl));
state->array_nl_len = len;
}
return Qnil;
}
// The free function to go with our allocation.
//
static void dir_free(NDirStruct* s){
if (s->chandle)
CloseHandle(s->chandle);
if (s->fhandle)
FindClose(s->fhandle);
ruby_xfree(s);
}
void
ruby_xml_parser_context_free(ruby_xml_parser_context *rxpc) {
if (rxpc->ctxt != NULL) {
xmlFreeParserCtxt(rxpc->ctxt);
rxpc->ctxt = NULL;
}
ruby_xfree(rxpc);
}
void
ruby_xml_relaxng_free(ruby_xml_relaxng *rxrelaxng) {
if (rxrelaxng->relaxng != NULL) {
xmlRelaxNGFree(rxrelaxng->relaxng);
rxrelaxng->relaxng = NULL;
}
ruby_xfree(rxrelaxng);
}
static void
proc_free(void *ptr)
{
RUBY_FREE_ENTER("proc");
if (ptr) {
ruby_xfree(ptr);
}
RUBY_FREE_LEAVE("proc");
}
static void
buffer_size_changed(struct buffer *buffer)
{
clReleaseMemObject(buffer->data);
buffer->data = clCreateBuffer(context, CL_MEM_READ_WRITE,
buffer->num_items * buffer->member_size, NULL, NULL);
ruby_xfree(buffer->cachebuf);
buffer->cachebuf = ruby_xmalloc(buffer->num_items * buffer->member_size);
}
/*
* call-seq: object_nl=(object_nl)
*
* This string is put at the end of a line that holds a JSON object (or
* Hash).
*/
static VALUE cState_object_nl_set(VALUE self, VALUE object_nl)
{
unsigned long len;
GET_STATE(self);
Check_Type(object_nl, T_STRING);
len = RSTRING_LEN(object_nl);
if (len == 0) {
if (state->object_nl) {
ruby_xfree(state->object_nl);
state->object_nl = NULL;
}
} else {
if (state->object_nl) ruby_xfree(state->object_nl);
state->object_nl = fstrndup(RSTRING_PTR(object_nl), len);
state->object_nl_len = len;
}
return Qnil;
}
static void
proc_free(void *ptr)
{
FREE_REPORT_ENTER("proc");
if (ptr) {
ruby_xfree(ptr);
}
FREE_REPORT_LEAVE("proc");
}
static void blake2_free(Blake2 *blake2) {
free(blake2->key_bytes);
free(blake2->output);
rb_gc_mark(blake2->to_hex);
rb_gc_mark(blake2->to_bytes);
ruby_xfree(blake2);
}
/*
* PRIVATE
*/
static void
ossl_cipher_free(void *ptr)
{
EVP_CIPHER_CTX *ctx = ptr;
if (ctx) {
EVP_CIPHER_CTX_cleanup(ctx);
ruby_xfree(ctx);
}
}
