Line data Source code
1 : /*
2 : * Copyright (C) 2025 Andrea Mazzoleni
3 : *
4 : * This program is free software: you can redistribute it and/or modify
5 : * it under the terms of the GNU General Public License as published by
6 : * the Free Software Foundation, either version 3 of the License, or
7 : * (at your option) any later version.
8 : *
9 : * This program is distributed in the hope that it will be useful,
10 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : * GNU General Public License for more details.
13 : *
14 : * You should have received a copy of the GNU General Public License
15 : * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 : */
17 :
18 : #include "portable.h"
19 :
20 : #include "snapraid.h"
21 :
22 : #define MODE_DEFAULT 0
23 : #define MODE_SPINDOWN 1
24 :
25 : #ifdef _WIN32
26 : #define COMMAND_LINE_MAX 32767
27 :
28 : static int needs_quote(const WCHAR* arg)
29 : {
30 : while (*arg) {
31 : if (*arg == L' ' || *arg == L'\t' || *arg == L'"')
32 : return 1;
33 : ++arg;
34 : }
35 :
36 : return 0;
37 : }
38 :
39 : #define charcat(c) \
40 : do { \
41 : if (pos + 1 >= size) \
42 : return -1; \
43 : cmd[pos++] = (c); \
44 : } while (0)
45 :
46 : static int argcat(WCHAR* cmd, int size, int pos, const WCHAR* arg)
47 : {
48 : int has_quote;
49 :
50 : /* space separator */
51 : if (pos != 0)
52 : charcat(L' ');
53 :
54 : has_quote = needs_quote(arg);
55 :
56 : if (!has_quote) {
57 : while (*arg)
58 : charcat(*arg++);
59 : } else {
60 : /* starting quote */
61 : charcat(L'"');
62 :
63 : while (*arg) {
64 : int bl = 0;
65 : while (*arg == L'\\') {
66 : ++arg;
67 : ++bl;
68 : }
69 :
70 : if (*arg == 0) {
71 : /* double backslashes before closing quote */
72 : bl = bl * 2;
73 : while (bl--)
74 : charcat(L'\\');
75 : } else if (*arg == '"') {
76 : /* double backslashes + escape the quote */
77 : bl = bl * 2 + 1;
78 : while (bl--)
79 : charcat(L'\\');
80 : charcat(L'"');
81 : ++arg;
82 : } else {
83 : /* normal backslashes */
84 : while (bl--)
85 : charcat(L'\\');
86 : charcat(*arg);
87 : ++arg;
88 : }
89 : }
90 :
91 : /* ending quote */
92 : charcat(L'"');
93 : }
94 :
95 : return pos;
96 : }
97 :
98 : static char* argutf8(const WCHAR* arg)
99 : {
100 : size_t len = wcslen(arg);
101 : char* utf8_arg;
102 : DWORD utf8_len;
103 : DWORD res;
104 :
105 : utf8_len = WideCharToMultiByte(CP_UTF8, 0, arg, len + 1 /* include final null */, 0, 0, 0, 0);
106 :
107 : utf8_arg = malloc(utf8_len);
108 : if (!utf8_arg)
109 : return 0;
110 :
111 : res = WideCharToMultiByte(CP_UTF8, 0, arg, len + 1 /* include final null */, utf8_arg, utf8_len, 0, 0);
112 : if (res != utf8_len)
113 : return 0;
114 :
115 : return utf8_arg;
116 : }
117 :
118 : /* Global variable to store child process handle */
119 : static HANDLE child_process = NULL;
120 :
121 : /* Console control handler - forwards Ctrl+C, Ctrl+Break to child */
122 : static BOOL WINAPI console_handler(DWORD ctrl_type)
123 : {
124 : /* if no child, default behavior */
125 : if (child_process == NULL)
126 : return FALSE;
127 :
128 : switch (ctrl_type) {
129 : case CTRL_C_EVENT :
130 : case CTRL_BREAK_EVENT :
131 : /*
132 : * Return TRUE to prevent parent termination. The child process
133 : * will receive these events automatically because it's attached
134 : * to the same console, so we don't need to forward them.
135 : */
136 : return TRUE; /* signal handled, don't terminate parent */
137 : case CTRL_CLOSE_EVENT :
138 : case CTRL_LOGOFF_EVENT :
139 : case CTRL_SHUTDOWN_EVENT :
140 : /*
141 : * Return TRUE to prevent our termination while child handles shutdown.
142 : * The child receives these events automatically (same console).
143 : * Note: Windows will forcibly kill us after a timeout regardless
144 : * of returning TRUE: ~5 seconds for CLOSE_EVENT and LOGOFF_EVENT,
145 : * ~5-20 seconds for SHUTDOWN_EVENT (configurable in registry).
146 : */
147 : return TRUE; /* signal handled, but Windows will kill us after timeout */
148 : default :
149 : return FALSE;
150 : }
151 : }
152 :
153 : int main(int argc, char* argv[])
154 : {
155 : int wide_argc;
156 : WCHAR** wide_argv;
157 : int utf8_argc;
158 : char** utf8_argv;
159 : WCHAR app_buffer[COMMAND_LINE_MAX];
160 : WCHAR cmd_buffer[COMMAND_LINE_MAX];
161 : DWORD res;
162 : int i;
163 : int pos;
164 : int mode;
165 : int ret;
166 :
167 : (void)argc;
168 : (void)argv;
169 :
170 : res = GetModuleFileNameW(NULL, app_buffer, sizeof(app_buffer));
171 : if (res == 0 || res >= sizeof(app_buffer)) {
172 : exit(EXIT_FAILURE);
173 : }
174 :
175 : wide_argv = CommandLineToArgvW(GetCommandLineW(), &wide_argc);
176 : if (!wide_argv) {
177 : exit(EXIT_FAILURE);
178 : }
179 :
180 : utf8_argc = 0;
181 : utf8_argv = malloc((wide_argc + 1) * sizeof(void*));
182 : if (!utf8_argv) {
183 : exit(EXIT_FAILURE);
184 : }
185 :
186 : pos = argcat(cmd_buffer, sizeof(cmd_buffer), 0, app_buffer);
187 : if (pos < 0) {
188 : exit(EXIT_FAILURE);
189 : }
190 :
191 : utf8_argv[0] = argutf8(app_buffer);
192 : if (!utf8_argv[0]) {
193 : exit(EXIT_FAILURE);
194 : }
195 : utf8_argc = 1;
196 :
197 : mode = MODE_DEFAULT;
198 : for (i = 1; i < wide_argc; i++) {
199 : if (wcscmp(wide_argv[i], L"-s") == 0 || wcscmp(wide_argv[i], L"--spin-down-on-error") == 0) {
200 : mode = MODE_SPINDOWN;
201 : } else {
202 : pos = argcat(cmd_buffer, sizeof(cmd_buffer), pos, wide_argv[i]);
203 : if (pos < 0) {
204 : exit(EXIT_FAILURE);
205 : }
206 : utf8_argv[utf8_argc] = argutf8(wide_argv[i]);
207 : if (!utf8_argv[utf8_argc]) {
208 : exit(EXIT_FAILURE);
209 : }
210 : ++utf8_argc;
211 : }
212 : }
213 : utf8_argv[utf8_argc] = 0;
214 : cmd_buffer[pos] = 0;
215 :
216 : LocalFree(wide_argv);
217 :
218 : if (mode == MODE_DEFAULT) {
219 : ret = snapraid_main(utf8_argc, utf8_argv);
220 : } else {
221 : STARTUPINFOW si;
222 : PROCESS_INFORMATION pi;
223 : DWORD wait;
224 :
225 : /* install console control handler */
226 : if (!SetConsoleCtrlHandler(console_handler, TRUE)) {
227 : fprintf(stderr, "Failed to set console handler\n");
228 : exit(EXIT_FAILURE);
229 : }
230 :
231 : ZeroMemory(&si, sizeof(si));
232 : si.cb = sizeof(si);
233 : ZeroMemory(&pi, sizeof(pi));
234 :
235 : if (!CreateProcessW(app_buffer, cmd_buffer, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
236 : fprintf(stderr, "Failed to exec SnapRAID\n");
237 : exit(EXIT_FAILURE);
238 : }
239 :
240 : /* store child process handle for signal handler */
241 : child_process = pi.hProcess;
242 :
243 : wait = WaitForSingleObject(pi.hProcess, INFINITE);
244 : if (wait != WAIT_OBJECT_0) {
245 : fprintf(stderr, "WaitForSingleObject failed: %lu\n", (unsigned long)GetLastError());
246 : TerminateProcess(pi.hProcess, 1);
247 : CloseHandle(pi.hThread);
248 : CloseHandle(pi.hProcess);
249 : return 1;
250 : }
251 :
252 : /* clear child process handle */
253 : child_process = NULL;
254 :
255 : if (!GetExitCodeProcess(pi.hProcess, &res)) {
256 : fprintf(stderr, "GetExitCodeProcess failed: %lu\n", (unsigned long)GetLastError());
257 : CloseHandle(pi.hThread);
258 : CloseHandle(pi.hProcess);
259 : return 1;
260 : }
261 :
262 : CloseHandle(pi.hThread);
263 : CloseHandle(pi.hProcess);
264 :
265 : ret = res;
266 :
267 : if (ret != 0) {
268 : char* spindown_argv[3];
269 : spindown_argv[0] = utf8_argv[0];
270 : spindown_argv[1] = "down";
271 : spindown_argv[2] = 0;
272 :
273 : /* sync all disks */
274 : printf("Flush...\n");
275 : if (sync() != 0)
276 : printf("WARNING! Failed to flush disks!\n");
277 :
278 : snapraid_main(2, spindown_argv);
279 : }
280 : }
281 :
282 : for (i = 0; i < utf8_argc; ++i)
283 : free(utf8_argv[i]);
284 : free(utf8_argv);
285 :
286 : return ret;
287 : }
288 : #else
289 :
290 : char full_argv0[PATH_MAX];
291 :
292 1 : const char* get_argv0(const char* argv0)
293 : {
294 1 : ssize_t len = readlink("/proc/self/exe", full_argv0, sizeof(full_argv0) - 1);
295 1 : if (len != -1) {
296 1 : full_argv0[len] = '\0';
297 1 : return full_argv0;
298 : } else {
299 : #ifdef __APPLE__
300 : uint32_t size = sizeof(full_argv0);
301 : if (_NSGetExecutablePath(full_argv0, &size) == 0)
302 : return full_argv0;
303 : #endif
304 : }
305 0 : return argv0;
306 : }
307 :
308 : /* global variable to store child PID for signal handler */
309 : static volatile pid_t child_pid = 0;
310 :
311 : /* signal handler that forwards signals to child */
312 : /* LCOV_EXCL_START */
313 : static void forward_signal(int sig)
314 : {
315 : if (child_pid > 0) {
316 : kill(child_pid, sig);
317 : }
318 : }
319 : /* LCOV_EXCL_STOP */
320 :
321 280 : int main(int argc, char* argv[])
322 : {
323 : int mode;
324 : int i, j;
325 : int ret;
326 :
327 280 : mode = MODE_DEFAULT;
328 280 : j = 1;
329 4192 : for (i = 1; i < argc; ++i) {
330 3912 : if (strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--spin-down-on-error") == 0) {
331 1 : mode = MODE_SPINDOWN;
332 : } else {
333 3911 : argv[j] = argv[i];
334 3911 : ++j;
335 : }
336 : }
337 280 : argc = j;
338 280 : argv[argc] = 0;
339 :
340 280 : if (mode == MODE_DEFAULT) {
341 279 : ret = snapraid_main(argc, argv);
342 : } else {
343 : struct sigaction sa;
344 :
345 : /* set up signal handler to ignore signals */
346 1 : sa.sa_handler = forward_signal;
347 1 : sigemptyset(&sa.sa_mask);
348 1 : sa.sa_flags = SA_RESTART; /* restart interrupted system calls */
349 :
350 : /* install forwarding handler for signals */
351 1 : sigaction(SIGINT, &sa, NULL); /* Ctrl+C */
352 1 : sigaction(SIGQUIT, &sa, NULL); /* Ctrl+\ */
353 1 : sigaction(SIGTERM, &sa, NULL); /* termination */
354 1 : sigaction(SIGHUP, &sa, NULL); /* hangup */
355 1 : sigaction(SIGUSR1, &sa, NULL); /* user-defined 1 */
356 1 : sigaction(SIGUSR2, &sa, NULL); /* user-defined 2 */
357 :
358 1 : pid_t pid = fork();
359 2 : if (pid == -1) {
360 : /* LCOV_EXCL_START */
361 : perror("Failed to fork SnapRAID");
362 : exit(EXIT_FAILURE);
363 : /* LCOV_EXCL_STOP */
364 : }
365 :
366 2 : if (pid == 0) {
367 : /* child process */
368 :
369 : /* restore default signal handlers */
370 1 : signal(SIGINT, SIG_DFL);
371 1 : signal(SIGQUIT, SIG_DFL);
372 1 : signal(SIGTERM, SIG_DFL);
373 1 : signal(SIGHUP, SIG_DFL);
374 1 : signal(SIGUSR1, SIG_DFL);
375 1 : signal(SIGUSR2, SIG_DFL);
376 :
377 1 : execvp(get_argv0(argv[0]), argv);
378 :
379 : /* here it's an error */
380 : /* LCOV_EXCL_START */
381 : perror("Failed to exec SnapRAID");
382 : exit(EXIT_FAILURE);
383 : /* LCOV_EXCL_STOP */
384 : } else {
385 : /* parent process */
386 : int status;
387 :
388 : /* store child PID so signal handler can forward signals */
389 1 : child_pid = pid;
390 :
391 : do {
392 1 : ret = waitpid(pid, &status, 0);
393 1 : } while (ret == -1 && errno == EINTR); /* retry if interrupted by signal */
394 :
395 1 : if (ret == -1) {
396 : /* LCOV_EXCL_START */
397 : perror("Failed to wait for SnapRAID");
398 : exit(EXIT_FAILURE);
399 : /* LCOV_EXCL_STOP */
400 : }
401 :
402 : /* clear child PID */
403 1 : child_pid = 0;
404 :
405 : /* restore default signal handlers */
406 1 : signal(SIGINT, SIG_DFL);
407 1 : signal(SIGQUIT, SIG_DFL);
408 1 : signal(SIGTERM, SIG_DFL);
409 1 : signal(SIGHUP, SIG_DFL);
410 1 : signal(SIGUSR1, SIG_DFL);
411 1 : signal(SIGUSR2, SIG_DFL);
412 :
413 1 : if (WIFEXITED(status)) {
414 1 : ret = WEXITSTATUS(status);
415 0 : } else if (WIFSIGNALED(status)) {
416 : /* terminated by signal */
417 0 : ret = 128 + WTERMSIG(status);
418 : } else {
419 0 : ret = -1;
420 : }
421 :
422 1 : if (ret != 0) {
423 : char* spindown_argv[3];
424 0 : spindown_argv[0] = argv[0];
425 0 : spindown_argv[1] = "down";
426 0 : spindown_argv[2] = 0;
427 :
428 : /* ignore sigpipe to allow spindown even if the terminal is closed */
429 0 : signal(SIGPIPE, SIG_IGN);
430 :
431 : /* sync all disks */
432 0 : printf("Flush...\n");
433 0 : sync();
434 :
435 0 : snapraid_main(2, spindown_argv);
436 : }
437 : }
438 : }
439 :
440 246 : return ret;
441 : }
442 : #endif
|
