# Créer une dropbox qui gère le partage et permissions



## ccciolll (22 Avril 2014)

Bonjour,

Voilà, je souhaite créer une dropbox, ou drop zone, ou appelez ça comme vous voudrez, en local sur mon mac, dans la quelle tout dossier créé ou glissé par mes soins prenne automatiquement les droits "Lecture et Ecriture autorisées" pour tout utilisateur.

Ceci afin qu'une fois copiés sur le serveur que je partage avec d'autres, ces fichiers soient utilisables et, surtout, modifiables par mes collègues.

Pour des raisons de performance, je ne souhaite pas travailler directement sur le serveur (et quand bien même, quand je m'y connecte, les fichiers que je crée sont quand-même par défaut en lecture seule pour autre que moi).


----------



## r e m y (22 Avril 2014)

Il doit y avoir moyen de créer un AppleScript que fasse ce changement de droits par un "do shellscript..."

Puis attacher ce script au dossier que tu nommeras dropzone (en activant les scripts de dossier)

Ainsi pour chaque fichier glissé dans ce dossier, l'AppleScript sera executé et le fichier adoptera les droits en lecture/ecriture souhaités

Voilà pour la théorie. Je laisse les spécialistes en AppleScript et script Terminal te donner la syntaxe exacte des commandes à Applescripter


----------



## ccciolll (22 Avril 2014)

Peut-être avec Automator ?


----------



## edd72 (22 Avril 2014)

ccciolll a dit:


> je souhaite créer une dropbox, ou drop zone, ou appelez ça comme vous voudrez, en local sur mon mac



Ouais, un répertoire partagé... (pas besoin d'utiliser des mots du 21e siècle pour des concepts du 20e, DropBox c'est autre chose, c'est une synchronisation entre le dépôt et les appareils).


----------



## pascalformac (22 Avril 2014)

edd72 a dit:


> Ouais, un répertoire partagé..


" Partagé " c'est même fait pour ca


----------



## bompi (22 Avril 2014)

En fait, un simple script qui tourne toutes les minutes et ça sera bon. On peut lancer ce script avec cron ou launchd. 

En plus sophistiqué il faudrait faire une application qui soit activée par les événements du système de fichiers (comme fsevents) pour que l'action soit immédiate et réalisée une seule fois.


----------



## edd72 (22 Avril 2014)

+1 pour la cron avec un chmod


----------



## macomaniac (23 Avril 2014)

Salut *ccciolll*.



bompi a dit:


> En fait, un simple script qui tourne toutes les minutes et ça sera bon. On peut lancer ce script avec cron...
> 
> 
> edd72 a dit:
> ...



--> application par l'ilote de service *macomaniac*  :​

Tu ouvres une fenêtre du «Terminal» et tu fais successivement (par exemple) :




D'abord :


```
sudo mkdir /"Shared Items"/libre_espace
```


et &#8617;&#65038; + _password_ admin + &#8617;&#65038; --> tu viens de créer un dossier intitulé libre_espace dans le répertoire Éléments partagés à la racine de ton OS. Évidemment, créé par le Système, le dossier est pour l'instant en droits restreints :


```
drwxr-xr-x  2 root  wheel
```

càd. qu'aucun utilisateur autre que root n'y a de droits d'écriture, mais on s'en fiche pour l'instant, ça va servir de pierre de touche ultérieurement.

&#10058;​


Ensuite :


```
touch ~/Documents/maj-droits.sh
```

et &#8617;&#65038; --> tu viens de créer un fichier basique de type '_shell script_' intitulé 'maj-droits.sh' dans le dossier 'Documents' de ton répertoire d'utilisateur admin (dont je supposerai que son nom abrégé est ccciolll).

&#10043;​


Tu vas graphiquement (pour te faciliter la vie) audit fichier 'maj-droits.sh' et tu fais un ctrl_clic dessus pour l'ouvrir avec «TextEdit». Dans sa fenêtre vide, tu fais un copier-coller de :


```
#!/bin/bash
/usr/sbin/chown -R ccciolll:staff /"Shared Items"/libre_espace
chmod -R 777 /"Shared Items"/libre_espace
```

et tu sauvegardes le fichier, qui est dans le format 'texte' qui va bien. 

Tu as renseigné dans le '_shell script_' 2 commande récursives successives : l'une ('chown') établissant les _accédants_ au dossier libre_espace à :  ccciolll  staff  everyone ; l'autre ('chmod') les _permissions_ de ces _accédants_ à 777 en _valeur octale_, càd. à rwx (read/write/execute = lire/écrire/exécuter) pour l'_accédant : propriétaire_ = ccciolll, l'_accédant : groupe_ = staff (tous les 'ayant-comptes') et l'_accédant : everyone_ = other (les 'touristes' de l'OS).

&#10045;​


Par contre, ce qui ne va pas bien à ce stade, c'est les droits du fichier : 'maj-droits.sh', car ils sont du type :


```
-rw-rw-r--  ccciolll   staff
```

c'est-à-dire qu'il manque l'executive bit = x condition _sine qua non_ pour que le fichier soit exécutable. Qu'à cela ne tienne, tu reviens à la fenêtre du «Terminal» et tu saisis :


```
sudo chmod 777 ~/Documents/maj-droits.sh
```

et &#8617;&#65038; (avec _password_ admin, si tu as traîné au-delà des 5' où tu peux continuer d'être sudoer sans mot-de-passe après une première authentification en ligne de commande). Désormais, les droits de ton fichier sont :


```
-rwxrwxrwx   ccciolll  staff
```

et tout le monde est content (toi y compris, puisque je t'intime de l'être ).


&#10044;​


Maintenant, tu télécharges et installes l'application gratuite : &#9758;CronniX 3.0.2&#9756; (au cas où tu ne l'as pas déjà), laquelle offre une GUI commode pour établir des crons (commandes récurrentes, à tâche et à périodicité réglable, qui vont s'effectuer en toile de fond une fois l'OS démarré). Tu lances l'application qui par défaut ouvre une fenêtre de tâches référencée : «Cron pour l'utilisateur : ccciolll». Comme il est plus sûr d'avoir un cron qui va tourner imperturbablement aussi longtemps que ton OS est démarré sans qu'il dépende de ta seule session admin ouverte (qu'il puisse donc tourner même si tu fermes ta session), mais surtout comme les commandes 'chown' et 'chmod' impliquent un initiataire root pour s'exécuter _ipso facto_, tu vas à la barre de menus supérieure de «CronniX» et tu sélectionnes : '_Ouvrir le cron du Système_', ce qui vire la fenêtre de tâches à : '«Cron pour l'utilisateur : system». 


&#10057;​


Maintenant, tu t'inspires de cette capture :





--> Tu choisis 'Nouveau' (1), tu choisis 'Simple' (2), tu coches toutes les cases pour avoir des * partout (3), tu copies-colles : /Users/ccciolll/Documents/maj-droits.sh dans la fenêtre de commande (4) ou tu navigues graphiquement à ton fichier 'maj-droits.sh' contenu dans le répertoire de tes 'Documents' (4bis) et enfin tu presses le bouton 'Nouveau' (5).

&#10034;​


Il ne te reste plus, dans la barre d'outils de la GUI de «CronniX», qu'à presser le bouton '_Enregistrer_' (en t'authentifiant pour cela par ton mot-de-passe admin - car tu instaures une commande_cron qui va être initiée par root).

&#10059;​


En conséquence de ce petit montage --> toutes les minutes aussi longtemps que ton OS est démarré et quelle que soit la session ouverte (même si la tienne est fermée), un cron_root va s'exécuter rétablissant de manière récursive les _accédants_ au dossier /Éléments partagés/libre-espace *et à tout ce qu'il contient actuellement* à : ccciolll staff everyone (par la commande chown du '_shell script_'), et rétablissant de manière récursive les _permissions_ de ces _accédants_ au dossier /Éléments partagés/libre-espace *et à tout ce qu'il contient actuellement* à : drwxrwxrwx pour les _dossiers_, et à : -rwxrwxrwx pour les _fichiers_ (par la commande chmod du '_shell script_') - soit au complet :


```
drwxrwxrwx   ccciolll    staff  everyone
-rwxrwxrwx   ccciolll    staff  everyone
```


&#10055;&#65038;​

&#9758; _élémentaire mon cher Watson_ *ccciolll*  (testé expérimentalement avec succès sur mon _MacBook Pro_, OS : «Mavericks 10.9.2»). Après tout, si j'avais envie de changer à 777 pour tous les droits d'éléments dans mon OS, il me suffirait d'aller promener le chien _iceux_ dans le dossier destinataire du cron le temps pour l'horloge du Mac de sauter une minute .

[NB. Évidemment, il te faut remplacer toutes les occurrences de 'ccciolll' supposé ton nom abrégé d'utilisateur admin par ton vrai nom d'utilisateur en minuscules. De surcroît, l'intitulé du dossier partagé : libre_espace et sa localisation at : /"Shared Items" sont bien entendu modifiables à volonté --> il suffit de remplacer les occurrences d'intitulé et de localisation dans les commandes successives par celles actuellement en place en cas de changement.]


----------



## ccciolll (23 Avril 2014)

WA !

J'en ai les bras coupés !

Quel tuto, mais quel tuto !


----------



## ccciolll (25 Avril 2014)

Salut, je viens donc d'essayer de suivre le tuto.

à priori, le premier code fourni ne fonctionne pas, il met le message d'erreur suivant

```
mkdir: /Shared Items: No such file or directory
```

Mais qu'à cela ne tienne, j'ai repris la commande sudo mkdir, puis j'ai clic-glissé un dossier que je voyais sur mon bureau pour avoir le bon chemin (puisque je voulais ce dossier sur mon bureau, de toutes façons).

Tout semble avoir fonctionné jusqu'à Cronnix (j'ai changé les noms là où il le fallait, ton explication est bien faite)
Arrivé là, bien que je clique sur Fichier > Ouvrir le cron du système, il reste affiché Cron pour l'utilisateur : ccciolll Cron courant dans la fenêtre de cronnix.
Diable !

---------- Nouveau message ajouté à 11h43 ---------- Le message précédent a été envoyé à 11h35 ----------

Néanmoins, j'ai fait le test sans cron system, ça semble fonctionner (tout ce que j'y ai mis est passé en droits 777).

En revanche, petite chose curieuse, quand je veux copier des éléments dans le dossier créé par terminal, il me demande l'authentification.


----------



## macomaniac (25 Avril 2014)

ccciolll a dit:


> à priori, le premier code fourni ne fonctionne pas, il met le message d'erreur suivant
> 
> ```
> mkdir: /Shared Items: No such file or directory
> ...



Whaaah! &#9757;&#65038; Il y a 'torts partagés' je pense -->




en ce qui me concerne, j'avais compris que tu voulais créer un dossier partageable avec d'autres utilisateurs dans un endroit accessible de ton OS, de telle manière que tous les éléments que quiconque y logerait prennent automatiquement des droits lecture/écriture pour tous et pas seulement pour le propriétaire-créateur. D'où mon idée de créer ce dossier partagé dans le répertoire accessible à tous 'Éléments partagés' et de créer un cron_Système (et pas simplement un cron_utilisateur) afin que l'édition périodique des droits des éléments inclus s'opère en toile de fond que ta session propre soit ouverte ou non, et que les commandes chown et chmod soient honorées dans un espace de l'OS qui n'est pas celui de l'utilisateur mais celui du Système (espace-racine)


Mais ce n'est pas ce que tu veux. Tu veux simplement à ton propre usage exclusif et sur ton Bureau un dossier à fonction de conversion automatique des permissions des fichiers ou dossiers que tu crées, qui par défaut sont en lecture/écriture seulement pour toi le propriétaire, mais en lecture seule pour le groupe (= staff) et le tout-venant (= everyone) - conversion automatique qui les virerait à lecture/écriture à tous les étages (donc aussi pour le groupe et le tout-venant), ce qui te permettrait de les copier directo sur un Serveur où les permissions du groupe et du tout-venant resteraient à lecture/écriture et leur permettraient d'être manipulés à volonté par quiconque.


Bref, ce que tu appelles une 'dropbox' est un dossier 'drop_zone' changeur de permissions à --> lecture-écriture à tous les étages.

--------------------​


En ce qui te concerne, tu sembles avoir cafouillé sur plusieurs points, dont le 1er est que lorsque dans une ligne de commande tu as à gérer un 'objet' dont l'intitulé se compose d'au moins 2 mots séparés par un espace vide, comme Shared Items, tu dois toujours ajouter à l'énoncé d'un tel intitulé des 'indicateurs' qui demandent au Système de traiter l'énoncé 'comme un seul bloc' désignant un objet unique. Ainsi, si tu rédiges une commande :


```
sudo mkdir /[COLOR="Red"]Shared Items[/COLOR]/brol
```

c'est invalide, car l'espace vide dans Shared Items casse la ligne d'énoncé et le Système ne 'voit' pas que 'Shared Items' = un objet unique, par suite aucun dossier brol n'est créé dans Shared Items car le binaire 'mkdir' est incapable de 'trouver' le répertoire d'appartenance ; par contre si tu écrit : 


```
sudo mkdir /[COLOR="Red"]"[/COLOR]Shared Items[COLOR="Red"]"[/COLOR]/brol
```

c'est valide, car les "" solidarisent les 2 mots du titre en une désignation d'objet unique, par suite un dossier brol est créé dans Shared Items qui est trouvé comme répertoire. Ou encore si tu écris :


```
sudo mkdir /Shared[COLOR="Red"]\[/COLOR] Items/brol
```

car l'anti_slash joue le rôle d'indicateur de neutralisation de l'espace vide qui le suit.


Par ailleurs, je ne vois pas pourquoi tu ne peux pas virer la GUI de «CronniX» à l'option :

cron pour l'utilisateur :
system
cron courant​
Il te suffit pour cela d'aller au menu '_Fichier_' et de sélectionner le sous-menu : _Ouvrir le cron du système_.


En dernier lieu, pour un dossier que tu veux créer sur ton Bureau et qui ne servira qu'à toi, tu te contentes de le faire graphiquement par le Finder, tu n'as pas besoin d'un mkdir dans le «Terminal». D'ailleurs, quand tu fais un mkdir dans le «Terminal», si tu te contentes de faire un glisser-déposer d'un dossier déjà existant en cible de l'invocation, tu vas te heurter à un '_file already exists_', puisque tu n'as pas énoncé d'intitulé de dossier à créer mais que tu t'es contenté de renseigner l'adresse d'un dossier existant.


&#9828;​



Enfin, peu importe ce cafouillage venant de la rencontre d'idées hétérogènes --> tu as 2 solutions pour avoir sous la main des fichiers-dossiers créés par toi avec permissions 'totales pour tous' :



La solution cron activant à chaque minute un shell_script d'édition des droits ciblé sur un dossier précis. Alors tu peux raccourcir la procédure --> 


Tu crées graphiquement un dossier brol sur ton Bureau, qui va être en droits :


```
drwxr-xr-x  ccciolll   staff   everyone
```

te permettant tous les glisser-déposer que tu veux dedans. 


Tu ouvres avec «TextEdit » ton fichier 'maj-droits.sh' qui est dans tes documents et tu l'édites ainsi :


```
#!/bin/bash
/usr/sbin/chown -R ccciolll:staff /Users/ccciolll/Desktop/brol
chmod -R 777 /Users/ccciolll/Desktop/brol
```

et tu le sauvegardes. Normalement, il a toujours l'executive_bit qui lui permet d'être exécutable.


Comme ton cron, qui est un cron pour l'utilisateur : ccciolll (ce qui suffit dans l'usage que tu veux ici), pointe toujours au fichier 'maj-droits.sh' de tes documents, normalement le dossier brol sur ton Bureau hérite désormais du protocole d'édition des droits périodiques.


Comme tu l'as compris, si ccciolll n'est pas ton nom d'utilisateur, tu remplaces partout ce nom par le vrai. Et si tu veux nommer ton dossier 'drop_zone' autrement que brol, libre à toi, il te suffit d'éditer les 2 terminaisons de commande du shell_script en remplaçant brol par l'intitulé de ton dossier.


&#9831;​


La solution umask qui, à mon avis, est la plus adaptée à tes desiderata (car la précédente équivaut à passer un plat au micro-onde avant de le ressortir consommable - ce qui demande d'attendre le saut d'une minute à l'horloge du Mac )


Par défaut, OSX impose un filtre dit umask ('masque de l'utilisateur') au maximum théorique de _permissions_ que peut porter un _dossier_ ou un _fichier_ lorsqu'un utilisateur le crée. Ce maximum théorique est pour un _dossier_ = lecture/écriture/exécution pour le _propriétaire_, le _groupe_ et le _tout-venant_ ('exécution' signifiant la possibilité d'_exécuter l'entrée à l'espace du répertoire_, préalable à pouvoir lire cet espace et écrire cet espace). Cela se calcule en _valeur octale_, où r (read) = 4, w (write) = 2 et x (execute) = 1. Donc le maximum de _permissions_ théorique = 4 + 2+ 1 = 7 à la fois pour le propriétaire, le groupe et le tout-venant --> 777. Pour les fichiers qui ne sont pas des _exécutables_ (comme les binaires invoqués en ligne de commande), la permission execute n'a pas de pertinence, donc le maximum théorique de permissions d'un fichier '_texte_' est donc de 4 + 2 + 0 = 6 à la fois pour le propriétaire, le groupe et le tout-venant --> 666.


Le filtre umask imposé par OSX à la création de tout _dossier_ et de tout _fichier_ est par défaut l'umask : 022 --> ce qui s'interprète ainsi : _a priori_, la valeur octale 022 est soustraite au maximum théorique de permissions 777 des _dossiers_, ce qui donne des permissions effectives de 755 ; et au maximum théorique de permissions 666 des _fichiers_, ce qui donne des permissions effectives de 644. Ce qui s'interprète par ce que tu constates : les dossiers que tu crées sont en lecture/écriture/exécution = 7 pour toi leur propriétaire créateur, mais en 5 seulement = lecture = 4 + exécution (de l'entrée au répertoire) = 1 pour le groupe et le tout-venant --> il y a donc forclosion de la permission d'écriture par l'umask : 022. Et pareil pour les _fichiers_ --> 666 de permissions maximales théoriques - 022 = 644 : le créateur propriétaire peut lire (4) + écrire (2), le groupe et le tout-venant ne peuvent que lire (4).


La solution à ton problème s'impose d'elle-même : il s'agit de neutraliser l'umask : 022 pour le ramener à la valeur umask : 000. Pour cela, dans le «Terminal» tu saisis :


```
sudo touch /etc/launchd-user.conf
```

(à l'action de la commande, une demande de password s'affiche : tu tapes ton mot-de-passe admin à l'aveugle - aucun caractère ne se montrant à la frappe - et tu represses la touche 'Entrée' du clavier) --> tu viens de créer dans le répertoire invisible /private/etc un fichier s'adressant au processus launchd (le processus parent en qualité de 1er des processus extra_kernel) en lui enjoignant de lire au démarrage, avant l'ouverture d'aucune session graphique d'utilisateur, un fichier de configuration de paramètres d'utilisateur. Ce fichier est vide, pour l'instant, mais a les bons droits, càd. :


```
-rwr--r-- root  wheel
```


Maintenant, tu télécharges et tu installes &#9758;TextWrangler&#9756;, superbe logiciel gratuit qui permet l'édition directe de fichiers système sans modification des permissions. Tu le lances, tu demandes '_Ouvrir_' au menu '_Fichier_', et tu t'inspires du visuel suivant :




Coche la case (1) d'affichage des éléments invisibles, navigue au répertoire private (2), sous-répertoire etc, et descend la liste des fichiers jusqu'au fichier launchd-user.conf vide que tu viens de créer (4). Ouvre-le (5). Saisis uniquement :


```
umask 000
```

et sauvegarde ton fichier (6). Re-démarre. Désormais, tous les _dossiers_ que tu créeras (toi ou un autre utilisateur de ton Mac, car le paramétrage prévaut pour toute session graphique d'utilisateur de l'OS) seront en 777 en valeur octale (lecture/écriture/exécution à tous les étages d'accédants) et tous les _fichiers_ que tu créeras seront en 666 en valeur octale (lecture/écriture à tous les étages d'accédants)  --> ce qui résout ton problème _en amont_ (a priori) là où le dossier 'dropzone' résout le problème _en aval_ (a posteriori).

&#9758; tu peux revenir sur ton paramétrage de l'umask à tout moment, en ré-éditant par «TextWrangler» le fichier /private/etc/launchd-user.conf pour ramener la valeur octale de l'umask à 002 par exemple (seuls toi et le groupe ont des permissions totales, le tout-venant n'a pas droit d'écriture) ; ou tu peux revenir à la valeur par défaut = 022 (tu es seul en permission d'écriture sur les _dossiers_ et _fichiers_ que tu crées). Évidemment, la suppression du fichier launchd-user.conf joue le même rôle de ramener à l'umask : 022 par défaut.


&#9825;​


----------



## jeremy72 (28 Février 2022)

Bonjour,
je déterre le sujet de 2014. 

il me semble que la commande chown -R ne fonctionne pas, si je comprend bien elle devrait permettre d'ajouter les utilisateurs qui possède les droits au dossier et l'ensemble des sous dossier/fichier ?
puis ensuite la commande chmod -R 777 de modifier les droits de ces utilisateurs ( la ça fonctionne  )

Bloc de code: (de ccciolll)
#!/bin/bash
/usr/sbin/chown -R ccciolll:staff /"Shared Items"/libre_espace
chmod -R 777 /"Shared Items"/libre_espace

Bloc de code: (de mon fichier maj-droits.sh)
#!/bin/bash
/usr/sbin/chown -R lauranne:staff /Users/Shared/libre_espace
chmod -R 777 /Users/Shared/libre_espace

*quand je fais le test depuis : préférences système... partage... partage de fichiers... clic droit sur mon dossier partagé "libre_espace". -> appliquer les autorisations aux éléments inclus.  ... ça marche ( ajout des utilisateurs + droits 777 )*

c'est exactement cette fonction que je souhaite activer automatiquement  toute les 10 ou 15 minutes, même toute les minutes ,

1/ est-ce que j'ai une erreur sur ma ligne ?
/usr/sbin/chown -R lauranne:staff /Users/Shared/libre_espace

2/ avez vous un autre logiciel pour remplacer : CronniX 3.0.2.  ou fonctionne-t-il encore
(j'ai pas réussi l'installation surement à cause de ma puce M1 ) 

3/ en 2022 , 9 ans après le poste initial , y a t-il une autre solution ? ou celle-ci reste t-elle d'actualité ?
pourquoi Automator ne peux pas faire ça par exemple ?

merci pour votre aide 

jérémy


----------



## macomaniac (1 Mars 2022)

CronniX est une application *32-bits* qui n'est plus prise en charge par les versions de macOS à partir de Catalina compris. Mais je t'ai trouvé une solution alternative qui ne passe plus par la *crontab* pour exécuter une tâche répétitve d'arrière-plan > mais qui utilise le service *launchd* en lui faisant charger un *daemon* exécutant répétitivement un programme défini par un *script shell*.

- souhaites-tu que je te l'expose sous forme de petit tuto comme je l'avais fait naguère pour *ccciolll* ?​


----------



## macomaniac (2 Mars 2022)

Voici le petit tuto -->

- *a)* je suppose que tu as créé dans TextEdit un fichier intitulé : *maj-droits.sh* dont le contenu soit :​

```
#!/bin/bash
/usr/sbin/chown -R lauranne:staff /Users/Shared/libre_espace
chmod -R 777 /Users/Shared/libre_espace
```

ce qui implique que tu aies créé un sous-dossier intitulé *libre_espace* dans le dossier *Partagé* (*Shared*) des Utilisateurs. Note que les intitulés du fichier script ou du dossier cible peuvent être modifiés.

Déplace le fichier *maj-droits.sh* => à la localisation : */Library/Scripts* (dans la Bibliothèque de l'OS > dossier Scripts).

----------

- *b*) cela fait > passe alors la commande :​

```
sudo chmod u+x /Library/Scripts/maj-droits.sh
```

pour rajouter l'*executable_bit* (*x*) aux permissions de l'utilisateur (= toi : *lauranne*) du fichier *maj-droits.sh*. Ce qui transforme le fichier en fichier exécutable.
----------

- *c)* crée à présent dans TextEdit un fichier intitulé : *com.maj-droits.plist*  avec le contenu suivant :​

```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
    <dict>
        <key>KeepAlive</key>
        <true/>
        <key>Label</key>
        <string>com.maj-droits.app</string>
        <key>Program</key>
        <string>/Library/Scripts/maj-droits.sh</string>
        <key>RunAtLoad</key>
        <true/>
        <key>StartInterval</key>
        <string>30</string>
    </dict>
</plist>
```

ce fichier de type *XML* équivaut à une liste d'instructions conformes à la syntaxe attendue d'un fichier que le processus *launchd* (*launch*_*d*aemon : le processus parent des processus de détail de l'OS) --> pourra lire pour en faire un service (*daemon* : processus récurrent d'arrière-plan lancé à l'initialisation de l'OS). Parmi ces instructions : *KeepAlive*=*true* & *RunAtLoad*=*true* commandent le lancement du service à l'initialisation de l'OS et son maintien en vie tout le temps de cette initialisation ; enfin *Startinterval*=*30* temporise l'action du service toutes les *30* secondes. Par ailleurs > la clé : *Label* détermine l'intitulé du service > et la clé : *Program* détermine l'adresse au script shell exécutable dont le contenu équivaut au programme à exécuter.

Déplace le fichier *com.maj-droits.plist* => à la localisation : */Library/LaunchDaemons* (dans la Bibliothèque de l'OS > dossier LaunchDaemons).

----------

- *d)* cela fait passe enfin la commande :​

```
sudo chown 0:0 /Library/LaunchDaemons/com.maj-droits.plist
```

qui modifie les accédants du fichier à : *user*=*root* & *primary group*=*wheel* (*0* et *0* en valeur octale). Un "*daemon*" se différenciant d'un "*agent*" > non dans sa fonction  de service récurrent de toile de fond > mais dans l'identité de son utilisateur propriétaire : un *daemon* ayant *root* en usager propriétaire > un *agent* ayant pour usager un utilisateur particulier.
----------

Tout cela accompli > redémarre une fois --> ce qui va permettre au processus parent *launchd* (le Service des services de l'OS) de charger l'instruction du fichier *com.maj-droits.plist* comme *daemon* courant sans arrêt en arrière-plan et effectuant les instructions du script shell : *maj-droits.sh* qui constitue son programme.

=> tu n'auras qu'à dire si çà fonctionne...​


----------



## jeremy72 (2 Mars 2022)

Bonjour macomaniac,

la commande numéro 2 fonctionne bien  => elle passe les staff et everyone de "lecture seulement" à "lecture et écriture" => TOP

```
chmod -R 777 /Users/Shared/libre_espace
```

par contre la commande numéro 1 ne marche pas => elle devrait ajouter les "romain" et "marion" à la liste des utilisaeur avant de passer tout le monde en 777

```
/usr/sbin/chown -R lauranne:staff /Users/Shared/libre_espace
```


je continue mes test


----------



## jeremy72 (2 Mars 2022)

autre question : est-ce que je peux dans mon fichier maj-droits.sh donner plusieurs dossier ?


```
#!/bin/bash
/usr/sbin/chown -R lauranne:staff /Users/Shared/libre_espace
chmod -R 777 /Users/Shared/libre_espace
/usr/sbin/chown -R lauranne:staff /Users/lauranne/Documents/TABLEAU
chmod -R 777 /Users/lauranne/Documents/TABLEAU
/usr/sbin/chown -R lauranne:staff /Users/lauranne/Documents/dossierX
chmod -R 777 /Users/lauranne/Documents/dossierX
```


Autrement  le : *com.maj-droits.plist.  fonctionne bien !!
mille merci *

me manque juste l'ajout des utilisateurs avant de les passer en 777 et c'est une grande victoire


----------



## jeremy72 (2 Mars 2022)

jeremy72 a dit:


> par contre la commande numéro 1 ne marche pas => elle devrait ajouter les "romain" et "marion" à la liste des utilisaeur avant de passer tout le monde en 777
> 
> ```
> /usr/sbin/chown -R lauranne:staff /Users/Shared/libre_espace
> ```


Ok pardon , la commande fonctionne bien => elle ajoute bien staff 

```
/usr/sbin/chown -R lauranne:staff /Users/Shared/libre_espace
```
Si je mets staff tout les utilisateurs ont accès au dossier => il faudrait plutôt une commande pour mettre à jours les utilisateurs déjà définit dans le dossier libre_espace ...

comme j'ai plusieurs dossiers à mettre à jours avec des utilisateurs différent =>  

Dossier Tableau = lauranne, romain, marion, jeremy
Dossier X = lauranne, jeremy
Dossier Y = lauranne, romain
Dossier Z = lauranne, marion, jeremy

j'ai essayé

```
/usr/sbin/chown -R romain /Users/Shared/libre_espace
```
réponse => Operation not permitted


----------



## jeremy72 (2 Mars 2022)

je viens d'avoir une idée 
si je créer des groupes utilisateurs : autant que de dossiers que j'ai à partager
je donner les droits utilisateurs de chaque dossiers à un groupe et plus à un utilisateurs
puis j'utilise la commande 

```
/usr/sbin/chown -R lauranne:"nom du groupe" /Users/Shared/libre_espace
```

est que c'est plus propre comme ça ?

du coup dans mon fichier : *maj-droits.sh. *est-ce que je peux faire ??


```
#!/bin/bash
/usr/sbin/chown -R lauranne:"nom-du-groupe-A" /Users/Shared/libre_espace
chmod -R 777 /Users/Shared/libre_espace
/usr/sbin/chown -R lauranne:"nom-du-groupe-B" /Users/Shared/Dossier_B
chmod -R 777 /Users/Shared/Dossier_B
/usr/sbin/chown -R lauranne:"nom-du-groupe-C" /Users/Shared/Dossier_C
chmod -R 777 /Users/Shared/Dossier_C
```


----------



## macomaniac (3 Mars 2022)

Dans le fichier exécutable *shell* > la commande :

```
/usr/sbin/chown -R lauranne:staff /Users/Shared/libre_espace
```

que tu peux simplifier au départ en :


```
chown -R lauranne:staff /Users/Shared/libre_espace
```

instaure de manière *lauranne* en utilisateur (utilisatrice ?) récursif du dossier *libre_espace* et de ses contenus > et *staff* en groupe principal. Il s'agit ici de ce qu'on appelle les autorisations *POSIX* (basiques ou élémentaires) sur des objets. À ce niveau --> tu ne peux avoir qu'*un* utilisateur et qu'*un* groupe principal (et pas plusieurs concomitamment).

mais il existe des autorisations secondaires (ou supplétives) dites d'*ACL* (*A*ccess *C*ontrol *L*ist) > qui peuvent greffer sur les autorisations *POSIX* des autorisations supplémentaires. Comme autoriser *machin* ou *truc* en co-utilisateurs d'objets déterminés.

Si tu veux que je t'indique comment modifier le fichier programmatique (le script *shell*) exécuté de manière récurrente par le *daemon* --> il faudrait que tu commences par m'expliquer en détail ce que tu souhaites. J'étais parti de l'idée basique que tu voulais autoriser en lecture et écriture tous les membres du groupes *staff* sur le dossier *libre_espace* et ses contenus > en réservant à *lauranne* de manière récurrente le rôle d'usager propriétaire de ces objets. Manifestement tu souhaites quelque chose de plus compliqué.


----------



## jeremy72 (3 Mars 2022)

j'ai plusieurs dossier partagé accessible via le réseau à des utilisateurs ( en compte : partage uniquement )
quand un utilisateurs créer un sous dossier , les droits ne se sont pas à jours pour les autres tant que je clique pas sur " appliquer les autorisations aux éléments inclus" ( de chaque dossier en +   environ 15 ) , chaque utilisateurs à des accès différents à ces dossiers.

l'idée est d'automatiser et ça marche... presque 

je ne veux pas rajouter ou enlever des utilisateurs, juste actualisé les autorisations déjà défini


----------



## macomaniac (3 Mars 2022)

Les utilisateurs qui ont accès à tes dossiers n'ont pas de compte ouvert dans ton OS ? = ils n'ont pas d'identité référencée dans l'OS ?

- est-ce que tu souhaites simplement qu'ils puissent avoir un accès en lecture et écriture à tous les contenus des dossiers partagés - peu importe l'utilisateur propriétaire de ces données ? - si oui : est-ce que restaurer de manière récurrente les autorisations de ces objets à *777* = valeur octale des permissions de lecture / écriture / exécution de l'entrée au répertoire pour l'utiisateur *lauranne* (toi de façon récurrente) > le groupe primaire *staff* (de tous les ayants-comptes dans l'OS) > le groupe secondaire *everyone* (de tous les accédants quels qu'ils soient) --> ne suffit pas ?​


----------



## jeremy72 (3 Mars 2022)

macomaniac a dit:


> Les utilisateurs qui ont accès à tes dossiers n'ont pas de compte ouvert dans ton OS ? = ils n'ont pas d'identité référencée dans l'OS ?
> 
> - est-ce que tu souhaites simplement qu'ils puissent avoir un accès en lecture et écriture à tous les contenus des dossiers partagés - peu importe l'utilisateur propriétaire de ces données ? - si oui : est-ce que restaurer de manière récurrente les autorisations de ces objets à *777* = valeur octale des permissions de lecture / écriture / exécution de l'entrée au répertoire pour l'utiisateur *lauranne* (toi de façon récurrente) > le groupe primaire *staff* (de tous les ayants-comptes dans l'OS) > le groupe secondaire *everyone* (de tous les accédants quels qu'ils soient) --> ne suffit pas ?​








Oui les utilisateurs ont des compte sur l'OS mais en partage uniquement comme PJ ci-dessus.
il se connecte via un autre mac sur le réseau donc je pense pas qu'ils n'ont pas de compte ouvert ?

Oui => peux importe le propriétaire des données, les utilisateurs doivent avoir accès ( en fonction des droits de chacun évidement )

quand je fait un clic droit  sur " appliquer les autorisations aux éléments inclus "  sur le dossier partagé
=> les utilisateurs apparaissent dans tout les sous dossiers ( quand je fais clic droit : lire les informations d'un sous dossier il sont bien  apparue)

alors qu'avec la commande ci dessous, les utilisateurs n'apparaisse pas

```
chown -R lauranne:staff /Users/Shared/libre_espace
```

sur l'ensemble des dossier paratgé, j'ai supprimé le groupe staff et accès interdit au groupe tous.


----------



## macomaniac (3 Mars 2022)

La commande *chown* (*ch*ange_*own*er) manipule les accédants à un objet (utilisateur propriétaire et/ou groupe principal). C'est la commande *chmod* (*ch*ange_*mod*e) qui > admis les accédants à un objet > agit sur leurs permissions d'accès > voire instaure des autorisations d'accès supplémentaires (*ACL*) pour d'autres utilisateurs. Quant aux utilisateurs limités au partage > ils ont bien des comptes enregistrés dans l'OS mais ils ne peuvent pas ouvrir une session ni modifier les réglages de l'ordinateur.

- passe la commande :​

```
diskutil listUsers / | grep -v '.*[\^\_\].*'
```

qui liste les identités d'utilisateurs à noms pleins (sans underscore initial *_* de processus utilisateurs de l'OS) > en affichant en regard : nom court / nom complet

Poste le retour => que je me rende compte de l'état des lieux.

Par ailleurs > choisis un objet partagé à titre d'exemple (dossier ou fichier) que j'appelle ici *brol*. Passe la commande :

```
ls -le [path_to]brol
```

tu peux saisir *ls -le* > sauter un espace > faire un glisser-déposer de l'objet dans le *terminal* --> ce qui va inscrire automatiquement l'adresse à l'objet et son intitulé en terminaison

la commande affiche les autorisations *POSIX* (basiques) en 1ère ligne > puis les autorisations d'*ACL* (supplémentaires) en-dessous (s'il en existe) pour l'objet *brol*

Poste le retour concernant ton objet exemplaire => que je me rende compte.


----------



## jeremy72 (4 Mars 2022)

```
UID       Short Name                      Long Name
------------------------------------------------------------------------
506       stock                           stock
508       antoine                         antoine
505       benedicte                       bénédicte
504       steve                           steve
-2        nobody                          Unprivileged User
502       julien                          Julien
201       Guest                           Utilisateur invité
503       nathalie                        nathalie
509       location                        location
501       serveur                         Serveur
0         root                            System Administrator
1         daemon                          System Services
507       jeremy                          jérémy
```


```
0: user:benedicte allow read,write,append,readattr,writeattr,readextattr,writeextattr,readsecurity
 1: user:julien allow read,write,append,readattr,writeattr,readextattr,writeextattr,readsecurity
 2: user:jeremy allow read,write,append,readattr,writeattr,readextattr,writeextattr,readsecurity
```


----------



## jeremy72 (5 Mars 2022)

je souhaite actualisé les droits des dossiers partagé au utilisateurs défini.

je ne veux pas rajouter ou enlever des utilisateurs, uniquement actualisé : 

=> comme la fonction ci dessous : " appliquer les autorisations aux éléments inclus". sur 15 dossier partagé








merci pour ton aide


----------



## macomaniac (5 Mars 2022)

Whouahaha... Tu as une foule d'utilisateurs... J'ai besoin encore d'un seul renseignement. Passe la commande :

```
id benedicte
```

(tu peux remplacer *benedicte* = nom court par n'importe quel autre nom court d'un de tes utilisateurs - sauf *jeremy* si c'est toi et *root* > *daemon* > *Guest* = utilisateurs de type Système) la commande affiche les affililations de l'utilisateur (dont ses affiliations de groupes de l'OS)

Poste le retour. Que je voie si tel utilisateur limité au partage a quand même des privilèges de groupe dans l'OS.

----------

Il y a bien des *ACL* sur l'objet exemplaire en faveur de *benedicte* > *julien* > *jeremy*. Dans le fichier script programmatique > il est possible d'instaurer de façon récursive et récurrente toutes les autorisations d'*ACL* que tu veux pour tous les utilsateurs que tu veux.


----------



## jeremy72 (5 Mars 2022)

```
uid=505(benedicte) gid=20(staff) groups=20(staff),733(com.apple.sharepoint.group.33),739(com.apple.sharepoint.group.39),736(com.apple.sharepoint.group.36),734(com.apple.sharepoint.group.34),12(everyone),61(localaccounts),723(com.apple.sharepoint.group.23),738(com.apple.sharepoint.group.38),737(com.apple.sharepoint.group.37),710(com.apple.sharepoint.group.10),732(com.apple.sharepoint.group.32),720(com.apple.sharepoint.group.20),701(com.apple.sharepoint.group.1),742(com.apple.sharepoint.group.42),717(com.apple.sharepoint.group.17),707(com.apple.sharepoint.group.7),724(com.apple.sharepoint.group.24),729(com.apple.sharepoint.group.29),709(com.apple.sharepoint.group.9),706(com.apple.sharepoint.group.6),716(com.apple.sharepoint.group.16),715(com.apple.sharepoint.group.15),718(com.apple.sharepoint.group.18),727(com.apple.sharepoint.group.27),703(com.apple.sharepoint.group.3),722(com.apple.sharepoint.group.22),741(com.apple.sharepoint.group.41),725(com.apple.sharepoint.group.25),726(com.apple.sharepoint.group.26),100(_lpoperator),704(com.apple.sharepoint.group.4),740(com.apple.sharepoint.group.40),721(com.apple.sharepoint.group.21),730(com.apple.sharepoint.group.30),705(com.apple.sharepoint.group.5),731(com.apple.sharepoint.group.31),711(com.apple.sharepoint.group.11),728(com.apple.sharepoint.group.28),719(com.apple.sharepoint.group.19),713(com.apple.sharepoint.group.13),714(com.apple.sharepoint.group.14)
```

"> il est possible d'instaurer de façon récursive et récurrente toutes les autorisations d'*ACL* que tu veux pour tous les utilisateurs que tu veux."     => je suis pas certain d'avoir compris , ça signifie quoi ??


----------



## jeremy72 (5 Mars 2022)

tu arrive a avoir les infos sur le bloc de code ?


----------



## macomaniac (5 Mars 2022)

*benedicte* faisant partie du groupe *staff* (des ayant-comptes dans l'OS) > il suffit que le groupe *staff* ait des permissions de lecture / écriture / entrée aux répertoires (*7* en valeur octale) --> pour que *benedicte* qui en fait partie puisse lire et écrire à tous les objets nantis de ces autorisations de *staff*. Et il doit en aller ainsi de tous tes autres utilisateurs.

- conséquence : une commande récursive *chmod -R 777 [user]:staff* sur le dossier *libre_espace* suffit pour que tous les membres de *staff* (tous tes utilisateurs) aient les permissions d'accès attendues. Toi tu ne verras pas graphiquement si tu ouvres une fenêtre d'informations du Finder tel ou tel utilisateur avec tel ou tel droit. Mais eux auront libre accès aux objets du dossier *libre_espace*. Est-ce que ça ne te suffit pas ?​
Question : tous tes dossiers partagés sont-ils compris dans le répertoire commun *libre_espace* ?

----------

Tout objet de l'OS est associé à une liste invisible dite d'*ACL* (*A*ccess_*C*ontrol_*L*ist). Dans cette liste *ACL* > il peut y avoir autant d'*ACE* (*A*ccess_*C*ontrol_*E*ntry) que tu veux. Chaque entrée ajoute à l'objet un utilisateur ou un groupe particulier avec telle ou telle permission ou restriction. Il s'agit d'autorisations supplémentaires aux autorisations primaires de l'objet.

- dans ton exemple :​

```
0: user:benedicte allow read,write,append,readattr,writeattr,readextattr,writeextattr,readsecurity
 1: user:julien allow read,write,append,readattr,writeattr,readextattr,writeextattr,readsecurity
 2: user:jeremy allow read,write,append,readattr,writeattr,readextattr,writeextattr,readsecurity
```

tu as 3 *ACE* identiques (pour *benedicte* > *julien* > *jeremy*) ajoutant des permissions de lecture / écriture / attachement etc.

Mais je le redis : si *benedicte* > *julien* > *jeremy* sont membres du groupe *staff* autorisé en lecture / écriture à l'objet --> ils n'ont pas besoin d'autorisations d'*ACL* supplémentaires.


----------



## jeremy72 (5 Mars 2022)

sur ce dossier partagé ou seulement benedicte, julien, jeremy ont accès, est-ce que si j'ajoute staff les autres utilisateurs auront accès ??   pour moi oui...   c'est pour ça que j'ai supprimé le groupe staff des dossiers partagé et donnée les autorisations à chaque utilisateurs..

c'est pour ça que je comprend pas pourquoi tu veux que j'ajoute staff au dossier...  ??

----------

tout les dossiers partagé sont dans

```
/Users/serveur/Documents
```

du coup est-ce que dans mon fichier *maj-droits.sh *je peux faire ceci :


```
#!/bin/bash
/usr/sbin/chown -R serveur:staff /Users/serveur/Documents/depot
chmod -R 777 /Users/serveur/Documents/depot
/usr/sbin/chown -R serveur:staff /Users/serveur/Documents/livre
chmod -R 777 /Users/serveur/Documents/livre
/usr/sbin/chown -R serveur:staff /Users/serveur/Documents/musique
chmod -R 777 /Users/serveur/Documents/musique
```

est-ce possible de supprimer dans le code : /usr/sbin/ ?  comme tu ma déjà indiqué ( mais dans le tuto il est présent donc ?? )
autrement pour info  j'ai d'autre dossier dans /Documents qui ne sont pas des dossiers partagé , 
est-ce un problème d'être dans le répertoire document plutôt que shared ?


----------



## macomaniac (5 Mars 2022)

*serveur* : c'est ton identité d'utilisateur admin *501* ? - et tous les objets partagés sont dans le sous-dossier Documents de son dossier de compte *serveur* ?

- alors tes 2 commandes doivent faire l'affaire. Vérifie avec tes utilisateurs s'ils accèdent bien à tes Documents.​


----------



## jeremy72 (7 Mars 2022)

macomaniac a dit:


> *serveur* : c'est ton identité d'utilisateur admin *501* ?


OUI 


macomaniac a dit:


> et tous les objets partagés sont dans le sous-dossier Documents de son dossier de compte *serveur* ?
> 
> ​


OUI 

du coup est-ce que dans mon fichier *maj-droits.sh *je peux faire ceci :



```
#!/bin/bash
/usr/sbin/chown -R serveur:staff /Users/serveur/Documents/depot
chmod -R 777 /Users/serveur/Documents/depot
/usr/sbin/chown -R serveur:staff /Users/serveur/Documents/livre
chmod -R 777 /Users/serveur/Documents/livre
/usr/sbin/chown -R serveur:staff /Users/serveur/Documents/musique
chmod -R 777 /Users/serveur/Documents/musique
```


-------------

sur ce dossier partagé ou seulement benedicte, julien, jeremy ont accès, est-ce que si j'ajoute staff les autres utilisateurs auront accès ?? pour moi oui... c'est pour ça que j'ai supprimé le groupe staff des dossiers partagé et donnée les autorisations à chaque utilisateurs..

c'est pour ça que je comprend pas pourquoi tu veux que j'ajoute staff au dossier... ??


----------



## macomaniac (7 Mars 2022)

Si tu inscris *staff* en groupe d'accès principal aux sous-dossiers *depot* > *livre* > *musique* (contenus dans le dossier *Documents* de ton dossier de compte *serveur*) > avec des permissions *7* pour *staff* (4=lecture + 2=écriture + 1=exécution de l'accès au répertoire) récursives pour tous les contenus --> alors tous les membres du groupe *staff* (= tous tes utilisateurs) auront accès à ces dossiers et à ces contenus.

- tu n'avais pas déclaré que tu voulais un accès réservé à *3 *utilisateurs seulement (*benedicte* > *jeremy* > *julien*) à l'exclusion des autres.​
Passe une commande :

```
ls ~/Doc*
```

qui liste les objets de 1er rang de ton dossier *Documents*

Poste le retour --> que je me rende compte de la distribution de sous-dossiers que tu veux partager. Par ailleurs > et en rapport à cette liste des sous-dossiers de *Documents* --> précise : quels utilisateurs doivent pouvoir accéder à quoi (tous à tel ou pas tous à tel autre).


----------



## jeremy72 (7 Mars 2022)

si je créer des groupes utilisateurs : autant que de dossiers que j'ai à partager
je donner les droits utilisateurs de chaque dossiers à un groupe et plus à un utilisateurs
puis j'utilise la commande



```
/usr/sbin/chown -R lauranne:"nom du groupe" /Users/Shared/libre_espace
```


est-ce que c'est bon ?

sinon est-ce que je peux faire ceci ?  plusieurs fichiers ?


```
#!/bin/bash
/usr/sbin/chown -R serveur:staff /Users/serveur/Documents/depot
chmod -R 777 /Users/serveur/Documents/depot
/usr/sbin/chown -R serveur:staff /Users/serveur/Documents/livre
chmod -R 777 /Users/serveur/Documents/livre
/usr/sbin/chown -R serveur:staff /Users/serveur/Documents/musique
chmod -R 777 /Users/serveur/Documents/musique
```


----------



## macomaniac (7 Mars 2022)

Je n'ai pas vu *lauranne* listé(e) dans les utilisateurs de l'OS : de qui s'agit-il ? - et qu'y a-t-il dans le sous-dossier *libre_espace* du dossier *Partagé* ? Je pose la question > car tu semblais créer des dossiers de partage (*depot* > *livre* > *musique*) dans le sous-dossier *Documents* de ton dossier de compte *serveur* - pas dans *libre_espace*.

Voici la liste des utilisateurs personnels que tu avais postée :

```
stock                           
antoine                   
benedicte                       
steve                        
nathalie                      
location                       
serveur                   
jeremy
```

a priori ils sont tous membres par défaut du groupe *staff* et ont accès à tous les objets auxquels le groupe *staff* a accès. Est-ce que tu cherches à les répartir dans des groupes secondaires que tu crées ? - si oui : pourquoi ?  

En résumé : j'ai du mal à me représenter exactement ce que tu veux faire.


----------



## jeremy72 (7 Mars 2022)

les dossiers partagé sont bien dans documents ( libre_espace dans Shared était l'exemple du début de ce tuto en 2014 )
au finale ça ne change rien ?

le nom des membres : peut importe de jeremy, nathalie, lauranne ...  car je vais créer de nouveau membre et attribuer des autorisations d'accès au dossiers en fonctions de tel ou tel dossiers partagé.
exemple :
*/Users/serveur/Documents/livre  *=> 3 utilisateurs
*/Users/serveur/Documents/depot  *=> 5 utilisateurs
*/Users/serveur/Documents/musique  *=> 4 utilisateurs

au finale ça ne change rien le nom des utilisateurs?

la commande :

```
chown -R serveur:staff /Users/serveur/Documents/livre
```
ne fonctionne pas dans mon cas , puisqu'elle donne l'accès à tout les utilisateurs ( staff )
J'ai SUPPRIMER l'Accès du groupe *Staff *à tout les dossiers partagé puisque je veux donnée des accès individuel.

chaque dossier à des utilisateurs différent..


je me pose la question si je créer un *groupe d'utilisateur  *nommé * livre: *je met à l'intérieur  3 utilisateurs 
j'autorise le partage au dossier */Users/serveur/Documents/livre *uniquement au groupe *livre*

est-ce que la commande suivante fonctionne

```
chown -R serveur:livre /Users/serveur/Documents/livre
```

autrement comment faire pour "actualiser les droits d'utilisateur"   qui ont accès au dossier *livre* sans rajouter d'autres utilisateurs qui eux n'ont pas le droit d'avoir accès à *livre*


----------



## macomaniac (8 Mars 2022)

Tu peux effectivement créer des groupes personnalisés qui auraient le même intitulé que les dossiers à partager avec les membres de ces groupes. Donc un groupe *livre* pour l'accès spécifique au dossier *livre* > groupe *depot* pour le dossier *depot* > groupe *musique* pour le dossier *musique*. Et tu invites dans ces groupes uniquement les utilisateurs de ton choix. Cela étant > les 3 commandes :

```
chown -R serveur:livre /Users/serveur/Documents/livre
chown -R serveur:depot /Users/serveur/Documents/depot
chown -R serveur:musique /Users/serveur/Documents/musique
```

restreindront les accès respectifs aux membres seuls de chaque groupe. Si tu prends soin par ailleurs à ce que le groupe secondaire (non affiché par défaut) qui est toujours *everyone* (tout un chacun) --> n'ait pas de permissions d'accès aux sous-dossiers > car les membres de *staff* (tous les utilisateurs) sont aussi membres automatiquement de *everyone*. Pour cela > des commandes :


```
sudo chmod -R 770 /Users/serveur/Documents/livre
sudo chmod -R 770 /Users/serveur/Documents/depot
sudo chmod -R 770 /Users/serveur/Documents/musique
```

attribuent *0* permissions au groupe secondaire *everyone* > mais *7* à *serveur* (utilisateur) et *7* au groupe principal personnalisé dans chaque cas qui a été établi par la triplette des commandes *chown*.

Tu n'as qu'à dire si cette solution fonctionne à ta convenance.

Note : *777* en valeur octale dans une commande *chmod* se lit ainsi : le 1er *7* = permissions de l'*user* > le 2è *7* = permissions du groupe principal > le 3è *7* = permissions du groupe secondaire *everyone*. *7* étant la somme de : *4*=permission de lecture + *2*=permission d'écriture + *1*=permission d'exécution de l'entrée au répertoire. Si tu passes des commandes *chmod* avec *770* en valeur octale --> tu modifies à *0* à la fin les seules permissions du groupe secondaire = *everyone*.


----------



## jeremy72 (8 Mars 2022)

je vais essayer ça 
effectivement sur les dossiers partagé, j'ai supprimer l'accès à everyone ( accès interdit )

si j'ai bien compris le e 2è *7* = permissions du groupe principal => va correspondre au groupe que je vais créer ? exemple *livre* ou *musique *


----------



## macomaniac (8 Mars 2022)

Exact. Le 2è *7* (= permissions de lecture + écriture + exécution) correspondra au groupe que tu auras créé (*livre* ou *musique*...) > si tu passes au préalable une commande *chown* sur le dossier avec *serveur:livre* ou *serveur:musique* comme attribution d'accès (*serveur* sera alors l'utilisateur du dossier et *livre* ou *musique* son groupe principal - ce qui éjecte le *staff* par défaut de tout droit d'accès de groupe). L'option récursive *-R* étend ces propriétés à tous les objets contenus dans le dossier. Idem pour les permissions d'une commande *chmod* si tu la flanques de l'option récursive *-R*.


----------



## jeremy72 (9 Mars 2022)

les 2 commande *chown -R serveur:staff* et *chmod -R 770* retourne "Operation not permitted"   sur les fichiers ajouter par les autre utilisateurs que serveur.

quand l'utilisateur *serveur* ajoute un fichier ça fonctionne 
quand *julien* ajoute un fichier ça ne marche plus.

est-ce que ça ne vient pas du fait que le répertoire est document ? 

y a t il une solution ?


----------



## macomaniac (9 Mars 2022)

Est-ce que tu as inscrit les commandes dans le fichier script shell : *maj-droits.sh* (présent dans les *Scripts* de la Bibliothèque de l'OS) ? - car alors le programme de ce fichier sera effectué par le daemon : *com.maj-droits.plist* (présent dans les *LaunchDaemons* de cette même Bibliothèque de l'OS) après un redémarrage qui fera prendre en compte ces instructions par le processus *launchd*. Cela > parce que le *daemon* étant un service de l'utilisateur *root* --> il aura les privilèges de modifier les autorisations des contenus du dossier cible.

- si par contre tu testes manuellement dans le *terminal* les commandes --> alors elles n'ont pas ce privilège *root* d'exécution. Pour un pareil test manuel > tu dois mentionner *sudo* en tête de chaque commande - exemple :​

```
sudo chown -R serveur:livre /Users/serveur/Documents/livre
sudo chmod -R 770 /Users/serveur/Documents/livre
```

ce qui te demande de t'authentifier (avec ton mot-de-passe admin d'utiilsateur *serveur* saisi en aveugle) à la demande de *password* quand tu passes ces commandes isolément dans le *terminal*.

En résumé : comment testes-tu l'effet des commandes ? - en manuel dans le *terminal* ou en éditant le fichier *shell* ?


----------



## jeremy72 (9 Mars 2022)

compris pour le sudo  j'ai effectivement testé manuellement dans le terminal

par contre je comprend pas j'ai suivi le tuto sur mon macbook air (bigsur M1 )et ça à marché du premier coup

par contre impossible de le faire fonctionné sur mon mac mini (catalina 10.15.2). ??

j'ai bien :
*maj-droits.sh* présent dans les *Scripts* de la Bibliothèque
*com.maj-droits.plist* présent dans les *LaunchDaemons* de cette même Bibliothèque

j'ai bien passé :

```
sudo chmod u+x /Library/Scripts/maj-droits.sh
```


```
sudo chown 0:0 /Library/LaunchDaemons/com.maj-droits.plist
```

j'ai bien vu Wheel sur le fichier com.maj-droits.plist

par contre comment vérifié que maj-droits.sh est bien un exécutable ?
mon mac mini n'est pas connecté à internet, j'imagine que ça change rien

je cherche les différence entre les 2... une idée ?


----------



## macomaniac (10 Mars 2022)

On va y arriver.

- commençons par ton *MacBook Air* (Big Sur) où tu dis que ça fonctionne. Peux-tu passer les 2 commandes (séparément) :​

```
sudo cat /Library/LaunchDaemons/com.maj-droits.plist
sudo cat /Library/Scripts/maj-droits.sh
```

qui affichent les contenus actuels du fichier de service : *com.maj-droits.plist* et du script programme : *maj-droits.sh*

Poste les 2 affichages retournés => que je voie l'état des lieux actuel.


----------



## jeremy72 (10 Mars 2022)

```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
    <dict>
        <key>KeepAlive</key>
        <true/>
        <key>Label</key>
        <string>com.maj-droits.app</string>
        <key>Program</key>
        <string>/Library/Scripts/maj-droits.sh</string>
        <key>RunAtLoad</key>
        <true/>
        <key>StartInterval</key>
        <string>30</string>
    </dict>
</plist>%
```


```
#!/bin/bash
/usr/sbin/chown -R Lauranne:staff /Users/Shared/libre_espace
chmod -R 770 /Users/Shared/libre_espace%
```


----------



## macomaniac (10 Mars 2022)

Ton fichier de service pointe bien au programme du fichier script.

- en ce qui concerne ce dernier : il adresse un dossier *libre_espace* dans *Partagé* > avec 2 actions : instauration récursive de *Lauranne* comme utilisatrice et *staff* comme groupe principal > et permissions de lecture / écriture : exécution (de l'entrée au répertoire) pour ces 2 à l'exclusion de *everyone* (groupe secondaire).​
Tu ne te sers pas de ton *MacBook Air* (Big Sur) pour tes partages ? Uniquement en mode expérimental ? - car on trouve une utilisatrice *Lauranne* absente des utilisateurs de l'autre Mac > et un dossier partagé *libre_espace* qui n'a plus rien à voir avec le dossier *Documents* de l'autre Mac. C'est donc un appareil de test du dispositif ici ?


----------



## jeremy72 (10 Mars 2022)

!!!!  Résolu !!!! 
encore une fois mille merci 

j'ai comparé sur mon mac mini le fichier : *maj-droits.sh *retourné le code si dessous ??? alors que depuis le TextEdit il n'y avait uniquement:
#!/bin/bash\
/usr/sbin/chown -R Serveur:staff /Users/Serveur/Documents/Livre\
chmod -R 770 /Users/Serveur/Documents/Livre

j'ai refait le fichier *maj-droits.sh *, rien n'y faire ça marché pas...  obligé d'aller chercher le fichier sur le macbook air et la ça marche 

je pense que le fichier était toujours en rtf, la conversion en shell n'a pas du fonctionné.... euh je m'avance un peu trop la , j'ai pas les compétences de *macomaniac *qui à su être à l'écoute , patient et disponible.... bravo à toi 
----------
tu m'avais déjà dit oui mais je peux bien supprimé /usr/sbin/
pour mon info à quoi ça sert ?? /usr/sbin/



```
{\rtf1\ansi\ansicpg1252\cocoartf2511
\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fnil\fcharset0 Menlo-Regular;}
{\colortbl;\red255\green255\blue255;\red43\green54\blue81;}
{\*\expandedcolortbl;;\cssrgb\c21961\c27843\c39216;}
\paperw11900\paperh16840\margl1440\margr1440\vieww18660\viewh9760\viewkind0
\deftab720
\pard\pardeftab720\sl400\partightenfactor0

\f0\fs28\fsmilli14400 \cf2 \expnd0\expndtw0\kerning0
#!/bin/bash\
/usr/sbin/chown -R Serveur:staff /Users/Serveur/Documents/Livre\
chmod -R 770 /Users/Serveur/Documents/Livre
```


----------



## macomaniac (10 Mars 2022)

Tes affichages ne sont pas très lisibles.

- sur ton Mac *mini* : supposant que tu aies un fichier de service fonctionnel qui pointe bien au fichier programme *maj-droits.sh* des *Scripts* de la Bibliothèque de l'OS --> il faut que ce fichier soit en format texte effectivement et qu'il ait l'*executable_bit* : *x* comme permission exécutive de l'utilisateur *serveur*. Dernier point que tu vérifies par une commande :​
```
ls -al /Library/Scrips/maj-droits.sh
```

qui affiche les autorisations du fichier.
​- quant à son contenu : *a)* si tu as *3* dossiers dans Documents = *livre* > *depot* > *musique* (attention à la casse ! je suppose ici que les 3 dossiers sont bien intitulés comme je les écris sans majuscule - sinon tu opères les variations correspondantes aux intitulés réels des dossiers dans tes commandes) ; *b)* si tu as créé *3* groupes homonymes : *livre* > *depot* > *musique* (attention à la casse encore) auxquels tu as associé les utilisateurs de ton choix ; *c)* si l'utilisateur propriétaire (=toi) a pour nomcourt *serveur* (attention à la casse encore !) ; *d)* enfin si tu souhaites que seuls les utilisateurs associés à un groupe puissent partager les contenus du dossier homonyme correspondant -->​
alors il faudrait que le contenu de ton fichier *maj-droits.sh* soit le suivant :

```
#!/bin/bash
chown -R serveur:livre /Users/serveur/Documents/livre
chown -R serveur:depot /Users/serveur/Documents/depot
chown -R serveur:musique /Users/serveur/Documents/musique
chmod -R 770 /Users/serveur/Documents/livre
chmod -R 770 /Users/serveur/Documents/depot
chmod -R 770 /Users/serveur/Documents/musique
```

par rapport aux exemples que tu donnais précédemment où tout se trouvait inscrit en minuscules > je ne comprends pas pourquoi des majuscules interviennent dans ton message précédent. L'intitulé d'un utilisateur (*serveur*) ou d'un groupe (*livre* > *depot* > *musique*) doit correspondre strictement à son nomcourt (nom du compte) > pas à son nom complet qui n'est qu'un intitulé cosmétique.

----------

Une commande dans le *terminal* commence par appeler un programme exécutable contenu dans un fichier du même nom > lequel est localisé dans l'OS dans un dossier de binaires déterminé. Les programmes *chown* et *chmod* sont localisés tous les 2 dans le répertoire (invisible) */usr* > dossier *sbin*. Les adresses absolues à ces programmes inscrivent le chemin complet aux fichiers : */usr/sbin/chown* et */usr/sbin/chmod*. Mais on peut mentionner directement l'intitulé du fichier-programme : *chown* et *chmod* > dans la mesure où des préférences implicites (pour l'utilisateur *serveur* ou pour l'utilisateur *root*) adressent automatiquement les dossiers de résidence des exécutables (*sbin* ici).


----------

