diff --git a/.gitignore b/.gitignore index ac47793..016e97d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +# Vim swap files +.*.swp + # Object files *.o *.ko @@ -32,3 +35,6 @@ *.dSYM/ su-exec +su-exec-static +su-exec-debug +license.inc diff --git a/Makefile b/Makefile index bda7689..61a3647 100644 --- a/Makefile +++ b/Makefile @@ -1,17 +1,37 @@ -CFLAGS ?= -Wall -Werror -g +CFLAGS ?= -Wall -Werror -Iinclude LDFLAGS ?= PROG := su-exec SRCS := $(PROG).c +INCS := license.inc + +PREFIX := /usr/local +INSTALL_DIR := $(PREFIX)/bin +MAN_DIR := $(PREFIX)/share/man/man8 all: $(PROG) -$(PROG): $(SRCS) - $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) +license.inc: LICENSE + xxd -i $^ > $@ + +$(PROG): $(SRCS) $(INCS) + $(CC) $(CFLAGS) -o $@ $(SRCS) $(LDFLAGS) + strip $@ + +$(PROG)-static: $(SRCS) $(INCS) + $(CC) $(CFLAGS) -o $@ $(SRCS) -static $(LDFLAGS) + strip $@ -$(PROG)-static: $(SRCS) - $(CC) $(CFLAGS) -o $@ $^ -static $(LDFLAGS) +$(PROG)-debug: $(SRCS) $(INCS) + $(CC) -g $(CFLAGS) -o $@ $(SRCS) $(LDFLAGS) + +install: + install -d 0755 $(DESTDIR)$(INSTALL_DIR) + install -m 0755 $(PROG) $(DESTDIR)$(INSTALL_DIR) + install -d 0755 $(DESTDIR)$(MAN_DIR) + install -m 0644 su-exec.1 $(DESTDIR)$(MAN_DIR) clean: - rm -f $(PROG) $(PROG)-static + rm -f $(PROG) $(PROG)-static $(PROG)-debug $(INCS) + diff --git a/include/static_assert.h b/include/static_assert.h new file mode 100644 index 0000000..160f368 --- /dev/null +++ b/include/static_assert.h @@ -0,0 +1,106 @@ +/* + * Copied from https://github.com/wc-duck/dbgtools/blob/master/include/dbgtools/static_assert.h + */ +/* + dbgtools - platform independent wrapping of "nice to have" debug functions. + + version 0.1, october, 2013 + + https://github.com/wc-duck/dbgtools + + Copyright (C) 2013- Fredrik Kihlander + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Fredrik Kihlander + */ + +#ifndef DBGTOOLS_STATIC_ASSERT_INCLUDED +#define DBGTOOLS_STATIC_ASSERT_INCLUDED + +/** + * Compile-time check that condition is true, if false a compile-time error will be generated. + * This macro tries to use a built in variant of static assert to generate as good errors as possible but fall back to a generic implementation + * if that is not available. + * + * @note msg will be ignored and an "as good as possible" message will get displayed instead if compiler has no built in support for static assert. + * + * @note macro do unfortunately not work within structs in its c-implementation =/ + * @note on compilers that do not support __COUNTER__ static_assert_counter.h will be used to generate a counter. This however forces the user to include + * static_assert.h in each file where it is used ( as should be done anyways ). + * + * @example STATIC_ASSERT( sizeof( int ) == 4, "size of int is not 4!" ); + */ +#define STATIC_ASSERT(cond, msg) +#undef STATIC_ASSERT + +// ... clang ... +#if defined( __clang__ ) +# if defined( __cplusplus ) && __has_feature(cxx_static_assert) +# define STATIC_ASSERT( cond, msg ) static_assert( cond, msg ) +# elif __has_feature(c_static_assert) +# define STATIC_ASSERT( cond, msg ) _Static_assert( cond, msg ) +# endif + +// ... msvc ... +#elif defined( _MSC_VER ) && ( defined(_MSC_VER) && (_MSC_VER >= 1600) ) +# define STATIC_ASSERT( cond, msg ) static_assert( cond, msg ) + +// ... gcc ... +#elif defined( __cplusplus ) +# if __cplusplus >= 201103L || ( defined(_MSC_VER) && (_MSC_VER >= 1600) ) +# define STATIC_ASSERT( cond, msg ) static_assert( cond, msg ) +# endif +#elif defined( __STDC__ ) +# if defined( __STDC_VERSION__ ) +# if __STDC_VERSION__ >= 201112L +# define STATIC_ASSERT( cond, msg ) _Static_assert( cond, msg ) +# else +# define STATIC_ASSERT( cond, msg ) _Static_assert( cond, msg ) +# endif +# endif +#endif + +/* if we couldn't detect a builtin static assert, lets define one! */ +#ifndef STATIC_ASSERT +# if defined( __COUNTER__ ) +# define DBGTOOLS_STATIC_ASSERT_MACRO_TOKENS_DO(line) DBGTOOLS_STATIC_ASSERT_MACRO_TOKENS_DO1(__COUNTER__,line) +# else +# define DBGTOOLS_STATIC_ASSERT_MACRO_TOKENS_DO(line) DBGTOOLS_STATIC_ASSERT_MACRO_TOKENS_DO1(DBG_TOOLS_STATIC_ASSERT_COUNTER,line) +# endif +# define DBGTOOLS_STATIC_ASSERT_MACRO_TOKENS_DO1(count,line) DBGTOOLS_STATIC_ASSERT_MACRO_TOKENS_DO2(count,line) +# define DBGTOOLS_STATIC_ASSERT_MACRO_TOKENS_DO2(count,line) static_assert_##count##_at_line_##line +# +# if defined( _MSC_VER ) +# if defined( __cplusplus ) + template struct DBG_TOOLS_STATIC_ASSERT_IMPL; + template<> struct DBG_TOOLS_STATIC_ASSERT_IMPL {}; +# define STATIC_ASSERT( cond, msg ) struct DBGTOOLS_STATIC_ASSERT_MACRO_TOKENS_DO( __LINE__ ) { DBG_TOOLS_STATIC_ASSERT_IMPL<(cond)> a; } +# else +# define STATIC_ASSERT( cond, msg ) enum { DBGTOOLS_STATIC_ASSERT_MACRO_TOKENS_DO( __LINE__ ) = 1 / (!!(cond)) } +# endif +# else +# define STATIC_ASSERT( cond, msg ) typedef char DBGTOOLS_STATIC_ASSERT_MACRO_TOKENS_DO( __LINE__ )[ (cond) ? 1 : -1 ] __attribute__ ((unused)) +# endif +#endif + +#endif + +// This inclusion is outside the ifdef on purpose. +#if !defined( __COUNTER__ ) +# include "static_assert_counter.h" +#endif diff --git a/include/static_assert_counter.h b/include/static_assert_counter.h new file mode 100644 index 0000000..358093b --- /dev/null +++ b/include/static_assert_counter.h @@ -0,0 +1,279 @@ +/* + * Copied from https://github.com/wc-duck/dbgtools/blob/master/include/dbgtools/static_assert_counter.h + */ +/* + dbgtools - platform independent wrapping of "nice to have" debug functions. + + version 0.1, october, 2013 + + https://github.com/wc-duck/dbgtools + + Copyright (C) 2013- Fredrik Kihlander + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Fredrik Kihlander +*/ + +/** + * Auto-generated header implementing a counter that increases by each include of the file. + * + * This header will define the macro DBG_TOOLS_STATIC_ASSERT_COUNTER to be increased for each inclusion of the file. + * + * It has been generated with 3 amount of digits resulting in the counter wrapping around after + * 10000 inclusions. + * + * Usage: + * + * #include "this_header.h" + * int a = DBG_TOOLS_STATIC_ASSERT_COUNTER; // 0 + * #include "this_header.h" + * int b = DBG_TOOLS_STATIC_ASSERT_COUNTER; // 1 + * #include "this_header.h" + * int c = DBG_TOOLS_STATIC_ASSERT_COUNTER; // 2 + * #include "this_header.h" + * int d = DBG_TOOLS_STATIC_ASSERT_COUNTER; // 3 + */ + +#ifndef DBG_TOOLS_STATIC_ASSERT_COUNTER +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_0 +#endif // DBG_TOOLS_STATIC_ASSERT_COUNTER + +#if !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_0 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_0 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 0 +#elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_1 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_1 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 1 +#elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_2 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_2 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 2 +#elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_3 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_3 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 3 +#elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_4 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_4 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 4 +#elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_5 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_5 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 5 +#elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_6 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_6 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 6 +#elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_7 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_7 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 7 +#elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_8 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_8 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 8 +#elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_9 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_9 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 9 +#else +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_1 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_2 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_3 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_4 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_5 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_6 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_7 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_8 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D0_9 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_0 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_0 0 +# if !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_0 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_0 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 0 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_1 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_1 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 1 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_2 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_2 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 2 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_3 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_3 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 3 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_4 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_4 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 4 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_5 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_5 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 5 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_6 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_6 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 6 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_7 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_7 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 7 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_8 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_8 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 8 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_9 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_9 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 9 +# else +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_1 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_2 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_3 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_4 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_5 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_6 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_7 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_8 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D1_9 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_1 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_1 0 +# if !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_0 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_0 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 0 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_1 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_1 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 1 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_2 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_2 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 2 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_3 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_3 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 3 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_4 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_4 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 4 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_5 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_5 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 5 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_6 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_6 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 6 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_7 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_7 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 7 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_8 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_8 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 8 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_9 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_9 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 9 +# else +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_1 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_2 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_3 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_4 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_5 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_6 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_7 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_8 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D2_9 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_2 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_2 0 +# if !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_0 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_0 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 0 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_1 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_1 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 1 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_2 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_2 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 2 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_3 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_3 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 3 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_4 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_4 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 4 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_5 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_5 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 5 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_6 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_6 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 6 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_7 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_7 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 7 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_8 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_8 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 8 +# elif !defined( DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_9 ) +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_9 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 9 +# else +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_1 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_2 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_3 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_4 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_5 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_6 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_7 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_8 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_D3_9 +# undef DBG_TOOLS_STATIC_ASSERT_COUNTER_3 +# define DBG_TOOLS_STATIC_ASSERT_COUNTER_3 0 +# endif +# endif +# endif +#endif + +#define DBG_TOOLS_STATIC_ASSERT_COUNTER_JOIN_DIGITS_MACRO_(digit0,digit1,digit2,digit3) digit0##digit1##digit2##digit3 +#define DBG_TOOLS_STATIC_ASSERT_COUNTER_JOIN_DIGITS_MACRO(digit0,digit1,digit2,digit3) DBG_TOOLS_STATIC_ASSERT_COUNTER_JOIN_DIGITS_MACRO_(digit0,digit1,digit2,digit3) +#undef DBG_TOOLS_STATIC_ASSERT_COUNTER +#define DBG_TOOLS_STATIC_ASSERT_COUNTER DBG_TOOLS_STATIC_ASSERT_COUNTER_JOIN_DIGITS_MACRO(DBG_TOOLS_STATIC_ASSERT_COUNTER_3,DBG_TOOLS_STATIC_ASSERT_COUNTER_2,DBG_TOOLS_STATIC_ASSERT_COUNTER_1,DBG_TOOLS_STATIC_ASSERT_COUNTER_0) + diff --git a/su-exec.1 b/su-exec.1 new file mode 100644 index 0000000..67cf2be --- /dev/null +++ b/su-exec.1 @@ -0,0 +1,69 @@ +.TH SU-EXEC 8 "14 Oct 2017" + +.SH NAME +su-exec \- change user id and group id before executing a program + +.SH SYNOPSIS +\fBsu-exec\fP \fIuser-spec\fP \fIcommand\fP [ \fIarguments...\fP ] + +\fBsu-exec\fP \fI-l\fP + +.SH DESCRIPTION +\fBsu-exec\fP executes a program with modified privileges. The program +will be exceuted directly and not run as a child, like su and sudo does, +which avoids TTY and signal issues. + +Notice that su-exec depends on being run by the root user, non-root +users do not have permission to change uid/gid. + +.SH OPTIONS +.TP +\fIuser-spec\fP +is either a user name (e.g. \fBnobody\fP) or user name and group name +separated with colon (e.g. \fBnobody:ftp\fP). Numeric uid/gid values +can be used instead of names. + +.TP +\fIcommand\fP +is the program to execute. Can be either absolute or relative path. + +.TP +\fI-l\fP +Print license information and exits. + +.SH EXAMPLES + +.TP +Execute httpd as user \fIapache\fP and gid value 1000 with the two specified arguments: + +$ \fBsu-exec apache:1000 /usr/sbin/httpd -f /opt/www/httpd.conf\fP + +.SH ENVIRONMENT VARIABLES + +.TP +\fBHOME\fP +Is updated to the value matching the user entry in \fC/etc/passwd\fP. + +.TP +\fBPATH\fP +Is used for searching for the program to execute. + +Since su-exec is not running as a suid binary, the dynamic linker or +libc will not strip or ignore variables like LD_LIBRARY_PATH etc. + +.SH EXIT STATUS +.TP +\fB0\fP +When printing license information. + +.TP +\fB1\fP +If \fbsu-exec\fR fails to change priveledges or execute the program it +will return \fB1\fP. In the successfull case the exit value will be +whatever the executed program returns. + +.SH "SEE ALSO" +su(1), runuser(8), sudo(8), gosu(1) + +.SH BUGS +\fBUSER\fP and \fBLOGNAME\fP environmental variables are not updated. diff --git a/su-exec.c b/su-exec.c index 176bbf2..435b3ae 100644 --- a/su-exec.c +++ b/su-exec.c @@ -11,14 +11,50 @@ #include #include +#include "static_assert.h" + +STATIC_ASSERT( sizeof(uid_t) <= 4, "The size of uid_t is too big, the source must be updated" ); +#define UID_T_STRING_SIZE 11 /* Worst case: "4294967295\0" */ +#define UID_T_FMT "%lu" +#define UID_T_FMT_CAST (unsigned long) + static char *argv0; static void usage(int exitcode) { printf("Usage: %s user-spec command [args]\n", argv0); + printf("Usage: %s -l\n\tShows license.\n", argv0); exit(exitcode); } +#include "license.inc" +static void print_license() +{ + unsigned int i; + for (i=0; ipw_gid; } - setenv("HOME", pw != NULL ? pw->pw_dir : "/", 1); + if (pw != NULL) { + setenv("HOME", pw->pw_dir, 1); + setenv("USER", pw->pw_name, 1); + setenv("LOGNAME", pw->pw_name, 1); + } else { + char tmp[UID_T_STRING_SIZE]; + sprintf(tmp, UID_T_FMT, UID_T_FMT_CAST uid); + setenv("HOME", "/", 1); + setenv("USER", tmp, 1); + setenv("LOGNAME", tmp, 1); + } if (group && group[0] != '\0') { /* group was specified, ignore grouplist for setgroups later */ @@ -73,8 +123,10 @@ int main(int argc, char *argv[]) } if (pw == NULL) { - if (setgroups(1, &gid) < 0) - err(1, "setgroups(%i)", gid); + if (setgroups(1, &gid) < 0) { + print_eperm_warning(WARNING_setgroups); + err(EXIT_FAILURE, "setgroups(%i)", gid); + } } else { int ngroups = 0; gid_t *glist = NULL; @@ -83,25 +135,31 @@ int main(int argc, char *argv[]) int r = getgrouplist(pw->pw_name, gid, glist, &ngroups); if (r >= 0) { - if (setgroups(ngroups, glist) < 0) - err(1, "setgroups"); + if (setgroups(ngroups, glist) < 0) { + print_eperm_warning(WARNING_setgroups); + err(EXIT_FAILURE, "setgroups"); + } break; } glist = realloc(glist, ngroups * sizeof(gid_t)); if (glist == NULL) - err(1, "malloc"); + err(EXIT_FAILURE, "malloc"); } } - if (setgid(gid) < 0) - err(1, "setgid(%i)", gid); + if (setgid(gid) < 0) { + print_eperm_warning(WARNING_setgid); + err(EXIT_FAILURE, "setgid(%i)", gid); + } - if (setuid(uid) < 0) - err(1, "setuid(%i)", uid); + if (setuid(uid) < 0) { + print_eperm_warning(WARNING_setuid); + err(EXIT_FAILURE, "setuid(%i)", uid); + } execvp(cmdargv[0], cmdargv); - err(1, "%s", cmdargv[0]); + err(EXIT_FAILURE, "%s", cmdargv[0]); - return 1; + return EXIT_FAILURE; }