with a daemon I fail to see how we could handle that (other than, well, windowrules)

with a daemon I fail to see how we could handle that (other than, well, windowrules)

Because the window rule applied to the client which just told the demand to spawn a window instead of spawning a window it's self, but the demon isn't affected by the window rule as the demon isn't launched with those rules

i think we should add a window rule for that for something like "global"(e.g. [global; float]). and instead of getting the PID of that proc process(which is what we're doing rn), do something like a pidof to all of processes with the same name

Edit: typo

...what?

right now, exec calls spawn() which calls spawnWithRule() which have

    const uint64_t PROC = spawnRawProc(args, pInitialWorkspace);

...

            g_pConfigManager->addExecRule({r, (unsigned long)PROC});

only applying the rules to the PROC that it have just spawned(assuming PROC is it's PID).

but.. since instead of that proc spawning the program, the proc is communicating with the daemon with IPC, then the daemon will spawn the process, making the addexecrule useless.

so my proposed solution is that we find all the process with same name by it's pid (similar to the pidof program) then apply the rules to all of them. gated by a specifier(such as "global") which should be parsed in the spawnWithRule()(which should do the above), thus the daemon have those rules too, so spawning the program with rules would work.

also, i think we should delete those rules after it's spawned(maybe as a subprocess after a delay?) since the daemon could have a lot of rules that contradict with each other or chaos

how would you match it though?

We create a process with PID X
it finds a server via some random pipe and sends it a request
PID X dies
PID Y opens a window

Usually daemons are the same binary such as thunar's daemon is still thunar but with the --daemon argument

So I suggested applying the rule to all process names the same as PROC(I'm guessing you can directly filter by that or get its proc id after spawn)

but how do we know what is the "name" of pid X?

get it from /proc/pid/comm?

that's not portable

from stackoverflow:

Use the kinfo_getproc function
pid_t pid = ...;
struct kinfo_proc *proc = kinfo_getproc(pid);
if (proc) {
printf("Name %s\n", proc->ki_comm);
//ki_comm should be the program name
//see the sys/user.h header file for other relevant fields.
free(proc);
}

kinfo_getproc doesn't exist on DragonFly, NetBSD, OpenBSD. ki_comm does but named differently (affects the whole struct kinfo_proc, see ki_ppid example in Hyprland). For portability use sysctl directly instead of going through libutil, libkvm, libprocstat.

Note, linprocfs(5) lacks /proc/<pid>/comm (aka argv[0]) unlike /proc/<pid>/cmdline (NUL-separated argv[]). It's easier to test/port the latter e.g., https://gitlab.freedesktop.org/libinput/libei/-/commit/cc046f1f6719