diff options
Diffstat (limited to 'support/dktools/dk-uid.c')
-rw-r--r-- | support/dktools/dk-uid.c | 937 |
1 files changed, 937 insertions, 0 deletions
diff --git a/support/dktools/dk-uid.c b/support/dktools/dk-uid.c new file mode 100644 index 0000000000..2263382aa5 --- /dev/null +++ b/support/dktools/dk-uid.c @@ -0,0 +1,937 @@ +/* + WARNING: This file was generated by dkct. + Changes you make here will be lost if dkct is run again! + You should modify the original source and run dkct on it. + Original source: dk-uid.ctr +*/ + +/* +Copyright (C) 2015-2017, Dirk Krause + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above opyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. +* Neither the name of the author nor the names of contributors may be used + to endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#line 9 "dk-uid.ctr" + +/** @file dk-uid.c Search for free user ID in a given range. + See dk_uid_help_text below. +*/ + +#include "dk4conf.h" + +#include <stdio.h> + +#if DK4_HAVE_STDLIB_H +#ifndef STDLIB_H_INCLUDED +#include <stdlib.h> +#define STDLIB_H_INCLUDED 1 +#endif +#endif + +#if DK4_HAVE_UNISTD_H +#ifndef UNISTD_H_INCLUDED +#include <unistd.h> +#define UNISTD_H_INCLUDED 1 +#endif +#endif + +#if DK4_HAVE_PROCESS_H +#ifndef PROCESS_H_INCLUDED +#include <process.h> +#define PROCESS_H_INCLUDED 1 +#endif +#endif + +#if DK4_HAVE_PWD_H +#ifndef PWD_H_INCLUDED +#include <pwd.h> +#define PWD_H_INCLUDED 1 +#endif +#endif + +#include "dk4types.h" +#include "dk4const.h" +#include "dk4mem.h" +#include "dk4numco.h" +#include "dk4fput.h" +#include "dk4vers.h" +#include "dk4app.h" +#include "dk4maidddu.h" +#include "dk4maadu.h" +#include "dk4maodd.h" +#include "dk4bf.h" + + + + + +#line 61 "dk-uid.ctr" + + + +/** Constant keywords used by the module, not localized. +*/ +static const dkChar * const dk_uid_kwnl[] = { +/* 0 */ +dkT("dktools"), + +/* 1 */ +dkT("dk-uid.txt"), + +/* 2 */ +dkT("dk-uid.str"), + +NULL + + +#line 81 "dk-uid.ctr" +}; + + + +/** Help text used if localized help file is not found. +*/ +static const dkChar * const dk_uid_help_text[] = { +dkT(""), +dkT("Find free user ID"), +dkT(""), +dkT("dk-uid <min> <max>"), +dkT(""), +dkT("The program finds to attempt a free user ID (UID) value in the specified"), +dkT("range."), +dkT(""), +dkT("Options:"), +dkT("--help\t\tShow this short help text."), +dkT("--manual\t*** SHOW FULL MANUAL. ***"), +dkT("--version\tShow version information."), +dkT("--license\tShow license information."), +dkT(""), +dkT("http://dktools.sourceforge.net"), +dkT(""), +NULL + + +#line 106 "dk-uid.ctr" +}; + + + +/** License conditions. +*/ +static const dkChar * const dk_uid_license_text[] = { +dkT("This software uses code from the following projects, either directly or as"), +dkT("a library:"), +dkT(""), +dkT("dktools\t\tDirk Krause's tools and libraries."), +dkT("\t\tSee http://dktools.sourceforge.net/ for more information."), +#if DK4_HAVE_ZLIB_H +dkT(""), +dkT("zlib\t\tData compression library."), +dkT("\t\tSee http://www.zlib.net/ for more information."), +#endif +#if DK4_HAVE_BZLIB_H +dkT(""), +dkT("bzip2\t\tData compression program and library."), +dkT("\t\tSee http://www.bzip.org/ for more information."), +#endif +dkT(""), +dkT("All the licenses below apply to the program."), +dkT("Licenses for used libraries are shown as found on my Scientific Linux 6.x"), +dkT("computer in the /usr/share/doc directory on 2015-04-01. Check the project"), +dkT("homepages of the used libraries for additional information and/or updated"), +dkT("license terms."), +dkT(""), +dkT(""), +dkT("DK tools and libraries license"), +dkT("=============================="), +dkT("Copyright (c) 2015-2016, Dirk Krause"), +dkT("All rights reserved."), +dkT(""), +dkT("Redistribution and use in source and binary forms, with or without"), +dkT("modification, are permitted provided that the following conditions are met:"), +dkT(""), +dkT("* Redistributions of source code must retain the above copyright notice,"), +dkT(" this list of conditions and the following disclaimer."), +dkT("* Redistributions in binary form must reproduce the above copyright"), +dkT(" notice, this list of conditions and the following disclaimer in the"), +dkT(" documentation and/or other materials provided with the distribution."), +dkT("* Neither the name of the Dirk Krause nor the names of contributors may be"), +dkT(" used to endorse or promote products derived from this software without"), +dkT(" specific prior written permission."), +dkT(""), +dkT("THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\""), +dkT("AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE"), +dkT("IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE"), +dkT("ARE DISCLAIMED."), +dkT(""), +dkT("IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,"), +dkT("INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,"), +dkT("BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"), +dkT("DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY"), +dkT("OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING"), +dkT("NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,"), +dkT("EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."), +#if DK4_HAVE_ZLIB_H +dkT(""), +dkT(""), +dkT("Zlib license"), +dkT("============"), +dkT("(C) 1995-2004 Jean-loup Gailly and Mark Adler"), +dkT(""), +dkT("This software is provided 'as-is', without any express or implied"), +dkT("warranty. In no event will the authors be held liable for any damages"), +dkT("arising from the use of this software."), +dkT(""), +dkT("Permission is granted to anyone to use this software for any purpose,"), +dkT("including commercial applications, and to alter it and redistribute it"), +dkT("freely, subject to the following restrictions:"), +dkT(""), +dkT("1. The origin of this software must not be misrepresented; you must not"), +dkT(" claim that you wrote the original software. If you use this software"), +dkT(" in a product, an acknowledgment in the product documentation would be"), +dkT(" appreciated but is not required."), +dkT("2. Altered source versions must be plainly marked as such, and must not be"), +dkT(" misrepresented as being the original software."), +dkT("3. This notice may not be removed or altered from any source distribution."), +dkT(""), +dkT("Jean-loup Gailly Mark Adler"), +dkT("jloup@gzip.org madler@alumni.caltech.edu"), +#endif +#if DK4_HAVE_BZLIB_H +dkT(""), +dkT(""), +dkT("Bzip2 and libbzip2 library license"), +dkT("=================================="), +dkT("This program, \"bzip2\", the associated library \"libbzip2\", and all"), +dkT("documentation, are copyright (C) 1996-2007 Julian R Seward. All"), +dkT("rights reserved."), +dkT(""), +dkT("Redistribution and use in source and binary forms, with or without"), +dkT("modification, are permitted provided that the following conditions"), +dkT("are met:"), +dkT(""), +dkT("1. Redistributions of source code must retain the above copyright"), +dkT(" notice, this list of conditions and the following disclaimer."), +dkT(""), +dkT("2. The origin of this software must not be misrepresented; you must "), +dkT(" not claim that you wrote the original software. If you use this "), +dkT(" software in a product, an acknowledgment in the product "), +dkT(" documentation would be appreciated but is not required."), +dkT(""), +dkT("3. Altered source versions must be plainly marked as such, and must"), +dkT(" not be misrepresented as being the original software."), +dkT(""), +dkT("4. The name of the author may not be used to endorse or promote "), +dkT(" products derived from this software without specific prior written "), +dkT(" permission."), +dkT(""), +dkT("THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS"), +dkT("OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED"), +dkT("WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE"), +dkT("ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY"), +dkT("DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL"), +dkT("DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE"), +dkT("GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS"), +dkT("INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,"), +dkT("WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING"), +dkT("NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS"), +dkT("SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."), +dkT(""), +dkT("Julian Seward, jseward@bzip.org"), +dkT("bzip2/libbzip2 version 1.0.5 of 10 December 2007"), +#endif +dkT(""), +NULL + + +#line 237 "dk-uid.ctr" +}; + + + +/** Constant texts used by the program. +*/ +static const dkChar * const dk_uid_kw_def[] = { +/* 0 */ +dkT("Failed to install signal handlers!"), + +/* 1 */ +dkT("Failed to restore signal handlers!"), + +/* 2 */ +dkT("Illegal number of command line arguments!\n\tMinimum and maximum UID required!"), + +/* 3 */ +dkT("The getpwent() function is not available on this platform!"), + +/* 4 */ +dkT("Failed to write text to standard output!"), + +/* 5 */ +dkT("Failed to convert numeric value to string, probably bug!"), + +/* 6 */ +dkT("No unused UID in specified range!"), + +/* 7 */ +dkT("Failed to retrieve bit from bit field, probably bug!"), + +/* 8 */ +dkT("Aborted by signal!"), + +/* 9 */ +dkT("Failed to obtain command line arguments, probably bug!"), + +/* 10 */ +dkT("Command line argument \""), + +/* 11 */ +dkT("\" is not a number!"), + +/* 12 */ +dkT("UID range too large!"), + +NULL + + +#line 295 "dk-uid.ctr" +}; + + + +/** Application structure for diagnostics. +*/ +dk4_app_t *app = NULL; + + + +/** Constant texts used by the program, localized. +*/ +static const dkChar * const *dk_uid_msg = dk_uid_kw_def; + + + +/** Minimum UID value. +*/ +static dk4_um_t dk_uid_min = (dk4_um_t)500UL; + + + + +/** Maximum UID value. +*/ +static dk4_um_t dk_uid_max = (dk4_um_t)59997UL; + + + + +/** Number of elements in dk_uid_msg array. +*/ +static size_t dk_uid_sz_msg = +sizeof(dk_uid_kw_def)/sizeof(DK4_PCDKCHAR) - 1; + + + +/** Exit status code. +*/ +int exval = EXIT_FAILURE; + + +#ifdef SIGPIPE +/** Indicator: SIGPIPE signal received. +*/ +static +DK4_VOLATILE +dk4_sig_atomic_t sig_had_pipe = 0; +#endif + +/** Indicator: SIGINT signal received. +*/ +static +DK4_VOLATILE +dk4_sig_atomic_t sig_had_int = 0; + +/** Indicator: SIGTERM signal received. +*/ +static +DK4_VOLATILE +dk4_sig_atomic_t sig_had_term = 0; + + + +/** Pass a volatile pointer to an atomic integer. + This function is necessary as some compilers mis-optimize + direct access to volatile variables (at least if you believe + one of the coding standards). + @param ptr Address of atomic integer variable. + @return The unmodified pointer. +*/ +static +DK4_VOLATILE +dk4_sig_atomic_t * +sig_pass_pointer(DK4_VOLATILE dk4_sig_atomic_t *ptr) +{ + return ptr; +} + + + +#ifdef SIGPIPE +/** Handler for SIGPIPE signal. + @param signo Signal number (always SIGPIPE, ignored). +*/ +static +void +sig_handler_pipe(int signo) +{ + *sig_pass_pointer(&sig_had_pipe) = 1; +} +#endif + +/** Handler for SIGINT signal. + @param signo Signal number (always SIGINT, ignored). +*/ +static +void +sig_handler_int(int signo) +{ + *sig_pass_pointer(&sig_had_int) = 1; +} + +/** Handler for SIGTERM signal. + @param signo Signal number (always SIGTERM, ignored). +*/ +static +void +sig_handler_term(int signo) +{ + *sig_pass_pointer(&sig_had_term) = 1; +} + +/** Read value from volatile atomic type. + This function is necessary as some compilers mis-optimize + direct access to volatile variables (at least if you believe + one of the coding standards). + @param ap Pointer to volatile atomic variable. + @return Contents of the variable. +*/ +static +dk4_sig_atomic_t +sig_read_atomic(DK4_VOLATILE dk4_sig_atomic_t *ap) +{ + return (*ap); +} + +/** Check whether we can continue or if a signal was received. + @param check_pipe Flag: Check for occured SIGPIPE signal too. + @return 1 if the program can continue, 0 if a signal was received. +*/ +static +int +sig_can_continue(int check_pipe) +{ + int back = 1; +#ifdef SIGPIPE + if (0 != check_pipe) { + if (0 != sig_read_atomic(&sig_had_pipe)) { back = 0; } + } +#endif + if (0 != sig_read_atomic(&sig_had_int )) { back = 0; } + if (0 != sig_read_atomic(&sig_had_term)) { back = 0; } + return back; +} + + + +/** Check whether we can continue. + @return 1 for yes, 0 for no. +*/ +static +int +dk_uid_can_continue(void) +{ + int back = 1; + if (0 == sig_can_continue(1)) { + back = 0; + } + return back; +} + + + + +/** Traverse existing user accounts to search for a free UID. + @param rs Range size. +*/ +static +void +dk_uid_run_with_range_size(dk4_um_t rs) +{ +#if DK4_HAVE_GETPWENT + dkChar buf[16+8*sizeof(dk4_um_t)]; + dk4_bit_field_t *bf = NULL; + struct passwd *pwptr; + dk4_um_t cuid; + int cc; + int bval; + bf = dk4bf_open(rs, NULL); + if (NULL != bf) { +#if DK4_HAVE_SETPWENT + setpwent(); +#endif + cc = 1; + while (1 == cc) { + if (0 != dk_uid_can_continue()) { + pwptr = getpwent(); + if (NULL != pwptr) { + cuid = (dk4_um_t)(pwptr->pw_uid); + if (dk_uid_min <= cuid) { + if (dk_uid_max >= cuid) { + dk4bf_set(bf, (size_t)(cuid - dk_uid_min), 1, NULL); + } + } + } else { + cc = 0; + } + } else { + cc = -1; + } + } + if (0 == cc) { + cuid = (dk4_um_t)0UL; + cc = 1; + while (1 == cc) { + if (0 != dk_uid_can_continue()) { + if (cuid < rs) { + bval = 0; + if (0 != dk4bf_get(&bval, bf, (size_t)cuid, NULL)) { + if (0 == bval) { + cc = 0; + bval = dk4ma_write_decimal_unsigned( + buf, DK4_SIZEOF(buf,dkChar), (cuid + dk_uid_min), 0, NULL + ); + if (0 != bval) { + if (0 != dk4fputs(buf, stdout, NULL)) { + if (0 != dk4fputc(dkT('\n'), stdout, NULL)) { + exval = EXIT_SUCCESS; + } else { + cc = -1; + /* ERROR: Write failed */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 4 + ); + } + } else { + cc = -1; + /* ERROR: Write failed */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 4 + ); + } + } else { + +#line 529 "dk-uid.ctr" + cc = -1; + /* ERROR: Failed to convert value to string, bug */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 5 + ); + } + } else { + cuid++; + if (rs <= cuid) { + cc = -1; + /* ERROR: No free UID found */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 6 + ); + } + } + } else { + +#line 546 "dk-uid.ctr" + cc = -1; + /* ERROR: Failed to retrieve bit, bug */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 7 + ); + } + } else { + cc = -1; + /* ERROR: No free UID found */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 6 + ); + } + } else { + cc = -1; + /* ERROR: Aborted by signal */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 8 + ); + } + } + } else { + /* ERROR: Aborted by signal */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 8 + ); + } +#if DK4_HAVE_ENDPWENT + endpwent(); +#endif + dk4bf_close(bf); + } else { + /* ERROR: Memory */ + dk4app_log_base1(app, DK4_LL_ERROR, 90); + } +#endif +} + + + +/** After installing the signal handlers, process the command line + arguments. +*/ +static +void +dk_uid_normal_run(void) +{ + dk4_er_t er; + const dkChar *str1; + const dkChar *str2; + const dkChar *ep1 = NULL; + const dkChar *ep2 = NULL; + dk4_um_t tmpval; + int numargs; + int res; + + +#line 602 "dk-uid.ctr" + numargs = dk4app_get_argc(app); + if (2 == numargs) { + str1 = dk4app_get_argv(app, 0); + str2 = dk4app_get_argv(app, 1); + if ((NULL != str1) && (NULL != str2)) { + +#line 607 "dk-uid.ctr" + res = dk4ma_input_dk_dec_dk4_um_t(&dk_uid_min, str1, &ep1, 1, NULL); + if (0 != res) { + res = dk4ma_input_dk_dec_dk4_um_t(&dk_uid_max, str2, &ep2, 1, NULL); + if (0 != res) { + if (dk_uid_max < dk_uid_min) { + tmpval = dk_uid_max; + dk_uid_max = dk_uid_min; + dk_uid_min = tmpval; + } + tmpval = dk_uid_max - dk_uid_min; + dk4error_init(&er); + tmpval = dk4ma_um_add(tmpval, (dk4_um_t)1UL, &er); + if (DK4_E_NONE == er.ec) { + if ((dk4_um_t)SIZE_MAX >= tmpval) { + dk_uid_run_with_range_size(tmpval); + } else { + /* ERROR: Numeric overflow in range calculation */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 12 + ); + } + } else { + /* ERROR: Numeric overflow in range calculation */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 12 + ); + } + } else { + /* ERROR: Argument is not a number */ + dk4app_log_3( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 10, 11, str2 + ); + } + } else { + /* ERROR: Argument is not a number */ + dk4app_log_3( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 10, 11, str1 + ); + } + } else { + +#line 647 "dk-uid.ctr" + /* ERROR: Failed to obtain command line arguments, bug! */ + dk4app_log_1( + app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 9 + ); + } + } else { + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 2); + } + +#line 655 "dk-uid.ctr" +} + + + +#if DK4_HAVE_SIGACTION +/** Set signal handlers and run. +*/ +static +void +dk_uid_run_with_signal_handlers(void) +{ +#ifdef SIGPIPE + struct sigaction opipe; +#endif + struct sigaction oint; +#ifdef SIGPIPE + struct sigaction npipe; +#endif + struct sigaction nint; + struct sigaction oterm; + struct sigaction nterm; + int success = 0; + +#ifdef SIGPIPE + /* Set up signal handling for SIGPIPE. + */ + DK4_MEMRES(&npipe, sizeof(npipe)); + npipe.sa_handler = sig_handler_pipe; + npipe.sa_flags = 0; + if (0 != sigemptyset(&npipe.sa_mask)) { + /* ERROR: Failed to set up masked signal set for SIGPIPE */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 0); + goto finished; + } + if (0 != sigaddset(&npipe.sa_mask, SIGPIPE)) { + /* ERROR: Failed to set up masked signal set for SIGPIPE */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 0); + goto finished; + } + if (0 != sigaction(SIGPIPE, &npipe, &opipe)) { + /* ERROR: Failed to set up signal handler for SIGPIPE */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 0); + goto finished; + } +#endif + + /* Set up signal handling for SIGINT. + */ + DK4_MEMRES(&nint, sizeof(nint)); + nint.sa_handler = sig_handler_int; + nint.sa_flags = 0; + if (0 != sigemptyset(&nint.sa_mask)) { + /* ERROR: Failed to set up masked signal set for SIGINT */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 0); + goto restore_old_pipe; + } + if (0 != sigaddset(&nint.sa_mask, SIGINT)) { + /* ERROR: Failed to set up masked signal set for SIGINT */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 0); + goto restore_old_pipe; + } + if (0 != sigaction(SIGINT, &nint, &oint)) { + /* ERROR: Failed to set up signal handler for SIGINT */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 0); + goto restore_old_pipe; + } + + /* Set up signal handling for SIGTERM + */ + DK4_MEMRES(&nterm, sizeof(nterm)); + nterm.sa_handler = sig_handler_term; + nterm.sa_flags = 0; + if (0 != sigemptyset(&nterm.sa_mask)) { + /* ERROR: Failed to set up masked signal set for SIGTERM */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 0); + goto restore_old_int; + } + if (0 != sigaddset(&nterm.sa_mask, SIGTERM)) { + /* ERROR: Failed to set up masked signal set for SIGTERM */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 0); + goto restore_old_int; + } + if (0 != sigaction(SIGTERM, &nterm, &oterm)) { + /* ERROR: Failed to set up signal handler for SIGTERM */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 0); + goto restore_old_int; + } + + success = 1; + dk_uid_normal_run(); + + /* Restore signal handling for SIGTERM. + */ + if (0 != sigaction(SIGTERM, &oterm, NULL)) { + /* ERROR: Failed to restore old SIGTERM settings */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 1); + success = 0; + } + + /* Restore signal handling for SIGINT. + */ + restore_old_int: + if (0 != sigaction(SIGINT, &oint, NULL)) { + /* ERROR: Failed to restore old SIGPIPE settings */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 1); + success = 0; + } + +#ifdef SIGPIPE + /* Restore signal handling for SIGPIPE. + */ + restore_old_pipe: + if (0 != sigaction(SIGPIPE, &opipe, NULL)) { + /* ERROR: Failed to restore old SIGPIPE settings */ + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK4_LL_ERROR, 1); + success = 0; + } +#endif + + /* Set exit status code if error occured. + */ + finished: + if (0 == success) { exval = EXIT_FAILURE; } +} +#else +#if DK4_HAVE_SIGSET +/** Set signal handlers and run. +*/ +static +void +dk_uid_run_with_signal_handlers(void) +{ +#ifdef SIGPIPE + dk4_sig_handler_t *oldpipe = NULL; +#endif + dk4_sig_handler_t *oldint = NULL; + dk4_sig_handler_t *oldterm = NULL; + +#ifdef SIGPIPE + oldpipe = sigset(SIGPIPE, sig_handler_pipe); +#endif + oldint = sigset(SIGINT, sig_handler_int); + oldterm = sigset(SIGTERM, sig_handler_term); + dk_uid_normal_run(); + sigset(SIGTERM, oldterm); + sigset(SIGINT, oldint); +#ifdef SIGPIPE + sigset(SIGPIPE, oldpipe); +#endif +} +#else +#if DK4_HAVE_SIGNAL +/** Set signal handlers and run. +*/ +static +void +dk_uid_run_with_signal_handlers(void) +{ +#ifdef SIGPIPE + dk4_sig_handler_t *oldpipe = NULL; +#endif + dk4_sig_handler_t *oldint = NULL; + dk4_sig_handler_t *oldterm = NULL; + +#ifdef SIGPIPE + oldpipe = signal(SIGPIPE, sig_handler_pipe); +#endif + oldint = signal(SIGINT, sig_handler_int); + oldterm = signal(SIGTERM, sig_handler_term); + dk_uid_normal_run(); + signal(SIGTERM, oldterm); + signal(SIGINT, oldint); +#ifdef SIGPIPE + signal(SIGPIPE, oldpipe); +#endif +} +#else +/** Set signal handlers and run. +*/ +static +void +dk_uid_run_with_signal_handlers(void) +{ + dk_uid_normal_run(); +} +#endif +#endif +#endif + + + +/** Main function. + @param argc Number of command line arguments. + @param argv Command line arguments array. + @return 0 on success, all other values indicate errors. +*/ +#if DK4_CHAR_SIZE > 1 +int wmain(int argc, wchar_t *argv[]) +#else +int main(int argc, char *argv[]) +#endif +{ + + +#line 858 "dk-uid.ctr" + + +#line 859 "dk-uid.ctr" + dk4fput_initialize_stdout(); + dk4fput_initialize_stderr(); + app = dk4app_open_cmd( + argc, argv, NULL, 0, + dk_uid_kwnl[0], DKT_VERSION_DK, + dk_uid_kwnl[1], dk_uid_help_text, dk_uid_license_text + ); + if (NULL != app) { + dk_uid_sz_msg = dk4app_string_table_size(dk_uid_kw_def); + dk_uid_msg = dk4app_string_table(app, dk_uid_kwnl[2], dk_uid_kw_def); +#if DK4_HAVE_GETPWENT + if (0 != dk4app_can_run_normally(app)) { + dk_uid_run_with_signal_handlers(); + } else { + if (0 != dk4app_help_version_license(app)) { + exval = EXIT_SUCCESS; + } + } +#else + dk4app_log_1(app, dk_uid_msg, dk_uid_sz_msg, DK_LL_ERROR, 3); +#endif + dk4app_close(app); + } else { + } + fflush(stdout); + fflush(stderr); + dk4fput_cleanup_stderr(); + dk4fput_cleanup_stdout(); + + +#line 888 "dk-uid.ctr" + + +#line 889 "dk-uid.ctr" + exit(exval); return exval; +} + |