C++ dir_exists函数代码示例

/// 需要移动到公共目录下，递归创建目录
static int RecurseCreateDirectory(const char *dir)
{	
	if( dir[0] == 0 )
		return DDCE_ARGUMENT_ERROR;

	DDC_BOOL_RETURN( dir_exists(dir),DDCE_SUCCESS );		

	char dirFather[MAX_PATH*2];
	strncpy(dirFather,dir,MAX_PATH*2);
	char *p = strrchr(dirFather,DDC_C_SLASH);
	if( p )
		*p = 0;

	while( !dir_exists(dirFather) )
	{		
		int ret = RecurseCreateDirectory(dirFather);
		if( ret != 0 )
			return ret;
	}

	//目录结尾不带"\\"
	if( dir[strlen(dir)-1] != DDC_C_SLASH )	
		return CreateDirectory(dir,NULL)==TRUE?0:DDCE_DISK_OP_ERROR;

	return 0;
}

//
// store a room in the persistent database
void worldStorePersistentRoom(WORLD_DATA *world, const char *key,
			      ROOM_DATA *room) {
  static char fname[MAX_BUFFER];
  static char  dir1[SMALL_BUFFER];
  static char  dir2[SMALL_BUFFER];
  if(!*key)
    return;

  unsigned long hash1 = pearson_hash8_1(key) % WORLD_BINS;
  unsigned long hash2 = pearson_hash8_2(key) % WORLD_BINS;
  *fname = '\0';
  *dir1  = '\0';
  *dir2  = '\0';

  // make sure our hash bins exist
  sprintf(dir1, "%s/persistent/%lu", 
	  worldGetPath(world), hash1);
  if(!dir_exists(dir1))
    mkdir(dir1, S_IRWXU | S_IRWXG);

  // and the second one as well
  sprintf(dir2, "%s/persistent/%lu/%lu", 
	  worldGetPath(world), hash1, hash2);
  if(!dir_exists(dir2))
    mkdir(dir2, S_IRWXU | S_IRWXG);

  // now, store the room
  sprintf(fname, "%s/persistent/%lu/%lu/%s", 
	  worldGetPath(world), hash1, hash2, key);
  STORAGE_SET *set = roomStore(room);
  storage_write(set, fname);
  storage_close(set);

  // log_string("stored persistent room :: %s", fname);
}

static int rmkdir(char* path) {
    /*
     * strip off trailing components unless we can stat the directory, or we
     * have run out of components
     */

    char* i = strrchr(path, '/');

    if (path[0] == '\0' || dir_exists(path))
        return 0;

    if (i != NULL) {
        *i = '\0';
        rmkdir(path);
        *i = '/';
        mkdir(path, 0777);
    }

#ifdef WIN32
    return 0;
#else
    if (dir_exists(path))
        return 0;
    else
        return -1;
#endif
}

static bool cgm_mount_cgroup(void *hdata, const char *root, int type)
{
    if (dir_exists(CGMANAGER_LOWER_SOCK))
        return cgm_bind_dir(root, CGMANAGER_LOWER_SOCK);
    if (dir_exists(CGMANAGER_UPPER_SOCK))
        return cgm_bind_dir(root, CGMANAGER_UPPER_SOCK);
    // Host doesn't have cgmanager running?  Then how did we get here?
    return false;
}

bool
Setup::createDirIfNeeded(const char *path, int mode)
{
	if (!dir_exists(path))
	{
		if (makedirs(path, mode) != 0 || !dir_exists(path))
		{
			fprintf(stderr, "failed to create missing directory: %s\n", path);
			return false;
		}
	}
	return true;
}

static int initialize_catalog(void)
{

    if (!initialized)
    {
        bool default_dir = true;

        /* directory config is of the format: "dir: /path/to/dir" */
        if (global_settings.playlist_catalog_dir[0] &&
            strcmp(global_settings.playlist_catalog_dir,
                   PLAYLIST_CATALOG_DEFAULT_DIR))
        {
            strcpy(playlist_dir, global_settings.playlist_catalog_dir);
            default_dir = false;
        }

        /* fall back to default directory if no or invalid config */
        if (default_dir)
        {
            strcpy(playlist_dir, PLAYLIST_CATALOG_DEFAULT_DIR);
            if (!dir_exists(playlist_dir))
                mkdir(playlist_dir);
        }

        playlist_dir_length = strlen(playlist_dir);

        if (dir_exists(playlist_dir))
        {
            playlist_dir_exists = true;
            memset(most_recent_playlist, 0, sizeof(most_recent_playlist));
            initialized = true;
        }
    }

    if (!playlist_dir_exists)
    {
        if (mkdir(playlist_dir) < 0) {
            splashf(HZ*2, ID2P(LANG_CATALOG_NO_DIRECTORY), playlist_dir);
            return -1;
        }
        else {
            playlist_dir_exists = true;
            memset(most_recent_playlist, 0, sizeof(most_recent_playlist));
            initialized = true;
        }
    }

    return 0;
}

CacheSession::CacheSession(ClientSession *session, const char *url, uint32_t file_ttl,
						   uint32_t dir_ttl)
	: FilterSession(session)
{
	m_dir_ttl = file_ttl;
	m_dir_ttl = dir_ttl;
	string tmp(url);
	make_hash64("md5", tmp, m_url_hash, true);
	tmp = url + string(":meta:") + get_client_id();
	make_hash64("md5", tmp, m_meta_key, true);
	tmp = url + string(":data:") + get_client_id();
	make_hash64("md5", tmp, m_data_key, true);
	m_base_dir = cacheBaseDir() + SEPSTR + m_url_hash;
	if (!dir_exists(m_base_dir.c_str()) && makedirs(m_base_dir.c_str()) < 0)
	{
		m_enable = false;
		_DEBUG("Disabling Cache Session: can't create");
	}
#if 0
	else if (!can_write_dir(m_base_dir.c_str()))
	{
		m_enable = false;
		_DEBUG("Disabling Cache Session: can't write");
	}
#endif
	else
	{
		m_enable = true;
		_DEBUG("Enabling Cache Session");
	}
}

static bool cgm_bind_dir(const char *root, const char *dirname)
{
    nih_local char *cgpath = NULL;

    /* /sys should have been mounted by now */
    cgpath = NIH_MUST( nih_strdup(NULL, root) );
    NIH_MUST( nih_strcat(&cgpath, NULL, "/sys/fs/cgroup") );

    if (!dir_exists(cgpath)) {
        ERROR("%s does not exist", cgpath);
        return false;
    }

    /* mount a tmpfs there so we can create subdirs */
    if (mount("cgroup", cgpath, "tmpfs", 0, "size=10000,mode=755")) {
        SYSERROR("Failed to mount tmpfs at %s", cgpath);
        return false;
    }
    NIH_MUST( nih_strcat(&cgpath, NULL, "/cgmanager") );

    if (mkdir(cgpath, 0755) < 0) {
        SYSERROR("Failed to create %s", cgpath);
        return false;
    }

    if (mount(dirname, cgpath, "none", MS_BIND, 0)) {
        SYSERROR("Failed to bind mount %s to %s", dirname, cgpath);
        return false;
    }

    return true;
}

/*
 * We may decide to make the socket path customizable.  For now
 * just assume it is in /sys/fs/cgroup/ which has some special
 * consequences
 */
static bool setup_cgroup_dir(void)
{
	int ret;
	if (!dir_exists(CGDIR)) {
		nih_debug(CGDIR " does not exist");
		return false;
	}
	if (daemon_running()) {
		nih_error("%s: cgmanager is already running", __func__);
		return false;
	}
	if (file_exists(CGMANAGER_SOCK)) {
		if (unlink(CGMANAGER_SOCK) < 0) {
			nih_error("%s: failed to delete stale cgmanager socket", __func__);
			return false;
		}
	}
	/* Check that /sys/fs/cgroup is writeable, else mount a tmpfs */
	unlink(CGPROBE);
	ret = creat(CGPROBE, O_RDWR);
	if (ret >= 0) {
		close(ret);
		unlink(CGPROBE);
		return mkdir_cgmanager_dir();
	}
	ret = mount("cgroup", CGDIR, "tmpfs", 0, "size=10000");
	if (ret) {
		nih_debug("Failed to mount tmpfs on %s: %s",
			CGDIR, strerror(errno));
		return false;
	}
	nih_debug("Mounted tmpfs onto %s", CGDIR);
	return mkdir_cgmanager_dir();
}

void spray(int s, const struct sockaddr *cli, int cli_len,
	   const char *file_path, __u16 padding, unsigned int fr)
{
	char *filename = basename(file_path);
	char *encoded_file_path;
	int size;
	int num_blocks;

        size = asprintf(&encoded_file_path, "%s/%s", ENCODED_DIR, filename);
        if (size == -1) {
                fprintf(stderr,
                        "asprintf: cannot allocate encoded file path\n");
                return;
        }

	/* Check if a directory for that name exists. */
	if (!dir_exists(encoded_file_path)) {
		fprintf(stderr,
			"invalid request; %s encoding does not exist\n",
			filename);
		return;
	}

	num_blocks = get_num_blocks(filename);
	if (num_blocks == -1) {
		fprintf(stderr,
			"get_num_blocks: cannot find number of blocks\n");
		return;
	}

	send_data_files(s, cli, cli_len, filename, num_blocks, padding, fr);
	send_code_files(s, cli, cli_len, filename, num_blocks, padding, fr);
}

static int recursive_remove(const char * const path) {
  if (NULL == path) { return 0; }

  int e = 0;

  if (dir_exists(path)) {
    FTSENT * ent;
    const char * const ptrs[] = { path, 0 };
    const int fts_options = FTS_NOCHDIR | FTS_PHYSICAL | FTS_XDEV;
    FTS * fts = fts_open((char * const *)ptrs, fts_options, NULL);

    while((ent = fts_read(fts)) && 0 == e) {
      switch(ent->fts_info) {
      case FTS_NS: case FTS_DNR: case FTS_ERR:
        fprintf(stderr, "%s: fts_read error: %s\n",
            ent->fts_accpath, strerror(ent->fts_errno));
        e = ent->fts_errno;
        break;
      case FTS_D: case FTS_DC: case FTS_DOT: case FTS_NSOK:
        break;
      case FTS_DP: case FTS_F: case FTS_SL: case FTS_SLNONE: case FTS_DEFAULT:
        if (0 != remove(ent->fts_accpath)) {
          fprintf(stderr, "Unable to remove %s. %s\n",
              ent->fts_accpath,
              strerror(ent->fts_errno));
          e = ent->fts_errno;
        }
        break;
      }
    }
    fts_close(fts);
  }

  return e;
}

/*-------------------------------------------------------------------------*/
int make_dir(char *path) {
  int i;
  char tmp_path1[MAXPATH],
       tmp_path2[MAXPATH],
       length,
       mkdir_error;


  if (path[0] == '\0') {
    return -1;
  }

  strmcpy(tmp_path1, path, sizeof(tmp_path1));
  cat_separator(tmp_path1);
  length = strlen(tmp_path1);
  strncpy(tmp_path2, tmp_path1, 3);
  i = 3;
  while (i < length) {
    if (tmp_path1[i] == '\\') {
      tmp_path2[i] = '\0';
      if (!dir_exists(tmp_path2)) {
        mkdir_error = mkdir(tmp_path2);
        if (mkdir_error) {
          path[i] = '\0';
          return mkdir_error;
        }
      }
    }
    tmp_path2[i] = tmp_path1[i];

    i++;
  }

  return 0;
}

int dispatch(const avector * vec, const long const * lows, const long const * highs, const int num_ranges,
	     const double d, const long lo, const long hi, const char * destdir, const char * fprefix)
{
  // group file names: destdir/fprefix_g<rid>_d_lo_hi
#define BASENAME_LEN 40
  char vecgroupname[FILENAME_MAX];
  char * psuffix, *pslash;
  int rid, rcounter = 0;
  bool last_range = FALSE;

  assert( vec!=NULL );
  assert( destdir!=NULL );

  if ( ! dir_exists(destdir) ) {
    fprintf(stderr, "ERROR: directory does not exist: %s\n", destdir);
    return 0;
  }
  if ( vec->size<=0 )
    return 0;

  /* prepare for the group names: */
  strncpy(vecgroupname, destdir, FILENAME_MAX);
  vecgroupname[FILENAME_MAX-1] = 0;
  psuffix = vecgroupname + strlen(vecgroupname);
  assert( psuffix>vecgroupname );
  assert( psuffix-vecgroupname < FILENAME_MAX-BASENAME_LEN ); // save space for actual names.
  pslash = strrchr(vecgroupname, '/');
  if ( pslash==NULL || pslash+1!=psuffix )
    *psuffix++ = '/';
  *psuffix = 0;

  for ( rid=0; rid<num_ranges; rid++ ) {
    if ( vec->size < lows[rid] )
      break;
    else if ( vec->size <= highs[rid] || highs[rid]<0 ) {
      // save the vector into this range:
      FILE * vgfile = NULL;
      snprintf(psuffix, BASENAME_LEN, "%s_g%d_%.8g_%ld_%ld", fprefix, rid+1, d, lo, hi);
      vgfile = fopen(vecgroupname, "a"); // NOTE: old group files are kept.
      if ( vgfile == NULL ) {
	fprintf(stderr, "Can't append to vector group file '%s'\n", vecgroupname);
	continue;
      }

      outputavector(vgfile, vec, 0);

      fclose(vgfile);
      rcounter++;
      if ( highs[rid]<0 ) {
	if ( last_range )
	  fprintf(stderr, "WARN: more than one -1 in the ranges; current rid = %d\n", rid+1);
	last_range = TRUE;
      }
    } else
      continue;
  }

  return rcounter;
}

int run_uninstall_autoloader()
{
		#ifdef ENABLE_LOG
		if (verbose) WriteToLog("[UNINSTALLER]");
		#endif
		//Check if installed
		if(file_exists("/dev_flash/sys/internal/sys_init_osd_orig.self") != SUCCESS)
		{
			#ifdef ENABLE_LOG
			if (verbose) WriteToLog("Error: sys_init_osd_orig.self not found\r\n");
			#endif
			return FAILED;
		}
		//Enable dev_blind
		if(dir_exists("/dev_blind") != SUCCESS)
		{
			{lv2syscall8(SC_FS_MOUNT, (u64)(char*)"CELL_FS_IOS:BUILTIN_FLSH1", (u64)(char*)"CELL_FS_FAT", (u64)(char*)"/dev_blind", 0, 0, 0, 0, 0); }
		}
		//Restore original sys_init_osd.self
		if(file_exists(PATH_SYS_INI_OSD_ORIG) == SUCCESS)
		{
			if(file_exists(PATH_SYS_INI_OSD) == SUCCESS)
			{
				unlink_secure(PATH_SYS_INI_OSD);
				sysLv2FsRename(PATH_SYS_INI_OSD_ORIG, PATH_SYS_INI_OSD);
				//Remove payload
				char filename[128];
				int fw_list[32] = { 0x355C,0x421C,0x430C,0x431C,0x440C,0x441C,0x446C,0x450C,0x453C,0x455C,0x460C,0x465C,0x466C,0x470C,0x475C,0x476C,
									0x355D,0x421D,0x430D,              0x441D,0x446D,0x450D,0x453D,0x455D,0x460D,0x465D,0x466D,0x470D,0x475D,0x476D};
				int i;
				for (i = 0; i < 32; i++)
				{
					if (fw_list[i] == 0) break;
					sprintf (filename, "/dev_blind/sys/internal/mpl_payload_%X.bin", fw_list[i]);
					if (file_exists(filename) == SUCCESS) unlink_secure(filename);
					sprintf (filename, "/dev_blind/sys/internal/mamba_%X.bin", fw_list[i]);
					if (file_exists(filename) == SUCCESS) unlink_secure(filename);
				}
				#ifdef ENABLE_LOG
				if (verbose) WriteToLog("Success: MAMBA/PRX Autoloader uninstalled\r\n");
				#endif
				return SUCCESS;
			}
			else
			{
				#ifdef ENABLE_LOG
				if (verbose) WriteToLog("Error: sys_init_osd.self not found\r\n");
				#endif
				return FAILED;
			}
		}
		else
		{
			#ifdef ENABLE_LOG
			if (verbose) WriteToLog("Error: /dev_blind not mounted\r\n");
			#endif
			return FAILED;
		}
}

bool DirectoryIterator::IsDirectory()
{
	char dtmp[_MAX_PATH];
	GetFullPath(dtmp);
	//this is needed on windows!!!
	FixPath(dtmp, false);
	return dir_exists(dtmp);
}