Foam::h5Write::h5Write ( const word& name, const objectRegistry& obr, const dictionary& dict, const bool loadFromFiles ) : name_(name), obr_(obr), mesh_(refCast<const fvMesh>(obr)) { // Read dictionary read(dict); // Calssify fields nFields_ = classifyFields(); // Initialize file fileCreate(); // Only do if some fields are to be written if (nFields_) { // Set length of cell numbers array nCells_.setSize(Pstream::nProcs()); // Write mesh and initial conditions meshWrite(); write(); } }
// =-=-=-=-=-=-=- // local function to handle sub file creation int _rsSubStructFileCreate( rsComm_t* _comm, subFile_t* _sub_file ) { irods::structured_object_ptr struct_obj( new irods::structured_object( *_sub_file ) ); struct_obj->comm( _comm ); struct_obj->resc_hier( _sub_file->specColl->rescHier ); irods::error err = fileCreate( _comm, struct_obj ); if ( !err.ok() ) { std::stringstream msg; msg << "failed on call to fileCreate for ["; msg << struct_obj->sub_file_path(); irods::log( PASSMSG( msg.str(), err ) ); return 0; } else { return err.code(); } } // _rsSubStructFileCreate
/** * Shell command () prints existing files or creates new ones. * @param args array of arguments * @return OK for success, SYSERR for syntax error */ command xsh_cat(int nargs, char *args[]) { int fd = 0; char c = 0; /* Output help, if '--help' argument was supplied */ if ((nargs == 2 && strncmp(args[1], "--help", 6) == 0) || (nargs > 3) || (nargs < 2)) { printf("Usage: cat [filename] or cat > [filename]\n"); printf("Print file contents or copy console input into new file.\n"); printf("\t--help\t display this help and exit\n"); return OK; } if (nargs == 2) { /* Cat a file */ fd = fileOpen(args[1]); if (SYSERR != fd) { fileSeek(fd, 0); while ((c = fileGetChar(fd)) != (char)SYSERR) { printf("%c", c); } } else { printf("File \"%s\" not found.\n", args[1]); } printf("\n\n"); return OK; } if (strncmp(args[1], ">", 2)) { printf("ERROR: Cannot read from \"%s\", only CONSOLE!\n", args[1]); return SYSERR; } if (SYSERR != fileOpen(args[2])) { printf("ERROR: file \"%s\" already exists!\n", args[2]); return SYSERR; } fd = fileCreate(args[2]); if (SYSERR == fd) { printf("ERROR creating file \"%s\"\n", args[2]); return SYSERR; } printf("Creating new file \"%s\". Enter ~ to exit.\n", args[2]); while ((c = getc(CONSOLE)) != '~') { filePutChar(fd, c); } fileClose(fd); return OK; }
static void addFile(File *root, char *name, uint mode) { File *f; f = fileCreate(root, name, mode | ModeDir, "adm"); if(f == nil) vtFatal("could not create file: %s: %r", name); fileDecRef(f); }
int main(int argc, char *argv[]) { ServerArguments arguments; // Arguments parser. if (serverArgumentsCreate(&arguments, argc, argv) == ERROR) { return ERROR; } File file; if (fileCreate(&file, serverArgumentsFileRoute(&arguments)) == ERROR) { return ERROR; } int sesion_id = ONE; while (!feof(fileAsociatedFile(&file))) { long line_length = fileLineLengthCount(&file); char buffer[line_length + ONE]; fileReadLine(&file, buffer, (int)line_length + ONE); Process process; processCreate(&process, buffer, sesion_id); sesion_id++; } // Create server. Server server; if (serverCreate(&server) == ERROR) { return ERROR; } if (serverOpen(&server, serverArgumentsPort(&arguments)) == ERROR) { return ERROR; } Socket new_sock = serverAccept(&server); if (new_sock.sockfd == ERROR) { return ERROR; } if (socketSend(&new_sock, NULL) == ERROR) { return ERROR; } serverArgumentsDestroy(&arguments); serverDestroy(&server); socketDestroy(&new_sock); fileDestroy(&file); return ZERO; }
void CreateDataFiles() { if (!ONWIN) { std::string temp = "mkdir \""; temp += getenv("HOME"); temp += "/.config/cubepass\""; std::system(temp.c_str()); } else { std::string temp = "md \""; temp += getenv("APPDATA"); temp += "\\CubePass\""; system(temp.c_str()); } std::ofstream fileCreate(SETTINGS_FILE.c_str()); fileCreate.close(); fileCreate.open(DATABASE_FILE.c_str()); fileCreate.close(); inip::iniParser _iniFile(SETTINGS_FILE); nihdb::dataBase _datFile(DATABASE_FILE); _iniFile.CreateSection("Startup"); _iniFile.AddProperty("Startup", "Version", VERSION); _iniFile.AddProperty("Startup", "RememberUsername", "false"); _iniFile.AddProperty("Startup", "ShowHelp", "true"); _iniFile.CreateSection("Users"); _datFile.AddComment("CubePass database"); _datFile.AddComment("This database stores all the data for CubePass"); _datFile.AddComment("ALL SENSITIVE DATA IS ENCRYPTED"); _datFile.AddComment(""); _iniFile.ApplyChanges(); _datFile.ApplyChanges(); return; }
static int usersFileWrite(Ubox* box) { Fs *fs; User *u; int i, r; Fsys *fsys; char *p, *q, *s; File *dir, *file; if((fsys = fsysGet("main")) == nil) return 0; fsysFsRlock(fsys); fs = fsysGetFs(fsys); /* * BUG: * the owner/group/permissions need to be thought out. */ r = 0; if((dir = fileOpen(fs, "/active")) == nil) goto tidy0; if((file = fileWalk(dir, uidadm)) == nil) file = fileCreate(dir, uidadm, ModeDir|0775, uidadm); fileDecRef(dir); if(file == nil) goto tidy; dir = file; if((file = fileWalk(dir, "users")) == nil) file = fileCreate(dir, "users", 0664, uidadm); fileDecRef(dir); if(file == nil) goto tidy; if(!fileTruncate(file, uidadm)) goto tidy; p = s = vtMemAlloc(box->len+1); q = p + box->len+1; for(u = box->head; u != nil; u = u->next){ p += snprint(p, q-p, "%s:%s:", u->uid, u->uname); if(u->leader != nil) p+= snprint(p, q-p, u->leader); p += snprint(p, q-p, ":"); if(u->ngroup){ p += snprint(p, q-p, u->group[0]); for(i = 1; i < u->ngroup; i++) p += snprint(p, q-p, ",%s", u->group[i]); } p += snprint(p, q-p, "\n"); } r = fileWrite(file, s, box->len, 0, uidadm); vtMemFree(s); tidy: if(file != nil) fileDecRef(file); tidy0: fsysFsRUnlock(fsys); fsysPut(fsys); return r; }
/*----main*--------*/ int main(int argc,char* argv[]){ fileCreate("666.m3u"); printf("DONE!\n"); getchar(); return 0; }
/* * Prepare the directory to store a snapshot. * Temporary snapshots go into /snapshot/yyyy/mmdd/hhmm[.#] * Archival snapshots go into /archive/yyyy/mmdd[.#]. * * TODO This should be rewritten to eliminate most of the duplication. */ static File* fileOpenSnapshot(Fs *fs, char *dstpath, int doarchive) { int n; char buf[30], *s, *p, *elem; File *dir, *f; Tm now; if(dstpath){ if((p = strrchr(dstpath, '/')) != nil){ *p++ = '\0'; elem = p; p = dstpath; if(*p == '\0') p = "/"; }else{ p = "/"; elem = dstpath; } if((dir = fileOpen(fs, p)) == nil) return nil; f = fileCreate(dir, elem, ModeDir|ModeSnapshot|0555, "adm"); fileDecRef(dir); return f; }else if(doarchive){ /* * a snapshot intended to be archived to venti. */ dir = fileOpen(fs, "/archive"); if(dir == nil) return nil; now = *localtime(time(0)); /* yyyy */ snprint(buf, sizeof(buf), "%d", now.year+1900); f = fileWalk(dir, buf); if(f == nil) f = fileCreate(dir, buf, ModeDir|0555, "adm"); fileDecRef(dir); if(f == nil) return nil; dir = f; /* mmdd[#] */ snprint(buf, sizeof(buf), "%02d%02d", now.mon+1, now.mday); s = buf+strlen(buf); for(n=0;; n++){ if(n) seprint(s, buf+sizeof(buf), ".%d", n); f = fileWalk(dir, buf); if(f != nil){ fileDecRef(f); continue; } f = fileCreate(dir, buf, ModeDir|ModeSnapshot|0555, "adm"); break; } fileDecRef(dir); return f; }else{ /* * Just a temporary snapshot * We'll use /snapshot/yyyy/mmdd/hhmm. * There may well be a better naming scheme. * (I'd have used hh:mm but ':' is reserved in Microsoft file systems.) */ dir = fileOpen(fs, "/snapshot"); if(dir == nil) return nil; now = *localtime(time(0)); /* yyyy */ snprint(buf, sizeof(buf), "%d", now.year+1900); f = fileWalk(dir, buf); if(f == nil) f = fileCreate(dir, buf, ModeDir|0555, "adm"); fileDecRef(dir); if(f == nil) return nil; dir = f; /* mmdd */ snprint(buf, sizeof(buf), "%02d%02d", now.mon+1, now.mday); f = fileWalk(dir, buf); if(f == nil) f = fileCreate(dir, buf, ModeDir|0555, "adm"); fileDecRef(dir); if(f == nil) return nil; dir = f; /* hhmm[.#] */ snprint(buf, sizeof buf, "%02d%02d", now.hour, now.min); s = buf+strlen(buf); for(n=0;; n++){ if(n) seprint(s, buf+sizeof(buf), ".%d", n); f = fileWalk(dir, buf); if(f != nil){ fileDecRef(f); continue; } f = fileCreate(dir, buf, ModeDir|ModeSnapshot|0555, "adm"); break; } fileDecRef(dir); return f; } }
int runIntegrationTest(const char *testName, CharString testArguments, ReturnCode expectedResultCode, const TestOutputType testOutputType, const CharString mrsWatsonExePath, const CharString resourcesPath) { int result = 0; int returnCode; ReturnCode resultCode; ChannelCount failedAnalysisChannel; SampleCount failedAnalysisFrame; #if WINDOWS STARTUPINFOA startupInfo; PROCESS_INFORMATION processInfo; #endif // Remove files from a previous test run File outputFolder = newFileWithPathCString(kApplicationRunnerOutputFolder); if (fileExists(outputFolder)) { _removeOutputFiles(testName); } else { fileCreate(outputFolder, kFileTypeDirectory); } freeFile(outputFolder); if (mrsWatsonExePath == NULL) { return -1; } else { File mrsWatsonExe = newFileWithPath(mrsWatsonExePath); boolByte mrsWatsonExeExists = fileExists(mrsWatsonExe); freeFile(mrsWatsonExe); if (!mrsWatsonExeExists) { freeCharString(testArguments); return -1; } } if (resourcesPath == NULL) { freeCharString(testArguments); return -1; } else { File resourcesFile = newFileWithPath(resourcesPath); boolByte resourcesExists = fileExists(resourcesFile); freeFile(resourcesFile); if (!resourcesExists) { freeCharString(testArguments); return -1; } } // Create the command line argument CharString arguments = newCharStringWithCapacity(kCharStringLengthLong); charStringAppendCString(arguments, "\""); charStringAppend(arguments, mrsWatsonExePath); charStringAppendCString(arguments, "\""); charStringAppendCString(arguments, " "); CharString defaultArguments; CharString outputFilename = getTestOutputFilename(testName, testOutputType); defaultArguments = _getDefaultArguments(testName, resourcesPath, outputFilename); charStringAppend(arguments, defaultArguments); freeCharString(defaultArguments); charStringAppendCString(arguments, " "); charStringAppend(arguments, testArguments); // Although testArguments is passed into this function (and hence, it would // generally not take ownership of it), in this case we free the arguments // here to make writing the test cases simpler and reduce the amount of // boilerplate code. freeCharString(testArguments); #if WINDOWS memset(&startupInfo, 0, sizeof(startupInfo)); memset(&processInfo, 0, sizeof(processInfo)); startupInfo.cb = sizeof(startupInfo); returnCode = CreateProcessA( (LPCSTR)(mrsWatsonExePath->data), (LPSTR)(arguments->data), 0, 0, false, CREATE_DEFAULT_ERROR_MODE, 0, 0, &startupInfo, &processInfo); if (returnCode) { // TODO: Check return codes for these calls WaitForSingleObject(processInfo.hProcess, kApplicationRunnerWaitTimeoutInMs); GetExitCodeProcess(processInfo.hProcess, (LPDWORD)&resultCode); CloseHandle(processInfo.hProcess); CloseHandle(processInfo.hThread); } else { logCritical("Could not launch process, got error %s", stringForLastError(GetLastError())); return 1; } #else returnCode = system(arguments->data); resultCode = (ReturnCode)WEXITSTATUS(returnCode); #endif freeCharString(arguments); if (resultCode == RETURN_CODE_FORK_FAILED || resultCode == RETURN_CODE_SHELL_FAILED || resultCode == RETURN_CODE_LAUNCH_FAILED_OTHER) { logCritical("Could not launch shell, got return code %d\n\ Please check the executable path specified in the --mrswatson-path argument.", resultCode); return 1; } else if (resultCode == expectedResultCode) { CharString failedAnalysisFunctionName = newCharString(); if (testOutputType != kTestOutputNone) { if (analyzeFile(outputFilename->data, failedAnalysisFunctionName, &failedAnalysisChannel, &failedAnalysisFrame)) { // TODO: // if (!testEnvironment->results->keepFiles) { // _removeOutputFiles(testName); // } result = 0; } else { fprintf(stderr, "Audio analysis check for %s failed at frame %lu, channel %d. ", failedAnalysisFunctionName->data, failedAnalysisFrame, failedAnalysisChannel); result = 1; } } else { result = 0; // TODO: // if (!testEnvironment->results->keepFiles) { // _removeOutputFiles(testName); // } } freeCharString(failedAnalysisFunctionName); } else { fprintf(stderr, "Expected result code %d (%s), got %d (%s). ", expectedResultCode, _getResultCodeString(expectedResultCode), resultCode, _getResultCodeString(resultCode)); result = 1; } freeCharString(outputFilename); return result; }
bool_t bakeDemo() { bign_params params[1]; octet randa[48]; octet randb[48]; octet echoa[64]; octet echob[64]; bake_settings settingsa[1]; bake_settings settingsb[1]; octet da[32]; octet db[32]; octet certdataa[5 + 64]; octet certdatab[3 + 64]; bake_cert certa[1]; bake_cert certb[1]; octet file_data[1024]; file_st filea[1]; file_st fileb[1]; const char pwd[] = "8086"; octet keya[32]; octet keyb[32]; // загрузить долговременные параметры if (bignStdParams(params, "1.2.112.0.2.0.34.101.45.3.1") != ERR_OK) return FALSE; // настроить генераторы ASSERT(prngEcho_keep() <= sizeof(echoa)); // задать настройки memSetZero(settingsa, sizeof(bake_settings)); memSetZero(settingsb, sizeof(bake_settings)); settingsa->kca = settingsa->kcb = TRUE; settingsb->kca = settingsb->kcb = TRUE; settingsa->rng = settingsb->rng = prngEchoStepR; settingsa->rng_state = echoa; settingsb->rng_state = echob; // загрузить личные ключи hexTo(da, _da); hexTo(db, _db); // загрузить сертификаты hexTo(certdataa, _certa); hexTo(certdatab, _certb); certa->data = certdataa; certa->len = strLen(_certa) / 2; certb->data = certdatab; certb->len = strLen(_certb) / 2; certa->val = certb->val = certVal; // тест Б.2 hexTo(randa, _bmqv_randa); hexTo(randb, _bmqv_randb); ASSERT(sizeof(file_data) >= sizeof(_bmqv_data) / 2); hexTo(file_data, _bmqv_data); if (fileCreate(filea, file_data, strlen(_bmqv_data) / 2) != ERR_OK || fileCreate(fileb, file_data, strlen(_bmqv_data) / 2) != ERR_OK) return FALSE; prngEchoStart(echoa, randa, strLen(_bmqv_randb) / 2); prngEchoStart(echob, randb, strLen(_bmqv_randb) / 2); if (bakeBMQVRunB(keyb, params, settingsb, db, certb, certa, fileRead, fileWrite, fileb) != ERR_OK || bakeBMQVRunA(keya, params, settingsa, da, certa, certb, fileRead, fileWrite, filea)) return FALSE; if (!memEq(keya, keyb, 32) || !hexEq(keya, "C6F86D0E468D5EF1A9955B2EE0CF0581" "050C81D1B47727092408E863C7EEB48C")) return FALSE; // тест Б.3 hexTo(randa, _bsts_randa); hexTo(randb, _bsts_randb); ASSERT(sizeof(file_data) >= strlen(_bsts_data) / 2); hexTo(file_data, _bsts_data); if (fileCreate(filea, file_data, strlen(_bsts_data) / 2) != ERR_OK || fileCreate(fileb, file_data, strlen(_bsts_data) / 2) != ERR_OK) return FALSE; prngEchoStart(echoa, randa, strLen(_bsts_randb) / 2); prngEchoStart(echob, randb, strLen(_bsts_randb) / 2); if (bakeBSTSRunB(keyb, params, settingsb, db, certb, certVal, fileRead, fileWrite, fileb) != ERR_OK || bakeBSTSRunA(keya, params, settingsa, da, certa, certVal, fileRead, fileWrite, filea)) return FALSE; if (!memEq(keya, keyb, 32) || !hexEq(keya, "78EF2C56BD6DA2116BB5BEE80CEE5C05" "394E7609183CF7F76DF0C2DCFB25C4AD")) return FALSE; // тест Б.4 hexTo(randa, _bpace_randa); hexTo(randb, _bpace_randb); ASSERT(sizeof(file_data) >= strlen(_bsts_data) / 2); hexTo(file_data, _bpace_data); if (fileCreate(filea, file_data, strlen(_bpace_data) / 2) != ERR_OK || fileCreate(fileb, file_data, strlen(_bpace_data) / 2) != ERR_OK) return FALSE; prngEchoStart(echoa, randa, strLen(_bpace_randb) / 2); prngEchoStart(echob, randb, strLen(_bpace_randb) / 2); if (bakeBPACERunB(keyb, params, settingsb, (octet*)pwd, strLen(pwd), fileRead, fileWrite, fileb) != ERR_OK || bakeBPACERunA(keya, params, settingsa, (octet*)pwd, strLen(pwd), fileRead, fileWrite, filea)) return FALSE; if (!memEq(keya, keyb, 32) || !hexEq(keya, "DAC4D8F411F9C523D28BBAAB32A5270E" "4DFA1F0F757EF8E0F30AF08FBDE1E7F4")) return FALSE; // все нормально return TRUE; }
void errorReporterInitialize(ErrorReporter self) { CharString infoText = newCharStringWithCString(kErrorReportInfoText); CharString wrappedInfoText; time_t now; size_t length; size_t i; printf("=== Starting error report ===\n"); wrappedInfoText = charStringWrap(infoText, 0); // The second newline here is intentional printf("%s\n", wrappedInfoText->data); time(&now); self->started = true; snprintf(self->reportName->data, self->reportName->capacity, "MrsWatson Report %s", ctime(&now)); // Trim the final newline character from this string if it exists length = strlen(self->reportName->data); if (self->reportName->data[length - 1] == '\n') { self->reportName->data[length - 1] = '\0'; length--; } for (i = 0; i < length; i++) { if (!(charStringIsLetter(self->reportName, i) || charStringIsNumber(self->reportName, i))) { self->reportName->data[i] = '-'; } } #if UNIX snprintf(self->desktopPath->data, self->desktopPath->capacity, "%s/Desktop", getenv("HOME")); #elif WINDOWS SHGetFolderPathA(NULL, CSIDL_DESKTOPDIRECTORY, NULL, 0, self->desktopPath->data); #endif // Try to place the report on the user's desktop. However, if we cannot find // the desktop (which may occur with localized Linux installations, for instance), // then just dump it in the current directory instead. File desktopPath = newFileWithPath(self->desktopPath); File reportPath; if (!fileExists(desktopPath)) { logWarn("Could not find desktop location, placing error report in current directory instead"); CharString currentDirString = fileGetCurrentDirectory(); File currentDir = newFileWithPath(currentDirString); reportPath = newFileWithParent(currentDir, self->reportName); freeFile(currentDir); freeCharString(currentDirString); } else { reportPath = newFileWithParent(desktopPath, self->reportName); freeFile(desktopPath); } if (fileExists(reportPath)) { logCritical("The path '%s' already contains a previous error report. Please remove the report data and try again."); } else { fileCreate(reportPath, kFileTypeDirectory); } // Now we should have a real error report path charStringCopy(self->reportDirPath, reportPath->absolutePath); freeFile(reportPath); freeCharString(wrappedInfoText); freeCharString(infoText); }