### Bug Summary

File: | builds/wireshark/wireshark/wsutil/ws_pipe.c
Warning: | line 651, column 18 Potential leak of memory pointed to by 'argv'

### Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ws_pipe.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-21/lib/clang/21 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -D BUILD_WSUTIL -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_BUILD_DLL -D WS_DEBUG -D WS_DEBUG_UTF_8 -D wsutil_EXPORTS -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/build/wsutil -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-nonliteral -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/wireshark/wireshark/sbout/2026-04-26-100332-3641-1 -x c /builds/wireshark/wireshark/wsutil/ws_pipe.c

Keyboard shortcuts:

- Use 'j/k' keys for keyboard navigation
- Use 'Shift+S' to show/hide relevant lines
- Use '?' to toggle this window

Close
Show only relevant lines Show control flow arrows

1 | /* ws_pipe.c
2 | *
3 | * Routines for handling pipes.
4 | *
5 | * Wireshark - Network traffic analyzer
6 | * By Gerald Combs <gerald@wireshark.org>
7 | * Copyright 1998 Gerald Combs
8 | *
9 | * SPDX-License-Identifier: GPL-2.0-or-later
10 | */
11 |
12 | #include "config.h"
13 | #define WS_LOG_DOMAIN"Capture" LOG_DOMAIN_CAPTURE"Capture"
14 | #include "wsutil/ws_pipe.h"
15 |
16 | #include <stdio.h>
17 | #include <stdlib.h>
18 | #include <string.h>
19 |
20 | #ifdef _WIN32
21 | #include <windows.h>
22 | #include <io.h>
23 | #include <fcntl.h> /* for _O_BINARY */
24 | #include <wsutil/win32-utils.h>
25 | #else
26 | #include <unistd.h>
27 | #ifdef HAVE_SYS_SELECT_H
28 | #include <sys/select.h>
29 | #endif
30 | #endif
31 |
32 | #if !GLIB_CHECK_VERSION(2, 58, 2)(2 > (2) || (2 == (2) && 80 > (58)) || (2 == (2 ) && 80 == (58) && 0 >= (2)))
33 | #ifdef __linux__1
34 | #define HAS_G_SPAWN_LINUX_THREAD_SAFETY_BUG
35 | #include <fcntl.h>
36 | #include <sys/syscall.h> /* for syscall and SYS_getdents64 */
37 | #include <wsutil/file_util.h> /* for ws_open -> open to pacify checkAPIs.pl */
38 | #endif
39 | #endif
40 |
41 | #include "wsutil/filesystem.h"
42 | #include "wsutil/wslog.h"
43 |
44 | #ifdef HAS_G_SPAWN_LINUX_THREAD_SAFETY_BUG
45 | struct linux_dirent64 {
46 | uint64_t d_ino; /* 64-bit inode number */
47 | uint64_t d_off; /* 64-bit offset to next structure */
48 | unsigned short d_reclen; /* Size of this dirent */
49 | unsigned char d_type; /* File type */
50 | char d_name[]; /* Filename (null-terminated) */
51 | };
52 |
53 | /* Async-signal-safe string to integer conversion. */
54 | static int
55 | filename_to_fd(const char *p)
56 | {
57 | char c;
58 | int fd = 0;
59 | const int cutoff = INT_MAX2147483647 / 10;
60 | const int cutlim = INT_MAX2147483647 % 10;
61 |
62 | if (*p == '\0')
63 | return -1;
64 |
65 | while ((c = *p++) != '\0') {
66 | if (!g_ascii_isdigit(c)((g_ascii_table[(guchar) (c)] & G_ASCII_DIGIT) != 0))
67 | return -1;
68 | c -= '0';
69 |
70 | /* Check for overflow. */
71 | if (fd > cutoff || (fd == cutoff && c > cutlim))
72 | return -1;
73 |
74 | fd = fd * 10 + c;
75 | }
76 |
77 | return fd;
78 | }
79 |
80 | static void
81 | close_non_standard_fds_linux(void * user_data _U___attribute__((unused)))
82 | {
83 | /*
84 | * GLib 2.14.2 and newer (up to at least GLib 2.58.1) on Linux with multiple
85 | * threads can deadlock in the child process due to use of opendir (which
86 | * is not async-signal-safe). To avoid this, disable the broken code path
87 | * and manually close file descriptors using async-signal-safe code only.
88 | * Use CLOEXEC to allow reporting of execve errors to the parent via a pipe.
89 | * https://gitlab.gnome.org/GNOME/glib/issues/1014
90 | * https://gitlab.gnome.org/GNOME/glib/merge_requests/490
91 | */
92 | int dir_fd = ws_open("/proc/self/fd", O_RDONLY | O_DIRECTORY);
93 | if (dir_fd >= 0) {
94 | char buf[4096];
95 | int nread, fd;
96 | struct linux_dirent64 *de;
97 |
98 | while ((nread = (int) syscall(SYS_getdents64, dir_fd, buf, sizeof(buf))) > 0) {
99 | for (int pos = 0; pos < nread; pos += de->d_reclen) {
100 | de = (struct linux_dirent64 *)(buf + pos);
101 | fd = filename_to_fd(de->d_name);
102 | if (fd > STDERR_FILENO2 && fd != dir_fd) {
103 | /* Close all other (valid) file descriptors above stderr. */
104 | fcntl(fd, F_SETFD, FD_CLOEXEC);
105 | }
106 | }
107 | }
108 |
109 | close(dir_fd);
110 | } else {
111 | /* Slow fallback in case /proc is not mounted */
112 | for (int fd = STDERR_FILENO2 + 1; fd < getdtablesize(); fd++) {
113 | fcntl(fd, F_SETFD, FD_CLOEXEC);
114 | }
115 | }
116 | }
117 | #endif
118 |
119 | #ifdef _WIN32
120 | static ULONG pipe_serial_number;
121 |
122 | /* Alternative for CreatePipe() where read handle is opened with FILE_FLAG_OVERLAPPED */
123 | static bool_Bool
124 | ws_pipe_create_overlapped_read(HANDLE *read_pipe_handle, HANDLE *write_pipe_handle,
125 | SECURITY_ATTRIBUTES *sa, DWORD suggested_buffer_size)
126 | {
127 | HANDLE read_pipe, write_pipe;
128 | char *name = ws_strdup_printf("\\\\.\\Pipe\\WiresharkWsPipe.%08lx.%08lx",wmem_strdup_printf(((void*)0), "\\\\.\\Pipe\\WiresharkWsPipe.%08lx.%08lx" , GetCurrentProcessId(), InterlockedIncrement((LONG*)&pipe_serial_number ))
129 | GetCurrentProcessId(),wmem_strdup_printf(((void*)0), "\\\\.\\Pipe\\WiresharkWsPipe.%08lx.%08lx" , GetCurrentProcessId(), InterlockedIncrement((LONG*)&pipe_serial_number ))
130 | InterlockedIncrement((LONG*)&pipe_serial_number))wmem_strdup_printf(((void*)0), "\\\\.\\Pipe\\WiresharkWsPipe.%08lx.%08lx" , GetCurrentProcessId(), InterlockedIncrement((LONG*)&pipe_serial_number ));
131 | gunichar2 *wname = g_utf8_to_utf16(name, -1, NULL((void*)0), NULL((void*)0), NULL((void*)0));
132 |
133 | g_free(name);
134 |
135 | read_pipe = CreateNamedPipe(wname, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
136 | PIPE_TYPE_BYTE | PIPE_WAIT, 1,
137 | suggested_buffer_size, suggested_buffer_size,
138 | 0, sa);
139 | if (INVALID_HANDLE_VALUE == read_pipe)
140 | {
141 | g_free(wname);
142 | return false0;
143 | }
144 |
145 | write_pipe = CreateFile(wname, GENERIC_WRITE, 0, sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL((void*)0));
146 | if (INVALID_HANDLE_VALUE == write_pipe)
147 | {
148 | DWORD error = GetLastError();
149 | CloseHandle(read_pipe);
150 | SetLastError(error);
151 | g_free(wname);
152 | return false0;
153 | }
154 |
155 | *read_pipe_handle = read_pipe;
156 | *write_pipe_handle = write_pipe;
157 | g_free(wname);
158 | return true1;
159 | }
160 | #endif
161 |
162 | /**
163 | * Helper to convert a command and argument list to an NULL-terminated 'argv'
164 | * array, suitable for g_spawn_sync and friends. Free with g_strfreev.
165 | */
166 | static char **
167 | convert_to_argv(const char *command, unsigned args_count, char *const *args)
168 | {
169 | char **argv = g_new(char *, (size_t)args_count + 2)((char * *) g_malloc_n (((size_t)args_count + 2), sizeof (char *)));
10 | ← | Memory is allocated | →
170 | // The caller does not seem to modify this, but g_spawn_sync uses 'char **'
171 | // as opposed to 'const char **', so just to be sure clone it.
172 | argv[0] = g_strdup(command)g_strdup_inline (command);
173 | for (unsigned i = 0; i < args_count; i++) {
11 | ← | Assuming 'i' is >= 'args_count' | →
12 | ← | Loop condition is false. Execution continues on line 183 | →
174 | // Empty arguments may indicate a bug in Wireshark. Extcap for example
175 | // omits arguments when their string value is empty. On Windows, empty
176 | // arguments would silently be ignored because protect_arg returns an
177 | // empty string, therefore we print a warning here.
178 | if (!*args[i]) {
179 | ws_warning("Empty argument %u in arguments list", i)do { if (1) { ws_log_full("Capture", LOG_LEVEL_WARNING, "wsutil/ws_pipe.c" , 179, __func__, "Empty argument %u in arguments list", i); } } while (0);
180 | }
181 | argv[1 + i] = g_strdup(args[i])g_strdup_inline (args[i]);
182 | }
183 | argv[args_count + 1] = NULL((void*)0);
184 | return argv;
185 | }
186 |
187 | /**
188 | * Convert a non-empty NULL-terminated array of command and arguments to a
189 | * string for displaying purposes. On Windows, the returned string is properly
190 | * escaped and can be executed directly.
191 | */
192 | static char *
193 | convert_to_command_line(char **argv)
194 | {
195 | GString *command_line = g_string_sized_new(200);
196 | #ifdef _WIN32
197 | // The first argument must always be quoted even if it does not contain
198 | // special characters or else CreateProcess might consider arguments as part
199 | // of the executable.
200 | char *quoted_arg = protect_arg(argv[0]);
201 | if (quoted_arg[0] != '"') {
202 | g_string_append_c(command_line, '"')g_string_append_c_inline (command_line, '"');
203 | g_string_append(command_line, quoted_arg)(__builtin_constant_p (quoted_arg) ? __extension__ ({ const char * const __val = (quoted_arg); g_string_append_len_inline (command_line , __val, (__val != ((void*)0)) ? (gssize) strlen (((__val) + ! (__val))) : (gssize) -1); }) : g_string_append_len_inline (command_line , quoted_arg, (gssize) -1));
204 | g_string_append_c(command_line, '"')g_string_append_c_inline (command_line, '"');
205 | } else {
206 | g_string_append(command_line, quoted_arg)(__builtin_constant_p (quoted_arg) ? __extension__ ({ const char * const __val = (quoted_arg); g_string_append_len_inline (command_line , __val, (__val != ((void*)0)) ? (gssize) strlen (((__val) + ! (__val))) : (gssize) -1); }) : g_string_append_len_inline (command_line , quoted_arg, (gssize) -1));
207 | }
208 | g_free(quoted_arg);
209 |
210 | for (int i = 1; argv[i]; i++) {
211 | quoted_arg = protect_arg(argv[i]);
212 | g_string_append_c(command_line, ' ')g_string_append_c_inline (command_line, ' ');
213 | g_string_append(command_line, quoted_arg)(__builtin_constant_p (quoted_arg) ? __extension__ ({ const char * const __val = (quoted_arg); g_string_append_len_inline (command_line , __val, (__val != ((void*)0)) ? (gssize) strlen (((__val) + ! (__val))) : (gssize) -1); }) : g_string_append_len_inline (command_line , quoted_arg, (gssize) -1));
214 | g_free(quoted_arg);
215 | }
216 | #else
217 | for (int i = 0; argv[i]; i++) {
218 | char *quoted_arg = g_shell_quote(argv[i]);
219 | if (i != 0) {
220 | g_string_append_c(command_line, ' ')g_string_append_c_inline (command_line, ' ');
221 | }
222 | g_string_append(command_line, quoted_arg)(__builtin_constant_p (quoted_arg) ? __extension__ ({ const char * const __val = (quoted_arg); g_string_append_len_inline (command_line , __val, (__val != ((void*)0)) ? (gssize) strlen (((__val) + ! (__val))) : (gssize) -1); }) : g_string_append_len_inline (command_line , quoted_arg, (gssize) -1));
223 | g_free(quoted_arg);
224 | }
225 | #endif
226 | return g_string_free(command_line, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((command_line ), ((0))) : g_string_free_and_steal (command_line)) : (g_string_free ) ((command_line), ((0))));
15 | ← | Loop condition is false. Execution continues on line 226 | →
16 | ← | '?' condition is false | →
17 | ← | Returning without deallocating memory or storing the pointer for later deallocation | →
227 | }
228 |
229 | bool_Bool ws_pipe_spawn_sync(const char *working_directory, const char *command, unsigned argc, char **args, char **command_output)
230 | {
231 | bool_Bool status = false0;
232 | bool_Bool result = false0;
233 | char *local_output = NULL((void*)0);
234 | #ifdef _WIN32
235 |
236 | #define BUFFER_SIZE 16384
237 |
238 | STARTUPINFO info;
239 | PROCESS_INFORMATION processInfo;
240 |
241 | SECURITY_ATTRIBUTES sa;
242 | HANDLE child_stdout_rd = NULL((void*)0);
243 | HANDLE child_stdout_wr = NULL((void*)0);
244 | HANDLE child_stderr_rd = NULL((void*)0);
245 | HANDLE child_stderr_wr = NULL((void*)0);
246 | HANDLE inherit_handles[2];
247 |
248 | OVERLAPPED stdout_overlapped;
249 | OVERLAPPED stderr_overlapped;
250 | #else
251 | int exit_status = 0;
252 | #endif
253 |
254 | char **argv = convert_to_argv(command, argc, args);
255 | char *command_line = convert_to_command_line(argv);
256 |
257 | ws_debug("command line: %s", command_line)do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 257, __func__, "command line: %s", command_line); } } while (0);
258 |
259 | int64_t start_time = g_get_monotonic_time();
260 |
261 | #ifdef _WIN32
262 | /* Setup overlapped structures. Create Manual Reset events, initially not signalled */
263 | memset(&stdout_overlapped, 0, sizeof(OVERLAPPED));
264 | memset(&stderr_overlapped, 0, sizeof(OVERLAPPED));
265 | stdout_overlapped.hEvent = CreateEvent(NULL((void*)0), true1, false0, NULL((void*)0));
266 | if (!stdout_overlapped.hEvent)
267 | {
268 | g_free(command_line);
269 | g_strfreev(argv);
270 | ws_debug("Could not create stdout overlapped event")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 270, __func__, "Could not create stdout overlapped event"); } } while (0);
271 | return false0;
272 | }
273 | stderr_overlapped.hEvent = CreateEvent(NULL((void*)0), true1, false0, NULL((void*)0));
274 | if (!stderr_overlapped.hEvent)
275 | {
276 | CloseHandle(stdout_overlapped.hEvent);
277 | g_free(command_line);
278 | g_strfreev(argv);
279 | ws_debug("Could not create stderr overlapped event")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 279, __func__, "Could not create stderr overlapped event"); } } while (0);
280 | return false0;
281 | }
282 |
283 | memset(&sa, 0, sizeof(SECURITY_ATTRIBUTES));
284 | sa.nLength = sizeof(SECURITY_ATTRIBUTES);
285 | sa.bInheritHandle = false0;
286 | sa.lpSecurityDescriptor = NULL((void*)0);
287 |
288 | if (!ws_pipe_create_overlapped_read(&child_stdout_rd, &child_stdout_wr, &sa, 0))
289 | {
290 | CloseHandle(stdout_overlapped.hEvent);
291 | CloseHandle(stderr_overlapped.hEvent);
292 | g_free(command_line);
293 | g_strfreev(argv);
294 | ws_debug("Could not create stdout handle")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 294, __func__, "Could not create stdout handle"); } } while (0);
295 | return false0;
296 | }
297 |
298 | if (!ws_pipe_create_overlapped_read(&child_stderr_rd, &child_stderr_wr, &sa, 0))
299 | {
300 | CloseHandle(stdout_overlapped.hEvent);
301 | CloseHandle(stderr_overlapped.hEvent);
302 | CloseHandle(child_stdout_rd);
303 | CloseHandle(child_stdout_wr);
304 | g_free(command_line);
305 | g_strfreev(argv);
306 | ws_debug("Could not create stderr handle")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 306, __func__, "Could not create stderr handle"); } } while (0);
307 | return false0;
308 | }
309 |
310 | inherit_handles[0] = child_stderr_wr;
311 | inherit_handles[1] = child_stdout_wr;
312 |
313 | memset(&processInfo, 0, sizeof(PROCESS_INFORMATION));
314 | memset(&info, 0, sizeof(STARTUPINFO));
315 |
316 | info.cb = sizeof(STARTUPINFO);
317 | info.hStdError = child_stderr_wr;
318 | info.hStdOutput = child_stdout_wr;
319 | info.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
320 | info.wShowWindow = SW_HIDE;
321 |
322 | if (win32_create_process(NULL((void*)0), command_line, NULL((void*)0), NULL((void*)0), G_N_ELEMENTS(inherit_handles)(sizeof (inherit_handles) / sizeof ((inherit_handles)[0])), inherit_handles,
323 | CREATE_NEW_CONSOLE, NULL((void*)0), working_directory, &info, &processInfo))
324 | {
325 | char* stdout_buffer = (char*)g_malloc(BUFFER_SIZE);
326 | char* stderr_buffer = (char*)g_malloc(BUFFER_SIZE);
327 | DWORD dw;
328 | DWORD bytes_read;
329 | GString *output_string = g_string_new(NULL((void*)0));
330 | bool_Bool process_finished = false0;
331 | bool_Bool pending_stdout = true1;
332 | bool_Bool pending_stderr = true1;
333 |
334 | /* Start asynchronous reads from child process stdout and stderr */
335 | if (!ReadFile(child_stdout_rd, stdout_buffer, BUFFER_SIZE, NULL((void*)0), &stdout_overlapped))
336 | {
337 | if (GetLastError() != ERROR_IO_PENDING)
338 | {
339 | ws_debug("ReadFile on child stdout pipe failed. Error %ld", GetLastError())do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 339, __func__, "ReadFile on child stdout pipe failed. Error %ld" , GetLastError()); } } while (0);
340 | pending_stdout = false0;
341 | }
342 | }
343 |
344 | if (!ReadFile(child_stderr_rd, stderr_buffer, BUFFER_SIZE, NULL((void*)0), &stderr_overlapped))
345 | {
346 | if (GetLastError() != ERROR_IO_PENDING)
347 | {
348 | ws_debug("ReadFile on child stderr pipe failed. Error %ld", GetLastError())do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 348, __func__, "ReadFile on child stderr pipe failed. Error %ld" , GetLastError()); } } while (0);
349 | pending_stderr = false0;
350 | }
351 | }
352 |
353 | for (;;)
354 | {
355 | HANDLE handles[3];
356 | DWORD n_handles = 0;
357 | if (!process_finished)
358 | {
359 | handles[n_handles++] = processInfo.hProcess;
360 | }
361 | if (pending_stdout)
362 | {
363 | handles[n_handles++] = stdout_overlapped.hEvent;
364 | }
365 | if (pending_stderr)
366 | {
367 | handles[n_handles++] = stderr_overlapped.hEvent;
368 | }
369 |
370 | if (!n_handles)
371 | {
372 | /* No more things to wait */
373 | break;
374 | }
375 |
376 | dw = WaitForMultipleObjects(n_handles, handles, false0, INFINITE);
377 | if (dw < (WAIT_OBJECT_0 + n_handles))
378 | {
379 | int i = dw - WAIT_OBJECT_0;
380 | if (handles[i] == processInfo.hProcess)
381 | {
382 | /* Process finished but there might still be unread data in the pipe.
383 | * Close the write pipes, so ReadFile does not wait indefinitely.
384 | */
385 | CloseHandle(child_stdout_wr);
386 | CloseHandle(child_stderr_wr);
387 | process_finished = true1;
388 | }
389 | else if (handles[i] == stdout_overlapped.hEvent)
390 | {
391 | bytes_read = 0;
392 | if (!GetOverlappedResult(child_stdout_rd, &stdout_overlapped, &bytes_read, true1))
393 | {
394 | if (GetLastError() == ERROR_BROKEN_PIPE)
395 | {
396 | pending_stdout = false0;
397 | continue;
398 | }
399 | ws_debug("GetOverlappedResult on stdout failed. Error %ld", GetLastError())do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 399, __func__, "GetOverlappedResult on stdout failed. Error %ld" , GetLastError()); } } while (0);
400 | }
401 | if (process_finished && (bytes_read == 0))
402 | {
403 | /* We have drained the pipe and there isn't any process that holds active write handle to the pipe. */
404 | pending_stdout = false0;
405 | continue;
406 | }
407 | g_string_append_len(output_string, stdout_buffer, bytes_read)g_string_append_len_inline (output_string, stdout_buffer, bytes_read );
408 | if (!ReadFile(child_stdout_rd, stdout_buffer, BUFFER_SIZE, NULL((void*)0), &stdout_overlapped))
409 | {
410 | if (GetLastError() != ERROR_IO_PENDING)
411 | {
412 | ws_debug("ReadFile on child stdout pipe failed. Error %ld", GetLastError())do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 412, __func__, "ReadFile on child stdout pipe failed. Error %ld" , GetLastError()); } } while (0);
413 | pending_stdout = false0;
414 | }
415 | }
416 | }
417 | else if (handles[i] == stderr_overlapped.hEvent)
418 | {
419 | /* Discard the stderr data just like non-windows version of this function does. */
420 | bytes_read = 0;
421 | if (!GetOverlappedResult(child_stderr_rd, &stderr_overlapped, &bytes_read, true1))
422 | {
423 | if (GetLastError() == ERROR_BROKEN_PIPE)
424 | {
425 | pending_stderr = false0;
426 | continue;
427 | }
428 | ws_debug("GetOverlappedResult on stderr failed. Error %ld", GetLastError())do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 428, __func__, "GetOverlappedResult on stderr failed. Error %ld" , GetLastError()); } } while (0);
429 | }
430 | if (process_finished && (bytes_read == 0))
431 | {
432 | pending_stderr = false0;
433 | continue;
434 | }
435 | if (!ReadFile(child_stderr_rd, stderr_buffer, BUFFER_SIZE, NULL((void*)0), &stderr_overlapped))
436 | {
437 | if (GetLastError() != ERROR_IO_PENDING)
438 | {
439 | ws_debug("ReadFile on child stderr pipe failed. Error %ld", GetLastError())do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 439, __func__, "ReadFile on child stderr pipe failed. Error %ld" , GetLastError()); } } while (0);
440 | pending_stderr = false0;
441 | }
442 | }
443 | }
444 | }
445 | else
446 | {
447 | ws_debug("WaitForMultipleObjects returned 0x%08lX. Error %ld", dw, GetLastError())do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 447, __func__, "WaitForMultipleObjects returned 0x%08lX. Error %ld" , dw, GetLastError()); } } while (0);
448 | }
449 | }
450 |
451 | g_free(stdout_buffer);
452 | g_free(stderr_buffer);
453 |
454 | status = GetExitCodeProcess(processInfo.hProcess, &dw);
455 | if (status && dw != 0)
456 | {
457 | status = false0;
458 | }
459 |
460 | local_output = g_string_free(output_string, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((output_string ), ((0))) : g_string_free_and_steal (output_string)) : (g_string_free ) ((output_string), ((0))));
461 |
462 | CloseHandle(child_stdout_rd);
463 | CloseHandle(child_stderr_rd);
464 |
465 | CloseHandle(processInfo.hProcess);
466 | CloseHandle(processInfo.hThread);
467 | }
468 | else
469 | {
470 | status = false0;
471 |
472 | CloseHandle(child_stdout_rd);
473 | CloseHandle(child_stdout_wr);
474 | CloseHandle(child_stderr_rd);
475 | CloseHandle(child_stderr_wr);
476 | }
477 |
478 | CloseHandle(stdout_overlapped.hEvent);
479 | CloseHandle(stderr_overlapped.hEvent);
480 | #else
481 |
482 | GSpawnFlags flags = (GSpawnFlags)0;
483 | GSpawnChildSetupFunc child_setup = NULL((void*)0);
484 | #ifdef HAS_G_SPAWN_LINUX_THREAD_SAFETY_BUG
485 | flags = (GSpawnFlags)(flags | G_SPAWN_LEAVE_DESCRIPTORS_OPEN);
486 | child_setup = close_non_standard_fds_linux;
487 | #endif
488 | status = g_spawn_sync(working_directory, argv, NULL((void*)0),
489 | flags, child_setup, NULL((void*)0), &local_output, NULL((void*)0), &exit_status, NULL((void*)0));
490 |
491 | if (status && exit_status != 0)
492 | status = false0;
493 | #endif
494 |
495 | ws_debug("%s finished in %.3fms", argv[0], (g_get_monotonic_time() - start_time) / 1000.0)do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 495, __func__, "%s finished in %.3fms", argv[0], (g_get_monotonic_time () - start_time) / 1000.0); } } while (0);
496 |
497 | if (status)
498 | {
499 | if (local_output != NULL((void*)0)) {
500 | ws_noisy("spawn output: %s", local_output)do { if (1) { ws_log_full("Capture", LOG_LEVEL_NOISY, "wsutil/ws_pipe.c" , 500, __func__, "spawn output: %s", local_output); } } while (0);
501 | if (command_output != NULL((void*)0))
502 | *command_output = g_strdup(local_output)g_strdup_inline (local_output);
503 | }
504 | result = true1;
505 | }
506 |
507 | g_free(local_output);
508 | g_free(command_line);
509 | g_strfreev(argv);
510 |
511 | return result;
512 | }
513 |
514 | void ws_pipe_init(ws_pipe_t *ws_pipe)
515 | {
516 | if (!ws_pipe) return;
517 | memset(ws_pipe, 0, sizeof(ws_pipe_t));
518 | ws_pipe->pid = WS_INVALID_PID-1;
519 | }
520 |
521 | GPid ws_pipe_spawn_async(ws_pipe_t *ws_pipe, GPtrArray *args)
522 | {
523 | GPid pid = WS_INVALID_PID-1;
524 | int stdin_fd, stdout_fd, stderr_fd;
525 | #ifdef _WIN32
526 | STARTUPINFO info;
527 | PROCESS_INFORMATION processInfo;
528 |
529 | SECURITY_ATTRIBUTES sa;
530 | HANDLE child_stdin_rd = NULL((void*)0);
531 | HANDLE child_stdin_wr = NULL((void*)0);
532 | HANDLE child_stdout_rd = NULL((void*)0);
533 | HANDLE child_stdout_wr = NULL((void*)0);
534 | HANDLE child_stderr_rd = NULL((void*)0);
535 | HANDLE child_stderr_wr = NULL((void*)0);
536 | HANDLE inherit_handles[3];
537 | #endif
538 |
539 | // XXX harmonize handling of command arguments for the sync/async functions
540 | // and make them const? This array ends with a trailing NULL by the way.
541 | char **args_array = (char **)args->pdata;
542 |
543 | // args must include command itself
544 | ws_return_val_if(args->len < 1, WS_INVALID_PID)do { if (1 && (args->len < 1)) { ws_log_full("InvalidArg" , LOG_LEVEL_WARNING, "wsutil/ws_pipe.c", 544, __func__, "invalid argument: %s" , "args->len < 1"); return (-1); } } while (0);
1 | Assuming field 'len' is >= 1 | →
2 | ← | Taking false branch | →
545 | ws_return_val_if(!args_array[0], WS_INVALID_PID)do { if (1 && (!args_array[0])) { ws_log_full("InvalidArg" , LOG_LEVEL_WARNING, "wsutil/ws_pipe.c", 545, __func__, "invalid argument: %s" , "!args_array[0]"); return (-1); } } while (0);
3 | ← | Loop condition is false. Exiting loop | →
4 | ← | Assuming the condition is false | →
5 | ← | Taking false branch | →
6 | ← | Loop condition is false. Exiting loop | →
546 |
547 | unsigned args_count = args->len - 2;
548 | if (args_array[args->len - 1] != NULL((void*)0)) {
7 | ← | Assuming the condition is false | →
8 | ← | Taking false branch | →
549 | ws_warning("args should be NULL-terminated")do { if (1) { ws_log_full("Capture", LOG_LEVEL_WARNING, "wsutil/ws_pipe.c" , 549, __func__, "args should be NULL-terminated"); } } while (0);
550 | args_count = args->len - 1;
551 | }
552 | char **argv = convert_to_argv(args_array[0], args_count, args_array + 1);
9 | ← | Calling 'convert_to_argv' | →
13 | ← | Returned allocated memory | →
553 | char *command_line = convert_to_command_line(argv);
14 | ← | Calling 'convert_to_command_line' | →
18 | ← | Returning from 'convert_to_command_line' | →
554 |
555 | ws_debug("command line: %s", command_line)do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 555, __func__, "command line: %s", command_line); } } while (0);
19 | ← | Taking true branch | →
20 | ← | Loop condition is false. Exiting loop | →
556 |
557 | #ifdef _WIN32
558 | sa.nLength = sizeof(SECURITY_ATTRIBUTES);
559 | sa.bInheritHandle = false0;
560 | sa.lpSecurityDescriptor = NULL((void*)0);
561 |
562 | if (!CreatePipe(&child_stdin_rd, &child_stdin_wr, &sa, 0))
563 | {
564 | g_free(command_line);
565 | g_strfreev(argv);
566 | ws_debug("Could not create stdin handle")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 566, __func__, "Could not create stdin handle"); } } while ( 0);
567 | return WS_INVALID_PID-1;
568 | }
569 |
570 | if (!CreatePipe(&child_stdout_rd, &child_stdout_wr, &sa, 0))
571 | {
572 | CloseHandle(child_stdin_rd);
573 | CloseHandle(child_stdin_wr);
574 | g_free(command_line);
575 | g_strfreev(argv);
576 | ws_debug("Could not create stdout handle")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 576, __func__, "Could not create stdout handle"); } } while (0);
577 | return WS_INVALID_PID-1;
578 | }
579 |
580 | if (!CreatePipe(&child_stderr_rd, &child_stderr_wr, &sa, 0))
581 | {
582 | CloseHandle(child_stdin_rd);
583 | CloseHandle(child_stdin_wr);
584 | CloseHandle(child_stdout_rd);
585 | CloseHandle(child_stdout_wr);
586 | g_free(command_line);
587 | g_strfreev(argv);
588 | ws_debug("Could not create stderr handle")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 588, __func__, "Could not create stderr handle"); } } while (0);
589 | return WS_INVALID_PID-1;
590 | }
591 |
592 | inherit_handles[0] = child_stdin_rd;
593 | inherit_handles[1] = child_stderr_wr;
594 | inherit_handles[2] = child_stdout_wr;
595 |
596 | memset(&processInfo, 0, sizeof(PROCESS_INFORMATION));
597 | memset(&info, 0, sizeof(STARTUPINFO));
598 |
599 | info.cb = sizeof(STARTUPINFO);
600 | info.hStdInput = child_stdin_rd;
601 | info.hStdError = child_stderr_wr;
602 | info.hStdOutput = child_stdout_wr;
603 | info.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
604 | info.wShowWindow = SW_HIDE;
605 |
606 | if (win32_create_process(NULL((void*)0), command_line, NULL((void*)0), NULL((void*)0), G_N_ELEMENTS(inherit_handles)(sizeof (inherit_handles) / sizeof ((inherit_handles)[0])), inherit_handles,
607 | CREATE_NEW_CONSOLE, NULL((void*)0), NULL((void*)0), &info, &processInfo))
608 | {
609 | stdin_fd = _open_osfhandle((intptr_t)(child_stdin_wr), _O_BINARY);
610 | stdout_fd = _open_osfhandle((intptr_t)(child_stdout_rd), _O_BINARY);
611 | stderr_fd = _open_osfhandle((intptr_t)(child_stderr_rd), _O_BINARY);
612 | pid = processInfo.hProcess;
613 | CloseHandle(processInfo.hThread);
614 | }
615 | else
616 | {
617 | CloseHandle(child_stdin_wr);
618 | CloseHandle(child_stdout_rd);
619 | CloseHandle(child_stderr_rd);
620 | }
621 |
622 | /* We no longer need other (child) end of pipes. The child process holds
623 | * its own handles that will be closed on process exit. However, we have
624 | * to close *our* handles as otherwise read() on stdout_fd and stderr_fd
625 | * will block indefinitely after the process exits.
626 | */
627 | CloseHandle(child_stdin_rd);
628 | CloseHandle(child_stdout_wr);
629 | CloseHandle(child_stderr_wr);
630 | #else
631 |
632 | GError *error = NULL((void*)0);
633 | GSpawnFlags flags = G_SPAWN_DO_NOT_REAP_CHILD;
634 | GSpawnChildSetupFunc child_setup = NULL((void*)0);
635 | #ifdef HAS_G_SPAWN_LINUX_THREAD_SAFETY_BUG
636 | flags = (GSpawnFlags)(flags | G_SPAWN_LEAVE_DESCRIPTORS_OPEN);
637 | child_setup = close_non_standard_fds_linux;
638 | #endif
639 | bool_Bool spawned = g_spawn_async_with_pipes(NULL((void*)0), argv, NULL((void*)0),
640 | flags, child_setup, NULL((void*)0),
641 | &pid, &stdin_fd, &stdout_fd, &stderr_fd, &error);
642 | if (!spawned) {
21 | ← | Assuming 'spawned' is true | →
22 | ← | Taking false branch | →
643 | ws_debug("Error creating async pipe: %s", error->message)do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 643, __func__, "Error creating async pipe: %s", error->message ); } } while (0);
644 | g_free(error->message);
645 | }
646 | #endif
647 |
648 | g_free(command_line);
649 | g_strfreev(argv);
650 |
651 | ws_pipe->pid = pid;
23 | ← | Potential leak of memory pointed to by 'argv'
652 |
653 | if (pid != WS_INVALID_PID-1) {
654 | #ifdef _WIN32
655 | ws_pipe->stdin_io = g_io_channel_win32_new_fd(stdin_fd);
656 | ws_pipe->stdout_io = g_io_channel_win32_new_fd(stdout_fd);
657 | ws_pipe->stderr_io = g_io_channel_win32_new_fd(stderr_fd);
658 | #else
659 | ws_pipe->stdin_io = g_io_channel_unix_new(stdin_fd);
660 | ws_pipe->stdout_io = g_io_channel_unix_new(stdout_fd);
661 | ws_pipe->stderr_io = g_io_channel_unix_new(stderr_fd);
662 | #endif
663 | g_io_channel_set_encoding(ws_pipe->stdin_io, NULL((void*)0), NULL((void*)0));
664 | g_io_channel_set_encoding(ws_pipe->stdout_io, NULL((void*)0), NULL((void*)0));
665 | g_io_channel_set_encoding(ws_pipe->stderr_io, NULL((void*)0), NULL((void*)0));
666 | g_io_channel_set_buffered(ws_pipe->stdin_io, false0);
667 | g_io_channel_set_buffered(ws_pipe->stdout_io, false0);
668 | g_io_channel_set_buffered(ws_pipe->stderr_io, false0);
669 | g_io_channel_set_close_on_unref(ws_pipe->stdin_io, true1);
670 | g_io_channel_set_close_on_unref(ws_pipe->stdout_io, true1);
671 | g_io_channel_set_close_on_unref(ws_pipe->stderr_io, true1);
672 | }
673 |
674 | return pid;
675 | }
676 |
677 | #ifdef _WIN32
678 |
679 | typedef struct
680 | {
681 | HANDLE pipeHandle;
682 | OVERLAPPED ol;
683 | BOOL pendingIO;
684 | } PIPEINTS;
685 |
686 | bool_Bool
687 | ws_pipe_wait_for_pipe(HANDLE * pipe_handles, int num_pipe_handles, HANDLE pid)
688 | {
689 | PIPEINTS pipeinsts[3];
690 | HANDLE handles[4];
691 | bool_Bool result = true1;
692 |
693 | SecureZeroMemory(pipeinsts, sizeof(pipeinsts));
694 |
695 | if (num_pipe_handles == 0 || num_pipe_handles > 3)
696 | {
697 | ws_debug("Invalid number of pipes given as argument.")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 697, __func__, "Invalid number of pipes given as argument." ); } } while (0);
698 | return false0;
699 | }
700 |
701 | for (int i = 0; i < num_pipe_handles; ++i)
702 | {
703 | pipeinsts[i].ol.hEvent = CreateEvent(NULL((void*)0), true1, false0, NULL((void*)0));
704 | if (!pipeinsts[i].ol.hEvent)
705 | {
706 | ws_debug("Could not create overlapped event")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 706, __func__, "Could not create overlapped event"); } } while (0);
707 | for (int j = 0; j < i; j++)
708 | {
709 | CloseHandle(pipeinsts[j].ol.hEvent);
710 | }
711 | return false0;
712 | }
713 | }
714 |
715 | for (int i = 0; i < num_pipe_handles; ++i)
716 | {
717 | pipeinsts[i].pipeHandle = pipe_handles[i];
718 | pipeinsts[i].ol.Pointer = 0;
719 | pipeinsts[i].pendingIO = false0;
720 | if (!ConnectNamedPipe(pipeinsts[i].pipeHandle, &pipeinsts[i].ol))
721 | {
722 | DWORD error = GetLastError();
723 | switch (error)
724 | {
725 | case ERROR_IO_PENDING:
726 | pipeinsts[i].pendingIO = true1;
727 | break;
728 |
729 | case ERROR_PIPE_CONNECTED:
730 | SetEvent(pipeinsts[i].ol.hEvent);
731 | break;
732 |
733 | default:
734 | ws_debug("ConnectNamedPipe failed with %ld\n.", error)do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 734, __func__, "ConnectNamedPipe failed with %ld\n.", error ); } } while (0);
735 | result = false0;
736 | }
737 | }
738 | }
739 |
740 | while (result)
741 | {
742 | DWORD dw;
743 | int num_handles = 0;
744 | for (int i = 0; i < num_pipe_handles; ++i)
745 | {
746 | if (pipeinsts[i].pendingIO)
747 | {
748 | handles[num_handles] = pipeinsts[i].ol.hEvent;
749 | num_handles++;
750 | }
751 | }
752 | if (num_handles == 0)
753 | {
754 | /* All pipes have been successfully connected */
755 | break;
756 | }
757 | /* Wait for process in case it exits before the pipes have connected */
758 | handles[num_handles] = pid;
759 | num_handles++;
760 |
761 | dw = WaitForMultipleObjects(num_handles, handles, false0, 30000);
762 | int handle_idx = dw - WAIT_OBJECT_0;
763 | if (dw == WAIT_TIMEOUT)
764 | {
765 | ws_debug("extcap didn't connect to pipe within 30 seconds.")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 765, __func__, "extcap didn't connect to pipe within 30 seconds." ); } } while (0);
766 | result = false0;
767 | break;
768 | }
769 | // If index points to our handles array
770 | else if (handle_idx >= 0 && handle_idx < num_handles)
771 | {
772 | if (handles[handle_idx] == pid)
773 | {
774 | ws_debug("extcap terminated without connecting to pipe.")do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 774, __func__, "extcap terminated without connecting to pipe." ); } } while (0);
775 | result = false0;
776 | }
777 | for (int i = 0; i < num_pipe_handles; ++i)
778 | {
779 | if (handles[handle_idx] == pipeinsts[i].ol.hEvent)
780 | {
781 | DWORD cbRet;
782 | BOOL success = GetOverlappedResult(
783 | pipeinsts[i].pipeHandle, // handle to pipe
784 | &pipeinsts[i].ol, // OVERLAPPED structure
785 | &cbRet, // bytes transferred
786 | true1); // wait
787 | if (!success)
788 | {
789 | ws_debug("Error %ld \n.", GetLastError())do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 789, __func__, "Error %ld \n.", GetLastError()); } } while ( 0);
790 | result = false0;
791 | }
792 | pipeinsts[i].pendingIO = false0;
793 | }
794 | }
795 | }
796 | else
797 | {
798 | ws_debug("WaitForMultipleObjects returned 0x%08lX. Error %ld", dw, GetLastError())do { if (1) { ws_log_full("Capture", LOG_LEVEL_DEBUG, "wsutil/ws_pipe.c" , 798, __func__, "WaitForMultipleObjects returned 0x%08lX. Error %ld" , dw, GetLastError()); } } while (0);
799 | result = false0;
800 | }
801 | }
802 |
803 | for (int i = 0; i < num_pipe_handles; ++i)
804 | {
805 | if (pipeinsts[i].pendingIO)
806 | {
807 | CancelIoEx(pipeinsts[i].pipeHandle, &pipeinsts[i].ol);
808 | WaitForSingleObject(pipeinsts[i].ol.hEvent, INFINITE);
809 | }
810 | CloseHandle(pipeinsts[i].ol.hEvent);
811 | }
812 |
813 | return result;
814 | }
815 | #endif
816 |
817 | bool_Bool
818 | ws_pipe_data_available(int pipe_fd)
819 | {
820 | #ifdef _WIN32 /* PeekNamedPipe */
821 | HANDLE hPipe = (HANDLE) _get_osfhandle(pipe_fd);
822 | DWORD bytes_avail;
823 |
824 | if (hPipe == INVALID_HANDLE_VALUE)
825 | {
826 | return false0;
827 | }
828 |
829 | if (! PeekNamedPipe(hPipe, NULL((void*)0), 0, NULL((void*)0), &bytes_avail, NULL((void*)0)))
830 | {
831 | return false0;
832 | }
833 |
834 | if (bytes_avail > 0)
835 | {
836 | return true1;
837 | }
838 | return false0;
839 | #else /* select */
840 | fd_set rfds;
841 | struct timeval timeout;
842 |
843 | FD_ZERO(&rfds)do { unsigned int __i; fd_set *__arr = (&rfds); for (__i = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr )->__fds_bits)[__i] = 0; } while (0);
844 | FD_SET(pipe_fd, &rfds)((void) (((&rfds)->__fds_bits)[((pipe_fd) / (8 * (int) sizeof (__fd_mask)))] |= ((__fd_mask) (1UL << ((pipe_fd ) % (8 * (int) sizeof (__fd_mask)))))));
845 | timeout.tv_sec = 0;
846 | timeout.tv_usec = 0;
847 |
848 | if (select(pipe_fd + 1, &rfds, NULL((void*)0), NULL((void*)0), &timeout) > 0)
849 | {
850 | return true1;
851 | }
852 |
853 | return false0;
854 | #endif
855 | }
856 |
857 | /*
858 | * Editor modelines - https://www.wireshark.org/tools/modelines.html
859 | *
860 | * Local variables:
861 | * c-basic-offset: 4
862 | * tab-width: 8
863 | * indent-tabs-mode: nil
864 | * End:
865 | *
866 | * vi: set shiftwidth=4 tabstop=8 expandtab:
867 | * :indentSize=4:tabSize=8:noTabs=true:
868 | */