PARTAGE_NAME=“Bureau” DOSSIER=“$HOME/Bureau” UTILISATEUR=$(whoami)

echo “➡ Installation de Samba…” sudo apt update && sudo apt install -y samba

echo “➡ Création du dossier Bureau (s'il n'existe pas)…” mkdir -p “$DOSSIER”

echo “➡ Sauvegarde de la config actuelle de Samba…” sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak

echo “➡ Ajout du partage Samba dans smb.conf…”

# Supprimer un ancien bloc [Bureau] s'il existe sudo sed -i '/^\[Bureau\]/,/^$/d' /etc/samba/smb.conf

# Ajouter la nouvelle config en bas sudo tee -a /etc/samba/smb.conf > /dev/null «EOL

[Bureau]

 path = $DOSSIER
 browseable = yes
 writable = yes
 guest ok = yes
 read only = no
 force user = $UTILISATEUR

EOL

echo “➡ Redémarrage du service Samba…” sudo systemctl restart smbd

echo “✅ Le dossier '$DOSSIER' est maintenant partagé sous le nom '$PARTAGE_NAME'.” echo “➡ Accessible via : smb:$(hostname)/$PARTAGE_NAME ou smb:<adresse-IP>/$PARTAGE_NAME”

▶️ Comment utiliser ce script

  Ouvre un terminal.

  Copie le script dans un fichier :

nano partage_bureau.sh

  Colle le script, puis enregistre avec Ctrl+O, Entrée, puis Ctrl+X

  Rends le script exécutable :

chmod +x partage_bureau.sh

  Lance-le :

./partage_bureau.sh

🔁 Répète cela sur chaque machine Linux Mint du réseau.

Ensuite, tu peux accéder à chaque “Bureau” partagé depuis Nemo ou en tapant dans la barre d'adresse :

smb:nom-du-pc/Bureau ou smb:192.168.x.x/Bureau

Souhaites-tu aussi un script client pour monter automatiquement ces dossiers au démarrage ? Vous avez dit : oui ChatGPT a dit :

Parfait ! Voici un script client qui permet à chaque poste Linux Mint de :

  Scanner les autres machines du réseau local (ou lire une liste IP/host)

  Monter automatiquement leurs dossiers partagés Bureau dans un répertoire local (~/Réseau-Bureaux)

  Créer les montages au démarrage via fstab ou un script de session

📜 Script client : Montage automatique des dossiers “Bureau” du réseau

#!/bin/bash

#

MONTAGE_PARENT=“$HOME/Réseau-Bureaux” LISTE_IPS=(“192.168.1.10” “192.168.1.11” “192.168.1.12”) # ←- À adapter PARTAGE=“Bureau”

echo “➡ Création du dossier de base : $MONTAGE_PARENT” mkdir -p “$MONTAGE_PARENT”

echo “➡ Installation du support CIFS (Samba client)…” sudo apt install -y cifs-utils

# Boucle sur chaque IP for ip in “${LISTE_IPS[@]}”; do

  MONTAGE="$MONTAGE_PARENT/$ip"
  echo "➡ Création du dossier de montage pour $ip : $MONTAGE"
  sudo mkdir -p "$MONTAGE"

  # Tester si le partage est dispo
  echo "🔍 Vérification de $ip..."
  if smbclient -L //$ip -N 2>/dev/null | grep -q "$PARTAGE"; then
      echo "✅ Partage '$PARTAGE' trouvé sur $ip, ajout dans fstab..."
      
      # Nettoyage de lignes précédentes
      sudo sed -i "\|//$ip/$PARTAGE|d" /etc/fstab

      # Ajouter une ligne dans /etc/fstab
      echo "//$ip/$PARTAGE $MONTAGE cifs guest,_netdev,uid=$USER,gid=$USER 0 0" | sudo tee -a /etc/fstab > /dev/null
  else
      echo "❌ Le partage '$PARTAGE' n’est pas disponible sur $ip."
  fi

done

echo “➡ Montage de tous les partages listés dans fstab…” sudo mount -a

echo “✅ Tous les dossiers Bureau distants disponibles dans : $MONTAGE_PARENT”

📝 À faire avant d’exécuter le script

  Adapter la liste des IPs dans cette ligne :

LISTE_IPS=(“192.168.1.10” “192.168.1.11” “192.168.1.12”)

Tu peux aussi utiliser les noms NetBIOS/hostnames si tu les connais. ▶️ Utilisation du script

  Sauvegarde-le :

nano monter_bureaux.sh

  Colle le script, modifie les IPs, puis :

chmod +x monter_bureaux.sh ./monter_bureaux.sh

🔁 Pour que ça monte automatiquement au démarrage

L’entrée dans /etc/fstab s’en occupe. Assure-toi que :

  Le Wi-Fi ou Ethernet soit bien actif à l’ouverture de session

  _netdev est bien présent dans la ligne fstab (il attend que le réseau soit prêt)

✅ Résultat

Tu auras dans ton dossier ~/Réseau-Bureaux un sous-dossier pour chaque PC contenant son dossier “Bureau” partagé :

~/Réseau-Bureaux/ ├── 192.168.1.10 │ └── fichiers du Bureau distant ├── 192.168.1.11 │ └── …

Souhaites-tu aussi une interface graphique (ex. petit menu Python ou app GTK) pour choisir les machines à monter ? Vous avez dit : oui ChatGPT a dit :

Super ! Voici une interface graphique simple en Python avec GTK pour :

  Scanner des machines sur le réseau (à partir d’une liste d’IP/hostnames)

  Vérifier la disponibilité du partage Bureau

  Permettre à l'utilisateur de cocher/décocher les machines à monter

  Monter les dossiers sélectionnés dans ~/Réseau-Bureaux

✅ Prérequis 📦 Installer les dépendances (une seule fois) :

sudo apt install python3-gi python3-gi-cairo gir1.2-gtk-3.0 cifs-utils smbclient

📜 Code Python : interface de montage de dossiers Bureau

Sauvegarde dans un fichier appelé monter_bureaux_gui.py :

#!/usr/bin/env python3

import gi gi.require_version(“Gtk”, “3.0”) from gi.repository import Gtk import subprocess import os

#

MONTAGE_PARENT = os.path.expanduser(“~/Réseau-Bureaux”) PARTAGE = “Bureau” LISTE_MACHINES = [

  "192.168.1.10",
  "192.168.1.11",
  "192.168.1.12"

] # À adapter selon ton réseau

class BureauShareItem(Gtk.Box):

  def __init__(self, ip):
      super().__init__(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
      self.ip = ip
      self.checkbox = Gtk.CheckButton(label=f"{ip}")
      self.pack_start(self.checkbox, True, True, 0)

      # Tester si le partage est dispo
      self.share_available = self.check_share()
      if not self.share_available:
          self.checkbox.set_sensitive(False)
          self.checkbox.set_label(f"{ip} (non disponible)")

  def check_share(self):
      try:
          output = subprocess.check_output(["smbclient", "-L", f"//{self.ip}", "-N"], stderr=subprocess.DEVNULL).decode()
          return PARTAGE in output
      except:
          return False

class BureauShareApp(Gtk.Window):

  def __init__(self):
      super().__init__(title="Montage des Bureaux distants")
      self.set_border_width(15)
      self.set_default_size(400, 300)

      vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
      self.add(vbox)

      self.items = []
      for ip in LISTE_MACHINES:
          item = BureauShareItem(ip)
          self.items.append(item)
          vbox.pack_start(item, False, False, 0)

      self.button = Gtk.Button(label="Monter les bureaux sélectionnés")
      self.button.connect("clicked", self.on_mount_clicked)
      vbox.pack_start(self.button, False, False, 0)

  def on_mount_clicked(self, button):
      os.makedirs(MONTAGE_PARENT, exist_ok=True)

      for item in self.items:
          if item.checkbox.get_active() and item.share_available:
              mount_point = os.path.join(MONTAGE_PARENT, item.ip)
              os.makedirs(mount_point, exist_ok=True)
              subprocess.run([
                  "sudo", "mount", "-t", "cifs", f"//{item.ip}/{PARTAGE}", mount_point,
                  "-o", f"guest,uid={os.getuid()},gid={os.getgid()},_netdev"
              ])
      dialog = Gtk.MessageDialog(
          transient_for=self,
          flags=0,
          message_type=Gtk.MessageType.INFO,
          buttons=Gtk.ButtonsType.OK,
          text="Montage terminé",
      )
      dialog.run()
      dialog.destroy()

# Lancer l'application if name == “main”:

  win = BureauShareApp()
  win.connect("destroy", Gtk.main_quit)
  win.show_all()
  Gtk.main()

▶️ Exécuter l’interface

chmod +x monter_bureaux_gui.py ./monter_bureaux_gui.py

🔐 ⚠️ Permissions sudo

  Le script utilise sudo mount, donc tu seras invité à entrer ton mot de passe.

  Tu peux ajouter une règle sudoers pour permettre à mount -t cifs sans mot de passe (je peux t’aider à le faire si besoin).

✅ Résultat

  Tu coches les machines qui ont un partage Bureau

  Leurs dossiers sont montés dans ~/Réseau-Bureaux/192.168.x.x/

  Montage facile à la demande, sans ligne de commande

Souhaites-tu :

  Ajouter une option pour démonter les partages ?

  Rendre la liste d’IP configurable via un fichier texte ?

  Avoir une intégration automatique au démarrage ?