/*---------------------------------------------------------------------------*/ int rpl_set_prefix(rpl_dag_t *dag, uip_ipaddr_t *prefix, unsigned len) { rpl_prefix_t last_prefix; uint8_t last_len = dag->prefix_info.length; if(len > 128) { return 0; } if(dag->prefix_info.length != 0) { memcpy(&last_prefix, &dag->prefix_info, sizeof(rpl_prefix_t)); } memset(&dag->prefix_info.prefix, 0, sizeof(dag->prefix_info.prefix)); memcpy(&dag->prefix_info.prefix, prefix, (len + 7) / 8); dag->prefix_info.length = len; dag->prefix_info.flags = UIP_ND6_RA_FLAG_AUTONOMOUS; PRINTF("RPL: Prefix set - will announce this in DIOs\n"); if(dag->rank != ROOT_RANK(dag->instance)) { /* Autoconfigure an address if this node does not already have an address with this prefix. Otherwise, update the prefix */ if(last_len == 0) { PRINTF("rpl_set_prefix - prefix NULL\n"); check_prefix(NULL, &dag->prefix_info); } else { PRINTF("rpl_set_prefix - prefix NON-NULL\n"); check_prefix(&last_prefix, &dag->prefix_info); } } return 1; }
static int read_map(avro_reader_t reader, const avro_encoding_t * enc, avro_consumer_t *consumer, void *ud) { int rval; int64_t i; /* index within the current block */ int64_t index = 0; /* index within the entire array */ int64_t block_count; int64_t block_size; check_prefix(rval, enc->read_long(reader, &block_count), "Cannot read map block count: "); check(rval, avro_consumer_call(consumer, map_start_block, 1, block_count, ud)); while (block_count != 0) { if (block_count < 0) { block_count = block_count * -1; check_prefix(rval, enc->read_long(reader, &block_size), "Cannot read map block size: "); } for (i = 0; i < block_count; i++, index++) { char *key; int64_t key_size; avro_consumer_t *element_consumer = NULL; void *element_ud = NULL; check_prefix(rval, enc->read_string(reader, &key, &key_size), "Cannot read map key: "); rval = avro_consumer_call(consumer, map_element, index, key, &element_consumer, &element_ud, ud); if (rval) { avro_free(key, key_size); return rval; } rval = avro_consume_binary(reader, element_consumer, element_ud); if (rval) { avro_free(key, key_size); return rval; } avro_free(key, key_size); } check_prefix(rval, enc->read_long(reader, &block_count), "Cannot read map block count: "); check(rval, avro_consumer_call(consumer, map_start_block, 0, block_count, ud)); } return 0; }
static int check_filenames(git_patch_parsed *patch) { const char *prefixed_new, *prefixed_old; size_t old_prefixlen = 0, new_prefixlen = 0; bool added = (patch->base.delta->status == GIT_DELTA_ADDED); bool deleted = (patch->base.delta->status == GIT_DELTA_DELETED); if (patch->old_path && !patch->new_path) return git_parse_err("missing new path"); if (!patch->old_path && patch->new_path) return git_parse_err("missing old path"); /* Ensure (non-renamed) paths match */ if (check_header_names( patch->header_old_path, patch->old_path, "old", added) < 0 || check_header_names( patch->header_new_path, patch->new_path, "new", deleted) < 0) return -1; prefixed_old = (!added && patch->old_path) ? patch->old_path : patch->header_old_path; prefixed_new = (!deleted && patch->new_path) ? patch->new_path : patch->header_new_path; if (check_prefix( &patch->old_prefix, &old_prefixlen, patch, prefixed_old) < 0 || check_prefix( &patch->new_prefix, &new_prefixlen, patch, prefixed_new) < 0) return -1; /* Prefer the rename filenames as they are unambiguous and unprefixed */ if (patch->rename_old_path) patch->base.delta->old_file.path = patch->rename_old_path; else patch->base.delta->old_file.path = prefixed_old + old_prefixlen; if (patch->rename_new_path) patch->base.delta->new_file.path = patch->rename_new_path; else patch->base.delta->new_file.path = prefixed_new + new_prefixlen; if (!patch->base.delta->old_file.path && !patch->base.delta->new_file.path) return git_parse_err("git diff header lacks old / new paths"); return 0; }
/** * Searches for a value in the ART tree * @arg t The tree * @arg key The key * @arg key_len The length of the key * @return NULL if the item was not found, otherwise * the value pointer is returned. */ void* art_search(const art_tree *t, const unsigned char *key, int key_len) { art_node **child; art_node *n = t->root; int prefix_len, depth = 0; while (n) { // Might be a leaf if (IS_LEAF(n)) { n = (art_node*)LEAF_RAW(n); // Check if the expanded path matches if (!leaf_matches((art_leaf*)n, key, key_len, depth)) { return ((art_leaf*)n)->value; } return NULL; } // Bail if the prefix does not match if (n->partial_len) { prefix_len = check_prefix(n, key, key_len, depth); if (prefix_len != min(MAX_PREFIX_LEN, n->partial_len)) return NULL; depth = depth + n->partial_len; } // Recursively search child = find_child(n, key[depth]); n = (child) ? *child : NULL; depth++; } return NULL; }
static int read_array(avro_reader_t reader, const avro_encoding_t * enc, avro_consumer_t *consumer, void *ud) { int rval; int64_t i; /* index within the current block */ int64_t index = 0; /* index within the entire array */ int64_t block_count; int64_t block_size; check_prefix(rval, enc->read_long(reader, &block_count), "Cannot read array block count: "); check(rval, avro_consumer_call(consumer, array_start_block, 1, block_count, ud)); while (block_count != 0) { if (block_count < 0) { block_count = block_count * -1; check_prefix(rval, enc->read_long(reader, &block_size), "Cannot read array block size: "); } for (i = 0; i < block_count; i++, index++) { avro_consumer_t *element_consumer = NULL; void *element_ud = NULL; check(rval, avro_consumer_call(consumer, array_element, index, &element_consumer, &element_ud, ud)); check(rval, avro_consume_binary(reader, element_consumer, element_ud)); } check_prefix(rval, enc->read_long(reader, &block_count), "Cannot read array block count: "); check(rval, avro_consumer_call(consumer, array_start_block, 0, block_count, ud)); } return 0; }
/** * Convert mime string to media type constants value */ static javacall_media_type javautil_media_mime_to_type(const javacall_utf16* mime, long length) { javacall_media_type ret = JAVACALL_END_OF_TYPE; char* cMime = MALLOC(length + 1); if (cMime) { int wres = WideCharToMultiByte(CP_ACP, 0, mime, length, cMime, length + 1, NULL, NULL); if (0 != wres) { cMime[length] = 0; JAVA_DEBUG_PRINT1("javautil_media_mime_to_type %s\n", cMime); if (0 == strcmp(JAVACALL_AUDIO_MIDI_MIME, cMime)) { ret = JAVACALL_AUDIO_MIDI; } else if (0 == strcmp(JAVACALL_AUDIO_MIDI_MIME_2, cMime)) { ret = JAVACALL_AUDIO_MIDI; } else if (0 == strcmp(JAVACALL_AUDIO_SP_MIDI_MIME, cMime)) { ret = JAVACALL_AUDIO_MIDI; } else if (0 == strcmp(JAVACALL_AUDIO_WAV_MIME, cMime)) { ret = JAVACALL_AUDIO_WAV; } else if (0 == strcmp(JAVACALL_AUDIO_MP3_MIME, cMime)) { ret = JAVACALL_AUDIO_MP3; } else if (0 == strcmp(JAVACALL_AUDIO_TONE_MIME, cMime)) { ret = JAVACALL_AUDIO_TONE; } else if (0 == strcmp(JAVACALL_DEVICE_TONE_MIME, cMime)) { ret = JAVACALL_AUDIO_TONE; } else if (0 == strcmp(JAVACALL_DEVICE_MIDI_MIME, cMime)) { ret = JAVACALL_INTERACTIVE_MIDI; } else if (0 == strcmp(JAVACALL_VIDEO_MPEG4_MIME_2, cMime)) { ret = JAVACALL_VIDEO_MPEG4; } else if (0 == check_prefix(JAVACALL_CAPTURE_VIDEO_MIME, cMime)) { ret = JAVACALL_CAPTURE_VIDEO; } else if (0 == check_prefix(JAVACALL_CAPTURE_AUDIO_MIME, cMime)) { ret = JAVACALL_CAPTURE_AUDIO; } } FREE(cMime); } return ret; }
static int read_enum(avro_reader_t reader, const avro_encoding_t * enc, avro_consumer_t *consumer, void *ud) { int rval; int64_t index; check_prefix(rval, enc->read_long(reader, &index), "Cannot read enum value: "); return avro_consumer_call(consumer, enum_value, index, ud); }
/** * Handle syscalls that take a path as the first parameter */ static void _handle_file_series_syscalls(pid_t pid, char* syscall, int flag, uid_t uid, gid_t gid) { // TODO tracee_ptr_t path_ptr = (tracee_ptr_t) ptrace_get_syscall_arg(pid, 0); int len = ptrace_strlen(pid, path_ptr); char path[len + 1]; ptrace_read_data(pid, path, path_ptr, len + 1); #if 0 int nth_dir; if ((flag & SANDBOX_CHROOT_PRIVATE_FOLDER) && (nth_dir = check_prefix_dir(path,SANDBOX_PATH_INTERNAL)) > 0) { //internal file storage sandbox char* sub_dir = get_nth_dir(path, nth_dir + 2); if (!check_prefix(sub_dir, SANDBOX_PATH_INTERNAL_EXCLUDE)) { char new_path[len + 1]; //replace dir in path with LINK_PREFIX char* second_dir = get_nth_dir(path, nth_dir + 1); strcpy(new_path, SANDBOX_LINK); strcat(new_path, second_dir); ptrace_write_data(pid, new_path, path_ptr, len + 1); // create require folder create_nth_dir(new_path, 3, uid, gid, 0751); LOGD("pid %d %s: %s ==> new path: %s", pid, syscall, path, new_path); // return from open syscall, reset the path pid = waitpid(pid, NULL, __WALL); ptrace_write_data(pid, path, path_ptr, len + 1); long result = ptrace_get_syscall_arg(pid, 0); LOGD(" = %ld\n", result); return; } /* } else if ((flag & SANDBOX_FLAG) && FILE_SANDBOX_ENABLED && (nth_dir = check_prefix_dir(path,SANDBOX_PATH_EXTERNAL)) > 0) { */ /* //external file storage sandbox */ /* char new_path[len + 1]; */ /* //replace dir in path with LINK_PREFIX */ /* char* second_dir = get_nth_dir(path, nth_dir + 1); */ /* strcpy(new_path, SANDBOX_LINK); */ /* strcat(new_path, second_dir); */ /* ptrace_write_data(pid, new_path, arg0, len + 1); */ /* LOGD("pid %d %s: %s\n ==> new path: %s\n", pid, syscall, path, new_path); */ /* // return from open syscall, reset the path */ /* pid = waitpid(pid, NULL, __WALL); */ /* ptrace_write_data(pid, path, arg0, len + 1); */ /* return; */ } #endif LOGD("[%d] %s(%s, ...)\n", pid, syscall, path); }
int heim_digest_parse_challenge(heim_digest_t context, const char *challenge) { struct md5_value *val = NULL; int ret, type; challenge = check_prefix(context, challenge); ret = parse_values(challenge, &val); if (ret) goto out; ret = 1; context->serverNonce = values_find(&val, "nonce"); if (context->serverNonce == NULL) goto out; context->serverRealm = values_find(&val, "realm"); if (context->serverRealm == NULL) goto out; /* check alg */ context->serverAlgorithm = values_find(&val, "algorithm"); if (context->serverAlgorithm == NULL || strcasecmp(context->serverAlgorithm, "md5") == 0) { type = HEIM_DIGEST_TYPE_RFC2617_MD5; } else if (strcasecmp(context->serverAlgorithm, "md5-sess") == 0) { type = HEIM_DIGEST_TYPE_RFC2617_OR_RFC2831; } else { goto out; } context->serverQOP = values_find(&val, "qop"); if (context->serverQOP == NULL) type = HEIM_DIGEST_TYPE_RFC2069; context->serverOpaque = values_find(&val, "opaque"); if (context->type != HEIM_DIGEST_TYPE_AUTO && (context->type & type) == 0) goto out; else if (context->type == HEIM_DIGEST_TYPE_AUTO) context->type = type; ret = 0; out: free_values(val); if (ret) clear_context(context); return ret; }
static int dump_channels(const char *dev_dir_name) { DIR *dp; const struct dirent *ent; dp = opendir(dev_dir_name); if (!dp) return -errno; while (ent = readdir(dp), ent) if (check_prefix(ent->d_name, "in_") && check_postfix(ent->d_name, "_raw")) printf(" %-10s\n", ent->d_name); return (closedir(dp) == -1) ? -errno : 0; }
static int read_union(avro_reader_t reader, const avro_encoding_t * enc, avro_consumer_t *consumer, void *ud) { int rval; int64_t discriminant; avro_consumer_t *branch_consumer = NULL; void *branch_ud = NULL; check_prefix(rval, enc->read_long(reader, &discriminant), "Cannot read union discriminant: "); check(rval, avro_consumer_call(consumer, union_branch, discriminant, &branch_consumer, &branch_ud, ud)); return avro_consume_binary(reader, branch_consumer, branch_ud); }
/*---------------------------------------------------------------------------*/ int rpl_set_prefix(rpl_dag_t *dag, uip_ipaddr_t *prefix, unsigned len) { if(len > 128) { return 0; } memset(&dag->prefix_info.prefix, 0, sizeof(dag->prefix_info.prefix)); memcpy(&dag->prefix_info.prefix, prefix, (len + 7) / 8); dag->prefix_info.length = len; dag->prefix_info.flags = UIP_ND6_RA_FLAG_AUTONOMOUS; PRINTF("RPL: Prefix set - will announce this in DIOs\n"); /* Autoconfigure an address if this node does not already have an address with this prefix. */ check_prefix(NULL, &dag->prefix_info); return 1; }
bool simulator_symext::is_spurious( const predicatest &predicates, const abstract_modelt &abstract_model, abstract_counterexamplet &abstract_counterexample, concrete_counterexamplet &concrete_counterexample, fail_infot &fail_info) { status("Simulating abstract counterexample on concrete program"); #if 0 std::cout << "***********************************" << std::endl; std::cout << abstract_counterexample << std::endl; #endif if(path_slicing) { #if 0 // buggy right now status("Path slicing"); path_slicer( ns, abstract_model.goto_functions, abstract_counterexample); #endif } #if 0 std::cout << "***********************************" << std::endl; std::cout << abstract_counterexample << std::endl; std::cout << "***********************************" << std::endl; #endif if(!check_prefix( predicates, abstract_model, abstract_counterexample, concrete_counterexample, fail_info)) { status("Simulation successful"); return false; } return true; }
static art_leaf* recursive_delete(art_node *n, art_node **ref, const unsigned char *key, int key_len, int depth) { // Search terminated if (!n) return NULL; // Handle hitting a leaf node if (IS_LEAF(n)) { art_leaf *l = LEAF_RAW(n); if (!leaf_matches(l, key, key_len, depth)) { *ref = NULL; return l; } return NULL; } // Bail if the prefix does not match if (n->partial_len) { int prefix_len = check_prefix(n, key, key_len, depth); if (prefix_len != min(MAX_PREFIX_LEN, n->partial_len)) { return NULL; } depth = depth + n->partial_len; } // Find child node art_node **child = find_child(n, key[depth]); if (!child) return NULL; // If the child is leaf, delete from this node if (IS_LEAF(*child)) { art_leaf *l = LEAF_RAW(*child); if (!leaf_matches(l, key, key_len, depth)) { remove_child(n, ref, key[depth], child); return l; } return NULL; // Recurse } else { return recursive_delete(*child, child, key, key_len, depth+1); } }
/*---------------------------------------------------------------------------*/ void rpl_free_dag(rpl_dag_t *dag) { if(dag->joined) { PRINTF("RPL: Leaving the DAG "); PRINT6ADDR(&dag->dag_id); PRINTF("\n"); dag->joined = 0; /* Remove routes installed by DAOs. */ rpl_remove_routes(dag); /* Remove autoconfigured address */ if((dag->prefix_info.flags & UIP_ND6_RA_FLAG_AUTONOMOUS)) { check_prefix(&dag->prefix_info, NULL); } remove_parents(dag, 0); } dag->used = 0; }
gboolean nms_keyfile_utils_should_ignore_file (const char *filename) { gs_free char *base = NULL; g_return_val_if_fail (filename != NULL, TRUE); base = g_path_get_basename (filename); g_return_val_if_fail (base != NULL, TRUE); /* Ignore hidden and backup files */ /* should_ignore_file() must mirror escape_filename() */ if (check_prefix (base, ".") || check_suffix (base, "~")) return TRUE; /* Ignore temporary files */ if (check_mkstemp_suffix (base)) return TRUE; /* Ignore 802.1x certificates and keys */ if (check_suffix (base, PEM_TAG) || check_suffix (base, DER_TAG)) return TRUE; return FALSE; }
/*---------------------------------------------------------------------------*/ void rpl_free_dag(rpl_dag_t *dag) { if(dag->joined) { PRINTF("RPL: Leaving the DAG "); PRINT6ADDR(&dag->dag_id); PRINTF("\n"); dag->joined = 0; /* Remove routes installed by DAOs. */ rpl_remove_routes(dag); /* TODO: Should probably be another option for PREFIX handling in RPL */ #if !CONF_6LOWPAN_ND /* Remove autoconfigured address */ if((dag->prefix_info.flags & UIP_ND6_RA_FLAG_AUTONOMOUS)) { check_prefix(&dag->prefix_info, NULL); } #endif /* !CONF_6LOWPAN_ND */ remove_parents(dag, 0); } dag->used = 0; }
char * nms_keyfile_utils_escape_filename (const char *filename) { GString *str; const char *f = filename; const char ESCAPE_CHAR = '*'; /* keyfile used to escape with '*', do not change that behavior. * But for newly added escapings, use '_' instead. */ const char ESCAPE_CHAR2 = '_'; g_return_val_if_fail (filename && filename[0], NULL); str = g_string_sized_new (60); /* Convert '/' to ESCAPE_CHAR */ for (f = filename; f[0]; f++) { if (f[0] == '/') g_string_append_c (str, ESCAPE_CHAR); else g_string_append_c (str, f[0]); } /* escape_filename() must avoid anything that should_ignore_file() would reject. * We can escape here more aggressivly then what we would read back. */ if (check_prefix (str->str, ".")) str->str[0] = ESCAPE_CHAR2; if (check_suffix (str->str, "~")) str->str[str->len - 1] = ESCAPE_CHAR2; if ( check_mkstemp_suffix (str->str) || check_suffix (str->str, PEM_TAG) || check_suffix (str->str, DER_TAG)) g_string_append_c (str, ESCAPE_CHAR2); return g_string_free (str, FALSE);; }
/*---------------------------------------------------------------------------*/ void rpl_join_instance(uip_ipaddr_t *from, rpl_dio_t *dio) { rpl_instance_t *instance; rpl_dag_t *dag; rpl_parent_t *p; rpl_of_t *of; dag = rpl_alloc_dag(dio->instance_id, &dio->dag_id); if(dag == NULL) { PRINTF("RPL: Failed to allocate a DAG object!\n"); return; } instance = dag->instance; p = rpl_add_parent(dag, dio, from); PRINTF("RPL: Adding "); PRINT6ADDR(from); PRINTF(" as a parent: "); if(p == NULL) { PRINTF("failed\n"); instance->used = 0; return; } p->dtsn = dio->dtsn; PRINTF("succeeded\n"); /* Determine the objective function by using the objective code point of the DIO. */ of = rpl_find_of(dio->ocp); if(of == NULL) { PRINTF("RPL: DIO for DAG instance %u does not specify a supported OF\n", dio->instance_id); rpl_remove_parent(p); instance->used = 0; return; } /* Autoconfigure an address if this node does not already have an address with this prefix. */ if(dio->prefix_info.flags & UIP_ND6_RA_FLAG_AUTONOMOUS) { check_prefix(NULL, &dio->prefix_info); } dag->joined = 1; dag->preference = dio->preference; dag->grounded = dio->grounded; dag->version = dio->version; instance->of = of; instance->mop = dio->mop; instance->current_dag = dag; instance->dtsn_out = RPL_LOLLIPOP_INIT; instance->max_rankinc = dio->dag_max_rankinc; instance->min_hoprankinc = dio->dag_min_hoprankinc; instance->dio_intdoubl = dio->dag_intdoubl; instance->dio_intmin = dio->dag_intmin; instance->dio_intcurrent = instance->dio_intmin + instance->dio_intdoubl; instance->dio_redundancy = dio->dag_redund; instance->default_lifetime = dio->default_lifetime; instance->lifetime_unit = dio->lifetime_unit; memcpy(&dag->dag_id, &dio->dag_id, sizeof(dio->dag_id)); /* Copy prefix information from the DIO into the DAG object. */ memcpy(&dag->prefix_info, &dio->prefix_info, sizeof(rpl_prefix_t)); rpl_set_preferred_parent(dag, p); instance->of->update_metric_container(instance); dag->rank = instance->of->calculate_rank(p, 0); /* So far this is the lowest rank we are aware of. */ dag->min_rank = dag->rank; if(default_instance == NULL) { default_instance = instance; } PRINTF("RPL: Joined DAG with instance ID %u, rank %hu, DAG ID ", dio->instance_id, dag->rank); PRINT6ADDR(&dag->dag_id); PRINTF("\n"); ANNOTATE("#A join=%u\n", dag->dag_id.u8[sizeof(dag->dag_id) - 1]); rpl_reset_dio_timer(instance); rpl_set_default_route(instance, from); if(instance->mop != RPL_MOP_NO_DOWNWARD_ROUTES) { rpl_schedule_dao(instance); } else { PRINTF("RPL: The DIO does not meet the prerequisites for sending a DAO\n"); } }
int main(int argc, char *argv[]) { int c; char *filename = NULL; char *outfile = NULL; FILE *fh; Stream *st; int config_checkprefix = 1; int config_basename = 0; int integrate_saturated = 0; IndexingMethod *indm; IndexingPrivate **ipriv; char *indm_str = NULL; char *cellfile = NULL; char *prefix = NULL; char *speaks = NULL; char *toler = NULL; int n_proc = 1; struct index_args iargs; char *intrad = NULL; char *pkrad = NULL; char *int_str = NULL; char *tempdir = NULL; char *int_diag = NULL; char *geom_filename = NULL; struct beam_params beam; int have_push_res = 0; /* Defaults */ iargs.cell = NULL; iargs.noisefilter = 0; iargs.median_filter = 0; iargs.satcorr = 1; iargs.tols[0] = 5.0; iargs.tols[1] = 5.0; iargs.tols[2] = 5.0; iargs.tols[3] = 1.5; iargs.threshold = 800.0; iargs.min_gradient = 100000.0; iargs.min_snr = 5.0; iargs.check_hdf5_snr = 0; iargs.det = NULL; iargs.peaks = PEAK_ZAEF; iargs.beam = &beam; iargs.hdf5_peak_path = NULL; iargs.copyme = NULL; iargs.pk_inn = -1.0; iargs.pk_mid = -1.0; iargs.pk_out = -1.0; iargs.ir_inn = 4.0; iargs.ir_mid = 5.0; iargs.ir_out = 7.0; iargs.use_saturated = 1; iargs.no_revalidate = 0; iargs.stream_peaks = 1; iargs.stream_refls = 1; iargs.int_diag = INTDIAG_NONE; iargs.copyme = new_copy_hdf5_field_list(); if ( iargs.copyme == NULL ) { ERROR("Couldn't allocate HDF5 field list.\n"); return 1; } iargs.indm = NULL; /* No default */ iargs.ipriv = NULL; /* No default */ iargs.int_meth = integration_method("rings-nocen", NULL); iargs.push_res = 0.0; iargs.highres = +INFINITY; iargs.fix_profile_r = -1.0; iargs.fix_bandwidth = -1.0; iargs.fix_divergence = -1.0; /* Long options */ const struct option longopts[] = { /* Options with long and short versions */ {"help", 0, NULL, 'h'}, {"version", 0, NULL, 'v'}, {"input", 1, NULL, 'i'}, {"output", 1, NULL, 'o'}, {"indexing", 1, NULL, 'z'}, {"geometry", 1, NULL, 'g'}, {"pdb", 1, NULL, 'p'}, {"prefix", 1, NULL, 'x'}, {"threshold", 1, NULL, 't'}, {"beam", 1, NULL, 'b'}, /* Long-only options with no arguments */ {"filter-noise", 0, &iargs.noisefilter, 1}, {"no-check-prefix", 0, &config_checkprefix, 0}, {"basename", 0, &config_basename, 1}, {"no-peaks-in-stream", 0, &iargs.stream_peaks, 0}, {"no-refls-in-stream", 0, &iargs.stream_refls, 0}, {"integrate-saturated",0, &integrate_saturated, 1}, {"no-use-saturated", 0, &iargs.use_saturated, 0}, {"no-revalidate", 0, &iargs.no_revalidate, 1}, {"check-hdf5-snr", 0, &iargs.check_hdf5_snr, 1}, /* Long-only options which don't actually do anything */ {"no-sat-corr", 0, &iargs.satcorr, 0}, {"sat-corr", 0, &iargs.satcorr, 1}, {"no-check-hdf5-snr", 0, &iargs.check_hdf5_snr, 0}, {"use-saturated", 0, &iargs.use_saturated, 1}, /* Long-only options with arguments */ {"peaks", 1, NULL, 2}, {"cell-reduction", 1, NULL, 3}, {"min-gradient", 1, NULL, 4}, {"record", 1, NULL, 5}, {"cpus", 1, NULL, 6}, {"cpugroup", 1, NULL, 7}, {"cpuoffset", 1, NULL, 8}, {"hdf5-peaks", 1, NULL, 9}, {"copy-hdf5-field", 1, NULL, 10}, {"min-snr", 1, NULL, 11}, {"tolerance", 1, NULL, 13}, {"int-radius", 1, NULL, 14}, {"median-filter", 1, NULL, 15}, {"integration", 1, NULL, 16}, {"temp-dir", 1, NULL, 17}, {"int-diag", 1, NULL, 18}, {"push-res", 1, NULL, 19}, {"res-push", 1, NULL, 19}, /* compat */ {"peak-radius", 1, NULL, 20}, {"highres", 1, NULL, 21}, {"fix-profile-radius", 1, NULL, 22}, {"fix-bandwidth", 1, NULL, 23}, {"fix-divergence", 1, NULL, 24}, {0, 0, NULL, 0} }; /* Short options */ while ((c = getopt_long(argc, argv, "hi:o:z:p:x:j:g:t:vb:", longopts, NULL)) != -1) { switch (c) { case 'h' : show_help(argv[0]); return 0; case 'v' : printf("CrystFEL: " CRYSTFEL_VERSIONSTRING "\n"); printf(CRYSTFEL_BOILERPLATE"\n"); return 0; case 'b' : ERROR("WARNING: This version of CrystFEL no longer " "uses beam files. Please remove the beam file " "from your indexamajig command line.\n"); return 1; case 'i' : filename = strdup(optarg); break; case 'o' : outfile = strdup(optarg); break; case 'z' : indm_str = strdup(optarg); break; case 'p' : cellfile = strdup(optarg); break; case 'x' : prefix = strdup(optarg); break; case 'j' : n_proc = atoi(optarg); break; case 'g' : geom_filename = optarg; break; case 't' : iargs.threshold = strtof(optarg, NULL); break; case 2 : speaks = strdup(optarg); break; case 3 : ERROR("The option '--cell-reduction' is no longer " "used.\n" "The complete indexing behaviour is now " "controlled using '--indexing'.\n" "See 'man indexamajig' for details of the " "available methods.\n"); return 1; case 4 : iargs.min_gradient = strtof(optarg, NULL); break; case 5 : ERROR("The option '--record' is no longer used.\n" "Use '--no-peaks-in-stream' and" "'--no-refls-in-stream' if you need to control" "the contents of the stream.\n"); return 1; case 6 : case 7 : case 8 : ERROR("The options --cpus, --cpugroup and --cpuoffset" " are no longer used by indexamajig.\n"); break; case 9 : free(iargs.hdf5_peak_path); iargs.hdf5_peak_path = strdup(optarg); break; case 10 : add_copy_hdf5_field(iargs.copyme, optarg); break; case 11 : iargs.min_snr = strtof(optarg, NULL); break; case 13 : toler = strdup(optarg); break; case 14 : intrad = strdup(optarg); break; case 15 : iargs.median_filter = atoi(optarg); break; case 16 : int_str = strdup(optarg); break; case 17 : tempdir = strdup(optarg); break; case 18 : int_diag = strdup(optarg); break; case 19 : if ( sscanf(optarg, "%f", &iargs.push_res) != 1 ) { ERROR("Invalid value for --push-res\n"); return 1; } iargs.push_res *= 1e9; /* nm^-1 -> m^-1 */ have_push_res = 1; break; case 20 : pkrad = strdup(optarg); break; case 21 : if ( sscanf(optarg, "%f", &iargs.highres) != 1 ) { ERROR("Invalid value for --highres\n"); return 1; } /* A -> m^-1 */ iargs.highres = 1.0 / (iargs.highres/1e10); break; case 22 : if ( sscanf(optarg, "%f", &iargs.fix_profile_r) != 1 ) { ERROR("Invalid value for " "--fix-profile-radius\n"); return 1; } break; case 23 : if ( sscanf(optarg, "%f", &iargs.fix_bandwidth) != 1 ) { ERROR("Invalid value for --fix-bandwidth\n"); return 1; } break; case 24 : if ( sscanf(optarg, "%f", &iargs.fix_divergence) != 1 ) { ERROR("Invalid value for --fix-divergence\n"); return 1; } break; case 0 : break; case '?' : break; default : ERROR("Unhandled option '%c'\n", c); break; } } if ( tempdir == NULL ) { tempdir = strdup("."); } if ( filename == NULL ) { filename = strdup("-"); } if ( strcmp(filename, "-") == 0 ) { fh = stdin; } else { fh = fopen(filename, "r"); } if ( fh == NULL ) { ERROR("Failed to open input file '%s'\n", filename); return 1; } free(filename); if ( speaks == NULL ) { speaks = strdup("zaef"); STATUS("You didn't specify a peak detection method.\n"); STATUS("I'm using 'zaef' for you.\n"); } if ( strcmp(speaks, "zaef") == 0 ) { iargs.peaks = PEAK_ZAEF; } else if ( strcmp(speaks, "hdf5") == 0 ) { iargs.peaks = PEAK_HDF5; } else if ( strcmp(speaks, "cxi") == 0 ) { iargs.peaks = PEAK_CXI; } else { ERROR("Unrecognised peak detection method '%s'\n", speaks); return 1; } free(speaks); /* Set default path for peaks, if appropriate */ if ( iargs.hdf5_peak_path == NULL ) { if ( iargs.peaks == PEAK_HDF5 ) { iargs.hdf5_peak_path = strdup("/processing/hitfinder/peakinfo"); } else if ( iargs.peaks == PEAK_CXI ) { iargs.hdf5_peak_path = strdup("/entry_1/result_1"); } } if ( prefix == NULL ) { prefix = strdup(""); } else { if ( config_checkprefix ) { prefix = check_prefix(prefix); } } if ( n_proc == 0 ) { ERROR("Invalid number of processes.\n"); return 1; } iargs.det = get_detector_geometry(geom_filename, iargs.beam); if ( iargs.det == NULL ) { ERROR("Failed to read detector geometry from '%s'\n", geom_filename); return 1; } if ( indm_str == NULL ) { STATUS("You didn't specify an indexing method, so I won't try " " to index anything.\n" "If that isn't what you wanted, re-run with" " --indexing=<methods>.\n"); indm = NULL; } else { indm = build_indexer_list(indm_str); if ( indm == NULL ) { ERROR("Invalid indexer list '%s'\n", indm_str); return 1; } free(indm_str); } if ( int_str != NULL ) { int err; iargs.int_meth = integration_method(int_str, &err); if ( err ) { ERROR("Invalid integration method '%s'\n", int_str); return 1; } free(int_str); } if ( integrate_saturated ) { /* Option provided for backwards compatibility */ iargs.int_meth |= INTEGRATION_SATURATED; } if ( have_push_res && !(iargs.int_meth & INTEGRATION_RESCUT) ) { ERROR("WARNING: You used --push-res, but not -rescut, " "therefore --push-res will have no effect.\n"); } if ( toler != NULL ) { int ttt; ttt = sscanf(toler, "%f,%f,%f,%f", &iargs.tols[0], &iargs.tols[1], &iargs.tols[2], &iargs.tols[3]); if ( ttt != 4 ) { ERROR("Invalid parameters for '--tolerance'\n"); return 1; } free(toler); } if ( intrad != NULL ) { int r; r = sscanf(intrad, "%f,%f,%f", &iargs.ir_inn, &iargs.ir_mid, &iargs.ir_out); if ( r != 3 ) { ERROR("Invalid parameters for '--int-radius'\n"); return 1; } free(intrad); } else { STATUS("WARNING: You did not specify --int-radius.\n"); STATUS("WARNING: I will use the default values, which are" " probably not appropriate for your patterns.\n"); } if ( pkrad != NULL ) { int r; r = sscanf(pkrad, "%f,%f,%f", &iargs.pk_inn, &iargs.pk_mid, &iargs.pk_out); if ( r != 3 ) { ERROR("Invalid parameters for '--peak-radius'\n"); return 1; } free(pkrad); } if ( iargs.pk_inn < 0.0 ) { iargs.pk_inn = iargs.ir_inn; iargs.pk_mid = iargs.ir_mid; iargs.pk_out = iargs.ir_out; } if ( iargs.det == NULL ) { ERROR("You need to provide a geometry file (please read the" " manual for more details).\n"); return 1; } add_geom_beam_stuff_to_copy_hdf5(iargs.copyme, iargs.det, iargs.beam); if ( cellfile != NULL ) { iargs.cell = load_cell_from_file(cellfile); if ( iargs.cell == NULL ) { ERROR("Couldn't read unit cell (from %s)\n", cellfile); return 1; } free(cellfile); STATUS("This is what I understood your unit cell to be:\n"); cell_print(iargs.cell); } else { STATUS("No unit cell given.\n"); iargs.cell = NULL; } if ( int_diag != NULL ) { int r; signed int h, k, l; if ( strcmp(int_diag, "random") == 0 ) { iargs.int_diag = INTDIAG_RANDOM; } if ( strcmp(int_diag, "all") == 0 ) { iargs.int_diag = INTDIAG_ALL; } if ( strcmp(int_diag, "negative") == 0 ) { iargs.int_diag = INTDIAG_NEGATIVE; } if ( strcmp(int_diag, "implausible") == 0 ) { iargs.int_diag = INTDIAG_IMPLAUSIBLE; } if ( strcmp(int_diag, "strong") == 0 ) { iargs.int_diag = INTDIAG_STRONG; } r = sscanf(int_diag, "%i,%i,%i", &h, &k, &l); if ( r == 3 ) { iargs.int_diag = INTDIAG_INDICES; iargs.int_diag_h = h; iargs.int_diag_k = k; iargs.int_diag_l = l; } if ( (iargs.int_diag == INTDIAG_NONE) && (strcmp(int_diag, "none") != 0) ) { ERROR("Invalid value for --int-diag.\n"); return 1; } free(int_diag); if ( (n_proc > 1) && (iargs.int_diag != INTDIAG_NONE) ) { n_proc = 1; STATUS("Ignored \"-j\" because you used --int-diag.\n"); } } st = open_stream_for_write_2(outfile, geom_filename, argc, argv); if ( st == NULL ) { ERROR("Failed to open stream '%s'\n", outfile); return 1; } free(outfile); /* Prepare the indexer */ if ( indm != NULL ) { ipriv = prepare_indexing(indm, iargs.cell, iargs.det, iargs.tols); if ( ipriv == NULL ) { ERROR("Failed to prepare indexing.\n"); return 1; } } else { ipriv = NULL; } gsl_set_error_handler_off(); iargs.indm = indm; iargs.ipriv = ipriv; create_sandbox(&iargs, n_proc, prefix, config_basename, fh, st, tempdir); free(prefix); free(tempdir); free_detector_geometry(iargs.det); close_stream(st); cleanup_indexing(indm, ipriv); return 0; }
static struct gpiochip_info *list_gpiochip(const char *gpiochip_name, int *ret) { struct gpiochip_info *cinfo; struct gpiochip_info *current; const struct dirent *ent; DIR *dp; char *chrdev_name; int fd; int i = 0; cinfo = calloc(sizeof(struct gpiochip_info) * 4, GC_NUM + 1); if (!cinfo) err(EXIT_FAILURE, "gpiochip_info allocation failed"); current = cinfo; dp = opendir("/dev"); if (!dp) { *ret = -errno; goto error_out; } else { *ret = 0; } while (ent = readdir(dp), ent) { if (check_prefix(ent->d_name, "gpiochip")) { *ret = asprintf(&chrdev_name, "/dev/%s", ent->d_name); if (*ret < 0) goto error_out; fd = open(chrdev_name, 0); if (fd == -1) { *ret = -errno; fprintf(stderr, "Failed to open %s\n", chrdev_name); goto error_close_dir; } *ret = ioctl(fd, GPIO_GET_CHIPINFO_IOCTL, current); if (*ret == -1) { perror("Failed to issue CHIPINFO IOCTL\n"); goto error_close_dir; } close(fd); if (strcmp(current->label, gpiochip_name) == 0 || check_prefix(current->label, gpiochip_name)) { *ret = 0; current++; i++; } } } if ((!*ret && i == 0) || *ret < 0) { free(cinfo); cinfo = NULL; } if (!*ret && i > 0) { cinfo = realloc(cinfo, sizeof(struct gpiochip_info) * 4 * i); *ret = i; } error_close_dir: closedir(dp); error_out: if (*ret < 0) err(EXIT_FAILURE, "list gpiochip failed: %s", strerror(*ret)); return cinfo; }
/*---------------------------------------------------------------------------*/ rpl_dag_t * rpl_select_dag(rpl_instance_t *instance, rpl_parent_t *p) { rpl_parent_t *last_parent; rpl_dag_t *dag, *end, *best_dag; rpl_rank_t old_rank; old_rank = instance->current_dag->rank; last_parent = instance->current_dag->preferred_parent; if(instance->current_dag->rank != ROOT_RANK(instance)) { rpl_select_parent(p->dag); } best_dag = NULL; for(dag = &instance->dag_table[0], end = dag + RPL_MAX_DAG_PER_INSTANCE; dag < end; ++dag) { if(dag->used && dag->preferred_parent != NULL && dag->preferred_parent->rank != INFINITE_RANK) { if(best_dag == NULL) { best_dag = dag; } else { best_dag = instance->of->best_dag(best_dag, dag); } } } if(best_dag == NULL) { /* No parent found: the calling function handle this problem. */ return NULL; } if(instance->current_dag != best_dag) { /* Remove routes installed by DAOs. */ rpl_remove_routes(instance->current_dag); PRINTF("RPL: New preferred DAG: "); PRINT6ADDR(&best_dag->dag_id); PRINTF("\n"); if(best_dag->prefix_info.flags & UIP_ND6_RA_FLAG_AUTONOMOUS) { check_prefix(&instance->current_dag->prefix_info, &best_dag->prefix_info); } else if(instance->current_dag->prefix_info.flags & UIP_ND6_RA_FLAG_AUTONOMOUS) { check_prefix(&instance->current_dag->prefix_info, NULL); } best_dag->joined = 1; instance->current_dag->joined = 0; instance->current_dag = best_dag; } instance->of->update_metric_container(instance); /* Update the DAG rank. */ best_dag->rank = instance->of->calculate_rank(best_dag->preferred_parent, 0); if(last_parent == NULL || best_dag->rank < best_dag->min_rank) { best_dag->min_rank = best_dag->rank; } else if(!acceptable_rank(best_dag, best_dag->rank)) { PRINTF("RPL: New rank unacceptable!\n"); rpl_set_preferred_parent(instance->current_dag, NULL); if(instance->mop != RPL_MOP_NO_DOWNWARD_ROUTES && last_parent != NULL) { /* Send a No-Path DAO to the removed preferred parent. */ dao_output(last_parent, RPL_ZERO_LIFETIME); } return NULL; } if(best_dag->preferred_parent != last_parent) { rpl_set_default_route(instance, rpl_get_parent_ipaddr(best_dag->preferred_parent)); PRINTF("RPL: Changed preferred parent, rank changed from %u to %u\n", (unsigned)old_rank, best_dag->rank); RPL_STAT(rpl_stats.parent_switch++); if(instance->mop != RPL_MOP_NO_DOWNWARD_ROUTES) { if(last_parent != NULL) { /* Send a No-Path DAO to the removed preferred parent. */ dao_output(last_parent, RPL_ZERO_LIFETIME); } /* The DAO parent set changed - schedule a DAO transmission. */ RPL_LOLLIPOP_INCREMENT(instance->dtsn_out); rpl_schedule_dao(instance); } rpl_reset_dio_timer(instance); #if DEBUG rpl_print_neighbor_list(); #endif } else if(best_dag->rank != old_rank) { PRINTF("RPL: Preferred parent update, rank changed from %u to %u\n", (unsigned)old_rank, best_dag->rank); } return best_dag; }
int avro_consume_binary(avro_reader_t reader, avro_consumer_t *consumer, void *ud) { int rval; const avro_encoding_t *enc = &avro_binary_encoding; check_param(EINVAL, reader, "reader"); check_param(EINVAL, consumer, "consumer"); switch (avro_typeof(consumer->schema)) { case AVRO_NULL: check_prefix(rval, enc->read_null(reader), "Cannot read null value: "); check(rval, avro_consumer_call(consumer, null_value, ud)); break; case AVRO_BOOLEAN: { int8_t b; check_prefix(rval, enc->read_boolean(reader, &b), "Cannot read boolean value: "); check(rval, avro_consumer_call(consumer, boolean_value, b, ud)); } break; case AVRO_STRING: { int64_t len; char *s; check_prefix(rval, enc->read_string(reader, &s, &len), "Cannot read string value: "); check(rval, avro_consumer_call(consumer, string_value, s, len, ud)); } break; case AVRO_INT32: { int32_t i; check_prefix(rval, enc->read_int(reader, &i), "Cannot read int value: "); check(rval, avro_consumer_call(consumer, int_value, i, ud)); } break; case AVRO_INT64: { int64_t l; check_prefix(rval, enc->read_long(reader, &l), "Cannot read long value: "); check(rval, avro_consumer_call(consumer, long_value, l, ud)); } break; case AVRO_FLOAT: { float f; check_prefix(rval, enc->read_float(reader, &f), "Cannot read float value: "); check(rval, avro_consumer_call(consumer, float_value, f, ud)); } break; case AVRO_DOUBLE: { double d; check_prefix(rval, enc->read_double(reader, &d), "Cannot read double value: "); check(rval, avro_consumer_call(consumer, double_value, d, ud)); } break; case AVRO_BYTES: { char *bytes; int64_t len; check_prefix(rval, enc->read_bytes(reader, &bytes, &len), "Cannot read bytes value: "); check(rval, avro_consumer_call(consumer, bytes_value, bytes, len, ud)); } break; case AVRO_FIXED: { char *bytes; int64_t size = avro_schema_to_fixed(consumer->schema)->size; bytes = avro_malloc(size); if (!bytes) { avro_prefix_error("Cannot allocate new fixed value"); return ENOMEM; } rval = avro_read(reader, bytes, size); if (rval) { avro_prefix_error("Cannot read fixed value: "); avro_free(bytes, size); return rval; } rval = avro_consumer_call(consumer, fixed_value, bytes, size, ud); if (rval) { avro_free(bytes, size); return rval; } } break; case AVRO_ENUM: check(rval, read_enum(reader, enc, consumer, ud)); break; case AVRO_ARRAY: check(rval, read_array(reader, enc, consumer, ud)); break; case AVRO_MAP: check(rval, read_map(reader, enc, consumer, ud)); break; case AVRO_UNION: check(rval, read_union(reader, enc, consumer, ud)); break; case AVRO_RECORD: check(rval, read_record(reader, enc, consumer, ud)); break; case AVRO_LINK: avro_set_error("Consumer can't consume a link schema directly"); return EINVAL; } return 0; }
int heim_digest_parse_response(heim_digest_t context, const char *response) { struct md5_value *val = NULL; char *nonce; int ret; response = check_prefix(context, response); ret = parse_values(response, &val); if (ret) goto out; ret = 1; if (context->type == HEIM_DIGEST_TYPE_AUTO) { goto out; } else if (context->type == HEIM_DIGEST_TYPE_RFC2617_OR_RFC2831) { context->clientURI = values_find(&val, "uri"); if (context->clientURI) { context->type = HEIM_DIGEST_TYPE_RFC2617_MD5_SESS; } else { context->clientURI = values_find(&val, "digest-uri"); context->type = HEIM_DIGEST_TYPE_RFC2831; } } else if (context->type == HEIM_DIGEST_TYPE_RFC2831) { context->clientURI = values_find(&val, "digest-uri"); } else { context->clientURI = values_find(&val, "uri"); } if (context->clientURI == NULL) goto out; context->clientUsername = values_find(&val, "username"); if (context->clientUsername == NULL) goto out; /* if client sent realm, make sure its the same of serverRealm if its set */ context->clientRealm = values_find(&val, "realm"); if (context->clientRealm && context->serverRealm && strcmp(context->clientRealm, context->serverRealm) != 0) goto out; context->clientResponse = values_find(&val, "response"); if (context->clientResponse == NULL) goto out; nonce = values_find(&val, "nonce"); if (nonce == NULL) goto out; if (strcmp(nonce, context->serverNonce) != 0) { free(nonce); goto out; } free(nonce); if (context->type != HEIM_DIGEST_TYPE_RFC2069) { context->clientQOP = values_find(&val, "qop"); if (context->clientQOP == NULL) goto out; /* * If we have serverQOP, lets check that clientQOP exists * in the list of server entries. */ if (context->serverQOP) { Boolean found = false; char *b, *e; size_t len, clen = strlen(context->clientQOP); b = context->serverQOP; while (b && !found) { e = strchr(b, ','); if (e == NULL) len = strlen(b); else { len = e - b; e += 1; } if (clen == len && strncmp(b, context->clientQOP, len) == 0) found = true; b = e; } if (!found) goto out; } context->clientNC = values_find(&val, "nc"); if (context->clientNC == NULL) goto out; context->clientNonce = values_find(&val, "cnonce"); if (context->clientNonce == NULL) goto out; } set_auth_method(context); ret = 0; out: free_values(val); return ret; }
/*---------------------------------------------------------------------------*/ void rpl_join_instance(uip_ipaddr_t *from, rpl_dio_t *dio) { rpl_instance_t *instance; rpl_dag_t *dag; rpl_parent_t *p; rpl_of_t *of; int tx;//elnaz dag = rpl_alloc_dag(dio->instance_id, &dio->dag_id); if(dag == NULL) { // PRINTF("RPL: Failed to allocate a DAG object!\n"); return; } instance = dag->instance; p = rpl_add_parent(dag, dio, from); // PRINTF("RPL: Adding "); // PRINT6ADDR(from); // PRINTF(" as a parent: "); if(p == NULL) { // PRINTF("failed\n"); instance->used = 0; return; } p->dtsn = dio->dtsn; // PRINTF("succeeded\n"); /* Determine the objective function by using the objective code point of the DIO. */ of = rpl_find_of(dio->ocp); if(of == NULL) { // PRINTF("RPL: DIO for DAG instance %u does not specify a supported OF\n",dio->instance_id); rpl_remove_parent(p); instance->used = 0; return; } /* Autoconfigure an address if this node does not already have an address with this prefix. */ if(dio->prefix_info.flags & UIP_ND6_RA_FLAG_AUTONOMOUS) { check_prefix(NULL, &dio->prefix_info); } //-----------------elnaz tx =cc2420_get_txpower(); printf("Power=%d \n",tx); switch(tx) { case 3: dag->Tx = 0.003; break; case 7: dag->Tx = 0.03; break; case 11: dag->Tx = 0.1; break; case 15: dag->Tx = 0.2; break; case 19: dag->Tx = 0.3; break; case 23: dag->Tx = 0.5; break; case 27: dag->Tx = 0.8; break; case 31: dag->Tx = 1; } /* float mv = (bateria * 2.500 * 2) / 4096; printf("Battery: (%ld.%03d mV)\n", (long) mv, (unsigned) ((mv - floor(mv)) * 1000)); */ //printf("Test tx=%ld ",(long) (dag->Tx*1000)); //----------------------elnaz dag->joined = 1; dag->preference = dio->preference; dag->grounded = dio->grounded; dag->version = dio->version; instance->of = of; instance->mop = dio->mop; instance->current_dag = dag; instance->dtsn_out = RPL_LOLLIPOP_INIT; instance->max_rankinc = dio->dag_max_rankinc; instance->min_hoprankinc = dio->dag_min_hoprankinc; instance->dio_intdoubl = dio->dag_intdoubl; instance->dio_intmin = dio->dag_intmin; instance->dio_intcurrent = instance->dio_intmin + instance->dio_intdoubl; instance->dio_redundancy = dio->dag_redund; instance->default_lifetime = dio->default_lifetime; instance->lifetime_unit = dio->lifetime_unit; memcpy(&dag->dag_id, &dio->dag_id, sizeof(dio->dag_id)); /* Copy prefix information from the DIO into the DAG object. */ memcpy(&dag->prefix_info, &dio->prefix_info, sizeof(rpl_prefix_t)); rpl_set_preferred_parent(dag, p); instance->of->update_metric_container(instance); dag->rank = instance->of->calculate_rank(p, 0); /* So far this is the lowest rank we are aware of. */ dag->min_rank = dag->rank; if(default_instance == NULL) { default_instance = instance; } // PRINTF("RPL: Joined DAG with instance ID %u, rank %hu, DAG ID ", dio->instance_id, dag->rank); // PRINT6ADDR(&dag->dag_id); // PRINTF("\n"); ANNOTATE("#A join=%u\n", dag->dag_id.u8[sizeof(dag->dag_id) - 1]); rpl_reset_dio_timer(instance); rpl_set_default_route(instance, from); if(instance->mop != RPL_MOP_NO_DOWNWARD_ROUTES) { rpl_schedule_dao(instance); } else { // PRINTF("RPL: The DIO does not meet the prerequisites for sending a DAO\n"); } }
static void process_input_file(FILE *in, kd_message * &messages, const char *fname, bool quiet) { int num_errors = 0; int num_warnings = 0; int num_dev_errors = 0; int num_dev_warnings = 0; kd_string error_context; kd_string warning_context; kd_string error_lead_in; kd_string warning_lead_in; kd_message msg; // Temporary resource for building messages kd_string txt; // Temporary resource for assembling contents of KDU_TXT() kd_line line; int unmatched_braces = 0; bool in_txt = false; // If inside the `KDU_TXT' macro bool in_comment = false; while (line.read(in)) { const char *cp; if (error_context.is_empty() && ((cp=strstr(line.get(),"kdu_error _name(\"")) != NULL)) error_context.add(strchr(cp,'\"')); else if (error_lead_in.is_empty() && ((cp=strstr(line.get(),"kdu_error _name(\"")) != NULL)) error_lead_in.add(strchr(cp,'\"')); else if (warning_context.is_empty() && ((cp=strstr(line.get(),"kdu_warning _name(\"")) != NULL)) warning_context.add(strchr(cp,'\"')); else if (warning_lead_in.is_empty() && ((cp=strstr(line.get(),"kdu_warning _name(\"")) != NULL)) warning_lead_in.add(strchr(cp,'\"')); cp = line.get(); if (*cp == '#') continue; for (; *cp != '\0'; cp++) { if ((cp[0] == '/') && (cp[1] == '/')) break; // Rest of line is a comment if (in_comment) { if ((cp[0] == '*') && (cp[1] == '/')) { in_comment = false; cp++; } continue; } if ((cp[0] == '/') && (cp[1] == '*')) { in_comment = true; cp++; continue; } if (!msg.started()) { kdu_uint32 id; if (check_prefix(cp,"KDU_ERROR(")) { cp += strlen("KDU_ERROR("); if (read_id(cp,id) && !(error_context.is_empty() || error_lead_in.is_empty())) { msg.start(error_context,id,error_lead_in,false); num_errors++; } } else if (check_prefix(cp,"KDU_ERROR_DEV(")) { cp += strlen("KDU_ERROR_DEV("); if (read_id(cp,id) && !(error_context.is_empty() || error_lead_in.is_empty())) { msg.start(error_context,id,error_lead_in,true); num_errors++; num_dev_errors++; } } else if (check_prefix(cp,"KDU_WARNING(")) { cp += strlen("KDU_WARNING("); if (read_id(cp,id) && !(warning_context.is_empty() || warning_lead_in.is_empty())) { msg.start(warning_context,id,warning_lead_in,false); num_warnings++; } } else if (check_prefix(cp,"KDU_WARNING_DEV(")) { cp += strlen("KDU_WARNING_DEV("); if (read_id(cp,id) && !(warning_context.is_empty() || warning_lead_in.is_empty())) { msg.start(warning_context,id,warning_lead_in,true); num_warnings++; num_dev_warnings++; } } assert((unmatched_braces == 0) && !in_txt); continue; } // If we get here, a message has been started if (!in_txt) { if (check_prefix(cp,"KDU_TXT(")) { cp += strlen("KDU_TXT"); in_txt = true; } else if (*cp == '{') unmatched_braces++; else if (*cp == '}') { if (unmatched_braces > 0) unmatched_braces--; else { kd_message *new_msg = new kd_message; msg.donate(new_msg); assert(!msg.started()); insert_message(messages,new_msg,fname); } } continue; } // If we get here, we are inside a `KDU_TXT' macro if (*cp == '\"') cp = txt.add(cp); else if (*cp == ')') { msg.add_text(txt); txt.clear(); in_txt = false; } } } if (msg.started()) { kdu_error e; e << "Encountered incomplete \"KDU_ERROR\", " "\"KDU_ERROR_DEV\", \"KDU_WARNING\" or \"KDU_WARNING_DEV\" environment " "while parsing source file \"" << fname << "\"."; } if (!quiet) { pretty_cout << ">> Parsed " << num_errors << " KDU_ERROR messages (" << num_dev_errors << " for developers only)\n\tand " << num_warnings << " KDU_WARNING messages (" << num_dev_warnings << " for developers only)\n\tfrom \"" << fname << "\".\n"; pretty_cout.flush(); } }
static int dump_devices(void) { const struct dirent *ent; int ret; DIR *dp; dp = opendir(iio_dir); if (!dp) { fprintf(stderr, "No industrial I/O devices available\n"); return -ENODEV; } while (ent = readdir(dp), ent) { if (check_prefix(ent->d_name, type_device)) { char *dev_dir_name; if (asprintf(&dev_dir_name, "%s%s", iio_dir, ent->d_name) < 0) { ret = -ENOMEM; goto error_close_dir; } ret = dump_one_device(dev_dir_name); if (ret) { free(dev_dir_name); goto error_close_dir; } free(dev_dir_name); if (verblevel >= VERBLEVEL_SENSORS) printf("\n"); } } rewinddir(dp); while (ent = readdir(dp), ent) { if (check_prefix(ent->d_name, type_trigger)) { char *dev_dir_name; if (asprintf(&dev_dir_name, "%s%s", iio_dir, ent->d_name) < 0) { ret = -ENOMEM; goto error_close_dir; } ret = dump_one_trigger(dev_dir_name); if (ret) { free(dev_dir_name); goto error_close_dir; } free(dev_dir_name); } } return (closedir(dp) == -1) ? -errno : 0; error_close_dir: if (closedir(dp) == -1) perror("dump_devices(): Failed to close directory"); return ret; }
int main(int argc, char** argv) { std::cout << "\nsend_rpc_ra\n"; std::cout << "\n(C) 2015 Alexander Holler\n\n"; if (argc != 4) { std::cout << "Usage: " << "send_rpc_ra interface destination_ipv6 prefix_ipv6\n" << "Example: " << "send_ra eth0 ff02::1 fecd::\n\n"; return 1; } std::string interface(argv[1]); std::string destination(argv[2]); std::string prefix(argv[3]); struct { nd_router_advert nra; nd_opt_prefix_info opt_prefix_info; } my_ra; std::memset(&my_ra, 0, sizeof(my_ra)); my_ra.nra.nd_ra_type = ND_ROUTER_ADVERT; msghdr msghdr; std::memset(&msghdr, 0, sizeof(msghdr)); // destination address sockaddr_in6 dst; std::memset(&dst, 0, sizeof(dst)); dst.sin6_family = AF_INET6; dst.sin6_port = htons(IPPROTO_ICMPV6); if (inet_pton(AF_INET6, destination.c_str(), &dst.sin6_addr) != 1) { std::cerr << "Error setting destination '" << destination << "'\n"; return 2; } msghdr.msg_name = &dst; msghdr.msg_namelen = sizeof(dst); iovec iov[2]; std::memset(&iov, 0, sizeof(iov)); iov[0].iov_base = &my_ra; iov[0].iov_len = sizeof(my_ra); msghdr.msg_iov = (struct iovec *) &iov; msghdr.msg_iovlen = sizeof(iov) / sizeof(struct iovec); in6_pktinfo* ipi; cmsghdr* cmsg_hdr; uint8_t cmsgbuf[CMSG_SPACE(sizeof(int)) + CMSG_SPACE(sizeof(*ipi))]; std::memset(&cmsgbuf, 0, sizeof(cmsgbuf)); msghdr.msg_control = &cmsgbuf; msghdr.msg_controllen = sizeof(cmsgbuf); // hop limit cmsg_hdr = CMSG_FIRSTHDR(&msghdr); cmsg_hdr->cmsg_level = IPPROTO_IPV6; cmsg_hdr->cmsg_type = IPV6_HOPLIMIT; cmsg_hdr->cmsg_len = CMSG_LEN(sizeof(int)); cmsgbuf[sizeof(*cmsg_hdr)] = 255; // using CMSG_DATA throws a warning // packet info cmsg_hdr = CMSG_NXTHDR(&msghdr, cmsg_hdr); cmsg_hdr->cmsg_level = IPPROTO_IPV6; cmsg_hdr->cmsg_type = IPV6_PKTINFO; cmsg_hdr->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo)); ipi = (struct in6_pktinfo *) CMSG_DATA(cmsg_hdr); ipi->ipi6_ifindex = if_nametoindex(interface.c_str()); if (!ipi->ipi6_ifindex) { std::cerr << "Interface '" << interface << "' not found!\n"; return 3; } in6_addr s_addr; std::memset(&s_addr, 0, sizeof(s_addr)); if (set_src_addr(interface, s_addr)) { std::cerr << "Error finding link-local address of interface '" << interface << "'!\n"; return 4; } std::memcpy(&ipi->ipi6_addr, &s_addr, sizeof(ipi->ipi6_addr)); msghdr.msg_iovlen = 1; my_ra.opt_prefix_info.nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION; my_ra.opt_prefix_info.nd_opt_pi_len = 4; if (inet_pton(AF_INET6, prefix.c_str(), &my_ra.opt_prefix_info.nd_opt_pi_prefix) != 1) { std::cerr << "Error converting prefix '" << prefix << "'!\n"; return 5; } my_ra.opt_prefix_info.nd_opt_pi_prefix_len = 64; if (check_prefix(interface, my_ra.opt_prefix_info.nd_opt_pi_prefix)) { std::cerr << "Prefix " << prefix << " seems to be in use!\n"; return 6; } my_ra.opt_prefix_info.nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_AUTO; my_ra.opt_prefix_info.nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_RADDR; // Setting both lifetimes to 1 means the kernel will only delete the // link-local address without creating it before. my_ra.opt_prefix_info.nd_opt_pi_valid_time = htonl(1); my_ra.opt_prefix_info.nd_opt_pi_preferred_time = htonl(1); int sock = ::socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6); if (sock < 0) { std::cerr << "Error opening raw socket, are you root?\n"; return 7; } if (::sendmsg(sock, &msghdr, 0) < 0) { ::close(sock); std::cerr << "Error sending RA ( " << strerror(errno) << ")!\n"; return 8; } ::close(sock); std::cout << "Sent a Router Advertisment with prefix " << prefix << " to " << destination << "\n"; return 0; }
void smtp (int fd) { int state, c; char *buf = NULL; size_t size = 0; mu_mailbox_t mbox; mu_message_t msg; char *tempfile; char *rcpt_addr; in = fdopen (fd, "r"); out = fdopen (fd, "w"); SETVBUF (in, NULL, _IOLBF, 0); SETVBUF (out, NULL, _IOLBF, 0); smtp_reply (220, "Ready"); for (state = STATE_INIT; state != STATE_QUIT; ) { int argc; char **argv; int kw, len; if (getline (&buf, &size, in) == -1) exit (1); len = strlen (buf); while (len > 0 && (buf[len-1] == '\n' || buf[len-1] == '\r')) len --; buf[len] = 0; if (mu_argcv_get (buf, "", NULL, &argc, &argv)) exit (1); kw = smtp_kw (argv[0]); if (kw == KW_QUIT) { smtp_reply (221, "Done"); state = STATE_QUIT; mu_argcv_free (argc, argv); continue; } switch (state) { case STATE_INIT: switch (kw) { case KW_EHLO: case KW_HELO: if (argc == 2) { smtp_reply (250, "pleased to meet you"); state = STATE_EHLO; } else smtp_reply (501, "%s requires domain address", argv[0]); break; default: smtp_reply (503, "Polite people say HELO first"); break; } break; case STATE_EHLO: switch (kw) { case KW_MAIL: if (argc == 2) from_person = check_prefix (argv[1], "from:"); else if (argc == 3 && mu_c_strcasecmp (argv[1], "from:") == 0) from_person = argv[2]; else from_person = NULL; if (from_person) { from_person = strdup (from_person); smtp_reply (250, "Sender OK"); state = STATE_MAIL; } else smtp_reply (501, "Syntax error"); break; default: smtp_reply (503, "Need MAIL command"); } break; case STATE_MAIL: switch (kw) { case KW_RCPT: if (argc == 2) rcpt_addr = check_prefix (argv[1], "to:"); else if (argc == 3 && mu_c_strcasecmp (argv[1], "to:") == 0) rcpt_addr = argv[2]; else rcpt_addr = NULL; if (rcpt_addr) { if (add_recipient (rcpt_addr)) smtp_reply (451, "Recipient not accepted"); else { smtp_reply (250, "Recipient OK"); state = STATE_RCPT; } } else smtp_reply (501, "Syntax error"); break; default: smtp_reply (503, "Need RCPT command"); } break; case STATE_RCPT: switch (kw) { case KW_RCPT: if (argc == 2) rcpt_addr = check_prefix (argv[1], "to:"); else if (argc == 3 && mu_c_strcasecmp (argv[1], "to:") == 0) rcpt_addr = argv[2]; else rcpt_addr = NULL; if (rcpt_addr) { if (add_recipient (rcpt_addr)) smtp_reply (451, "Recipient not accepted"); else { smtp_reply (250, "Recipient OK"); state = STATE_RCPT; } } else smtp_reply (501, "Syntax error"); break; case KW_DATA: smtp_reply (354, "Enter mail, end with \".\" on a line by itself"); make_tmp (in, from_person, &tempfile); if ((c = mu_mailbox_create_default (&mbox, tempfile)) != 0) { mu_error ("%s: can't create mailbox %s: %s", progname, tempfile, mu_strerror (c)); unlink (tempfile); exit (1); } if ((c = mu_mailbox_open (mbox, MU_STREAM_RDWR)) != 0) { mu_error ("%s: can't open mailbox %s: %s", progname, tempfile, mu_strerror (c)); unlink (tempfile); exit (1); } mu_mailbox_get_message (mbox, 1, &msg); if (message_finalize (msg, 0) == 0) mta_send (msg); else smtp_reply (501, "can't send message"); /*FIXME: code?*/ unlink (tempfile); mu_address_destroy (&recipients); from_person = NULL; smtp_reply (250, "Message accepted for delivery"); state = STATE_EHLO; break; default: smtp_reply (503, "Invalid command"); break; } break; } mu_argcv_free (argc, argv); } close (fd); }