chgrp - PHP code example

PHP Function Chgrp

php function chgrp is an important file system function used to change the group of a file. This function is available in all versions of php. PHP has thousands of built-in functions. These functions are useful for executing complex tasks in a very simple manner. These functions are called using parenthesis () to pass inputs and return a value.

PHP supports various data types in its functions and has a feature named kind declaration. This feature allows the programmer to define the intended data type of a function. This way, if the input data does not match with the intended type, the function will throw a Fatal Error.

This article will discuss a few of the basic file system functions that PHP offers. Some of these include: fstat – returns information about a file or directory; lst_dir – lists the contents of a directory; move – moves a file; mtime – get the modification time; put_contents – writes a string to a file; size – gets the file size in bytes; and chgrp – changes the user group of a file.

Besides changing the group of a file, chgrp also checks whether the current owner has the same rights as the script being executed. This is especially helpful for secure websites and applications. This is why many developers prefer to use chgrp in their code. Moreover, it is easy to understand and provides greater flexibility. Hence, it is recommended to learn this feature.

chgrp example

    public function chgrp(string|iterable $files, string|int $group, bool $recursive = false)
    {
        foreach ($this->toIterable($files) as $file) {
            if ($recursive && is_dir($file) && !is_link($file)) {
                $this->chgrp(new \FilesystemIterator($file), $group, true);
            }
            if (is_link($file) && \function_exists('lchgrp')) {
                if (!self::box('lchgrp', $file, $group)) {
                    throw new IOException(sprintf('Failed to chgrp file "%s": ', $file).self::$lastError, 0, null, $file);
                }
            } else {
                if (!self::box('chgrp', $file, $group)) {
                    throw new IOException(sprintf('Failed to chgrp file "%s": ', $file).self::$lastError, 0, null, $file);
                }
            }
        }
    }

return false;
        }

        // Set directory permissions.         ssh2_sftp_chmod( $this->sftp_link, $path, $chmod );

        if ( $chown ) {
            $this->chown( $path, $chown );
        }

        if ( $chgrp ) {
            $this->chgrp( $path, $chgrp );
        }

        return true;
    }

    /** * Deletes a directory. * * @since 2.7.0 * * @param string $path Path to directory. * @param bool $recursive Optional. Whether to recursively remove files/directories. * Default false. * @return bool True on success, false on failure. */

$this->filesystem->chown($dir, 'user'.time().mt_rand(1000, 9999));
    }

    public function testChgrpByName()
    {
        $this->markAsSkippedIfPosixIsMissing();

        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'dir';
        mkdir($dir);

        $group = $this->getFileGroup($dir);
        $this->filesystem->chgrp($dir, $group);

        $this->assertSame($group, $this->getFileGroup($dir));
    }

    public function testChgrpById()
    {
        $this->markAsSkippedIfPosixIsMissing();

        $dir = $this->workspace.\DIRECTORY_SEPARATOR.'dir';
        mkdir($dir);

$return = touch($target);
        }
        break;

      case STREAM_META_OWNER_NAME:
      case STREAM_META_OWNER:
        $return = chown($target, $value);
        break;

      case STREAM_META_GROUP_NAME:
      case STREAM_META_GROUP:
        $return = chgrp($target, $value);
        break;

      case STREAM_META_ACCESS:
        $return = chmod($target, $value);
        break;
    }
    if ($return) {
      // For convenience clear the file status cache of the underlying file,       // since metadata operations are often followed by file status checks.       clearstatcache(TRUE, $target);
    }

    public function chgrp( $file, $group, $recursive = false ) {
        if ( ! $this->exists( $file ) ) {
            return false;
        }

        if ( ! $recursive ) {
            return chgrp( $file, $group );
        }

        if ( ! $this->is_dir( $file ) ) {
            return chgrp( $file, $group );
        }

        // Is a directory, and we want recursive.         $file     = trailingslashit( $file );
        $filelist = $this->dirlist( $file );

        foreach ( $filelist as $filename ) {

fwrite($v_dest_file, $v_content, 512);
                            }
                            if (($v_header['size'] % 512) != 0) {
                                $v_content = $this->_readBlock();
                                fwrite($v_dest_file, $v_content, ($v_header['size'] % 512));
                            }

                            @fclose($v_dest_file);

                            if ($p_preserve) {
                                @chown($v_header['filename'], $v_header['uid']);
                                @chgrp($v_header['filename'], $v_header['gid']);
                            }

                            // ----- Change the file mode, mtime                             @touch($v_header['filename'], $v_header['mtime']);
                            if ($v_header['mode'] & 0111) {
                                // make file executable, obey umask                                 $mode = fileperms($v_header['filename']) | (~umask() & 0111);
                                @chmod($v_header['filename'], $mode);
                            }
                        }