// write_raw_image(filename_or_blob, partition) Value* WriteRawImageFn(const char* name, State* state, int argc, Expr* argv[]) { char* result = NULL; Value* partition_value; Value* contents; if (ReadValueArgs(state, argv, 2, &contents, &partition_value) < 0) { return NULL; } if (partition_value->type != VAL_STRING) { ErrorAbort(state, "partition argument to %s must be string", name); goto done; } char* partition = partition_value->data; if (strlen(partition) == 0) { ErrorAbort(state, "partition argument to %s can't be empty", name); goto done; } if (contents->type == VAL_STRING && strlen((char*) contents->data) == 0) { ErrorAbort(state, "file argument to %s can't be empty", name); goto done; } char* filename = contents->data; if (0 == restore_raw_partition(NULL, partition, filename)) result = strdup(partition); else { result = strdup(""); goto done; } done: if (result != partition) FreeValue(partition_value); FreeValue(contents); return StringValue(result); }
/* * Return a pathname which the extension of the basename is substituted by * <i>repl</i>. * * If self has no extension part, <i>repl</i> is appended. */ static VALUE path_sub_ext(VALUE self, VALUE repl) { VALUE str = get_strpath(self); VALUE str2; long extlen; const char *ext; const char *p; StringValue(repl); p = RSTRING_PTR(str); extlen = RSTRING_LEN(str); ext = ruby_enc_find_extname(p, &extlen, rb_enc_get(str)); if (ext == NULL) { ext = p + RSTRING_LEN(str); } else if (extlen <= 1) { ext += extlen; } str2 = rb_str_subseq(str, 0, ext-p); rb_str_append(str2, repl); OBJ_INFECT(str2, str); return rb_class_new_instance(1, &str2, rb_obj_class(self)); }
static VALUE rb_trie_node_walk_bang(VALUE self, VALUE rchar) { StringValue(rchar); TrieState *state; long string_length ; TrieChar *char_prefix ; long p; Bool result; Data_Get_Struct(self, TrieState, state); string_length = (long)NUM2LONG(rb_funcall(rchar, rb_intern("length"), 0)); if (string_length == 1) { char_prefix = (TrieChar*)RSTRING_PTR(rchar); for (p = 0; p < RSTRING_LEN(rchar); p++) { result = trie_state_walk(state, *char_prefix); if (!result) return Qnil; char_prefix++; } return self; } else return Qnil; }
Value* AssertFn(const char* name, State* state, int argc, Expr* argv[]) { int i; for (i = 0; i < argc; ++i) { char* v = Evaluate(state, argv[i]); if (v == NULL) { return NULL; } int b = BooleanString(v); free(v); if (!b) { int prefix_len; int len = argv[i]->end - argv[i]->start; char* err_src = malloc(len + 20); strcpy(err_src, "assert failed: "); prefix_len = strlen(err_src); memcpy(err_src + prefix_len, state->script + argv[i]->start, len); err_src[prefix_len + len] = '\0'; free(state->errmsg); state->errmsg = err_src; return NULL; } } return StringValue(strdup("")); }
VALUE mc_decr(int argc, VALUE *argv, VALUE self) { memcached_st *mc; VALUE key, amount; static memcached_return_t result; unsigned int offset; uint64_t value; Data_Get_Struct(self, memcached_st, mc); rb_scan_args(argc, argv, "11", &key, &amount); key = StringValue(key); if (!use_binary(mc)) key = escape_key(key, NULL); offset = RTEST(amount) ? NUM2INT(amount) : 1; result = memcached_decrement(mc, RSTRING_PTR(key), RSTRING_LEN(key), offset, &value); if (result == MEMCACHED_SUCCESS) { return LONG2NUM(value); } else if (result == MEMCACHED_NOTFOUND) { return Qnil; } else { return throw_error(&result); } }
void read_data_fn(png_structp png_ptr, png_bytep data, png_size_t length) { VALUE io, str; size_t read_len; if (png_ptr == NULL) return; io = (VALUE)png_get_io_ptr(png_ptr); str = rb_funcall(io, id_read, 1, INT2FIX(length)); if (NIL_P(str)) rb_raise(rb_eRuntimeError, "Read Error. Reader returned nil."); StringValue(str); read_len = RSTRING_LEN(str); if (read_len != length) rb_raise(rb_eRuntimeError, "Read Error. Read %d instead of %d bytes.", (int)read_len, (int)length); memcpy(data, RSTRING_PTR(str), length); }
VALUE CommandTMatcher_sorted_matches_for(int argc, VALUE *argv, VALUE self) { // process arguments: 1 mandatory, 1 optional VALUE abbrev, options; if (rb_scan_args(argc, argv, "11", &abbrev, &options) == 1) options = Qnil; if (NIL_P(abbrev)) rb_raise(rb_eArgError, "nil abbrev"); abbrev = StringValue(abbrev); abbrev = rb_funcall(abbrev, rb_intern("downcase"), 0); // check optional options has for overrides VALUE limit_option = CommandT_option_from_hash("limit", options); // get unsorted matches VALUE scanner = rb_iv_get(self, "@scanner"); VALUE paths = rb_funcall(scanner, rb_intern("paths"), 0); VALUE always_show_dot_files = rb_iv_get(self, "@always_show_dot_files"); VALUE never_show_dot_files = rb_iv_get(self, "@never_show_dot_files"); long path_count = RARRAY_LEN(paths); match_t *matches = malloc(path_count * sizeof(match_t)); if (!matches) rb_raise(rb_eNoMemError, "memory allocation failed"); int err; int thread_count = 1; #ifdef HAVE_PTHREAD_H #define THREAD_THRESHOLD 1000 /* avoid the overhead of threading when search space is small */ if (path_count < THREAD_THRESHOLD) thread_count = 1; else thread_count = PROCESSOR_COUNT; // passed in as preprocessor macro pthread_t *threads = malloc(sizeof(pthread_t) * thread_count); if (!threads) rb_raise(rb_eNoMemError, "memory allocation failed"); #endif thread_args_t *thread_args = malloc(sizeof(thread_args_t) * thread_count); if (!thread_args) rb_raise(rb_eNoMemError, "memory allocation failed"); for (int i = 0; i < thread_count; i++) { thread_args[i].thread_count = thread_count; thread_args[i].thread_index = i; thread_args[i].matches = matches; thread_args[i].path_count = path_count; thread_args[i].paths = paths; thread_args[i].abbrev = abbrev; thread_args[i].always_show_dot_files = always_show_dot_files; thread_args[i].never_show_dot_files = never_show_dot_files; #ifdef HAVE_PTHREAD_H if (i == thread_count - 1) { #endif // for the last "worker", we'll just use the main thread (void)match_thread(&thread_args[i]); #ifdef HAVE_PTHREAD_H } else { err = pthread_create(&threads[i], NULL, match_thread, (void *)&thread_args[i]); if (err != 0) rb_raise(rb_eSystemCallError, "pthread_create() failure (%d)", err); } #endif } #ifdef HAVE_PTHREAD_H for (int i = 0; i < thread_count - 1; i++) { err = pthread_join(threads[i], NULL); if (err != 0) rb_raise(rb_eSystemCallError, "pthread_join() failure (%d)", err); } free(threads); #endif if (RSTRING_LEN(abbrev) == 0 || (RSTRING_LEN(abbrev) == 1 && RSTRING_PTR(abbrev)[0] == '.')) // alphabetic order if search string is only "" or "." qsort(matches, path_count, sizeof(match_t), cmp_alpha); else // for all other non-empty search strings, sort by score qsort(matches, path_count, sizeof(match_t), cmp_score); VALUE results = rb_ary_new(); long limit = NIL_P(limit_option) ? 0 : NUM2LONG(limit_option); if (limit == 0) limit = path_count; for (long i = 0; i < path_count && limit > 0; i++) { if (matches[i].score > 0.0) { rb_funcall(results, rb_intern("push"), 1, matches[i].path); limit--; } } free(matches); return results; }
static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) { bson_buffer_t buffer = (bson_buffer_t)NUM2LL(rb_ary_entry(extra, 0)); VALUE check_keys = rb_ary_entry(extra, 1); if (TYPE(key) == T_SYMBOL) { // TODO better way to do this... ? key = rb_str_new2(rb_id2name(SYM2ID(key))); } if (TYPE(key) != T_STRING) { bson_buffer_free(buffer); rb_raise(rb_eTypeError, "keys must be strings or symbols"); } if (allow_id == 0 && strcmp("_id", RSTRING_PTR(key)) == 0) { return ST_CONTINUE; } if (check_keys == Qtrue) { int i; if (RSTRING_LEN(key) > 0 && RSTRING_PTR(key)[0] == '$') { bson_buffer_free(buffer); rb_raise(InvalidKeyName, "key %s must not start with '$'", RSTRING_PTR(key)); } for (i = 0; i < RSTRING_LEN(key); i++) { if (RSTRING_PTR(key)[i] == '.') { bson_buffer_free(buffer); rb_raise(InvalidKeyName, "key %s must not contain '.'", RSTRING_PTR(key)); } } } switch(TYPE(value)) { case T_BIGNUM: { if (rb_funcall(value, gt_operator, 1, LL2NUM(9223372036854775807LL)) == Qtrue || rb_funcall(value, lt_operator, 1, LL2NUM(-9223372036854775808ULL)) == Qtrue) { bson_buffer_free(buffer); rb_raise(rb_eRangeError, "MongoDB can only handle 8-byte ints"); } } // NOTE: falls through to T_FIXNUM code case T_FIXNUM: { long long ll_value; ll_value = NUM2LL(value); if (ll_value > 2147483647LL || ll_value < -2147483648LL) { write_name_and_type(buffer, key, 0x12); SAFE_WRITE(buffer, (char*)&ll_value, 8); } else { int int_value; write_name_and_type(buffer, key, 0x10); int_value = (int)ll_value; SAFE_WRITE(buffer, (char*)&int_value, 4); } break; } case T_TRUE: { write_name_and_type(buffer, key, 0x08); SAFE_WRITE(buffer, &one, 1); break; } case T_FALSE: { write_name_and_type(buffer, key, 0x08); SAFE_WRITE(buffer, &zero, 1); break; } case T_FLOAT: { double d = NUM2DBL(value); write_name_and_type(buffer, key, 0x01); SAFE_WRITE(buffer, (char*)&d, 8); break; } case T_NIL: { write_name_and_type(buffer, key, 0x0A); break; } case T_HASH: { write_name_and_type(buffer, key, 0x03); write_doc(buffer, value, check_keys, Qfalse); break; } case T_ARRAY: { bson_buffer_position length_location, start_position, obj_length; int items, i; write_name_and_type(buffer, key, 0x04); start_position = bson_buffer_get_position(buffer); // save space for length length_location = bson_buffer_save_space(buffer, 4); if (length_location == -1) { rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c"); } items = RARRAY_LENINT(value); for(i = 0; i < items; i++) { char* name; VALUE key; INT2STRING(&name, i); key = rb_str_new2(name); write_element_with_id(key, rb_ary_entry(value, i), pack_extra(buffer, check_keys)); FREE_INTSTRING(name); } // write null byte and fill in length SAFE_WRITE(buffer, &zero, 1); obj_length = bson_buffer_get_position(buffer) - start_position; SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&obj_length, 4); break; } case T_STRING: { int length; write_name_and_type(buffer, key, 0x02); length = RSTRING_LENINT(value) + 1; SAFE_WRITE(buffer, (char*)&length, 4); write_utf8(buffer, value, 0); SAFE_WRITE(buffer, &zero, 1); break; } case T_SYMBOL: { const char* str_value = rb_id2name(SYM2ID(value)); int length = (int)strlen(str_value) + 1; write_name_and_type(buffer, key, 0x0E); SAFE_WRITE(buffer, (char*)&length, 4); SAFE_WRITE(buffer, str_value, length); break; } case T_OBJECT: { // TODO there has to be a better way to do these checks... const char* cls = rb_obj_classname(value); if (strcmp(cls, "BSON::Binary") == 0 || strcmp(cls, "ByteBuffer") == 0) { const char subtype = strcmp(cls, "ByteBuffer") ? (const char)FIX2INT(rb_funcall(value, rb_intern("subtype"), 0)) : 2; VALUE string_data = rb_funcall(value, rb_intern("to_s"), 0); int length = RSTRING_LENINT(string_data); write_name_and_type(buffer, key, 0x05); if (subtype == 2) { const int other_length = length + 4; SAFE_WRITE(buffer, (const char*)&other_length, 4); SAFE_WRITE(buffer, &subtype, 1); } SAFE_WRITE(buffer, (const char*)&length, 4); if (subtype != 2) { SAFE_WRITE(buffer, &subtype, 1); } SAFE_WRITE(buffer, RSTRING_PTR(string_data), length); break; } if (strcmp(cls, "BSON::ObjectId") == 0) { VALUE as_array = rb_funcall(value, rb_intern("to_a"), 0); int i; write_name_and_type(buffer, key, 0x07); for (i = 0; i < 12; i++) { char byte = (char)FIX2INT(rb_ary_entry(as_array, i)); SAFE_WRITE(buffer, &byte, 1); } break; } if (strcmp(cls, "BSON::DBRef") == 0) { bson_buffer_position length_location, start_position, obj_length; VALUE ns, oid; write_name_and_type(buffer, key, 0x03); start_position = bson_buffer_get_position(buffer); // save space for length length_location = bson_buffer_save_space(buffer, 4); if (length_location == -1) { rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c"); } ns = rb_funcall(value, rb_intern("namespace"), 0); write_element_with_id(rb_str_new2("$ref"), ns, pack_extra(buffer, Qfalse)); oid = rb_funcall(value, rb_intern("object_id"), 0); write_element_with_id(rb_str_new2("$id"), oid, pack_extra(buffer, Qfalse)); // write null byte and fill in length SAFE_WRITE(buffer, &zero, 1); obj_length = bson_buffer_get_position(buffer) - start_position; SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&obj_length, 4); break; } if (strcmp(cls, "BSON::Code") == 0) { bson_buffer_position length_location, start_position, total_length; int length; VALUE code_str; write_name_and_type(buffer, key, 0x0F); start_position = bson_buffer_get_position(buffer); length_location = bson_buffer_save_space(buffer, 4); if (length_location == -1) { rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c"); } code_str = rb_funcall(value, rb_intern("code"), 0); length = RSTRING_LENINT(code_str) + 1; SAFE_WRITE(buffer, (char*)&length, 4); SAFE_WRITE(buffer, RSTRING_PTR(code_str), length - 1); SAFE_WRITE(buffer, &zero, 1); write_doc(buffer, rb_funcall(value, rb_intern("scope"), 0), Qfalse, Qfalse); total_length = bson_buffer_get_position(buffer) - start_position; SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&total_length, 4); break; } if (strcmp(cls, "BSON::MaxKey") == 0) { write_name_and_type(buffer, key, 0x7f); break; } if (strcmp(cls, "BSON::MinKey") == 0) { write_name_and_type(buffer, key, 0xff); break; } if (strcmp(cls, "BSON::Timestamp") == 0) { unsigned int seconds; unsigned int increment; write_name_and_type(buffer, key, 0x11); seconds = NUM2UINT( rb_funcall(value, rb_intern("seconds"), 0)); increment = NUM2UINT( rb_funcall(value, rb_intern("increment"), 0)); SAFE_WRITE(buffer, (const char*)&increment, 4); SAFE_WRITE(buffer, (const char*)&seconds, 4); break; } if (strcmp(cls, "DateTime") == 0 || strcmp(cls, "Date") == 0 || strcmp(cls, "ActiveSupport::TimeWithZone") == 0) { bson_buffer_free(buffer); rb_raise(InvalidDocument, "%s is not currently supported; use a UTC Time instance instead.", cls); break; } if(strcmp(cls, "Complex") == 0 || strcmp(cls, "Rational") == 0 || strcmp(cls, "BigDecimal") == 0) { bson_buffer_free(buffer); rb_raise(InvalidDocument, "Cannot serialize the Numeric type %s as BSON; only Bignum, Fixnum, and Float are supported.", cls); break; } if (strcmp(cls, "ActiveSupport::Multibyte::Chars") == 0) { int length; VALUE str = StringValue(value); write_name_and_type(buffer, key, 0x02); length = RSTRING_LENINT(str) + 1; SAFE_WRITE(buffer, (char*)&length, 4); write_utf8(buffer, str, 0); SAFE_WRITE(buffer, &zero, 1); break; } bson_buffer_free(buffer); rb_raise(InvalidDocument, "Cannot serialize an object of class %s into BSON.", cls); break; } case T_DATA: { const char* cls = rb_obj_classname(value); if (strcmp(cls, "Time") == 0) { double t = NUM2DBL(rb_funcall(value, rb_intern("to_f"), 0)); long long time_since_epoch = (long long)round(t * 1000); write_name_and_type(buffer, key, 0x09); SAFE_WRITE(buffer, (const char*)&time_since_epoch, 8); break; } // Date classes are TYPE T_DATA in Ruby >= 1.9.3 if (strcmp(cls, "DateTime") == 0 || strcmp(cls, "Date") == 0 || strcmp(cls, "ActiveSupport::TimeWithZone") == 0) { bson_buffer_free(buffer); rb_raise(InvalidDocument, "%s is not currently supported; use a UTC Time instance instead.", cls); break; } if(strcmp(cls, "BigDecimal") == 0) { bson_buffer_free(buffer); rb_raise(InvalidDocument, "Cannot serialize the Numeric type %s as BSON; only Bignum, Fixnum, and Float are supported.", cls); break; } bson_buffer_free(buffer); rb_raise(InvalidDocument, "Cannot serialize an object of class %s into BSON.", cls); break; } case T_REGEXP: { VALUE pattern = RREGEXP_SRC(value); long flags = RREGEXP_OPTIONS(value); VALUE has_extra; write_name_and_type(buffer, key, 0x0B); write_utf8(buffer, pattern, 1); SAFE_WRITE(buffer, &zero, 1); if (flags & IGNORECASE) { char ignorecase = 'i'; SAFE_WRITE(buffer, &ignorecase, 1); } if (flags & MULTILINE) { char multiline = 'm'; char dotall = 's'; SAFE_WRITE(buffer, &multiline, 1); SAFE_WRITE(buffer, &dotall, 1); } if (flags & EXTENDED) { char extended = 'x'; SAFE_WRITE(buffer, &extended, 1); } has_extra = rb_funcall(value, rb_intern("respond_to?"), 1, rb_str_new2("extra_options_str")); if (TYPE(has_extra) == T_TRUE) { VALUE extra = rb_funcall(value, rb_intern("extra_options_str"), 0); bson_buffer_position old_position = bson_buffer_get_position(buffer); SAFE_WRITE(buffer, RSTRING_PTR(extra), RSTRING_LENINT(extra)); qsort(bson_buffer_get_buffer(buffer) + old_position, RSTRING_LEN(extra), sizeof(char), cmp_char); } SAFE_WRITE(buffer, &zero, 1); break; } default: { const char* cls = rb_obj_classname(value); bson_buffer_free(buffer); rb_raise(InvalidDocument, "Cannot serialize an object of class %s (type %d) into BSON.", cls, TYPE(value)); break; } } return ST_CONTINUE; }
// apply_patch(srcfile, tgtfile, tgtsha1, tgtsize, sha1_1, patch_1, ...) Value* ApplyPatchFn(const char* name, State* state, int argc, Expr* argv[]) { if (argc < 6 || (argc % 2) == 1) { return ErrorAbort(state, "%s(): expected at least 6 args and an " "even number, got %d", name, argc); } char* source_filename; char* target_filename; char* target_sha1; char* target_size_str; if (ReadArgs(state, argv, 4, &source_filename, &target_filename, &target_sha1, &target_size_str) < 0) { return NULL; } char* endptr; size_t target_size = strtol(target_size_str, &endptr, 10); if (target_size == 0 && endptr == target_size_str) { ErrorAbort(state, "%s(): can't parse \"%s\" as byte count", name, target_size_str); free(source_filename); free(target_filename); free(target_sha1); free(target_size_str); return NULL; } int patchcount = (argc-4) / 2; Value** patches = ReadValueVarArgs(state, argc-4, argv+4); int i; for (i = 0; i < patchcount; ++i) { if (patches[i*2]->type != VAL_STRING) { ErrorAbort(state, "%s(): sha-1 #%d is not string", name, i); break; } if (patches[i*2+1]->type != VAL_BLOB) { ErrorAbort(state, "%s(): patch #%d is not blob", name, i); break; } } if (i != patchcount) { for (i = 0; i < patchcount*2; ++i) { FreeValue(patches[i]); } free(patches); return NULL; } char** patch_sha_str = malloc(patchcount * sizeof(char*)); for (i = 0; i < patchcount; ++i) { patch_sha_str[i] = patches[i*2]->data; patches[i*2]->data = NULL; FreeValue(patches[i*2]); patches[i] = patches[i*2+1]; } int result = applypatch(source_filename, target_filename, target_sha1, target_size, patchcount, patch_sha_str, patches); for (i = 0; i < patchcount; ++i) { FreeValue(patches[i]); } free(patch_sha_str); free(patches); return StringValue(strdup(result == 0 ? "t" : "")); }
Value* SetPermFn(const char* name, State* state, int argc, Expr* argv[]) { char* result = NULL; bool recursive = (strcmp(name, "set_perm_recursive") == 0); int min_args = 4 + (recursive ? 1 : 0); if (argc < min_args) { return ErrorAbort(state, "%s() expects %d+ args, got %d", name, argc); } char** args = ReadVarArgs(state, argc, argv); if (args == NULL) return NULL; char* end; int i; int bad = 0; int uid = strtoul(args[0], &end, 0); if (*end != '\0' || args[0][0] == 0) { ErrorAbort(state, "%s: \"%s\" not a valid uid", name, args[0]); goto done; } int gid = strtoul(args[1], &end, 0); if (*end != '\0' || args[1][0] == 0) { ErrorAbort(state, "%s: \"%s\" not a valid gid", name, args[1]); goto done; } if (recursive) { int dir_mode = strtoul(args[2], &end, 0); if (*end != '\0' || args[2][0] == 0) { ErrorAbort(state, "%s: \"%s\" not a valid dirmode", name, args[2]); goto done; } int file_mode = strtoul(args[3], &end, 0); if (*end != '\0' || args[3][0] == 0) { ErrorAbort(state, "%s: \"%s\" not a valid filemode", name, args[3]); goto done; } for (i = 4; i < argc; ++i) { dirSetHierarchyPermissions(args[i], uid, gid, dir_mode, file_mode); } } else { int mode = strtoul(args[2], &end, 0); if (*end != '\0' || args[2][0] == 0) { ErrorAbort(state, "%s: \"%s\" not a valid mode", name, args[2]); goto done; } for (i = 3; i < argc; ++i) { if (chown(args[i], uid, gid) < 0) { fprintf(stderr, "%s: chown of %s to %d %d failed: %s\n", name, args[i], uid, gid, strerror(errno)); ++bad; } if (chmod(args[i], mode) < 0) { fprintf(stderr, "%s: chmod of %s to %o failed: %s\n", name, args[i], mode, strerror(errno)); ++bad; } } } result = strdup(""); done: for (i = 0; i < argc; ++i) { free(args[i]); } free(args); if (bad) { free(result); return ErrorAbort(state, "%s: some changes failed", name); } return StringValue(result); }
// package_extract_file(package_path, destination_path) // or // package_extract_file(package_path) // to return the entire contents of the file as the result of this // function (the char* returned is actually a FileContents*). Value* PackageExtractFileFn(const char* name, State* state, int argc, Expr* argv[]) { if (argc != 1 && argc != 2) { return ErrorAbort(state, "%s() expects 1 or 2 args, got %d", name, argc); } bool success = false; if (argc == 2) { // The two-argument version extracts to a file. char* zip_path; char* dest_path; if (ReadArgs(state, argv, 2, &zip_path, &dest_path) < 0) return NULL; ZipArchive* za = ((UpdaterInfo*)(state->cookie))->package_zip; const ZipEntry* entry = mzFindZipEntry(za, zip_path); if (entry == NULL) { fprintf(stderr, "%s: no %s in package\n", name, zip_path); goto done2; } FILE* f = fopen(dest_path, "wb"); if (f == NULL) { fprintf(stderr, "%s: can't open %s for write: %s\n", name, dest_path, strerror(errno)); goto done2; } success = mzExtractZipEntryToFile(za, entry, fileno(f)); fclose(f); done2: free(zip_path); free(dest_path); return StringValue(strdup(success ? "t" : "")); } else { // The one-argument version returns the contents of the file // as the result. char* zip_path; Value* v = malloc(sizeof(Value)); v->type = VAL_BLOB; v->size = -1; v->data = NULL; if (ReadArgs(state, argv, 1, &zip_path) < 0) return NULL; ZipArchive* za = ((UpdaterInfo*)(state->cookie))->package_zip; const ZipEntry* entry = mzFindZipEntry(za, zip_path); if (entry == NULL) { fprintf(stderr, "%s: no %s in package\n", name, zip_path); goto done1; } v->size = mzGetZipEntryUncompLen(entry); v->data = malloc(v->size); if (v->data == NULL) { fprintf(stderr, "%s: failed to allocate %ld bytes for %s\n", name, (long)v->size, zip_path); goto done1; } success = mzExtractZipEntryToBuffer(za, entry, (unsigned char *)v->data); done1: free(zip_path); if (!success) { free(v->data); v->data = NULL; v->size = -1; } return v; } }
int main(int argc, char* argv[]) { // setting default parameters for PointToPoint links and channels Config::SetDefault("ns3::PointToPointNetDevice::DataRate", StringValue("10Mbps")); Config::SetDefault("ns3::PointToPointChannel::Delay", StringValue("10ms")); Config::SetDefault("ns3::DropTailQueue::MaxPackets", StringValue("20")); // Read optional command-line parameters (e.g., enable visualizer with ./waf --run=<> --visualize CommandLine cmd; cmd.Parse(argc, argv); // Creating nodes NodeContainer nodes; nodes.Create(3); // 3 nodes, connected: 0 <---> 1 <---> 2 // Connecting nodes using two links PointToPointHelper p2p; p2p.Install(nodes.Get(0), nodes.Get(1)); p2p.Install(nodes.Get(1), nodes.Get(2)); // Install NDN stack on all nodes ndn::StackHelper ndnHelper; ndnHelper.SetDefaultRoutes(true); ndnHelper.setCsSize(0); ndnHelper.SetOldContentStore("ns3::ndn::cs::Lru", "MaxSize", "100"); ndnHelper.InstallAll(); // Choosing forwarding strategy ndn::StrategyChoiceHelper::InstallAll("/myprefix", "/localhost/nfd/strategy/best-route"); ns3::ndn::AppHelper consumerHelper("ns3::ndn::FileConsumerCbr::MultimediaConsumer"); consumerHelper.SetAttribute("AllowUpscale", BooleanValue(true)); consumerHelper.SetAttribute("AllowDownscale", BooleanValue(false)); consumerHelper.SetAttribute("ScreenWidth", UintegerValue(1920)); consumerHelper.SetAttribute("ScreenHeight", UintegerValue(1080)); consumerHelper.SetAttribute("StartRepresentationId", StringValue("auto")); consumerHelper.SetAttribute("MaxBufferedSeconds", UintegerValue(30)); consumerHelper.SetAttribute("StartUpDelay", StringValue("0.1")); consumerHelper.SetAttribute("AdaptationLogic", StringValue("dash::player::RateAndBufferBasedAdaptationLogic")); consumerHelper.SetAttribute("MpdFileToRequest", StringValue(std::string("/myprefix/AVC/BBB-2s.mpd" ))); //consumerHelper.SetPrefix (std::string("/Server_" + boost::lexical_cast<std::string>(i%server.size ()) + "/layer0")); ApplicationContainer app1 = consumerHelper.Install (nodes.Get(2)); // Producer responsible for hosting the MPD file ndn::AppHelper mpdProducerHelper("ns3::ndn::FileServer"); // Producer will reply to all requests starting with /myprefix/AVC/ and hosts the mpd file there mpdProducerHelper.SetPrefix("/myprefix"); mpdProducerHelper.SetAttribute("ContentDirectory", StringValue("/home/someuser/multimediaData")); mpdProducerHelper.Install(nodes.Get(0)); // install to some node from nodelist // Producer responsible for hosting the virtual segments ndn::AppHelper fakeSegmentProducerHelper("ns3::ndn::FakeFileServer"); // Producer will reply to all requests starting with /myprefix/AVC/BBB/ and hosts the virtual segment files there fakeSegmentProducerHelper.SetPrefix("/myprefix/AVC/BBB"); fakeSegmentProducerHelper.SetAttribute("MetaDataFile", StringValue("dash_dataset_avc_bbb.csv")); fakeSegmentProducerHelper.Install(nodes.Get(0)); // install to some node from nodelist ndn::GlobalRoutingHelper ndnGlobalRoutingHelper; ndnGlobalRoutingHelper.InstallAll(); ndnGlobalRoutingHelper.AddOrigins("/myprefix", nodes.Get(0)); ndn::GlobalRoutingHelper::CalculateRoutes(); Simulator::Stop(Seconds(1000.0)); Simulator::Run(); Simulator::Destroy(); NS_LOG_UNCOND("Simulation Finished."); return 0; }
/* * call-seq: * Win32::API#call(arg1, arg2, ...) * * Calls the function pointer with the given arguments (if any). Note that, * while this method will catch some prototype mismatches (raising a TypeError * in the process), it is not fulproof. It is ultimately your job to make * sure the arguments match the +prototype+ specified in the constructor. * * For convenience, nil is converted to NULL, true is converted to TRUE (1) * and false is converted to FALSE (0). */ static VALUE api_call(int argc, VALUE* argv, VALUE self){ VALUE v_proto, v_args, v_arg, v_return; Win32API* ptr; unsigned long return_value; int i = 0; int len; struct{ unsigned long params[20]; } param; Data_Get_Struct(self, Win32API, ptr); rb_scan_args(argc, argv, "0*", &v_args); v_proto = rb_iv_get(self, "@prototype"); // For void prototypes, allow either no args or an explicit nil if(RARRAY_LEN(v_proto) != RARRAY_LEN(v_args)){ char* c = StringValuePtr(RARRAY_PTR(v_proto)[0]); if(!strcmp(c, "V")){ rb_ary_push(v_args, Qnil); } else{ rb_raise(rb_eArgError, "wrong number of parameters: expected %d, got %d", RARRAY_LEN(v_proto), RARRAY_LEN(v_args) ); } } len = RARRAY_LEN(v_proto); for(i = 0; i < len; i++){ v_arg = RARRAY_PTR(v_args)[i]; // Convert nil to NULL. Otherwise convert as appropriate. if(NIL_P(v_arg)) param.params[i] = (unsigned long)NULL; else if(v_arg == Qtrue) param.params[i] = TRUE; else if(v_arg == Qfalse) param.params[i] = FALSE; else switch(ptr->prototype[i]){ case _T_LONG: param.params[i] = NUM2ULONG(v_arg); break; case _T_INTEGER: param.params[i] = NUM2INT(v_arg); break; case _T_POINTER: if(FIXNUM_P(v_arg)){ param.params[i] = NUM2ULONG(v_arg); } else{ StringValue(v_arg); rb_str_modify(v_arg); param.params[i] = (unsigned long)StringValuePtr(v_arg); } break; case _T_CALLBACK: ActiveCallback = v_arg; v_proto = rb_iv_get(ActiveCallback, "@prototype"); param.params[i] = (LPARAM)NUM2ULONG(rb_iv_get(ActiveCallback, "@address"));; break; case _T_STRING: param.params[i] = (unsigned long)RSTRING_PTR(v_arg); break; default: param.params[i] = NUM2ULONG(v_arg); } } /* Call the function, get the return value */ return_value = ptr->function(param); /* Return the appropriate type based on the return type specified * in the constructor. */ switch(ptr->return_type){ case _T_INTEGER: v_return = INT2NUM(return_value); break; case _T_LONG: v_return = ULONG2NUM(return_value); break; case _T_VOID: v_return = Qnil; break; case _T_POINTER: if(!return_value){ v_return = Qnil; } else{ VALUE v_efunc = rb_iv_get(self, "@effective_function_name"); char* efunc = RSTRING_PTR(v_efunc); if(efunc[strlen(efunc)-1] == 'W'){ v_return = rb_str_new( (TCHAR*)return_value, wcslen((wchar_t*)return_value)*2 ); } else{ v_return = rb_str_new2((TCHAR*)return_value); } } break; case _T_STRING: { VALUE v_efunc = rb_iv_get(self, "@effective_function_name"); char* efunc = RSTRING_PTR(v_efunc); if(efunc[strlen(efunc)-1] == 'W'){ v_return = rb_str_new( (TCHAR*)return_value, wcslen((wchar_t*)return_value)*2 ); } else{ v_return = rb_str_new2((TCHAR*)return_value); } } break; default: v_return = INT2NUM(0); } return v_return; }
DWORD CallbackFunction(CALLPARAM param, VALUE callback) { VALUE v_proto, v_return, v_proc, v_retval; VALUE argv[20]; int i, argc; char *a_proto; char *a_return; if(callback && !NIL_P(callback)){ v_proto = rb_iv_get(callback, "@prototype"); a_proto = RSTRING_PTR(v_proto); v_return = rb_iv_get(callback, "@return_type"); a_return = RSTRING_PTR(v_return); v_proc = rb_iv_get(callback, "@function"); argc = RSTRING_LEN(v_proto); for(i=0; i < RSTRING_LEN(v_proto); i++){ argv[i] = Qnil; switch(a_proto[i]){ case 'L': argv[i] = ULONG2NUM(param.params[i]); break; case 'P': if(param.params[i]) argv[i] = rb_str_new2((char *)param.params[i]); break; case 'I': argv[i] = INT2NUM(param.params[i]); break; default: rb_raise(cAPIProtoError, "Illegal prototype '%s'", a_proto[i]); } } v_retval = rb_funcall2(v_proc, rb_intern("call"), argc, argv); /* Handle true and false explicitly, as some CALLBACK functions * require TRUE or FALSE to break out of loops, etc. */ if(v_retval == Qtrue) return TRUE; else if(v_retval == Qfalse) return FALSE; switch (*a_return) { case 'I': return NUM2INT(v_retval); break; case 'L': return NUM2ULONG(v_retval); break; case 'S': return (unsigned long)RSTRING_PTR(v_retval); break; case 'P': if(NIL_P(v_retval)){ return 0; } else if(FIXNUM_P(v_retval)){ return NUM2ULONG(v_retval); } else{ StringValue(v_retval); rb_str_modify(v_retval); return (unsigned long)StringValuePtr(v_retval); } break; } } return 0; }
bool InterposeProperty(JSContext* cx, HandleObject target, const nsIID* iid, HandleId id, MutableHandle<JSPropertyDescriptor> descriptor) { // We only want to do interpostion on DOM instances and // wrapped natives. RootedObject unwrapped(cx, UncheckedUnwrap(target)); const js::Class* clasp = js::GetObjectClass(unwrapped); bool isCPOW = jsipc::IsWrappedCPOW(unwrapped); if (!mozilla::dom::IsDOMClass(clasp) && !IS_WN_CLASS(clasp) && !IS_PROTO_CLASS(clasp) && clasp != &OuterWindowProxyClass && !isCPOW) { return true; } XPCWrappedNativeScope* scope = ObjectScope(CurrentGlobalOrNull(cx)); MOZ_ASSERT(scope->HasInterposition()); nsCOMPtr<nsIAddonInterposition> interp = scope->GetInterposition(); InterpositionWhitelist* wl = XPCWrappedNativeScope::GetInterpositionWhitelist(interp); // We do InterposeProperty only if the id is on the whitelist of the interpostion // or if the target is a CPOW. if ((!wl || !wl->has(JSID_BITS(id.get()))) && !isCPOW) return true; JSAddonId* addonId = AddonIdOfObject(target); RootedValue addonIdValue(cx, StringValue(StringOfAddonId(addonId))); RootedValue prop(cx, IdToValue(id)); RootedValue targetValue(cx, ObjectValue(*target)); RootedValue descriptorVal(cx); nsresult rv = interp->InterposeProperty(addonIdValue, targetValue, iid, prop, &descriptorVal); if (NS_FAILED(rv)) { xpc::Throw(cx, rv); return false; } if (!descriptorVal.isObject()) return true; // We need to be careful parsing descriptorVal. |cx| is in the compartment // of the add-on and the descriptor is in the compartment of the // interposition. We could wrap the descriptor in the add-on's compartment // and then parse it. However, parsing the descriptor fetches properties // from it, and we would try to interpose on those property accesses. So // instead we parse in the interposition's compartment and then wrap the // descriptor. { JSAutoCompartment ac(cx, &descriptorVal.toObject()); if (!JS::ObjectToCompletePropertyDescriptor(cx, target, descriptorVal, descriptor)) return false; } // Always make the property non-configurable regardless of what the // interposition wants. descriptor.setAttributes(descriptor.attributes() | JSPROP_PERMANENT); if (!JS_WrapPropertyDescriptor(cx, descriptor)) return false; return true; }
Value* Literal(const char* name, State* state, int argc, Expr* argv[]) { return StringValue(strdup(name)); }
VALUE rb_exc_new_str(VALUE etype, VALUE str) { StringValue(str); return rb_funcall(etype, rb_intern("new"), 1, str); }
VALUE ruv_buffer_write(int argc, VALUE* argv, VALUE rb_buffer) { VALUE rb_str, rb_offset, rb_length, rb_extern_enc, rb_cBuffer; size_t offset, length, max_length, char_count; ruv_buffer_t *buffer; rb_encoding *rb_extern_encoding; Data_Get_Struct(rb_buffer, ruv_buffer_t, buffer); rb_scan_args(argc, argv, "13", &rb_str, &rb_offset, &rb_length, &rb_extern_enc); StringValue(rb_str); // encoding: use specified external encoding if provided // otherwise use Encoding.default_external as default if(!NIL_P(rb_extern_enc)) { rb_extern_encoding = rb_enc_get(rb_extern_enc); } else { rb_extern_encoding = rb_default_external_encoding(); } // convert to external encoding rb_str = rb_str_export_to_enc(rb_str, rb_extern_encoding); // offset: either specified in params or 0 if(!NIL_P(rb_offset)) { Check_Type(rb_offset, T_FIXNUM); offset = NUM2SIZET(rb_offset); if(offset >= buffer->length) { rb_raise(rb_eArgError, "Overflow! offset is larger than buffer size."); } } else { offset = 0; } // max length: the smaller of the max available space or the whole ruby string max_length = MIN(buffer->length - offset, (size_t)RSTRING_LEN(rb_str)); // length: number of bytes to write. (include half chars) if(!NIL_P(rb_length)) { Check_Type(rb_length, T_FIXNUM); length = NUM2SIZET(rb_length); } else { length = max_length; } // If we are not writing the whole string into the buffer, // re-adjust length so we don't write half a character (uft8, etc) // 1). get char count from calculated byte length // 2). get byte length back from char count // This way only whole char is written to buffer if(length != (size_t)RSTRING_LEN(rb_str)) { char_count = rb_str_sublen(rb_str, length); length = rb_str_offset(rb_str, char_count); } memcpy(buffer->data + offset, RSTRING_PTR(rb_str), length); // set instance variable so we know how much characters are written rb_cBuffer = rb_obj_class(rb_buffer); rb_iv_set(rb_cBuffer, RUV_BUFFER_CHAR_WRITTEN_SYM, SIZET2NUM(char_count)); return SIZET2NUM(length); }
// format(fs_type, partition_type, location, fs_size, mount_point) // // fs_type="yaffs2" partition_type="MTD" location=partition fs_size=<bytes> mount_point=<location> // fs_type="ext4" partition_type="EMMC" location=device fs_size=<bytes> mount_point=<location> // if fs_size == 0, then make_ext4fs uses the entire partition. // if fs_size > 0, that is the size to use // if fs_size < 0, then reserve that many bytes at the end of the partition Value* FormatFn(const char* name, State* state, int argc, Expr* argv[]) { char* result = NULL; if (argc != 5) { return ErrorAbort(state, "%s() expects 5 args, got %d", name, argc); } char* fs_type; char* partition_type; char* location; char* fs_size; char* mount_point; if (ReadArgs(state, argv, 5, &fs_type, &partition_type, &location, &fs_size, &mount_point) < 0) { return NULL; } if (strlen(fs_type) == 0) { ErrorAbort(state, "fs_type argument to %s() can't be empty", name); goto done; } if (strlen(partition_type) == 0) { ErrorAbort(state, "partition_type argument to %s() can't be empty", name); goto done; } if (strlen(location) == 0) { ErrorAbort(state, "location argument to %s() can't be empty", name); goto done; } if (strlen(mount_point) == 0) { ErrorAbort(state, "mount_point argument to %s() can't be empty", name); goto done; } if (strcmp(partition_type, "MTD") == 0) { mtd_scan_partitions(); const MtdPartition* mtd = mtd_find_partition_by_name(location); if (mtd == NULL) { fprintf(stderr, "%s: no mtd partition named \"%s\"", name, location); result = strdup(""); goto done; } MtdWriteContext* ctx = mtd_write_partition(mtd); if (ctx == NULL) { fprintf(stderr, "%s: can't write \"%s\"", name, location); result = strdup(""); goto done; } if (mtd_erase_blocks(ctx, -1) == -1) { mtd_write_close(ctx); fprintf(stderr, "%s: failed to erase \"%s\"", name, location); result = strdup(""); goto done; } if (mtd_write_close(ctx) != 0) { fprintf(stderr, "%s: failed to close \"%s\"", name, location); result = strdup(""); goto done; } result = location; #ifdef USE_EXT4 } else if (strcmp(fs_type, "ext4") == 0) { int status = make_ext4fs(location, atoll(fs_size), mount_point, sehandle); if (status != 0) { fprintf(stderr, "%s: make_ext4fs failed (%d) on %s", name, status, location); result = strdup(""); goto done; } result = location; #endif } else { fprintf(stderr, "%s: unsupported fs_type \"%s\" partition_type \"%s\"", name, fs_type, partition_type); } done: free(fs_type); free(partition_type); if (result != location) free(location); return StringValue(result); }
static CFStringRef rb_create_cf_string(VALUE string){ StringValue(string); string = rb_str_export_to_enc(string, rb_utf8_encoding()); char * c_string= StringValueCStr(string); return CFStringCreateWithCString(NULL, c_string, kCFStringEncodingUTF8); }
// mount(fs_type, partition_type, location, mount_point) // // fs_type="yaffs2" partition_type="MTD" location=partition // fs_type="ext4" partition_type="EMMC" location=device Value* MountFn(const char* name, State* state, int argc, Expr* argv[]) { char* result = NULL; if (argc != 4) { return ErrorAbort(state, "%s() expects 4 args, got %d", name, argc); } char* fs_type; char* partition_type; char* location; char* mount_point; if (ReadArgs(state, argv, 4, &fs_type, &partition_type, &location, &mount_point) < 0) { return NULL; } if (strlen(fs_type) == 0) { ErrorAbort(state, "fs_type argument to %s() can't be empty", name); goto done; } if (strlen(partition_type) == 0) { ErrorAbort(state, "partition_type argument to %s() can't be empty", name); goto done; } if (strlen(location) == 0) { ErrorAbort(state, "location argument to %s() can't be empty", name); goto done; } if (strlen(mount_point) == 0) { ErrorAbort(state, "mount_point argument to %s() can't be empty", name); goto done; } #ifdef HAVE_SELINUX char *secontext = NULL; if (sehandle) { selabel_lookup(sehandle, &secontext, mount_point, 0755); setfscreatecon(secontext); } #endif mkdir(mount_point, 0755); #ifdef HAVE_SELINUX if (secontext) { freecon(secontext); setfscreatecon(NULL); } #endif if (strcmp(partition_type, "MTD") == 0) { mtd_scan_partitions(); const MtdPartition* mtd; mtd = mtd_find_partition_by_name(location); if (mtd == NULL) { fprintf(stderr, "%s: no mtd partition named \"%s\"", name, location); result = strdup(""); goto done; } if (mtd_mount_partition(mtd, mount_point, fs_type, 0 /* rw */) != 0) { fprintf(stderr, "mtd mount of %s failed: %s\n", location, strerror(errno)); result = strdup(""); goto done; } result = mount_point; } else { if (mount(location, mount_point, fs_type, MS_NOATIME | MS_NODEV | MS_NODIRATIME, "") < 0) { fprintf(stderr, "%s: failed to mount %s at %s: %s\n", name, location, mount_point, strerror(errno)); result = strdup(""); } else { result = mount_point; } } done: free(fs_type); free(partition_type); free(location); if (result != mount_point) free(mount_point); return StringValue(result); }
int main(int argc, char* argv[]) { std::string fof = "fof.txt"; std::string dropFileName = "drops.txt"; std::string topologyFile = "src/ndnSIM/examples/topologies/topo-tree.txt"; std::string appDelayFile = "app-delays-trace.txt"; std::string rateTraceFile = "rate-trace.txt"; std::string percentage = "1.0"; std::string frequency = "1"; int simulationTime = 1000; CommandLine cmd; cmd.AddValue("fof", "forwarder overhead file", fof); cmd.AddValue("time", "simulation time argument", simulationTime); cmd.AddValue("top", "topology file", topologyFile); cmd.AddValue("drop", "bead drop file", dropFileName); cmd.AddValue("appd", "app delay file", appDelayFile); cmd.AddValue("rate", "rate trace file", rateTraceFile); cmd.AddValue("percentage", "bead percentage", percentage); cmd.AddValue("freq", "bead frequency", frequency); cmd.Parse(argc, argv); delayFile.open(fof); dropFile.open(dropFileName); AnnotatedTopologyReader topologyReader("", 1); topologyReader.SetFileName(topologyFile); topologyReader.Read(); ndn::StackHelper ndnHelper; ndnHelper.InstallAll(); // Getting containers for the consumer/producer Ptr<Node> consumers[4] = {Names::Find<Node>("leaf-1"), Names::Find<Node>("leaf-2"), Names::Find<Node>("leaf-3"), Names::Find<Node>("leaf-4")}; Ptr<Node> routers[2] = {Names::Find<Node>("rtr-1"), Names::Find<Node>("rtr-2")}; // Ptr<Node> producers[2] = {Names::Find<Node>("root-1"), Names::Find<Node>("root-2")}; Ptr<Node> producer = Names::Find<Node>("root-1"); // Choosing forwarding strategy ndn::StrategyChoiceHelper::InstallAll("/root", "/localhost/nfd/strategy/best-route"); // Installing global routing interface on all nodes ndn::GlobalRoutingHelper ndnGlobalRoutingHelper; ndnGlobalRoutingHelper.InstallAll(); // Install NDN on routers ndn::StackHelper ndnHelperWithCache; ndnHelperWithCache.SetDefaultRoutes(true); ndnHelperWithCache.SetOldContentStore("ns3::ndn::cs::Freshness::Lru", "MaxSize", "0"); ndnHelperWithCache.InstallCallback(routers[0], (size_t)&ForwardingDelay, 0); ndnHelperWithCache.InstallBeadDropCallback(routers[0], (size_t)&BeadDropCallback, 0); ndnHelperWithCache.SetUseHistory(routers[0], 100); ndnHelperWithCache.InstallCallback(routers[1], (size_t)&ForwardingDelay, 1); ndnHelperWithCache.InstallBeadDropCallback(routers[1], (size_t)&BeadDropCallback, 1); ndnHelperWithCache.SetUseHistory(routers[0], 100); ndn::AppHelper consumerHelper("ns3::ndn::ConsumerCbr"); // Consumer will request /prefix/0, /prefix/1, ... consumerHelper.SetPrefix("/root"); consumerHelper.SetAttribute("Frequency", StringValue("10")); // 10 interests a second consumerHelper.Install(consumers[0]); consumerHelper.Install(consumers[1]); consumerHelper.Install(consumers[2]); ndn::AppHelper producerHelper("ns3::ndn::Producer"); producerHelper.SetAttribute("PayloadSize", StringValue("1024")); producerHelper.SetAttribute("Frequency", StringValue(frequency)); // 1 BEAD every second producerHelper.SetAttribute("Percentage", StringValue(percentage)); // Register /root prefix with global routing controller and // install producer that will satisfy Interests in /root namespace ndnGlobalRoutingHelper.AddOrigins("/root", producer); producerHelper.SetPrefix("/root"); producerHelper.Install(producer).Start(Seconds(0)); producerHelper.Install(producer).Start(Seconds(0)); ndnHelperWithCache.InstallCallback(producer, (size_t)&ForwardingDelay, 2); // ndnGlobalRoutingHelper.AddOrigins("/root/nonbead", producers[1]); // producerHelper.SetPrefix("/root/nonbead"); // producerHelper.Install(producers[1]).Start(Seconds(9)); // Calculate and install FIBs ndn::GlobalRoutingHelper::CalculateRoutes(); Simulator::Stop(Seconds(simulationTime)); ndn::AppDelayTracer::InstallAll(appDelayFile); ndn::L3RateTracer::InstallAll(rateTraceFile, Seconds(0.5)); Simulator::Run(); Simulator::Destroy(); delayFile.flush(); delayFile.close(); dropFile.flush(); dropFile.close(); return 0; }
// file_getprop(file, key) // // interprets 'file' as a getprop-style file (key=value pairs, one // per line, # comment lines and blank lines okay), and returns the value // for 'key' (or "" if it isn't defined). Value* FileGetPropFn(const char* name, State* state, int argc, Expr* argv[]) { char* result = NULL; char* buffer = NULL; char* filename; char* key; if (ReadArgs(state, argv, 2, &filename, &key) < 0) { return NULL; } struct stat st; if (stat(filename, &st) < 0) { ErrorAbort(state, "%s: failed to stat \"%s\": %s", name, filename, strerror(errno)); goto done; } #define MAX_FILE_GETPROP_SIZE 65536 if (st.st_size > MAX_FILE_GETPROP_SIZE) { ErrorAbort(state, "%s too large for %s (max %d)", filename, name, MAX_FILE_GETPROP_SIZE); goto done; } buffer = malloc(st.st_size+1); if (buffer == NULL) { ErrorAbort(state, "%s: failed to alloc %d bytes", name, st.st_size+1); goto done; } FILE* f = fopen(filename, "rb"); if (f == NULL) { ErrorAbort(state, "%s: failed to open %s: %s", name, filename, strerror(errno)); goto done; } if (fread(buffer, 1, st.st_size, f) != st.st_size) { ErrorAbort(state, "%s: failed to read %d bytes from %s", name, st.st_size+1, filename); fclose(f); goto done; } buffer[st.st_size] = '\0'; fclose(f); char* line = strtok(buffer, "\n"); do { // skip whitespace at start of line while (*line && isspace(*line)) ++line; // comment or blank line: skip to next line if (*line == '\0' || *line == '#') continue; char* equal = strchr(line, '='); if (equal == NULL) { ErrorAbort(state, "%s: malformed line \"%s\": %s not a prop file?", name, line, filename); goto done; } // trim whitespace between key and '=' char* key_end = equal-1; while (key_end > line && isspace(*key_end)) --key_end; key_end[1] = '\0'; // not the key we're looking for if (strcmp(key, line) != 0) continue; // skip whitespace after the '=' to the start of the value char* val_start = equal+1; while(*val_start && isspace(*val_start)) ++val_start; // trim trailing whitespace char* val_end = val_start + strlen(val_start)-1; while (val_end > val_start && isspace(*val_end)) --val_end; val_end[1] = '\0'; result = strdup(val_start); break; } while ((line = strtok(NULL, "\n"))); if (result == NULL) result = strdup(""); done: free(filename); free(key); free(buffer); return StringValue(result); }
VALUE CommandTMatcher_sorted_matches_for(int argc, VALUE *argv, VALUE self) { long i, j, limit, path_count, thread_count; #ifdef HAVE_PTHREAD_H long err; pthread_t *threads; #endif long needle_bitmask = UNSET_BITMASK; long heap_matches_count; int use_heap; int sort; match_t *matches; match_t *heap_matches = NULL; heap_t *heap; thread_args_t *thread_args; VALUE always_show_dot_files; VALUE case_sensitive; VALUE recurse; VALUE ignore_spaces; VALUE limit_option; VALUE last_needle; VALUE needle; VALUE never_show_dot_files; VALUE new_paths_object_id; VALUE options; VALUE paths; VALUE paths_object_id; VALUE results; VALUE scanner; VALUE sort_option; VALUE threads_option; VALUE wrapped_matches; // Process arguments: 1 mandatory, 1 optional. if (rb_scan_args(argc, argv, "11", &needle, &options) == 1) { options = Qnil; } if (NIL_P(needle)) { rb_raise(rb_eArgError, "nil needle"); } // Check optional options hash for overrides. case_sensitive = CommandT_option_from_hash("case_sensitive", options); limit_option = CommandT_option_from_hash("limit", options); threads_option = CommandT_option_from_hash("threads", options); sort_option = CommandT_option_from_hash("sort", options); ignore_spaces = CommandT_option_from_hash("ignore_spaces", options); always_show_dot_files = rb_iv_get(self, "@always_show_dot_files"); never_show_dot_files = rb_iv_get(self, "@never_show_dot_files"); recurse = CommandT_option_from_hash("recurse", options); limit = NIL_P(limit_option) ? 15 : NUM2LONG(limit_option); sort = NIL_P(sort_option) || sort_option == Qtrue; use_heap = limit && sort; heap_matches_count = 0; needle = StringValue(needle); if (case_sensitive != Qtrue) { needle = rb_funcall(needle, rb_intern("downcase"), 0); } if (ignore_spaces == Qtrue) { needle = rb_funcall(needle, rb_intern("delete"), 1, rb_str_new2(" ")); } // Get unsorted matches. scanner = rb_iv_get(self, "@scanner"); paths = rb_funcall(scanner, rb_intern("paths"), 0); path_count = RARRAY_LEN(paths); // Cached C data, not visible to Ruby layer. paths_object_id = rb_ivar_get(self, rb_intern("paths_object_id")); new_paths_object_id = rb_funcall(paths, rb_intern("object_id"), 0); rb_ivar_set(self, rb_intern("paths_object_id"), new_paths_object_id); last_needle = rb_ivar_get(self, rb_intern("last_needle")); if ( NIL_P(paths_object_id) || rb_equal(new_paths_object_id, paths_object_id) != Qtrue ) { // `paths` changed, need to replace matches array. paths_object_id = new_paths_object_id; matches = malloc(path_count * sizeof(match_t)); if (!matches) { rb_raise(rb_eNoMemError, "memory allocation failed"); } wrapped_matches = Data_Wrap_Struct( rb_cObject, 0, free, matches ); rb_ivar_set(self, rb_intern("matches"), wrapped_matches); last_needle = Qnil; } else { // Get existing array. Data_Get_Struct( rb_ivar_get(self, rb_intern("matches")), match_t, matches ); // Will compare against previously computed haystack bitmasks. needle_bitmask = calculate_bitmask(needle); // Check whether current search extends previous search; if so, we can // skip all the non-matches from last time without looking at them. if (rb_funcall(needle, rb_intern("start_with?"), 1, last_needle) != Qtrue) { last_needle = Qnil; } } thread_count = NIL_P(threads_option) ? 1 : NUM2LONG(threads_option); if (use_heap) { heap_matches = malloc(thread_count * limit * sizeof(match_t)); if (!heap_matches) { rb_raise(rb_eNoMemError, "memory allocation failed"); } } #ifdef HAVE_PTHREAD_H #define THREAD_THRESHOLD 1000 /* avoid the overhead of threading when search space is small */ if (path_count < THREAD_THRESHOLD) { thread_count = 1; } threads = malloc(sizeof(pthread_t) * thread_count); if (!threads) rb_raise(rb_eNoMemError, "memory allocation failed"); #endif thread_args = malloc(sizeof(thread_args_t) * thread_count); if (!thread_args) rb_raise(rb_eNoMemError, "memory allocation failed"); for (i = 0; i < thread_count; i++) { thread_args[i].thread_count = thread_count; thread_args[i].thread_index = i; thread_args[i].case_sensitive = case_sensitive == Qtrue; thread_args[i].matches = matches; thread_args[i].limit = use_heap ? limit : 0; thread_args[i].path_count = path_count; thread_args[i].haystacks = paths; thread_args[i].needle = needle; thread_args[i].last_needle = last_needle; thread_args[i].always_show_dot_files = always_show_dot_files; thread_args[i].never_show_dot_files = never_show_dot_files; thread_args[i].recurse = recurse; thread_args[i].needle_bitmask = needle_bitmask; #ifdef HAVE_PTHREAD_H if (i == thread_count - 1) { #endif // For the last "worker", we'll just use the main thread. heap = match_thread(&thread_args[i]); if (heap) { for (j = 0; j < heap->count; j++) { heap_matches[heap_matches_count++] = *(match_t *)heap->entries[j]; } heap_free(heap); } #ifdef HAVE_PTHREAD_H } else { err = pthread_create(&threads[i], NULL, match_thread, (void *)&thread_args[i]); if (err != 0) { rb_raise(rb_eSystemCallError, "pthread_create() failure (%d)", (int)err); } } #endif } #ifdef HAVE_PTHREAD_H for (i = 0; i < thread_count - 1; i++) { err = pthread_join(threads[i], (void **)&heap); if (err != 0) { rb_raise(rb_eSystemCallError, "pthread_join() failure (%d)", (int)err); } if (heap) { for (j = 0; j < heap->count; j++) { heap_matches[heap_matches_count++] = *(match_t *)heap->entries[j]; } heap_free(heap); } } free(threads); #endif if (sort) { if ( RSTRING_LEN(needle) == 0 || (RSTRING_LEN(needle) == 1 && RSTRING_PTR(needle)[0] == '.') ) { // Alphabetic order if search string is only "" or "." // TODO: make those semantics fully apply to heap case as well // (they don't because the heap itself calls cmp_score, which means // that the items which stay in the top [limit] may (will) be // different). qsort( use_heap ? heap_matches : matches, use_heap ? heap_matches_count : path_count, sizeof(match_t), cmp_alpha ); } else { qsort( use_heap ? heap_matches : matches, use_heap ? heap_matches_count : path_count, sizeof(match_t), cmp_score ); } } results = rb_ary_new(); if (limit == 0) { limit = path_count; } for ( i = 0; i < (use_heap ? heap_matches_count : path_count) && limit > 0; i++ ) { if ((use_heap ? heap_matches : matches)[i].score > 0.0) { rb_funcall( results, rb_intern("push"), 1, (use_heap ? heap_matches : matches)[i].path ); limit--; } } if (use_heap) { free(heap_matches); } // Save this state to potentially speed subsequent searches. rb_ivar_set(self, rb_intern("last_needle"), needle); return results; }
static VALUE ossl_engine_s_load(int argc, VALUE *argv, VALUE klass) { #if !defined(HAVE_ENGINE_LOAD_BUILTIN_ENGINES) return Qnil; #else VALUE name; rb_scan_args(argc, argv, "01", &name); if(NIL_P(name)){ ENGINE_load_builtin_engines(); return Qtrue; } StringValue(name); #ifndef OPENSSL_NO_STATIC_ENGINE #if HAVE_ENGINE_LOAD_DYNAMIC OSSL_ENGINE_LOAD_IF_MATCH(dynamic); #endif #if HAVE_ENGINE_LOAD_4758CCA OSSL_ENGINE_LOAD_IF_MATCH(4758cca); #endif #if HAVE_ENGINE_LOAD_AEP OSSL_ENGINE_LOAD_IF_MATCH(aep); #endif #if HAVE_ENGINE_LOAD_ATALLA OSSL_ENGINE_LOAD_IF_MATCH(atalla); #endif #if HAVE_ENGINE_LOAD_CHIL OSSL_ENGINE_LOAD_IF_MATCH(chil); #endif #if HAVE_ENGINE_LOAD_CSWIFT OSSL_ENGINE_LOAD_IF_MATCH(cswift); #endif #if HAVE_ENGINE_LOAD_NURON OSSL_ENGINE_LOAD_IF_MATCH(nuron); #endif #if HAVE_ENGINE_LOAD_SUREWARE OSSL_ENGINE_LOAD_IF_MATCH(sureware); #endif #if HAVE_ENGINE_LOAD_UBSEC OSSL_ENGINE_LOAD_IF_MATCH(ubsec); #endif #if HAVE_ENGINE_LOAD_PADLOCK OSSL_ENGINE_LOAD_IF_MATCH(padlock); #endif #if HAVE_ENGINE_LOAD_CAPI OSSL_ENGINE_LOAD_IF_MATCH(capi); #endif #if HAVE_ENGINE_LOAD_GMP OSSL_ENGINE_LOAD_IF_MATCH(gmp); #endif #if HAVE_ENGINE_LOAD_GOST OSSL_ENGINE_LOAD_IF_MATCH(gost); #endif #if HAVE_ENGINE_LOAD_CRYPTODEV OSSL_ENGINE_LOAD_IF_MATCH(cryptodev); #endif #if HAVE_ENGINE_LOAD_AESNI OSSL_ENGINE_LOAD_IF_MATCH(aesni); #endif #endif #ifdef HAVE_ENGINE_LOAD_OPENBSD_DEV_CRYPTO OSSL_ENGINE_LOAD_IF_MATCH(openbsd_dev_crypto); #endif OSSL_ENGINE_LOAD_IF_MATCH(openssl); rb_warning("no such builtin loader for `%s'", RSTRING_PTR(name)); return Qnil; #endif /* HAVE_ENGINE_LOAD_BUILTIN_ENGINES */ }
/** * Helper method that encodes and appends a key/value pair (`key`, `value`) from * a hash to the watchman_t struct passed in via `data` */ int watchman_dump_hash_iterator(VALUE key, VALUE value, VALUE data) { watchman_t *w = (watchman_t *)data; watchman_dump_string(w, StringValue(key)); watchman_dump(w, value); return ST_CONTINUE; }
bool Library::Declare(JSContext* cx, unsigned argc, Value* vp) { CallArgs args = CallArgsFromVp(argc, vp); RootedObject obj(cx, JS_THIS_OBJECT(cx, vp)); if (!obj) return false; if (!IsLibrary(obj)) { JS_ReportErrorASCII(cx, "not a library"); return false; } PRLibrary* library = GetLibrary(obj); if (!library) { JS_ReportErrorASCII(cx, "library not open"); return false; } // We allow two API variants: // 1) library.declare(name, abi, returnType, argType1, ...) // declares a function with the given properties, and resolves the symbol // address in the library. // 2) library.declare(name, type) // declares a symbol of 'type', and resolves it. The object that comes // back will be of type 'type', and will point into the symbol data. // This data will be both readable and writable via the usual CData // accessors. If 'type' is a PointerType to a FunctionType, the result will // be a function pointer, as with 1). if (args.length() < 2) { JS_ReportErrorASCII(cx, "declare requires at least two arguments"); return false; } if (!args[0].isString()) { JS_ReportErrorASCII(cx, "first argument must be a string"); return false; } RootedObject fnObj(cx, nullptr); RootedObject typeObj(cx); bool isFunction = args.length() > 2; if (isFunction) { // Case 1). // Create a FunctionType representing the function. fnObj = FunctionType::CreateInternal(cx, args[1], args[2], HandleValueArray::subarray(args, 3, args.length() - 3)); if (!fnObj) return false; // Make a function pointer type. typeObj = PointerType::CreateInternal(cx, fnObj); if (!typeObj) return false; } else { // Case 2). if (args[1].isPrimitive() || !CType::IsCType(args[1].toObjectOrNull()) || !CType::IsSizeDefined(args[1].toObjectOrNull())) { JS_ReportErrorASCII(cx, "second argument must be a type of defined size"); return false; } typeObj = args[1].toObjectOrNull(); if (CType::GetTypeCode(typeObj) == TYPE_pointer) { fnObj = PointerType::GetBaseType(typeObj); isFunction = fnObj && CType::GetTypeCode(fnObj) == TYPE_function; } } void* data; PRFuncPtr fnptr; RootedString nameStr(cx, args[0].toString()); AutoCString symbol; if (isFunction) { // Build the symbol, with mangling if necessary. FunctionType::BuildSymbolName(nameStr, fnObj, symbol); AppendString(symbol, "\0"); // Look up the function symbol. fnptr = PR_FindFunctionSymbol(library, symbol.begin()); if (!fnptr) { JS_ReportErrorASCII(cx, "couldn't find function symbol in library"); return false; } data = &fnptr; } else { // 'typeObj' is another data type. Look up the data symbol. AppendString(symbol, nameStr); AppendString(symbol, "\0"); data = PR_FindSymbol(library, symbol.begin()); if (!data) { JS_ReportErrorASCII(cx, "couldn't find symbol in library"); return false; } } RootedObject result(cx, CData::Create(cx, typeObj, obj, data, isFunction)); if (!result) return false; if (isFunction) JS_SetReservedSlot(result, SLOT_FUNNAME, StringValue(nameStr)); args.rval().setObject(*result); // Seal the CData object, to prevent modification of the function pointer. // This permanently associates this object with the library, and avoids // having to do things like reset SLOT_REFERENT when someone tries to // change the pointer value. // XXX This will need to change when bug 541212 is fixed -- CData::ValueSetter // could be called on a sealed object. if (isFunction && !JS_FreezeObject(cx, result)) return false; return true; }
void LenaPssFfMacSchedulerTestCase2::DoRun (void) { if (!m_errorModelEnabled) { Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false)); Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false)); } Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true)); Ptr<LteHelper> lteHelper = CreateObject<LteHelper> (); Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> (); lteHelper->SetEpcHelper (epcHelper); Ptr<Node> pgw = epcHelper->GetPgwNode (); // Create a single RemoteHost NodeContainer remoteHostContainer; remoteHostContainer.Create (1); Ptr<Node> remoteHost = remoteHostContainer.Get (0); InternetStackHelper internet; internet.Install (remoteHostContainer); // Create the Internet PointToPointHelper p2ph; p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s"))); p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500)); p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.001))); NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost); Ipv4AddressHelper ipv4h; ipv4h.SetBase ("1.0.0.0", "255.0.0.0"); Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign (internetDevices); // interface 0 is localhost, 1 is the p2p device Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress (1); Ipv4StaticRoutingHelper ipv4RoutingHelper; Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ()); remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.0.0.0"), 1); // LogComponentDisableAll (LOG_LEVEL_ALL); //LogComponentEnable ("LenaTestPssFfMacCheduler", LOG_LEVEL_ALL); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); // Create Nodes: eNodeB and UE NodeContainer enbNodes; NodeContainer ueNodes; enbNodes.Create (1); ueNodes.Create (m_nUser); // Install Mobility Model MobilityHelper mobility; mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); mobility.Install (enbNodes); mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); mobility.Install (ueNodes); // Create Devices and install them in the Nodes (eNB and UE) NetDeviceContainer enbDevs; NetDeviceContainer ueDevs; lteHelper->SetSchedulerType ("ns3::PssFfMacScheduler"); enbDevs = lteHelper->InstallEnbDevice (enbNodes); ueDevs = lteHelper->InstallUeDevice (ueNodes); Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> (); Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy (); enbPhy->SetAttribute ("TxPower", DoubleValue (30.0)); enbPhy->SetAttribute ("NoiseFigure", DoubleValue (5.0)); // Set UEs' position and power for (int i = 0; i < m_nUser; i++) { Ptr<ConstantPositionMobilityModel> mm = ueNodes.Get (i)->GetObject<ConstantPositionMobilityModel> (); mm->SetPosition (Vector (m_dist.at (i), 0.0, 0.0)); Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get (i)->GetObject<LteUeNetDevice> (); Ptr<LteUePhy> uePhy = lteUeDev->GetPhy (); uePhy->SetAttribute ("TxPower", DoubleValue (23.0)); uePhy->SetAttribute ("NoiseFigure", DoubleValue (9.0)); } // Install the IP stack on the UEs internet.Install (ueNodes); Ipv4InterfaceContainer ueIpIface; ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevs)); // Assign IP address to UEs for (uint32_t u = 0; u < ueNodes.GetN (); ++u) { Ptr<Node> ueNode = ueNodes.Get (u); // Set the default gateway for the UE Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode->GetObject<Ipv4> ()); ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1); } // Attach a UE to a eNB lteHelper->Attach (ueDevs, enbDevs.Get (0)); // Activate an EPS bearer on all UEs for (uint32_t u = 0; u < ueNodes.GetN (); ++u) { Ptr<NetDevice> ueDevice = ueDevs.Get (u); GbrQosInformation qos; qos.gbrDl = (m_packetSize.at (u) + 32) * (1000 / m_interval) * 8; // bit/s, considering IP, UDP, RLC, PDCP header size qos.gbrUl = (m_packetSize.at (u) + 32) * (1000 / m_interval) * 8; qos.mbrDl = qos.gbrDl; qos.mbrUl = qos.gbrUl; enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE; EpsBearer bearer (q, qos); lteHelper->ActivateDedicatedEpsBearer (ueDevice, bearer, EpcTft::Default ()); } // Install downlind and uplink applications uint16_t dlPort = 1234; uint16_t ulPort = 2000; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), ulPort)); ApplicationContainer clientApps; ApplicationContainer serverApps; for (uint32_t u = 0; u < ueNodes.GetN (); ++u) { ++ulPort; serverApps.Add (dlPacketSinkHelper.Install (ueNodes.Get (u))); // receive packets from remotehost serverApps.Add (ulPacketSinkHelper.Install (remoteHost)); // receive packets from UEs UdpClientHelper dlClient (ueIpIface.GetAddress (u), dlPort); // uplink packets generator dlClient.SetAttribute ("Interval", TimeValue (MilliSeconds (m_interval))); dlClient.SetAttribute ("MaxPackets", UintegerValue (1000000)); dlClient.SetAttribute ("PacketSize", UintegerValue (m_packetSize.at (u))); UdpClientHelper ulClient (remoteHostAddr, ulPort); // downlink packets generator ulClient.SetAttribute ("Interval", TimeValue (MilliSeconds (m_interval))); ulClient.SetAttribute ("MaxPackets", UintegerValue (1000000)); ulClient.SetAttribute ("PacketSize", UintegerValue (m_packetSize.at (u))); clientApps.Add (dlClient.Install (remoteHost)); clientApps.Add (ulClient.Install (ueNodes.Get (u))); } serverApps.Start (Seconds (0.030)); clientApps.Start (Seconds (0.030)); double statsStartTime = 0.04; // need to allow for RRC connection establishment + SRS double statsDuration = 0.5; double tolerance = 0.1; Simulator::Stop (Seconds (statsStartTime + statsDuration - 0.0001)); lteHelper->EnableRlcTraces (); Ptr<RadioBearerStatsCalculator> rlcStats = lteHelper->GetRlcStats (); rlcStats->SetAttribute ("StartTime", TimeValue (Seconds (statsStartTime))); rlcStats->SetAttribute ("EpochDuration", TimeValue (Seconds (statsDuration))); Simulator::Run (); /** * Check that the downlink assignation is done in a "token bank fair queue" manner */ NS_LOG_INFO ("DL - Test with " << m_nUser << " user(s)"); std::vector <uint64_t> dlDataRxed; for (int i = 0; i < m_nUser; i++) { // get the imsi uint64_t imsi = ueDevs.Get (i)->GetObject<LteUeNetDevice> ()->GetImsi (); // get the lcId uint8_t lcId = 4; dlDataRxed.push_back (rlcStats->GetDlRxData (imsi, lcId)); NS_LOG_INFO ("\tUser " << i << " dist " << m_dist.at (i) << " imsi " << imsi << " bytes rxed " << (double)dlDataRxed.at (i) << " thr " << (double)dlDataRxed.at (i) / statsDuration << " ref " << m_estThrPssDl.at (i)); } for (int i = 0; i < m_nUser; i++) { NS_TEST_ASSERT_MSG_EQ_TOL ((double)dlDataRxed.at (i) / statsDuration, m_estThrPssDl.at (i), m_estThrPssDl.at (i) * tolerance, " Unfair Throughput!"); } Simulator::Destroy (); }
static VALUE rg_s_find_base_dir(G_GNUC_UNUSED VALUE self, VALUE text) { StringValue(text); return PANGODIRECTION2RVAL(pango_find_base_dir(RSTRING_PTR(text), RSTRING_LEN(text))); }
VALUE rb_str_format(int argc, const VALUE *argv, VALUE fmt) { enum {default_float_precision = 6}; rb_encoding *enc; const char *p, *end; char *buf; long blen, bsiz; VALUE result; long scanned = 0; int coderange = ENC_CODERANGE_7BIT; int width, prec, flags = FNONE; int nextarg = 1; int posarg = 0; int tainted = 0; VALUE nextvalue; VALUE tmp; VALUE str; volatile VALUE hash = Qundef; #define CHECK_FOR_WIDTH(f) \ if ((f) & FWIDTH) { \ rb_raise(rb_eArgError, "width given twice"); \ } \ if ((f) & FPREC0) { \ rb_raise(rb_eArgError, "width after precision"); \ } #define CHECK_FOR_FLAGS(f) \ if ((f) & FWIDTH) { \ rb_raise(rb_eArgError, "flag after width"); \ } \ if ((f) & FPREC0) { \ rb_raise(rb_eArgError, "flag after precision"); \ } ++argc; --argv; if (OBJ_TAINTED(fmt)) tainted = 1; StringValue(fmt); enc = rb_enc_get(fmt); fmt = rb_str_new4(fmt); p = RSTRING_PTR(fmt); end = p + RSTRING_LEN(fmt); blen = 0; bsiz = 120; result = rb_str_buf_new(bsiz); rb_enc_copy(result, fmt); buf = RSTRING_PTR(result); memset(buf, 0, bsiz); ENC_CODERANGE_SET(result, coderange); for (; p < end; p++) { const char *t; int n; VALUE sym = Qnil; for (t = p; t < end && *t != '%'; t++) ; PUSH(p, t - p); if (coderange != ENC_CODERANGE_BROKEN && scanned < blen) { scanned += rb_str_coderange_scan_restartable(buf+scanned, buf+blen, enc, &coderange); ENC_CODERANGE_SET(result, coderange); } if (t >= end) { /* end of fmt string */ goto sprint_exit; } p = t + 1; /* skip `%' */ width = prec = -1; nextvalue = Qundef; retry: switch (*p) { default: if (rb_enc_isprint(*p, enc)) rb_raise(rb_eArgError, "malformed format string - %%%c", *p); else rb_raise(rb_eArgError, "malformed format string"); break; case ' ': CHECK_FOR_FLAGS(flags); flags |= FSPACE; p++; goto retry; case '#': CHECK_FOR_FLAGS(flags); flags |= FSHARP; p++; goto retry; case '+': CHECK_FOR_FLAGS(flags); flags |= FPLUS; p++; goto retry; case '-': CHECK_FOR_FLAGS(flags); flags |= FMINUS; p++; goto retry; case '0': CHECK_FOR_FLAGS(flags); flags |= FZERO; p++; goto retry; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': n = 0; GETNUM(n, width); if (*p == '$') { if (nextvalue != Qundef) { rb_raise(rb_eArgError, "value given twice - %d$", n); } nextvalue = GETPOSARG(n); p++; goto retry; } CHECK_FOR_WIDTH(flags); width = n; flags |= FWIDTH; goto retry; case '<': case '{': { const char *start = p; char term = (*p == '<') ? '>' : '}'; int len; for (; p < end && *p != term; ) { p += rb_enc_mbclen(p, end, enc); } if (p >= end) { rb_raise(rb_eArgError, "malformed name - unmatched parenthesis"); } #if SIZEOF_INT < SIZEOF_SIZE_T if ((size_t)(p - start) >= INT_MAX) { const int message_limit = 20; len = (int)(rb_enc_right_char_head(start, start + message_limit, p, enc) - start); rb_enc_raise(enc, rb_eArgError, "too long name (%"PRIdSIZE" bytes) - %.*s...%c", (size_t)(p - start - 2), len, start, term); } #endif len = (int)(p - start + 1); /* including parenthesis */ if (sym != Qnil) { rb_enc_raise(enc, rb_eArgError, "named%.*s after <%"PRIsVALUE">", len, start, rb_sym2str(sym)); } CHECKNAMEARG(start, len, enc); get_hash(&hash, argc, argv); sym = rb_check_symbol_cstr(start + 1, len - 2 /* without parenthesis */, enc); if (sym != Qnil) nextvalue = rb_hash_lookup2(hash, sym, Qundef); if (nextvalue == Qundef) { rb_enc_raise(enc, rb_eKeyError, "key%.*s not found", len, start); } if (term == '}') goto format_s; p++; goto retry; } case '*': CHECK_FOR_WIDTH(flags); flags |= FWIDTH; GETASTER(width); if (width < 0) { flags |= FMINUS; width = -width; } p++; goto retry; case '.': if (flags & FPREC0) { rb_raise(rb_eArgError, "precision given twice"); } flags |= FPREC|FPREC0; prec = 0; p++; if (*p == '*') { GETASTER(prec); if (prec < 0) { /* ignore negative precision */ flags &= ~FPREC; } p++; goto retry; } GETNUM(prec, precision); goto retry; case '\n': case '\0': p--; case '%': if (flags != FNONE) { rb_raise(rb_eArgError, "invalid format character - %%"); } PUSH("%", 1); break; case 'c': { VALUE val = GETARG(); VALUE tmp; unsigned int c; int n; tmp = rb_check_string_type(val); if (!NIL_P(tmp)) { if (rb_enc_strlen(RSTRING_PTR(tmp),RSTRING_END(tmp),enc) != 1) { rb_raise(rb_eArgError, "%%c requires a character"); } c = rb_enc_codepoint_len(RSTRING_PTR(tmp), RSTRING_END(tmp), &n, enc); RB_GC_GUARD(tmp); } else { c = NUM2INT(val); n = rb_enc_codelen(c, enc); } if (n <= 0) { rb_raise(rb_eArgError, "invalid character"); } if (!(flags & FWIDTH)) { CHECK(n); rb_enc_mbcput(c, &buf[blen], enc); blen += n; } else if ((flags & FMINUS)) { CHECK(n); rb_enc_mbcput(c, &buf[blen], enc); blen += n; FILL(' ', width-1); } else { FILL(' ', width-1); CHECK(n); rb_enc_mbcput(c, &buf[blen], enc); blen += n; } } break; case 's': case 'p': format_s: { VALUE arg = GETARG(); long len, slen; if (*p == 'p') arg = rb_inspect(arg); str = rb_obj_as_string(arg); if (OBJ_TAINTED(str)) tainted = 1; len = RSTRING_LEN(str); rb_str_set_len(result, blen); if (coderange != ENC_CODERANGE_BROKEN && scanned < blen) { int cr = coderange; scanned += rb_str_coderange_scan_restartable(buf+scanned, buf+blen, enc, &cr); ENC_CODERANGE_SET(result, (cr == ENC_CODERANGE_UNKNOWN ? ENC_CODERANGE_BROKEN : (coderange = cr))); } enc = rb_enc_check(result, str); if (flags&(FPREC|FWIDTH)) { slen = rb_enc_strlen(RSTRING_PTR(str),RSTRING_END(str),enc); if (slen < 0) { rb_raise(rb_eArgError, "invalid mbstring sequence"); } if ((flags&FPREC) && (prec < slen)) { char *p = rb_enc_nth(RSTRING_PTR(str), RSTRING_END(str), prec, enc); slen = prec; len = p - RSTRING_PTR(str); } /* need to adjust multi-byte string pos */ if ((flags&FWIDTH) && (width > slen)) { width -= (int)slen; if (!(flags&FMINUS)) { CHECK(width); while (width--) { buf[blen++] = ' '; } } CHECK(len); memcpy(&buf[blen], RSTRING_PTR(str), len); RB_GC_GUARD(str); blen += len; if (flags&FMINUS) { CHECK(width); while (width--) { buf[blen++] = ' '; } } rb_enc_associate(result, enc); break; } } PUSH(RSTRING_PTR(str), len); RB_GC_GUARD(str); rb_enc_associate(result, enc); } break; case 'd': case 'i': case 'o': case 'x': case 'X': case 'b': case 'B': case 'u': { volatile VALUE val = GETARG(); int valsign; char nbuf[64], *s; const char *prefix = 0; int sign = 0, dots = 0; char sc = 0; long v = 0; int base, bignum = 0; int len; switch (*p) { case 'd': case 'i': case 'u': sign = 1; break; case 'o': case 'x': case 'X': case 'b': case 'B': if (flags&(FPLUS|FSPACE)) sign = 1; break; } if (flags & FSHARP) { switch (*p) { case 'o': prefix = "0"; break; case 'x': prefix = "0x"; break; case 'X': prefix = "0X"; break; case 'b': prefix = "0b"; break; case 'B': prefix = "0B"; break; } } bin_retry: switch (TYPE(val)) { case T_FLOAT: if (FIXABLE(RFLOAT_VALUE(val))) { val = LONG2FIX((long)RFLOAT_VALUE(val)); goto bin_retry; } val = rb_dbl2big(RFLOAT_VALUE(val)); if (FIXNUM_P(val)) goto bin_retry; bignum = 1; break; case T_STRING: val = rb_str_to_inum(val, 0, TRUE); goto bin_retry; case T_BIGNUM: bignum = 1; break; case T_FIXNUM: v = FIX2LONG(val); break; default: val = rb_Integer(val); goto bin_retry; } switch (*p) { case 'o': base = 8; break; case 'x': case 'X': base = 16; break; case 'b': case 'B': base = 2; break; case 'u': case 'd': case 'i': default: base = 10; break; } if (base != 10) { int numbits = ffs(base)-1; size_t abs_nlz_bits; size_t numdigits = rb_absint_numwords(val, numbits, &abs_nlz_bits); long i; if (INT_MAX-1 < numdigits) /* INT_MAX is used because rb_long2int is used later. */ rb_raise(rb_eArgError, "size too big"); if (sign) { if (numdigits == 0) numdigits = 1; tmp = rb_str_new(NULL, numdigits); valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp), 1, CHAR_BIT-numbits, INTEGER_PACK_BIG_ENDIAN); for (i = 0; i < RSTRING_LEN(tmp); i++) RSTRING_PTR(tmp)[i] = ruby_digitmap[((unsigned char *)RSTRING_PTR(tmp))[i]]; s = RSTRING_PTR(tmp); if (valsign < 0) { sc = '-'; width--; } else if (flags & FPLUS) { sc = '+'; width--; } else if (flags & FSPACE) { sc = ' '; width--; } } else { /* Following conditional "numdigits++" guarantees the * most significant digit as * - '1'(bin), '7'(oct) or 'f'(hex) for negative numbers * - '0' for zero * - not '0' for positive numbers. * * It also guarantees the most significant two * digits will not be '11'(bin), '77'(oct), 'ff'(hex) * or '00'. */ if (numdigits == 0 || ((abs_nlz_bits != (size_t)(numbits-1) || !rb_absint_singlebit_p(val)) && (!bignum ? v < 0 : BIGNUM_NEGATIVE_P(val)))) numdigits++; tmp = rb_str_new(NULL, numdigits); valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp), 1, CHAR_BIT-numbits, INTEGER_PACK_2COMP | INTEGER_PACK_BIG_ENDIAN); for (i = 0; i < RSTRING_LEN(tmp); i++) RSTRING_PTR(tmp)[i] = ruby_digitmap[((unsigned char *)RSTRING_PTR(tmp))[i]]; s = RSTRING_PTR(tmp); dots = valsign < 0; } len = rb_long2int(RSTRING_END(tmp) - s); } else if (!bignum) { valsign = 1; if (v < 0) { v = -v; sc = '-'; width--; valsign = -1; } else if (flags & FPLUS) { sc = '+'; width--; } else if (flags & FSPACE) { sc = ' '; width--; } snprintf(nbuf, sizeof(nbuf), "%ld", v); s = nbuf; len = (int)strlen(s); } else { tmp = rb_big2str(val, 10); s = RSTRING_PTR(tmp); valsign = 1; if (s[0] == '-') { s++; sc = '-'; width--; valsign = -1; } else if (flags & FPLUS) { sc = '+'; width--; } else if (flags & FSPACE) { sc = ' '; width--; } len = rb_long2int(RSTRING_END(tmp) - s); } if (dots) { prec -= 2; width -= 2; } if (*p == 'X') { char *pp = s; int c; while ((c = (int)(unsigned char)*pp) != 0) { *pp = rb_enc_toupper(c, enc); pp++; } } if (prefix && !prefix[1]) { /* octal */ if (dots) { prefix = 0; } else if (len == 1 && *s == '0') { len = 0; if (flags & FPREC) prec--; } else if ((flags & FPREC) && (prec > len)) { prefix = 0; } } else if (len == 1 && *s == '0') { prefix = 0; } if (prefix) { width -= (int)strlen(prefix); } if ((flags & (FZERO|FMINUS|FPREC)) == FZERO) { prec = width; width = 0; } else { if (prec < len) { if (!prefix && prec == 0 && len == 1 && *s == '0') len = 0; prec = len; } width -= prec; } if (!(flags&FMINUS)) { CHECK(width); while (width-- > 0) { buf[blen++] = ' '; } } if (sc) PUSH(&sc, 1); if (prefix) { int plen = (int)strlen(prefix); PUSH(prefix, plen); } CHECK(prec - len); if (dots) PUSH("..", 2); if (!sign && valsign < 0) { char c = sign_bits(base, p); while (len < prec--) { buf[blen++] = c; } } else if ((flags & (FMINUS|FPREC)) != FMINUS) { while (len < prec--) { buf[blen++] = '0'; } } PUSH(s, len); RB_GC_GUARD(tmp); CHECK(width); while (width-- > 0) { buf[blen++] = ' '; } } break; case 'f': { VALUE val = GETARG(), num, den; int sign = (flags&FPLUS) ? 1 : 0, zero = 0; long len, done = 0; int prefix = 0; if (!RB_TYPE_P(val, T_RATIONAL)) { nextvalue = val; goto float_value; } if (!(flags&FPREC)) prec = default_float_precision; den = rb_rational_den(val); num = rb_rational_num(val); if (FIXNUM_P(num)) { if ((SIGNED_VALUE)num < 0) { long n = -FIX2LONG(num); num = LONG2FIX(n); sign = -1; } } else if (rb_num_negative_p(num)) { sign = -1; num = rb_funcallv(num, idUMinus, 0, 0); } if (den != INT2FIX(1) || prec > 1) { const ID idDiv = rb_intern("div"); VALUE p10 = rb_int_positive_pow(10, prec); VALUE den_2 = rb_funcall(den, idDiv, 1, INT2FIX(2)); num = rb_funcallv(num, '*', 1, &p10); num = rb_funcallv(num, '+', 1, &den_2); num = rb_funcallv(num, idDiv, 1, &den); } else if (prec >= 0) { zero = prec; } val = rb_obj_as_string(num); len = RSTRING_LEN(val) + zero; if (prec >= len) ++len; /* integer part 0 */ if (sign || (flags&FSPACE)) ++len; if (prec > 0) ++len; /* period */ CHECK(len > width ? len : width); if (sign || (flags&FSPACE)) { buf[blen++] = sign > 0 ? '+' : sign < 0 ? '-' : ' '; prefix++; done++; } len = RSTRING_LEN(val) + zero; t = RSTRING_PTR(val); if (len > prec) { memcpy(&buf[blen], t, len - prec); blen += len - prec; done += len - prec; } else { buf[blen++] = '0'; done++; } if (prec > 0) { buf[blen++] = '.'; done++; } if (zero) { FILL('0', zero); done += zero; } else if (prec > len) { FILL('0', prec - len); memcpy(&buf[blen], t, len); blen += len; done += prec; } else if (prec > 0) { memcpy(&buf[blen], t + len - prec, prec); blen += prec; done += prec; } if ((flags & FWIDTH) && width > done) { int fill = ' '; long shifting = 0; if (!(flags&FMINUS)) { shifting = done; if (flags&FZERO) { shifting -= prefix; fill = '0'; } blen -= shifting; memmove(&buf[blen + width - done], &buf[blen], shifting); } FILL(fill, width - done); blen += shifting; } RB_GC_GUARD(val); break; } case 'g': case 'G': case 'e': case 'E': /* TODO: rational support */ case 'a': case 'A': float_value: { VALUE val = GETARG(); double fval; int i, need; char fbuf[32]; fval = RFLOAT_VALUE(rb_Float(val)); if (isnan(fval) || isinf(fval)) { const char *expr; if (isnan(fval)) { expr = "NaN"; } else { expr = "Inf"; } need = (int)strlen(expr); if ((!isnan(fval) && fval < 0.0) || (flags & FPLUS)) need++; if ((flags & FWIDTH) && need < width) need = width; CHECK(need + 1); snprintf(&buf[blen], need + 1, "%*s", need, ""); if (flags & FMINUS) { if (!isnan(fval) && fval < 0.0) buf[blen++] = '-'; else if (flags & FPLUS) buf[blen++] = '+'; else if (flags & FSPACE) blen++; memcpy(&buf[blen], expr, strlen(expr)); } else { if (!isnan(fval) && fval < 0.0) buf[blen + need - strlen(expr) - 1] = '-'; else if (flags & FPLUS) buf[blen + need - strlen(expr) - 1] = '+'; else if ((flags & FSPACE) && need > width) blen++; memcpy(&buf[blen + need - strlen(expr)], expr, strlen(expr)); } blen += strlen(&buf[blen]); break; } fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec); need = 0; if (*p != 'e' && *p != 'E') { i = INT_MIN; frexp(fval, &i); if (i > 0) need = BIT_DIGITS(i); } need += (flags&FPREC) ? prec : default_float_precision; if ((flags&FWIDTH) && need < width) need = width; need += 20; CHECK(need); snprintf(&buf[blen], need, fbuf, fval); blen += strlen(&buf[blen]); } break; } flags = FNONE; } sprint_exit: RB_GC_GUARD(fmt); /* XXX - We cannot validate the number of arguments if (digit)$ style used. */ if (posarg >= 0 && nextarg < argc) { const char *mesg = "too many arguments for format string"; if (RTEST(ruby_debug)) rb_raise(rb_eArgError, "%s", mesg); if (RTEST(ruby_verbose)) rb_warn("%s", mesg); } rb_str_resize(result, blen); if (tainted) OBJ_TAINT(result); return result; }