void http_version(void *data, const char *at, size_t length) { VALUE req = (VALUE)data; VALUE val = rb_str_new(at, length); rb_hash_aset(req, global_http_version, val); }
static VALUE foreach(int argc, VALUE* argv, VALUE self) { char *DELIM=DEF_DELIM; char *line = NULL; char *line2 =NULL, *new_line=NULL; size_t len = 0, len2=0, i, pairs_count; char *token,*start,*nobackslash,*t2; size_t idx,count,searchfield,flag,array_length,range_i; long check; int was_read; FILE *file; ID min_method, max_method; VALUE min_val, max_val; VALUE tmp_value, rest_args, filename; ID array_length_method; /*----------------------------------------*/ struct pair_st pairs[MAX_INTERVALS]; VALUE ary; rb_scan_args(argc,argv,"1*", &filename, &rest_args); /* if (argc == 0) { // there should only be 1 or 2 arguments rb_raise(rb_eArgError, "wrong number of arguments"); } file = fopen(StringValueCStr(argv[0]), "r"); if (file == NULL) rb_raise(rb_eRuntimeError, "File not found"); */ file = fopen(StringValueCStr(filename), "r"); if(file==NULL){ rb_raise(rb_eRuntimeError, "File not found"); } if (argc >1 ) { /* delimiter */ tmp_value=rb_ary_entry(rest_args,0); DELIM=StringValueCStr(tmp_value);; } if (argc >2 ) { /* search index */ tmp_value=rb_ary_entry(rest_args,1); searchfield=NUM2INT(tmp_value); } else{ searchfield=-1; } array_length_method=rb_funcall(rest_args,rb_intern("length"), 0); array_length=NUM2INT(array_length_method); min_method = rb_intern("first"); max_method = rb_intern("last"); /*------------test_id = rb_intern("class");*/ range_i=0; for(idx=2;idx<array_length;++idx){ min_val=rb_funcall(rb_ary_entry(rest_args,idx),rb_intern("length"), 0); len2=NUM2INT(min_val); for(i=0;i<len2;++i){ VALUE e=rb_ary_entry(rb_ary_entry(rest_args,idx),i); if(range_i>MAX_INTERVALS) rb_raise(rb_eRuntimeError, "Too much ranges passed"); if(TYPE(e) == T_NIL){ pairs[range_i].low=LONG_MIN; pairs[range_i].high=LONG_MAX; continue; /* just skip nil */ } if (! (rb_respond_to(e, min_method) & rb_respond_to(e, max_method))) rb_raise(rb_eRuntimeError, "Not range passed to Ccsv.foreach"); min_val=rb_funcall(e, min_method, 0); max_val=rb_funcall(e, max_method, 0); pairs[range_i].low=NUM2LONG(min_val); pairs[range_i].high=NUM2LONG(max_val); range_i++; } } pairs_count=range_i; /* main loop lines reading */ while ((was_read=getline(&line, &len, file)) != -1) { if(was_read<1) continue; len=was_read-1; /* try to join escaped lines */ for(;;) { /* check for backslashed newline */ if(line[len]!=EOL) break; if(line[len]==CR){ len-=1; } //rb_warn("NONLAST (%c,%c)",line[len],line[len]); count=0; t2=line+len-1; while((t2>=line) && (*t2=='\\')) {++count;--t2;} if(count%2 ==1){ /* backslashed! skip */ /* get another line... */ line2=NULL; len2=0; if((was_read=getline(&line2, &len2, file)) != -1) { len2=was_read; if(new_line) free(new_line); //!!!! new_line=malloc(len+len2+1); strcpy(new_line,line); new_line[len-1]='\n'; strcpy(new_line+len,line2); line=new_line; //nobackslash=len+1; start=new_line; len+=len2-1; nobackslash=start; free(line); free(line2); continue; } } break; } /* chomp! */ if(line[len]==EOL){ if(line[len-1]==CR) len-=1; line[len]='\0'; } /* skip empty line */ if(len<2) continue; ary = rb_ary_new(); start=line; nobackslash=line; idx = 0; flag=1; while (nobackslash != NULL) { /* get full field */ while(token=strstr(nobackslash, DELIM)){ count=0; t2=token-1; while((t2>=line) && (*t2=='\\')) {++count;--t2;} if(count%2 ==1){ /* backslashed! skip */ nobackslash=token; continue; } break; } if(token) *token='\0'; else token=start+strlen(start); if(searchfield==idx){ flag=0; /* do check! */ sscanf(start,"%ld",&check); for(i=0;i<pairs_count;++i){ /*rb_warn("check %ld: [%ld .. %ld]",check,pairs[i].low,pairs[i].high);*/ if(pairs[i].low<check && pairs[i].high>check){ /*rb_warn("check passed");*/ flag=1; /* yahooo! */ break; } } } /* not in ranges! */ if(flag==0) break; rb_ary_store(ary, idx, rb_str_new(start, token-start)); idx++; nobackslash=start=token+strlen(DELIM); while(token=strstr(nobackslash, DELIM)){ count=0; t2=token-1; while((t2>=line) && (*t2=='\\')) {++count;--t2;} if(count%2 ==1){ /* backslashed! skip */ nobackslash=token+strlen(DELIM); continue; } break; } nobackslash=token; } if(flag==0) continue; /* last item */ rb_ary_store(ary, idx, rb_str_new(start, strlen(start))); /* OBJ_FREEZE(ary); */ rb_yield(ary); /* FL_UNSET((ary), FL_FREEZE); */ /* for(idx = 0; idx < RARRAY_LEN(ary); idx ++) { rb_ary_store(ary, idx, Qnil); } */ } fclose(file); free(line); return Qnil; }
static VALUE rhe_accept(VALUE self, VALUE fileno, VALUE timeoutv, VALUE tcp, VALUE env) { struct sockaddr_in cliaddr; unsigned int len; char read_buf[MAX_HEADER_SIZE]; VALUE req; int flag = 1; ssize_t rv = 0; ssize_t buf_len; ssize_t reqlen; int fd; double timeout = NUM2DBL(timeoutv); len = sizeof(cliaddr); fd = _accept(NUM2INT(fileno), (struct sockaddr *)&cliaddr, len); /* endif */ if (fd < 0) { goto badexit; } rv = _read_timeout(fd, timeout, &read_buf[0], MAX_HEADER_SIZE); if ( rv <= 0 ) { close(fd); goto badexit; } if ( IMMEDIATE_P(tcp) ) { setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(int)); rb_hash_aset(env, remote_addr_key, rb_str_new2(inet_ntoa(cliaddr.sin_addr))); rb_hash_aset(env, remote_port_key, rb_String(rb_int_new(ntohs(cliaddr.sin_port)))); } else { rb_hash_aset(env, remote_addr_key, rb_str_new("",0)); rb_hash_aset(env, remote_port_key, rb_String(rb_int_new(0))); } buf_len = rv; while (1) { reqlen = _parse_http_request(&read_buf[0],buf_len,env); if ( reqlen >= 0 ) { break; } else if ( reqlen == -1 ) { /* error */ close(fd); goto badexit; } if ( MAX_HEADER_SIZE - buf_len == 0 ) { /* too large header */ char* badreq; badreq = BAD_REQUEST; rv = _write_timeout(fd, timeout, badreq, sizeof(BAD_REQUEST) - 1); close(fd); goto badexit; } /* request is incomplete */ rv = _read_timeout(fd, timeout, &read_buf[buf_len], MAX_HEADER_SIZE - buf_len); if ( rv <= 0 ) { close(fd); goto badexit; } buf_len += rv; } req = rb_ary_new2(3); rb_ary_push(req, rb_int_new(fd)); rb_ary_push(req, rb_str_new(&read_buf[reqlen],buf_len - reqlen)); return req; badexit: return Qnil; }
/* * call-seq: array_nl() * * This string is put at the end of a line that holds a JSON array. */ static VALUE cState_array_nl(VALUE self) { GET_STATE(self); return state->array_nl ? rb_str_new(state->array_nl, state->array_nl_len) : rb_str_new2(""); }
/* * STRING conversion */ VALUE asn1str_to_str(ASN1_STRING *str) { return rb_str_new(str->data, str->length); }
VALUE rb_exc_new(VALUE etype, const char *ptr, long len) { return rb_funcall(etype, rb_intern("new"), 1, rb_str_new(ptr, len)); }
/* * call-seq: indent() * * This string is used to indent levels in the JSON text. */ static VALUE cState_indent(VALUE self) { GET_STATE(self); return state->indent ? rb_str_new(state->indent, state->indent_len) : rb_str_new2(""); }
static VALUE rdmtx_encode(int argc, VALUE * argv, VALUE self) { VALUE string, margin, module, size; VALUE safeString; VALUE magickImageClass; VALUE outputImage; int safeMargin, safeModule, safeSize; int width; int height; DmtxEncode * enc; rb_scan_args(argc, argv, "13", &string, &margin, &module, &size); safeString = StringValue(string); if(NIL_P(margin)) { safeMargin = 5; } else { safeMargin = NUM2INT(margin); } if(NIL_P(module)) { safeModule = 5; } else { safeModule = NUM2INT(module); } if(NIL_P(size)) { safeSize = DmtxSymbolSquareAuto; } else { safeSize = NUM2INT(size); } // printf("Margin = %d, Module = %d, Size = %d\n", safeMargin, safeModule, safeSize); /* Create and initialize libdmtx structures */ enc = dmtxEncodeCreate(); dmtxEncodeSetProp(enc, DmtxPropPixelPacking, DmtxPack24bppRGB); dmtxEncodeSetProp(enc, DmtxPropSizeRequest, safeSize); dmtxEncodeSetProp(enc, DmtxPropMarginSize, safeMargin); dmtxEncodeSetProp(enc, DmtxPropModuleSize, safeModule); /* Create barcode image */ if (dmtxEncodeDataMatrix(enc, RSTRING_LEN(safeString), (unsigned char *)RSTRING_PTR(safeString)) == DmtxFail) { // printf("Fatal error !\n"); dmtxEncodeDestroy(&enc); return Qnil; } width = dmtxImageGetProp(enc->image, DmtxPropWidth); height = dmtxImageGetProp(enc->image, DmtxPropHeight); magickImageClass = rb_path2class("Magick::Image"); outputImage = rb_funcall(magickImageClass, rb_intern("new"), 2, INT2NUM(width), INT2NUM(height)); rb_funcall(outputImage, rb_intern("import_pixels"), 7, INT2NUM(0), INT2NUM(0), INT2NUM(width), INT2NUM(height), rb_str_new("RGB", 3), rb_str_new((char *)enc->image->pxl, 3*width*height), // rb_const_get("Magick" ,rb_intern("CharPixel")) rb_eval_string("Magick::CharPixel")); /* Clean up */ dmtxEncodeDestroy(&enc); return outputImage; }
/* * Document-method: auto_link * * call-seq: * auto_link(text, mode=:all, link_attr=nil, skip_tags=nil, flags=0) * auto_link(text, mode=:all, link_attr=nil, skip_tags=nil, flags=0) { |link_text| ... } * * Parses a block of text looking for "safe" urls or email addresses, * and turns them into HTML links with the given attributes. * * NOTE: The block of text may or may not be HTML; if the text is HTML, * Rinku will skip the relevant tags to prevent double-linking and linking * inside `pre` blocks by default. * * NOTE: If the input text is HTML, it's expected to be already escaped. * Rinku will perform no escaping. * * NOTE: Currently the follow protocols are considered safe and are the * only ones that will be autolinked. * * http:// https:// ftp:// mailto:// * * Email addresses are also autolinked by default. URLs without a protocol * specifier but starting with 'www.' will also be autolinked, defaulting to * the 'http://' protocol. * * - `text` is a string in plain text or HTML markup. If the string is formatted in * HTML, Rinku is smart enough to skip the links that are already enclosed in `<a>` * tags.` * * - `mode` is a symbol, either `:all`, `:urls` or `:email_addresses`, * which specifies which kind of links will be auto-linked. * * - `link_attr` is a string containing the link attributes for each link that * will be generated. These attributes are not sanitized and will be include as-is * in each generated link, e.g. * * ~~~~~ruby * auto_link('http://www.pokemon.com', :all, 'target="_blank"') * # => '<a href="http://www.pokemon.com" target="_blank">http://www.pokemon.com</a>' * ~~~~~ * * This string can be autogenerated from a hash using the Rails `tag_options` helper. * * - `skip_tags` is a list of strings with the names of HTML tags that will be skipped * when autolinking. If `nil`, this defaults to the value of the global `Rinku.skip_tags`, * which is initially `["a", "pre", "code", "kbd", "script"]`. * * - `flag` is an optional boolean value specifying whether to recognize * 'http://foo' as a valid domain, or require at least one '.'. It defaults to false. * * - `&block` is an optional block argument. If a block is passed, it will * be yielded for each found link in the text, and its return value will be used instead * of the name of the link. E.g. * * ~~~~~ruby * auto_link('Check it out at http://www.pokemon.com') do |url| * "THE POKEMAN WEBSITEZ" * end * # => 'Check it out at <a href="http://www.pokemon.com">THE POKEMAN WEBSITEZ</a>' * ~~~~~~ */ static VALUE rb_rinku_autolink(int argc, VALUE *argv, VALUE self) { static const char *SKIP_TAGS[] = {"a", "pre", "code", "kbd", "script", NULL}; VALUE result, rb_text, rb_mode, rb_html, rb_skip, rb_flags, rb_block; struct buf *output_buf; int link_mode, count; unsigned int link_flags = 0; const char *link_attr = NULL; const char **skip_tags = NULL; ID mode_sym; rb_scan_args(argc, argv, "14&", &rb_text, &rb_mode, &rb_html, &rb_skip, &rb_flags, &rb_block); Check_Type(rb_text, T_STRING); if (!NIL_P(rb_mode)) { Check_Type(rb_mode, T_SYMBOL); mode_sym = SYM2ID(rb_mode); } else { mode_sym = rb_intern("all"); } if (!NIL_P(rb_html)) { Check_Type(rb_html, T_STRING); link_attr = RSTRING_PTR(rb_html); } if (NIL_P(rb_skip)) rb_skip = rb_iv_get(self, "@skip_tags"); if (NIL_P(rb_skip)) { skip_tags = SKIP_TAGS; } else { skip_tags = rinku_load_tags(rb_skip); } if (!NIL_P(rb_flags)) { Check_Type(rb_flags, T_FIXNUM); link_flags = FIX2INT(rb_flags); } output_buf = bufnew(32); if (mode_sym == rb_intern("all")) link_mode = AUTOLINK_ALL; else if (mode_sym == rb_intern("email_addresses")) link_mode = AUTOLINK_EMAILS; else if (mode_sym == rb_intern("urls")) link_mode = AUTOLINK_URLS; else rb_raise(rb_eTypeError, "Invalid linking mode (possible values are :all, :urls, :email_addresses)"); count = rinku_autolink( output_buf, RSTRING_PTR(rb_text), RSTRING_LEN(rb_text), link_mode, link_flags, link_attr, skip_tags, RTEST(rb_block) ? &autolink_callback : NULL, (void*)rb_block); if (count == 0) result = rb_text; else { result = rb_str_new(output_buf->data, output_buf->size); rb_enc_copy(result, rb_text); } if (skip_tags != SKIP_TAGS) xfree(skip_tags); bufrelease(output_buf); return result; }
/** * Convert the buffer to a string. */ VALUE rb_bson_byte_buffer_to_s(VALUE self) { byte_buffer_t *b; TypedData_Get_Struct(self, byte_buffer_t, &rb_byte_buffer_data_type, b); return rb_str_new(READ_PTR(b), READ_SIZE(b)); }
VALUE symbol_spec_rb_id2name(VALUE self, VALUE symbol) { const char* c_str = rb_id2name(SYM2ID(symbol)); return rb_str_new(c_str, strlen(c_str)); }
// do not raise error void nyara_parse_query(VALUE output, const char* s, long len) { volatile VALUE str = rb_str_new(s, len); _tmp_str = str; int err = 0; rb_protect(_parse_query_func, output, &err); }
static VALUE rb_tinytds_result_fetch_row(VALUE self, ID timezone, int symbolize_keys, int as_array) { VALUE row; /* Storing Values */ unsigned int i; /* Wrapper And Local Vars */ GET_RESULT_WRAPPER(self); /* Create Empty Row */ row = as_array ? rb_ary_new2(rwrap->number_of_fields) : rb_hash_new(); for (i = 0; i < rwrap->number_of_fields; i++) { VALUE val = Qnil; int col = i+1; int coltype = dbcoltype(rwrap->client, col); BYTE *data = dbdata(rwrap->client, col); DBINT data_len = dbdatlen(rwrap->client, col); int null_val = ((data == NULL) && (data_len == 0)); if (!null_val) { switch(coltype) { case SYBINT1: val = INT2FIX(*(DBTINYINT *)data); break; case SYBINT2: val = INT2FIX(*(DBSMALLINT *)data); break; case SYBINT4: val = INT2NUM(*(DBINT *)data); break; case SYBINT8: val = LL2NUM(*(DBBIGINT *)data); break; case SYBBIT: val = *(int *)data ? Qtrue : Qfalse; break; case SYBNUMERIC: case SYBDECIMAL: { DBTYPEINFO *data_info = dbcoltypeinfo(rwrap->client, col); int data_slength = (int)data_info->precision + (int)data_info->scale + 1; char converted_decimal[data_slength]; dbconvert(rwrap->client, coltype, data, data_len, SYBVARCHAR, (BYTE *)converted_decimal, -1); val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new2((char *)converted_decimal)); break; } case SYBFLT8: { double col_to_double = *(double *)data; val = (col_to_double == 0.000000) ? opt_float_zero : rb_float_new(col_to_double); break; } case SYBREAL: { float col_to_float = *(float *)data; val = (col_to_float == 0.0) ? opt_float_zero : rb_float_new(col_to_float); break; } case SYBMONEY: { DBMONEY *money = (DBMONEY *)data; char converted_money[25]; long long money_value = ((long long)money->mnyhigh << 32) | money->mnylow; sprintf(converted_money, "%" LONG_LONG_FORMAT, money_value); val = rb_funcall(cBigDecimal, intern_new, 2, rb_str_new2(converted_money), opt_four); val = rb_funcall(val, intern_divide, 1, opt_tenk); break; } case SYBMONEY4: { DBMONEY4 *money = (DBMONEY4 *)data; char converted_money[20]; sprintf(converted_money, "%f", money->mny4 / 10000.0); val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new2(converted_money)); break; } case SYBBINARY: case SYBIMAGE: val = rb_str_new((char *)data, (long)data_len); #ifdef HAVE_RUBY_ENCODING_H rb_enc_associate(val, binaryEncoding); #endif break; case 36: { // SYBUNIQUE char converted_unique[37]; dbconvert(rwrap->client, coltype, data, 37, SYBVARCHAR, (BYTE *)converted_unique, -1); val = ENCODED_STR_NEW2(converted_unique); break; } case SYBDATETIME4: { DBDATETIME new_data; dbconvert(rwrap->client, coltype, data, data_len, SYBDATETIME, (BYTE *)&new_data, sizeof(new_data)); data = (BYTE *)&new_data; data_len = sizeof(new_data); } case SYBDATETIME: { DBDATEREC dr; dbdatecrack(rwrap->client, &dr, (DBDATETIME *)data); if (dr.year + dr.month + dr.day + dr.hour + dr.minute + dr.second + dr.millisecond != 0) { val = rb_funcall(rb_cTime, timezone, 7, INT2NUM(dr.year), INT2NUM(dr.month), INT2NUM(dr.day), INT2NUM(dr.hour), INT2NUM(dr.minute), INT2NUM(dr.second), INT2NUM(dr.millisecond*1000)); } break; } case 40: // SYBMSDATE case 41: // SYBMSTIME case 42: // SYBMSDATETIME2 case 43: { // SYBMSDATETIMEOFFSET #ifdef DBVERSION_73 if (dbtds(rwrap->client) >= DBTDS_7_3) { DBDATEREC2 dr2; dbanydatecrack(rwrap->client, &dr2, coltype, data); switch(coltype) { case 40: { // SYBMSDATE val = rb_funcall(cDate, intern_new, 3, INT2NUM(dr2.year), INT2NUM(dr2.month), INT2NUM(dr2.day)); break; } case 41: { // SYBMSTIME VALUE rational_nsec = rb_Rational(INT2NUM(dr2.nanosecond), opt_onek); val = rb_funcall(rb_cTime, timezone, 7, INT2NUM(1900), INT2NUM(1), INT2NUM(1), INT2NUM(dr2.hour), INT2NUM(dr2.minute), INT2NUM(dr2.second), rational_nsec); break; } case 42: { // SYBMSDATETIME2 VALUE rational_nsec = rb_Rational(INT2NUM(dr2.nanosecond), opt_onek); val = rb_funcall(rb_cTime, timezone, 7, INT2NUM(dr2.year), INT2NUM(dr2.month), INT2NUM(dr2.day), INT2NUM(dr2.hour), INT2NUM(dr2.minute), INT2NUM(dr2.second), rational_nsec); break; } case 43: { // SYBMSDATETIMEOFFSET long long numerator = ((long)dr2.second * (long long)1000000000) + (long long)dr2.nanosecond; VALUE rational_sec = rb_Rational(LL2NUM(numerator), opt_onebil); val = rb_funcall(rb_cTime, intern_new, 7, INT2NUM(dr2.year), INT2NUM(dr2.month), INT2NUM(dr2.day), INT2NUM(dr2.hour), INT2NUM(dr2.minute), rational_sec, INT2NUM(dr2.tzone*60)); break; } } } else { val = ENCODED_STR_NEW(data, data_len); } #else val = ENCODED_STR_NEW(data, data_len); #endif break; } case SYBCHAR: case SYBTEXT: val = ENCODED_STR_NEW(data, data_len); break; default: val = ENCODED_STR_NEW(data, data_len); break; } } if (as_array) { rb_ary_store(row, i, val); } else { VALUE key; if (rwrap->number_of_results == 0) { key = rb_ary_entry(rwrap->fields, i); } else { key = rb_ary_entry(rb_ary_entry(rwrap->fields, rwrap->number_of_results), i); } rb_hash_aset(row, key, val); } } return row; }
VALUE intersys_query_get_data(VALUE self, VALUE index) { struct rbQuery* query; int type = 0; VALUE ret = Qnil; bool_t is_null; Data_Get_Struct(self, struct rbQuery, query); RUN(cbind_query_get_col_sql_type(query->query, FIX2INT(index), &type)); switch(type) { case SQL_WCHAR: case SQL_WVARCHAR: case SQL_WLONGVARCHAR: case SQL_CHAR: case SQL_VARCHAR: case SQL_LONGVARCHAR: { wchar_t buf[32767]; int size; RUN(cbind_query_get_uni_str_data(query->query, buf, sizeof(buf), &size, &is_null)); if (is_null) { return Qnil; } return FROMWCSTR(buf); } case SQL_BINARY: case SQL_LONGVARBINARY: case SQL_VARBINARY: { char buf[32767]; int size; RUN(cbind_query_get_bin_data(query->query, buf, sizeof(buf), &size, &is_null)); if (is_null) { return Qnil; } return rb_str_new(buf, size); } case SQL_TINYINT: case SQL_SMALLINT: case SQL_INTEGER: case SQL_BIGINT: case SQL_BIT: { int res; RUN(cbind_query_get_int_data(query->query, &res, &is_null)); if (is_null) { return Qnil; } return INT2NUM(res); } case SQL_FLOAT: case SQL_DOUBLE: case SQL_REAL: case SQL_NUMERIC: case SQL_DECIMAL: { double res; RUN(cbind_query_get_double_data(query->query, &res, &is_null)); if (is_null) { return Qnil; } return rb_float_new(res); } } return ret; }
static VALUE zipruby_archive_s_open_buffer(int argc, VALUE *argv, VALUE self) { VALUE buffer, flags, comp_level; VALUE archive; struct zipruby_archive *p_archive; void *data = NULL; int len = 0, i_flags = 0; int errorp; int i_comp_level = Z_BEST_COMPRESSION; int buffer_is_temporary = 0; rb_scan_args(argc, argv, "03", &buffer, &flags, &comp_level); if (FIXNUM_P(buffer) && NIL_P(comp_level)) { comp_level = flags; flags = buffer; buffer = Qnil; } if (!NIL_P(flags)) { i_flags = NUM2INT(flags); } if (!NIL_P(comp_level)) { i_comp_level = NUM2INT(comp_level); if (i_comp_level != Z_DEFAULT_COMPRESSION && i_comp_level != Z_NO_COMPRESSION && (i_comp_level < Z_BEST_SPEED || Z_BEST_COMPRESSION < i_comp_level)) { rb_raise(rb_eArgError, "Wrong compression level %d", i_comp_level); } } if (i_flags & ZIP_CREATE) { if (!NIL_P(buffer)) { Check_Type(buffer, T_STRING); } else { buffer = rb_str_new("", 0); buffer_is_temporary = 1; } i_flags = (i_flags | ZIP_TRUNCATE); } else if (TYPE(buffer) == T_STRING) { data = RSTRING_PTR(buffer); len = RSTRING_LEN(buffer); } else if (rb_obj_is_instance_of(buffer, rb_cProc)) { data = (void *) buffer; len = -1; } else { rb_raise(rb_eTypeError, "wrong argument type %s (expected String or Proc)", rb_class2name(CLASS_OF(buffer))); } archive = rb_funcall(Archive, rb_intern("new"), 0); Data_Get_Struct(archive, struct zipruby_archive, p_archive); if ((p_archive->tmpfilnam = zipruby_tmpnam(data, len)) == NULL) { rb_raise(Error, "Open archive failed: Failed to create temporary file"); } if ((p_archive->archive = zip_open(p_archive->tmpfilnam, i_flags, &errorp)) == NULL) { char errstr[ERRSTR_BUFSIZE]; zip_error_to_str(errstr, ERRSTR_BUFSIZE, errorp, errno); rb_raise(Error, "Open archive failed: %s", errstr); } // p_archive->archive->comp_level = i_comp_level; p_archive->path = rb_str_new2(p_archive->tmpfilnam); p_archive->flags = i_flags; p_archive->buffer = buffer; p_archive->sources = rb_ary_new(); if (rb_block_given_p()) { VALUE retval; int status; retval = rb_protect(rb_yield, archive, &status); zipruby_archive_close(archive); if (status != 0) { rb_jump_tag(status); } return buffer_is_temporary ? buffer : retval; } else { return archive; } }
/** * filter_html **/ static VALUE t_filter_html(VALUE self, VALUE str) { node root, now, ret; bool in_tag; char *text; const char* inner_tag; long i, head_i, tail_i, copy_head_i, total_len; VALUE change_str, url_base, word; rb_encoding *enc; change_str = rb_str_new2(EMPTY_STRING); enc = rb_enc_get(str); text = StringValuePtr(str); Data_Get_Struct(self, struct _node, root); url_base = rb_iv_get(self, LINK_URL_VARIABLE); if (url_base == Qnil) { url_base = rb_str_new2(DEAULT_LINK_URL); } now = root; total_len = strlen(text); head_i = -1; tail_i = -1; copy_head_i = 0; in_tag = false; inner_tag = NULL; for(i = 0; i <= total_len; i++) { if (!in_tag && text[i] == BEGIN_TAG) { in_tag = true; if (strncasecmp(&text[i + 1], A_TAG, strlen(A_TAG)) == 0) { inner_tag = A_TAG; } else if (strncasecmp(&text[i + 1], SCRIPT_TAG, strlen(SCRIPT_TAG)) == 0) { inner_tag = SCRIPT_TAG; } else if (strncasecmp(&text[i + 1], PRE_TAG, strlen(PRE_TAG)) == 0) { inner_tag = PRE_TAG; } else if (strncasecmp(&text[i + 1], IFRAME_TAG, strlen(IFRAME_TAG)) == 0) { inner_tag = IFRAME_TAG; } else if (strncasecmp(&text[i + 1], OBJECT_TAG, strlen(OBJECT_TAG)) == 0) { inner_tag = OBJECT_TAG; } continue; } if (in_tag && !inner_tag && text[i] == END_TAG) { in_tag = false; continue; } if (inner_tag && text[i] == BEGIN_TAG) { if (strncasecmp(&text[i + 2], inner_tag, strlen(inner_tag)) == 0) { inner_tag = NULL; continue; } } if (in_tag) { continue; } ret = search_child(now, text[i]); if (ret && i != total_len) { if (head_i == -1) { head_i = i; } if (ret->end_flag) { tail_i = i; } now = ret; } else { if (head_i != -1) { if (tail_i != -1) { if (copy_head_i < head_i) { rb_funcall( change_str, rb_intern("concat"), 1, add_encode(rb_str_new(&text[copy_head_i], (head_i - copy_head_i)), enc) ); } word = rb_str_new(&text[head_i], (tail_i - head_i + 1)); rb_funcall( change_str, rb_intern("concat"), 1, add_encode(rb_funcall(url_base, rb_intern("%"), 1, rb_assoc_new(word, word)), enc) ); i = tail_i; copy_head_i = tail_i + 1; tail_i = -1; } else { i = head_i; } head_i = -1; } now = root; } } if (copy_head_i == 0) { return str; } else { rb_funcall( change_str, rb_intern("concat"), 1, add_encode(rb_str_new(&text[copy_head_i], (total_len - copy_head_i)), enc) ); return change_str; } }
VALUE rb_exc_new(VALUE etype, const char *ptr, long len) { return rb_funcall(etype, id_new, 1, rb_str_new(ptr, len)); }
static VALUE get_value(const char* buffer, int* position, int type) { VALUE value; switch (type) { case -1: { value = rb_class_new_instance(0, NULL, MinKey); break; } case 1: { double d; memcpy(&d, buffer + *position, 8); value = rb_float_new(d); *position += 8; break; } case 2: case 13: { int value_length; value_length = *(int*)(buffer + *position) - 1; *position += 4; value = STR_NEW(buffer + *position, value_length); *position += value_length + 1; break; } case 3: { int size; memcpy(&size, buffer + *position, 4); if (strcmp(buffer + *position + 5, "$ref") == 0) { // DBRef int offset = *position + 10; VALUE argv[2]; int collection_length = *(int*)(buffer + offset) - 1; char id_type; offset += 4; argv[0] = STR_NEW(buffer + offset, collection_length); offset += collection_length + 1; id_type = buffer[offset]; offset += 5; argv[1] = get_value(buffer, &offset, (int)id_type); value = rb_class_new_instance(2, argv, DBRef); } else { value = elements_to_hash(buffer + *position + 4, size - 5); } *position += size; break; } case 4: { int size, end; memcpy(&size, buffer + *position, 4); end = *position + size - 1; *position += 4; value = rb_ary_new(); while (*position < end) { int type = (int)buffer[(*position)++]; int key_size = (int)strlen(buffer + *position); VALUE to_append; *position += key_size + 1; // just skip the key, they're in order. to_append = get_value(buffer, position, type); rb_ary_push(value, to_append); } (*position)++; break; } case 5: { int length, subtype; VALUE data, st; VALUE argv[2]; memcpy(&length, buffer + *position, 4); subtype = (unsigned char)buffer[*position + 4]; if (subtype == 2) { data = rb_str_new(buffer + *position + 9, length - 4); } else { data = rb_str_new(buffer + *position + 5, length); } st = INT2FIX(subtype); argv[0] = data; argv[1] = st; value = rb_class_new_instance(2, argv, Binary); *position += length + 5; break; } case 6: { value = Qnil; break; } case 7: { VALUE str = rb_str_new(buffer + *position, 12); VALUE oid = rb_funcall(str, unpack_method, 1, rb_str_new2("C*")); value = rb_class_new_instance(1, &oid, ObjectId); *position += 12; break; } case 8: { value = buffer[(*position)++] ? Qtrue : Qfalse; break; } case 9: { int64_t millis; memcpy(&millis, buffer + *position, 8); // Support 64-bit time values in 32 bit environments in Ruby > 1.9 // Note: rb_time_num_new is not available pre Ruby 1.9 #if RUBY_API_VERSION_CODE >= 10900 #define add(x,y) (rb_funcall((x), '+', 1, (y))) #define mul(x,y) (rb_funcall((x), '*', 1, (y))) #define quo(x,y) (rb_funcall((x), rb_intern("quo"), 1, (y))) VALUE d, timev; d = LL2NUM(1000LL); timev = add(LL2NUM(millis / 1000), quo(LL2NUM(millis % 1000), d)); value = rb_time_num_new(timev, Qnil); #else value = rb_time_new(millis / 1000, (millis % 1000) * 1000); #endif value = rb_funcall(value, utc_method, 0); *position += 8; break; } case 10: { value = Qnil; break; } case 11: { int pattern_length = (int)strlen(buffer + *position); VALUE pattern = STR_NEW(buffer + *position, pattern_length); int flags_length, flags = 0, i = 0; VALUE argv[3]; *position += pattern_length + 1; flags_length = (int)strlen(buffer + *position); for (i = 0; i < flags_length; i++) { char flag = buffer[*position + i]; if (flag == 'i') { flags |= IGNORECASE; } else if (flag == 'm') { flags |= MULTILINE; } else if (flag == 's') { flags |= MULTILINE; } else if (flag == 'x') { flags |= EXTENDED; } } argv[0] = pattern; argv[1] = INT2FIX(flags); value = rb_class_new_instance(2, argv, Regexp); *position += flags_length + 1; break; } case 12: { int collection_length; VALUE collection, str, oid, id, argv[2]; collection_length = *(int*)(buffer + *position) - 1; *position += 4; collection = STR_NEW(buffer + *position, collection_length); *position += collection_length + 1; str = rb_str_new(buffer + *position, 12); oid = rb_funcall(str, unpack_method, 1, rb_str_new2("C*")); id = rb_class_new_instance(1, &oid, ObjectId); *position += 12; argv[0] = collection; argv[1] = id; value = rb_class_new_instance(2, argv, DBRef); break; } case 14: { int value_length; memcpy(&value_length, buffer + *position, 4); value = ID2SYM(rb_intern(buffer + *position + 4)); *position += value_length + 4; break; } case 15: { int code_length, scope_size; VALUE code, scope, argv[2]; *position += 4; code_length = *(int*)(buffer + *position) - 1; *position += 4; code = STR_NEW(buffer + *position, code_length); *position += code_length + 1; memcpy(&scope_size, buffer + *position, 4); scope = elements_to_hash(buffer + *position + 4, scope_size - 5); *position += scope_size; argv[0] = code; argv[1] = scope; value = rb_class_new_instance(2, argv, Code); break; } case 16: { int i; memcpy(&i, buffer + *position, 4); value = LL2NUM(i); *position += 4; break; } case 17: { unsigned int sec, inc; VALUE argv[2]; memcpy(&inc, buffer + *position, 4); memcpy(&sec, buffer + *position + 4, 4); argv[0] = UINT2NUM(sec); argv[1] = UINT2NUM(inc); value = rb_class_new_instance(2, argv, Timestamp); *position += 8; break; } case 18: { long long ll; memcpy(&ll, buffer + *position, 8); value = LL2NUM(ll); *position += 8; break; } case 127: { value = rb_class_new_instance(0, NULL, MaxKey); break; } default: { rb_raise(rb_eTypeError, "no c decoder for this type yet (%d)", type); break; } } return value; }
static VALUE find_file(VALUE fname) { VALUE res = 0; int nOK = 0; //RAWLOG_INFO1("find_file: fname: %s", RSTRING_PTR(fname)); #ifdef RHODES_EMULATOR if ( strncmp(RSTRING_PTR(fname), rho_simconf_getRhodesPath(), strlen(rho_simconf_getRhodesPath())) == 0 ) res = fname; else #endif if ( strncmp(RSTRING_PTR(fname), rho_native_rhopath(), strlen(rho_native_rhopath())) == 0 ){ res = rb_str_dup(fname); rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT)); //RAWLOG_INFO1("find_file: res: %s", RSTRING_PTR(res)); } else if ( strncmp(RSTRING_PTR(fname), rho_native_reruntimepath(), strlen(rho_native_reruntimepath())) == 0 ){ res = rb_str_dup(fname); rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT)); //RAWLOG_INFO1("find_file: res: %s", RSTRING_PTR(res)); }else{ int i = 0; VALUE load_path = GET_VM()->load_path; //VALUE dir; VALUE fname1 = checkRhoBundleInPath(fname); //RAWLOG_INFO1("find_file: fname after checkRhoBundleInPath: %s", RSTRING_PTR(fname)); //TODO: support document relative require in case of multiple apps if (RARRAY_LEN(load_path)>1){ for( ; i < RARRAY_LEN(load_path); i++ ){ VALUE dir = RARRAY_PTR(load_path)[i]; #ifdef RHODES_EMULATOR res = check_app_file_exist(dir, fname1, rho_simconf_getString("platform")); #endif if ( !res ) res = check_app_file_exist(dir, fname1, 0 ); if (res) { nOK = 1; break; } } if ( !nOK ) { #ifdef RHODES_EMULATOR //check for extensions /* res = rb_str_new2(rho_simconf_getRhodesPath() ); rb_str_cat2(res,"/lib/extensions/"); res = check_extension(res, fname, 1); if ( !res ) { res = rb_str_new2(rho_native_rhopath() ); rb_str_cat2(res,"/extensions/"); res = check_extension(res, fname,1); } if ( !res ) { res = rb_str_new2( rho_simconf_getString("ext_path") ); res = check_extension(res, fname, 0); } */ const char* szPaths = rho_simconf_getString("ext_path"); const char* szPath = szPaths; const char* szSep = strchr(szPath, ';'); res = 0; for( ; szSep; szSep = strchr(szPath, ';') ) { res = rb_str_new( szPath, szSep-szPath); rb_str_cat2(res,"/"); rb_str_append(res,fname); rb_str_cat2(res,RHO_RB_EXT); if ( eaccess(RSTRING_PTR(res), R_OK) == 0 ) break; res = rb_str_new( szPath, szSep-szPath); rb_str_cat2(res,"/app/"); rb_str_append(res,fname); rb_str_cat2(res,RHO_RB_EXT); if ( eaccess(RSTRING_PTR(res), R_OK) == 0 ) break; res = 0; szPath = szSep+1; } if( res ) nOK = 1; else return 0; #else return 0; #endif } } /*else { dir = RARRAY_PTR(load_path)[RARRAY_LEN(load_path)-1]; res = rb_str_dup(dir); rb_str_cat(res,"/",1); rb_str_cat(res,RSTRING_PTR(fname),RSTRING_LEN(fname)); rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT)); if ( g_curAppPath != 0 && eaccess(RSTRING_PTR(res), R_OK) != 0 ){ res = rb_str_new2(g_curAppPath); rb_str_cat(res,"/",1); rb_str_cat(res,RSTRING_PTR(fname),RSTRING_LEN(fname)); rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT)); } } */ } //RAWLOG_INFO1("find_file: RhoPreparePath: %s", RSTRING_PTR(res)); res = RhoPreparePath(res); if ( !nOK ) nOK = 1;//eaccess(RSTRING_PTR(res), R_OK) == 0 ? 1 : 0; return nOK ? res : 0; }
static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self) { VALUE rowHash, opts, block; mysql2_result_wrapper * wrapper; MYSQL_ROW row; MYSQL_FIELD * fields = NULL; unsigned int i = 0, symbolizeKeys = 0; unsigned long * fieldLengths; void * ptr; #ifdef HAVE_RUBY_ENCODING_H rb_encoding *default_internal_enc = rb_default_internal_encoding(); rb_encoding *conn_enc = rb_to_encoding(rb_iv_get(self, "@encoding")); #endif GetMysql2Result(self, wrapper); if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) { Check_Type(opts, T_HASH); if (rb_hash_aref(opts, sym_symbolize_keys) == Qtrue) { symbolizeKeys = 1; } } ptr = wrapper->result; row = (MYSQL_ROW)rb_thread_blocking_region(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0); if (row == NULL) { return Qnil; } rowHash = rb_hash_new(); fields = mysql_fetch_fields(wrapper->result); fieldLengths = mysql_fetch_lengths(wrapper->result); if (wrapper->fields == Qnil) { wrapper->numberOfFields = mysql_num_fields(wrapper->result); wrapper->fields = rb_ary_new2(wrapper->numberOfFields); } for (i = 0; i < wrapper->numberOfFields; i++) { VALUE field = rb_mysql_result_fetch_field(self, i, symbolizeKeys); if (row[i]) { VALUE val; switch(fields[i].type) { case MYSQL_TYPE_NULL: // NULL-type field val = Qnil; break; case MYSQL_TYPE_BIT: // BIT field (MySQL 5.0.3 and up) val = rb_str_new(row[i], fieldLengths[i]); break; case MYSQL_TYPE_TINY: // TINYINT field case MYSQL_TYPE_SHORT: // SMALLINT field case MYSQL_TYPE_LONG: // INTEGER field case MYSQL_TYPE_INT24: // MEDIUMINT field case MYSQL_TYPE_LONGLONG: // BIGINT field case MYSQL_TYPE_YEAR: // YEAR field val = rb_cstr2inum(row[i], 10); break; case MYSQL_TYPE_DECIMAL: // DECIMAL or NUMERIC field case MYSQL_TYPE_NEWDECIMAL: // Precision math DECIMAL or NUMERIC field (MySQL 5.0.3 and up) val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(row[i], fieldLengths[i])); break; case MYSQL_TYPE_FLOAT: // FLOAT field case MYSQL_TYPE_DOUBLE: // DOUBLE or REAL field val = rb_float_new(strtod(row[i], NULL)); break; case MYSQL_TYPE_TIME: { // TIME field int hour, min, sec, tokens; tokens = sscanf(row[i], "%2d:%2d:%2d", &hour, &min, &sec); val = rb_funcall(rb_cTime, intern_utc, 6, INT2NUM(0), INT2NUM(1), INT2NUM(1), INT2NUM(hour), INT2NUM(min), INT2NUM(sec)); break; } case MYSQL_TYPE_TIMESTAMP: // TIMESTAMP field case MYSQL_TYPE_DATETIME: { // DATETIME field int year, month, day, hour, min, sec, tokens; tokens = sscanf(row[i], "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec); if (year+month+day+hour+min+sec == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date: %s", row[i]); val = Qnil; } else { val = rb_funcall(rb_cTime, intern_utc, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec)); } } break; } case MYSQL_TYPE_DATE: // DATE field case MYSQL_TYPE_NEWDATE: { // Newer const used > 5.0 int year, month, day, tokens; tokens = sscanf(row[i], "%4d-%2d-%2d", &year, &month, &day); if (year+month+day == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date: %s", row[i]); val = Qnil; } else { val = rb_funcall(cDate, intern_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day)); } } break; } case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_BLOB: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_STRING: // CHAR or BINARY field case MYSQL_TYPE_SET: // SET field case MYSQL_TYPE_ENUM: // ENUM field case MYSQL_TYPE_GEOMETRY: // Spatial fielda default: val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H // if binary flag is set, respect it's wishes if (fields[i].flags & BINARY_FLAG) { rb_enc_associate(val, binaryEncoding); } else { // lookup the encoding configured on this field VALUE new_encoding = rb_funcall(cMysql2Client, intern_encoding_from_charset_code, 1, INT2NUM(fields[i].charsetnr)); if (new_encoding != Qnil) { // use the field encoding we were able to match rb_encoding *enc = rb_to_encoding(new_encoding); rb_enc_associate(val, enc); } else { // otherwise fall-back to the connection's encoding rb_enc_associate(val, conn_enc); } if (default_internal_enc) { val = rb_str_export_to_enc(val, default_internal_enc); } } #endif break; } rb_hash_aset(rowHash, field, val); } else { rb_hash_aset(rowHash, field, Qnil); } } return rowHash; }
/* * call-seq: space_before() * * This string is used to insert a space before the ':' in JSON objects. */ static VALUE cState_space_before(VALUE self) { GET_STATE(self); return state->space_before ? rb_str_new(state->space_before, state->space_before_len) : rb_str_new2(""); }
/* * call-seq: * Verse.create_host_id -> string * * Create an ID for the verse host that clients can later use to verify * which server they're connecting to. * */ static VALUE rbverse_verse_create_host_id( VALUE module ) { uint8 id[V_HOST_ID_SIZE]; verse_host_id_create( id ); return rb_str_new( (const char *)id, V_HOST_ID_SIZE ); }
static VALUE ossl_asn1_decode0(unsigned char **pp, long length, long *offset, long depth, int once, int yield) { unsigned char *start, *p; long len, off = *offset; int hlen, tag, tc, j; VALUE ary, asn1data, value, tag_class; ary = rb_ary_new(); p = *pp; while(length > 0){ start = p; j = ASN1_get_object(&p, &len, &tag, &tc, length); if(j & 0x80) ossl_raise(eASN1Error, NULL); hlen = p - start; if(yield){ VALUE arg = rb_ary_new(); rb_ary_push(arg, LONG2NUM(depth)); rb_ary_push(arg, LONG2NUM(off)); rb_ary_push(arg, LONG2NUM(hlen)); rb_ary_push(arg, LONG2NUM(len)); rb_ary_push(arg, (j & V_ASN1_CONSTRUCTED) ? Qtrue : Qfalse); rb_ary_push(arg, ossl_asn1_class2sym(tc)); rb_ary_push(arg, INT2NUM(tag)); rb_yield(arg); } length -= hlen; off += hlen; if(len > length) ossl_raise(eASN1Error, "value is too short"); if((tc & V_ASN1_PRIVATE) == V_ASN1_PRIVATE) tag_class = sPRIVATE; else if((tc & V_ASN1_CONTEXT_SPECIFIC) == V_ASN1_CONTEXT_SPECIFIC) tag_class = sCONTEXT_SPECIFIC; else if((tc & V_ASN1_APPLICATION) == V_ASN1_APPLICATION) tag_class = sAPPLICATION; else tag_class = sUNIVERSAL; if(j & V_ASN1_CONSTRUCTED){ /* TODO: if j == 0x21 it is indefinite length object. */ if((j == 0x21) && (len == 0)){ long lastoff = off; value = ossl_asn1_decode0(&p, length, &off, depth+1, 0, yield); len = off - lastoff; } else value = ossl_asn1_decode0(&p, len, &off, depth+1, 0, yield); } else{ value = rb_str_new(p, len); p += len; off += len; } if(tag_class == sUNIVERSAL && tag < ossl_asn1_info_size && ossl_asn1_info[tag].klass){ VALUE klass = *ossl_asn1_info[tag].klass; long flag = 0; if(!rb_obj_is_kind_of(value, rb_cArray)){ switch(tag){ case V_ASN1_BOOLEAN: value = decode_bool(start, hlen+len); break; case V_ASN1_INTEGER: value = decode_int(start, hlen+len); break; case V_ASN1_BIT_STRING: value = decode_bstr(start, hlen+len, &flag); break; case V_ASN1_NULL: value = decode_null(start, hlen+len); break; case V_ASN1_ENUMERATED: value = decode_enum(start, hlen+len); break; case V_ASN1_OBJECT: value = decode_obj(start, hlen+len); break; case V_ASN1_UTCTIME: /* FALLTHROUGH */ case V_ASN1_GENERALIZEDTIME: value = decode_time(start, hlen+len); break; default: /* use original value */ break; } } asn1data = rb_funcall(klass, rb_intern("new"), 1, value); if(tag == V_ASN1_BIT_STRING){ rb_iv_set(asn1data, "@unused_bits", LONG2NUM(flag)); } } else{ asn1data = rb_funcall(cASN1Data, rb_intern("new"), 3, value, INT2NUM(tag), ID2SYM(tag_class)); } rb_ary_push(ary, asn1data); length -= len; if(once) break; } *pp = p; *offset = off; return ary; }
/* * It gets a value of variable size column value for the record that * ID is _id_. * * @example Gets weight vector value * Groonga::Schema.define do |schema| * schema.create_table("Products", * :type => :patricia_trie, * :key_type => "ShortText") do |table| * # This is weight vector. * # ":with_weight => true" is important to store weight value. * table.short_text("tags", * :type => :vector, * :with_weight => true) * end * end * * products = Groonga["Products"] * rroonga = products.add("Rroonga") * rroonga.tags = [ * { * :value => "ruby", * :weight => 100, * }, * { * :value => "groonga", * :weight => 10, * }, * ] * * p rroonga.tags * # => [ * # {:value => "ruby", :weight => 100}, * # {:value => "groonga", :weight => 10} * # ] * * @overload [](id) * @param [Integer, Record] id The record ID. * @return [Array<Hash<Symbol, String>>] An array of value if the column * is a weight vector column. * Each value is a Hash like the following form: * * <pre> * { * :value => [KEY], * :weight => [WEIGHT], * } * </pre> * * @[KEY]@ is the key of the table that is specified as range on * creating the weight vector. * * @[WEIGHT]@ is a positive integer. * * @return [::Object] See {Groonga::Object#[]} for columns except * weight vector column. * * @since 4.0.1. */ static VALUE rb_grn_variable_size_column_array_reference (VALUE self, VALUE rb_id) { grn_ctx *context = NULL; grn_obj *column, *range; grn_id id; grn_obj *value; VALUE rb_value; VALUE rb_range; unsigned int i, n; rb_grn_variable_size_column_deconstruct(SELF(self), &column, &context, NULL, NULL, &value, NULL, NULL, &range); if (!(column->header.flags & GRN_OBJ_WITH_WEIGHT)) { return rb_call_super(1, &rb_id); } id = RVAL2GRNID(rb_id, context, range, self); grn_obj_reinit(context, value, value->header.domain, value->header.flags | GRN_OBJ_VECTOR); grn_obj_get_value(context, column, id, value); rb_grn_context_check(context, self); rb_range = GRNTABLE2RVAL(context, range, GRN_FALSE); n = grn_vector_size(context, value); rb_value = rb_ary_new2(n); for (i = 0; i < n; i++) { VALUE rb_element_value; unsigned int weight = 0; grn_id domain; VALUE rb_element; if (value->header.type == GRN_UVECTOR) { grn_id id; id = grn_uvector_get_element(context, value, i, &weight); rb_element_value = rb_grn_record_new(rb_range, id, Qnil); } else { const char *element_value; unsigned int element_value_length; element_value_length = grn_vector_get_element(context, value, i, &element_value, &weight, &domain); rb_element_value = rb_str_new(element_value, element_value_length); } rb_element = rb_hash_new(); rb_hash_aset(rb_element, ID2SYM(rb_intern("value")), rb_element_value); rb_hash_aset(rb_element, ID2SYM(rb_intern("weight")), UINT2NUM(weight)); rb_ary_push(rb_value, rb_element); } return rb_value; }
/* Method: ImageList#to_blob Purpose: returns the imagelist as a blob (a String) Notes: runs an info parm block if present - the user can specify the image format and depth */ VALUE ImageList_to_blob(VALUE self) { Image *images, *image; Info *info; volatile VALUE info_obj; volatile VALUE blob_str; void *blob = NULL; size_t length = 0; ExceptionInfo exception; info_obj = rm_info_new(); Data_Get_Struct(info_obj, Info, info); // Convert the images array to an images sequence. images = images_from_imagelist(self); GetExceptionInfo(&exception); (void) SetImageInfo(info, MagickTrue, &exception); rm_check_exception(&exception, images, RetainOnError); if (*info->magick != '\0') { Image *img; for (img = images; img; img = GetNextImageInList(img)) { strncpy(img->magick, info->magick, sizeof(info->magick)-1); } } for (image = images; image; image = GetNextImageInList(image)) { rm_sync_image_options(image, info); } // Unconditionally request multi-images support. The worst that // can happen is that there's only one image or the format // doesn't support multi-image files. info->adjoin = MagickTrue; blob = ImagesToBlob(info, images, &length, &exception); if (blob && exception.severity >= ErrorException) { magick_free((void*)blob); blob = NULL; length = 0; } rm_split(images); CHECK_EXCEPTION() (void) DestroyExceptionInfo(&exception); if (length == 0 || !blob) { return Qnil; } blob_str = rb_str_new(blob, (long)length); magick_free((void*)blob); return blob_str; }
static VALUE fcgi_s_accept(VALUE self) { int status; FCGX_Request *req; rb_fdset_t readfds; req = ALLOC(FCGX_Request); status = FCGX_InitRequest(req,0,0); if (status != 0) { rb_raise(eFCGIError, "FCGX_Init() failed"); return Qnil; } rb_fd_init(&readfds); rb_fd_set(req->listen_sock, &readfds); if (rb_thread_fd_select(readfds.maxfd, &readfds, NULL, NULL, NULL) < 1) { return Qnil; } status = FCGX_Accept_r(req); if (status >= 0) { fcgi_data *data; fcgi_stream_data *stream_data; char **env; VALUE obj,key, value; char *pkey,*pvalue; int flags, fd; /* Unset NONBLOCKING */ fd = ((FCGX_Request*) req)->ipcFd; flags = fcntl(fd, F_GETFL); if (flags & O_NONBLOCK) { fcntl(fd, F_SETFL, flags & ~O_NONBLOCK); } obj = Data_Make_Struct(self, fcgi_data, fcgi_mark, fcgi_free_req, data); data->req = req; data->in = Data_Make_Struct(cFCGIStream, fcgi_stream_data, fcgi_stream_mark, fcgi_stream_free, stream_data); stream_data->stream = req->in; stream_data->req = obj; data->out = Data_Make_Struct(cFCGIStream, fcgi_stream_data, fcgi_stream_mark, fcgi_stream_free, stream_data); stream_data->stream = req->out; stream_data->req = obj; data->err = Data_Make_Struct(cFCGIStream, fcgi_stream_data, fcgi_stream_mark, fcgi_stream_free, stream_data); stream_data->stream = req->err; stream_data->req = obj; data->env = rb_hash_new(); env = req->envp; for (; *env; env++) { int size = 0; pkey = *env; pvalue = pkey; while( *(pvalue++) != '=') size++; key = rb_str_new(pkey, size); value = rb_str_new2(pvalue); OBJ_TAINT(key); OBJ_TAINT(value); rb_hash_aset(data->env, key, value); } return obj; } else { FCGX_Free(req, 1); free(req); return Qnil; } }
static int _parse_http_request(char *buf, ssize_t buf_len, VALUE env) { const char* method; size_t method_len; const char* path; size_t path_len; int minor_version; struct phr_header headers[MAX_HEADERS]; size_t num_headers, question_at; size_t i; int ret; char tmp[MAX_HEADER_NAME_LEN + sizeof("HTTP_") - 1]; VALUE last_value; num_headers = MAX_HEADERS; ret = phr_parse_request(buf, buf_len, &method, &method_len, &path, &path_len, &minor_version, headers, &num_headers, 0); if (ret < 0) goto done; rb_hash_aset(env, request_method_key, rb_str_new(method,method_len)); rb_hash_aset(env, request_uri_key, rb_str_new(path, path_len)); rb_hash_aset(env, script_name_key, rb_str_new2("")); strcpy(tmp, "HTTP/1."); tmp[7] = 48 + ((minor_version > 1 || minor_version < 0 ) ? 0 : minor_version); rb_hash_aset(env, server_protocol_key, rb_str_new(tmp, sizeof("HTTP/1.0") - 1)); /* PATH_INFO QUERY_STRING */ path_len = find_ch(path, path_len, '#'); /* strip off all text after # after storing request_uri */ question_at = find_ch(path, path_len, '?'); if ( store_path_info(env, path, question_at) < 0 ) { rb_hash_clear(env); ret = -1; goto done; } if (question_at != path_len) ++question_at; rb_hash_aset(env, query_string_key, rb_str_new(path + question_at, path_len - question_at)); last_value = Qnil; for (i = 0; i < num_headers; ++i) { if (headers[i].name != NULL) { const char* name; size_t name_len; VALUE slot; VALUE env_key; env_key = find_common_header(headers + i); if ( env_key == Qnil ) { const char* s; char* d; size_t n; if (sizeof(tmp) - 5 < headers[i].name_len) { rb_hash_clear(env); ret = -1; goto done; } strcpy(tmp, "HTTP_"); for (s = headers[i].name, n = headers[i].name_len, d = tmp + 5; n != 0; s++, --n, d++) { *d = *s == '-' ? '_' : TOU(*s); name = tmp; name_len = headers[i].name_len + 5; env_key = rb_str_new(name, name_len); } } slot = rb_hash_aref(env, env_key); if ( slot != Qnil ) { rb_str_cat2(slot, ", "); rb_str_cat(slot, headers[i].value, headers[i].value_len); } else { slot = rb_str_new(headers[i].value, headers[i].value_len); rb_hash_aset(env, env_key, slot); last_value = slot; } } else { /* continuing lines of a mulitiline header */ if ( last_value != Qnil ) rb_str_cat(last_value, headers[i].value, headers[i].value_len); } } done: return ret; }
VALUE TCPClient::tcp_recv(int max_buffer) { RAGE_CHECK_DISPOSED_RET(disposed, Qnil); char *buffer = nullptr; VALUE ret_str; int result = 0; if (max_buffer == 0) { buffer = new char[RAGE_CLIENT_TCP_MAX_BUFFER]; char *data = nullptr; size_t max_len = 0, i, pos = 0; do { memset(buffer, 0, RAGE_CLIENT_TCP_MAX_BUFFER); result = recv(sock, buffer, RAGE_CLIENT_TCP_MAX_BUFFER, 0); if (result > 0) { data = (char*)al_realloc(data, max_len + result); for (i = 0; i < result; i++) data[pos++] = buffer[i]; max_len += result; } else if (result == 0) { disconnect(); } } while(result > 0); ret_str = rb_str_new(data, max_len); if (data != nullptr) al_free(data); } else { buffer = new char[max_buffer]; memset(buffer, 0, max_buffer); result = recv(sock, buffer, max_buffer, 0); if (result > 0) { ret_str = rb_str_new(buffer, result); } else ret_str = Qnil; } return ret_str; }
static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezone, int symbolizeKeys, int asArray, int castBool, int cast, MYSQL_FIELD * fields) { VALUE rowVal; mysql2_result_wrapper * wrapper; MYSQL_ROW row; unsigned int i = 0; unsigned long * fieldLengths; void * ptr; #ifdef HAVE_RUBY_ENCODING_H rb_encoding *default_internal_enc; rb_encoding *conn_enc; #endif GetMysql2Result(self, wrapper); #ifdef HAVE_RUBY_ENCODING_H default_internal_enc = rb_default_internal_encoding(); conn_enc = rb_to_encoding(wrapper->encoding); #endif ptr = wrapper->result; row = (MYSQL_ROW)rb_thread_blocking_region(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0); if (row == NULL) { return Qnil; } if (asArray) { rowVal = rb_ary_new2(wrapper->numberOfFields); } else { rowVal = rb_hash_new(); } fieldLengths = mysql_fetch_lengths(wrapper->result); if (wrapper->fields == Qnil) { wrapper->numberOfFields = mysql_num_fields(wrapper->result); wrapper->fields = rb_ary_new2(wrapper->numberOfFields); } for (i = 0; i < wrapper->numberOfFields; i++) { VALUE field = rb_mysql_result_fetch_field(self, i, symbolizeKeys); if (row[i]) { VALUE val = Qnil; enum enum_field_types type = fields[i].type; if(!cast) { if (type == MYSQL_TYPE_NULL) { val = Qnil; } else { val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif } } else { switch(type) { case MYSQL_TYPE_NULL: // NULL-type field val = Qnil; break; case MYSQL_TYPE_BIT: // BIT field (MySQL 5.0.3 and up) val = rb_str_new(row[i], fieldLengths[i]); break; case MYSQL_TYPE_TINY: // TINYINT field if (castBool && fields[i].length == 1) { val = *row[i] == '1' ? Qtrue : Qfalse; break; } case MYSQL_TYPE_SHORT: // SMALLINT field case MYSQL_TYPE_LONG: // INTEGER field case MYSQL_TYPE_INT24: // MEDIUMINT field case MYSQL_TYPE_LONGLONG: // BIGINT field case MYSQL_TYPE_YEAR: // YEAR field val = rb_cstr2inum(row[i], 10); break; case MYSQL_TYPE_DECIMAL: // DECIMAL or NUMERIC field case MYSQL_TYPE_NEWDECIMAL: // Precision math DECIMAL or NUMERIC field (MySQL 5.0.3 and up) if (fields[i].decimals == 0) { val = rb_cstr2inum(row[i], 10); } else if (strtod(row[i], NULL) == 0.000000){ val = rb_funcall(cBigDecimal, intern_new, 1, opt_decimal_zero); }else{ val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(row[i], fieldLengths[i])); } break; case MYSQL_TYPE_FLOAT: // FLOAT field case MYSQL_TYPE_DOUBLE: { // DOUBLE or REAL field double column_to_double; column_to_double = strtod(row[i], NULL); if (column_to_double == 0.000000){ val = opt_float_zero; }else{ val = rb_float_new(column_to_double); } break; } case MYSQL_TYPE_TIME: { // TIME field int hour, min, sec, tokens; tokens = sscanf(row[i], "%2d:%2d:%2d", &hour, &min, &sec); val = rb_funcall(rb_cTime, db_timezone, 6, opt_time_year, opt_time_month, opt_time_month, INT2NUM(hour), INT2NUM(min), INT2NUM(sec)); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { // utc val = rb_funcall(val, intern_utc, 0); } } break; } case MYSQL_TYPE_TIMESTAMP: // TIMESTAMP field case MYSQL_TYPE_DATETIME: { // DATETIME field unsigned int year, month, day, hour, min, sec, tokens; uint64_t seconds; tokens = sscanf(row[i], "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec); seconds = (year*31557600ULL) + (month*2592000ULL) + (day*86400ULL) + (hour*3600ULL) + (min*60ULL) + sec; if (seconds == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date: %s", row[i]); val = Qnil; } else { if (seconds < MYSQL2_MIN_TIME || seconds >= MYSQL2_MAX_TIME) { // use DateTime instead VALUE offset = INT2NUM(0); if (db_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); } val = rb_funcall(cDateTime, intern_civil, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), offset); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); val = rb_funcall(val, intern_new_offset, 1, offset); } else { // utc val = rb_funcall(val, intern_new_offset, 1, opt_utc_offset); } } } else { val = rb_funcall(rb_cTime, db_timezone, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec)); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { // utc val = rb_funcall(val, intern_utc, 0); } } } } } break; } case MYSQL_TYPE_DATE: // DATE field case MYSQL_TYPE_NEWDATE: { // Newer const used > 5.0 int year, month, day, tokens; tokens = sscanf(row[i], "%4d-%2d-%2d", &year, &month, &day); if (year+month+day == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date: %s", row[i]); val = Qnil; } else { val = rb_funcall(cDate, intern_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day)); } } break; } case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_BLOB: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_STRING: // CHAR or BINARY field case MYSQL_TYPE_SET: // SET field case MYSQL_TYPE_ENUM: // ENUM field case MYSQL_TYPE_GEOMETRY: // Spatial fielda default: val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif break; } } if (asArray) { rb_ary_push(rowVal, val); } else { rb_hash_aset(rowVal, field, val); } } else { if (asArray) { rb_ary_push(rowVal, Qnil); } else { rb_hash_aset(rowVal, field, Qnil); } } } return rowVal; }
static inline void event_callback (struct em_event* e) { const unsigned long signature = e->signature; int event = e->event; const char *data_str = e->data_str; const unsigned long data_num = e->data_num; switch (event) { case EM_CONNECTION_READ: { VALUE conn = rb_hash_aref (EmConnsHash, ULONG2NUM (signature)); if (conn == Qnil) rb_raise (EM_eConnectionNotBound, "received %lu bytes of data for unknown signature: %lu", data_num, signature); rb_funcall (conn, Intern_receive_data, 1, rb_str_new (data_str, data_num)); return; } case EM_CONNECTION_ACCEPTED: case EM_CONNECTION_UNBOUND: { rb_funcall (EmModule, Intern_event_callback, 3, ULONG2NUM(signature), INT2FIX(event), data_str ? rb_str_new(data_str,data_num) : ULONG2NUM(data_num)); return; } case EM_CONNECTION_COMPLETED: { VALUE conn = ensure_conn(signature); rb_funcall (conn, Intern_connection_completed, 0); return; } case EM_CONNECTION_NOTIFY_READABLE: { VALUE conn = ensure_conn(signature); rb_funcall (conn, Intern_notify_readable, 0); return; } case EM_CONNECTION_NOTIFY_WRITABLE: { VALUE conn = ensure_conn(signature); rb_funcall (conn, Intern_notify_readable, 0); return; } case EM_LOOPBREAK_SIGNAL: { rb_funcall (EmModule, Intern_run_deferred_callbacks, 0); return; } case EM_TIMER_FIRED: { VALUE timer = rb_funcall (EmTimersHash, Intern_delete, 1, ULONG2NUM (data_num)); if (timer == Qnil) { rb_raise (EM_eUnknownTimerFired, "no such timer: %lu", data_num); } else if (timer == Qfalse) { /* Timer Canceled */ } else { rb_funcall (timer, Intern_call, 0); } return; } #ifdef WITH_SSL case EM_SSL_HANDSHAKE_COMPLETED: { VALUE conn = ensure_conn(signature); rb_funcall (conn, Intern_ssl_handshake_completed, 0); return; } case EM_SSL_VERIFY: { VALUE conn = ensure_conn(signature); VALUE should_accept = rb_funcall (conn, Intern_ssl_verify_peer, 1, rb_str_new(data_str, data_num)); if (RTEST(should_accept)) evma_accept_ssl_peer (signature); return; } #endif case EM_PROXY_TARGET_UNBOUND: { VALUE conn = ensure_conn(signature); rb_funcall (conn, Intern_proxy_target_unbound, 0); return; } } }