C++ check_file函数代码示例

void read_out()
{
	int k=0;
	FILE *fopen(),*fp;
	int count;
	fp=fopen("database.txt","r");

	if(check_file(fp)==0){printf("Problem reading the file SLOTS_BEST_productN.txt, have you created it yet?\r\n");}
	else
		{
			count=getc(fp);
			while(count!=EOF)
			{
				count=getc(fp);
				putchar(count);
			}
		}//open the file and put the characters onto the screen
	fclose(fp);
	wait_for_user();
}

void run_bst_del(char *file, std::vector<char *> & strvec)
{
    if (FALSE == check_file(file)) {
        exit(1);
    }

    ifstream fin(file);
    if (!fin.good()) {
        cerr << "read file: " << file << " failed.\n";
        exit(1);
    }
    Bst bst(fin);
    bst.build();

    for (size_t i=0; i< strvec.size(); i++) {
        cout << "\nDeleted \""<< strvec[i] << "\":\n\n";
        bst.del(strvec[i]);
        bst.display();
    }
}

int Command_load(Command *cmd)
{
    bstring db_file = option(cmd, "db", "config.sqlite");
    bstring conf_file = option(cmd, "config", "mongrel2.conf");
    bstring what = NULL;
    bstring why = NULL;

    check_file(conf_file, "config file", R_OK);
    Config_load(bdata(conf_file), bdata(db_file));

    what = bfromcstr("load");
    why = bfromcstr("command");

    log_action(db_file, what, why, NULL, conf_file);

error: // fallthrough
    bdestroy(what);
    bdestroy(why);
    return 0;
}

int check_directory(const char* dirpath)
{
    int num_error = 0;
    std::vector<std::string>* subdir_names = NULL;
    std::vector<std::string> file_names;
    std::vector<std::string>* link_names = NULL;
    mooon::sys::CDirUtils::list(dirpath, subdir_names, &file_names, link_names);

    for (std::vector<std::string>::size_type i=0; i<file_names.size(); ++i)
    {
        if (mooon::db_proxy::is_sql_log_filename(file_names[i]))
        {
            const std::string filepath = mooon::utils::CStringUtils::format_string("%s/%s", dirpath, file_names[i].c_str());
            if (check_file(filepath.c_str()) != 0)
                ++num_error;
        }
    }

    return 0 == num_error;
}

void	send_file(t_all *all, char *cmd)
{
	int		fd;
	char	buff[MAX_SIZE];

	cmd = cmd + 4;
	if (check_file(cmd) == -1)
		display_return_and_explanation(cmd, all->sv->c_sock, 0, 'f');
	else
	{
		if ((fd = open(cmd, O_RDONLY)) == -1)
			server_error("OPEN");
		if (read(fd, buff, MAX_SIZE - 1) == -1)
			server_error("READ");
		// printf("%lu\n", sizeof(buff));
		// all.
		send(all->sv->c_sock, buff, ft_strlen(buff), 0);
	}
	/*send(all->sv->c_sock, pwd, ft_strlen(pwd), 0);*/
}

static void test(void)
{
  int rv = 0;
  const char file_a [] = "/FTP/127.0.0.1/a.txt";
  const char file_b [] = "/FTP/127.0.0.1/b.txt";

  rv = rtems_bsdnet_initialize_network();
  rtems_test_assert(rv == 0);

  rv = rtems_initialize_ftpd();
  rtems_test_assert(rv == 0);

  initialize_ftpfs();
  change_self_priority();
  create_file(file_a, &content [0], sizeof(content));
  copy_file(file_a, file_b);
  check_file(file_b);
  check_file_size(file_a, sizeof(content));
  check_file_size(file_b, sizeof(content));
}

    int FileOperation::write_file(const char* buf, const int32_t nbytes)
    {
      const char *p_tmp = buf;
      int32_t left = nbytes;
      int32_t written_len = 0;
      int i = 0;
      while (left > 0)
      {
        ++i;
        if (i >= MAX_DISK_TIMES)
        {
          break;
        }

        if (check_file() < 0)
          return -errno;

        if ((written_len = ::write(fd_, p_tmp, left)) <= 0)
        {
          written_len = -errno;
          if (EINTR == -written_len || EAGAIN == -written_len)
          {
            continue;
          }
          if (EBADF == -written_len)
          {
            fd_ = -1;
            continue;
          }
          else
          {
            return written_len;
          }
        }

        left -= written_len;
        p_tmp += written_len;
      }

      return p_tmp - buf;
    }

int CTimerFile::write_data(const void *data, uint32_t len)
{
    if (check_file() == -1)
    {
        return -1;
    }
    
    size_t res = fwrite(data, 1, len, m_file_stream);
    if (res != len)
    {
        LOG_DEBUG("Write to file failed. %d, %s", errno, strerror(errno));
        return -1;
    }
    
    fflush(m_file_stream);
    
    m_cur_file_line++;
    m_last_write_time = std::time(nullptr);
    
    return 0;
}

static struct classifier_config*
read_config(FILE *input) 
{
    assert(input);
    struct file_range types_section, atoms_section; 
    struct classifier_config *config = NULL;
    struct classifier_types *types = NULL;

    if (!(types = classifier_types_new()) ||
        !(config = classifier_config_new()) ||
        check_file(input, &types_section, &atoms_section) ||
        read_types(types, input, types_section) ||
        read_atoms(config, types, input, atoms_section) ||
        config_copy_classes(config, types)) {
        classifier_config_free(config);
        config = NULL;
    }
    classifier_types_free(types);
    
    return config;
}

int
main(int argc, char **argv)
{
   unsigned char uchar_out[DIM1_LEN] = {0, 128, 255};
   int format[MAX_NUM_FORMATS];
   int num_formats;
   int f = 0;

   printf("\n*** Testing netcdf data conversion.\n");
   determine_test_formats(&num_formats, format);

   for (f = 0; f < num_formats; f++)
   {
      printf("*** Testing conversion in netCDF %s files... ", format_name[f]);
      create_file(format[f], uchar_out);
      check_file(format[f], uchar_out);
      SUMMARIZE_ERR;
   }

   FINAL_RESULTS;
}

    LPTR load_file(LPTR address, status_t* result)
    {
        header_t* h = address;
        *result = check_file(h);
        if (*result != status_t::Ok)
            return nullptr;

        ph_t* ph = nullptr;

        for (int i = 0; i < h->pht_entry_c; ++i)
        {
            ph = (uint32_t)h + h->pht_off + i*h->pht_entry_s;

            if (ph->type != ph_type::Load)
                continue;

            memory::memcpy(ph->p_addr, (uint32_t)h +ph->offset, ph->size);
        }

        return h->entry;
    }

/* This opens and checks a netCDF file. */
int open_and_check_file(MPI_Comm comm, int iosysid, int iotype, int *ncid, char *fname,
                        char *attname, char *dimname, int disable_close, int my_rank)
{
    int mode = PIO_WRITE;
    int ret;

    /* Open the file. */
    if ((ret = PIOc_openfile(iosysid, ncid, &iotype, fname, mode)))
        return ret;

    /* Check the file. */
    if ((ret = check_file(comm, iosysid, iotype, *ncid, fname, attname, dimname, my_rank)))
        return ret;

    /* Close the file, maybe. */
    if (!disable_close)
        if ((ret = PIOc_closefile(*ncid)))
            return ret;

    return PIO_NOERR;
}

/* verify that the filesystem matches the package database */
static int check_files(alpm_pkg_t *pkg)
{
	alpm_filelist_t *filelist = alpm_pkg_get_files(pkg);
	char path[PATH_MAX], *rel;
	const char *pkgname = alpm_pkg_get_name(pkg);
	unsigned int i;
	int ret = 0;
	size_t space;

	strncpy(path, alpm_option_get_root(handle), PATH_MAX);
	rel = path + strlen(path);
	space = PATH_MAX - (rel - path);

	for(i = 0; i < filelist->count; ++i) {
		alpm_file_t file = filelist->files[i];
		int isdir = 0;
		size_t len;

		if(skip_noextract && match_noextract(handle, file.name)) { continue; }

		strncpy(rel, file.name, space);
		len = strlen(file.name);
		if(rel[len - 1] == '/') {
			isdir = 1;
			rel[len - 1] = '\0';
		}

		if(check_file(pkgname, path, isdir) != 0) { ret = 1; }
	}

	if(include_db_files && check_db_files(pkg) != 0) {
		ret = 1;
	}

	if(!quiet && !ret) {
		eprintf("%s: all files match database\n", alpm_pkg_get_name(pkg));
	}

	return ret;
}

    std::optional<std::string> plugin_searcher::find_extension(const std::string& name) {
        LOG(DEBUG) << "Searching for Extension: " << name << "\n";
        for (auto folder : active_mod_folder_list) {
        #if _WIN64 || __X86_64__
            std::string test_path = folder + "\\intercept\\" + name + "_x64.dll";
        #else
        #ifdef __linux__
            std::string test_path = folder + "/intercept/" + name + ".so";
        #else
            std::string test_path = folder + "\\intercept\\" + name + ".dll";
        #endif
        #endif

            LOG(DEBUG) << "Mod: " << test_path << "\n";
            std::ifstream check_file(test_path);
            if (check_file.good()) {
                return test_path;
            }
        }
        LOG(ERROR) << "Client plugin: " << name << " was not found.\n";
        return std::optional<std::string>();
    }

void test_group<test_data>::object::test<3>() {
	set_test_name("Test append-release recycling");

	ensure_equals(file.get_block_count(), 1);

	file.release_block(0);

	ensure_equals(file.get_block_count(), 0);

	ensure_equals(file.append_block(create_test_block(0)), 0);
	ensure_equals(file.get_block_count(), 1);

	ensure_equals(file.append_block(create_test_block(100)), 1);
	ensure_equals(file.get_block_count(), 2);

	file.close();

	commons::io::recycling_block_file check_file("recycling_test_block_file", 512, free_block_initializer());
	ensure_equals(check_file.get_block_count(), 2);
	ensure_blocks_are_equals(check_file.read_block(0), create_test_block(0));
	ensure_blocks_are_equals(check_file.read_block(1), create_test_block(100));
}