1"""
2Helper for running LibreOffice (soffice) in environments where AF_UNIX
3sockets may be blocked (e.g., sandboxed VMs).  Detects the restriction
4at runtime and applies an LD_PRELOAD shim if needed.
5 
6Usage:
7    from office.soffice import run_soffice, get_soffice_env
8 
9    # Option 1 – run soffice directly
10    result = run_soffice(["--headless", "--convert-to", "pdf", "input.docx"])
11 
12    # Option 2 – get env dict for your own subprocess calls
13    env = get_soffice_env()
14    subprocess.run(["soffice", ...], env=env)
15"""
16 
17import os
18import socket
19import subprocess
20import tempfile
21from pathlib import Path
22 
23 
24def get_soffice_env() -> dict:
25    env = os.environ.copy()
26    env["SAL_USE_VCLPLUGIN"] = "svp"
27 
28    if _needs_shim():
29        shim = _ensure_shim()
30        env["LD_PRELOAD"] = str(shim)
31 
32    return env
33 
34 
35def run_soffice(args: list[str], **kwargs) -> subprocess.CompletedProcess:
36    env = get_soffice_env()
37    return subprocess.run(["soffice"] + args, env=env, **kwargs)
38 
39 
40 
41_SHIM_SO = Path(tempfile.gettempdir()) / "lo_socket_shim.so"
42 
43 
44def _needs_shim() -> bool:
45    try:
46        s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
47        s.close()
48        return False
49    except OSError:
50        return True
51 
52 
53def _ensure_shim() -> Path:
54    if _SHIM_SO.exists():
55        return _SHIM_SO
56 
57    src = Path(tempfile.gettempdir()) / "lo_socket_shim.c"
58    src.write_text(_SHIM_SOURCE)
59    subprocess.run(
60        ["gcc", "-shared", "-fPIC", "-o", str(_SHIM_SO), str(src), "-ldl"],
61        check=True,
62        capture_output=True,
63    )
64    src.unlink()
65    return _SHIM_SO
66 
67 
68 
69_SHIM_SOURCE = r"""
70#define _GNU_SOURCE
71#include <dlfcn.h>
72#include <errno.h>
73#include <signal.h>
74#include <stdio.h>
75#include <stdlib.h>
76#include <sys/socket.h>
77#include <unistd.h>
78 
79static int (*real_socket)(int, int, int);
80static int (*real_socketpair)(int, int, int, int[2]);
81static int (*real_listen)(int, int);
82static int (*real_accept)(int, struct sockaddr *, socklen_t *);
83static int (*real_close)(int);
84static int (*real_read)(int, void *, size_t);
85 
86/* Per-FD bookkeeping (FDs >= 1024 are passed through unshimmed). */
87static int is_shimmed[1024];
88static int peer_of[1024];
89static int wake_r[1024];            /* accept() blocks reading this */
90static int wake_w[1024];            /* close()  writes to this      */
91static int listener_fd = -1;        /* FD that received listen()    */
92 
93__attribute__((constructor))
94static void init(void) {
95    real_socket     = dlsym(RTLD_NEXT, "socket");
96    real_socketpair = dlsym(RTLD_NEXT, "socketpair");
97    real_listen     = dlsym(RTLD_NEXT, "listen");
98    real_accept     = dlsym(RTLD_NEXT, "accept");
99    real_close      = dlsym(RTLD_NEXT, "close");
100    real_read       = dlsym(RTLD_NEXT, "read");
101    for (int i = 0; i < 1024; i++) {
102        peer_of[i] = -1;
103        wake_r[i]  = -1;
104        wake_w[i]  = -1;
105    }
106}
107 
108/* ---- socket ---------------------------------------------------------- */
109int socket(int domain, int type, int protocol) {
110    if (domain == AF_UNIX) {
111        int fd = real_socket(domain, type, protocol);
112        if (fd >= 0) return fd;
113        /* socket(AF_UNIX) blocked – fall back to socketpair(). */
114        int sv[2];
115        if (real_socketpair(domain, type, protocol, sv) == 0) {
116            if (sv[0] >= 0 && sv[0] < 1024) {
117                is_shimmed[sv[0]] = 1;
118                peer_of[sv[0]]    = sv[1];
119                int wp[2];
120                if (pipe(wp) == 0) {
121                    wake_r[sv[0]] = wp[0];
122                    wake_w[sv[0]] = wp[1];
123                }
124            }
125            return sv[0];
126        }
127        errno = EPERM;
128        return -1;
129    }
130    return real_socket(domain, type, protocol);
131}
132 
133/* ---- listen ---------------------------------------------------------- */
134int listen(int sockfd, int backlog) {
135    if (sockfd >= 0 && sockfd < 1024 && is_shimmed[sockfd]) {
136        listener_fd = sockfd;
137        return 0;
138    }
139    return real_listen(sockfd, backlog);
140}
141 
142/* ---- accept ---------------------------------------------------------- */
143int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
144    if (sockfd >= 0 && sockfd < 1024 && is_shimmed[sockfd]) {
145        /* Block until close() writes to the wake pipe. */
146        if (wake_r[sockfd] >= 0) {
147            char buf;
148            real_read(wake_r[sockfd], &buf, 1);
149        }
150        errno = ECONNABORTED;
151        return -1;
152    }
153    return real_accept(sockfd, addr, addrlen);
154}
155 
156/* ---- close ----------------------------------------------------------- */
157int close(int fd) {
158    if (fd >= 0 && fd < 1024 && is_shimmed[fd]) {
159        int was_listener = (fd == listener_fd);
160        is_shimmed[fd] = 0;
161 
162        if (wake_w[fd] >= 0) {              /* unblock accept() */
163            char c = 0;
164            write(wake_w[fd], &c, 1);
165            real_close(wake_w[fd]);
166            wake_w[fd] = -1;
167        }
168        if (wake_r[fd] >= 0) { real_close(wake_r[fd]); wake_r[fd]  = -1; }
169        if (peer_of[fd] >= 0) { real_close(peer_of[fd]); peer_of[fd] = -1; }
170 
171        if (was_listener)
172            _exit(0);                        /* conversion done – exit */
173    }
174    return real_close(fd);
175}
176"""
177 
178 
179 
180if __name__ == "__main__":
181    import sys
182    result = run_soffice(sys.argv[1:])
183    sys.exit(result.returncode)
184