Example #1
0
static int atalk_build_paths(TALLOC_CTX *ctx, const char *path,
			     const char *fname,
			     char **adbl_path, char **orig_path,
			     SMB_STRUCT_STAT *adbl_info,
			     SMB_STRUCT_STAT *orig_info,
			     bool fake_dir_create_times)
{
	int ptr0 = 0;
	int ptr1 = 0;
	char *dname = 0;
	char *name  = 0;

	if (!ctx || !path || !fname || !adbl_path || !orig_path ||
		!adbl_info || !orig_info)
		return -1;
#if 0
	DEBUG(3, ("ATALK: PATH: %s[%s]\n", path, fname));
#endif
	if (strstr(path, APPLEDOUBLE) || strstr(fname, APPLEDOUBLE)) {
		DEBUG(3, ("ATALK: path %s[%s] already contains %s\n", path, fname, APPLEDOUBLE));
		return -1;
	}

	if (fname[0] == '.') ptr0 ++;
	if (fname[1] == '/') ptr0 ++;

	*orig_path = talloc_asprintf(ctx, "%s/%s", path, &fname[ptr0]);

	/* get pointer to last '/' */
	ptr1 = atalk_get_path_ptr(*orig_path);

	sys_lstat(*orig_path, orig_info, fake_dir_create_times);

	if (S_ISDIR(orig_info->st_ex_mode)) {
		*adbl_path = talloc_asprintf(ctx, "%s/%s/%s/", 
		  path, &fname[ptr0], APPLEDOUBLE);
	} else {
		dname = talloc_strdup(ctx, *orig_path);
		dname[ptr1] = '\0';
		name = *orig_path;
		*adbl_path = talloc_asprintf(ctx, "%s/%s/%s", 
		  dname, APPLEDOUBLE, &name[ptr1 + 1]);
	}
#if 0
	DEBUG(3, ("ATALK: DEBUG:\n%s\n%s\n", *orig_path, *adbl_path)); 
#endif
	sys_lstat(*adbl_path, adbl_info, fake_dir_create_times);
	return 0;
}
Example #2
0
static FILE *
get_volfp (glusterfs_ctx_t *ctx)
{
    int          ret = 0;
    cmd_args_t  *cmd_args = NULL;
    FILE        *specfp = NULL;
    struct stat  statbuf;

    cmd_args = &ctx->cmd_args;

    ret = sys_lstat (cmd_args->volfile, &statbuf);
    if (ret == -1) {
        gf_log ("glusterfsd", GF_LOG_ERROR,
                "%s: %s", cmd_args->volfile, strerror (errno));
        return NULL;
    }

    if ((specfp = fopen (cmd_args->volfile, "r")) == NULL) {
        gf_log ("glusterfsd", GF_LOG_ERROR,
                "volume file %s: %s",
                cmd_args->volfile,
                strerror (errno));
        return NULL;
    }

    gf_log ("glusterfsd", GF_LOG_DEBUG,
            "loading volume file %s", cmd_args->volfile);

    return specfp;
}
Example #3
0
static char *
parse_and_validate_args (int argc, char *argv[])
{
        char        *basedir = NULL;
        struct stat  d = {0, };
        int          ret = -1;
#ifndef __FreeBSD__
        unsigned char volume_id[16];
#endif /* __FreeBSD__ */
        char        *slv_mnt = NULL;

        if (argc != 4) {
                err ("Usage: %s <DIR> <SLAVE-VOL-MOUNT> <CRAWL-THREAD-COUNT>\n",
                      argv[0]);
                return NULL;
        }

        basedir = argv[1];
        ret = sys_lstat (basedir, &d);
        if (ret) {
                err ("%s: %s\n", basedir, strerror (errno));
                return NULL;
        }

#ifndef __FreeBSD__
        ret = sys_lgetxattr (basedir, "trusted.glusterfs.volume-id",
                             volume_id, 16);
        if (ret != 16) {
                err ("%s:Not a valid brick path.\n", basedir);
                return NULL;
        }
#endif /* __FreeBSD__ */

        slv_mnt = argv[2];
        ret = sys_lstat (slv_mnt, &d);
        if (ret) {
                err ("%s: %s\n", slv_mnt, strerror (errno));
                return NULL;
        }
        slavemnt = argv[2];

        workers = atoi(argv[3]);
        if (workers <= 0)
                workers = DEFAULT_WORKERS;

        return basedir;
}
Example #4
0
static int
umountd_async (char *path, dev_t dev, int frmdir, int timeout)
{
        int                   ret        = -1;
        struct stat           stbuf      = {0, };
        int                       unmount_ret = 0;

        do {
                unmount_ret = unmount (path, 0);
                if (unmount_ret == 0)
                        gf_log ("umountd", GF_LOG_INFO, "Unmounted %s", path);

                if (unmount_ret != 0 && errno != EBUSY) {
                               gf_log ("umountd", GF_LOG_WARNING,
                                      "umount %s failed: %s",
                                path, strerror (errno));
                }

                ret = sys_lstat (path, &stbuf);
                if (ret != 0) {
                        gf_log ("umountd", GF_LOG_WARNING,
                                      "Cannot stat device from %s",
                                path, strerror (errno));
                        break;
                }

                if (stbuf.st_dev != dev) {
                        if (unmount_ret != 0)
                                gf_log ("umountd", GF_LOG_INFO,
                                        "device mismatch "
                                        "(expect %lld, found %lld), "
                                        "someone else unmounted %s",
                                        dev, stbuf.st_dev, path);
                        ret = 0;
                        break;
                }

                sleep (timeout);
        } while (1/*CONSTCOND*/);

        if (ret) {
                gf_log ("umountd", GF_LOG_ERROR,
                        "Asynchronous unmount of %s failed: %s",
                        path, strerror (errno));
        } else {
                if (frmdir) {
                        ret = rmdir (path);
                        if (ret)
                                gf_log ("umountd", GF_LOG_WARNING,
                                         "rmdir %s failed: %s",
                                         path, strerror (errno));
                        else
                                gf_log ("umountd", GF_LOG_INFO,
                                         "Removed %s", path);
                }
        }

        return ret;
}
Example #5
0
int vfswrap_lstat(vfs_handle_struct *handle, connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf)
{
	int result;

	START_PROFILE(syscall_lstat);
	result = sys_lstat(path, sbuf);
	END_PROFILE(syscall_lstat);
	return result;
}
enum fmaster_pre_execute_result
fmaster_lstat_pre_execute(struct thread *td, struct fmaster_lstat_args *uap,
			  int *error)
{

	if (fmaster_is_master_file(td, uap->path)) {
		*error = sys_lstat(td, (struct lstat_args *)uap);
		return (PRE_EXEC_END);
	}

	return (PRE_EXEC_CONT);
}
Example #7
0
/**********************
 ntalk_mkresdir: creates a new .AppleDouble directory (if necessary)
                 for the resource fork of a specified file
**********************/
int ntalk_mkresdir(const char *fname)
{
  char fdir[255];
  int i;
  int lastslash;
  SMB_STRUCT_STAT dirstats;
  char appledouble[] = APPLEDOUBLE;

  /* find directory containing fname */
  for (i = 0; (fname[i] != 0) && (i <= 254); i++) {
    fdir[i] = fname[i];
    if (fdir[i] == '/') {
      lastslash = i;
    }
  }
  lastslash++;
  fdir[lastslash] = 0;
  sys_lstat(fdir, &dirstats);

  /* append .AppleDouble */
  for (i = 0; (appledouble[i] != 0) && (lastslash <= 254); i++) {
    fdir[lastslash] = appledouble[i];
    lastslash++;
  }
  fdir[lastslash] = 0;

  /* create this directory */
  /* silently ignore EEXIST error */
  if ((mkdir(fdir, dirstats.st_mode) < 0) && (errno != EEXIST)) {
    return errno;
  }

  /* set ownership of this dir to the same as its parent */
  /* holy race condition, batman! */
  /* warning: this doesn't check for errors */
  chown(fdir, dirstats.st_uid, dirstats.st_gid);

  printf("%s\n", fdir);

  return 1;
}
Example #8
0
int dos_lstat(char *fname,SMB_STRUCT_STAT *sbuf)
{
  return(sys_lstat(dos_to_unix(fname,False),sbuf));
}
Example #9
0
static int copy_reg(char *source, const char *dest)
{
  SMB_STRUCT_STAT source_stats;
  int ifd;
  int ofd;
  char *buf;
  int len;                      /* Number of bytes read into `buf'. */

  sys_lstat (source, &source_stats);
  if (!S_ISREG (source_stats.st_mode))
    return 1;

  if (unlink (dest) && errno != ENOENT)
    return 1;

  if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
    return 1;

  if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0 )
  {
    close (ifd);
    return 1;
  }

  if((buf = malloc( COPYBUF_SIZE )) == NULL)
  {
    close (ifd);  
    close (ofd);  
    unlink (dest);
    return 1;
  }

  while ((len = read(ifd, buf, COPYBUF_SIZE)) > 0)
  {
    if (write_data(ofd, buf, len) < 0)
    {
      close (ifd);
      close (ofd);
      unlink (dest);
      free(buf);
      return 1;
    }
  }
  free(buf);
  if (len < 0)
  {
    close (ifd);
    close (ofd);
    unlink (dest);
    return 1;
  }

  if (close (ifd) < 0)
  {
    close (ofd);
    return 1;
  }
  if (close (ofd) < 0)
    return 1;

  /* chown turns off set[ug]id bits for non-root,
     so do the chmod last.  */

  /* Try to copy the old file's modtime and access time.  */
  {
    struct utimbuf tv;

    tv.actime = source_stats.st_atime;
    tv.modtime = source_stats.st_mtime;
    if (utime (dest, &tv))
      return 1;
  }

  /* Try to preserve ownership.  For non-root it might fail, but that's ok.
     But root probably wants to know, e.g. if NFS disallows it.  */
  if (chown (dest, source_stats.st_uid, source_stats.st_gid)
      && (errno != EPERM))
    return 1;

  if (chmod (dest, source_stats.st_mode & 07777))
    return 1;

  unlink (source);
  return 0;
}
Example #10
0
static int copy_reg(const char *source, const char *dest)
{
	SMB_STRUCT_STAT source_stats;
	int saved_errno;
	int ifd = -1;
	int ofd = -1;

	if (sys_lstat (source, &source_stats) == -1)
		return -1;

	if (!S_ISREG (source_stats.st_mode))
		return -1;

	if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
		return -1;

	if (unlink (dest) && errno != ENOENT)
		return -1;

#ifdef O_NOFOLLOW
	if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
#else
	if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
#endif
		goto err;

	if (transfer_file(ifd, ofd, (size_t)-1) == -1)
		goto err;

	/*
	 * Try to preserve ownership.  For non-root it might fail, but that's ok.
	 * But root probably wants to know, e.g. if NFS disallows it.
	 */

#ifdef HAVE_FCHOWN
	if ((fchown(ofd, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
#else
	if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
#endif
		goto err;

	/*
	 * fchown turns off set[ug]id bits for non-root,
	 * so do the chmod last.
	 */

#if defined(HAVE_FCHMOD)
	if (fchmod (ofd, source_stats.st_mode & 07777))
#else
	if (chmod (dest, source_stats.st_mode & 07777))
#endif
		goto err;

	if (close (ifd) == -1)
		goto err;

	if (close (ofd) == -1)
		return -1;

	/* Try to copy the old file's modtime and access time.  */
	{
		struct utimbuf tv;

		tv.actime = source_stats.st_atime;
		tv.modtime = source_stats.st_mtime;
		utime(dest, &tv);
	}

	if (unlink (source) == -1)
		return -1;

	return 0;

  err:

	saved_errno = errno;
	if (ifd != -1)
		close(ifd);
	if (ofd != -1)
		close(ofd);
	errno = saved_errno;
	return -1;
}
Example #11
0
int
main(int argc, char **argv)
{
    int ret = 0;
    struct stat st;
    char *dname = NULL;
    char *bname = NULL;
    ssize_t ret_size = 0;
    uuid_t pgfid_raw = {
        0,
    };
    char pgfid[36] = "";
    char xxh64[GF_XXH64_DIGEST_LENGTH * 2 + 1] = {
        0,
    };
    char pgfid_bname[1024] = {
        0,
    };
    char *key = NULL;
    char *val = NULL;
    size_t key_size = 0;
    size_t val_size = 0;
    const char *file_path = NULL;
    char *file_path1 = NULL;
    char *file_path2 = NULL;

    if (argc != 2) {
        fprintf(stderr, "Usage: setgfid2path <file-path>\n");
        return -1;
    }

    ret = sys_lstat(argv[1], &st);
    if (ret != 0) {
        fprintf(stderr, "Invalid File Path\n");
        return -1;
    }

    if (st.st_nlink >= MAX_GFID2PATH_LINK_SUP) {
        fprintf(stderr,
                "Number of Hardlink support exceeded. "
                "max=%d\n",
                MAX_GFID2PATH_LINK_SUP);
        return -1;
    }

    file_path = argv[1];
    file_path1 = strdup(file_path);
    file_path2 = strdup(file_path);

    dname = dirname(file_path1);
    bname = basename(file_path2);

    /* Get GFID of Parent directory */
    ret_size = sys_lgetxattr(dname, GFID_XATTR_KEY, pgfid_raw, GFID_SIZE);
    if (ret_size != GFID_SIZE) {
        fprintf(stderr, "Failed to get GFID of parent directory. dir=%s\n",
                dname);
        ret = -1;
        goto out;
    }

    /* Convert to UUID format */
    if (uuid_utoa_r(pgfid_raw, pgfid) == NULL) {
        fprintf(stderr,
                "Failed to format GFID of parent directory. "
                "dir=%s GFID=%s\n",
                dname, pgfid_raw);
        ret = -1;
        goto out;
    }

    /* Find xxhash for PGFID/BaseName */
    snprintf(pgfid_bname, sizeof(pgfid_bname), "%s/%s", pgfid, bname);
    gf_xxh64_wrapper((unsigned char *)pgfid_bname, strlen(pgfid_bname),
                     GF_XXHSUM64_DEFAULT_SEED, xxh64);

    key_size = SLEN(GFID2PATH_XATTR_KEY_PREFIX) + GF_XXH64_DIGEST_LENGTH * 2 +
               1;
    key = alloca(key_size);
    snprintf(key, key_size, GFID2PATH_XATTR_KEY_PREFIX "%s", xxh64);

    val_size = UUID_CANONICAL_FORM_LEN + NAME_MAX + 2;
    val = alloca(val_size);
    snprintf(val, val_size, "%s/%s", pgfid, bname);

    /* Set the Xattr, ignore if same key xattr already exists */
    ret = sys_lsetxattr(file_path, key, val, strlen(val), XATTR_CREATE);
    if (ret == -1) {
        if (errno == EEXIST) {
            printf("Xattr already exists, ignoring..\n");
            ret = 0;
            goto out;
        }

        fprintf(stderr, "Failed to set gfid2path xattr. errno=%d\n error=%s",
                errno, strerror(errno));
        ret = -1;
        goto out;
    }

    printf("Success. file=%s key=%s value=%s\n", file_path, key, val);

out:
    if (file_path1 != NULL)
        free(file_path1);

    if (file_path2 != NULL)
        free(file_path2);

    return ret;
}
Example #12
0
int wsys_lstat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf)
{
	pstring fname;
	return sys_lstat(unicode_to_unix(fname,wfname,sizeof(fname)), sbuf);
}
int lstat(const char *file, struct stat *st)
{
    return sys_lstat(file, st);
}
Example #14
0
int
parse_cmdline (int argc, char *argv[], glusterfs_ctx_t *ctx)
{
    int               process_mode = 0;
    int               ret = 0;
    struct stat       stbuf = {0, };
    struct tm        *tm = NULL;
    time_t            utime;
    char              timestr[256];
    char              tmp_logfile[1024] = { 0 };
    char              *tmp_logfile_dyn = NULL;
    char              *tmp_logfilebase = NULL;
    cmd_args_t        *cmd_args = NULL;

    cmd_args = &ctx->cmd_args;

    argp_parse (&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args);

    if (ENABLE_DEBUG_MODE == cmd_args->debug_mode) {
        cmd_args->log_level = GF_LOG_DEBUG;
        cmd_args->log_file = "/dev/stderr";
        cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
    }

    process_mode = gf_get_process_mode (argv[0]);

    if ((cmd_args->volfile_server == NULL)
            && (cmd_args->volfile == NULL)) {
        if (process_mode == GF_SERVER_PROCESS)
            cmd_args->volfile = gf_strdup (DEFAULT_SERVER_VOLFILE);
        else if (process_mode == GF_GLUSTERD_PROCESS)
            cmd_args->volfile = gf_strdup (DEFAULT_GLUSTERD_VOLFILE);
        else
            cmd_args->volfile = gf_strdup (DEFAULT_CLIENT_VOLFILE);
    }

    if (cmd_args->run_id) {
        ret = sys_lstat (cmd_args->log_file, &stbuf);
        /* If its /dev/null, or /dev/stdout, /dev/stderr,
         * let it use the same, no need to alter
         */
        if (((ret == 0) &&
                (S_ISREG (stbuf.st_mode) || S_ISLNK (stbuf.st_mode))) ||
                (ret == -1)) {
            /* Have seperate logfile per run */
            tm = localtime (&utime);
            strftime (timestr, 256, "%Y%m%d.%H%M%S", tm);
            sprintf (tmp_logfile, "%s.%s.%d",
                     cmd_args->log_file, timestr, getpid ());

            /* Create symlink to actual log file */
            sys_unlink (cmd_args->log_file);

            tmp_logfile_dyn = gf_strdup (tmp_logfile);
            tmp_logfilebase = basename (tmp_logfile_dyn);
            ret = sys_symlink (tmp_logfilebase,
                               cmd_args->log_file);
            if (ret == -1) {
                fprintf (stderr, "symlink of logfile failed");
            } else {
                GF_FREE (cmd_args->log_file);
                cmd_args->log_file = gf_strdup (tmp_logfile);
            }

            GF_FREE (tmp_logfile_dyn);
        }
    }

    return ret;
}
Example #15
0
static int copy_reg(const char *source, const char *dest)
{
	SMB_STRUCT_STAT source_stats;
	int saved_errno;
	int ifd = -1;
	int ofd = -1;

	if (sys_lstat(source, &source_stats, false) == -1)
		return -1;

	if (!S_ISREG (source_stats.st_ex_mode))
		return -1;

	if (source_stats.st_ex_size > module_sizelimit) {
		DEBUG(5,
			("%s: size of %s larger than sizelimit (%lld > %lld), rename prohititted\n",
			MODULE, source,
			(long long)source_stats.st_ex_size,
			(long long)module_sizelimit));
		return -1;
	}

	if((ifd = open (source, O_RDONLY, 0)) < 0)
		return -1;

	if (unlink (dest) && errno != ENOENT) {
		close(ifd);
		return -1;
	}

#ifdef O_NOFOLLOW
	if((ofd = open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
#else
	if((ofd = open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
#endif
		goto err;

	if (transfer_file(ifd, ofd, source_stats.st_ex_size) == -1)
		goto err;

	/*
	 * Try to preserve ownership.  For non-root it might fail, but that's ok.
	 * But root probably wants to know, e.g. if NFS disallows it.
	 */

#ifdef HAVE_FCHOWN
	if ((fchown(ofd, source_stats.st_ex_uid, source_stats.st_ex_gid) == -1) && (errno != EPERM))
#else
	if ((chown(dest, source_stats.st_ex_uid, source_stats.st_ex_gid) == -1) && (errno != EPERM))
#endif
		goto err;

	/*
	 * fchown turns off set[ug]id bits for non-root,
	 * so do the chmod last.
	 */

#if defined(HAVE_FCHMOD)
	if ((fchmod (ofd, source_stats.st_ex_mode & 07777) == -1) &&
			(errno != EPERM))
#else
	if ((chmod (dest, source_stats.st_ex_mode & 07777) == -1) &&
			(errno != EPERM))
#endif
		goto err;

	if (close (ifd) == -1)
		goto err;

	if (close (ofd) == -1)
		return -1;

	/* Try to copy the old file's modtime and access time.  */
#if defined(HAVE_UTIMENSAT)
	{
		struct timespec ts[2];

		ts[0] = source_stats.st_ex_atime;
		ts[1] = source_stats.st_ex_mtime;
		utimensat(AT_FDCWD, dest, ts, AT_SYMLINK_NOFOLLOW);
	}
#elif defined(HAVE_UTIMES)
	{
		struct timeval tv[2];

		tv[0] = convert_timespec_to_timeval(source_stats.st_ex_atime);
		tv[1] = convert_timespec_to_timeval(source_stats.st_ex_mtime);
#ifdef HAVE_LUTIMES
		lutimes(dest, tv);
#else
		utimes(dest, tv);
#endif
	}
#elif defined(HAVE_UTIME)
	{
		struct utimbuf tv;

		tv.actime = convert_timespec_to_time_t(source_stats.st_ex_atime);
		tv.modtime = convert_timespec_to_time_t(source_stats.st_ex_mtime);
		utime(dest, &tv);
	}
#endif

	if (unlink (source) == -1)
		return -1;

	return 0;

  err:

	saved_errno = errno;
	if (ifd != -1)
		close(ifd);
	if (ofd != -1)
		close(ofd);
	errno = saved_errno;
	return -1;
}
Example #16
0
int
xworker_do_crawl (struct xwork *xwork, struct dirjob *job)
{
        DIR            *dirp = NULL;
        int             ret = -1;
        int             boff;
        int             plen;
        struct dirent  *result;
        char            dbuf[512];
        char           *path = NULL;
        struct dirjob  *cjob = NULL;
        struct stat     statbuf = {0,};
        char            gfid_path[4096] = {0,};


        plen = strlen (job->dirname) + 256 + 2;
        path = alloca (plen);

        tdbg ("Entering: %s\n", job->dirname);

        dirp = sys_opendir (job->dirname);
        if (!dirp) {
                terr ("opendir failed on %s (%s)\n", job->dirname,
                     strerror (errno));
                goto out;
        }

        boff = sprintf (path, "%s/", job->dirname);

        for (;;) {
                ret = readdir_r (dirp, (struct dirent *)dbuf, &result);
                if (ret) {
                        err ("readdir_r(%s): %s\n", job->dirname,
                             strerror (errno));
                        goto out;
                }

                if (!result) /* EOF */
                        break;

                if (result->d_ino == 0)
                        continue;

                if (skip_name (job->dirname, result->d_name))
                        continue;

                /* It is sure that, children and grandchildren of .glusterfs
                 * are directories, just add them to global queue.
                 */
                if (skip_stat (job, result->d_name)) {
                        strncpy (path + boff, result->d_name, (plen-boff));
                        cjob = dirjob_new (path, job);
                        if (!cjob) {
                                err ("dirjob_new(%s): %s\n",
                                     path, strerror (errno));
                                ret = -1;
                                goto out;
                        }
                        xwork_addcrawl (xwork, cjob);
                        continue;
                }

                strcpy (gfid_path, slavemnt);
                strcat (gfid_path, "/.gfid/");
                strcat (gfid_path, result->d_name);
                ret = sys_lstat (gfid_path, &statbuf);

                if (ret && errno == ENOENT) {
                        out ("%s\n", result->d_name);
                        BUMP (skipped_gfids);
                }

                if (ret && errno != ENOENT) {
                        err ("stat on slave failed(%s): %s\n",
                             gfid_path, strerror (errno));
                        goto out;
                }
        }

        ret = 0;
out:
        if (dirp)
                sys_closedir (dirp);

        return ret;
}