extattr_bsd.c   [plain text]

#include "extattr_os.h"

#ifdef EXTATTR_BSD

#include <errno.h>

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include "flags.h"

static int
valid_namespace (struct hv *flags, int *pattrnamespace)
{
  const size_t NAMESPACE_KEYLEN = strlen(NAMESPACE_KEY);
  SV **psv_ns;
  char *ns = NULL;
  int ok = 1; /* Default is valid */
  int attrnamespace = EXTATTR_NAMESPACE_USER;

  if (flags && (psv_ns = hv_fetch(flags, NAMESPACE_KEY, NAMESPACE_KEYLEN, 0)))
  {
    /*
     * Undefined => default. Otherwise "user" and "system" are valid.
     */
    if (SvOK(*psv_ns))
    {
      char *s;
      STRLEN len = 0;

      s = SvPV(*psv_ns, len);

      if (len)
      {
	if (memcmp(NAMESPACE_USER, s, len) == 0)
	  attrnamespace = EXTATTR_NAMESPACE_USER;
	else if (memcmp(NAMESPACE_SYSTEM, s, len) == 0)
	  attrnamespace = EXTATTR_NAMESPACE_SYSTEM;
	else
	  ok = 0;
      }
      else
      {
	ok = 0;
      }
    }
  }

  if (ok)
    *pattrnamespace = attrnamespace;

  return ok;
}

/* Helper to convert number of bytes written into success/failure code. */
static inline int
bsd_extattr_set_succeeded (const int expected, const int actual)
{
  int ret = 0;

  if (actual == -1) {
    ret = -errno;
  } else if (actual != expected) {
    /* Pretend there's not enough space for the data. */
    ret = -ENOBUFS;
  }

  return ret;
}

int
bsd_setxattr (const char *path,
	      const char *attrname,
	      const char *attrvalue,
	      const size_t slen,
	      struct hv *flags)
{
  int attrnamespace = -1;
  int ret = 0;

  if (!valid_namespace(flags, &attrnamespace))
  {
    ret = -EOPNOTSUPP;
  }

  if (ret == 0)
  {
    File_ExtAttr_setflags_t setflags = File_ExtAttr_flags2setflags(flags);
    switch (setflags)
    {
    case SET_CREATEIFNEEDED:
    case SET_REPLACE:
      /* Default behaviour */
      break;

    case SET_CREATE:
      /*
       * This needs to be emulated, since the default *BSD calls
       * don't provide a way of failing if the attribute exists.
       * This emulation is inherently racy.
       */
      {
	ssize_t sz = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
	if (sz >= 0)
	{
	  /* Attribute already exists => fail. */
	  ret = -EEXIST;
	}
      }
      break;
    }
  }

  if (ret == 0)
  {
    ret = extattr_set_file(path, attrnamespace, attrname, attrvalue, slen);
    ret = bsd_extattr_set_succeeded(slen, ret);
  }

  return ret;
}

int
bsd_fsetxattr (const int fd,
	       const char *attrname,
	       const char *attrvalue,
	       const size_t slen,
	       struct hv *flags)
{
  int attrnamespace = -1;
  int ret = 0;

  if (!valid_namespace(flags, &attrnamespace))
  {
    ret = -EOPNOTSUPP;
  }

  if (ret == 0)
  {
    File_ExtAttr_setflags_t setflags = File_ExtAttr_flags2setflags(flags);
    switch (setflags)
    {
    case SET_CREATEIFNEEDED:
    case SET_REPLACE:
      /* Default behaviour */
      break;

    case SET_CREATE:
      /*
       * This needs to be emulated, since the default *BSD calls
       * don't provide a way of failing if the attribute exists.
       * This emulation is inherently racy.
       */
      {
	ssize_t sz = extattr_get_fd(fd, attrnamespace, attrname, NULL, 0);
	if (sz >= 0)
	{
	  /* Attribute already exists => fail. */
	  ret = -EEXIST;
	}
      }
      break;
    }
  }

  if (ret == 0)
  {
    ret = extattr_set_fd(fd, attrnamespace, attrname, attrvalue, slen);
    ret = bsd_extattr_set_succeeded(slen, ret);
  }

  return ret;
}

int
bsd_getxattr (const char *path,
	      const char *attrname,
	      void *attrvalue,
	      const size_t slen,
	      struct hv *flags)
{
  int attrnamespace = -1;
  int ret = 0;

  if (!valid_namespace(flags, &attrnamespace))
  {
    ret = -EOPNOTSUPP;
  }

  if (ret == 0) {
    ret = extattr_get_file(path, attrnamespace, attrname, attrvalue, slen);
    if (ret < 0) {
      ret = -errno;
    }
  }

  return ret;
}

int
bsd_fgetxattr (const int fd,
	       const char *attrname,
	       void *attrvalue,
	       const size_t slen,
	       struct hv *flags)
{
  int attrnamespace = -1;
  int ret = 0;

  if (!valid_namespace(flags, &attrnamespace))
  {
    ret = -EOPNOTSUPP;
  }

  if (ret == 0) {
    ret = extattr_get_fd(fd, attrnamespace, attrname, attrvalue, slen);
    if (ret < 0) {
      ret = -errno;
    }
  }

  return ret;
}

int
bsd_removexattr (const char *path,
		 const char *attrname,
		 struct hv *flags)
{
  int attrnamespace = -1;
  int ret = 0;

  if (!valid_namespace(flags, &attrnamespace))
  {
    ret = -EOPNOTSUPP;
  }

  if (ret == 0) {
    ret = extattr_delete_file(path, attrnamespace, attrname);
    if (ret < 0) {
      ret = -errno;
    }
  }

  return ret;
}

int
bsd_fremovexattr (const int fd,
		  const char *attrname,
		  struct hv *flags)
{
  int attrnamespace = -1;
  int ret = 0;

  if (!valid_namespace(flags, &attrnamespace))
  {
    ret = -EOPNOTSUPP;
  }

  if (ret == 0) {
    ret = extattr_delete_fd(fd, attrnamespace, attrname);
    if (ret < 0) {
      ret = -errno;
    }
  }

  return ret;
}

/* Convert the BSD-style list to a nul-separated list. */
static void
reformat_list (char *buf, const ssize_t len)
{
  ssize_t pos = 0;
  ssize_t attrlen;

  while (pos < len)
  {
    attrlen = (unsigned char) buf[pos];
    memmove(buf + pos, buf + pos + 1, attrlen);
    buf[pos + attrlen] = '\0';
    pos += attrlen + 1;
  }
}

ssize_t
bsd_listxattr (const char *path,
	       char *buf,
	       const size_t buflen,
	       struct hv *flags)
{
  int attrnamespace = -1;
  ssize_t ret = 0;

  if (!valid_namespace(flags, &attrnamespace))
  {
    ret = -EOPNOTSUPP;
  }

  if (ret == 0)
  {
    ret = extattr_list_file(path,
			    attrnamespace,
			    /* To get the length on *BSD, pass NULL here. */
			    buflen ? buf : NULL,
			    buflen);

    if (buflen && (ret > 0))
      reformat_list(buf, ret);

    if (ret < 0) {
      ret = -errno;
    }
  }

  return ret;
}

ssize_t
bsd_flistxattr (const int fd,
		char *buf,
		const size_t buflen,
		struct hv *flags)
{
  int attrnamespace = -1;
  ssize_t ret = 0;

  if (!valid_namespace(flags, &attrnamespace))
  {
    ret = -EOPNOTSUPP;
  }

  if (ret == 0)
  {
    ret = extattr_list_fd(fd,
			  attrnamespace,
			  /* To get the length on *BSD, pass NULL here. */
			  buflen ? buf : NULL,
			  buflen);

    if (buflen && (ret > 0))
      reformat_list(buf, ret);

    if (ret < 0) {
      ret = -errno;
    }
  }

  return ret;
}

static ssize_t
listxattrns (char *buf, const size_t buflen,
	     const int iHasUser, const int iHasSystem)
{
  size_t len = 0;
  ssize_t ret = 0;

  if (iHasUser)
    len += sizeof(NAMESPACE_USER);
  if (iHasSystem)
    len += sizeof(NAMESPACE_SYSTEM);

  if (buflen >= len)
  {
    char *p = buf;

    if (iHasUser)
    {
      memcpy(p, NAMESPACE_USER, sizeof(NAMESPACE_USER));
      p += sizeof(NAMESPACE_USER);
    }
    if (iHasSystem)
    {
      memcpy(p, NAMESPACE_SYSTEM, sizeof(NAMESPACE_SYSTEM));
      p += sizeof(NAMESPACE_SYSTEM);
    }

    ret = len;
  }
  else if (buflen == 0)
  {
    ret = len;
  }
  else
  {
    ret = -ERANGE;
  }

  return ret;
}

ssize_t
bsd_listxattrns (const char *path,
		 char *buf,
		 const size_t buflen,
		 struct hv *flags)
{
  int iHasUser = 0;
  int iHasSystem = 0;
  ssize_t ret = 0;

  ret = extattr_list_file(path, EXTATTR_NAMESPACE_USER, NULL, 0);
  if (ret > 0)
    iHasUser = 1;

  if (ret >= 0)
  {
    ret = extattr_list_file(path, EXTATTR_NAMESPACE_SYSTEM, NULL, 0);
    if (ret > 0)
      iHasSystem = 1;

    /*
     * XXX: How do we cope with EPERM? Throw an exception.
     * For now ignore it, although this could cause problems.
     */
    if (ret == -1 && errno == EPERM)
      ret = 0;
  }

  if (ret >= 0)
    ret = listxattrns(buf, buflen, iHasUser, iHasSystem);

  return ret;
}

ssize_t
bsd_flistxattrns (const int fd,
		  char *buf,
		  const size_t buflen,
		  struct hv *flags)
{
  int iHasUser = 0;
  int iHasSystem = 0;
  ssize_t ret;

  ret = extattr_list_fd(fd, EXTATTR_NAMESPACE_USER, NULL, 0);
  if (ret > 0)
    iHasUser = 1;

  if (ret >= 0)
  {
    ret = extattr_list_fd(fd, EXTATTR_NAMESPACE_SYSTEM, NULL, 0);
    if (ret > 0)
      iHasSystem = 1;

    /*
     * XXX: How do we cope with EPERM? Throw an exception.
     * For now ignore it, although this could cause problems.
     */
    if (ret == -1 && errno == EPERM)
      ret = 0;
  }

  if (ret >= 0)
    ret = listxattrns(buf, buflen, iHasUser, iHasSystem);

  return ret;
}

#endif /* EXTATTR_BSD */