static void do_select_shutdown() { safe_free(pfds); safe_free(pfd_map); }
void writeSCF(FILE *asmFile, bool doWrite) { SnapScaffoldMesg scf; GenericMesg pmesg = { &scf, MESG_SCF }; GraphNodeIterator scaffolds; CIScaffoldT *scaffold; fprintf(stderr, "writeSCF()--\n"); InitGraphNodeIterator(&scaffolds, ScaffoldGraph->ScaffoldGraph, GRAPH_NODE_DEFAULT); while ((scaffold = NextGraphNodeIterator(&scaffolds)) != NULL) { if(scaffold->type != REAL_SCAFFOLD) continue; assert(scaffold->info.Scaffold.numElements > 0); scf.eaccession = AS_UID_fromInteger(getUID(uidServer)); scf.iaccession = scaffold->id; scf.num_contig_pairs = scaffold->info.Scaffold.numElements - 1; scf.contig_pairs = (SnapContigPairs *)safe_malloc(sizeof(SnapContigPairs) * scaffold->info.Scaffold.numElements); CIScaffoldTIterator contigs; ChunkInstanceT *contigCurr; ChunkInstanceT *contigLast; InitCIScaffoldTIterator(ScaffoldGraph, scaffold, TRUE, FALSE, &contigs); contigLast = NextCIScaffoldTIterator(&contigs); SequenceOrient orientLast; SequenceOrient orientCurr; orientLast.setIsForward(contigLast->offsetAEnd.mean < contigLast->offsetBEnd.mean); assert(contigLast->scaffoldID == scaffold->id); if (scf.num_contig_pairs == 0) { scf.contig_pairs[0].econtig1 = CCOmap.lookup(contigLast->id); scf.contig_pairs[0].econtig2 = CCOmap.lookup(contigLast->id); scf.contig_pairs[0].mean = 0.0; scf.contig_pairs[0].stddev = 0.0; scf.contig_pairs[0].orient.setIsAB_AB(); // got to put something } else { int32 pairCount = 0; while ((contigCurr = NextCIScaffoldTIterator(&contigs)) != NULL) { assert(pairCount < scf.num_contig_pairs); assert(contigCurr->scaffoldID == scaffold->id); scf.contig_pairs[pairCount].econtig1 = CCOmap.lookup(contigLast->id); scf.contig_pairs[pairCount].econtig2 = CCOmap.lookup(contigCurr->id); SequenceOrient orientCurr; orientCurr.setIsForward(contigCurr->offsetAEnd.mean < contigCurr->offsetBEnd.mean); if (orientLast.isForward()) { if (orientCurr.isForward()) { scf.contig_pairs[pairCount].mean = contigCurr->offsetAEnd.mean - contigLast->offsetBEnd.mean; scf.contig_pairs[pairCount].stddev = sqrt(contigCurr->offsetAEnd.variance - contigLast->offsetBEnd.variance); scf.contig_pairs[pairCount].orient.setIsAB_AB(); } else { //orientCurr == B_A scf.contig_pairs[pairCount].mean = contigCurr->offsetBEnd.mean - contigLast->offsetBEnd.mean; scf.contig_pairs[pairCount].stddev = sqrt(contigCurr->offsetBEnd.variance - contigLast->offsetBEnd.variance); scf.contig_pairs[pairCount].orient.setIsAB_BA(); } } else { //orientLast == B_A if (orientCurr.isForward()) { scf.contig_pairs[pairCount].mean = contigCurr->offsetAEnd.mean - contigLast->offsetAEnd.mean; scf.contig_pairs[pairCount].stddev = sqrt(contigCurr->offsetAEnd.variance - contigLast->offsetAEnd.variance); scf.contig_pairs[pairCount].orient.setIsBA_AB(); } else { //orientCurr == B_A scf.contig_pairs[pairCount].mean = contigCurr->offsetBEnd.mean - contigLast->offsetAEnd.mean; scf.contig_pairs[pairCount].stddev = sqrt(contigCurr->offsetBEnd.variance - contigLast->offsetAEnd.variance); scf.contig_pairs[pairCount].orient.setIsBA_BA(); } } contigLast = contigCurr; orientLast = orientCurr; ++pairCount; } } if (doWrite) WriteProtoMesg_AS(asmFile, &pmesg); SCFmap.add(scf.iaccession, scf.eaccession); safe_free(scf.contig_pairs); } }
/* * Delete */ void delete_ptr_heap(ptr_heap_t *heap) { safe_free(heap->heap); heap->heap = NULL; }
void state_free (struct browser_state *state) { safe_free((void**)&state->entry); safe_free((void**)&state->folder); }
void writeCCO(FILE *asmFile, bool doWrite) { SnapConConMesg cco; GenericMesg pmesg = { &cco, MESG_CCO }; GraphNodeIterator contigs; ContigT *contig; fprintf(stderr, "writeCCO()--\n"); InitGraphNodeIterator(&contigs, ScaffoldGraph->ContigGraph, GRAPH_NODE_DEFAULT); while ((contig = NextGraphNodeIterator(&contigs)) != NULL) { assert(contig->id >= 0); assert(contig->id < GetNumGraphNodes(ScaffoldGraph->ContigGraph)); if (contig->flags.bits.isChaff) continue; NodeCGW_T *unitig = GetGraphNode(ScaffoldGraph->CIGraph, contig->info.Contig.AEndCI); if ((ScaffoldGraph->tigStore->getNumUnitigs(contig->id, FALSE) == 1) && (contig->scaffoldID == NULLINDEX) && (unitig->info.CI.numInstances > 0)) // Contig is a surrogate instance continue; MultiAlignT *ma = ScaffoldGraph->tigStore->loadMultiAlign(contig->id, FALSE); cco.eaccession = AS_UID_fromInteger(getUID(uidServer)); cco.iaccession = contig->id; cco.placed = ScaffoldGraph->tigStore->getContigStatus(contig->id); cco.length = GetMultiAlignLength(ma); cco.consensus = Getchar(ma->consensus, 0); cco.quality = Getchar(ma->quality, 0); cco.forced = 0; cco.num_pieces = GetNumIntMultiPoss(ma->f_list); cco.num_unitigs = GetNumIntMultiPoss(ma->u_list); cco.num_vars = GetNumIntMultiPoss(ma->v_list); cco.pieces = NULL; cco.unitigs = NULL; cco.vars = NULL; if (cco.consensus == NULL) fprintf(stderr, "buildCCOMessage()-- contig %d missing consensus sequence\n", cco.iaccession); assert(cco.consensus != NULL); if (cco.length != strlen(cco.consensus)) fprintf(stderr, "buildCCOMessage()-- contig %d length %d != consensus string length "F_SIZE_T"\n", cco.iaccession, cco.length, strlen(cco.consensus)); assert(cco.length == strlen(cco.consensus)); if (cco.num_pieces > 0) { cco.pieces = (SnapMultiPos *)safe_malloc(cco.num_pieces * sizeof(SnapMultiPos)); for(int32 i=0; i<cco.num_pieces; i++) { IntMultiPos *imp = GetIntMultiPos(ma->f_list, i); cco.pieces[i].type = imp->type; cco.pieces[i].eident = FRGmap.lookup(imp->ident); cco.pieces[i].delta_length = imp->delta_length; cco.pieces[i].position = imp->position; cco.pieces[i].delta = imp->delta; } } if (cco.num_unitigs > 0) { cco.unitigs = (UnitigPos *)safe_malloc(cco.num_unitigs * sizeof(UnitigPos)); for(int32 i=0; i<cco.num_unitigs; i++) { IntUnitigPos *imp = GetIntUnitigPos(ma->u_list, i); cco.unitigs[i].type = imp->type; cco.unitigs[i].eident = UTGmap.lookup(imp->ident); cco.unitigs[i].position = imp->position; cco.unitigs[i].delta = imp->delta; cco.unitigs[i].delta_length = imp->delta_length; } } if (cco.num_vars > 0) { cco.vars = (IntMultiVar *)safe_malloc(cco.num_vars * sizeof(IntMultiVar)); for(int32 i=0; i<cco.num_vars; i++) { IntMultiVar *imv = GetIntMultiVar(ma->v_list, i); cco.vars[i].var_id = imv->var_id; cco.vars[i].phased_id = imv->phased_id; cco.vars[i].position = imv->position; cco.vars[i].num_reads = imv->num_reads; cco.vars[i].num_alleles = imv->num_alleles; cco.vars[i].num_alleles_confirmed = imv->num_alleles_confirmed; cco.vars[i].min_anchor_size = imv->min_anchor_size; cco.vars[i].var_length = imv->var_length; cco.vars[i].alleles = imv->alleles; cco.vars[i].var_seq_memory = imv->var_seq_memory; cco.vars[i].read_id_memory = imv->read_id_memory; cco.vars[i].enc_num_reads = NULL; cco.vars[i].enc_weights = NULL; cco.vars[i].enc_var_seq = NULL; cco.vars[i].enc_read_ids = NULL; } } if (doWrite) WriteProtoMesg_AS(asmFile, &pmesg); safe_free(cco.pieces); safe_free(cco.unitigs); safe_free(cco.vars); CCOmap.add(cco.iaccession, cco.eaccession); } }
static int md_mfd_license_commit_side_effects( md_commit *commit, const mdb_db *old_db, mdb_db *inout_new_db, mdb_db_change_array *change_list, void *arg) { int err = 0; int idx, num_vps; int i = 0, num_changes = 0; tbool found = false; const mdb_db_change *change = NULL; char *ns_maxconnections = NULL; char *ns_maxbandwidth = NULL; tstr_array *t_vp_max_rate_list = NULL; num_changes = mdb_db_change_array_length_quick (change_list); lc_log_basic(LOG_ALERT, "In license commit %d", num_changes); for (i = 0; i < num_changes; i++) { change = mdb_db_change_array_get_quick (change_list, i); bail_null (change); #ifdef USE_MFD_LICENSE /* Check if it is mfd license node*/ if ((bn_binding_name_pattern_match (ts_str(change->mdc_name), nkn_mfd_lic_node)) && (mdct_modify == change->mdc_change_type)) { tbool t_mfd_license = false; const char *t_max_connections = 0; const char *t_max_bandwidth = 0; /* First get the license node value */ err = mdb_get_node_value_tbool(commit, inout_new_db, ts_str(change->mdc_name), 0, &found, &t_mfd_license); bail_error (err); /* Based on the license set the values for * max connections and max bandwidth */ if (t_mfd_license) { /* Change the defaults when license is good */ t_max_connections = VALID_LICENSE_MAXCONN; t_max_bandwidth = VALID_LICENSE_MAXBW; } else { /* Change the defaults when license is bad or not present */ t_max_connections = INVALID_LICENSE_MAXCONN; t_max_bandwidth = INVALID_LICENSE_MAXBW; } ns_maxconnections = smprintf("/nkn/nvsd/network/config/max_connections"); bail_null(ns_maxconnections); ns_maxbandwidth = smprintf("/nkn/nvsd/network/config/max_bandwidth"); bail_null(ns_maxbandwidth); err = mdb_set_node_str(commit, inout_new_db, bsso_modify, 0, bt_uint32, t_max_connections, "%s", ns_maxconnections); bail_error(err); err = mdb_set_node_str(commit, inout_new_db, bsso_modify, 0, bt_uint32, t_max_bandwidth, "%s", ns_maxbandwidth); bail_error(err); /* Do the reset of max_session_rate of virtual player only if license expires */ if (t_mfd_license) goto bail; /* Now iterate through the virtual-players and get the max_session_rate nodes */ err = mdb_get_matching_tstr_array(commit, inout_new_db, "/nkn/nvsd/virtual_player/config/*", mdqf_sel_class_no_state, &t_vp_max_rate_list); num_vps = tstr_array_length_quick(t_vp_max_rate_list); for (idx = 0; idx < num_vps; idx++) { err = mdb_set_node_str(commit, inout_new_db, bsso_modify, 0, bt_uint32, "0", "%s/max_session_rate", tstr_array_get_str_quick(t_vp_max_rate_list, idx)); bail_error(err); } } else #endif /* USE_MFD_LICENSE */ /* check if it is MFD's SSL license node */ if ((bn_binding_name_pattern_match(ts_str(change->mdc_name), nkn_mfd_ssl_lic_node)) && (mdct_modify == change->mdc_change_type)) { tbool t_mfd_ssl_license = false; /* First get the license node value */ err = mdb_get_node_value_tbool(commit, inout_new_db, ts_str(change->mdc_name), 0, &found, &t_mfd_ssl_license); bail_error(err); if (t_mfd_ssl_license) { /* License is valid. Raise an event ?? */ } else { /* License if invalid */ } } } #ifndef USE_MFD_LICENSE tbool t_mfd_license = false; const char *t_max_connections = 0; const char *t_max_bandwidth = 0; /* Change the defaults when license is good */ t_max_connections = VALID_LICENSE_MAXCONN; t_max_bandwidth = VALID_LICENSE_MAXBW; ns_maxconnections = smprintf("/nkn/nvsd/network/config/max_connections"); bail_null(ns_maxconnections); ns_maxbandwidth = smprintf("/nkn/nvsd/network/config/max_bandwidth"); bail_null(ns_maxbandwidth); err = mdb_set_node_str(commit, inout_new_db, bsso_modify, 0, bt_uint32, t_max_connections, "%s", ns_maxconnections); bail_error(err); err = mdb_set_node_str(commit, inout_new_db, bsso_modify, 0, bt_uint32, t_max_bandwidth, "%s", ns_maxbandwidth); bail_error(err); /* Do the reset of max_session_rate of virtual player only if license expires */ /* Now iterate through the virtual-players and get the max_session_rate nodes */ err = mdb_get_matching_tstr_array(commit, inout_new_db, "/nkn/nvsd/virtual_player/config/*", mdqf_sel_class_no_state, &t_vp_max_rate_list); num_vps = tstr_array_length_quick(t_vp_max_rate_list); for (idx = 0; idx < num_vps; idx++) { err = mdb_set_node_str(commit, inout_new_db, bsso_modify, 0, bt_uint32, "0", "%s/max_session_rate", tstr_array_get_str_quick(t_vp_max_rate_list, idx)); bail_error(err); } #endif /* ! USE_MFD_LICENSE */ bail: tstr_array_free(&t_vp_max_rate_list); safe_free(ns_maxconnections); safe_free(ns_maxbandwidth); return err; }
static void storeurlStateFree(storeurlStateData * r) { safe_free(r->orig_url); cbdataFree(r); }
// TODO: allow commandline options (v2) // TODO: remove existing infs for similar devices (v2) int __cdecl main(int argc_ansi, char** argv_ansi) { DWORD r; BOOL b; int i, ret, argc = argc_ansi, si=0; char** argv = argv_ansi; wchar_t **wenv, **wargv; char* hardware_id = NULL; char* device_id = NULL; char* user_sid = NULL; char* inf_name = NULL; char path[MAX_PATH_LENGTH]; char destname[MAX_PATH_LENGTH]; uintptr_t syslog_reader_thid = -1L; // Connect to the messaging pipe pipe_handle = CreateFileA(INSTALLER_PIPE_NAME, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, NULL); if (pipe_handle == INVALID_HANDLE_VALUE) { // If we can't connect to the pipe, someone is probably trying to run us standalone printf("This application can not be run from the command line.\n"); printf("Please use your initial installer application if you want to install the driver.\n"); return WDI_ERROR_NOT_SUPPORTED; } if (init_dlls()) { plog("could not init DLLs"); ret = WDI_ERROR_RESOURCE; goto out; } // Initialize COM for Restore Point disabling IGNORE_RETVAL(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)); // libwdi provides the arguments as UTF-16 => read them and convert to UTF-8 if (__wgetmainargs != NULL) { __wgetmainargs(&argc, &wargv, &wenv, 1, &si); argv = calloc(argc, sizeof(char*)); for (i=0; i<argc; i++) { argv[i] = wchar_to_utf8(wargv[i]); } } else { plog("unable to access UTF-16 args - trying ANSI"); } if (argc < 2) { printf("usage: %s <inf_name>\n", argv[0]); plog("missing inf_name parameter"); } inf_name = argv[1]; plog("got parameter %s", argv[1]); r = GetFullPathNameU(".", MAX_PATH_LENGTH, path, NULL); if ((r == 0) || (r > MAX_PATH_LENGTH)) { plog("could not retrieve absolute path of working directory"); ret = WDI_ERROR_ACCESS; goto out; } safe_strcat(path, MAX_PATH_LENGTH, "\\"); safe_strcat(path, MAX_PATH_LENGTH, inf_name); device_id = req_id(IC_GET_DEVICE_ID); hardware_id = req_id(IC_GET_HARDWARE_ID); // Will be used if we ever need to create a file, as the original user, from this app user_sid = req_id(IC_GET_USER_SID); ConvertStringSidToSidA(user_sid, &user_psid); // Setup the syslog reader thread syslog_ready_event = CreateEvent(NULL, TRUE, FALSE, NULL); syslog_terminate_event = CreateEvent(NULL, TRUE, FALSE, NULL); syslog_reader_thid = _beginthread(syslog_reader_thread, 0, 0); if ( (syslog_reader_thid == -1L) || (WaitForSingleObject(syslog_ready_event, 2000) != WAIT_OBJECT_0) ) { plog("Unable to create syslog reader thread"); SetEvent(syslog_terminate_event); // NB: if you try to close the syslog reader thread handle, you get a // "more recent driver was found" error from UpdateForPnP. Weird... } // Disable the creation of a restore point disable_system_restore(TRUE); // Find if the device is plugged in send_status(IC_SET_TIMEOUT_INFINITE); if (hardware_id != NULL) { plog("Installing driver for %s - please wait...", hardware_id); b = UpdateDriverForPlugAndPlayDevicesU(NULL, hardware_id, path, INSTALLFLAG_FORCE, NULL); send_status(IC_SET_TIMEOUT_DEFAULT); if (b == TRUE) { // Success plog("driver update completed"); enumerate_device(device_id); ret = WDI_SUCCESS; goto out; } ret = process_error(GetLastError(), path); if (ret != WDI_SUCCESS) { goto out; } } // TODO: try URL for OEMSourceMediaLocation (v2) plog("Copying inf file (for the next time device is plugged) - please wait..."); send_status(IC_SET_TIMEOUT_INFINITE); b = SetupCopyOEMInfU(path, NULL, SPOST_PATH, 0, destname, MAX_PATH_LENGTH, NULL, NULL); send_status(IC_SET_TIMEOUT_DEFAULT); if (b) { plog("copied inf to %s", destname); ret = WDI_SUCCESS; enumerate_device(device_id); goto out; } ret = process_error(GetLastError(), path); if (ret != WDI_SUCCESS) { goto out; } // If needed, flag removed devices for reinstallation. see: // http://msdn.microsoft.com/en-us/library/aa906206.aspx check_removed(hardware_id); out: // Report any error status code and wait for target app to read it send_status(IC_INSTALLER_COMPLETED); pstat(ret); // Restore the system restore point creation original settings disable_system_restore(FALSE); // TODO: have libwi send an ACK? Sleep(1000); SetEvent(syslog_terminate_event); if (argv != argv_ansi) { for (i=0; i<argc; i++) { safe_free(argv[i]); } safe_free(argv); } CloseHandle(syslog_ready_event); CloseHandle(syslog_terminate_event); CloseHandle((HANDLE)syslog_reader_thid); CloseHandle(pipe_handle); return ret; }
void updateICMRecord(IntConConMesg *icm_mesg, char * inFile, char *seqAn, char *prefix, char * wrkDir) { // update the consensus icm_mesg->consensus = getConsensus(inFile, seqAn, prefix, wrkDir); icm_mesg->length = strlen(icm_mesg->consensus); // update quality icm_mesg->quality = (char *) safe_malloc(sizeof(char) * icm_mesg->length+1); memset(icm_mesg->quality, '1', icm_mesg->length); icm_mesg->quality[icm_mesg->length] = '\0'; //update read data int32 currRead = 0; char line[AS_SEQAN_MAX_RESULT_LENGTH]; char resultFile[AS_SEQAN_MAX_BUFFER_LENGTH]; getFileName(prefix, wrkDir, AS_SEQAN_RESULT, resultFile); FILE *tempOut; tempOut = fopen(resultFile,"r"); // skip header of output while (!feof(tempOut)) { fgets(line, AS_SEQAN_MAX_RESULT_LENGTH, tempOut); if (strncasecmp(line, "typ", 3) == 0) { break; } } // now read alignments of each read for (currRead = 0; currRead < icm_mesg->num_pieces; currRead++) { if (currRead > 0) { // read the typ: line fgets(line, AS_SEQAN_MAX_RESULT_LENGTH, tempOut); } // read the seq: line fgets(line, AS_SEQAN_MAX_RESULT_LENGTH, tempOut); // read the Pos line fgets(line, AS_SEQAN_MAX_RESULT_LENGTH, tempOut); chomp(line); int32 begin, end; sscanf(line,"Pos:"F_S32","F_S32,&begin,&end); icm_mesg->pieces[currRead].position.bgn = begin; icm_mesg->pieces[currRead].position.end = end; // read the dln line fgets(line, AS_SEQAN_MAX_RESULT_LENGTH, tempOut); chomp(line); sscanf(line,"dln:"F_S32, &icm_mesg->pieces[currRead].delta_length); // read the del line fgets(line, AS_SEQAN_MAX_RESULT_LENGTH, tempOut); chomp(line); if (icm_mesg->pieces[currRead].delta_length > 0) { char *dlnStr = line+AS_SEQAN_MAX_HEADER_LENGTH; icm_mesg->pieces[currRead].delta = (int32 *)safe_malloc(sizeof(int32) * icm_mesg->pieces[currRead].delta_length); int32 i = 0; while (i < icm_mesg->pieces[currRead].delta_length) { icm_mesg->pieces[currRead].delta[i] = (int32) strtol(dlnStr,&dlnStr,10); i++; } } // read blank line fgets(line, AS_SEQAN_MAX_RESULT_LENGTH, tempOut); } // now read the alignments of each unitig for (currRead = 0; currRead < icm_mesg->num_unitigs; currRead++) { // read the seq: line while (strncmp(line, "Pos:", 4) != 0) { fgets(line, AS_SEQAN_MAX_RESULT_LENGTH, tempOut); } // we read the Pos line above, process it now chomp(line); int32 begin, end; sscanf(line,"Pos:"F_S32","F_S32,&begin,&end); // read the dln line fgets(line, AS_SEQAN_MAX_RESULT_LENGTH, tempOut); chomp(line); sscanf(line,"dln:"F_S32, &icm_mesg->unitigs[currRead].delta_length); // read the del line char * del = readMultiLine(tempOut); if (currRead >= 0) { icm_mesg->unitigs[currRead].position.bgn = begin; icm_mesg->unitigs[currRead].position.end = end; if (icm_mesg->unitigs[currRead].delta_length > 0) { char *dlnStr = del+AS_SEQAN_MAX_HEADER_LENGTH; icm_mesg->unitigs[currRead].delta = (int32 *)safe_malloc(sizeof(int32) * icm_mesg->unitigs[currRead].delta_length); int32 i = 0; while (i < icm_mesg->unitigs[currRead].delta_length) { icm_mesg->unitigs[currRead].delta[i] = (int32) strtol(dlnStr,&dlnStr,10); i++; } } } safe_free(del); } fclose(tempOut); }
int build_elem_comm_maps(int proc, MESH_INFO_PTR mesh) { /* * Build element communication maps, given a distributed mesh. * This routine builds initial communication maps for Chaco input * (for Nemesis, initial communication maps are read from the Nemesis file) * and rebuilds communication maps after data migration. * * One communication map per neighboring processor is built. * The corresponding maps on neighboring processors * must be sorted in the same order, so that neighboring processors do not * have to use ghost elements. For each communication map's pair of * processors, the lower-numbered processor determines the order of the * elements in the communication map. The sort key is the elements' global * IDs on the lower-number processor; the secondary key is the neighboring * elements global IDs. The secondary key is used when a single element * must communicate with more than one neighbor. */ const char *yo = "build_elem_comm_maps"; int i, j; ELEM_INFO *elem; ZOLTAN_ID_TYPE iadj_elem; int iadj_proc; int indx; int num_alloc_maps; int max_adj = 0; int max_adj_per_map; int cnt, offset; int *sindex = NULL; int tmp; struct map_list_head *tmp_maps = NULL, *map = NULL; DEBUG_TRACE_START(proc, yo); /* * Free the old maps, if they exist. */ if (mesh->ecmap_id != NULL) { safe_free((void **) &(mesh->ecmap_id)); safe_free((void **) &(mesh->ecmap_cnt)); safe_free((void **) &(mesh->ecmap_elemids)); safe_free((void **) &(mesh->ecmap_sideids)); safe_free((void **) &(mesh->ecmap_neighids)); mesh->necmap = 0; } /* * Look for off-processor adjacencies. * Loop over all elements */ num_alloc_maps = MAP_ALLOC; mesh->ecmap_id = (int *) malloc(num_alloc_maps * sizeof(int)); mesh->ecmap_cnt = (int *) malloc(num_alloc_maps * sizeof(int)); tmp_maps = (struct map_list_head*) malloc(num_alloc_maps * sizeof(struct map_list_head)); if (mesh->ecmap_id == NULL || mesh->ecmap_cnt == NULL || tmp_maps == NULL) { Gen_Error(0, "Fatal: insufficient memory"); DEBUG_TRACE_END(proc, yo); return 0; } for (i = 0; i < mesh->num_elems; i++) { elem = &(mesh->elements[i]); for (j = 0; j < elem->adj_len; j++) { /* Skip NULL adjacencies (sides that are not adjacent to another elem). */ if (elem->adj[j] == ZOLTAN_ID_INVALID) continue; iadj_elem = elem->adj[j]; iadj_proc = elem->adj_proc[j]; if (iadj_proc != proc) { /* * Adjacent element is off-processor. * Add this element to the temporary data structure for * the appropriate neighboring processor. */ if ((indx = in_list2(iadj_proc, mesh->necmap, mesh->ecmap_id)) == -1) { /* * Start a new communication map. */ if (mesh->necmap >= num_alloc_maps) { num_alloc_maps += MAP_ALLOC; mesh->ecmap_id = (int *) realloc(mesh->ecmap_id, num_alloc_maps * sizeof(int)); mesh->ecmap_cnt = (int *) realloc(mesh->ecmap_cnt, num_alloc_maps * sizeof(int)); tmp_maps = (struct map_list_head *) realloc(tmp_maps, num_alloc_maps * sizeof(struct map_list_head)); if (mesh->ecmap_id == NULL || mesh->ecmap_cnt == NULL || tmp_maps == NULL) { Gen_Error(0, "Fatal: insufficient memory"); DEBUG_TRACE_END(proc, yo); return 0; } } mesh->ecmap_id[mesh->necmap] = iadj_proc; mesh->ecmap_cnt[mesh->necmap] = 0; map = &(tmp_maps[mesh->necmap]); map->glob_id = (ZOLTAN_ID_TYPE *) malloc(MAP_ALLOC * sizeof(ZOLTAN_ID_TYPE)); map->elem_id = (int *) malloc(MAP_ALLOC * sizeof(int)); map->side_id = (int *) malloc(MAP_ALLOC * sizeof(int)); map->neigh_id = (ZOLTAN_ID_TYPE *) malloc(MAP_ALLOC * sizeof(ZOLTAN_ID_TYPE)); if (map->glob_id == NULL || map->elem_id == NULL || map->side_id == NULL || map->neigh_id == NULL) { Gen_Error(0, "Fatal: insufficient memory"); DEBUG_TRACE_END(proc, yo); return 0; } map->map_alloc_size = MAP_ALLOC; indx = mesh->necmap; mesh->necmap++; } /* Add to map for indx. */ map = &(tmp_maps[indx]); if (mesh->ecmap_cnt[indx] >= map->map_alloc_size) { map->map_alloc_size += MAP_ALLOC; map->glob_id = (ZOLTAN_ID_TYPE *) realloc(map->glob_id, map->map_alloc_size * sizeof(ZOLTAN_ID_TYPE)); map->elem_id = (int *) realloc(map->elem_id, map->map_alloc_size * sizeof(int)); map->side_id = (int *) realloc(map->side_id, map->map_alloc_size * sizeof(int)); map->neigh_id = (ZOLTAN_ID_TYPE *) realloc(map->neigh_id, map->map_alloc_size * sizeof(ZOLTAN_ID_TYPE)); if (map->glob_id == NULL || map->elem_id == NULL || map->side_id == NULL || map->neigh_id == NULL) { Gen_Error(0, "Fatal: insufficient memory"); DEBUG_TRACE_END(proc, yo); return 0; } } tmp = mesh->ecmap_cnt[indx]; map->glob_id[tmp] = elem->globalID; map->elem_id[tmp] = i; map->side_id[tmp] = j+1; /* side is determined by position in adj array (+1 since not 0-based). */ map->neigh_id[tmp] = iadj_elem; mesh->ecmap_cnt[indx]++; max_adj++; } } } /* * If no communication maps, don't need to do anything else. */ if (mesh->necmap > 0) { /* * Allocate data structure for element communication map arrays. */ mesh->ecmap_elemids = (int *) malloc(max_adj * sizeof(int)); mesh->ecmap_sideids = (int *) malloc(max_adj * sizeof(int)); mesh->ecmap_neighids = (ZOLTAN_ID_TYPE *) malloc(max_adj * sizeof(ZOLTAN_ID_TYPE)); /* * Allocate temporary memory for sort index. */ max_adj_per_map = 0; for (i = 0; i < mesh->necmap; i++) if (mesh->ecmap_cnt[i] > max_adj_per_map) max_adj_per_map = mesh->ecmap_cnt[i]; sindex = (int *) malloc(max_adj_per_map * sizeof(int)); cnt = 0; for (i = 0; i < mesh->necmap; i++) { map = &(tmp_maps[i]); for (j = 0; j < mesh->ecmap_cnt[i]; j++) sindex[j] = j; /* * Sort the map so that adjacent processors have the same ordering * for the communication. * Assume the ordering of the lower-numbered processor in the pair * of communicating processors. */ if (proc < mesh->ecmap_id[i]) quicksort_pointer_inc_id_id(sindex, map->glob_id, map->neigh_id, 0, mesh->ecmap_cnt[i]-1); else quicksort_pointer_inc_id_id(sindex, map->neigh_id, map->glob_id, 0, mesh->ecmap_cnt[i]-1); /* * Copy sorted data into elem map arrays. */ offset = cnt; for (j = 0; j < mesh->ecmap_cnt[i]; j++) { mesh->ecmap_elemids[offset] = map->elem_id[sindex[j]]; mesh->ecmap_sideids[offset] = map->side_id[sindex[j]]; mesh->ecmap_neighids[offset] = map->neigh_id[sindex[j]]; offset++; } cnt += mesh->ecmap_cnt[i]; } } /* Free temporary data structure. */ for (i = 0; i < mesh->necmap; i++) { safe_free((void **) &(tmp_maps[i].glob_id)); safe_free((void **) &(tmp_maps[i].elem_id)); safe_free((void **) &(tmp_maps[i].side_id)); safe_free((void **) &(tmp_maps[i].neigh_id)); } safe_free((void **) &tmp_maps); safe_free((void **) &sindex); if (Test.DDirectory) compare_maps_with_ddirectory_results(proc, mesh); DEBUG_TRACE_END(proc, yo); return 1; }
/* * Read from the driver installation syslog in real-time */ void __cdecl syslog_reader_thread(void* param) { #define NB_SYSLOGS 3 char* syslog_name[NB_SYSLOGS] = { "\\inf\\setupapi.dev.log", "\\setupapi.log", "\\setupact.log" }; HANDLE log_handle; DWORD last_offset, size, read_size, processed_size; char *buffer = NULL; char log_path[MAX_PATH_LENGTH]; DWORD duration = 0; int i; // Try the various driver installation logs for (i=0; i<NB_SYSLOGS; i++) { safe_strcpy(log_path, MAX_PATH_LENGTH, getenv("WINDIR")); // Use %WINDIR% env variable safe_strcat(log_path, MAX_PATH_LENGTH, syslog_name[i]); log_handle = CreateFileA(log_path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (log_handle != INVALID_HANDLE_VALUE) { plog("using syslog '%s'", log_path); break; } } if (i == NB_SYSLOGS) { plog("Could not open any syslog"); goto out; } // We assert that the log file is never gonna be bigger than 2 GB // TODO: special case of setupapi.dev.log's last offset not being the end (v2) last_offset = SetFilePointer(log_handle, 0, NULL, FILE_END); if (last_offset == INVALID_SET_FILE_POINTER) { plog("Could not set syslog offset"); goto out; } plog("sylog reader thread started"); SetEvent(syslog_ready_event); processed_size = 0; while(WaitForSingleObject(syslog_terminate_event, 0) != WAIT_OBJECT_0) { // Find out if file size has increased since last time size = GetFileSize(log_handle, NULL); if (size == INVALID_FILE_SIZE) { plog("could not read syslog file size"); goto out; } size -= last_offset; if (size != 0) { // Read from file and add a zero terminator buffer = malloc(size+1); if (buffer == NULL) { plog("could not allocate buffer to read syslog"); goto out; } // Keep an extra spare byte at the beginning if (!ReadFile(log_handle, buffer, size, &read_size, NULL)) { plog("failed to read syslog"); goto out; } buffer[read_size] = 0; // Send all the complete lines through the pipe processed_size = process_syslog(buffer, read_size); safe_free(buffer); last_offset += processed_size; // Reposition at start of last line if needed if (processed_size != read_size) { last_offset = SetFilePointer(log_handle, processed_size-read_size, NULL, FILE_CURRENT); if (last_offset == INVALID_SET_FILE_POINTER) { plog("Could not set syslog offset"); goto out; } } // Reset adaptive sleep duration if we did send data out if (processed_size !=0) { duration = 0; } } // Compute adaptive sleep duration if (((size == 0) || (processed_size == 0)) && (duration < 500)) { duration += 100; // read log more frequently on recent update } Sleep(duration); } out: plog("syslog reader thread terminating"); safe_free(buffer); CloseHandle(log_handle); _endthread(); }
/* Borrow part of code from libwww2 came with Mosaic distribution */ static void gopherToHTML(GopherStateData * gopherState, char *inbuf, int len) { char *pos = inbuf; char *lpos = NULL; char *tline = NULL; LOCAL_ARRAY(char, line, TEMP_BUF_SIZE); LOCAL_ARRAY(char, tmpbuf, TEMP_BUF_SIZE); String outbuf = StringNull; char *name = NULL; char *selector = NULL; char *host = NULL; char *port = NULL; char *escaped_selector = NULL; const char *icon_url = NULL; char gtype; StoreEntry *entry = NULL; memset(tmpbuf, '\0', TEMP_BUF_SIZE); memset(line, '\0', TEMP_BUF_SIZE); entry = gopherState->entry; if (gopherState->conversion == HTML_INDEX_PAGE) { char *html_url = html_quote(storeUrl(entry)); gopherHTMLHeader(entry, "Gopher Index %s", html_url); storeAppendPrintf(entry, "<p>This is a searchable Gopher index. Use the search\n" "function of your browser to enter search terms.\n" "<ISINDEX>\n"); gopherHTMLFooter(entry); /* now let start sending stuff to client */ storeBufferFlush(entry); gopherState->HTML_header_added = 1; return; } if (gopherState->conversion == HTML_CSO_PAGE) { char *html_url = html_quote(storeUrl(entry)); gopherHTMLHeader(entry, "CSO Search of %s", html_url); storeAppendPrintf(entry, "<P>A CSO database usually contains a phonebook or\n" "directory. Use the search function of your browser to enter\n" "search terms.</P><ISINDEX>\n"); gopherHTMLFooter(entry); /* now let start sending stuff to client */ storeBufferFlush(entry); gopherState->HTML_header_added = 1; return; } inbuf[len] = '\0'; if (!gopherState->HTML_header_added) { if (gopherState->conversion == HTML_CSO_RESULT) gopherHTMLHeader(entry, "CSO Search Result", NULL); else gopherHTMLHeader(entry, "Gopher Menu", NULL); strCat(outbuf, "<PRE>"); gopherState->HTML_header_added = 1; gopherState->HTML_pre = 1; } while ((pos != NULL) && (pos < inbuf + len)) { if (gopherState->len != 0) { /* there is something left from last tx. */ xstrncpy(line, gopherState->buf, gopherState->len + 1); lpos = (char *) memccpy(line + gopherState->len, inbuf, '\n', len); if (lpos) *lpos = '\0'; else { /* there is no complete line in inbuf */ /* copy it to temp buffer */ if (gopherState->len + len > TEMP_BUF_SIZE) { debug(10, 1) ("GopherHTML: Buffer overflow. Lost some data on URL: %s\n", storeUrl(entry)); len = TEMP_BUF_SIZE - gopherState->len; } xmemcpy(gopherState->buf + gopherState->len, inbuf, len); gopherState->len += len; return; } /* skip one line */ pos = (char *) memchr(pos, '\n', len); if (pos) pos++; /* we're done with the remain from last tx. */ gopherState->len = 0; *(gopherState->buf) = '\0'; } else { lpos = (char *) memccpy(line, pos, '\n', len - (pos - inbuf)); if (lpos) *lpos = '\0'; else { /* there is no complete line in inbuf */ /* copy it to temp buffer */ if ((len - (pos - inbuf)) > TEMP_BUF_SIZE) { debug(10, 1) ("GopherHTML: Buffer overflow. Lost some data on URL: %s\n", storeUrl(entry)); len = TEMP_BUF_SIZE; } if (len > (pos - inbuf)) { xmemcpy(gopherState->buf, pos, len - (pos - inbuf)); gopherState->len = len - (pos - inbuf); } break; } /* skip one line */ pos = (char *) memchr(pos, '\n', len); if (pos) pos++; } /* at this point. We should have one line in buffer to process */ if (*line == '.') { /* skip it */ memset(line, '\0', TEMP_BUF_SIZE); continue; } switch (gopherState->conversion) { case HTML_INDEX_RESULT: case HTML_DIR:{ tline = line; gtype = *tline++; name = tline; selector = strchr(tline, TAB); if (selector) { *selector++ = '\0'; host = strchr(selector, TAB); if (host) { *host++ = '\0'; port = strchr(host, TAB); if (port) { char *junk; port[0] = ':'; junk = strchr(host, TAB); if (junk) *junk++ = 0; /* Chop port */ else { junk = strchr(host, '\r'); if (junk) *junk++ = 0; /* Chop port */ else { junk = strchr(host, '\n'); if (junk) *junk++ = 0; /* Chop port */ } } if ((port[1] == '0') && (!port[2])) port[0] = 0; /* 0 means none */ } /* escape a selector here */ escaped_selector = xstrdup(rfc1738_escape_part(selector)); switch (gtype) { case GOPHER_DIRECTORY: icon_url = mimeGetIconURL("internal-menu"); break; case GOPHER_HTML: case GOPHER_FILE: icon_url = mimeGetIconURL("internal-text"); break; case GOPHER_INDEX: case GOPHER_CSO: icon_url = mimeGetIconURL("internal-index"); break; case GOPHER_IMAGE: case GOPHER_GIF: case GOPHER_PLUS_IMAGE: icon_url = mimeGetIconURL("internal-image"); break; case GOPHER_SOUND: case GOPHER_PLUS_SOUND: icon_url = mimeGetIconURL("internal-sound"); break; case GOPHER_PLUS_MOVIE: icon_url = mimeGetIconURL("internal-movie"); break; case GOPHER_TELNET: case GOPHER_3270: icon_url = mimeGetIconURL("internal-telnet"); break; case GOPHER_BIN: case GOPHER_MACBINHEX: case GOPHER_DOSBIN: case GOPHER_UUENCODED: icon_url = mimeGetIconURL("internal-binary"); break; case GOPHER_INFO: icon_url = NULL; break; default: icon_url = mimeGetIconURL("internal-unknown"); break; } memset(tmpbuf, '\0', TEMP_BUF_SIZE); if ((gtype == GOPHER_TELNET) || (gtype == GOPHER_3270)) { if (strlen(escaped_selector) != 0) snprintf(tmpbuf, TEMP_BUF_SIZE, "<IMG border=\"0\" SRC=\"%s\"> <A HREF=\"telnet://%s@%s%s%s/\">%s</A>\n", icon_url, escaped_selector, rfc1738_escape_part(host), *port ? ":" : "", port, html_quote(name)); else snprintf(tmpbuf, TEMP_BUF_SIZE, "<IMG border=\"0\" SRC=\"%s\"> <A HREF=\"telnet://%s%s%s/\">%s</A>\n", icon_url, rfc1738_escape_part(host), *port ? ":" : "", port, html_quote(name)); } else if (gtype == GOPHER_INFO) { snprintf(tmpbuf, TEMP_BUF_SIZE, "\t%s\n", html_quote(name)); } else { if (strncmp(selector, "GET /", 5) == 0) { /* WWW link */ snprintf(tmpbuf, TEMP_BUF_SIZE, "<IMG border=\"0\" SRC=\"%s\"> <A HREF=\"http://%s/%s\">%s</A>\n", icon_url, host, rfc1738_escape_unescaped(selector + 5), html_quote(name)); } else { /* Standard link */ snprintf(tmpbuf, TEMP_BUF_SIZE, "<IMG border=\"0\" SRC=\"%s\"> <A HREF=\"gopher://%s/%c%s\">%s</A>\n", icon_url, host, gtype, escaped_selector, html_quote(name)); } } safe_free(escaped_selector); strCat(outbuf, tmpbuf); } else { memset(line, '\0', TEMP_BUF_SIZE); continue; } } else { memset(line, '\0', TEMP_BUF_SIZE); continue; } break; } /* HTML_DIR, HTML_INDEX_RESULT */ case HTML_CSO_RESULT:{ if (line[0] == '-') { int code, recno; char *s_code, *s_recno, *result; s_code = strtok(line + 1, ":\n"); s_recno = strtok(NULL, ":\n"); result = strtok(NULL, "\n"); if (!result) break; code = atoi(s_code); recno = atoi(s_recno); if (code != 200) break; if (gopherState->cso_recno != recno) { snprintf(tmpbuf, TEMP_BUF_SIZE, "</PRE><HR noshade size=\"1px\"><H2>Record# %d<br><i>%s</i></H2>\n<PRE>", recno, html_quote(result)); gopherState->cso_recno = recno; } else { snprintf(tmpbuf, TEMP_BUF_SIZE, "%s\n", html_quote(result)); } strCat(outbuf, tmpbuf); break; } else { int code; char *s_code, *result; s_code = strtok(line, ":"); result = strtok(NULL, "\n"); if (!result) break; code = atoi(s_code); switch (code) { case 200:{ /* OK */ /* Do nothing here */ break; } case 102: /* Number of matches */ case 501: /* No Match */ case 502: /* Too Many Matches */ { /* Print the message the server returns */ snprintf(tmpbuf, TEMP_BUF_SIZE, "</PRE><HR noshade size=\"1px\"><H2>%s</H2>\n<PRE>", html_quote(result)); strCat(outbuf, tmpbuf); break; } } } } /* HTML_CSO_RESULT */ default: break; /* do nothing */ } /* switch */ } /* while loop */ if (strLen(outbuf) > 0) { storeAppend(entry, strBuf(outbuf), strLen(outbuf)); /* now let start sending stuff to client */ storeBufferFlush(entry); } stringClean(&outbuf); return; }
int updateFragmentWithParent(IntUnitigMesg *iunitig, int thisFrag, OverlapStore *ovs) { uint32 ovlMax = 0; uint32 ovlLen = 0; OVSoverlap *ovl = NULL; int testFrag = thisFrag - 1; int testOvl = 0; int oldParent = iunitig->f_list[thisFrag].parent; int oldAHang = iunitig->f_list[thisFrag].ahang; int oldBHang = iunitig->f_list[thisFrag].bhang; uint32 consensusCutoff = AS_OVS_encodeQuality(AS_CNS_ERROR_RATE); int contained = 0; int fragment = -1; int overlap = -1; int overlapIdentity = consensusCutoff; int overlapBHang = AS_READ_MAX_NORMAL_LEN; HashTable_AS *ovlBefore = CreateScalarHashTable_AS(); HashTable_AS *ovlAfter = CreateScalarHashTable_AS(); HashTable_AS *iidIndex = CreateScalarHashTable_AS(); int hangSlop = 0; int failed = -1; fprintf(stderr, "\n"); fprintf(stderr, "WORKING on fragment %d == %d\n", thisFrag, iunitig->f_list[thisFrag].ident); // Save in the hash table the fragments before/after this one. // for (testFrag=0; testFrag<iunitig->num_frags; testFrag++) { InsertInHashTable_AS(iidIndex, (uint64)iunitig->f_list[testFrag].ident, sizeof(uint64), (uint64)testFrag, 0); if (testFrag < thisFrag) InsertInHashTable_AS(ovlBefore, (uint64)iunitig->f_list[testFrag].ident, sizeof(uint64), ~(uint64)0, 0); if (testFrag > thisFrag) InsertInHashTable_AS(ovlAfter, (uint64)iunitig->f_list[testFrag].ident, sizeof(uint64), ~(uint64)0, 0); } // Get the overlaps for this fragment. // AS_OVS_setRangeOverlapStore(ovs, iunitig->f_list[thisFrag].ident, iunitig->f_list[thisFrag].ident); if (ovlMax < AS_OVS_numOverlapsInRange(ovs)) { ovlMax = AS_OVS_numOverlapsInRange(ovs) * 2; ovl = (OVSoverlap *)safe_realloc(ovl, sizeof(OVSoverlap) * ovlMax); } ovlLen = 0; while (AS_OVS_readOverlapFromStore(ovs, ovl+ovlLen, AS_OVS_TYPE_OVL)) { int aid=0, bid=0; int afwd=0, bfwd=0; int correct=0; // Reorient the overlap so the b_iid is thisFrag. // { AS_IID x = ovl[ovlLen].a_iid; ovl[ovlLen].a_iid = ovl[ovlLen].b_iid; ovl[ovlLen].b_iid = x; if (ovl[ovlLen].dat.ovl.flipped) { int x = ovl[ovlLen].dat.ovl.a_hang; ovl[ovlLen].dat.ovl.a_hang = ovl[ovlLen].dat.ovl.b_hang; ovl[ovlLen].dat.ovl.b_hang = x; } else { ovl[ovlLen].dat.ovl.a_hang = -ovl[ovlLen].dat.ovl.a_hang; ovl[ovlLen].dat.ovl.b_hang = -ovl[ovlLen].dat.ovl.b_hang; } } // Make sure we get the correct overlap. We seem to be allowed // to have both an I and an N overlap for a given pair of // fragments. At least, I hope that's all we're allowed. // aid = LookupValueInHashTable_AS(iidIndex, (uint64)ovl[ovlLen].a_iid, sizeof(uint64)); bid = LookupValueInHashTable_AS(iidIndex, (uint64)ovl[ovlLen].b_iid, sizeof(uint64)); afwd = (iunitig->f_list[aid].position.bgn < iunitig->f_list[aid].position.end); bfwd = (iunitig->f_list[bid].position.bgn < iunitig->f_list[bid].position.end); if ((afwd == bfwd) && (ovl[ovlLen].dat.ovl.flipped == 0)) correct = 1; if ((afwd != bfwd) && (ovl[ovlLen].dat.ovl.flipped == 1)) correct = 1; if (ExistsInHashTable_AS(ovlBefore, (uint64)ovl[ovlLen].a_iid, sizeof(uint64))) { if (correct) ReplaceInHashTable_AS(ovlBefore, (uint64)ovl[ovlLen].a_iid, sizeof(uint64), (uint64)ovlLen, 0); fprintf(stderr, "%s before overlap for %d (%c) to %d (%c) ("F_S64","F_S64",%c) at ovl position %d\n", correct ? "save" : "skip", ovl[ovlLen].a_iid, afwd ? 'F' : 'R', ovl[ovlLen].b_iid, bfwd ? 'F' : 'R', ovl[ovlLen].dat.ovl.a_hang, ovl[ovlLen].dat.ovl.b_hang, ovl[ovlLen].dat.ovl.flipped ? 'I' : 'N', ovlLen); } if (ExistsInHashTable_AS(ovlAfter, (uint64)ovl[ovlLen].a_iid, sizeof(uint64))) { if (correct) ReplaceInHashTable_AS(ovlAfter, (uint64)ovl[ovlLen].a_iid, sizeof(uint64), (uint64)ovlLen, 0); fprintf(stderr, "%s after overlap for %d (%c) to %d (%c) ("F_S64","F_S64",%c) at ovl position %d\n", correct ? "save" : "skip", ovl[ovlLen].a_iid, afwd ? 'F' : 'R', ovl[ovlLen].b_iid, bfwd ? 'F' : 'R', ovl[ovlLen].dat.ovl.a_hang, ovl[ovlLen].dat.ovl.b_hang, ovl[ovlLen].dat.ovl.flipped ? 'I' : 'N', ovlLen); } ovlLen++; } tryAgain: // See if we're contained in any of these overlaps. if (overlap == -1) { for (testFrag=thisFrag-1; testFrag>=0; testFrag--) { if (ExistsInHashTable_AS(ovlBefore, (uint64)iunitig->f_list[testFrag].ident, sizeof(uint64))) { testOvl = LookupValueInHashTable_AS(ovlBefore, (uint64)iunitig->f_list[testFrag].ident, sizeof(uint64)); // Fragment has no overlap if (testOvl == -1) continue; fprintf(stderr, "found testFrag = %d testOvl = %d erates "F_U64" %u hang "F_S64" "F_S64" (CONTAIN) slop=%d\n", testFrag, testOvl, ovl[testOvl].dat.ovl.orig_erate, consensusCutoff, ovl[testOvl].dat.ovl.a_hang, ovl[testOvl].dat.ovl.b_hang, hangSlop); // Three if's for documentation: // 1) If we're an overlap we care about // 2) If we're a contained overlap // 3) If we're better than what we've seen so far // Then save the overlap // if (ovl[testOvl].dat.ovl.orig_erate < consensusCutoff) { if ((ovl[testOvl].dat.ovl.a_hang >= -hangSlop) && (ovl[testOvl].dat.ovl.b_hang <= hangSlop)) { if (ovl[testOvl].dat.ovl.orig_erate < overlapIdentity) { contained = 1; fragment = testFrag; overlap = testOvl; overlapBHang = 0; overlapIdentity = ovl[testOvl].dat.ovl.orig_erate; } } } } } } // If not contained, scan the overlaps again, looking for the // thickest/bestest. This will be the overlap with the smallest a // or b hang -- depending on the orientation of the parent // fragment. // // Instead of working through overlaps, we work through fragments. // if (overlap == -1) { for (testFrag=thisFrag-1; testFrag>=0; testFrag--) { if (ExistsInHashTable_AS(ovlBefore, (uint64)iunitig->f_list[testFrag].ident, sizeof(uint64))) { int ahang = 0; int bhang = 0; testOvl = LookupValueInHashTable_AS(ovlBefore, (uint64)iunitig->f_list[testFrag].ident, sizeof(uint64)); // Fragment has no overlap if (testOvl == -1) continue; // Overlap is too noisy if (ovl[testOvl].dat.ovl.orig_erate >= consensusCutoff) continue; if (iunitig->f_list[testFrag].position.bgn < iunitig->f_list[testFrag].position.end) { ahang = ovl[testOvl].dat.ovl.a_hang; bhang = ovl[testOvl].dat.ovl.b_hang; } else { ahang = -ovl[testOvl].dat.ovl.b_hang; bhang = -ovl[testOvl].dat.ovl.a_hang; } // Overlap isn't dovetail -- negative ahang if (ahang < 0) continue; // Overlap isn't dovetail -- containment if (bhang < 0) continue; fprintf(stderr, "found testFrag = %d testOvl = %d erates "F_U64" %u hang "F_S64" "F_S64" (DOVETAIL) slop=%d\n", testFrag, testOvl, ovl[testOvl].dat.ovl.orig_erate, consensusCutoff, ovl[testOvl].dat.ovl.a_hang, ovl[testOvl].dat.ovl.b_hang, hangSlop); if (bhang < overlapBHang) { contained = 0; fragment = testFrag; overlap = testOvl; overlapIdentity = ovl[testOvl].dat.ovl.orig_erate; overlapBHang = bhang; } } } } // Now, if we have found the parent fragment, update. // if (overlap >= 0) { testOvl = overlap; testFrag = fragment; iunitig->f_list[thisFrag].parent = ovl[testOvl].a_iid; if (contained) iunitig->f_list[thisFrag].contained = iunitig->f_list[thisFrag].parent; else iunitig->f_list[thisFrag].contained = 0; // Reorient again based on the orientation of the testFrag. // if (iunitig->f_list[testFrag].position.bgn < iunitig->f_list[testFrag].position.end) { // testFrag is forward iunitig->f_list[thisFrag].ahang = ovl[testOvl].dat.ovl.a_hang; iunitig->f_list[thisFrag].bhang = ovl[testOvl].dat.ovl.b_hang; } else { // testFrag is reverse iunitig->f_list[thisFrag].ahang = -ovl[testOvl].dat.ovl.b_hang; iunitig->f_list[thisFrag].bhang = -ovl[testOvl].dat.ovl.a_hang; } // Report we did something. // fprintf(stderr, "Updated fragment "F_IID" from "F_IID",%d,%d to "F_IID",%d,%d\n", iunitig->f_list[thisFrag].ident, oldParent, oldAHang, oldBHang, iunitig->f_list[thisFrag].parent, iunitig->f_list[thisFrag].ahang, iunitig->f_list[thisFrag].bhang); goto successfullyUpdated; } // Otherwise, try to find an overlap again, this time allowing a // bit of slop in the hangs. // if (hangSlop == 0) { hangSlop = 10; goto tryAgain; } // Now, we're convinced there is no decent overlap between this // fragment and any fragment before it. // // Scan forward for the first thing we overlap. for (testFrag=thisFrag+1; testFrag < iunitig->num_frags; testFrag++) { int ahang = 0; int bhang = 0; testOvl = LookupValueInHashTable_AS(ovlAfter, (uint64)iunitig->f_list[testFrag].ident, sizeof(uint64)); // Fragment has no overlap if (testOvl == -1) continue; // Overlap is too noisy if (ovl[testOvl].dat.ovl.orig_erate >= consensusCutoff) continue; if (iunitig->f_list[testFrag].position.bgn < iunitig->f_list[testFrag].position.end) { ahang = ovl[testOvl].dat.ovl.a_hang; bhang = ovl[testOvl].dat.ovl.b_hang; } else { ahang = -ovl[testOvl].dat.ovl.b_hang; bhang = -ovl[testOvl].dat.ovl.a_hang; } // Don't allow negative ahangs. At all. This catches the case // where the parent might be contained in us, and generally makes // consensus happier. // // Don't allow empty hangs - this can lead to infinite loops // where we keep swapping the same two fragments. OK, not // infinite, since we eventually run out of stack space and // crash. // if (ahang <= 0) continue; fprintf(stderr, "shifttest ovl=%d testFrag="F_IID" pos %d-%d thisFrag="F_IID" pos %d-%d hangs %d,%d\n", testOvl, iunitig->f_list[testFrag].ident, iunitig->f_list[testFrag].position.bgn, iunitig->f_list[testFrag].position.end, iunitig->f_list[thisFrag].ident, iunitig->f_list[thisFrag].position.bgn, iunitig->f_list[thisFrag].position.end, ahang, bhang); IntMultiPos fragCopy = iunitig->f_list[thisFrag]; memmove(iunitig->f_list + thisFrag, iunitig->f_list + thisFrag + 1, sizeof(IntMultiPos) * (testFrag - thisFrag)); iunitig->f_list[testFrag] = fragCopy; fprintf(stderr, "Shifted fragment "F_IID" from position %d to position %d\n", iunitig->f_list[testFrag].ident, thisFrag, testFrag); // Since we moved things around, we must process the new fragment // at 'thisFrag's location. // failed = updateFragmentWithParent(iunitig, thisFrag, ovs); if (failed == -1) goto successfullyUpdated; break; } // And we failed. Good luck with this one. // fprintf(stderr, "Failed to update fragment "F_IID" from "F_IID",%d,%d.\n", iunitig->f_list[thisFrag].ident, oldParent, oldAHang, oldBHang); failed = thisFrag; successfullyUpdated: DeleteHashTable_AS(ovlBefore); DeleteHashTable_AS(ovlAfter); safe_free(ovl); return(failed); }
static void locationRewriteStateFree(rewriteStateData * r) { safe_free(r->orig_url); cbdataFree(r); }
int create_a_graph( int Proc, int Num_Proc, PROB_INFO_PTR prob, PARIO_INFO_PTR pio_info, MESH_INFO_PTR mesh) { const char *yo = "create_a_graph"; /* The graph (and geometry) is created in parallel by each process, as opposed to being * created by process 0 and then dealt out to the other processes. This allows us to * create graphs where the number of vertices is larger than a number which would * fit in the memory of one process. * * Geometrically the graph is a cylinder extending in the z-direction. * * Each process creates points along a circle in an x-y plane, and knows which process has the * plane adjacent to it and what global ID has been assigned to the neighbors with the same * x and y value as its points. So adjacency information is easily created. */ ZOLTAN_ID_TYPE i, j, nvtxs, gnvtxs, num4; ZOLTAN_ID_TYPE gid; long left=0, right=0; int vwgt_dim=0, ewgt_dim=0; int ndim = 0, next; int *start; ZOLTAN_ID_TYPE *adj = NULL; float *ewgts = NULL, *vwgts = NULL; float *x = NULL, *y = NULL, *z = NULL; double theta, delta, radius, m, length, step; /***************************** BEGIN EXECUTION ******************************/ DEBUG_TRACE_START(Proc, yo); gnvtxs = pio_info->init_size; ndim = pio_info->init_dim; vwgt_dim = pio_info->init_vwgt_dim; if (vwgt_dim<1) vwgt_dim=1; /* For now, insist on 1 or more weights. */ /* for simplicity coerce number of vertices on a process to a multiple of 4 */ nvtxs = gnvtxs / Num_Proc; if (nvtxs > 4){ num4 = nvtxs / 4; nvtxs = num4 * 4; } else{ num4 = 1; nvtxs = 4; } gnvtxs = (ZOLTAN_ID_TYPE)nvtxs * Num_Proc; if (Proc == 0){ printf("create_a_graph: Graph will have " ZOLTAN_ID_SPEC " vertices, " ZOLTAN_ID_SPEC " on each process\n", gnvtxs, nvtxs); } /* Each process has the same number of vertices. Let's determine their global IDs */ initialize_vertex_global_id_info(nvtxs, Num_Proc); /* Calculate vertex coordinates and adjacencies */ x = (float *) malloc(nvtxs * sizeof(float)); if (ndim > 1) y = (float *) malloc(nvtxs * sizeof(float)); if (ndim > 2) z = (float *) malloc(nvtxs * sizeof(float)); vwgts = (float *) malloc(vwgt_dim*nvtxs * sizeof(float)); if (!x || (ndim > 1 && !y) || (ndim > 2 && !z) || !vwgts) { Gen_Error(0, "fatal: Error allocating memory."); return 0; } if (ndim == 1){ /* a line */ step = 1.0 / 500.0; length = (double)nvtxs * step; x[0] = length * (float)Proc; for (i=1; i < nvtxs; i++){ x[i] = x[i+1] + step; } } else if (ndim == 2){ /* a circle */ radius = (double)nvtxs/500.0; theta = (2 * M_PI ) / (double)Num_Proc; delta = theta / (double)nvtxs; m = (theta * Proc); for (i=0; i < nvtxs; i++, m += delta){ x[i] = radius * cos(m); y[i] = radius * sin(m); } } else if (ndim == 3){ /* a cylinder */ radius = (double)nvtxs/500.0; delta = M_PI_2 / (double)(num4 + 1); theta = delta; i = 0; while (theta < M_PI_2){ /* points along first quadrant of a circle in the plane z=Proc */ x[i] = radius * cos(theta); y[i] = radius * sin(theta); z[i] = (float)Proc; theta += delta; i++; } for (i=0; i < num4; i++){ /* second quadrant */ x[num4+i] = -x[num4 - i - 1]; y[num4+i] = y[num4 - i - 1]; z[num4+i] = (float)Proc; /* third quadrant */ x[2*num4+i] = -x[i]; y[2*num4+i] = -y[i]; z[2*num4+i] = (float)Proc; /* third quadrant */ x[3*num4+i] = x[num4 - i - 1]; y[3*num4+i] = -y[num4 - i - 1]; z[3*num4+i] = (float)Proc; } } for (i = 0; i < nvtxs; i++) { if (pio_info->init_vwgt_dim == 0) /* Unit weights if no weights were requested. */ vwgts[i] = 1.0; else srand(0); for (j = 0; j < vwgt_dim; j++) { /* Only assign one of the weight dimensions a weight>0. */ /* Modify to get more complicated test cases. */ if (j == i%vwgt_dim) vwgts[i*vwgt_dim+j] = ((float) rand())/RAND_MAX; else vwgts[i*vwgt_dim+j] = 0.0; } } start = (int *)malloc(sizeof(int) * (nvtxs + 1)); if (ndim < 3){ /* each vertex has one or two neighbors */ adj = (ZOLTAN_ID_TYPE *)malloc(sizeof(ZOLTAN_ID_TYPE) * 2 * nvtxs); start[0] = 0; next = 0; for (i=0; i < nvtxs; i++){ gid = local_to_global_id_map(i, Proc); if (ndim == 1){ left = gid - 1; right = gid + 1; } else if (ndim == 2){ left = (gid == 0) ? (gnvtxs - 1) : (gid - 1); right = (gid == gnvtxs - 1) ? 0 : (gid + 1); } start[i+1] = start[i]; if (left >= 0){ adj[next++] = left; start[i+1]++; } if (right < gnvtxs){ adj[next++] = left; start[i+1]++; } } } else{ /* each vertex has 2 neighbors on this process, and one or two off process */ adj = (ZOLTAN_ID_TYPE *)malloc(sizeof(ZOLTAN_ID_TYPE) * 4 * nvtxs); start[0] = 0; next = 0; for (i=0; i < nvtxs; i++){ gid = local_to_global_id_map(i, Proc); left = (i == 0) ? local_to_global_id_map(nvtxs-1, Proc) : local_to_global_id_map(i-1, Proc); right = (i == nvtxs-1) ? local_to_global_id_map(0, Proc) : local_to_global_id_map(i+1, Proc); start[i+1] = start[i]; adj[next++] = left; start[i+1]++; adj[next++] = right; start[i+1]++; left = gid - nvtxs; right = gid + nvtxs; if (left >= 0){ adj[next++] = left; start[i+1]++; } if (right < gnvtxs){ adj[next++] = right; start[i+1]++; } } } /* TODO - edge weights? */ if (!setup_mesh_struct(Proc, Num_Proc, prob, mesh, pio_info, gnvtxs, nvtxs, start, adj, vwgt_dim, vwgts, ewgt_dim, ewgts, ndim, x, y, z)){ Gen_Error(0, "fatal: Error returned from chaco_setup_mesh_struct"); return 0; } safe_free((void **) &adj); safe_free((void **) &vwgts); safe_free((void **) &ewgts); safe_free((void **) &start); safe_free((void **) &x); safe_free((void **) &y); safe_free((void **) &z); DEBUG_TRACE_END(Proc, yo); return 1; }
int32 main(int32 argc, char **argv) { int32 arg = 1; int32 err = 0; int32 hlp = 0; char * gkpStoreName = NULL; int32 gkpStorePart = 0; char * msgFile = NULL; char * outputFileName= NULL; char * seqAn = NULL; char * wrkDir = NULL; char * seqStoreName = NULL; int32 seqStoreVer = 0; int32 seqStorePart = 0; argc = AS_configure(argc, argv); while (arg < argc) { if (strcmp(argv[arg], "-c") == 0) { msgFile = argv[++arg]; } else if (strcmp(argv[arg], "-G") == 0) { gkpStoreName = argv[++arg]; } else if (strcmp(argv[arg], "-S") == 0) { gkpStorePart = atoi(argv[++arg]); } else if (strcmp(argv[arg], "-o") == 0) { outputFileName = argv[++arg]; } else if (strcmp(argv[arg], "-s") == 0) { seqAn = argv[++arg]; } else if (strcmp(argv[arg], "-w") == 0) { wrkDir = argv[++arg]; } else if (strcmp(argv[arg], "-u") == 0) { seqStoreName = argv[++arg]; } else if (strcmp(argv[arg], "-V") == 0) { seqStoreVer = atoi(argv[++arg]); } else if (strcmp(argv[arg], "-p") == 0) { seqStorePart = atoi(argv[++arg]); } else { err++; } arg++; } if ((err) || (gkpStoreName == NULL) || (msgFile == NULL) || (outputFileName == NULL) || seqAn == NULL) { fprintf(stderr, "USAGE: SeqAn_CNS -G <gkpStore> -c <input.cgb> -o <output.cgi> -s <seqan_executable> [-u seqstore, required for contig consensus] [-w working directory]\n"); exit(1); } gkStore *gkpStore = new gkStore(gkpStoreName, FALSE, FALSE); gkpStore->gkStore_loadPartition(gkpStorePart); gkFragment fr; GenericMesg *pmesg; tSequenceDB *sequenceDB = NULL; FILE *infp = fopen(msgFile,"r"); FILE *tempReads; FILE *outfp = fopen(outputFileName, "w"); char fileName[AS_SEQAN_MAX_BUFFER_LENGTH]; char *prefix = outputFileName; getFileName(prefix, wrkDir, AS_SEQAN_INPUT_NAME, fileName); int32 i = 0; while ((EOF != ReadProtoMesg_AS(infp, &pmesg))) { int32 freeMem = 0; if (pmesg->t == MESG_IUM) { IntUnitigMesg *ium_mesg = (IntUnitigMesg *)pmesg->m; if (strlen(ium_mesg->consensus) == 0) { tempReads = fopen(fileName,"w"); for (i =0; i < ium_mesg->num_frags; i++) { // get the fragment sequence gkpStore->gkStore_getFragment(ium_mesg->f_list[i].ident, &fr, GKFRAGMENT_QLT); uint32 clrBeg = fr.gkFragment_getClearRegionBegin(); uint32 clrEnd = fr.gkFragment_getClearRegionEnd (); char *seqStart = fr.gkFragment_getSequence(); char *seq = seqStart+clrBeg; seq[clrEnd] = 0; AS_UTL_writeFastA(tempReads, seq, clrEnd-clrBeg, ">"F_IID","F_IID"\n", ium_mesg->f_list[i].position.bgn, ium_mesg->f_list[i].position.end); } fclose(tempReads); updateRecord(ium_mesg, fileName, seqAn, prefix, wrkDir); freeMem = 1; } WriteProtoMesg_AS(outfp, pmesg); if (freeMem) { safe_free(ium_mesg->consensus); safe_free(ium_mesg->quality); } } else if (pmesg->t == MESG_ICM) { IntConConMesg *icm_mesg = (IntConConMesg *)pmesg->m; if (seqStoreName == NULL) { fprintf(stderr, "USAGE: The -u option is required for contig consensus\n"); exit(1); } if (sequenceDB == NULL) { sequenceDB = openSequenceDB(seqStoreName, FALSE, seqStoreVer); openSequenceDBPartition(sequenceDB, seqStorePart); } if (strlen(icm_mesg->consensus) == 0) { tempReads = fopen(fileName,"w"); for (i =0; i < icm_mesg->num_pieces; i++) { // get the fragment sequence gkpStore->gkStore_getFragment(icm_mesg->pieces[i].ident, &fr, GKFRAGMENT_QLT); uint32 clrBeg = fr.gkFragment_getClearRegionBegin(); uint32 clrEnd = fr.gkFragment_getClearRegionEnd (); char *seqStart = fr.gkFragment_getSequence(); char *seq = seqStart+clrBeg; seq[clrEnd] = 0; AS_UTL_writeFastA(tempReads, seq, clrEnd-clrBeg, ">"F_IID","F_IID"\n", icm_mesg->pieces[i].position.bgn, icm_mesg->pieces[i].position.end); } // now handle the unitig messages for (i =0; i < icm_mesg->num_unitigs; i++) { VA_TYPE(char) *ungappedSequence = CreateVA_char(0); VA_TYPE(char) *ungappedQuality = CreateVA_char(0); MultiAlignT *uma = loadMultiAlignTFromSequenceDB(sequenceDB, icm_mesg->unitigs[i].ident, 1); assert(uma != NULL); GetMultiAlignUngappedConsensus(uma, ungappedSequence, ungappedQuality); char * seq = Getchar(ungappedSequence,0); AS_UTL_writeFastA(tempReads, seq, strlen(seq), ">"F_IID","F_IID"\n", icm_mesg->unitigs[i].position.bgn, icm_mesg->unitigs[i].position.end); } fclose(tempReads); updateICMRecord(icm_mesg, fileName, seqAn, prefix, wrkDir); freeMem = 1; } WriteProtoMesg_AS(outfp, pmesg); if (freeMem) { safe_free(icm_mesg->consensus); safe_free(icm_mesg->quality); } } } fclose(infp); fclose(outfp); return 0; }
int create_random_triangles( int Proc, int Num_Proc, PROB_INFO_PTR prob, PARIO_INFO_PTR pio_info, MESH_INFO_PTR mesh) { /* Local declarations. */ const char *yo = "create_random_input"; int i, j, w, nvtxs, gnvtxs, ntri; int vwgt_dim=0, ewgt_dim=0; int ndim = 0; int *start = NULL, *adj = NULL; int no_geom = FALSE; float *ewgts = NULL, *vwgts = NULL; float *x = NULL, *y = NULL, *z = NULL; float wgt, diff; short *assignments = NULL; char filename[256]; FILE *fpg = NULL, *fpc = NULL; /* Files to echo random input */ /***************************** BEGIN EXECUTION ******************************/ DEBUG_TRACE_START(Proc, yo); if (Proc == 0) { /* Adapted from read_chaco_graph; build same values as read_chaco_graph * and then let random input be distributed as a Chaco graph would be. */ /* read the array in on processor 0 */ ntri = (int)pio_info->init_size; nvtxs = ntri * 3; ndim = pio_info->init_dim; vwgt_dim = pio_info->init_vwgt_dim; if (vwgt_dim<1) vwgt_dim=1; /* For now, insist on 1 or more weights. */ if (ntri <= OUTPUT_FILES_MAX_NVTXS) { sprintf(filename, "%s.graph", pio_info->pexo_fname); fpg = fopen(filename, "w"); sprintf(filename, "%s.coords", pio_info->pexo_fname); fpc = fopen(filename, "w"); } if (nvtxs > 0) { /* Allocate space for vertex weights and coordinates. */ x = (float *) malloc(nvtxs * sizeof(float)); if (ndim > 1) y = (float *) malloc(nvtxs * sizeof(float)); if (ndim > 2) z = (float *) malloc(nvtxs * sizeof(float)); vwgts = (float *) malloc(vwgt_dim*nvtxs * sizeof(float)); if (!x || (ndim > 1 && !y) || (ndim > 2 && !z) || !vwgts) { Gen_Error(0, "fatal: Error allocating memory."); return 0; } /* Generate random triangles and vertex weights. */ srand(0); diff = 1.0/50.0; switch (ndim) { case 1: for (i = 0; i < nvtxs; i+=3) { x[i] = ((float) rand())/RAND_MAX; x[i+1] = x[i] - diff; x[i+2] = x[i] + diff; if (fpc != NULL) fprintf(fpc, "%e\n%e\n%e\n", x[i],x[i+1],x[i+2]); } break; case 2: for (i = 0; i < nvtxs; i+=3) { x[i] = ((float) rand())/RAND_MAX; y[i] = ((float) rand())/RAND_MAX; x[i+1] = x[i] - diff; y[i+1] = y[i]; x[i+2] = x[i]; y[i+2] = y[i] + diff; if (fpc != NULL) fprintf(fpc, "%e %e\n%e %e\n%e %e\n", x[i], y[i],x[i+1], y[i+1],x[i+2], y[i+2]); } break; case 3: for (i = 0; i < nvtxs; i+=3) { x[i] = ((float) rand())/RAND_MAX; y[i] = ((float) rand())/RAND_MAX; z[i] = ((float) rand())/RAND_MAX; x[i+1] = x[i] - diff; y[i+1] = y[i]; z[i+1] = z[i]; x[i+2] = x[i]; y[i+2] = y[i] + diff; z[i+2] = z[i]; if (fpc != NULL) fprintf(fpc, "%e %e %e\n%e %e %e\n%e %e %e\n", x[i], y[i], z[i],x[i+1], y[i+1], z[i+1],x[i+2], y[i+2], z[i+2]); } break; } if (pio_info->init_vwgt_dim == 0) { for (i = 0; i < nvtxs; i++) { /* Unit weights if no weights were requested. */ vwgts[i] = 1.0; } } else{ memset(vwgts, 0, nvtxs * sizeof(float)); for (i=0,w=0; i < ntri; i++) { for (j = 0; j < vwgt_dim; j++) { /* Each point of triangle gets the same weight. */ /* Only assign one of the weight dimensions a weight>0. */ /* Modify to get more complicated test cases. */ if (j == i%vwgt_dim){ wgt = ((float) rand())/RAND_MAX; vwgts[w+j] = wgt; w += vwgt_dim; vwgts[w+j] = wgt; w += vwgt_dim; vwgts[w+j] = wgt; w += vwgt_dim; } } } } /* Each vertex has two neighbors */ ewgt_dim = 0; start = (int *) malloc((nvtxs+1) * sizeof(int)); adj = (int *)malloc(nvtxs*2*sizeof(int)); ewgts = NULL; for (i = 0; i <= nvtxs; i++) { start[i] = i*2; } for (i=0, w=0, j=1; i < ntri; i++,j+=3){ /* j is first vertex (1-based) in triangle */ adj[w++] = j+1; /* adjacencies of vertex j */ adj[w++] = j+2; adj[w++] = j+2; /* adjacencies of vertex j+1 */ adj[w++] = j; adj[w++] = j; /* adjacencies of vertex j+2 */ adj[w++] = j+1; } if (fpg != NULL) { if (vwgt_dim==1) fprintf(fpg, "%d %d 010\n", nvtxs, nvtxs); else fprintf(fpg, "%d %d 010 %d\n", nvtxs, nvtxs, vwgt_dim); for (i = 0, w=0; i < nvtxs; i++, w += 2) { for (j = 0; j < vwgt_dim; j++) fprintf(fpg, "%e ", vwgts[i*vwgt_dim+j]); fprintf(fpg, "%d %d",adj[w],adj[w+1]); fprintf(fpg, "\n"); } } } if (fpg != NULL) fclose(fpg); if (fpc != NULL) fclose(fpc); } /* Distribute graph */ if (!chaco_dist_graph(MPI_COMM_WORLD, pio_info, 0, &gnvtxs, &nvtxs, &start, &adj, &vwgt_dim, &vwgts, &ewgt_dim, &ewgts, &ndim, &x, &y, &z, &assignments)) { Gen_Error(0, "fatal: Error returned from chaco_dist_graph"); return 0; } if (!chaco_setup_mesh_struct(Proc, Num_Proc, prob, mesh, pio_info, gnvtxs, nvtxs, start, adj, vwgt_dim, vwgts, ewgt_dim, ewgts, ndim, x, y, z, assignments, 1, no_geom)) { Gen_Error(0, "fatal: Error returned from chaco_setup_mesh_struct"); return 0; } safe_free((void **)(void *) &adj); safe_free((void **)(void *) &vwgts); safe_free((void **)(void *) &ewgts); safe_free((void **)(void *) &start); safe_free((void **)(void *) &x); safe_free((void **)(void *) &y); safe_free((void **)(void *) &z); safe_free((void **)(void *) &assignments); DEBUG_TRACE_END(Proc, yo); return 1; }
END_TEST START_TEST (test_util_trim) { char *p, *q, *r, *s, *t, *u, *v, *w, *x, *y, *z; fail_unless( !strcmp( p = util_trim("p" ), "p") ); fail_unless( !strcmp( q = util_trim("q " ), "q") ); fail_unless( !strcmp( r = util_trim(" r" ), "r") ); fail_unless( !strcmp( s = util_trim(" s "), "s") ); fail_unless( !strcmp( t = util_trim("foo" ), "foo") ); fail_unless( !strcmp( u = util_trim("foo " ), "foo") ); fail_unless( !strcmp( v = util_trim(" bar" ), "bar") ); fail_unless( !strcmp( w = util_trim(" bar "), "bar") ); fail_unless( !strcmp( x = util_trim(" foo bar " ), "foo bar") ); fail_unless( !strcmp( y = util_trim(" "), "") ); fail_unless( !strcmp( z = util_trim("" ), "") ); fail_unless( util_trim((char *) NULL) == NULL ); safe_free(p); safe_free(q); safe_free(r); safe_free(s); safe_free(t); safe_free(u); safe_free(v); safe_free(w); safe_free(x); safe_free(y); safe_free(z); }
static void idnsFreeNameservers(void) { safe_free(nameservers); nns = nns_alloc = 0; }
void NemSpread<T,INT>::load_lb_info(void) /* * load_lb_info: * * This function reads and distributes the load balance information. * This information is defined as the following scalars, which are specific * to each processor: * * Num_Internal_Nodes * Num_Border_Nodes * Num_External_Nodes * globals.Num_Internal_Elems * globals.Num_Border_Elems * * and the following vectors, also specific to each processor: * * globals.GNodes [Num_Internal_Nodes+Num_Border_Nodes+Num_External_Nodes] * globals.GElems [globals.Num_Internal_Elems+globals.Num_Border_Elems] * * For the 1 processor case, this routine fills in appropriate values * for these quantities. */ { int lb_exoid=0; INT cmap_max_size=0, *comm_vec; const char *yo = "load_lb_info"; char Title[MAX_LINE_LENGTH+1]; float version; int cpu_ws=0; /******************************** START EXECUTION ****************************/ if(Debug_Flag) printf ("\nStart to read in and distribute the load balance info\n"); /* Open the Load Balance exoII file for reading */ printf ("EXODUS II load-balance file: %s\n", Exo_LB_File); cpu_ws = io_ws; int mode = EX_READ | int64api; int iio_ws = 0; // Don't interfere with exodus files; this is the nemesis file. if((lb_exoid = ex_open(Exo_LB_File, mode, &cpu_ws, &iio_ws, &version)) == -1) { fprintf(stderr, "%sERROR: Couldn\'t open lb file, %s\n", yo, Exo_LB_File); exit(1); } /* Read information about the processor configuration */ read_proc_init(lb_exoid,Proc_Info, &Proc_Ids); /* Allocate space for the counts */ globals.Num_Internal_Nodes = (INT *)array_alloc(__FILE__, __LINE__, 1, 7*Proc_Info[2], sizeof(INT)); globals.Num_Border_Nodes = globals.Num_Internal_Nodes +Proc_Info[2]; globals.Num_External_Nodes = globals.Num_Border_Nodes +Proc_Info[2]; globals.Num_Internal_Elems = globals.Num_External_Nodes +Proc_Info[2]; globals.Num_Border_Elems = globals.Num_Internal_Elems +Proc_Info[2]; globals.Num_N_Comm_Maps = globals.Num_Border_Elems +Proc_Info[2]; globals.Num_E_Comm_Maps = globals.Num_N_Comm_Maps +Proc_Info[2]; /* Allocate space for each processor entity */ globals.GNodes = (INT **)array_alloc(__FILE__, __LINE__, 1, 3*Proc_Info[2], sizeof(INT *)); globals.GElems = globals.GNodes +Proc_Info[2]; globals.Elem_Map = globals.GElems +Proc_Info[2]; /* Allocate contiguous space for the pointer vectors on all processors */ INT *Int_Space = (INT *)array_alloc(__FILE__, __LINE__, 1, (7*Proc_Info[0] + 1), sizeof(INT)); INT *Int_Node_Num = Int_Space + 1; INT *Bor_Node_Num = Int_Node_Num +Proc_Info[0]; INT *Ext_Node_Num = Bor_Node_Num +Proc_Info[0]; INT *Int_Elem_Num = Ext_Node_Num +Proc_Info[0]; INT *Bor_Elem_Num = Int_Elem_Num +Proc_Info[0]; INT *Node_Comm_Num = Bor_Elem_Num +Proc_Info[0]; INT *Elem_Comm_Num = Node_Comm_Num +Proc_Info[0]; /* Read the initial information contained in the load balance file */ read_lb_init(lb_exoid, Int_Space, Int_Node_Num, Bor_Node_Num, Ext_Node_Num, Int_Elem_Num, Bor_Elem_Num, Node_Comm_Num, Elem_Comm_Num, Title); /* Allocate memory for the communication map arrays */ globals.N_Comm_Map = (NODE_COMM_MAP<INT>**)malloc(Proc_Info[2]*sizeof(NODE_COMM_MAP<INT> *)); globals.E_Comm_Map = (ELEM_COMM_MAP<INT>**)malloc(Proc_Info[2]*sizeof(ELEM_COMM_MAP<INT> *)); if(!globals.N_Comm_Map || !globals.E_Comm_Map) { fprintf(stderr, "ERROR: Insufficient memory!\n"); exit(1); } for (int iproc=0; iproc <Proc_Info[2]; iproc++) { /* * Error check: * Currently a maximum of one nodal communication map and one * elemental communication map is supported. */ if(globals.Num_N_Comm_Maps[iproc] > 1 || globals.Num_E_Comm_Maps[iproc] > 1) { fprintf(stderr, "%s: ERROR. Only 1 nodal and elemental comm map " "is supported\n", yo); exit(1); } else { /* Always allocate at least one and initialize the counts to 0 */ globals.N_Comm_Map[iproc] = (NODE_COMM_MAP<INT> *)malloc(PEX_MAX(1, globals.Num_N_Comm_Maps[iproc]) * sizeof(NODE_COMM_MAP<INT>)); if(globals.N_Comm_Map[iproc] == NULL && globals.Num_N_Comm_Maps[iproc] > 0) { fprintf(stderr, "%s: ERROR. Insufficient memory for nodal comm. map!\n", yo); exit(1); } for(size_t ijump=0; ijump < PEX_MAX(1, globals.Num_N_Comm_Maps[iproc]); ijump++) ((globals.N_Comm_Map[iproc])+ijump)->node_cnt = 0; globals.E_Comm_Map[iproc] = (ELEM_COMM_MAP<INT> *)malloc(PEX_MAX(1, globals.Num_E_Comm_Maps[iproc]) * sizeof(ELEM_COMM_MAP<INT>)); if(globals.E_Comm_Map[iproc] == NULL && globals.Num_E_Comm_Maps[iproc] > 0) { fprintf(stderr, "%s: ERROR. Insufficient memory for elemental comm. map!\n", yo); exit(1); } for(size_t ijump=0; ijump < PEX_MAX(1, globals.Num_E_Comm_Maps[iproc]); ijump++) ((globals.E_Comm_Map[iproc])+ijump)->elem_cnt = 0; } } /* End "for (int iproc=0; iproc <Proc_Info[2]; iproc++)" */ /* Set up each processor for the communication map parameters */ read_cmap_params(lb_exoid, Node_Comm_Num, Elem_Comm_Num, globals.Num_N_Comm_Maps, globals.Num_E_Comm_Maps, globals.E_Comm_Map, globals.N_Comm_Map, &cmap_max_size, &comm_vec); /* Allocate enough space to read the LB_data for one processor */ INT *Integer_Vector = (INT *)array_alloc(__FILE__, __LINE__, 1, Int_Space[0] + cmap_max_size, sizeof (INT)); /* * loop through the processors, one at a time, to read * their load balance information * * NOTE: From here on there are no provisions for multiple nodal * or elemental communication maps. */ size_t ijump = 0; /* keep track of where in comm_vec we are */ for (int iproc = 0; iproc <Proc_Info[0]; iproc++) { /* Get the node map for processor "iproc" */ if(ex_get_processor_node_maps(lb_exoid, &Integer_Vector[0], &Integer_Vector[Int_Node_Num[iproc]], &Integer_Vector[Int_Node_Num[iproc]+ Bor_Node_Num[iproc]], iproc) < 0) { fprintf(stderr, "%s: ERROR, failed to get node map for Proc %d!\n", yo, iproc); exit(1); } size_t vec_indx = Int_Node_Num[iproc] + Bor_Node_Num[iproc] + Ext_Node_Num[iproc]; /* Get the element map for processor number "iproc" */ if(ex_get_processor_elem_maps(lb_exoid, &Integer_Vector[vec_indx], &Integer_Vector[vec_indx+Int_Elem_Num[iproc]], iproc) < 0) { fprintf(stderr, "%s: ERROR, failed to get element map for Proc %d!\n", yo, iproc); exit(1); } if(Node_Comm_Num[iproc] > 0) { vec_indx += Int_Elem_Num[iproc] + Bor_Elem_Num[iproc]; if(ex_get_node_cmap(lb_exoid, comm_vec[ijump], &Integer_Vector[vec_indx], &Integer_Vector[vec_indx+comm_vec[ijump+1]], iproc) < 0) { /* * If there are disconnected mesh pieces, then it is * possible that there is no comminication between the * pieces and there will be no communication maps. Normally * this is a problem, so output a warning, but don't abort. */ fprintf(stderr, "%s: WARNING. Failed to get nodal comm map for Proc %d!\n", yo, iproc); } } if(Elem_Comm_Num[iproc] > 0) { vec_indx += 2*comm_vec[ijump+1]; if(ex_get_elem_cmap(lb_exoid, comm_vec[ijump+2], &Integer_Vector[vec_indx], &Integer_Vector[vec_indx+comm_vec[ijump+3]], &Integer_Vector[vec_indx+2*comm_vec[ijump+3]], iproc) < 0) { fprintf(stderr, "%s: ERROR. Failed to get elemental comm map for Proc %d!\n", yo, iproc); exit(1); } } /* * Communicate load balance information to the correct processor * - if iproc = Proc_Ids[*] then process the data instead. */ assert(Proc_Ids[iproc] == iproc); process_lb_data (Integer_Vector, iproc); /* * now move ijump to the next communications map * make sure to check if there are any for this processor */ if (Node_Comm_Num[iproc] > 0) ijump += 2; if (Elem_Comm_Num[iproc] > 0) ijump += 2; } /* Close the load balance file - we are finished with it */ if(ex_close (lb_exoid) == -1) { fprintf (stderr, "%sERROR: Error in closing load balance file\n", yo); exit(1); } /************************* Cleanup and Printout Phase ***********************/ /* Free temporary memory */ safe_free((void **) &Integer_Vector); if(num_qa_rec > 0) { for(int i = 0; i < length_qa; i++) safe_free((void **) &(qa_record_ptr[i])); safe_free((void **) &qa_record_ptr); } if(num_inf_rec > 0) { for(int i = 0; i < num_inf_rec; i++) safe_free((void **) &(inf_record_ptr[i])); safe_free((void **) &inf_record_ptr); } safe_free((void **) &Int_Space); safe_free((void **) &comm_vec); /*========================================================================*/ if(Debug_Flag) printf ("\nFinished distributing load balance info\n"); /* Output Detailed timing information for the progam */ /* * Print out a Large table of Load Balance Information if the debug_flag * setting is large enough */ if(Debug_Flag >= 7) { printf ("\n\n"); print_line ("=", 79); for (int iproc=0; iproc <Proc_Info[2]; iproc++) { printf("\n\t***For Processor %d***\n", Proc_Ids[iproc]); printf("\tInternal nodes owned by the current processor\n\t"); for(INT i = 0; i < globals.Num_Internal_Nodes[iproc]; i++) printf(" %lu", (size_t)globals.GNodes[iproc][i]); printf("\n"); printf("\tBorder nodes owned by the current processor\n\t"); for(INT i = 0; i < globals.Num_Border_Nodes[iproc]; i++) printf(" %lu", (size_t)globals.GNodes[iproc][i + globals.Num_Internal_Nodes[iproc]]); printf("\n"); if(globals.Num_External_Nodes[iproc] > 0) { printf("\tExternal nodes needed by the current processor\n\t"); for(INT i = 0; i < globals.Num_External_Nodes[iproc]; i++) printf(" %lu", (size_t)globals.GNodes[iproc][i + globals.Num_Internal_Nodes[iproc] + globals.Num_Border_Nodes[iproc]]); printf("\n"); } printf("\tInternal elements owned by the current processor\n\t"); for(INT i = 0; i < globals.Num_Internal_Elems[iproc]; i++) printf(" %lu", (size_t)globals.GElems[iproc][i]); printf("\n"); if(globals.Num_Border_Elems[iproc] > 0) { printf("\tBorder elements owned by the current processor\n\t"); for(INT i=0; i < globals.Num_Border_Elems[iproc]; i++) printf(" %lu", (size_t)globals.GElems[iproc][i+globals.Num_Internal_Elems[iproc]]); printf("\n"); } if(globals.Num_N_Comm_Maps[iproc] > 0) { printf("\tNodal Comm Map for the current processor\n"); printf("\t\tnode IDs:"); for(size_t i=0; i < globals.N_Comm_Map[iproc]->node_cnt; i++) printf(" %lu", (size_t)globals.N_Comm_Map[iproc]->node_ids[i]); printf("\n\t\tproc IDs:"); for(size_t i=0; i < globals.N_Comm_Map[iproc]->node_cnt; i++) printf(" %lu", (size_t)globals.N_Comm_Map[iproc]->proc_ids[i]); printf("\n"); } if(globals.Num_E_Comm_Maps[iproc] > 0) { printf("\tElemental Comm Map for the current processor\n"); printf("\t\telement IDs:"); for(size_t i=0; i < globals.E_Comm_Map[iproc]->elem_cnt; i++) printf(" %lu", (size_t)globals.E_Comm_Map[iproc]->elem_ids[i]); printf("\n\t\tside IDs:"); for(size_t i=0; i < globals.E_Comm_Map[iproc]->elem_cnt; i++) printf(" %lu", (size_t)globals.E_Comm_Map[iproc]->side_ids[i]); printf("\n\t\tproc IDs:"); for(size_t i=0; i < globals.E_Comm_Map[iproc]->elem_cnt; i++) printf(" %lu", (size_t)globals.E_Comm_Map[iproc]->proc_ids[i]); printf("\n"); } } printf("\n"); print_line ("=", 79); } } /* END of routine load_lb_info () ******************************************/
/* * Refresh the list of USB devices */ BOOL GetUSBDevices(DWORD devnum) { // The first two are standard Microsoft drivers (including the Windows 8 UASP one). // The rest are the vendor UASP drivers I know of so far - list may be incomplete! const char* storage_name[] = { "USBSTOR", "UASPSTOR", "VUSBSTOR", "ETRONSTOR", "ASUSSTPT" }; const char* scsi_name = "SCSI"; const char* usb_speed_name[USB_SPEED_MAX] = { "USB", "USB 1.0", "USB 1.1", "USB 2.0", "USB 3.0" }; // Hash table and String Array used to match a Device ID with the parent hub's Device Interface Path htab_table htab_devid = HTAB_EMPTY; StrArray dev_if_path; char letter_name[] = " (?:)"; char uefi_togo_check[] = "?:\\EFI\\Rufus\\ntfs_x64.efi"; BOOL r = FALSE, found = FALSE, is_SCSI; HDEVINFO dev_info = NULL; SP_DEVINFO_DATA dev_info_data; SP_DEVICE_INTERFACE_DATA devint_data; PSP_DEVICE_INTERFACE_DETAIL_DATA_A devint_detail_data; DEVINST parent_inst, grandparent_inst, device_inst; DWORD size, i, j, k, l, datatype, drive_index; ULONG list_size[ARRAYSIZE(storage_name)] = { 0 }, list_start[ARRAYSIZE(storage_name)] = { 0 }, full_list_size, ulFlags; HANDLE hDrive; LONG maxwidth = 0; int s, score, drive_number, remove_drive; char drive_letters[27], *device_id, *devid_list = NULL, entry_msg[128]; char *label, *entry, buffer[MAX_PATH], str[MAX_PATH], *method_str; usb_device_props props; IGNORE_RETVAL(ComboBox_ResetContent(hDeviceList)); StrArrayClear(&DriveID); StrArrayClear(&DriveLabel); StrArrayCreate(&dev_if_path, 128); // Add a dummy for string index zero, as this is what non matching hashes will point to StrArrayAdd(&dev_if_path, ""); device_id = (char*)malloc(MAX_PATH); if (device_id == NULL) goto out; // Build a hash table associating a CM Device ID of an USB device with the SetupDI Device Interface Path // of its parent hub - this is needed to retrieve the device speed dev_info = SetupDiGetClassDevsA(&_GUID_DEVINTERFACE_USB_HUB, NULL, NULL, DIGCF_PRESENT|DIGCF_DEVICEINTERFACE); if (dev_info != INVALID_HANDLE_VALUE) { if (htab_create(DEVID_HTAB_SIZE, &htab_devid)) { dev_info_data.cbSize = sizeof(dev_info_data); for (i=0; SetupDiEnumDeviceInfo(dev_info, i, &dev_info_data); i++) { if (usb_debug) uprintf("Processing Hub %d:", i + 1); devint_detail_data = NULL; devint_data.cbSize = sizeof(devint_data); // Only care about the first interface (MemberIndex 0) if ( (SetupDiEnumDeviceInterfaces(dev_info, &dev_info_data, &_GUID_DEVINTERFACE_USB_HUB, 0, &devint_data)) && (!SetupDiGetDeviceInterfaceDetailA(dev_info, &devint_data, NULL, 0, &size, NULL)) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER) && ((devint_detail_data = (PSP_DEVICE_INTERFACE_DETAIL_DATA_A)calloc(1, size)) != NULL) ) { devint_detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A); if (SetupDiGetDeviceInterfaceDetailA(dev_info, &devint_data, devint_detail_data, size, &size, NULL)) { // Find the Device IDs for all the children of this hub if (CM_Get_Child(&device_inst, dev_info_data.DevInst, 0) == CR_SUCCESS) { device_id[0] = 0; s = StrArrayAdd(&dev_if_path, devint_detail_data->DevicePath); if (usb_debug) uprintf(" Hub[%d] = '%s'", s, devint_detail_data->DevicePath); if ((s>= 0) && (CM_Get_Device_IDA(device_inst, device_id, MAX_PATH, 0) == CR_SUCCESS)) { if ((k = htab_hash(device_id, &htab_devid)) != 0) { htab_devid.table[k].data = (void*)(uintptr_t)s; } if (usb_debug) uprintf(" Found ID[%03d]: %s", k, device_id); while (CM_Get_Sibling(&device_inst, device_inst, 0) == CR_SUCCESS) { device_id[0] = 0; if (CM_Get_Device_IDA(device_inst, device_id, MAX_PATH, 0) == CR_SUCCESS) { if ((k = htab_hash(device_id, &htab_devid)) != 0) { htab_devid.table[k].data = (void*)(uintptr_t)s; } if (usb_debug) uprintf(" Found ID[%03d]: %s", k, device_id); } } } } } free(devint_detail_data); } } } SetupDiDestroyDeviceInfoList(dev_info); } free(device_id); // Build a single list of Device IDs from all the storage enumerators we know of full_list_size = 0; ulFlags = CM_GETIDLIST_FILTER_SERVICE; if (nWindowsVersion >= WINDOWS_7) ulFlags |= CM_GETIDLIST_FILTER_PRESENT; for (s=0; s<ARRAYSIZE(storage_name); s++) { // Get a list of device IDs for all USB storage devices // This will be used to find if a device is UASP if (CM_Get_Device_ID_List_SizeA(&list_size[s], storage_name[s], ulFlags) != CR_SUCCESS) list_size[s] = 0; if (list_size[s] != 0) full_list_size += list_size[s]-1; // remove extra NUL terminator } devid_list = NULL; if (full_list_size != 0) { full_list_size += 1; // add extra NUL terminator devid_list = (char*)malloc(full_list_size); if (devid_list == NULL) { uprintf("Could not allocate Device ID list\n"); return FALSE; } for (s=0, i=0; s<ARRAYSIZE(storage_name); s++) { list_start[s] = i; if (list_size[s] > 1) { if (CM_Get_Device_ID_ListA(storage_name[s], &devid_list[i], list_size[s], ulFlags) != CR_SUCCESS) continue; if (usb_debug) { uprintf("Processing IDs belonging to %s:", storage_name[s]); for (device_id = &devid_list[i]; *device_id != 0; device_id += strlen(device_id) + 1) uprintf(" %s", device_id); } // The list_size is sometimes larger than required thus we need to find the real end for (i += list_size[s]; i > 2; i--) { if ((devid_list[i-2] != '\0') && (devid_list[i-1] == '\0') && (devid_list[i] == '\0')) break; } } } } // Now use SetupDi to enumerate all our storage devices dev_info = SetupDiGetClassDevsA(&_GUID_DEVINTERFACE_DISK, NULL, NULL, DIGCF_PRESENT|DIGCF_DEVICEINTERFACE); if (dev_info == INVALID_HANDLE_VALUE) { uprintf("SetupDiGetClassDevs (Interface) failed: %s\n", WindowsErrorString()); goto out; } dev_info_data.cbSize = sizeof(dev_info_data); for (i=0; SetupDiEnumDeviceInfo(dev_info, i, &dev_info_data); i++) { memset(buffer, 0, sizeof(buffer)); method_str = ""; if (!SetupDiGetDeviceRegistryPropertyA(dev_info, &dev_info_data, SPDRP_ENUMERATOR_NAME, &datatype, (LPBYTE)buffer, sizeof(buffer), &size)) { uprintf("SetupDiGetDeviceRegistryProperty (Enumerator Name) failed: %s\n", WindowsErrorString()); continue; } // UASP drives are listed under SCSI (along with regular SYSTEM drives => "DANGER, WILL ROBINSON!!!") is_SCSI = (safe_stricmp(buffer, scsi_name) == 0); if ((safe_stricmp(buffer, storage_name[0]) != 0) && (!is_SCSI)) continue; // We can't use the friendly name to find if a drive is a VHD, as friendly name string gets translated // according to your locale, so we poke the Hardware ID memset(&props, 0, sizeof(props)); memset(buffer, 0, sizeof(buffer)); props.is_VHD = SetupDiGetDeviceRegistryPropertyA(dev_info, &dev_info_data, SPDRP_HARDWAREID, &datatype, (LPBYTE)buffer, sizeof(buffer), &size) && IsVHD(buffer); if (usb_debug) uprintf("Processing Device: '%s'", buffer); memset(buffer, 0, sizeof(buffer)); if (!SetupDiGetDeviceRegistryPropertyA(dev_info, &dev_info_data, SPDRP_FRIENDLYNAME, &datatype, (LPBYTE)buffer, sizeof(buffer), &size)) { uprintf("SetupDiGetDeviceRegistryProperty (Friendly Name) failed: %s\n", WindowsErrorString()); // We can afford a failure on this call - just replace the name with "USB Storage Device (Generic)" safe_strcpy(buffer, sizeof(buffer), lmprintf(MSG_045)); } else if ((!props.is_VHD) && (devid_list != NULL)) { // Get the properties of the device. We could avoid doing this lookup every time by keeping // a lookup table, but there shouldn't be that many USB storage devices connected... // NB: Each of these Device IDs have an _only_ child, from which we get the Device Instance match. for (device_id = devid_list; *device_id != 0; device_id += strlen(device_id) + 1) { if ( (CM_Locate_DevNodeA(&parent_inst, device_id, 0) == CR_SUCCESS) && (CM_Get_Child(&device_inst, parent_inst, 0) == CR_SUCCESS) && (device_inst == dev_info_data.DevInst) ) { // If we're not dealing with the USBSTOR part of our list, then this is an UASP device props.is_UASP = ((((uintptr_t)device_id)+2) >= ((uintptr_t)devid_list)+list_start[1]); // Now get the properties of the device, and its Device ID, which we need to populate the properties j = htab_hash(device_id, &htab_devid); if (usb_debug) uprintf(" Matched with ID[%03d]: %s", j, device_id); // If the hash didn't match a populated string in dev_if_path[] (htab_devid.table[j].data > 0), // we might have an extra vendor driver in between (e.g. "ASUS USB 3.0 Boost Storage Driver" // for UASP devices in ASUS "Turbo Mode" or "Apple Mobile Device USB Driver" for iPods) // so try to see if we can match the grandparent. if ( ((uintptr_t)htab_devid.table[j].data == 0) && (CM_Get_Parent(&grandparent_inst, parent_inst, 0) == CR_SUCCESS) && (CM_Get_Device_IDA(grandparent_inst, str, MAX_PATH, 0) == CR_SUCCESS) ) { device_id = str; method_str = "[GP]"; j = htab_hash(device_id, &htab_devid); if (usb_debug) uprintf(" Matched with (GP) ID[%03d]: %s", j, device_id); } if ((uintptr_t)htab_devid.table[j].data > 0) { if (usb_debug) uprintf(" Matched with Hub[%d]: '%s'", (uintptr_t)htab_devid.table[j].data, dev_if_path.String[(uintptr_t)htab_devid.table[j].data]); GetUSBProperties(dev_if_path.String[(uintptr_t)htab_devid.table[j].data], device_id, &props); } if (usb_debug) uprintf(" Props VID:PID = %04X:%04X", props.vid, props.pid); // If previous calls still didn't succeed, try reading the VID:PID from the device_id if ((props.vid == 0) && (props.pid == 0)) { BOOL post_backslash = FALSE; method_str = "[ID]"; for (j=0, k=0; (j<strlen(device_id))&&(k<2); j++) { // The ID is in the form USB_VENDOR_BUSID\VID_xxxx&PID_xxxx\... if (device_id[j] == '\\') post_backslash = TRUE; if (!post_backslash) continue; if (device_id[j] == '_') { props.pid = (uint16_t)strtoul(&device_id[j+1], NULL, 16); if (k++==0) props.vid = props.pid; } } } break; } } } if (props.is_VHD) { uprintf("Found VHD device '%s'", buffer); } else { if ((props.vid == 0) && (props.pid == 0)) { if (is_SCSI) { // If we have an SCSI drive and couldn't get a VID:PID, we are most likely // dealing with a system drive => eliminate it! if (usb_debug) uprintf(" Non USB => Eliminated"); continue; } safe_strcpy(str, sizeof(str), "????:????"); // Couldn't figure VID:PID } else { static_sprintf(str, "%04X:%04X", props.vid, props.pid); } if (props.speed >= USB_SPEED_MAX) props.speed = 0; uprintf("Found %s%s%s device '%s' (%s) %s\n", props.is_UASP?"UAS (":"", usb_speed_name[props.speed], props.is_UASP?")":"", buffer, str, method_str); if (props.is_LowerSpeed) uprintf("NOTE: This device is an USB 3.0 device operating at lower speed..."); } devint_data.cbSize = sizeof(devint_data); hDrive = INVALID_HANDLE_VALUE; devint_detail_data = NULL; for (j=0; ;j++) { safe_closehandle(hDrive); safe_free(devint_detail_data); if (!SetupDiEnumDeviceInterfaces(dev_info, &dev_info_data, &_GUID_DEVINTERFACE_DISK, j, &devint_data)) { if(GetLastError() != ERROR_NO_MORE_ITEMS) { uprintf("SetupDiEnumDeviceInterfaces failed: %s\n", WindowsErrorString()); } else { uprintf("A device was eliminated because it didn't report itself as a disk\n"); } break; } if (!SetupDiGetDeviceInterfaceDetailA(dev_info, &devint_data, NULL, 0, &size, NULL)) { if(GetLastError() == ERROR_INSUFFICIENT_BUFFER) { devint_detail_data = (PSP_DEVICE_INTERFACE_DETAIL_DATA_A)calloc(1, size); if (devint_detail_data == NULL) { uprintf("Unable to allocate data for SP_DEVICE_INTERFACE_DETAIL_DATA\n"); continue; } devint_detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A); } else { uprintf("SetupDiGetDeviceInterfaceDetail (dummy) failed: %s\n", WindowsErrorString()); continue; } } if (devint_detail_data == NULL) { uprintf("SetupDiGetDeviceInterfaceDetail (dummy) - no data was allocated\n"); continue; } if(!SetupDiGetDeviceInterfaceDetailA(dev_info, &devint_data, devint_detail_data, size, &size, NULL)) { uprintf("SetupDiGetDeviceInterfaceDetail (actual) failed: %s\n", WindowsErrorString()); continue; } hDrive = CreateFileA(devint_detail_data->DevicePath, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if(hDrive == INVALID_HANDLE_VALUE) { uprintf("Could not open '%s': %s\n", devint_detail_data->DevicePath, WindowsErrorString()); continue; } drive_number = GetDriveNumber(hDrive, devint_detail_data->DevicePath); if (drive_number < 0) continue; drive_index = drive_number + DRIVE_INDEX_MIN; if (!IsMediaPresent(drive_index)) { uprintf("Device eliminated because it appears to contain no media\n"); safe_closehandle(hDrive); safe_free(devint_detail_data); break; } if (GetDriveLabel(drive_index, drive_letters, &label)) { if ((!enable_HDDs) && (!props.is_VHD) && ((score = IsHDD(drive_index, (uint16_t)props.vid, (uint16_t)props.pid, buffer)) > 0)) { uprintf("Device eliminated because it was detected as an USB Hard Drive (score %d > 0)\n", score); uprintf("If this device is not an USB Hard Drive, please e-mail the author of this application\n"); uprintf("NOTE: You can enable the listing of USB Hard Drives in 'Advanced Options' (after clicking the white triangle)"); safe_closehandle(hDrive); safe_free(devint_detail_data); break; } // The empty string is returned for drives that don't have any volumes assigned if (drive_letters[0] == 0) { entry = lmprintf(MSG_046, label, drive_number, SizeToHumanReadable(GetDriveSize(drive_index), FALSE, use_fake_units)); } else { // Find the UEFI:TOGO partition(s) (and eliminate them form our listing) for (k=0; drive_letters[k]; k++) { uefi_togo_check[0] = drive_letters[k]; if (PathFileExistsA(uefi_togo_check)) { for (l=k; drive_letters[l]; l++) drive_letters[l] = drive_letters[l+1]; k--; } } // We have multiple volumes assigned to the same device (multiple partitions) // If that is the case, use "Multiple Volumes" instead of the label safe_strcpy(entry_msg, sizeof(entry_msg), (((drive_letters[0] != 0) && (drive_letters[1] != 0))? lmprintf(MSG_047):label)); for (k=0, remove_drive=0; drive_letters[k] && (!remove_drive); k++) { // Append all the drive letters we detected letter_name[2] = drive_letters[k]; if (right_to_left_mode) safe_strcat(entry_msg, sizeof(entry_msg), RIGHT_TO_LEFT_MARK); safe_strcat(entry_msg, sizeof(entry_msg), letter_name); if (drive_letters[k] == (PathGetDriveNumberU(app_dir) + 'A')) remove_drive = 1; if (drive_letters[k] == (PathGetDriveNumberU(system_dir) + 'A')) remove_drive = 2; } // Make sure that we don't list any drive that should not be listed if (remove_drive) { uprintf("Removing %C: from the list: This is the %s!", drive_letters[--k], (remove_drive==1)?"disk from which " APPLICATION_NAME " is running":"system disk"); safe_closehandle(hDrive); safe_free(devint_detail_data); break; } safe_sprintf(&entry_msg[strlen(entry_msg)], sizeof(entry_msg) - strlen(entry_msg), "%s [%s]", (right_to_left_mode)?RIGHT_TO_LEFT_MARK:"", SizeToHumanReadable(GetDriveSize(drive_index), FALSE, use_fake_units)); entry = entry_msg; } // Must ensure that the combo box is UNSORTED for indexes to be the same StrArrayAdd(&DriveID, buffer); StrArrayAdd(&DriveLabel, label); IGNORE_RETVAL(ComboBox_SetItemData(hDeviceList, ComboBox_AddStringU(hDeviceList, entry), drive_index)); maxwidth = max(maxwidth, GetEntryWidth(hDeviceList, entry)); safe_closehandle(hDrive); safe_free(devint_detail_data); break; } } } SetupDiDestroyDeviceInfoList(dev_info); // Adjust the Dropdown width to the maximum text size SendMessage(hDeviceList, CB_SETDROPPEDWIDTH, (WPARAM)maxwidth, 0); if (devnum >= DRIVE_INDEX_MIN) { for (i=0; i<ComboBox_GetCount(hDeviceList); i++) { if ((DWORD)ComboBox_GetItemData(hDeviceList, i) == devnum) { found = TRUE; break; } } } if (!found) i = 0; IGNORE_RETVAL(ComboBox_SetCurSel(hDeviceList, i)); SendMessage(hMainDialog, WM_COMMAND, (CBN_SELCHANGE<<16) | IDC_DEVICE, 0); SendMessage(hMainDialog, WM_COMMAND, (CBN_SELCHANGE<<16) | IDC_FILESYSTEM, ComboBox_GetCurSel(hFileSystem)); r = TRUE; out: // Set 'Start' as the selected button, so that tab selection works SendMessage(hMainDialog, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hMainDialog, IDC_START), TRUE); safe_free(devid_list); StrArrayDestroy(&dev_if_path); htab_destroy(&htab_devid); return r; }
int http_transfer(UrlResource *rsrc, libnet_callback notify) { FILE *out = NULL; Url *u = NULL; Url *proxy_url = NULL; Url *redir_u = NULL; char *request = NULL; //char *raw_header = NULL; HttpHeader *header = NULL; //char *len_string = NULL; //char *new_location = NULL; char *tmp_string = NULL; //char buf[BUFSIZE]; int sock = -1; ssize_t bytes_read = 0; int msg_code = 0; int retval = 0; int i; char *buf = MALLOC(BUFSIZE); if (!buf) { LIBNET_DEBUG("No enough memory!\n"); return 0; } /* make sure we haven't recursed too much */ if ( redirect_count > REDIRECT_MAX ) { LIBNET_DEBUG("redirection max count exceeded (looping redirect?)"); redirect_count = 0; msg_code = -NET_ERR_CONNECT_FAILED; goto cleanup; } /* make sure everything's initialized to something useful */ u = rsrc->url; if ( !u->host ) { LIBNET_DEBUG("no host specified"); msg_code = -NET_ERR_CONNECT_FAILED; goto cleanup; } /* fill in proxyness */ if ( !rsrc->proxy ) { rsrc->proxy = get_proxy("HTTP_PROXY"); } if (( NULL == rsrc->outfile ) && (NULL == rsrc->buffer)) { if ( u->file ) rsrc->outfile = strdup(u->file); else rsrc->outfile = strdup("index.html"); } if ( !u->path ) u->path = strdup("/"); if ( !u->file ) u->file = strdup(""); /* funny looking */ if ( !u->port ) u->port = 80; rsrc->options |= default_opts; /* send the request to either the proxy or the remote host */ if ( rsrc->proxy ) { proxy_url = url_new(); url_init(proxy_url, rsrc->proxy); if ( !proxy_url->port ) proxy_url->port = 80; if ( !proxy_url->host ) { LIBNET_DEBUG( "bad proxy `%s'", rsrc->proxy); msg_code = -NET_ERR_CONNECT_FAILED; goto cleanup; } if ( proxy_url->username ) rsrc->proxy_username = strdup(proxy_url->username); if ( proxy_url->password ) rsrc->proxy_password = strdup(proxy_url->password); #ifdef LIB_W5300 sock = w5300_tcp_connect(proxy_url->host, proxy_url->port, rsrc->srcip, rsrc->srcport); #else sock = util_tcp_connect(proxy_url->host, proxy_url->port); #endif if (sock < 0) { msg_code = -NET_ERR_CONNECT_FAILED; goto cleanup; } safe_free(u->path); safe_free(u->file); u->path = strdup(""); u->file = strdup(u->full_url); request = get_request(rsrc); LIBNET_DEBUG("sending request:\n%s", request); S_WRITE(sock, request, STRLEN(request)); FREE(request); } else /* no proxy */ { #ifdef LIB_W5300 sock = w5300_tcp_connect(u->host, u->port, rsrc->srcip, rsrc->srcport); #else sock = util_tcp_connect(u->host, u->port); #endif if (sock < 0) { msg_code = -NET_ERR_CONNECT_FAILED; goto cleanup; } request = get_request(rsrc); LIBNET_DEBUG("sending request:\n%s", request); S_WRITE(sock, request, STRLEN(request)); FREE(request); } if (rsrc->outfile) { if ((get_file_size(rsrc->outfile) > 0) && (rsrc->options & OPT_RESUME)) out = fopen(rsrc->outfile, "rb+"); else out = fopen(rsrc->outfile, "wb"); if ( !out ) { LIBNET_DEBUG( "opening %s: %s", rsrc->outfile, ""); msg_code = -NET_ERR_FILE_SAVE_ERROR; goto cleanup; } } /* check to see if it returned a HTTP 1.x response */ MEMSET(buf, '\0', 5); #ifdef LIB_W5300 bytes_read = S_READ(sock, buf, BUFSIZE); buf[bytes_read] = '\0'; LIBNET_DEBUG("receive respond:(%d)\n%s", bytes_read, buf); #else bytes_read = S_READ(sock, buf, 8); #endif if ( bytes_read <= 0 ) { msg_code = -NET_ERR_HTTP_SERVER_ERROR; goto cleanup; } if ( ! (buf[0] == 'H' && buf[1] == 'T' && buf[2] == 'T' && buf[3] == 'P') ) { if((rsrc->options & OPT_RESUME) && rsrc->outfile_offset) { LIBNET_DEBUG("server does not support resume!"); msg_code = -NET_ERR_OPERATION_NOT_PERMIT; goto cleanup; } //fwrite(buf, bytes_read, 1,out); } else { /* skip the header */ #ifdef LIB_W5300 buf[bytes_read] = '\0'; #else char *raw_header1 = NULL; buf[bytes_read] = '\0'; raw_header1 = get_raw_header(sock); strconcat2(buf, raw_header1, NULL); FREE(raw_header1); LIBNET_DEBUG("receive respond:(%d)\n%s", bytes_read, buf); #endif header = make_http_header(buf); /* check for redirects */ tmp_string = get_header_value("location", header); if (buf[9] == '3' && tmp_string ) { #if 1 //diable redirec function redir_u = url_new(); /* make sure we still send user/password along */ redir_u->username = safe_strdup(u->username); redir_u->password = safe_strdup(u->password); url_init(redir_u, tmp_string); rsrc->url = redir_u; redirect_count++; //retval = transfer(rsrc, notify); transfer((UINT32)rsrc, (UINT32)notify); rsrc->url =u; redirect_count--; if(redirect_count<0) redirect_count=0; if (redir_u) { url_destroy(redir_u); FREE(redir_u); } #endif FREE(tmp_string); tmp_string = NULL; //msg_code = -NET_ERR_OPERATION_NOT_PERMIT;//we can support redirect now, remove this line. goto cleanup; } if (tmp_string) { FREE(tmp_string); tmp_string = NULL; } if (buf[9] == '4' || buf[9] == '5') { for (i = 0; buf[i] && buf[i] != '\n'; i++); buf[i] = '\0'; LIBNET_DEBUG("HTTP error from server: %s\n", buf); if( buf[9] == '4' && buf[10] == '0' && buf[11] == '4') msg_code = -NET_ERR_FILE_NOT_FOUND; else msg_code = -NET_ERR_HTTP_SERVER_ERROR; goto cleanup; } tmp_string = get_header_value("content-length", header); if (tmp_string) { rsrc->outfile_size = (off_t )ATOI(tmp_string); FREE(tmp_string); tmp_string = NULL; if(rsrc->use_pecache ==0) { if ((rsrc->buffer) && (rsrc->buffer_len < rsrc->outfile_size)) { LIBNET_DEBUG("the buffer length less than the file fize (%d < %d)\n", rsrc->buffer, (int)rsrc->outfile_size); msg_code = -NET_ERR_FILE_SAVE_ERROR; goto cleanup; } } } tmp_string = get_header_value("content-range", header); if (tmp_string) { FREE(tmp_string); tmp_string = NULL; rsrc->outfile_size += rsrc->outfile_offset; } if ((!rsrc->outfile_size) && (rsrc->options & OPT_RESUME) && !(rsrc->options & OPT_NORESUME) && rsrc->outfile_offset ) { LIBNET_DEBUG("unable to determine remote file size"); msg_code = -NET_ERR_FILE_SAVE_ERROR; goto cleanup; } } if(rsrc->use_pecache ==0) retval = dump_data(rsrc, sock, out, notify); else retval = dump_data_to_pecache(rsrc, sock, out, notify); cleanup: free_http_header(header); //if (raw_header) // FREE(raw_header); if (proxy_url) { url_destroy(proxy_url); FREE(proxy_url); } if (sock >= 0) { S_CLOSE(sock); } if (out) fclose(out); if (buf) { FREE(buf); } #ifndef WIN32 if (rsrc->outfile) fs_sync(rsrc->outfile); #endif if (msg_code < 0 && rsrc->running) { notify(NET_MSG_DOWNLOAD_FINISH, (UINT32)msg_code); libnet_abort_url_read(TRUE);//to break url_open while loop //retval!=1 means transfer fail } return retval; }
void writeULK(FILE *asmFile, bool doWrite) { SnapUnitigLinkMesg ulk; GenericMesg pmesg = { & ulk, MESG_ULK }; GraphNodeIterator nodes; ChunkInstanceT *ci; fprintf(stderr, "writeULK()--\n"); InitGraphNodeIterator(&nodes, ScaffoldGraph->CIGraph, GRAPH_NODE_DEFAULT); while ((ci = NextGraphNodeIterator(&nodes)) != NULL) { assert(ci->type != CONTIG_CGW); if (ci->type == RESOLVEDREPEATCHUNK_CGW) continue; if (ci->flags.bits.isChaff) continue; GraphEdgeIterator edges(ScaffoldGraph->CIGraph, ci->id, ALL_END, ALL_EDGES); CIEdgeT *edge; while ((edge = edges.nextMerged()) != NULL) { if (edge->idA != ci->id || edge->flags.bits.isInferred || edge->flags.bits.isInferredRemoved || edge->flags.bits.isMarkedForDeletion) continue; ChunkInstanceT *mi = GetGraphNode(ScaffoldGraph->CIGraph, edge->idB); if (mi->flags.bits.isChaff) continue; ulk.eunitig1 = UTGmap.lookup(edge->idA); // == ci->id ulk.eunitig2 = UTGmap.lookup(edge->idB); ulk.orientation = edge->orient; // Don't need to map orientation, always using canonical orientation ulk.overlap_type = (isOverlapEdge(edge)) ? AS_OVERLAP : AS_NO_OVERLAP; ulk.is_possible_chimera = edge->flags.bits.isPossibleChimera; ulk.mean_distance = edge->distance.mean; ulk.std_deviation = sqrt(edge->distance.variance); ulk.num_contributing = edge->edgesContributing; ulk.status = AS_UNKNOWN_IN_ASSEMBLY; uint32 edgeCount = 0; uint32 edgeTotal = ulk.num_contributing; if ((edgeTotal == 1) && (ulk.overlap_type == AS_OVERLAP)) // don't output pure overlap edges continue; // Look through the fragment pairs in this edge to decide the status of the link. CIEdgeT *redge = (edge->flags.bits.isRaw) ? edge : GetGraphEdge(ScaffoldGraph->CIGraph, edge->nextRawEdge); int numBad = 0; int numGood = 0; int numUnknown = 0; for (; redge != NULL; redge = GetGraphEdge(ScaffoldGraph->CIGraph, redge->nextRawEdge)) { if(isOverlapEdge(redge)) continue; CIFragT *fragA = GetCIFragT(ScaffoldGraph->CIFrags, redge->fragA); CIFragT *fragB = GetCIFragT(ScaffoldGraph->CIFrags, redge->fragB); assert(fragA->flags.bits.edgeStatus == fragB->flags.bits.edgeStatus); if ((fragA->flags.bits.edgeStatus == UNTRUSTED_EDGE_STATUS) || (fragA->flags.bits.edgeStatus == TENTATIVE_UNTRUSTED_EDGE_STATUS)) numBad++; else if ((fragA->flags.bits.edgeStatus == TRUSTED_EDGE_STATUS) || (fragA->flags.bits.edgeStatus == TENTATIVE_TRUSTED_EDGE_STATUS)) numGood++; else numUnknown++; } if (numBad > 0) ulk.status = AS_BAD; else if (numGood > 0) ulk.status = AS_IN_ASSEMBLY; else ulk.status = AS_UNKNOWN_IN_ASSEMBLY; ulk.jump_list = (SnapMate_Pairs *)safe_malloc(sizeof(SnapMate_Pairs) * edgeTotal); if (edge->flags.bits.isRaw) { assert(edgeTotal == 1); ulk.jump_list[edgeCount].in1 = FRGmap.lookup(edge->fragA); ulk.jump_list[edgeCount].in2 = FRGmap.lookup(edge->fragB); ulk.jump_list[edgeCount].type.setIsMatePair(); edgeCount++; } else { assert(edgeTotal > 0); redge = edge; assert(redge->nextRawEdge != NULLINDEX); // must have >= 1 raw edge while (redge->nextRawEdge != NULLINDEX) { redge = GetGraphEdge(ScaffoldGraph->CIGraph, redge->nextRawEdge); if (isOverlapEdge(redge)) { // overlap edges don't count edgeTotal--; continue; } ulk.jump_list[edgeCount].in1 = FRGmap.lookup(redge->fragA); ulk.jump_list[edgeCount].in2 = FRGmap.lookup(redge->fragB); ulk.jump_list[edgeCount].type.setIsMatePair(); edgeCount++; } } assert(edgeCount == edgeTotal); if (doWrite) WriteProtoMesg_AS(asmFile, &pmesg); safe_free(ulk.jump_list); } } }
/* * Background thread to check for updates */ static DWORD WINAPI CheckForUpdatesThread(LPVOID param) { BOOL releases_only, found_new_version = FALSE; int status = 0; const char* server_url = RUFUS_URL "/"; int i, j, k, max_channel, verbose = 0, verpos[4]; static const char* archname[] = {"win_x86", "win_x64"}; static const char* channel[] = {"release", "beta", "test"}; // release channel const char* accept_types[] = {"*/*\0", NULL}; DWORD dwFlags, dwSize, dwDownloaded, dwTotalSize, dwStatus; char* buf = NULL; char agent[64], hostname[64], urlpath[128], mime[32]; OSVERSIONINFOA os_version = {sizeof(OSVERSIONINFOA), 0, 0, 0, 0, ""}; HINTERNET hSession = NULL, hConnection = NULL, hRequest = NULL; URL_COMPONENTSA UrlParts = {sizeof(URL_COMPONENTSA), NULL, 1, (INTERNET_SCHEME)0, hostname, sizeof(hostname), 0, NULL, 1, urlpath, sizeof(urlpath), NULL, 1}; SYSTEMTIME ServerTime, LocalTime; FILETIME FileTime; int64_t local_time = 0, reg_time, server_time, update_interval; update_check_in_progress = TRUE; verbose = ReadSetting32(SETTING_VERBOSE_UPDATES); // Without this the FileDialog will produce error 0x8001010E when compiled for Vista or later IGNORE_RETVAL(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)); // Unless the update was forced, wait a while before performing the update check if (!force_update_check) { // It would of course be a lot nicer to use a timer and wake the thread, but my // development time is limited and this is FASTER to implement. do { for (i=0; (i<30) && (!force_update_check); i++) Sleep(500); } while ((!force_update_check) && ((iso_op_in_progress || format_op_in_progress || (dialog_showing>0)))); if (!force_update_check) { if ((ReadSetting32(SETTING_UPDATE_INTERVAL) == -1)) { vuprintf("Check for updates disabled, as per settings.\n"); goto out; } reg_time = ReadSetting64(SETTING_LAST_UPDATE); update_interval = (int64_t)ReadSetting32(SETTING_UPDATE_INTERVAL); if (update_interval == 0) { WriteSetting32(SETTING_UPDATE_INTERVAL, DEFAULT_UPDATE_INTERVAL); update_interval = DEFAULT_UPDATE_INTERVAL; } GetSystemTime(&LocalTime); if (!SystemTimeToFileTime(&LocalTime, &FileTime)) goto out; local_time = ((((int64_t)FileTime.dwHighDateTime)<<32) + FileTime.dwLowDateTime) / 10000000; vvuprintf("Local time: %" PRId64 "\n", local_time); if (local_time < reg_time + update_interval) { vuprintf("Next update check in %" PRId64 " seconds.\n", reg_time + update_interval - local_time); goto out; } } } PrintInfoDebug(3000, MSG_243); status++; // 1 if (!GetVersionExA(&os_version)) { uprintf("Could not read Windows version - Check for updates cancelled.\n"); goto out; } if ((!InternetCrackUrlA(server_url, (DWORD)safe_strlen(server_url), 0, &UrlParts)) || (!InternetGetConnectedState(&dwFlags, 0))) goto out; hostname[sizeof(hostname)-1] = 0; safe_sprintf(agent, ARRAYSIZE(agent), APPLICATION_NAME "/%d.%d.%d (Windows NT %d.%d%s)", rufus_version[0], rufus_version[1], rufus_version[2], nWindowsVersion >> 4, nWindowsVersion & 0x0F, is_x64() ? "; WOW64" : ""); hSession = InternetOpenA(agent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); if (hSession == NULL) goto out; hConnection = InternetConnectA(hSession, UrlParts.lpszHostName, UrlParts.nPort, NULL, NULL, INTERNET_SERVICE_HTTP, 0, (DWORD_PTR)NULL); if (hConnection == NULL) goto out; status++; // 2 releases_only = !ReadSettingBool(SETTING_INCLUDE_BETAS); // Test releases get their own distribution channel (and also force beta checks) #if defined(TEST) max_channel = (int)ARRAYSIZE(channel); #else max_channel = releases_only ? 1 : (int)ARRAYSIZE(channel) - 1; #endif for (k=0; (k<max_channel) && (!found_new_version); k++) { uprintf("Checking %s channel...\n", channel[k]); // At this stage we can query the server for various update version files. // We first try to lookup for "<appname>_<os_arch>_<os_version_major>_<os_version_minor>.ver" // and then remove each each of the <os_> components until we find our match. For instance, we may first // look for rufus_win_x64_6.2.ver (Win8 x64) but only get a match for rufus_win_x64_6.ver (Vista x64 or later) // This allows sunsetting OS versions (eg XP) or providing different downloads for different archs/groups. safe_sprintf(urlpath, sizeof(urlpath), "%s%s%s_%s_%d.%d.ver", APPLICATION_NAME, (k==0)?"":"_", (k==0)?"":channel[k], archname[is_x64()?1:0], os_version.dwMajorVersion, os_version.dwMinorVersion); vuprintf("Base update check: %s\n", urlpath); for (i=0, j=(int)safe_strlen(urlpath)-5; (j>0)&&(i<ARRAYSIZE(verpos)); j--) { if ((urlpath[j] == '.') || (urlpath[j] == '_')) { verpos[i++] = j; } } if (i != ARRAYSIZE(verpos)) { uprintf("Broken code in CheckForUpdatesThread()!\n"); goto out; } UrlParts.lpszUrlPath = urlpath; UrlParts.dwUrlPathLength = sizeof(urlpath); for (i=0; i<ARRAYSIZE(verpos); i++) { vvuprintf("Trying %s\n", UrlParts.lpszUrlPath); hRequest = HttpOpenRequestA(hConnection, "GET", UrlParts.lpszUrlPath, NULL, NULL, accept_types, INTERNET_FLAG_HYPERLINK|INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP|INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS|INTERNET_FLAG_NO_COOKIES| INTERNET_FLAG_NO_UI|INTERNET_FLAG_NO_CACHE_WRITE, (DWORD_PTR)NULL); if ((hRequest == NULL) || (!HttpSendRequestA(hRequest, NULL, 0, NULL, 0))) goto out; // Ensure that we get a text file dwSize = sizeof(dwStatus); dwStatus = 404; HttpQueryInfoA(hRequest, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, (LPVOID)&dwStatus, &dwSize, NULL); if (dwStatus == 200) break; InternetCloseHandle(hRequest); hRequest = NULL; safe_strcpy(&urlpath[verpos[i]], 5, ".ver"); } if (dwStatus != 200) { vuprintf("Could not find a %s version file on server %s", channel[k], server_url); if ((releases_only) || (k+1 >= ARRAYSIZE(channel))) goto out; continue; } vuprintf("Found match for %s on server %s", urlpath, server_url); dwSize = sizeof(mime); HttpQueryInfoA(hRequest, HTTP_QUERY_CONTENT_TYPE, (LPVOID)&mime, &dwSize, NULL); if (strncmp(mime, "text/plain", sizeof("text/plain")-1) != 0) goto out; // We also get a date from Apache, which we'll use to avoid out of sync check, // in case some set their clock way into the future and back. // On the other hand, if local clock is set way back in the past, we will never check. dwSize = sizeof(ServerTime); // If we can't get a date we can trust, don't bother... if ( (!HttpQueryInfoA(hRequest, HTTP_QUERY_DATE|HTTP_QUERY_FLAG_SYSTEMTIME, (LPVOID)&ServerTime, &dwSize, NULL)) || (!SystemTimeToFileTime(&ServerTime, &FileTime)) ) goto out; server_time = ((((int64_t)FileTime.dwHighDateTime)<<32) + FileTime.dwLowDateTime) / 10000000; vvuprintf("Server time: %" PRId64 "\n", server_time); // Always store the server response time - the only clock we trust! WriteSetting64(SETTING_LAST_UPDATE, server_time); // Might as well let the user know if (!force_update_check) { if ((local_time > server_time + 600) || (local_time < server_time - 600)) { uprintf("IMPORTANT: Your local clock is more than 10 minutes in the %s. Unless you fix this, " APPLICATION_NAME " may not be able to check for updates...", (local_time > server_time + 600)?"future":"past"); } } dwSize = sizeof(dwTotalSize); if (!HttpQueryInfoA(hRequest, HTTP_QUERY_CONTENT_LENGTH|HTTP_QUERY_FLAG_NUMBER, (LPVOID)&dwTotalSize, &dwSize, NULL)) goto out; safe_free(buf); // Make sure the file is NUL terminated buf = (char*)calloc(dwTotalSize+1, 1); if (buf == NULL) goto out; // This is a version file - we should be able to gulp it down in one go if (!InternetReadFile(hRequest, buf, dwTotalSize, &dwDownloaded) || (dwDownloaded != dwTotalSize)) goto out; status++; vuprintf("Successfully downloaded version file (%d bytes)\n", dwTotalSize); parse_update(buf, dwTotalSize+1); vuprintf("UPDATE DATA:\n"); vuprintf(" version: %d.%d.%d (%s)\n", update.version[0], update.version[1], update.version[2], channel[k]); vuprintf(" platform_min: %d.%d\n", update.platform_min[0], update.platform_min[1]); vuprintf(" url: %s\n", update.download_url); found_new_version = ((to_uint64_t(update.version) > to_uint64_t(rufus_version)) || (force_update)) && ( (os_version.dwMajorVersion > update.platform_min[0]) || ( (os_version.dwMajorVersion == update.platform_min[0]) && (os_version.dwMinorVersion >= update.platform_min[1])) ); uprintf("N%sew %s version found%c\n", found_new_version?"":"o n", channel[k], found_new_version?'!':'.'); } out: safe_free(buf); if (hRequest) InternetCloseHandle(hRequest); if (hConnection) InternetCloseHandle(hConnection); if (hSession) InternetCloseHandle(hSession); switch(status) { case 1: PrintInfoDebug(3000, MSG_244); break; case 2: PrintInfoDebug(3000, MSG_245); break; case 3: case 4: PrintInfo(3000, found_new_version?MSG_246:MSG_247); default: break; } // Start the new download after cleanup if (found_new_version) { // User may have started an operation while we were checking while ((!force_update_check) && (iso_op_in_progress || format_op_in_progress || (dialog_showing>0))) { Sleep(15000); } DownloadNewVersion(); } else if (force_update_check) { PostMessage(hMainDialog, UM_NO_UPDATE, 0, 0); } force_update_check = FALSE; update_check_in_progress = FALSE; ExitThread(0); }
void writeCLK(FILE *asmFile, bool doWrite) { SnapContigLinkMesg clk; GenericMesg pmesg = { &clk, MESG_CLK }; GraphNodeIterator nodes; ContigT *ctg; fprintf(stderr, "writeCLK()--\n"); InitGraphNodeIterator(&nodes, ScaffoldGraph->ContigGraph, GRAPH_NODE_DEFAULT); while ((ctg = NextGraphNodeIterator(&nodes)) != NULL) { if (ctg->flags.bits.isChaff) continue; if (SurrogatedSingleUnitigContig(ctg)) continue; GraphEdgeIterator edges(ScaffoldGraph->ContigGraph, ctg->id, ALL_END, ALL_EDGES); CIEdgeT *edge; while((edge = edges.nextMerged()) != NULL){ if (edge->idA != ctg->id) continue; ContigT *mate = GetGraphNode(ScaffoldGraph->ContigGraph, edge->idB); if(mate->flags.bits.isChaff) continue; if (SurrogatedSingleUnitigContig(mate)) continue; clk.econtig1 = CCOmap.lookup(edge->idA); clk.econtig2 = CCOmap.lookup(edge->idB); clk.orientation = edge->orient; // Don't need to map orientation, always using canonical orientation clk.overlap_type = (isOverlapEdge(edge)) ? AS_OVERLAP : AS_NO_OVERLAP; switch (GetEdgeStatus(edge)) { case LARGE_VARIANCE_EDGE_STATUS: case UNKNOWN_EDGE_STATUS: case INTER_SCAFFOLD_EDGE_STATUS: clk.status = AS_UNKNOWN_IN_ASSEMBLY; break; case TENTATIVE_TRUSTED_EDGE_STATUS: case TRUSTED_EDGE_STATUS: clk.status = AS_IN_ASSEMBLY; break; case TENTATIVE_UNTRUSTED_EDGE_STATUS: case UNTRUSTED_EDGE_STATUS: clk.status = AS_BAD; break; default: assert(0 /* Invalid edge status */); } clk.is_possible_chimera = edge->flags.bits.isPossibleChimera; clk.mean_distance = edge->distance.mean; clk.std_deviation = sqrt(edge->distance.variance); clk.num_contributing = edge->edgesContributing; uint32 edgeCount = 0; uint32 edgeTotal = clk.num_contributing; if ((edgeTotal == 1) && (clk.overlap_type == AS_OVERLAP) && (GlobalData->outputOverlapOnlyContigEdges == FALSE)) // don't output pure overlap edges continue; clk.jump_list = (SnapMate_Pairs *)safe_malloc(sizeof(SnapMate_Pairs) * edgeTotal); if (edge->flags.bits.isRaw) { assert(edgeTotal == 1); if (clk.overlap_type == AS_NO_OVERLAP) { clk.jump_list[edgeCount].in1 = FRGmap.lookup(edge->fragA); clk.jump_list[edgeCount].in2 = FRGmap.lookup(edge->fragB); clk.jump_list[edgeCount].type.setIsMatePair(); } else { assert(GlobalData->outputOverlapOnlyContigEdges); clk.jump_list[edgeCount].in1 = AS_UID_undefined(); clk.jump_list[edgeCount].in2 = AS_UID_undefined(); clk.jump_list[edgeCount].type.setIsOverlap(); } edgeCount++; } else { CIEdgeT *redge = edge; assert(redge->nextRawEdge != NULLINDEX); // must have >= 1 raw edge while (redge->nextRawEdge != NULLINDEX) { redge = GetGraphEdge(ScaffoldGraph->ContigGraph, redge->nextRawEdge); if (isOverlapEdge(redge)) { // overlap edges don't count edgeTotal--; continue; } clk.jump_list[edgeCount].in1 = FRGmap.lookup(redge->fragA); clk.jump_list[edgeCount].in2 = FRGmap.lookup(redge->fragB); clk.jump_list[edgeCount].type.setIsMatePair(); edgeCount++; } } assert(edgeCount == edgeTotal); if (doWrite) WriteProtoMesg_AS(asmFile, &pmesg); safe_free(clk.jump_list); } } }
void free_mesh_arrays(MESH_INFO_PTR mesh) { int i; for (i = 0; i < mesh->elem_array_len; i++) free_element_arrays(&(mesh->elements[i]), mesh); safe_free((void **)(void *) &(mesh->elements)); safe_free((void **)(void *) &(mesh->blank)); for (i = 0; i < mesh->num_el_blks; i++) safe_free((void **)(void *) &(mesh->eb_names[i])); safe_free((void **)(void *) &(mesh->eb_names)); safe_free((void **)(void *) &(mesh->eb_etypes)); safe_free((void **)(void *) &(mesh->ecmap_id)); safe_free((void **)(void *) &(mesh->ecmap_cnt)); safe_free((void **)(void *) &(mesh->ecmap_elemids)); safe_free((void **)(void *) &(mesh->ecmap_sideids)); safe_free((void **)(void *) &(mesh->ecmap_neighids)); safe_free((void **)(void *) &(mesh->hgid)); safe_free((void **)(void *) &(mesh->hindex)); safe_free((void **)(void *) &(mesh->hvertex)); safe_free((void **)(void *) &(mesh->hvertex_proc)); safe_free((void **)(void *) &(mesh->heWgtId)); safe_free((void **)(void *) &(mesh->hewgts)); }
void writeSLK(FILE *asmFile, bool doWrite) { SnapScaffoldLinkMesg slk; GenericMesg pmesg = { &slk, MESG_SLK }; GraphNodeIterator scaffolds; CIScaffoldT *scaffold; CIScaffoldT *scafmate; fprintf(stderr, "writeSLK()--\n"); InitGraphNodeIterator(&scaffolds, ScaffoldGraph->ScaffoldGraph, GRAPH_NODE_DEFAULT); while ((scaffold = NextGraphNodeIterator(&scaffolds)) != NULL) { GraphEdgeIterator edges(ScaffoldGraph->ScaffoldGraph, scaffold->id, ALL_END, ALL_EDGES); CIEdgeT *edge; CIEdgeT *redge; while((edge = edges.nextMerged()) != NULL) { if (edge->idA != scaffold->id) continue; scafmate = GetGraphNode(ScaffoldGraph->ScaffoldGraph, edge->idB); assert(!isOverlapEdge(edge)); slk.escaffold1 = SCFmap.lookup(scaffold->id); slk.escaffold2 = SCFmap.lookup(scafmate->id); slk.orientation = edge->orient; slk.mean_distance = edge->distance.mean; slk.std_deviation = sqrt(edge->distance.variance); slk.num_contributing = edge->edgesContributing; int edgeTotal = slk.num_contributing; int edgeCount = 0; if(edgeTotal < 2) continue; slk.jump_list = (SnapMate_Pairs *)safe_malloc(sizeof(SnapMate_Pairs) * slk.num_contributing); if (edge->flags.bits.isRaw) { assert(edgeTotal <= 1); // sanity check if (edgeTotal == 1) { slk.jump_list[edgeCount].in1 = FRGmap.lookup(edge->fragA); slk.jump_list[edgeCount].in2 = FRGmap.lookup(edge->fragB); }else{ slk.jump_list[edgeCount].in1 = AS_UID_undefined(); slk.jump_list[edgeCount].in2 = AS_UID_undefined(); } slk.jump_list[edgeCount].type.setIsMatePair(); edgeCount++; } else { redge = edge; assert(redge->flags.bits.isRaw == FALSE); assert(redge->nextRawEdge != NULLINDEX); // must have >= 1 raw edge while (redge->nextRawEdge != NULLINDEX) { redge = GetGraphEdge(ScaffoldGraph->ScaffoldGraph,redge->nextRawEdge); assert(!isOverlapEdge(redge)); slk.jump_list[edgeCount].in1 = FRGmap.lookup(redge->fragA); slk.jump_list[edgeCount].in2 = FRGmap.lookup(redge->fragB); slk.jump_list[edgeCount].type.setIsMatePair(); edgeCount++; } } assert(edgeCount == edgeTotal); if (doWrite) WriteProtoMesg_AS(asmFile, &pmesg); safe_free(slk.jump_list); } } }
int create_random_input( int Proc, int Num_Proc, PROB_INFO_PTR prob, PARIO_INFO_PTR pio_info, MESH_INFO_PTR mesh) { /* Local declarations. */ const char *yo = "create_random_input"; int i, j, nvtxs, gnvtxs; int vwgt_dim=0, ewgt_dim=0; int ndim = 0; int *start = NULL, *adj = NULL; int no_geom = FALSE; float *ewgts = NULL, *vwgts = NULL; float *x = NULL, *y = NULL, *z = NULL; short *assignments = NULL; char filename[256]; FILE *fpg = NULL, *fpc = NULL; /* Files to echo random input */ /***************************** BEGIN EXECUTION ******************************/ DEBUG_TRACE_START(Proc, yo); if (Proc == 0) { /* Adapted from read_chaco_graph; build same values as read_chaco_graph * and then let random input be distributed as a Chaco graph would be. */ /* read the array in on processor 0 */ nvtxs = pio_info->init_size; ndim = pio_info->init_dim; vwgt_dim = pio_info->init_vwgt_dim; if (vwgt_dim<1) vwgt_dim=1; /* For now, insist on 1 or more weights. */ if (nvtxs <= OUTPUT_FILES_MAX_NVTXS) { sprintf(filename, "%s.graph", pio_info->pexo_fname); fpg = fopen(filename, "w"); sprintf(filename, "%s.coords", pio_info->pexo_fname); fpc = fopen(filename, "w"); } if (nvtxs > 0) { /* Allocate space for vertex weights and coordinates. */ x = (float *) malloc(nvtxs * sizeof(float)); if (ndim > 1) y = (float *) malloc(nvtxs * sizeof(float)); if (ndim > 2) z = (float *) malloc(nvtxs * sizeof(float)); vwgts = (float *) malloc(vwgt_dim*nvtxs * sizeof(float)); if (!x || (ndim > 1 && !y) || (ndim > 2 && !z) || !vwgts) { Gen_Error(0, "fatal: Error allocating memory."); return 0; } /* Generate random coordinates and weights. */ srand(0); switch (ndim) { case 1: for (i = 0; i < nvtxs; i++) { x[i] = ((float) rand())/RAND_MAX; if (fpc != NULL) fprintf(fpc, "%e\n", x[i]); } break; case 2: for (i = 0; i < nvtxs; i++) { x[i] = ((float) rand())/RAND_MAX; y[i] = ((float) rand())/RAND_MAX; if (fpc != NULL) fprintf(fpc, "%e %e\n", x[i], y[i]); } break; case 3: for (i = 0; i < nvtxs; i++) { x[i] = ((float) rand())/RAND_MAX; y[i] = ((float) rand())/RAND_MAX; z[i] = ((float) rand())/RAND_MAX; if (fpc != NULL) fprintf(fpc, "%e %e %e\n", x[i], y[i], z[i]); } break; } for (i = 0; i < nvtxs; i++) { if (pio_info->init_vwgt_dim == 0) /* Unit weights if no weights were requested. */ vwgts[i] = 1.0; else for (j = 0; j < vwgt_dim; j++) { /* Only assign one of the weight dimensions a weight>0. */ /* Modify to get more complicated test cases. */ if (j == i%vwgt_dim) vwgts[i*vwgt_dim+j] = ((float) rand())/RAND_MAX; else vwgts[i*vwgt_dim+j] = 0.0; } } /* KDDSJP: Need to add edge info here. Later. For now, set no edges */ ewgt_dim = 0; start = (int *) malloc((nvtxs+1) * sizeof(int)); adj = NULL; ewgts = NULL; for (i = 0; i < nvtxs; i++) { start[i] = 0; } start[nvtxs] = 0; if (fpg != NULL) { if (vwgt_dim==1) fprintf(fpg, "%d %d 010\n", nvtxs, start[nvtxs]); else fprintf(fpg, "%d %d 010 %d\n", nvtxs, start[nvtxs], vwgt_dim); } for (i = 0; i < nvtxs; i++) { if (fpg != NULL) for (j = 0; j < vwgt_dim; j++) fprintf(fpg, "%e ", vwgts[i*vwgt_dim+j]); /* KDDSJP Print edges here */ if (fpg != NULL) fprintf(fpg, "\n"); } } if (fpg != NULL) fclose(fpg); if (fpc != NULL) fclose(fpc); } /* Distribute graph */ if (!chaco_dist_graph(MPI_COMM_WORLD, pio_info, 0, &gnvtxs, &nvtxs, &start, &adj, &vwgt_dim, &vwgts, &ewgt_dim, &ewgts, &ndim, &x, &y, &z, &assignments)) { Gen_Error(0, "fatal: Error returned from chaco_dist_graph"); return 0; } if (!chaco_setup_mesh_struct(Proc, Num_Proc, prob, mesh, pio_info, gnvtxs, nvtxs, start, adj, vwgt_dim, vwgts, ewgt_dim, ewgts, ndim, x, y, z, assignments, 1, no_geom)) { Gen_Error(0, "fatal: Error returned from chaco_setup_mesh_struct"); return 0; } safe_free((void **)(void *) &adj); safe_free((void **)(void *) &vwgts); safe_free((void **)(void *) &ewgts); safe_free((void **)(void *) &start); safe_free((void **)(void *) &x); safe_free((void **)(void *) &y); safe_free((void **)(void *) &z); safe_free((void **)(void *) &assignments); DEBUG_TRACE_END(Proc, yo); return 1; }
// Insert entry 'data' under section 'section' of a config file // Section must include the relevant delimitors (eg '[', ']') if needed char* insert_section_data(const char* filename, const char* section, const char* data, BOOL dos2unix) { const wchar_t* outmode[] = { L"w", L"w, ccs=UTF-8", L"w, ccs=UTF-16LE" }; wchar_t *wsection = NULL, *wfilename = NULL, *wtmpname = NULL, *wdata = NULL, bom = 0; wchar_t wspace[] = L" \t"; wchar_t buf[1024]; FILE *fd_in = NULL, *fd_out = NULL; size_t i, size; int mode; char *ret = NULL, tmp[2]; if ((filename == NULL) || (section == NULL) || (data == NULL)) return NULL; if ((filename[0] == 0) || (section[0] == 0) || (data[0] == 0)) return NULL; wfilename = utf8_to_wchar(filename); if (wfilename == NULL) { uprintf("Could not convert '%s' to UTF-16\n", filename); goto out; } wsection = utf8_to_wchar(section); if (wfilename == NULL) { uprintf("Could not convert '%s' to UTF-16\n", section); goto out; } wdata = utf8_to_wchar(data); if (wdata == NULL) { uprintf("Could not convert '%s' to UTF-16\n", data); goto out; } fd_in = _wfopen(wfilename, L"r, ccs=UNICODE"); if (fd_in == NULL) { uprintf("Could not open file '%s'\n", filename); goto out; } // Check the input file's BOM and create an output file with the same fread(&bom, sizeof(bom), 1, fd_in); switch(bom) { case 0xFEFF: mode = 2; // UTF-16 (LE) break; case 0xBBEF: // Yeah, the UTF-8 BOM is really 0xEF,0xBB,0xBF, but mode = 1; // find me a non UTF-8 file that actually begins with "ï»" break; default: mode = 0; // ANSI break; } fseek(fd_in, 0, SEEK_SET); // uprintf("'%s' was detected as %s\n", filename, // (mode==0)?"ANSI/UTF8 (no BOM)":((mode==1)?"UTF8 (with BOM)":"UTF16 (with BOM")); wtmpname = (wchar_t*)calloc(wcslen(wfilename)+2, sizeof(wchar_t)); if (wtmpname == NULL) { uprintf("Could not allocate space for temporary output name\n"); goto out; } wcscpy(wtmpname, wfilename); wtmpname[wcslen(wtmpname)] = '~'; fd_out = _wfopen(wtmpname, outmode[mode]); if (fd_out == NULL) { uprintf("Could not open temporary output file %s~\n", filename); goto out; } // Process individual lines. NUL is always appended. while (fgetws(buf, ARRAYSIZE(buf), fd_in) != NULL) { i = 0; // Skip leading spaces i += wcsspn(&buf[i], wspace); // Our token should begin a line if (_wcsnicmp(&buf[i], wsection, wcslen(wsection)) != 0) { fputws(buf, fd_out); continue; } // Section was found, output it fputws(buf, fd_out); // Now output the new data fwprintf(fd_out, L"%s\n", wdata); ret = (char*)data; } out: if (fd_in != NULL) fclose(fd_in); if (fd_out != NULL) fclose(fd_out); // If an insertion occured, delete existing file and use the new one if (ret != NULL) { // We're in Windows text mode => Remove CRs if requested fd_in = _wfopen(wtmpname, L"rb"); fd_out = _wfopen(wfilename, L"wb"); // Don't check fds if ((fd_in != NULL) && (fd_out != NULL)) { size = (mode==2)?2:1; while(fread(tmp, size, 1, fd_in) == 1) { if ((!dos2unix) || (tmp[0] != 0x0D)) fwrite(tmp, size, 1, fd_out); } fclose(fd_in); fclose(fd_out); } else { uprintf("Could not write %s - original file has been left unmodifiedn", filename); ret = NULL; if (fd_in != NULL) fclose(fd_in); if (fd_out != NULL) fclose(fd_out); } } _wunlink(wtmpname); safe_free(wfilename); safe_free(wtmpname); safe_free(wsection); safe_free(wdata); return ret; }
static void free_refresh_check_format(void *data) { refresh_check_format *p = data; safe_free(p->header); }