Hoe chmoderen we recursief alle mappen behalve bestanden?

Om recursief directories lees- en uitvoerrechten te geven:

find /path/to/base/dir -type d -exec chmod 755 {} +

Om recursief bestanden leesrechten te geven:

find /path/to/base/dir -type f -exec chmod 644 {} +

• *

Of, als er veel objecten te verwerken zijn:

chmod 755 $(find /path/to/base/dir -type d)
chmod 644 $(find /path/to/base/dir -type f)

Of, om het kuitschieten van chmod te verminderen:

find /path/to/base/dir -type d -print0 | xargs -0 chmod 755 
find /path/to/base/dir -type f -print0 | xargs -0 chmod 644

Een veel voorkomende reden voor dit soort dingen is het instellen van mappen op 755 maar bestanden op 644. In dit geval is er een iets snellere manier dan nik’s find voorbeeld:

chmod -R u+rwX,go+rX,go-w /path

Betekenis:

• -R = recursief;
• u+rwX = gebruikers kunnen lezen, schrijven en uitvoeren;
• go+rX = groep en anderen kunnen lezen en uitvoeren;
• go-w = groep en anderen kunnen niet schrijven

Het belangrijkste om hier op te merken is dat hoofdletters X anders werkt dan kleine letters x. In de handleiding kunnen we lezen:

De uitvoer/zoekbits als het bestand een directory is of als een van de uitvoer/zoekbits in de originele (ongewijzigde) modus staat.

Met andere woorden, chmod u+X op een bestand zal het uitvoerbit niet instellen; en g+X zal het alleen instellen als het al ingesteld is voor de gebruiker.

Als je er zeker van wilt zijn dat de bestanden zijn ingesteld op 644 en er bestanden in het pad zijn die de executievlag hebben, moet je eerst de executievlag verwijderen. +X verwijdert de uitvoeringsvlag niet van bestanden die deze al hebben.

Voorbeeld: chmod -R ugo-x,u+rwX,go+rX,go-w path

Update: dit lijkt te mislukken omdat de eerste wijziging (ugo-x) de map niet uitvoerbaar maakt, zodat alle bestanden eronder niet worden gewijzigd.

Ik heb besloten om hier zelf een klein scriptje voor te schrijven. Recursief chmod script voor dirs en/of bestanden - Gist :

chmodr.sh

#!/bin/sh
# 
# chmodr.sh
#
# author: Francis Byrne
# date: 2011/02/12
#
# Generic Script for recursively setting permissions for directories and files
# to defined or default permissions using chmod.
#
# Takes a path to recurse through and options for specifying directory and/or 
# file permissions.
# Outputs a list of affected directories and files.
# 
# If no options are specified, it recursively resets all directory and file
# permissions to the default for most OSs (dirs: 755, files: 644).

# Usage message
usage()
{
  echo "Usage: $0 PATH -d DIRPERMS -f FILEPERMS"
  echo "Arguments:"
  echo "PATH: path to the root directory you wish to modify permissions for"
  echo "Options:"
  echo " -d DIRPERMS, directory permissions"
  echo " -f FILEPERMS, file permissions"
  exit 1
}

# Check if user entered arguments
if [$# -lt 1] ; then
 usage
fi

# Get options
while getopts d:f: opt
do
  case "$opt" in
    d) DIRPERMS="$OPTARG";;
    f) FILEPERMS="$OPTARG";;
    \?) usage;;
  esac
done

# Shift option index so that $1 now refers to the first argument
shift $(($OPTIND - 1))

# Default directory and file permissions, if not set on command line
if [-z "$DIRPERMS"] && [-z "$FILEPERMS"] ; then
  DIRPERMS=755
  FILEPERMS=644
fi

# Set the root path to be the argument entered by the user
ROOT=$1

# Check if the root path is a valid directory
if [! -d $ROOT] ; then
 echo "$ROOT does not exist or isn't a directory!" ; exit 1
fi

# Recursively set directory/file permissions based on the permission variables
if [-n "$DIRPERMS"] ; then
  find $ROOT -type d -print0 | xargs -0 chmod -v $DIRPERMS
fi

if [-n "$FILEPERMS"] ; then
  find $ROOT -type f -print0 | xargs -0 chmod -v $FILEPERMS
fi

Het doet in principe de recursieve chmod maar biedt ook een beetje flexibiliteit voor commandoregelopties (stelt directory en/of bestandsrechten in, of sluit beide uit het zet alles automatisch terug naar 755-644). Het controleert ook op een paar fout scenario’s.

Ik heb er ook over geschreven op mijn blog .

Om recursief directories lees- en uitvoerrechten te geven:

find /path/to/base/dir -type d -exec chmod 755 {} \;

Om recursief bestanden leesrechten te geven:

find /path/to/base/dir -type f -exec chmod 644 {} \;

Beter laat dan me nooit nik’s antwoord aan de kant van de correctheid te laten opwaarderen. Mijn oplossing is langzamer, maar het werkt met een willekeurig aantal bestanden, met eventuele symbolen in bestandsnamen, en je kunt het met sudo normaal uitvoeren (maar pas op dat het verschillende bestanden met sudo ontdekt).

Probeer dit pythonscript; het vereist geen spawning van processen en doet slechts twee syscalls per bestand. Afgezien van een implementatie in C, zal het waarschijnlijk de snelste manier zijn om het te doen (ik had het nodig om een bestandssysteem van 15 miljoen bestanden te repareren die allemaal op 777 waren ingesteld)

#!/usr/bin/python3
import os
for par, dirs, files in os.walk('.'):
    for d in dirs:
        os.chmod(par + '/' + d, 0o755)
    for f in files:
        os.chmod(par + '/' + f, 0o644)

In mijn geval was er een try/catch nodig rond de laatste chmod, aangezien chmodding enkele speciale bestanden heeft gefaald.

U kunt ook gebruik maken van tree:

tree -faid /your_directory | xargs -L1 -I{} bash -c 'sudo chmod 755 "$1"' -- '{}'

en als u ook de map wilt bekijken voeg dan een echo

tree -faid /your_directory | xargs -L1 -I{} bash -c 'sudo chmod 755 "$1" && echo$1' -- '{}'
``` toe.

Je zou het volgende bash-script als voorbeeld kunnen gebruiken. Zorg ervoor dat u het uitvoerbare rechten geeft (755). Gebruik gewoon ./autochmod.sh voor de huidige directory, of ./autochmod.sh

#!/bin/bash

if [-e $1]; then
    if [-d $1];then
        dir=$1
    else
        echo "No such directory: $1"
        exit
    fi
else
    dir="./"
fi

for f in $(ls -l $dir | awk '{print $8}'); do
    if [-d $f];then
        chmod 755 $f
    else
        chmod 644 $f
    fi
done