std::string CChainWalkSet::CheckOrRotatePreCalcFile() { char sPreCalcFileName[255]; // 255 files limit to be sure for (; preCalcPart < 255; preCalcPart++) { sprintf(sPreCalcFileName, "%s.%d", sPrecalcPathName.c_str(), preCalcPart); std::string sReturnPreCalcPath(sPreCalcFileName); long fileLen = 0; FILE* file = fopen(sReturnPreCalcPath.c_str(), "ab"); if(file!=NULL) { fileLen = GetFileLen(sReturnPreCalcPath); long unsigned int nextFileLen = fileLen + (sizeof(uint64_t) * (m_nRainbowChainLen-1)); // Rotate to next file if we are going to pass 2GB filesize if (nextFileLen < ((unsigned)2 * 1024 * 1024 * 1024)) { // We might want to vPrecalcFiles.push_back(sReturnPreCalcPath) if we just created this file // We don't as only newly generated chainwalksets will be stored to this new file, so we don't have to look there if (debug) printf("Debug: Using for precalc: %s\n", sReturnPreCalcPath.c_str()); fclose(file); return sReturnPreCalcPath; } fclose(file); } } return std::string(""); }
//打开脚本文件 bool CScript::OpenFile(char* strFilePath) { m_strFileName.assign(strFilePath); SAFE_DELETE(m_pFileData); m_nFileLen = GetFileLen(strFilePath); if(m_nFileLen < 0) { ShowMessage("Open file %s failed.", strFilePath); return false; } m_pFileData = new char[m_nFileLen+1]; //读数据 FILE* fp = fopen(strFilePath, "rb"); fread(m_pFileData, m_nFileLen, 1, fp); fclose(fp); m_bScanningStr = false; m_nFileOffset = 0; return true; }
bool BaseLog::OpenLog(const char* lpszFileName) { if (m_f != NULL) return false; if (lpszFileName == NULL) { m_strFileName = PathHelp::os_get_application_path(); m_strFileName += "log\\"; m_strFileName += GetCurrentModuleName(); m_strFileName += ".log"; } else { m_strFileName = PathHelp::os_get_application_path(); m_strFileName += lpszFileName; } int nSize = GetFileLen( m_strFileName.c_str() ); if (nSize > 1024*1024*5) remove(m_strFileName.c_str()); m_f = fopen (m_strFileName.c_str(), "a+"); if (!m_f) { m_isOpen = false; return false; } m_isOpen = true; m_filter.Init(m_strFileName.c_str()); return true; }
/////////////////////////////////////////////////////////////////////////////// // Name: CheckDelPidFiles // Author: Mihai Buha ([email protected]) // Description: removes all the pidfiles specified, but not too frequently // Parameters: p_pszNames - input - null-terminated array of filenames // p_szMissNames - output - if not null, fill with names of // missing files. Take care to allocate enough memory for // "Watchdog: <all filenames in p_pszNames> " or else bad // things will happen. // Returns: true if all pidfiles existed or timeout not expired // false if some pidfile was missing (controlling app was dead - // did not create a file during latest 2 intervals) /////////////////////////////////////////////////////////////////////////////// bool CheckDelPidFiles (const char** p_pszNames, char* p_szMissNames) { static clock_t last_checked; static long n_SC_CLK_TCK; static bool last_existed = true; clock_t timestamp; bool status = true; bool exists = true; if(!n_SC_CLK_TCK) n_SC_CLK_TCK = sysconf( _SC_CLK_TCK); timestamp = GetClockTicks(); if( timestamp < last_checked){ // large uptime overflowed the clock_t last_checked = timestamp; } if( timestamp - last_checked < PIDFILES_FACTOR * PIDFILES_TIMEOUT * n_SC_CLK_TCK){ return status; } last_checked = timestamp; int i; for( i=0; p_pszNames[i]; ++i) { int nFileLen = GetFileLen(p_pszNames[i]); if ( nFileLen > 0) { unlink( p_pszNames[i]); continue; } if (nFileLen == 0) { LOG("CheckDelPidFiles: file %s len==0", p_pszNames[i]); unlink( p_pszNames[i]); } LOG_ERR( "CheckDelPidFiles: pidfile %s missing!", p_pszNames[i]); if( exists && p_szMissNames){ sprintf( p_szMissNames, "Watchdog: "); } exists = false; if( p_szMissNames){ strcat( p_szMissNames, p_pszNames[i]); strcat( p_szMissNames, " "); } system_to( 60, NIVIS_TMP"take_system_snapshot.sh "ACTIVITY_DATA_PATH"snapshot_warning.txt &"); } status = exists || last_existed; last_existed = exists; return status; }
int main(int argc, char **argv) { int retval; double fd; char output_path[512]; //, chkpt_path[512]; //FILE* state; retval = boinc_init(); if (retval) { fprintf(stderr, "boinc_init returned %d\n", retval); exit(retval); } // extract a --device option std::vector<char*> argVec; int cudaDevice = -1; for(int ii = 0; ii < argc; ii++) { if(cudaDevice < 0 && strcmp(argv[ii], "--device") == 0 && ii + 1 < argc) cudaDevice = atoi(argv[++ii]); else argVec.push_back(argv[ii]); } argc = (int)argVec.size(); argv = &argVec[0]; if(cudaDevice < 0) cudaDevice = 0; boinc_begin_critical_section(); // set the cuda device if ( rcuda::SetCudaDevice(cudaDevice) != 0 ) { fprintf(stderr, "Error setting device %u. Temporary exiting for 60 secs\n", cudaDevice); boinc_temporary_exitHack(); } cudaDeviceProp deviceProp; if(cudaGetDeviceProperties(&deviceProp, cudaDevice) == cudaErrorInvalidDevice) { fprintf(stderr, "Error querying device %u. Temporary exiting for 60 secs\n", cudaDevice); boinc_temporary_exitHack(); } #ifdef WIN32 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); #endif int buffCount = 0x2000; int chainSize = 100; if(deviceProp.major == 1) { /* buffCount = deviceProp.multiProcessorCount * 8;// 8 blocks per multiprocessor buffCount *= deviceProp.maxThreadsPerBlock / 64; // (BLOCK_X_SIZE) // buffCount *= 24; if(deviceProp.minor <= 1) buffCount *= 24; // 24 warps per multiprocessor for compute 1.0 and 1.1 else buffCount *= 32; // 32 warps per multiprocessor for compute 1.2 and 1.3 */ buffCount = 0x2000; } else if(deviceProp.major == 2) { chainSize = 200; /* buffCount = deviceProp.multiProcessorCount * 8;// 8 blocks per multiprocessor buffCount *= deviceProp.maxThreadsPerBlock / 64; //(BLOCK_X_SIZE) buffCount *= 32; // 48 warps per multiprocessor for compute 2.x /* if(deviceProp.minor == 1) { buffCount *= 2; } */ buffCount = 0x4000; } if(cudaDevice > 0) { chainSize = 1000; } if(argc < 10) { fprintf(stderr, "Not enough parameters"); return -1; } std::string sHashRoutineName, sCharsetName, sSalt, sCheckPoints; uint32 nRainbowChainCount, nPlainLenMin, nPlainLenMax, nRainbowTableIndex, nRainbowChainLen; uint64 nChainStart; sHashRoutineName = argv[1]; sCharsetName = argv[2]; nPlainLenMin = atoi(argv[3]); nPlainLenMax = atoi(argv[4]); nRainbowTableIndex = atoi(argv[5]); nRainbowChainLen = atoi(argv[6]); nRainbowChainCount = atoi(argv[7]); #ifdef _WIN32 nChainStart = _atoi64(argv[8]); #else nChainStart = atoll(argv[8]); #endif sCheckPoints = argv[9]; std::vector<int> vCPPositions; char *cp = strtok((char *)sCheckPoints.c_str(), ","); while(cp != NULL) { vCPPositions.push_back(atoi(cp)); cp = strtok(NULL, ","); } if(argc == 11) { sSalt = argv[10]; } //std::cout << "Starting ChainGenerator" << std::endl; // Setup CChainWalkContext //std::cout << "ChainGenerator started." << std::endl; if (!CChainWalkContext::SetHashRoutine(sHashRoutineName)) { fprintf(stderr, "hash routine %s not supported\n", sHashRoutineName.c_str()); return 1; } //std::cout << "Hash routine validated" << std::endl; if (!CChainWalkContext::SetPlainCharset(sCharsetName, nPlainLenMin, nPlainLenMax)) { std::cerr << "charset " << sCharsetName << " not supported" << std::endl; return 2; } //std::cout << "Plain charset validated" << std::endl; if (!CChainWalkContext::SetRainbowTableIndex(nRainbowTableIndex)) { std::cerr << "invalid rainbow table index " << nRainbowTableIndex << std::endl; return 3; } //std::cout << "Rainbowtable index validated" << std::endl; if(sHashRoutineName == "mscache")// || sHashRoutineName == "lmchall" || sHashRoutineName == "halflmchall") { // Convert username to unicode const char *szSalt = sSalt.c_str(); int salt_length = strlen(szSalt); unsigned char cur_salt[256]; for (int i=0; i<salt_length; i++) { cur_salt[i*2] = szSalt[i]; cur_salt[i*2+1] = 0x00; } CChainWalkContext::SetSalt(cur_salt, salt_length*2); } else if(sHashRoutineName == "halflmchall") { // The salt is hardcoded into the hash routine // CChainWalkContext::SetSalt((unsigned char*)&salt, 8); } else if(sHashRoutineName == "oracle") { CChainWalkContext::SetSalt((unsigned char *)sSalt.c_str(), sSalt.length()); } //std::cout << "Opening chain file" << std::endl; // Open file boinc_resolve_filename("result", output_path, sizeof(output_path)); fclose(boinc_fopen(output_path, "a")); FILE *outfile = boinc_fopen(output_path, "r+b"); if (outfile == NULL) { std::cerr << "failed to create " << output_path << std::endl; return 4; } // Check existing chains unsigned int nDataLen = (unsigned int)GetFileLen(outfile); // Round to boundary nDataLen = nDataLen / 10 * 10; if (nDataLen == nRainbowChainCount * 10) { std::cerr << "precomputation of this rainbow table already finished" << std::endl; fclose(outfile); return 0; } fseek(outfile, nDataLen, SEEK_SET); //XXX size_t isn't 32/64 clean size_t nReturn; CChainWalkContext cwc; uint64 nIndex[2]; //time_t tStart = time(NULL); // std::cout << "Starting to generate chains" << std::endl; int maxCalcBuffSize = rcuda::GetChainsBufferSize( buffCount ); std::cerr << "maxCalcBuffSize - estimated: " << buffCount << ". Chosen: " << maxCalcBuffSize << std::endl; uint64 *calcBuff = new uint64[2*maxCalcBuffSize]; int ii; CudaCWCExtender ex(&cwc); rcuda::RCudaTask cuTask; ex.Init(); for(int nCurrentCalculatedChains = nDataLen / 10, calcSize; nCurrentCalculatedChains < nRainbowChainCount; ) { fd = (double)nCurrentCalculatedChains / (double)nRainbowChainCount; boinc_fraction_done(fd); cuTask.hash = ex.GetHash(); cuTask.startIdx = nChainStart + nCurrentCalculatedChains; cuTask.idxCount = std::min<int>(nRainbowChainCount - nCurrentCalculatedChains, maxCalcBuffSize); cuTask.dimVec = ex.GetPlainDimVec(); cuTask.dimVecSize = ex.GetPlainDimVecSize()/2; cuTask.charSet = ex.GetCharSet(); cuTask.charSetSize = ex.GetCharSetSize(); cuTask.cpPositions = &vCPPositions[0]; cuTask.cpPosSize = vCPPositions.size(); cuTask.reduceOffset = ex.GetReduceOffset(); cuTask.plainSpaceTotal = ex.GetPlainSpaceTotal(); cuTask.rainbowChainLen = nRainbowChainLen; cuTask.kernChainSize = chainSize; for(ii = 0; ii < cuTask.idxCount; ii++) { calcBuff[2*ii] = cuTask.startIdx + ii; calcBuff[2*ii+1] = 0; } calcSize = rcuda::CalcChainsOnCUDA(&cuTask, calcBuff); BOINC_STATUS boinc_status; boinc_get_status(&boinc_status); if (boinc_status.quit_request || boinc_status.abort_request) { boinc_end_critical_section(); while (1) boinc_sleep(1); } if(calcSize > 0) { nCurrentCalculatedChains += calcSize; for(ii = 0; ii < cuTask.idxCount; ii++) { nIndex[0] = cuTask.startIdx + ii; // nReturn = fwrite(nIndex, 1, 8, outfile); nReturn = fwrite(calcBuff+(2*ii), 1, 8, outfile); nReturn += fwrite(calcBuff+(2*ii+1), 1, 2, outfile); if(nReturn != 10) { std::cerr << "disk write fail" << std::endl; fclose(outfile); return 9; } } } else { std::cerr << "Calculations on CUDA failed!" << std::endl; fclose(outfile); return -1; } } delete [] calcBuff; #ifdef _DEBUG std::cout << "Generation completed" << std::endl; #endif fclose(outfile); boinc_fraction_done(1); boinc_finish(0); }
////////////////////////////////////////////////////////////////////////////// /// @brief removes all the pidfiles specified, but not too frequently /// @author Mihai Buha ([email protected]) /// @param[in] p_pszNames null-terminated array of filenames /// @param[out] p_szMissNames if not null, fill with names of /// missing files. Take care to allocate enough memory for /// "Watchdog: <all filenames in p_pszNames> " or else bad /// things will happen. /// @retval true All pidfiles existed or timeout not expired /// @retval false Some pidfile was missing (controlling app was dead - /// did not create a file during latest 2 intervals) ////////////////////////////////////////////////////////////////////////////// bool CWatchdogMngr::checkDelPidFiles (const char** p_pszNames, char* p_szMissNames) { clock_t timestamp ; static clock_t sStartTime = GetClockTicks(); static clock_t last_checked; static bool last_existed = true; bool status = true; bool exists = true; timestamp = GetClockTicks(); if( timestamp < last_checked) { // large uptime overflowed the clock_t last_checked = timestamp; sStartTime = timestamp; } if( (timestamp - last_checked < WTD_PID_VRFY_INTERVAL * sysconf(_SC_CLK_TCK)) || (timestamp - sStartTime < WTD_PID_VRFY_INTERVAL * sysconf(_SC_CLK_TCK)) ) { return true; } last_checked = timestamp; for( unsigned i=0; p_pszNames[i]; ++i) { int nFileLen = GetFileLen(p_pszNames[i]); if (nFileLen == 0) { usleep(30*1000);//wait a little maybe in process of writing the pid file nFileLen = GetFileLen(p_pszNames[i]); } if ( nFileLen > 0) { unlink( p_pszNames[i]); continue; } if (nFileLen == 0) { ERR("checkDelPidFiles: pidfile[%s] len==0", p_pszNames[i]); systemf_to( 20 ,"log2flash 'WTD: ERR:checkDelPidFiles: pidfile[%s] len==0' &", p_pszNames[i]); unlink( p_pszNames[i]); } LOG( "ERR:Missing [%s]", p_pszNames[i]); if ( exists ) { exists = false; } if( p_szMissNames ) { strcat( p_szMissNames, p_pszNames[i]); strcat( p_szMissNames, ","); } } // Take snapshot if any of the pidfiles is missing. if (! exists) { system_to( 60, NIVIS_TMP"take_system_snapshot.sh "ACTIVITY_DATA_PATH"snapshot_warning.txt &"); } status = exists || last_existed; last_existed = exists; return status; }
bool player_impl::open(const char *movie, int media_type, int render_type) { // 如果未关闭原来的媒体, 则先关闭. if (m_avplay || m_source) close(); // 未创建窗口, 无法播放, 返回失败. if (!m_window) return false; char filename[MAX_PATH]; int len = strlen(movie) + 1; strcpy(filename, movie); int64_t file_lentgh = 0; if (media_type == MEDIA_TYPE_FILE || media_type == MEDIA_TYPE_BT) { file_lentgh = GetFileLen(movie); __android_log_print(ANDROID_LOG_INFO,"open","%s %d\n",movie,file_lentgh); if (file_lentgh < 0) { ::logger("get file size failed!\n"); return false; } } do { // 创建avplay. m_avplay = alloc_avplay_context(); if (!m_avplay) { ::logger("allocate avplay context failed!\n"); break; } // 为avplay创建demux. demux_context *demux = alloc_demux_context(); configure(m_avplay, demux, MEDIA_DEMUX); // 目前只有除youku之外, 都使用generic_demux. if (media_type != MEDIA_TYPE_YK) { demux->init_demux = generic_init_demux; demux->read_packet = generic_read_packet; demux->seek_packet = generic_packet_seek; demux->read_pause = generic_read_pause; demux->read_play = generic_read_play; demux->stream_index = generic_stream_index; demux->query_avcodec_id = generic_query_avcodec_id; demux->destory = generic_destory; } else { // TODO: 实现youku相关的demux. break; } // 初始化avplay. if (initialize(m_avplay, filename, media_type, demux) != 0) { ::logger("initialize avplay failed!\n"); break; } // TODO: 如果是bt类型, 则在此得到视频文件列表, 并添加到m_media_list. // if (media_type == MEDIA_TYPE_BT) // { // bt_source_info *bt_info = &m_avplay->m_source_ctx->info.bt; // for (int i = 0; i < bt_info->info_size; i++) // { // std::string name = std::string(bt_info->info[i].file_name); // m_media_list.insert(std::make_pair(filename, name)); // } // } // 分配音频和视频的渲染器. m_audio = alloc_audio_render(); if (!m_audio) { ::logger("allocate audio render failed!\n"); break; } m_video = alloc_video_render(&m_window); if (!m_video) { ::logger("allocate video render failed!\n"); break; } // 初始化音频和视频渲染器. init_audio(m_audio); init_video(m_video, render_type); // 配置音频视频渲染器. configure(m_avplay, m_video, VIDEO_RENDER); configure(m_avplay, m_audio, AUDIO_RENDER); // 得到视频宽高. if (m_avplay->m_video_ctx) { m_video_width = m_avplay->m_video_ctx->width; m_video_height = m_avplay->m_video_ctx->height; } // 打开视频实时码率和帧率计算. enable_calc_frame_rate(m_avplay); enable_calc_bit_rate(m_avplay); //__android_log_print(ANDROID_LOG_INFO,"m_window--","%d\n",m_window); return true; } while (0); if (m_avplay) free_avplay_context(m_avplay); m_avplay = NULL; if (m_source) free_media_source(m_source); if (m_audio) free_audio_render(m_audio); if (m_video) free_video_render(m_video); ::logger("open avplay failed!\n"); return true; }
int main(int argc, char* argv[]) { if (argc != 3) { Logo(); printf("usage: rtdump rainbow_table_pathname rainbow_chain_index\n"); return 0; } string sPathName = argv[1]; int nRainbowChainIndex = atoi(argv[2]); int nRainbowChainLen, nRainbowChainCount; if (!CChainWalkContext::SetupWithPathName(sPathName, nRainbowChainLen, nRainbowChainCount)) return 0; if (nRainbowChainIndex < 0 || nRainbowChainIndex > nRainbowChainCount - 1) { printf("valid rainbow chain index range: 0 - %d\n", nRainbowChainCount - 1); return 0; } // Open file FILE* file = fopen(sPathName.c_str(), "rb"); if (file == NULL) { printf("failed to open %s\n", sPathName.c_str()); return 0; } // Dump if (GetFileLen(file) != nRainbowChainCount * 16) printf("rainbow table size check fail\n"); else { // Read required chain RainbowChain chain; fseek(file, nRainbowChainIndex * 16, SEEK_SET); fread(&chain, 1, 16, file); // Dump required chain CChainWalkContext cwc; cwc.SetIndex(chain.nIndexS); int nPos; for (nPos = 0; nPos < nRainbowChainLen - 1; nPos++) { cwc.IndexToPlain(); cwc.PlainToHash(); printf("#%-4d %s %s %s\n", nPos, uint64tohexstr(cwc.GetIndex()).c_str(), cwc.GetPlainBinary().c_str(), cwc.GetHash().c_str()); cwc.HashToIndex(nPos); } printf("#%-4d %s\n", nPos, uint64tohexstr(cwc.GetIndex()).c_str()); if (cwc.GetIndex() != chain.nIndexE) printf("\nwarning: rainbow chain integrity check fail!\n"); } // Close file fclose(file); return 0; }
int main(int argc, char **argv) { int retval; double fd; char output_path[512]; //, chkpt_path[512]; //FILE* state; retval = boinc_init(); if (retval) { fprintf(stderr, "boinc_init returned %d\n", retval); exit(retval); } // get size of input file (used to compute fraction done) // //file_size(input_path, fsize); // See if there's a valid checkpoint file. // If so seek input file and truncate output file // if(argc < 10) { fprintf(stderr, "Not enough parameters"); return -1; } std::string sHashRoutineName, sCharsetName, sSalt, sCheckPoints; uint32 nRainbowChainCount, nPlainLenMin, nPlainLenMax, nRainbowTableIndex, nRainbowChainLen; uint64 nChainStart; sHashRoutineName = argv[1]; sCharsetName = argv[2]; nPlainLenMin = atoi(argv[3]); nPlainLenMax = atoi(argv[4]); nRainbowTableIndex = atoi(argv[5]); nRainbowChainLen = atoi(argv[6]); nRainbowChainCount = atoi(argv[7]); #ifdef _WIN32 nChainStart = _atoi64(argv[8]); #else nChainStart = atoll(argv[8]); #endif sCheckPoints = argv[9]; std::vector<uint32> vCPPositions; char *cp = strtok((char *)sCheckPoints.c_str(), ","); while(cp != NULL) { vCPPositions.push_back(atoi(cp)); cp = strtok(NULL, ","); } if(argc == 11) { sSalt = argv[10]; } //std::cout << "Starting ChainGenerator" << std::endl; // Setup CChainWalkContext //std::cout << "ChainGenerator started." << std::endl; if (!CChainWalkContext::SetHashRoutine(sHashRoutineName)) { fprintf(stderr, "hash routine %s not supported\n", sHashRoutineName.c_str()); return 1; } //std::cout << "Hash routine validated" << std::endl; if (!CChainWalkContext::SetPlainCharset(sCharsetName, nPlainLenMin, nPlainLenMax)) { std::cerr << "charset " << sCharsetName << " not supported" << std::endl; return 2; } //std::cout << "Plain charset validated" << std::endl; if (!CChainWalkContext::SetRainbowTableIndex(nRainbowTableIndex)) { std::cerr << "invalid rainbow table index " << nRainbowTableIndex << std::endl; return 3; } //std::cout << "Rainbowtable index validated" << std::endl; if(sHashRoutineName == "mscache")// || sHashRoutineName == "lmchall" || sHashRoutineName == "halflmchall") { // Convert username to unicode const char *szSalt = sSalt.c_str(); int salt_length = strlen(szSalt); unsigned char cur_salt[256]; for (int i=0; i<salt_length; i++) { cur_salt[i*2] = szSalt[i]; cur_salt[i*2+1] = 0x00; } CChainWalkContext::SetSalt(cur_salt, salt_length*2); } else if(sHashRoutineName == "halflmchall") { // The salt is hardcoded into the hash routine // CChainWalkContext::SetSalt((unsigned char*)&salt, 8); } else if(sHashRoutineName == "oracle") { CChainWalkContext::SetSalt((unsigned char *)sSalt.c_str(), sSalt.length()); } //std::cout << "Opening chain file" << std::endl; // Open file boinc_resolve_filename("result", output_path, sizeof(output_path)); fclose(boinc_fopen(output_path, "a")); FILE *outfile = boinc_fopen(output_path, "r+b"); if (outfile == NULL) { std::cerr << "failed to create " << output_path << std::endl; return 4; } // Check existing chains unsigned int nDataLen = (unsigned int)GetFileLen(outfile); // Round to boundary nDataLen = nDataLen / 10 * 10; if (nDataLen == nRainbowChainCount * 10) { std::cerr << "precomputation of this rainbow table already finished" << std::endl; fclose(outfile); return 0; } nChainStart += (nDataLen / 10); fseek(outfile, nDataLen, SEEK_SET); //XXX size_t isn't 32/64 clean size_t nReturn; CChainWalkContext cwc; uint64 nIndex[2]; //time_t tStart = time(NULL); // std::cout << "Starting to generate chains" << std::endl; for(uint32 nCurrentCalculatedChains = nDataLen / 10; nCurrentCalculatedChains < nRainbowChainCount; nCurrentCalculatedChains++) { uint32 cpcheck = 0; unsigned short checkpoint = 0; fd = (double)nCurrentCalculatedChains / (double)nRainbowChainCount; boinc_fraction_done(fd); cwc.SetIndex(nChainStart++); // use a given index now! nIndex[0] = cwc.GetIndex(); for (uint32 nPos = 0; nPos < nRainbowChainLen - 1; nPos++) { // std::cout << "IndexToPlain()" << std::endl; cwc.IndexToPlain(); // std::cout << "PlainToHash()" << std::endl; cwc.PlainToHash(); // std::cout << "HashToIndex()" << std::endl; cwc.HashToIndex(nPos); if(cpcheck < vCPPositions.size() && nPos == vCPPositions[cpcheck]) { checkpoint |= (1 << cpcheck) & (unsigned short)cwc.GetIndex() << cpcheck; cpcheck++; } } //std::cout << "GetIndex()" << std::endl; nIndex[1] = cwc.GetIndex(); // Write chain to disk if ((nReturn = fwrite(&nIndex[1], 1, 8, outfile)) != 8) { std::cerr << "disk write fail" << std::endl; fclose(outfile); return 9; } if((nReturn = fwrite(&checkpoint, 1, 2, outfile)) != 2) { std::cerr << "disk write fail" << std::endl; fclose(outfile); return 9; } } //std::cout << "Generation completed" << std::endl; fclose(outfile); boinc_fraction_done(1); boinc_finish(0); }