Exemplo n.º 1
0
static int 
mem_stat(resmgr_context_t *ctp, io_stat_t *msg, void *vocb) {
	struct mem_ocb			*ocb = vocb;
	union object			*obp = ocb ? ocb->object : 0;
	size_t					size = ocb ? (obp ? OBJECT_SIZE(obp) : UINT_MAX) : 0;

	memset(&msg->o, 0x00, sizeof msg->o);
	msg->o.st_size = size;
	msg->o.st_nblocks = (size + (__PAGESIZE-1)) / __PAGESIZE;
	msg->o.st_blocksize = msg->o.st_blksize = __PAGESIZE;
	msg->o.st_ctime =
	msg->o.st_mtime =
	msg->o.st_atime =(obp ? obp->mem.pm.mtime : time(0));
	msg->o.st_ino = obp ? (uintptr_t)INODE_XOR(obp) : 1;
	if(ocb && obp) {
		msg->o.st_uid = obp->mem.pm.uid;
		msg->o.st_gid = obp->mem.pm.gid;
		msg->o.st_mode = (obp->mem.pm.mode != 0) ? obp->mem.pm.mode : S_IFNAM | S_IPERMS;
		msg->o.st_nlink = obp->hdr.refs;
		msg->o.st_dev = path_devno;
		msg->o.st_rdev = S_ISNAM(msg->o.st_mode) ? S_INSHD : 0;
	} else {
		//The /dev/mem device is set to rw root only, the /dev/shmem
		//device is set to rwx for all, since it is un-enforced. 
		msg->o.st_mode = ocb ? S_IFREG | 0600 : S_IFDIR | 0777;
		msg->o.st_nlink = ocb ? 1 : 2;
		msg->o.st_dev = mem_devno;
		msg->o.st_rdev = 0;
	}
	msg->o.st_dev |= (ctp->info.srcnd << ND_NODE_BITS);
	return _RESMGR_PTR(ctp, &msg->o, sizeof msg->o);
}
Exemplo n.º 2
0
Arquivo: util.c Projeto: JBurant/mc
const char *
string_perm (mode_t mode_bits)
{
    static char mode[11];

    strcpy (mode, "----------");
    if (S_ISDIR (mode_bits))
        mode[0] = 'd';
    if (S_ISCHR (mode_bits))
        mode[0] = 'c';
    if (S_ISBLK (mode_bits))
        mode[0] = 'b';
    if (S_ISLNK (mode_bits))
        mode[0] = 'l';
    if (S_ISFIFO (mode_bits))
        mode[0] = 'p';
    if (S_ISNAM (mode_bits))
        mode[0] = 'n';
    if (S_ISSOCK (mode_bits))
        mode[0] = 's';
    if (S_ISDOOR (mode_bits))
        mode[0] = 'D';
    if (ismode (mode_bits, S_IXOTH))
        mode[9] = 'x';
    if (ismode (mode_bits, S_IWOTH))
        mode[8] = 'w';
    if (ismode (mode_bits, S_IROTH))
        mode[7] = 'r';
    if (ismode (mode_bits, S_IXGRP))
        mode[6] = 'x';
    if (ismode (mode_bits, S_IWGRP))
        mode[5] = 'w';
    if (ismode (mode_bits, S_IRGRP))
        mode[4] = 'r';
    if (ismode (mode_bits, S_IXUSR))
        mode[3] = 'x';
    if (ismode (mode_bits, S_IWUSR))
        mode[2] = 'w';
    if (ismode (mode_bits, S_IRUSR))
        mode[1] = 'r';
#ifdef S_ISUID
    if (ismode (mode_bits, S_ISUID))
        mode[3] = (mode[3] == 'x') ? 's' : 'S';
#endif /* S_ISUID */
#ifdef S_ISGID
    if (ismode (mode_bits, S_ISGID))
        mode[6] = (mode[6] == 'x') ? 's' : 'S';
#endif /* S_ISGID */
#ifdef S_ISVTX
    if (ismode (mode_bits, S_ISVTX))
        mode[9] = (mode[9] == 'x') ? 't' : 'T';
#endif /* S_ISVTX */
    return mode;
}
Exemplo n.º 3
0
static char
ftypelet (mode_t bits)
{
  if (S_ISBLK (bits))
    return 'b';
  if (S_ISCHR (bits))
    return 'c';
  if (S_ISDIR (bits))
    return 'd';
  if (S_ISREG (bits))
    return '-';
  if (S_ISFIFO (bits))
    return 'p';
  if (S_ISLNK (bits))
    return 'l';
  if (S_ISSOCK (bits))
    return 's';
  if (S_ISMPC (bits))
    return 'm';
  if (S_ISNWK (bits))
    return 'n';
  if (S_ISDOOR (bits))
    return 'D';
  if (S_ISCTG (bits))
    return 'C';
/* Added by Alexander Lamaison for Swish project */
  if (S_ISWHT (bits))
    return 'w';
  if (S_ISMPB (bits))
    return 'B';
  if (S_ISNAM (bits))
    return 'x';
/* Added 2006.08.20 */
  /* The following two tests are for Cray DMF (Data Migration
     Facility), which is a HSM file system.  A migrated file has a
     `st_dm_mode' that is different from the normal `st_mode', so any
     tests for migrated files should use the former.  */

  if (S_ISOFD (bits))
    /* off line, with data  */
    return 'M';
  /* off line, with no data  */
  if (S_ISOFL (bits))
    return 'M';
  return '?';
}
Exemplo n.º 4
0
/* make permissions string from file mode */
char *str_mode(mode_t fmode) {
	static char	perms[1+3+3+3+1];		/* static so we can return it */
	char *p = perms;

	/* directory ? */

	
	if		(S_ISDIR(fmode))	*p='d';
	else if (S_ISNAM(fmode))	*p='n';
	else if (S_ISLNK(fmode))	*p='l';
	else if (S_ISCHR(fmode))	*p='c';
	else if (S_ISBLK(fmode))	*p='b';
	else if (S_ISSOCK(fmode))	*p='s';
	else if (S_ISFIFO(fmode))	*p='p';
    else						*p='-';
	p++;

	/* Handle USER permissions */
	*p++ = (fmode & S_IRUSR) ? 'r' : '-';
	*p++ = (fmode & S_IWUSR) ? 'w' : '-';
	if (fmode & S_ISUID)
		*p++ = (fmode & S_IXUSR) ? 's' : 'S';
 	else
		*p++ = (fmode & S_IXUSR) ? 'x' : '-';

	/* Handle GROUP permissions */
	*p++ = (fmode & S_IRGRP) ? 'r' : '-';
	*p++ = (fmode & S_IWGRP) ? 'w' : '-';
	if (fmode & S_ISGID)
		*p++ = (fmode & S_IXGRP) ? 's' : 'L';
	else
		*p++ = (fmode & S_IXGRP) ? 'x' : '-';

	/* Handle OTHER permissions */
	*p++ = (fmode & S_IROTH) ? 'r' : '-';
	*p++ = (fmode & S_IWOTH) ? 'w' : '-';
	if (fmode & S_ISVTX)
		*p++ = (fmode & S_IXOTH) ? 't' : 'T';
	else
		*p++ = (fmode & S_IXOTH) ? 'x' : '-';

	*p = 0;
	return perms;
}
Exemplo n.º 5
0
static int 
mem_change_attr(resmgr_context_t *ctp, resmgr_iomsgs_t *msg, void *vocb) {
	iofunc_ocb_t		nocb;
	iofunc_attr_t		attr;
	struct mem_ocb		*ocb = vocb;
	union object		*obp;
	int					ret;

	if(!ocb || !(obp = ocb->object) || (!S_ISNAM(obp->mem.pm.mode) && !S_ISREG(obp->mem.pm.mode))) {
		return _RESMGR_DEFAULT;
	}

	memset(&nocb, 0, sizeof(nocb));
	nocb.ioflag = ocb->ioflag;
	memset(&attr, 0, sizeof(attr));
	attr.mode = obp->mem.pm.mode, attr.gid = obp->mem.pm.gid, attr.uid = obp->mem.pm.uid;

	switch(msg->type) {
	case _IO_CHOWN:
		if((ret = iofunc_chown(ctp, &msg->chown, &nocb, &attr)) == EOK) {
			obp->mem.pm.gid = attr.gid;
			obp->mem.pm.uid = attr.uid;
		}
		break;
	case _IO_CHMOD:
		if((ret = iofunc_chmod(ctp, &msg->chmod, &nocb, &attr)) == EOK) {
			obp->mem.pm.mode = attr.mode;
		}
		break;
	default:
		ret = _RESMGR_DEFAULT;
		break;
	}

	return ret;
}
Exemplo n.º 6
0
#endif
    S_IRWXU, S_IRUSR, S_IWUSR, S_IXUSR,
    S_IRWXG, S_IRGRP, S_IWGRP, S_IXGRP,
    S_IRWXO, S_IROTH, S_IWOTH, S_IXOTH,
    S_ISUID, S_ISGID, S_ISVTX,
    S_ISBLK (S_IFREG),
    S_ISCHR (S_IFREG),
    S_ISDIR (S_IFREG),
    S_ISFIFO (S_IFREG),
    S_ISREG (S_IFREG),
    S_ISLNK (S_IFREG),
    S_ISSOCK (S_IFREG),
    S_ISDOOR (S_IFREG),
    S_ISMPB (S_IFREG),
    S_ISMPX (S_IFREG),
    S_ISNAM (S_IFREG),
    S_ISNWK (S_IFREG),
    S_ISPORT (S_IFREG),
    S_ISCTG (S_IFREG),
    S_ISOFD (S_IFREG),
    S_ISOFL (S_IFREG),
    S_ISWHT (S_IFREG)
  };

/* Sanity checks.  */

verify (S_IRWXU == (S_IRUSR | S_IWUSR | S_IXUSR));
verify (S_IRWXG == (S_IRGRP | S_IWGRP | S_IXGRP));
verify (S_IRWXO == (S_IROTH | S_IWOTH | S_IXOTH));

#ifdef S_IFBLK
Exemplo n.º 7
0
static int php_random_bytes(void *bytes, size_t size)
{
#if PHP_WIN32
	/* Defer to CryptGenRandom on Windows */
	if (php_win32_get_random_bytes(bytes, size) == FAILURE) {
		zend_throw_exception(zend_ce_exception, "Could not gather sufficient random data", 0);
		return FAILURE;
	}
#elif HAVE_DECL_ARC4RANDOM_BUF && ((defined(__OpenBSD__) && OpenBSD >= 201405) || (defined(__NetBSD__) && __NetBSD_Version__ >= 700000001))
	arc4random_buf(bytes, size);
#elif HAVE_DECL_GETRANDOM
	/* Linux getrandom(2) syscall */
	size_t read_bytes = 0;
	size_t amount_to_read = 0;
	ssize_t n;

	/* Keep reading until we get enough entropy */
	do {
		amount_to_read = size - read_bytes;
		/* Below, (bytes + read_bytes)  is pointer arithmetic.

		   bytes   read_bytes  size
		     |      |           |
		    [#######=============] (we're going to write over the = region)
		             \\\\\\\\\\\\\
		              amount_to_read

		*/
		n = syscall(SYS_getrandom, bytes + read_bytes, amount_to_read, 0);

		if (n == -1) {
			if (errno == EINTR || errno == EAGAIN) {
				/* Try again */
				continue;
			}
			/*
				If the syscall fails, we are doomed. The loop that calls
				php_random_bytes should be terminated by the exception instead
				of proceeding to demand more entropy.
			*/
			zend_throw_exception(zend_ce_exception, "Could not gather sufficient random data", errno);
			return FAILURE;
		}

		read_bytes += (size_t) n;
	} while (read_bytes < size);
#else
	int    fd = RANDOM_G(fd);
	struct stat st;
	size_t read_bytes = 0;
	ssize_t n;

	if (fd < 0) {
#if HAVE_DEV_URANDOM
		fd = open("/dev/urandom", O_RDONLY);
#endif
		if (fd < 0) {
			zend_throw_exception(zend_ce_exception, "Cannot open source device", 0);
			return FAILURE;
		}
		/* Does the file exist and is it a character device? */
		if (fstat(fd, &st) != 0 || 
# ifdef S_ISNAM
                !(S_ISNAM(st.st_mode) || S_ISCHR(st.st_mode))
# else
                !S_ISCHR(st.st_mode)
# endif
		) {
			close(fd);
			zend_throw_exception(zend_ce_exception, "Error reading from source device", 0);
			return FAILURE;
		}
		RANDOM_G(fd) = fd;
	}

	while (read_bytes < size) {
		n = read(fd, bytes + read_bytes, size - read_bytes);
		if (n <= 0) {
			break;
		}
		read_bytes += n;
	}

	if (read_bytes < size) {
		zend_throw_exception(zend_ce_exception, "Could not gather sufficient random data", 0);
		return FAILURE;
	}
#endif

	return SUCCESS;
}
Exemplo n.º 8
0
char const *
file_type (struct stat const *st)
{
  /* See POSIX 1003.1-2001 XCU Table 4-8 lines 17093-17107 for some of
     these formats.

     To keep diagnostics grammatical in English, the returned string
     must start with a consonant.  */

  /* Do these three first, as they're the most common.  */

  if (S_ISREG (st->st_mode))
    return st->st_size == 0 ? _("regular empty file") : _("regular file");

  if (S_ISDIR (st->st_mode))
    return _("directory");

  if (S_ISLNK (st->st_mode))
    return _("symbolic link");

  /* Do the S_TYPEIS* macros next, as they may be implemented in terms
     of S_ISNAM, and we want the more-specialized interpretation.  */

  if (S_TYPEISMQ (st))
    return _("message queue");

  if (S_TYPEISSEM (st))
    return _("semaphore");

  if (S_TYPEISSHM (st))
    return _("shared memory object");

  if (S_TYPEISTMO (st))
    return _("typed memory object");

  /* The remaining are in alphabetical order.  */

  if (S_ISBLK (st->st_mode))
    return _("block special file");

  if (S_ISCHR (st->st_mode))
    return _("character special file");

  if (S_ISCTG (st->st_mode))
    return _("contiguous data");

  if (S_ISFIFO (st->st_mode))
    return _("fifo");

  if (S_ISDOOR (st->st_mode))
    return _("door");

  if (S_ISMPB (st->st_mode))
    return _("multiplexed block special file");

  if (S_ISMPC (st->st_mode))
    return _("multiplexed character special file");

  if (S_ISMPX (st->st_mode))
    return _("multiplexed file");

  if (S_ISNAM (st->st_mode))
    return _("named file");

  if (S_ISNWK (st->st_mode))
    return _("network special file");

  if (S_ISOFD (st->st_mode))
    return _("migrated file with data");

  if (S_ISOFL (st->st_mode))
    return _("migrated file without data");

  if (S_ISPORT (st->st_mode))
    return _("port");

  if (S_ISSOCK (st->st_mode))
    return _("socket");

  if (S_ISWHT (st->st_mode))
    return _("whiteout");

  return _("weird file");
}
Exemplo n.º 9
0
/* {{{ */
PHPAPI int php_random_bytes(void *bytes, size_t size, zend_bool should_throw)
{
#ifdef PHP_WIN32
	/* Defer to CryptGenRandom on Windows */
	if (php_win32_get_random_bytes(bytes, size) == FAILURE) {
		if (should_throw) {
			zend_throw_exception(zend_ce_exception, "Could not gather sufficient random data", 0);
		}
		return FAILURE;
	}
#elif HAVE_DECL_ARC4RANDOM_BUF && ((defined(__OpenBSD__) && OpenBSD >= 201405) || (defined(__NetBSD__) && __NetBSD_Version__ >= 700000001))
	arc4random_buf(bytes, size);
#else
	size_t read_bytes = 0;
	ssize_t n;
#if defined(__linux__) && defined(SYS_getrandom)
	/* Linux getrandom(2) syscall */
	/* Keep reading until we get enough entropy */
	while (read_bytes < size) {
		/* Below, (bytes + read_bytes)  is pointer arithmetic.

		   bytes   read_bytes  size
		     |      |           |
		    [#######=============] (we're going to write over the = region)
		             \\\\\\\\\\\\\
		              amount_to_read

		*/
		size_t amount_to_read = size - read_bytes;
		n = syscall(SYS_getrandom, bytes + read_bytes, amount_to_read, 0);

		if (n == -1) {
			if (errno == ENOSYS) {
				/* This can happen if PHP was compiled against a newer kernel where getrandom()
				 * is available, but then runs on an older kernel without getrandom(). If this
				 * happens we simply fall back to reading from /dev/urandom. */
				ZEND_ASSERT(read_bytes == 0);
				break;
			} else if (errno == EINTR || errno == EAGAIN) {
				/* Try again */
				continue;
			} else {
			    /* If the syscall fails, fall back to reading from /dev/urandom */
				break;
			}
		}

		read_bytes += (size_t) n;
	}
#endif
	if (read_bytes < size) {
		int    fd = RANDOM_G(fd);
		struct stat st;

		if (fd < 0) {
#if HAVE_DEV_URANDOM
			fd = open("/dev/urandom", O_RDONLY);
#endif
			if (fd < 0) {
				if (should_throw) {
					zend_throw_exception(zend_ce_exception, "Cannot open source device", 0);
				}
				return FAILURE;
			}
			/* Does the file exist and is it a character device? */
			if (fstat(fd, &st) != 0 ||
# ifdef S_ISNAM
					!(S_ISNAM(st.st_mode) || S_ISCHR(st.st_mode))
# else
					!S_ISCHR(st.st_mode)
# endif
			) {
				close(fd);
				if (should_throw) {
					zend_throw_exception(zend_ce_exception, "Error reading from source device", 0);
				}
				return FAILURE;
			}
			RANDOM_G(fd) = fd;
		}

		for (read_bytes = 0; read_bytes < size; read_bytes += (size_t) n) {
			n = read(fd, bytes + read_bytes, size - read_bytes);
			if (n <= 0) {
				break;
			}
		}

		if (read_bytes < size) {
			if (should_throw) {
				zend_throw_exception(zend_ce_exception, "Could not gather sufficient random data", 0);
			}
			return FAILURE;
		}
	}
#endif

	return SUCCESS;
}