Change ubuntu image to node

Reviewed-on: #3

.gitea/workflows/build.yml

@@ -0,0 +1,30 @@
+name: Build
+
+on:
+  push: {}
+
+defaults:
+  run:
+    shell: bash
+    working-directory: .
+
+jobs:
+  build:
+    runs-on: ubuntu
+    container:
+      image: node:20
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      
+      - name: Install tools
+        run: apt update && apt install -y build-essential
+
+      - name: Compile project
+        run: make
+
+      - name: Save build output
+        uses: actions/upload-artifact@v3
+        with:
+          name: ncsambawatcher
+          path: ./ncsambawatcher

.gitea/workflows/release.yml

@@ -0,0 +1,49 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - v.*
+
+defaults:
+  run:
+    shell: bash
+    working-directory: .
+
+jobs: 
+  release:
+    runs-on: ubuntu
+    needs: build
+    container:
+      image: node:20
+    steps:
+      steps:
+      - name: Install build tools
+        run: apt update && apt install -y zip
+      
+      - name: Download compiled binary
+        uses: actions/download-artifact@v3
+        with:
+          name: ncsambawatcher
+
+      - name: Copy files
+        run: |
+          mkdir build
+          cp ncsambawatcher build/ncsambawatcher
+          cp configs/ncsambawatcher.config.default build/ncsambawatcher.config
+          cp init.sh config/init.sh 
+
+      - name: Create release zip
+        run: |
+          cd build
+          zip ../ncsambawatcher.zip ./*
+
+      - name: Publish release
+        uses: actions/create-release@v1
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        with:
+          tag_name: ${{ github.ref_name }}
+          release_name: Release ${{ github.ref_name }}
+          files: |
+            ncsambawatcher.zip

.gitignore

@@ -90,3 +90,5 @@ settings.json
 watch.c
 ncwatchfile
 ncsambawatcher
+
+obj/

Makefile

@@ -1,2 +1,31 @@
-all:
+# Compiler and flags
-	g++ -lrt -std=c++17 src/main.cpp src/usermanager.cpp src/guarder.cpp -o ncsambawatcher
+CXX := g++
+CXXFLAGS := -std=c++17 -Wall -Wextra -O2
+
+# Directories
+SRC_DIR := src
+OBJ_DIR := obj
+BUILD_DIR := .
+TARGET := $(BUILD_DIR)/ncsambawatcher
+
+# Create list of source and object files
+SRCS := $(wildcard $(SRC_DIR)/*.cpp)
+OBJS := $(SRCS:$(SRC_DIR)/%.cpp=$(OBJ_DIR)/%.o)
+
+# Default target
+all: $(TARGET)
+
+# Link object files into final binary
+$(TARGET): $(OBJS)
+	$(CXX) $(CXXFLAGS) -o $@ $^
+
+# Compile .cpp to .o into obj/
+$(OBJ_DIR)/%.o: $(SRC_DIR)/%.cpp
+	@mkdir -p $(OBJ_DIR)
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+# Clean build artifacts
+clean:
+	rm -f $(OBJ_DIR)/*.o $(TARGET)
+
+.PHONY: all clean

configs/ncsambawatcher.config.default

@@ -0,0 +1 @@
+NEXTCLOUD_CONTAINER_NAME=nextcloud

configs/ncsambawatcher.service

@@ -1,6 +1,7 @@
 [Unit]
 Description=A service which scan Nextcloud folders
-After=network.target
+After=network.target docker.service
+Requires=docker.service
 
 [Service]
 ExecStart=/usr/bin/ncsambawatcher

configs/smb.24.04.conf

@@ -0,0 +1,48 @@
+[global]
+   vfs objects = full_audit
+   full_audit:prefix = %u|%I|%m|%S
+   full_audit:success = mkdirat unlinkat renameat write
+   full_audit:failure = none
+   full_audit:facility = local5
+   full_audit:priority = NOTICE
+
+# Example usershare
+[<username>] #CHANGEME
+   path = /path/to/nextcloud/data/<username>/files/ #CHANGEME
+   valid users = <username> #CHANGEME
+   force user = www-data
+   force group = www-data
+   create mask = 0755
+   force create mode = 0755
+   directory mask = 0755
+   force directory mode = 0755
+   guest ok = no
+   public = no
+   writable = yes
+   browsable = yes
+   hide dot files = no
+   inherit owner = yes
+   hide unreadable = no
+
+# Example groupfolder share
+[Sharename]
+   path = /path/to/nextcloud/data/__groupfolders/<groupfolder-id> #CHANGEME
+   valid users = usernames #CHANGEME
+   force user = www-data
+   force group = www-data
+   create mask = 0755
+   force create mode = 0755
+   directory mask = 0755
+   force directory mode = 0755
+   guest ok = no
+   public = no
+   writable = yes
+   browsable = yes
+   hide dot files = no
+   inherit owner = yes
+   hide unreadable = no
+   full_audit:prefix = %u|%I|%m|__groupfolders/<groupfolder-id> #CHANGEME
+
+# To disable logs for a specific share, add this line to that share
+[Sharename]
+   vfs objects = 

src/definitions.h

@@ -0,0 +1,11 @@
+#ifndef _LOCATIONS_H
+#define _LOCATIONS_H
+
+#define LOGFILE "journalctl -u smbd --since now -f"
+
+#define USER_LOG_LOCATION 3
+
+#define SCAN_CMD_USR "docker exec --user www-data nextcloud /var/www/html/occ files:scan --path="
+#define SCAN_CMD_GRP "docker exec --user www-data nextcloud /var/www/html/occ groupfolder:scan "
+
+#endif // _LOCATIONS_H

src/guarder.cpp

@@ -1 +0,0 @@
-#include "guarder.h"

src/guarder.h

@@ -1,50 +0,0 @@
-#ifndef _GUARDER_H
-#define _GUARDER_H
-
-#include <sys/types.h>
-#include <sys/shm.h>
-#include <sys/ipc.h>
-
-class guarder{
-private:
-    const int shmid;
-
-    void setFlag(bool value)
-    {
-        bool *flag = static_cast<bool *>(shmat(shmid, nullptr, 0));
-        *flag = value;
-        shmdt(flag);
-    }
-
-public:
-    guarder() : shmid(shmget(IPC_PRIVATE, sizeof(bool), 0666 | IPC_CREAT))
-    {
-        setFlagOff();
-    }
-
-    void setFlagOff()
-    {
-        setFlag(false);
-    }
-
-    void setFlagOn()
-    {
-        setFlag(true);
-    }
-
-    bool isFlagOn()
-    {
-        bool *flag = static_cast<bool *>(shmat(shmid, nullptr, 0));
-        bool ret = *flag;
-        shmdt(flag);
-        return ret;
-    }
-
-    ~guarder()
-    {
-        shmctl(shmid, IPC_RMID, nullptr);
-    }
-
-};
-
-#endif // _GUARDER_H

src/locations.h

@@ -1,8 +0,0 @@
-#ifndef _LOCATIONS_H
-#define _LOCATIONS_H
-
-#define LOGFILE "journalctl -u smbd --since now -f"
-
-#define USER_LOG_LOCATION 3
-
-#endif // _LOCATIONS_H

src/main.cpp

@@ -1,62 +1,23 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/wait.h>
 #include <iostream>
+#include <thread>
+#include <vector>
+#include <set>
 #include <array>
 #include <string>
-#include <vector>
+#include <mutex>
-#include <unistd.h>
+#include <condition_variable>
-#include <sys/types.h>
+#include <cstdio>
-#include <syslog.h>
-#include <fcntl.h>
-#include <signal.h>
-#include "locations.h"
 #include "usermanager.h"
-#include "guarder.h"
 
-#define MAXNAMESIZE 255
-#define SCAN_DONE_SIG SIGRTMIN
-#define SCAN_CMD_USR "docker exec --user www-data nextcloud /var/www/html/occ files:scan --path="
-
-int p1[2];
-guarder guard;
 userManager manager;
+std::condition_variable cv;
+std::mutex mtx;
 
-void flushManagerToPipe()
+void readingThreadFunc()
 {
-    if (!guard.isFlagOn())
-    {
-        std::vector<std::string> users = manager.getFlaggedUsers();
-
-        for (std::vector<std::string>::iterator it = users.begin(); it != users.end(); ++it)
-        {
-            int size = it->size();
-            write(p1[1], &size, sizeof(int));
-            write(p1[1], it->data(), size * sizeof(char));
-        }
-
-        manager.unflagAllUsers();
-    }
-}
-
-void handler(int sig) 
-{
-    if (sig == SCAN_DONE_SIG)
-    {
-        flushManagerToPipe();
-    }
-}
-
-int main()
-{
-    openlog("ncsambawatcher", LOG_PID | LOG_CONS, LOG_USER);
-    pipe(p1);
-
-    pid_t parent = getpid();
-    pid_t child = fork();
-
-    if (child > 0) // parent
-    {
-        signal(SCAN_DONE_SIG, handler);
-        close(p1[0]); // read
-
     FILE *logpipe = popen(LOGFILE, "r");
     std::array<char, 256> buffer;
 
@@ -67,53 +28,73 @@ int main()
         if (line.find('|') == std::string::npos)
             continue;
 
-            std::vector<std::string> x = splitLogFile(line, '|');
+        std::vector<std::string> x = splitString(line, '|');
         std::string user(x.at(USER_LOG_LOCATION));
+
+        {
+            std::lock_guard<std::mutex> lock(mtx);
             manager.addUser(user);
             manager.setUserFlagged(user);
+        }
+
+        cv.notify_one();
 
         std::cout << "User find: " << user << std::endl;
-
-            flushManagerToPipe();
     }
-
+}
-        fclose(logpipe);
+
-        close(p1[1]); // write
+void scannerThreadFunc()
-    }
+{
-    else // child
+    std::unique_lock<std::mutex> lock(mtx);
-    {
+    std::vector<pid_t> childrens;
-        close(p1[1]); // write
+    while (true)
-
+    {
-        int size;
+        cv.wait(lock, []
-        char *buffer = nullptr;
+                { return manager.isAnybodyFlagged(); });
-
+
-        while (read(p1[0], &size, sizeof(int)))
+        std::set<std::string> scanUsers = manager.getFlaggedUsers();
-        {
+        manager.unflagAllUsers();
-            if (buffer == nullptr)
+
-                buffer = new char[size];
+        lock.unlock();
-
+        childrens.clear();
-            read(p1[0], buffer, size * sizeof(char));
+
-            std::string name(buffer);
+        for (const std::string& user : scanUsers)
-
+        {
-            std::cout << "Scan received for: " << name << std::endl;
+            pid_t child = fork();
-
+
-            guard.setFlagOn();
+            if (child < 0)
-            system((std::string(SCAN_CMD_USR) + name).data());
+            {
-            guard.setFlagOff();
+                std::cerr << "Fork failed for: " << user << std::endl;
-
+            }
-            kill(parent, SCAN_DONE_SIG);
+            else if (child == 0) // child
-
+            {
-            if (buffer != nullptr)
+                std::string cmd = userManager::getScanCommandFromUser(user);
-            {
+                execl("/bin/sh", "sh", "-c", cmd.c_str(), static_cast<char *>(nullptr));
-                delete[] buffer;
+                std::cerr << "Scan failed" << std::endl;
-                buffer = nullptr;
+                _exit(EXIT_FAILURE);
-            }
+            }
-        }
+            else // parent
-
+            {
-        close(p1[0]); // read
+                childrens.push_back(child);
-    }
+            }
-
+        }
-    closelog();
+
-
+        for (const pid_t& pid : childrens)
-    return EXIT_SUCCESS;
+        {
+            waitpid(pid, nullptr, 0);
+        }
+
+        lock.lock();
+    }
+}
+
+int main()
+{
+    std::thread readingThread(readingThreadFunc);
+    std::thread scannerThread(scannerThreadFunc);
+
+    readingThread.join();
+    scannerThread.join();
+
+    return 0;
 }

src/usermanager.cpp

@@ -1,9 +1,9 @@
 #include "usermanager.h"
 
-std::vector<std::string> splitLogFile(const std::string& input, char delimiter = '|')
+std::vector<std::string> splitString(const std::string& str, char delimiter = '|')
 {
     std::vector<std::string> ret;
-    std::stringstream ss(input);
+    std::stringstream ss(str);
     std::string token;
 
     while (std::getline(ss, token, delimiter)) {
@@ -12,3 +12,13 @@ std::vector<std::string> splitLogFile(const std::string& input, char delimiter =
 
     return ret;
 }
+
+std::string userManager::getScanCommandFromUser(const std::string &user)
+{
+    if (user.find("__groupfolder") != std::string::npos)
+    {
+        return std::string(SCAN_CMD_GRP) + splitString(user, '/').back();
+    }
+
+    return std::string(SCAN_CMD_USR) + user;
+}

src/usermanager.h

@@ -4,25 +4,31 @@
 #include <string>
 #include <map>
 #include <vector>
+#include <set>
 #include <sstream>
-#include "locations.h"
+#include <mutex>
+#include "definitions.h"
 
-std::vector<std::string> splitLogFile(const std::string& input, char delimiter);
+std::vector<std::string> splitString(const std::string& input, char delimiter);
 
 class userManager
 {
 private:
     std::map<std::string, bool> users;
+    std::mutex mtx;
 
 public:
     
+    static std::string getScanCommandFromUser(const std::string&);
+
     void addUserFromLogLine(std::string &line)
     {
-        addUser(splitLogFile(line, '|').at(USER_LOG_LOCATION));
+        addUser(splitString(line, '|').at(USER_LOG_LOCATION));
     }
 
     void addUser(std::string &user)
     {
+        std::lock_guard<std::mutex> lock(mtx);
         if (users.count(user) == 0)
         {
             users[user] = false;
@@ -31,16 +37,19 @@ public:
 
     void removeUser(std::string &user)
     {
+        std::lock_guard<std::mutex> lock(mtx);
         users.erase(user);
     }
 
     bool isContains(std::string &user)
     {
+        std::lock_guard<std::mutex> lock(mtx);
         return users.count(user) == 1;
     }
 
     void setUserFlagged(std::string &user)
     {
+        std::lock_guard<std::mutex> lock(mtx);
         if (users.count(user) == 1)
         {
             users[user] = true;
@@ -49,6 +58,7 @@ public:
 
     void setUserUnflagged(std::string &user)
     {
+        std::lock_guard<std::mutex> lock(mtx);
         if (users.count(user) == 1)
         {
             users[user] = false;
@@ -57,38 +67,56 @@ public:
 
     void unflagAllUsers()
     {
+        std::lock_guard<std::mutex> lock(mtx);
         for (std::map<std::string, bool>::iterator it = users.begin(); it != users.end(); ++it)
         {
             it->second = false;
         }
     }
 
-    std::vector<std::string> getUsers()
+    std::set<std::string> getUsers()
     {
-        std::vector<std::string> ret;
+        std::set<std::string> ret;
+
+        std::lock_guard<std::mutex> lock(mtx);
 
         for (std::map<std::string, bool>::iterator it = users.begin(); it != users.end(); ++it)
         {
-            ret.push_back(it->first);
+            ret.insert(it->first);
         }
 
         return ret;
     }
 
-    std::vector<std::string> getFlaggedUsers()
+    std::set<std::string> getFlaggedUsers()
     {
-        std::vector<std::string> ret;
+        std::set<std::string> ret;
+
+        std::lock_guard<std::mutex> lock(mtx);
 
         for (std::map<std::string, bool>::iterator it = users.begin(); it != users.end(); ++it)
         {
             if (it->second)
             {
-                ret.push_back(it->first);
+                ret.insert(it->first);
             }
         }
 
         return ret;
     }
+
+    bool isAnybodyFlagged()
+    {
+        std::lock_guard<std::mutex> lock(mtx);
+    
+        for (std::map<std::string, bool>::iterator it = users.begin(); it != users.end(); ++it)
+        {
+            if (it->second)
+                return true;
+        }
+
+        return false;
+    }
 };
 
 #endif // _USERMAN_H