Beispiel #1
0
int share_file_copy(char **args, int arg_cnt, int pflags)
{
  struct stat st;
  shfs_t *dest_fs;
  shfs_t **src_fs;
  shfs_ino_t *dest_file;
  shfs_ino_t **src_file;
  shbuf_t *buff;
  char fpath[PATH_MAX+1];
  unsigned char *data;
  size_t data_len;
  size_t of;
  int src_cnt;
  int w_len;
  int err;
  int i;

  if (arg_cnt < 1)
    return (SHERR_INVAL);

  src_file = NULL;
  src_fs = NULL;

  arg_cnt--;
  src_cnt = 0;
  if (!arg_cnt) {
    /* create faux substitute. */
/*DEBUG: */return (SHERR_INVAL);
  } else {
    dest_file = sharetool_file(args[arg_cnt], &dest_fs);

    src_file = (shfs_ino_t **)calloc(arg_cnt + 1, sizeof(shfs_ino_t *));
    src_fs = (shfs_t **)calloc(arg_cnt + 1, sizeof(shfs_t *));

    for (i = 1; i < arg_cnt; i++) {
      src_file[src_cnt] = sharetool_file(args[i], &src_fs[src_cnt]);
      err = shfs_fstat(src_file[src_cnt], &st);
      src_cnt++;
      if (err)
        goto done;
    }
  }

  for (i = 0; i < src_cnt; i++) {
    shfs_t *s_fs = src_fs[i];
    err = shfs_file_copy(src_file[i], dest_file);
    shfs_free(&s_fs);
    if (err)
      goto done;
  }

  err = 0;
done:
  if (src_file) free(src_file);
  if (src_fs) free(src_fs);

  return (err);
}
Beispiel #2
0
static int _shfs_lock_verify(shfs_ino_t *inode, int flags)
{
  shstat st;
  int err;

  err = shfs_fstat(inode, &st);
  if (err)
    return (err);

  return (_shfs_lock_verify_hier(inode));
}
Beispiel #3
0
int share_file_cat(char *path, int pflags)
{
  shstat st;
  shfs_t *tree;
  shfs_ino_t *file;
  shbuf_t *buff;
  char fpath[PATH_MAX+1];
  unsigned char *data;
  size_t data_len;
  size_t of;
  int w_len;
  int err;

  tree = shfs_uri_init(path, 0, &file);
  if (!tree)
    return (SHERR_NOENT);

  err = shfs_fstat(file, &st);
  if (err) {
    shfs_free(&tree);
    return (err);
  }

  buff = shbuf_init();
  err = shfs_read(file, buff);
  if (err) {
    shbuf_free(&buff);
    shfs_free(&tree);
    return (err);
  }

  of = 0;
  while (of < shbuf_size(buff)) {
    data_len = MIN((shbuf_size(buff) - of), 65536);
    data = shbuf_data(buff) + of;
    w_len = fwrite(data, sizeof(char), data_len, sharetool_fout);
    if (w_len < 0) {
      shbuf_free(&buff);
      shfs_free(&tree);
      return (-errno);
    }

    of += w_len;
  }

  shbuf_free(&buff);
  shfs_free(&tree);

  return (0);
}
Beispiel #4
0
int shfs_unlock(shfs_ino_t *inode)
{
  shstat st;
  int err;

  err = shfs_fstat(inode, &st);
  if (err)
    return (err);

  if (shfs_type(inode) == SHINODE_FILE_LOCK)
    return (SHERR_OPNOTSUPP);

  return (shfs_attr_unset(inode, SHATTR_FLOCK));
}
Beispiel #5
0
int shfs_lock_of(shfs_ino_t *inode, int flags, size_t of, size_t len)
{
  shstat st;
  int err;

  err = shfs_fstat(inode, &st);
  if (err)
    return (err);

  if (shfs_type(inode) == SHINODE_FILE_LOCK)
    return (SHERR_OPNOTSUPP);

  return (shfs_attr_set(inode, SHATTR_FLOCK));
}
Beispiel #6
0
int shfs_rev_delta(shfs_ino_t *file, shbuf_t *diff_buff)
{
  shstat st;
  shbuf_t *work_buff;
  shbuf_t *head_buff;
  shbuf_t *ref_buff;
  shfs_t *fs;
  shkey_t *key;
  int err;

  if (shfs_type(file) != SHINODE_FILE)
    return (SHERR_INVAL);

  err = shfs_fstat(file, &st);
  if (err)
    return (err);

  work_buff = shbuf_init();
  err = shfs_read(file, work_buff);
  if (err) {
    shbuf_free(&work_buff);
    return (err);
  }

  /* obtain BASE branch snapshot */
  head_buff = shbuf_init();
  err = shfs_rev_ref_read(file, "tag", "BASE", head_buff);
  if (err)
    goto done;

  if (shbuf_size(work_buff) == shbuf_size(head_buff) &&
      0 == memcmp(shbuf_data(work_buff), shbuf_data(head_buff), shbuf_size(work_buff))) {
    /* no difference */
    err = SHERR_AGAIN;
    goto done;
  }

  err = shdelta(work_buff, head_buff, diff_buff); 

done:
  shbuf_free(&work_buff);
  shbuf_free(&head_buff);
  shbuf_free(&work_buff);

  return (err);
}
Beispiel #7
0
int shfs_rev_commit(shfs_ino_t *file, shfs_ino_t **rev_p)
{
  shstat st;
  shbuf_t *diff_buff;
  shbuf_t *work_buff;
  shbuf_t *head_buff;
  shfs_ino_t *base;
  shfs_ino_t *repo; /* SHINODE_REPOSITORY */
  shfs_ino_t *new_rev; /* SHINODE_REVISION */
  shfs_ino_t *delta; /* SHINODE_DELTA */
  shkey_t *rev_key;
  shfs_t *fs;
  int err;

  if (rev_p)
    *rev_p = NULL;

  head_buff = work_buff = diff_buff = NULL;

  err = shfs_fstat(file, &st);
  if (err)
    return (err);

  work_buff = shbuf_init();
  err = shfs_read(file, work_buff); 
  if (err)
    goto done;

  base = shfs_rev_base(file);
  if (base) {
    /* obtain delta of current file data content against BASE revision's data content. */
    head_buff = shbuf_init();
    err = shfs_rev_ref_read(file, "tag", "BASE", head_buff);
    if (err)
      goto done;

    if (shbuf_size(work_buff) == shbuf_size(head_buff) &&
        0 == memcmp(shbuf_data(work_buff), shbuf_data(head_buff), shbuf_size(work_buff))) {
      /* no difference */
      err = SHERR_AGAIN;
      goto done;
    }

    diff_buff = shbuf_init();
    err = shdelta(work_buff, head_buff, diff_buff); 
    shbuf_free(&head_buff);
    if (err)
      return (err);

    rev_key = shfs_token(base);
  } else {
    /* initial revision */
    rev_key = ashkey_uniq();
  }

  repo = shfs_inode(file, NULL, SHINODE_REPOSITORY);
  if (!repo) {
    err = SHERR_IO;
    goto done;
  }

  /* create a new revision using previous revision's inode name */
  new_rev = shfs_inode(repo, (char *)shkey_hex(rev_key), SHINODE_REVISION); 
  if (!new_rev) {
    err = SHERR_IO;
    goto done;
  }

  /* define revision's meta information. */
  shfs_meta_set(new_rev, 
      SHMETA_USER_NAME, (char *)get_libshare_account_name());

  /* save delta to new revision */
  err = shfs_rev_delta_write(new_rev, diff_buff);
  shbuf_free(&diff_buff);
  if (err)
    goto done;


  /* save new revision as BASE branch head */
  err = shfs_rev_base_set(file, new_rev);
  if (err)
    goto done;

  /* save work-data to BASE tag. */
  err = shfs_rev_ref_write(file, "tag", "BASE", work_buff); 
  shbuf_free(&work_buff);
  if (err)
    goto done;

  if (base) {
    /* tag previous revision's key token onto revision inode. */
    shfs_rev_tag(new_rev, "PREV", base);
  }

  if (rev_p)
    *rev_p = new_rev;

done:
  shbuf_free(&work_buff);
  shbuf_free(&diff_buff);
  shbuf_free(&head_buff);

  return (err);
}
Beispiel #8
0
int shfs_file_copy(shfs_ino_t *src_file, shfs_ino_t *dest_file)
{
  shfs_t *ref_fs;
  shfs_ino_t *ref;
  shstat st;
  shbuf_t *buff;
  int err;

  if (!src_file || !dest_file)
    return (SHERR_INVAL);

  /* ensure there is something to copy */
  err = shfs_fstat(src_file, &st);
  if (err) {
fprintf(stderr, "DEBUG: shfs_file_copy: %d = shfs_fstat(src_file)\n", err);
    return (err);
  }

  if (shfs_type(dest_file) == SHINODE_DIRECTORY) {

#if 0
    /* extract tar archive */
    if (shfs_format(dest_file) == SHINODE_BINARY &&
        0 == strcmp(shfs_meta_get(dest_file, "content.mime"), 
          "application/x-tar")) {
      buff = shbuf_init();
      err = shfs_read(src_file, buff);
      if (err) {
        shbuf_free(&buff);
        return (err);
      }
      err = shfs_unarch(buff, dest_file);
      shbuf_free(&buff);
      return (0);
    }
#endif

    if (!(shfs_attr(src_file) & SHATTR_ARCH)) {
      if (IS_INODE_CONTAINER(shfs_type(src_file))) {
        dest_file = shfs_inode(dest_file, 
            shfs_filename(src_file), shfs_type(src_file));
      } else {
        dest_file = shfs_inode(dest_file, NULL, shfs_type(src_file));
      }
    }

  }

  ref =  NULL;
  ref_fs = NULL;
  if (shfs_format(dest_file) == SHINODE_REFERENCE) {
    /* apply operation to end-point inode. */
    err = shfs_ref_get(dest_file, &ref_fs, &ref);
    if (err) {
fprintf(stderr, "DEBUG: shfs_file_copy: %d = shfs_ref_get(dest_file)\n", err); 
      return (err);
}

    dest_file = ref;
  }

  if (shfs_format(dest_file) != SHINODE_EXTERNAL) { 
    /* direct copy data content without conversion when applicable. */
    switch (shfs_format(src_file)) {
#if 0
      case SHINODE_COMPRESS:
        err = shfs_zlib_copy(src_file, dest_file);
        if (err)
          return (err);
        return (0);
#endif
    }
  }

  /* default case */
  buff = shbuf_init();
  err = shfs_read(src_file, buff);
  if (err) {
fprintf(stderr, "DEBUG: shfs_file_copy: %d = shfs_read()\n", err); 
    goto done;
}

  err = shfs_write(dest_file, buff);
  shbuf_free(&buff);
  if (err) {
fprintf(stderr, "DEBUG: shfs_file_copy: %d = shfs_write()\n", err);
    goto done;
}

  /* success */
  err = 0;

done:
  shbuf_free(&buff);
  if (ref_fs)
    shfs_free(&ref_fs);
  return (err);
}