int slaptest( int argc, char **argv ) { int rc = EXIT_SUCCESS; const char *progname = "slaptest"; slap_tool_init( progname, SLAPTEST, argc, argv ); if ( slapd_pid_file != NULL ) { if ( test_file( slapd_pid_file, "pid" ) ) { return EXIT_FAILURE; } } if ( slapd_args_file != NULL ) { if ( test_file( slapd_args_file, "args" ) ) { return EXIT_FAILURE; } } if ( !quiet ) { fprintf( stderr, "config file testing succeeded\n"); } if ( slap_tool_destroy()) rc = EXIT_FAILURE; return rc; }
char *recursive_execve(char **path, char **command, char **tabenv, int i) { char *filename; filename = NULL; if (!test_file('.', '/', command)) { if (((filename = command[0]) && (access(command[0], R_OK | X_OK) == -1)) || (execve(filename, command, tabenv) == -1)) return ("Permissions denied."); } else if (command[0][0] != '/') filename = my_strcat(path[i++], command[0], 1); else if (!test_file(' ', '/', command)) if (((filename = command[0]) && (access(command[0], R_OK | X_OK) == -1)) || (execve(filename, command, tabenv) == -1)) return ("Permissions denied."); if (filename != NULL) { execve(filename, command, tabenv); recursive_execve(path, command, tabenv, i); } else return (NULL); return (0); }
static int Test_verifierParseProof(void) { enum { file_size = 2 }; const char* file[file_size] = { "$. ", "p $. " }; const size_t thms_len[file_size] = { 1, 2 }; const size_t thms_0[1] = {0}; const size_t thms_1[2] = {0, 1}; const size_t* thms_s[file_size] = { thms_0, thms_1 }; size_t i; struct verifier vrf; verifierInit(&vrf); struct reader r[file_size]; struct symstring thms[file_size]; for (i = 0; i < file_size; i++) { readerInitString(&r[i], file[i]); symstringInit(&thms[i]); size_tArrayAppend(&thms[i], thms_s[i], thms_len[i]); } struct frame ctx; frameInit(&ctx); #define test_file(f, error) \ do { \ verifierBeginReadingFile(&vrf, &r[f]); \ verifierParseProof(&vrf, &ctx); \ verifierCheckProof(&vrf, &thms[f]); \ check_err(vrf.err, error); \ readerClean(&r[f]); \ } while (0) test_file(0, error_incorrectProof); verifierAddConstant(&vrf, "type"); verifierAddVariable(&vrf, "var"); struct symstring stmt; symstringInit(&stmt); symstringAdd(&stmt, 0); symstringAdd(&stmt, 1); verifierAddFloating(&vrf, "p", &stmt); test_file(1, error_none); for (i = 0; i < file_size; i++) { symstringClean(&thms[i]); } frameClean(&ctx); verifierClean(&vrf); return 0; #undef test_file }
int main(void) { struct xkb_context *ctx = test_get_context(0); assert(test_file(ctx, "keymaps/basic.xkb")); assert(test_file(ctx, "keymaps/comprehensive-plus-geom.xkb")); assert(test_file(ctx, "keymaps/no-types.xkb")); assert(test_file(ctx, "keymaps/quartz.xkb")); assert(!test_file(ctx, "keymaps/divide-by-zero.xkb")); assert(!test_file(ctx, "keymaps/bad.xkb")); assert(!test_file(ctx, "keymaps/syntax-error.xkb")); assert(!test_file(ctx, "keymaps/syntax-error2.xkb")); assert(!test_file(ctx, "does not exist")); /* Test response to invalid flags and formats. */ fclose(stdin); assert(!xkb_keymap_new_from_file(ctx, NULL, XKB_KEYMAP_FORMAT_TEXT_V1, 0)); assert(!xkb_keymap_new_from_file(ctx, stdin, 0, 0)); assert(!xkb_keymap_new_from_file(ctx, stdin, XKB_KEYMAP_USE_ORIGINAL_FORMAT, 0)); assert(!xkb_keymap_new_from_file(ctx, stdin, 1234, 0)); assert(!xkb_keymap_new_from_file(ctx, stdin, XKB_KEYMAP_FORMAT_TEXT_V1, -1)); assert(!xkb_keymap_new_from_file(ctx, stdin, XKB_KEYMAP_FORMAT_TEXT_V1, 1234)); xkb_context_unref(ctx); return 0; }
QUEX_NAMESPACE_MAIN_OPEN static void test(bool BinaryF, size_t BPC) { switch( BPC ) { case 4: test_file(BinaryF, "examples/languages"); /* only with UCS4 */ case 2: test_file(BinaryF, "examples/small"); /* only with UCS4, UCS2 */ case 1: test_file(BinaryF, "examples/festgemauert"); /* with UCS4, UCS2, ASCII */ break; default: hwut_verify(false); } }
static int Test_verifierParseProofSymbol(void) { enum { file_size = 4 }; const char* file[file_size] = { "$. ", "undefined ", "defined_float ", "defined_assert ", }; size_t i; int isEndOfProof; struct verifier vrf; verifierInit(&vrf); struct reader r[file_size]; for (i = 0; i < file_size; i++) { readerInitString(&r[i], file[i]); } struct frame ctx; frameInit(&ctx); #define test_file(f, error) \ do { \ verifierBeginReadingFile(&vrf, &r[f]); \ verifierParseProofSymbol(&vrf, &ctx, &isEndOfProof); \ check_err(vrf.err, error); \ readerClean(&r[f]); \ } while (0) test_file(0, error_none); test_file(1, error_undefinedSymbol); size_t c = verifierAddConstant(&vrf, "c"); size_t v = verifierAddVariable(&vrf, "v"); struct symstring stmt1; symstringInit(&stmt1); symstringAdd(&stmt1, c); symstringAdd(&stmt1, v); verifierAddFloating(&vrf, "defined_float", &stmt1); test_file(2, error_none); struct symstring stmt2; symstringInit(&stmt2); verifierAddAssertion(&vrf, "defined_assert", &stmt2); test_file(3, error_none); ut_assert(vrf.stack.size == 2, "stack size == %lu, should be 2", vrf.stack.size); frameClean(&ctx); verifierClean(&vrf); return 0; #undef test_file }
int main(int argc, char *argv[]) { int opt, flag; flag = 0; e_flag = 0; while ((opt = getopt(argc, argv, "ef:d:")) > 0) { switch (opt) { case 'f': test_file(optarg); flag = 1; break; case 'd': test_folder(optarg); flag = 1; break; case 'e': e_flag = 1; break; default: printf("Usage: %s [-e] [-f <file_name.cs>] [-d <directory>]\n", argv[0]); exit(-1); } } if (flag == 0) { printf("Usage: %s [-e] [-f <file_name.cs>] [-d <directory>]\n", argv[0]); exit(-1); } return 0; }
/****** Loads recent file from list ******/ void main_menu::load_recent(int file_id) { //Check to see if the file actually exists QFile test_file(QString::fromStdString(config::recent_files[file_id])); if(!test_file.exists()) { std::string mesg_text = "The specified file: '" + config::recent_files[file_id] + "' could not be loaded"; warning_box->setText(QString::fromStdString(mesg_text)); warning_box->show(); return; } //Close the core if(main_menu::gbe_plus != NULL) { main_menu::gbe_plus->shutdown(); main_menu::gbe_plus->core_emu::~core_emu(); } config::rom_file = config::recent_files[file_id]; config::save_file = config::rom_file + ".sav"; config::sdl_render = false; config::render_external_sw = render_screen_sw; config::render_external_hw = render_screen_hw; config::sample_rate = settings->sample_rate; if(qt_gui::screen != NULL) { delete qt_gui::screen; } qt_gui::screen = NULL; boot_game(); }
int main() { // ofstream ファイルへの書き出し // Cのファイル書き込みと違い、closeはしなくてもよい。 // デストラクタ内で自動的にファイルを閉じるようになっている。 std::ofstream file("C:\\Users\\vantan\\Desktop\\ofstream\\res\\test.txt", std::ios::trunc); file << "Hello, world!" << std::endl; // 明示的に閉じても問題はない。 file.close(); // ifstream ファイルからの読み込み // ofstreamと同じく、closeはしなくてもよい。 std::ifstream test_file("C:\\Users\\vantan\\Desktop\\ofstream\\res\\test.txt"); std::string str; // ファイルから1行読み込む while (std::getline(test_file, str)){ test_file >> str; std::cout << str << std::endl; } return 0; }
DEF_TEST(document_tests, reporter) { test_empty(reporter); test_abort(reporter); test_abortWithFile(reporter); test_file(reporter); test_close(reporter); }
TEE_Result tee_fs_dirfile_remove(struct tee_fs_dirfile_dirh *dirh, const struct tee_fs_dirfile_fileh *dfh) { TEE_Result res; struct dirfile_entry dent; uint32_t file_number; res = read_dent(dirh, dfh->idx, &dent); if (res) return res; if (!dent.oidlen) return TEE_SUCCESS; file_number = dent.file_number; assert(dfh->file_number == file_number); assert(test_file(dirh, file_number)); memset(&dent, 0, sizeof(dent)); res = write_dent(dirh, dfh->idx, &dent); if (!res) clear_file(dirh, file_number); return res; }
static void test_layout (gconstpointer d) { const gchar *filename = d; gchar *expected_file; GError *error = NULL; GString *dump; gchar *diff; expected_file = get_expected_filename (filename); dump = g_string_sized_new (0); test_file (filename, dump); diff = diff_with_file (expected_file, dump->str, dump->len, &error); g_assert_no_error (error); if (diff && diff[0]) { g_printerr ("Contents don't match expected contents:\n%s", diff); g_test_fail (); g_free (diff); } g_string_free (dump, TRUE); g_free (expected_file); }
/* test local file -----------------------------------------------------------*/ static int test_local(gtime_t ts, gtime_t te, double ti, const char *path, const char *sta, const char *dir, int *nc, int *nt, FILE *fp) { gtime_t time; char remot[1024],remot_p[1024],dir_t[1024],local[1024],str[1024]; int stat,abort=0; for (time=ts;timediff(time,te)<=1E-3;time=timeadd(time,ti)) { sprintf(str,"%s->%s",path,local); if (showmsg(str)) { abort=1; break; } genpath(path,sta,time,0,remot); genpath(dir ,sta,time,0,dir_t); remot2local(remot,dir_t,local); stat=test_file(local); fprintf(fp," %s",stat==0?"-":(stat==1?"o":"z")); showmsg("STAT=%s",stat==0?"x":(stat==1?"o":"z")); (*nt)++; if (stat) (*nc)++; } fprintf(fp,"\n"); return abort; }
void ex2() { // Testing the Multimap with subjects // Start by reading the file string test_file_name = "Test_files/my_mail.txt"; Mail_file test_file(test_file_name); // See what's in the map! cout << "Read following subjects in the map:\n"; for (auto b = test_file.subjects.begin(); b != test_file.subjects.end(); b++) { cout << "Message subject: \"" << b->first << "\"\n"; } // Now, to the exercise proper: cout << "Enter the subject line to look up...\n> "; string lookup_subject; getline(cin, lookup_subject); cout << "Looking for: \"" << lookup_subject << "\"\n"; auto found_subjects = test_file.subjects.equal_range(lookup_subject); if (found_subjects.first != found_subjects.second) { cout << "Found messages:\n"; int count = 1; for (auto b = found_subjects.first; b != found_subjects.second; ++b) { string from_address; find_from_addr(&b->second, from_address); cout << "Message " << count++ << " from " << from_address << endl << b->second << "*** END ***\n"; } } else cout << "No messages found for this subject line.\n"; }
int main(int argc, char * argv[]) { int choix = 0; while(choix != -1) { printf("--------MENU TP2 SDD--------\n"); printf("1) test sur les piles \n"); printf("2) test sur les files \n"); printf("3) Question de l'examen \n"); printf("autre: sortie du programme \n"); scanf("%d",&choix); switch(choix) { case 1 : test_pile(); break; case 2 : test_file(); break; case 3 : exo_exam(); break; default: choix = -1; } } return 0; }
/** * This method will perform the main tasks of this application: * Read the text corpus and create a trie and then read the test * file and query the trie for frequencies. * @param params the runtime program parameters */ static void perform_tasks(const __executor::lm_exec_params & params) { //Attempt to open the test file memory_mapped_file_reader test_file(params.m_query_file_name.c_str()); //Assert that the query file is opened ASSERT_CONDITION_THROW(!test_file.is_open(), string("The Test Queries file: '") + params.m_query_file_name + string("' does not exist!")); //Connect to the language model lm_configurator::connect(params.m_lm_params); //Override the reporting level for testing purposes //Logger::get_reporting_level() = DebugLevelsEnum::DEBUG2; //Execute the queries execute_queries(test_file); //Deallocate the trie LOG_USAGE << "Cleaning up memory ..." << END_LOG; //Close the test file test_file.close(); //Disconnect from the trie lm_configurator::disconnect(); }
int file_reader(char *file, int ***map) { int fd; int ret; char *line; int i; if (!(init_map(map, file))) return (0); if (!test_file(file)) return (0); i = 0; fd = open(file, O_RDONLY); while ((ret = get_next_line(fd, &line)) > 0) { if (!((*map)[i] = line_filler(line, (*map)[i]))) return (0); ft_strdel(&line); i++; } if (!test_size(map)) return (0); close(fd); return ((ret < 0) ? 0 : 1); }
static void test_get_transfer_url_bigfile( void **state ) { const char *url = "http://example.org/big_file"; const char *turl = NULL; char res[256]; int i, fd; Hbf_State hbf_state; hbf_transfer_t *list = NULL; (void) state; list = hbf_init_transfer( url ); assert_non_null( list ); list->threshold = list->block_size = (1024*1024); /* block size 1 MB */ /* open a file */ fd = open( test_file("church.jpg"), O_RDONLY ); assert_true(fd >= 0); hbf_state = hbf_splitlist(list, fd); assert_true( hbf_state == HBF_SUCCESS); assert_true( list->block_cnt == 2 ); for( i=0; i < list->block_cnt; i++ ) { turl = get_transfer_url( list, i ); assert_non_null(turl); sprintf(res, "%s-chunking-%u-%u-%u", url, list->transfer_id, list->block_cnt, i ); /* printf( "XX: %s\n", res ); */ assert_string_equal( turl, res ); } hbf_free_transfer(list); }
static void test_get_transfer_url( void **state ) { const char *url = "http://example.org/owncloud"; const char *turl = NULL; int fd; Hbf_State hbf_state; hbf_transfer_t *list = NULL; (void) state; list = hbf_init_transfer( url ); assert_non_null( list ); /* open a file */ fd = open( test_file("church.jpg"), O_RDONLY ); assert_true(fd >= 0); hbf_state = hbf_splitlist(list, fd); assert_true( hbf_state == HBF_SUCCESS); assert_true( list->block_cnt == 1); turl = get_transfer_url( list, 0 ); assert_non_null( turl ); assert_string_equal( url, turl ); hbf_free_transfer( list ); }
/* test with a file size that is not a multiply of the slize size. */ static void test_hbf_splitlist_zero( void **state ){ hbf_transfer_t *list = NULL; const char *dest_url = "http://localhost/ocm/remote.php/webdav/big/zerofile.txt"; int fd; Hbf_State hbf_state; (void) state; /* open a file */ fd = open(test_file("zerofile.txt"), O_RDONLY); assert_true(fd >= 0); list = hbf_init_transfer(dest_url); assert_non_null(list); hbf_state = hbf_splitlist(list, fd); assert_non_null(list); assert_int_equal(list->stat_size, 0); #ifndef NDEBUG assert_int_equal(list->calc_size, list->stat_size); #endif assert_int_equal(list->block_cnt, 1); assert_true( hbf_state == HBF_SUCCESS); hbf_free_transfer( list ); }
int main (int argc, char *argv[]) { int retval; #ifdef __SYMBIAN32__ g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL); g_set_print_handler(mrtPrintHandler); #endif /*__SYMBIAN32__*/ if (argc > 1) { retval = test_file (argv[1]); #ifdef __SYMBIAN32__ testResultXml("markup-test"); #endif /* EMULATOR */ return retval; } else { fprintf (stderr, "Give a markup file on the command line\n"); return 1; } }
static void test_get_transfer_url( void **state ) { const char *url = "http://example.org/owncloud"; const char *turl = NULL; char res[256]; int i; Hbf_State hbf_state; hbf_transfer_t *list = NULL; list = hbf_init_transfer( url ); assert_non_null( list ); /* open a file */ int fd = open( test_file("church.jpg"), O_RDONLY ); assert_true(fd >= 0); hbf_state = hbf_splitlist(list, fd); assert_true( hbf_state == HBF_SUCCESS); for( i=0; i < list->block_cnt; i++ ) { turl = get_transfer_url( list, i ); sprintf(res, "%s-chunking-%d-%d-%d", url, list->transfer_id, list->block_cnt, i ); printf( "XX: %s\n", res ); assert_string_equal( turl, res ); } }
int main(int argc, char* argv[]) { int i; unsigned readsize; char *dir; printf("readframes tester - [email protected]\n"); if (argc < 3) { printf("Usage: readframes <directory> <readsize>\n"); exit(1); } dir = argv[1]; readsize = strtoul(argv[2], NULL, 0); printf("Testing on directory %s with readsize=%u\n", dir, readsize); test_directory(dir); qsort(file_list, num_files, sizeof(char *), name_cmp); for (i=0;i<num_files;i++) { test_file(file_list[i], readsize); } printf("\nProcessed %d files totalling %.2f MBytes\n", num_files, total_bytes/(1024*1024)); printf("Speed was %.2f files/sec\n", num_files/total_time); printf("Average speed was %.2fms per file\n", 1000.0*total_time/num_files); printf("Worst: %.2fms Best: %.2fms\n", max_time*1000.0, min_time*1000.0); return 0; }
bool OpenCascadeBasedSerializer::ready() { std::ofstream test_file(out_filename.c_str(), std::ios_base::binary); bool succeeded = test_file.is_open(); test_file.close(); remove(out_filename.c_str()); return succeeded; }
int main (int argc, char *argv[]) { gboolean rv; GMimeStream *out_stream; out_stream = g_mime_stream_file_new (stdout); if (argc < 2) { g_printerr ("usage: %s <msg-files>\n", argv[0]); return 1; } setlocale (LC_ALL, ""); g_mime_init(GMIME_ENABLE_RFC2047_WORKAROUNDS); if (argc == 2) { g_mime_stream_printf (out_stream, "%%{"); g_mime_stream_printf (out_stream, "path: \"%s\", ", argv[1]); rv = test_file (argv[1], out_stream); g_mime_stream_printf (out_stream, "}"); } else { g_mime_stream_printf (out_stream, "["); int x; for (x = 1; x < argc; x++ ) { /* printf("File: %s\n", argv[x]); */ if (x > 1) { g_mime_stream_printf (out_stream, ", "); } g_mime_stream_printf (out_stream, "%%{"); g_mime_stream_printf (out_stream, "path: \"%s\", ", argv[x]); rv = test_file (argv[x], out_stream); g_mime_stream_printf (out_stream, "}"); } g_mime_stream_printf (out_stream, "]"); } g_mime_shutdown (); /* flush stdout */ g_mime_stream_flush (out_stream); /* free/close the stream */ g_object_unref (out_stream); return rv ? 0 : 1; }
static int Test_verifierParseFloating(void) { size_t i; enum { file_size = 5 }; const char* file[file_size] = { "$. ", "And mid these dancing rocks at once and ever $.\n", "Chopin piano $. ", "wff x $. ", "wff y $. " }; struct verifier vrf; verifierInit(&vrf); struct reader r[file_size]; struct symstring stmts[file_size]; for (i = 0; i < file_size; i++) { symstringInit(&stmts[i]); readerInitString(&r[i], file[i]); check_err(vrf.err, error_none); } #define test_file(rId, error) \ do { \ LOG_DEBUG("testing file %d", rId); \ verifierBeginReadingFile(&vrf, &r[rId]); \ verifierParseFloating(&vrf, &stmts[rId]); \ check_err(vrf.err, error); \ readerClean(&r[rId]); \ } while (0) test_file(0, error_invalidFloatingStatement); test_file(1, error_invalidFloatingStatement); test_file(2, error_expectedVariableSymbol); verifierAddConstant(&vrf, "wff"); test_file(3, error_expectedVariableSymbol); verifierAddVariable(&vrf, "y"); test_file(4, error_none); LOG_DEBUG("cleaning stmts"); for (i = 0; i < file_size; i++) { symstringClean(&stmts[i]); } LOG_DEBUG("cleaning vrf"); verifierClean(&vrf); return 0; #undef test_file }
/* test with a file size that is not a multiply of the slize size. */ static void test_hbf_splitlist_odd( void **state ){ hbf_transfer_t *list = NULL; const char *dest_url = "http://localhost/ocm/remote.php/webdav/big/church.jpg"; int prev_id = 0; int i, fd; Hbf_State hbf_state; (void) state; /* open a file */ fd = open(test_file("church.jpg"), O_RDONLY); assert_true(fd >= 0); /* do a smoke test for uniqueness */ for( i=0; i < 10000; i++) { list = hbf_init_transfer(dest_url); assert_non_null(list); usleep(1); hbf_state = hbf_splitlist(list, fd); assert_int_not_equal(list->transfer_id, prev_id); prev_id = list->transfer_id; hbf_free_transfer(list); } list = hbf_init_transfer(dest_url); assert_non_null(list); hbf_state = hbf_splitlist(list, fd); assert_non_null(list); #ifndef NDEBUG assert_int_equal(list->calc_size, list->stat_size); #endif assert_int_not_equal(list->block_cnt, 0); assert_true( hbf_state == HBF_SUCCESS); /* checks on the block list */ if( 1 ) { int seen_zero_seq = 0; int prev_seq = -1; int64_t prev_block_end = -1; for( i=0; i < list->block_cnt; i++) { hbf_block_t *blk = list->block_arr[i]; assert_non_null(blk); if( blk->seq_number == 0 ) seen_zero_seq++; assert_int_equal(prev_seq, blk->seq_number -1 ); prev_seq = blk->seq_number; assert_true((prev_block_end+1) == (blk->start)); prev_block_end = blk->start + blk->size; } /* Make sure we exactly saw blk->seq_number == 0 exactly one times */ assert_int_equal( seen_zero_seq, 1 ); } hbf_free_transfer( list ); }
DEF_TEST(document_tests, reporter) { REQUIRE_PDF_DOCUMENT(document_tests, reporter); test_empty(reporter); test_abort(reporter); test_abortWithFile(reporter); test_file(reporter); test_close(reporter); }
static char* default_file(void){ struct stat sb; char *np_env=NULL, *default_file=NULL; char temp_file[MAX_INPUT_BUFFER]; size_t len; if((np_env=getenv("NAGIOS_CONFIG_PATH"))!=NULL) { /* skip any starting colon... */ while(*np_env==':') np_env++; /* Look for NP_DEFAULT_INI_FILENAME1 and NP_DEFAULT_INI_FILENAME2 in * every PATHs defined (colon-separated). */ while((len=strcspn(np_env,":"))>0){ /* Test NP_DEFAULT_INI_FILENAME[1-2] in current np_env token */ if(test_file(np_env,len,NP_DEFAULT_INI_FILENAME1,temp_file)==1 || test_file(np_env,len,NP_DEFAULT_INI_FILENAME2,temp_file)==1){ default_file=strdup(temp_file); break; } /* Move on to the next token */ np_env+=len; while(*np_env==':') np_env++; } /* while(...) */ } /* if(getenv("NAGIOS_CONFIG_PATH")) */ /* Look for NP_DEFAULT_INI_FILENAME1 in NP_DEFAULT_INI_NAGIOS_PATH[1-4] */ if(!default_file){ if(test_file(NP_DEFAULT_INI_NAGIOS_PATH1,strlen(NP_DEFAULT_INI_NAGIOS_PATH1),NP_DEFAULT_INI_FILENAME1,temp_file)==1 || test_file(NP_DEFAULT_INI_NAGIOS_PATH2,strlen(NP_DEFAULT_INI_NAGIOS_PATH2),NP_DEFAULT_INI_FILENAME1,temp_file)==1 || test_file(NP_DEFAULT_INI_NAGIOS_PATH3,strlen(NP_DEFAULT_INI_NAGIOS_PATH3),NP_DEFAULT_INI_FILENAME1,temp_file)==1 || test_file(NP_DEFAULT_INI_NAGIOS_PATH4,strlen(NP_DEFAULT_INI_NAGIOS_PATH4),NP_DEFAULT_INI_FILENAME1,temp_file)==1) default_file=strdup(temp_file); } /* Look for NP_DEFAULT_INI_FILENAME2 in NP_DEFAULT_INI_PATH[1-3] */ if(!default_file){ if(test_file(NP_DEFAULT_INI_PATH1,strlen(NP_DEFAULT_INI_PATH1),NP_DEFAULT_INI_FILENAME2,temp_file)==1 || test_file(NP_DEFAULT_INI_PATH2,strlen(NP_DEFAULT_INI_PATH2),NP_DEFAULT_INI_FILENAME2,temp_file)==1 || test_file(NP_DEFAULT_INI_PATH3,strlen(NP_DEFAULT_INI_PATH3),NP_DEFAULT_INI_FILENAME2,temp_file)==1) default_file=strdup(temp_file); } /* Return default_file or empty string (should return NULL if we want plugins * to die there)... */ if(default_file) return default_file; return ""; }
drvstus_t rfs_entry(driver_t * drvp, uint_t val, void * p) { printfk("%s %d line \n\r", __func__, __LINE__); if(drvp == NULL) { printfk("drvp NULL\n\r"); return DFCERRSTUS; } device_t * devp = new_device_dsc(); if(devp == NULL) { printfk("new device failed\n\r"); return DFCERRSTUS; } printfk("%s %d line \n\r", __func__, __LINE__); rfs_set_driver(drvp); printfk("%s %d line \n\r", __func__, __LINE__); rfs_set_device(devp, drvp); printfk("%s %d line \n\r", __func__, __LINE__); if(new_rfsdevext_mmblk(devp, FSMM_BLK) == DFCERRSTUS) { printfk("new rfsdevext_mmblk failed\n\r"); if(del_device_dsc(devp) == DFCERRSTUS) { printfk("del_device_dsc failed\n\r"); } return DFCERRSTUS; } printfk("%s %d line \n\r", __func__, __LINE__); if(krldev_add_driver(devp, drvp) == DFCERRSTUS) { printfk("krldev add driver failed\n\r"); if(del_device_dsc(devp) == DFCERRSTUS) { printfk("del_device_dsc failed\n\r"); } return DFCERRSTUS; } printfk("%s %d line \n\r", __func__, __LINE__); if(krlnew_device(devp) == DFCERRSTUS) { printfk("krlnew device failed\n\r"); if(del_device_dsc(devp) == DFCERRSTUS) { printfk("del_device_dsc failed\n\r"); } return DFCERRSTUS; } init_rfs(devp); test_file(devp); return DFCOKSTUS; }