int ty_stat(const char *path, ty_file_info *info, bool follow)
{
    assert(path && path[0]);
    assert(info);

    return do_stat(AT_FDCWD, path, info, follow);
}

static int sys_stat(stat_args_t *arg)
{
        stat_args_t kern_args;
        struct stat buf;
        char *path;
        int ret;

        if (copy_from_user(&kern_args, arg, sizeof(kern_args)) < 0) {
                curthr->kt_errno = EFAULT;
                return -1;
        }

        if ((path = user_strdup(&kern_args.path)) == NULL) {
                curthr->kt_errno = EINVAL;
                return -1;
        }

        ret = do_stat(path, &buf);

        if (ret == 0) {
                ret = copy_to_user(kern_args.buf, &buf, sizeof(struct stat));
        }

        if (ret != 0) {
                kfree(path);
                curthr->kt_errno = -ret;
                return -1;
        }

        kfree(path);
        return 0;
}

int link_stat(const char *path, STRUCT_STAT *buffer, int follow_dirlinks)
{
#ifdef SUPPORT_LINKS
	if (copy_links)
		return do_stat(path, buffer);
	if (do_lstat(path, buffer) < 0)
		return -1;
	if (follow_dirlinks && S_ISLNK(buffer->st_mode)) {
		STRUCT_STAT st;
		if (do_stat(path, &st) == 0 && S_ISDIR(st.st_mode))
			*buffer = st;
	}
	return 0;
#else
	return do_stat(path, buffer);
#endif
}

int uffs_fstat(int fd, struct uffs_stat *buf)
{
    uffs_Object *obj = FD2OBJ(fd);

    CHK_OBJ(obj, -1);

    return do_stat(obj, buf);
}

//: File size in bytes. Only if is_file() == true
off_t  FileInfo::size() const
{
  struct stat s;
  if (do_stat(filename_.c_str(), &s))
    return s.st_size;
  else
    return 0;
}

//: Time of last status change. (creation, chmod, ...)
time_t FileInfo::created() const
{
  struct stat s;
  if (do_stat(filename_.c_str(), &s))
    return s.st_ctime;
  else
    return 0;
}

//: Time of last access
time_t FileInfo::accessed() const
{
  struct stat s;
  if (do_stat(filename_.c_str(), &s))
    return s.st_atime;
  else
    return 0;
}

//: Time of last data modification. See 'man stat(2)'
time_t FileInfo::modified() const
{
  struct stat s;
  if (do_stat(filename_.c_str(), &s))
    return s.st_mtime;
  else
    return 0;
}

//: Returns TRUE if we are pointing to a directory or a symbolic link to
//: a directory.
bool FileInfo::is_dir()      const
{
  struct stat s;
  if (do_stat(filename_.c_str(), &s))
    return S_ISDIR(s.st_mode);
  else
    return false;
}

  //: Returns TRUE if we are pointing to a file or a symbolic link to
  //: a file.
  bool FileInfo::is_file() const
  {
    struct stat s;
    if (do_stat(filename_, &s)) {
      return S_ISREG(s.st_mode);
    }

    return false;
  }

  //: File size in bytes. Only if is_file() == true
  off_t FileInfo::size() const
  {
    struct stat s;
    if (do_stat(filename_, &s)) {
      return s.st_size;
    }

    return 0;
  }

  //: Time of last status change. (creation, chmod, ...)
  time_t FileInfo::created() const
  {
    struct stat s;
    if (do_stat(filename_, &s)) {
      return s.st_ctime;
    }

    return 0;
  }

  //: Time of last data modification. See 'man stat(2)'
  time_t FileInfo::modified() const
  {
    struct stat s;
    if (do_stat(filename_, &s)) {
      return s.st_mtime;
    }

    return 0;
  }

CAMLprim value unix_lstat_64(value path)
{
  struct _stat64 buf;
  __int64 st_ino;
  if (!do_stat(1, 1, String_val(path), caml_string_length(path), NULL, &st_ino, &buf)) {
    uerror("lstat", path);
  }
  return stat_aux(1, st_ino, &buf);
}

int main(int argc, char *argv[])
{
	int i;

	for (i = 1; i < argc; i++)
		do_stat(argv[i]);

	return 0;
}

  //: Time of last access
  time_t FileInfo::accessed() const
  {
    struct stat s;
    if (do_stat(filename_, &s)) {
      return s.st_atime;
    }

    return 0;
  }

void file_sync_service(int fd, void *cookie)
{
    syncmsg msg;
    char name[1025];
    unsigned namelen;

    char *buffer = malloc(SYNC_DATA_MAX);
    if(buffer == 0) goto fail;

    for(;;) {
        D("sync: waiting for command\n");

        if(readx(fd, &msg.req, sizeof(msg.req))) {
            fail_message(fd, "command read failure");
            break;
        }
        namelen = ltohl(msg.req.namelen);
        if(namelen > 1024) {
            fail_message(fd, "invalid namelen");
            break;
        }
        if(readx(fd, name, namelen)) {
            fail_message(fd, "filename read failure");
            break;
        }
        name[namelen] = 0;

        msg.req.namelen = 0;
        D("sync: '%s' '%s'\n", (char*) &msg.req, name);

        switch(msg.req.id) {
        case ID_STAT:
            if(do_stat(fd, name)) goto fail;
            break;
        case ID_LIST:
            if(do_list(fd, name)) goto fail;
            break;
        case ID_SEND:
            if(do_send(fd, name, buffer)) goto fail;
            break;
        case ID_RECV:
            if(do_recv(fd, name, buffer)) goto fail;
            break;
        case ID_QUIT:
            goto fail;
        default:
            fail_message(fd, "unknown command");
            goto fail;
        }
    }

fail:
    if(buffer != 0) free(buffer);
    D("sync: done\n");
    adb_close(fd);
}

CAMLprim value unix_fstat_64(value handle)
{
  int ret;
  struct _stat64 buf;
  __int64 st_ino;
  if (!do_stat(0, 1, NULL, 0, Handle_val(handle), &st_ino, &buf)) {
    uerror("fstat", Nothing);
  }
  return stat_aux(1, st_ino, &buf);
}

int sys_fstat(int fp, struct stat *sb)
{
	if(!sb)
		return -EINVAL;
	struct file *f = get_file_pointer((task_t *)current_task, fp);
	if(!f) return -EBADF;
	do_stat(f->inode, sb);
	fput((task_t *)current_task, fp, 0);
	return 0;
}

int _ty_statat(int fd, const char *path, ty_file_info *info, bool follow)
{
    assert(path && path[0]);
    assert(info);

    if (fd < 0)
        fd = AT_FDCWD;

    return do_stat(fd, path, info, follow);
}