trunk/utils/tmpcat.c

/*
 * tmpcat.c -- A simple utility to write an input in your editor and cat it.
 *
 * This file is part of OSN Commons.
 * Copyright (C) 2025  OSN Developers.
 *
 * OSN Commons is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * OSN Commons is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with OSN Commons.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <errno.h>
#include <getopt.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#ifdef HAVE_CONFIG_H
#    include "config.h"
#endif

#define PROG_CANONICAL_NAME "tmpcat"
#define PROG_AUTHORS "Ar Rakin <[email protected]>"

/* TODO: Add support for more file types, and
   output statistics separately for each file type. */

static const char *prog_name = NULL;

static struct option const long_options[] = {
    { "help",    no_argument, 0, 'h' },
    { "version", no_argument, 0, 'v' },
    { 0,         0,           0, 0   }
};

static const char *short_options = "hv";

struct editor_data
{
    unsigned char *buffer;
    size_t size;
};

static void
usage (void)
{
    fprintf (stdout, "Usage:\n");
    fprintf (stdout, "  %s [OPTIONS...] [EDITOR]\n", PROG_CANONICAL_NAME);
    fprintf (
        stdout,
        "Allows you to write an input in your editor and echo it out.\n\n");
    fprintf (stdout, "Options:\n");
    fprintf (stdout, "  -h, --help    Show this help message and exit.\n");
    fprintf (stdout, "  -v, --version Show version info and exit.\n");
    fprintf (stdout, "\n");
    fprintf (stdout,
             "For general help and bug reports, feel free to send your\n");
    fprintf (stdout, "message to <[email protected]>.\n");
}

static void
show_version (void)
{
    printf (PROG_CANONICAL_NAME " (" PACKAGE_FULLNAME ") v" PACKAGE_VERSION
                                "\n");
    fputc ('\n', stdout);
    printf ("License GPLv3+: GNU GPL version 3 or later "
            "<http://gnu.org/licenses/gpl.html>.\n");
    printf (
        "This is free software: you are free to change and redistribute it.\n");
    printf ("There is NO WARRANTY, to the extent permitted by law.\n");
    fputc ('\n', stdout);
    printf ("Written by " PROG_AUTHORS ".\n");
}

static char **
split_string (const char *str, const char delim)
{
    char **splitted = NULL;
    char *buf = NULL;
    size_t size = 0;
    size_t buf_size = 0;

    while (true)
        {
            char c = *str;

            buf = realloc (buf, ++buf_size);

            if (c == delim || !c)
                {
                    buf[buf_size - 1] = 0;
                    splitted = realloc (splitted, (++size) * (sizeof (char *)));
                    splitted[size - 1] = buf;
                    buf = NULL;
                    buf_size = 0;

                    if (!c)
                        break;
                }
            else
                buf[buf_size - 1] = c;

            str++;
        }

    splitted = realloc (splitted, (++size) * (sizeof (char *)));
    splitted[size - 1] = NULL;

    return splitted;
}

static void
free_str_r (char **strv)
{
    char **base = strv;

    while (*strv)
        free (*strv++);

    free (base);
}

static void *
path_concat (const char *s1, const char *s2)
{
    size_t len1 = strlen (s1);
    size_t len2 = strlen (s2);
    size_t len = len1 + len2 + 1;
    char *str = malloc (len + 1);

    memcpy (str, s1, len1);
    str[len1] = '/';
    memcpy (str + len1 + 1, s2, len2);
    str[len] = 0;

    return str;
}

static char *
find_executable (const char *name)
{
    if (strchr (name, '/') != NULL)
        return strdup (name);

    const char *path_env = getenv ("PATH");
    path_env = path_env == NULL ? "" : path_env;

    char **paths = split_string (path_env, ':');
    char **base = paths;
    char *result = NULL;

    while (*paths)
        {
            char *path = path_concat (*paths, name);

            if (access (path, R_OK) == 0)
                {
                    result = path;
                    break;
                }

            free (path);
            paths++;
        }

    free_str_r (base);
    return result;
}

static struct editor_data *
read_editor_data (const char *editor_path, size_t editor_argc,
                  const char **editor_args)
{
    char *executable = find_executable (editor_path);

    if (executable == NULL)
        {
            fprintf (stderr, "%s: no executable '%s' found in $PATH\n",
                     prog_name, editor_path);
            exit (EXIT_FAILURE);
        }

    char tmpfile_template[] = "/tmp/tmpXXXXXXXXX";
    int tmpfile_fd = mkstemp (tmpfile_template);

    pid_t pid = fork ();

    if (pid == -1)
        {
            fprintf (stderr, "%s: fork failed: %s\n", prog_name,
                     strerror (errno));
            exit (EXIT_FAILURE);
        }

    if (pid == 0)
        {
            char **args = malloc ((editor_argc + 3) * sizeof (char *));

            if (args == NULL)
                {
                    fprintf (stderr, "%s: malloc failed: %s\n", prog_name,
                             strerror (errno));
                    exit (EXIT_FAILURE);
                }

            args[0] = executable;
            args[editor_argc + 1] = strdup (tmpfile_template);
            args[editor_argc + 2] = NULL;

            for (size_t i = 0; i < editor_argc; i++)
                args[i + 1] = strdup (editor_args[i]);

            execv (executable, args);
            fprintf (stderr, "%s: failed to execute '%s': %s\n", prog_name,
                     executable, strerror (errno));
            exit (EXIT_FAILURE);
        }
    else
        {
            int status;

            if (waitpid (pid, &status, 0) == -1)
                {
                    fprintf (stderr, "%s: could not wait for child: %s\n",
                             prog_name, strerror (errno));
                    exit (EXIT_FAILURE);
                }

            if (WIFEXITED (status) && WEXITSTATUS (status) != 0)
                {
                    fprintf (stderr, "%s: '%s' failed with exit status %d\n",
                             prog_name, executable, WEXITSTATUS (status));
                    exit (EXIT_FAILURE);
                }

            if (WIFSIGNALED (status))
                {
                    fprintf (stderr, "%s: '%s' terminated by signal %s\n",
                             prog_name, executable,
                             strsignal (WTERMSIG (status)));
                    exit (EXIT_FAILURE);
                }

            struct editor_data *data = malloc (sizeof (struct editor_data));
            off_t size = lseek (tmpfile_fd, 0, SEEK_END);

            if (size < 0)
                {
                    fprintf (stderr, "%s: lseek failed: %s\n", prog_name,
                             strerror (errno));
                    exit (EXIT_FAILURE);
                }

            if (lseek (tmpfile_fd, 0, SEEK_SET) < 0)
                {
                    fprintf (stderr, "%s: lseek failed: %s\n", prog_name,
                             strerror (errno));
                    exit (EXIT_FAILURE);
                }

            data->buffer = malloc (size + 1);
            data->size = size;

            if (read (tmpfile_fd, data->buffer, (size_t) size) == -1)
                {
                    fprintf (stderr, "%s: cannot read temporary file: %s\n",
                             prog_name, strerror (errno));
                    exit (EXIT_FAILURE);
                }

            close (tmpfile_fd);
            free (executable);
            return data;
        }

    return NULL;
}

void
free_editor_data (struct editor_data *data)
{
    free (data->buffer);
    free (data);
}

int
main (int argc, char **argv)
{
    prog_name = argv[0];

    while (true)
        {
            int longind = 0;
            int c = getopt_long (argc, argv, short_options, long_options,
                                 &longind);

            if (c == -1)
                break;

            switch (c)
                {
                case 'h':
                    usage ();
                    exit (EXIT_SUCCESS);
                    break;

                case 'v':
                    show_version ();
                    exit (EXIT_SUCCESS);
                    break;

                case '?':
                    exit (EXIT_FAILURE);
                    break;
                }
        }

    const char *editor = getenv ("EDITOR");

    if (argc > optind)
        editor = argv[optind];

    if (editor == NULL)
        editor = "editor";

    struct editor_data *data
        = read_editor_data (editor, argc - 1 > optind ? argc - optind - 1 : 0,
                            (const char **) (argv + optind + 1));

    if (write (STDOUT_FILENO, data->buffer, data->size) == -1)
        {
            fprintf (stderr, "%s: unable to write to stdout: %s\n", prog_name,
                     strerror (errno));
            exit (EXIT_FAILURE);
        }

    free_editor_data (data);
    return 0;
}
1	/*
2	* tmpcat.c -- A simple utility to write an input in your editor and cat it.
3	*
4	* This file is part of OSN Commons.
5	* Copyright (C) 2025 OSN Developers.
6	*
7	* OSN Commons is free software: you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation, either version 3 of the License, or
10	* any later version.
11	*
12	* OSN Commons is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with OSN Commons. If not, see <http://www.gnu.org/licenses/>.
19	*/
20
21	#include <errno.h>
22	#include <getopt.h>
23	#include <stdbool.h>
24	#include <stdio.h>
25	#include <stdlib.h>
26	#include <string.h>
27	#include <sys/types.h>
28	#include <sys/wait.h>
29	#include <unistd.h>
30
31	#ifdef HAVE_CONFIG_H
32	# include "config.h"
33	#endif
34
35	#define PROG_CANONICAL_NAME "tmpcat"
36	#define PROG_AUTHORS "Ar Rakin <[email protected]>"
37
38	/* TODO: Add support for more file types, and
39	output statistics separately for each file type. */
40
41	static const char *prog_name = NULL;
42
43	static struct option const long_options[] = {
44	{ "help", no_argument, 0, 'h' },
45	{ "version", no_argument, 0, 'v' },
46	{ 0, 0, 0, 0 }
47	};
48
49	static const char *short_options = "hv";
50
51	struct editor_data
52	{
53	unsigned char *buffer;
54	size_t size;
55	};
56
57	static void
58	usage (void)
59	{
60	fprintf (stdout, "Usage:\n");
61	fprintf (stdout, " %s [OPTIONS...] [EDITOR]\n", PROG_CANONICAL_NAME);
62	fprintf (
63	stdout,
64	"Allows you to write an input in your editor and echo it out.\n\n");
65	fprintf (stdout, "Options:\n");
66	fprintf (stdout, " -h, --help Show this help message and exit.\n");
67	fprintf (stdout, " -v, --version Show version info and exit.\n");
68	fprintf (stdout, "\n");
69	fprintf (stdout,
70	"For general help and bug reports, feel free to send your\n");
71	fprintf (stdout, "message to <[email protected]>.\n");
72	}
73
74	static void
75	show_version (void)
76	{
77	printf (PROG_CANONICAL_NAME " (" PACKAGE_FULLNAME ") v" PACKAGE_VERSION
78	"\n");
79	fputc ('\n', stdout);
80	printf ("License GPLv3+: GNU GPL version 3 or later "
81	"<http://gnu.org/licenses/gpl.html>.\n");
82	printf (
83	"This is free software: you are free to change and redistribute it.\n");
84	printf ("There is NO WARRANTY, to the extent permitted by law.\n");
85	fputc ('\n', stdout);
86	printf ("Written by " PROG_AUTHORS ".\n");
87	}
88
89	static char **
90	split_string (const char *str, const char delim)
91	{
92	char **splitted = NULL;
93	char *buf = NULL;
94	size_t size = 0;
95	size_t buf_size = 0;
96
97	while (true)
98	{
99	char c = *str;
100
101	buf = realloc (buf, ++buf_size);
102
103	if (c == delim \|\| !c)
104	{
105	buf[buf_size - 1] = 0;
106	splitted = realloc (splitted, (++size) * (sizeof (char *)));
107	splitted[size - 1] = buf;
108	buf = NULL;
109	buf_size = 0;
110
111	if (!c)
112	break;
113	}
114	else
115	buf[buf_size - 1] = c;
116
117	str++;
118	}
119
120	splitted = realloc (splitted, (++size) * (sizeof (char *)));
121	splitted[size - 1] = NULL;
122
123	return splitted;
124	}
125
126	static void
127	free_str_r (char **strv)
128	{
129	char **base = strv;
130
131	while (*strv)
132	free (*strv++);
133
134	free (base);
135	}
136
137	static void *
138	path_concat (const char s1, const char s2)
139	{
140	size_t len1 = strlen (s1);
141	size_t len2 = strlen (s2);
142	size_t len = len1 + len2 + 1;
143	char *str = malloc (len + 1);
144
145	memcpy (str, s1, len1);
146	str[len1] = '/';
147	memcpy (str + len1 + 1, s2, len2);
148	str[len] = 0;
149
150	return str;
151	}
152
153	static char *
154	find_executable (const char *name)
155	{
156	if (strchr (name, '/') != NULL)
157	return strdup (name);
158
159	const char *path_env = getenv ("PATH");
160	path_env = path_env == NULL ? "" : path_env;
161
162	char **paths = split_string (path_env, ':');
163	char **base = paths;
164	char *result = NULL;
165
166	while (*paths)
167	{
168	char path = path_concat (paths, name);
169
170	if (access (path, R_OK) == 0)
171	{
172	result = path;
173	break;
174	}
175
176	free (path);
177	paths++;
178	}
179
180	free_str_r (base);
181	return result;
182	}
183
184	static struct editor_data *
185	read_editor_data (const char *editor_path, size_t editor_argc,
186	const char **editor_args)
187	{
188	char *executable = find_executable (editor_path);
189
190	if (executable == NULL)
191	{
192	fprintf (stderr, "%s: no executable '%s' found in $PATH\n",
193	prog_name, editor_path);
194	exit (EXIT_FAILURE);
195	}
196
197	char tmpfile_template[] = "/tmp/tmpXXXXXXXXX";
198	int tmpfile_fd = mkstemp (tmpfile_template);
199
200	pid_t pid = fork ();
201
202	if (pid == -1)
203	{
204	fprintf (stderr, "%s: fork failed: %s\n", prog_name,
205	strerror (errno));
206	exit (EXIT_FAILURE);
207	}
208
209	if (pid == 0)
210	{
211	char *args = malloc ((editor_argc + 3) sizeof (char *));
212
213	if (args == NULL)
214	{
215	fprintf (stderr, "%s: malloc failed: %s\n", prog_name,
216	strerror (errno));
217	exit (EXIT_FAILURE);
218	}
219
220	args[0] = executable;
221	args[editor_argc + 1] = strdup (tmpfile_template);
222	args[editor_argc + 2] = NULL;
223
224	for (size_t i = 0; i < editor_argc; i++)
225	args[i + 1] = strdup (editor_args[i]);
226
227	execv (executable, args);
228	fprintf (stderr, "%s: failed to execute '%s': %s\n", prog_name,
229	executable, strerror (errno));
230	exit (EXIT_FAILURE);
231	}
232	else
233	{
234	int status;
235
236	if (waitpid (pid, &status, 0) == -1)
237	{
238	fprintf (stderr, "%s: could not wait for child: %s\n",
239	prog_name, strerror (errno));
240	exit (EXIT_FAILURE);
241	}
242
243	if (WIFEXITED (status) && WEXITSTATUS (status) != 0)
244	{
245	fprintf (stderr, "%s: '%s' failed with exit status %d\n",
246	prog_name, executable, WEXITSTATUS (status));
247	exit (EXIT_FAILURE);
248	}
249
250	if (WIFSIGNALED (status))
251	{
252	fprintf (stderr, "%s: '%s' terminated by signal %s\n",
253	prog_name, executable,
254	strsignal (WTERMSIG (status)));
255	exit (EXIT_FAILURE);
256	}
257
258	struct editor_data *data = malloc (sizeof (struct editor_data));
259	off_t size = lseek (tmpfile_fd, 0, SEEK_END);
260
261	if (size < 0)
262	{
263	fprintf (stderr, "%s: lseek failed: %s\n", prog_name,
264	strerror (errno));
265	exit (EXIT_FAILURE);
266	}
267
268	if (lseek (tmpfile_fd, 0, SEEK_SET) < 0)
269	{
270	fprintf (stderr, "%s: lseek failed: %s\n", prog_name,
271	strerror (errno));
272	exit (EXIT_FAILURE);
273	}
274
275	data->buffer = malloc (size + 1);
276	data->size = size;
277
278	if (read (tmpfile_fd, data->buffer, (size_t) size) == -1)
279	{
280	fprintf (stderr, "%s: cannot read temporary file: %s\n",
281	prog_name, strerror (errno));
282	exit (EXIT_FAILURE);
283	}
284
285	close (tmpfile_fd);
286	free (executable);
287	return data;
288	}
289
290	return NULL;
291	}
292
293	void
294	free_editor_data (struct editor_data *data)
295	{
296	free (data->buffer);
297	free (data);
298	}
299
300	int
301	main (int argc, char **argv)
302	{
303	prog_name = argv[0];
304
305	while (true)
306	{
307	int longind = 0;
308	int c = getopt_long (argc, argv, short_options, long_options,
309	&longind);
310
311	if (c == -1)
312	break;
313
314	switch (c)
315	{
316	case 'h':
317	usage ();
318	exit (EXIT_SUCCESS);
319	break;
320
321	case 'v':
322	show_version ();
323	exit (EXIT_SUCCESS);
324	break;
325
326	case '?':
327	exit (EXIT_FAILURE);
328	break;
329	}
330	}
331
332	const char *editor = getenv ("EDITOR");
333
334	if (argc > optind)
335	editor = argv[optind];
336
337	if (editor == NULL)
338	editor = "editor";
339
340	struct editor_data *data
341	= read_editor_data (editor, argc - 1 > optind ? argc - optind - 1 : 0,
342	(const char **) (argv + optind + 1));
343
344	if (write (STDOUT_FILENO, data->buffer, data->size) == -1)
345	{
346	fprintf (stderr, "%s: unable to write to stdout: %s\n", prog_name,
347	strerror (errno));
348	exit (EXIT_FAILURE);
349	}
350
351	free_editor_data (data);
352	return 0;
353	}