and defines.
plugins/sudoers/sudoers.in
plugins/sudoers/sudoers2ldif
plugins/sudoers/sudoers_debug.c
+plugins/sudoers/sudoers_debug.h
plugins/sudoers/sudoers_version.h
plugins/sudoers/sudoreplay.c
plugins/sudoers/testsudoers.c
* Note: order must match sudo_debug_subsystems[]
*/
#define SUDO_DEBUG_MAIN ( 1<<16) /* sudo main() */
-#define SUDO_DEBUG_ARGS ( 2<<16) /* command line argument processing */
-#define SUDO_DEBUG_EXEC ( 3<<16) /* command execution */
-#define SUDO_DEBUG_PTY ( 4<<16) /* pseudo-tty */
-#define SUDO_DEBUG_UTMP ( 5<<16) /* utmp file ops */
-#define SUDO_DEBUG_CONV ( 6<<16) /* user conversation */
-#define SUDO_DEBUG_PCOMM ( 7<<16) /* plugin communications */
-#define SUDO_DEBUG_UTIL ( 8<<16) /* utility functions */
-#define SUDO_DEBUG_NETIF ( 9<<16) /* network interface functions */
-#define SUDO_DEBUG_AUDIT (10<<16) /* audit */
-#define SUDO_DEBUG_EDIT (11<<16) /* sudoedit */
-#define SUDO_DEBUG_SELINUX (12<<16) /* selinux */
-#define SUDO_DEBUG_LDAP (13<<16) /* sudoers LDAP */
-#define SUDO_DEBUG_MATCH (14<<16) /* sudoers matching */
-#define SUDO_DEBUG_PARSER (15<<16) /* sudoers parser */
-#define SUDO_DEBUG_ALIAS (16<<16) /* sudoers alias functions */
-#define SUDO_DEBUG_DEFAULTS (17<<16) /* sudoers defaults settings */
-#define SUDO_DEBUG_AUTH (18<<16) /* authentication functions */
-#define SUDO_DEBUG_ENV (19<<16) /* environment handling */
-#define SUDO_DEBUG_LOGGING (20<<16) /* logging functions */
-#define SUDO_DEBUG_NSS (21<<16) /* network service switch */
-#define SUDO_DEBUG_RBTREE (22<<16) /* red-black tree functions */
-#define SUDO_DEBUG_PERMS (23<<16) /* uid/gid swapping functions */
-#define SUDO_DEBUG_PLUGIN (24<<16) /* main plugin functions */
-#define SUDO_DEBUG_HOOKS (25<<16) /* hook functions */
-#define SUDO_DEBUG_SSSD (26<<16) /* sudoers SSSD */
-#define SUDO_DEBUG_EVENT (27<<16) /* event handling */
-#define SUDO_DEBUG_ALL 0xffff0000 /* all subsystems */
+#define SUDO_DEBUG_UTIL ( 2<<16) /* utility functions */
+#define SUDO_DEBUG_NETIF ( 3<<16) /* network interface functions */
+#define SUDO_DEBUG_PLUGIN ( 4<<16) /* main plugin functions */
+#define SUDO_DEBUG_EVENT ( 5<<16) /* event handling */
+#define SUDO_DEBUG_ARGS ( 6<<16) /* command line argument processing */
+#define SUDO_DEBUG_EXEC ( 7<<16) /* command execution */
+#define SUDO_DEBUG_PTY ( 8<<16) /* pseudo-tty */
+#define SUDO_DEBUG_UTMP ( 9<<16) /* utmp file ops */
+#define SUDO_DEBUG_CONV (10<<16) /* user conversation */
+#define SUDO_DEBUG_PCOMM (11<<16) /* plugin communications */
+#define SUDO_DEBUG_EDIT (12<<16) /* sudoedit */
+#define SUDO_DEBUG_SELINUX (13<<16) /* selinux */
+#define SUDO_DEBUG_HOOKS (14<<16) /* hook functions */
+#define SUDO_DEBUG_ALL 0xffff0000 /* all subsystems */
/* Initializer for instance index to indicate that debugging is not setup. */
#define SUDO_DEBUG_INSTANCE_INITIALIZER SUDO_DEBUG_MKINSTANCE(-1)
};
/* Note: this must match the order in sudo_debug.h */
-/* XXX - remove sudoers-specific bits */
static const char *const sudo_debug_default_subsystems[] = {
"main",
+ "util",
+ "netif",
+ "plugin",
+ "event",
"args",
"exec",
"pty",
"utmp",
"conv",
"pcomm",
- "util",
- "netif",
- "audit",
"edit",
"selinux",
- "ldap",
- "match",
- "parser",
- "alias",
- "defaults",
- "auth",
- "env",
- "logging",
- "nss",
- "rbtree",
- "perms",
- "plugin",
"hooks",
- "sssd",
- "event",
NULL
};
get_ttysize_ioctl(int *rowp, int *colp)
{
struct winsize wsize;
- debug_decl(get_ttysize_ioctl, SUDO_DEBUG_EXEC, SUDO_DEBUG_INSTANCE_DEFAULT)
+ debug_decl(get_ttysize_ioctl, SUDO_DEBUG_UTIL, SUDO_DEBUG_INSTANCE_DEFAULT)
if (ioctl(STDERR_FILENO, TIOCGWINSZ, &wsize) == 0 &&
wsize.ws_row != 0 && wsize.ws_col != 0) {
void
sudo_get_ttysize_v1(int *rowp, int *colp)
{
- debug_decl(sudo_get_ttysize, SUDO_DEBUG_EXEC, SUDO_DEBUG_INSTANCE_DEFAULT)
+ debug_decl(sudo_get_ttysize, SUDO_DEBUG_UTIL, SUDO_DEBUG_INSTANCE_DEFAULT)
if (get_ttysize_ioctl(rowp, colp) == -1) {
char *p;
$(incdir)/sudo_debug.h $(incdir)/sudo_fatal.h $(incdir)/sudo_gettext.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/afs.c
aix_auth.lo: $(authdir)/aix_auth.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/aix_auth.c
alias.lo: $(srcdir)/alias.c $(devdir)/def_data.h $(devdir)/gram.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/parse.h \
$(srcdir)/redblack.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/alias.c
audit.lo: $(srcdir)/audit.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_alloc.h $(incdir)/sudo_compat.h $(incdir)/sudo_conf.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/bsm_audit.h \
$(srcdir)/defaults.h $(srcdir)/linux_audit.h $(srcdir)/logging.h \
$(srcdir)/solaris_audit.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/audit.c
base64.lo: $(srcdir)/base64.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_alloc.h $(incdir)/sudo_compat.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/base64.c
base64.o: base64.lo
boottime.lo: $(srcdir)/boottime.c $(devdir)/def_data.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/boottime.c
bsdauth.lo: $(authdir)/bsdauth.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/bsdauth.c
bsm_audit.lo: $(srcdir)/bsm_audit.c $(incdir)/sudo_compat.h \
$(incdir)/sudo_debug.h $(incdir)/sudo_fatal.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/check.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/check.c
check_addr.o: $(srcdir)/regress/parser/check_addr.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/interfaces.h $(srcdir)/logging.h \
$(srcdir)/parse.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/regress/parser/check_addr.c
check_base64.o: $(srcdir)/regress/parser/check_base64.c \
$(incdir)/sudo_compat.h $(top_builddir)/config.h
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h \
$(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/regress/iolog_path/check_iolog_path.c
check_symbols.o: $(srcdir)/regress/check_symbols/check_symbols.c \
$(incdir)/compat/stdbool.h $(incdir)/sudo_compat.h \
$(incdir)/sudo_debug.h $(incdir)/sudo_fatal.h $(incdir)/sudo_gettext.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/dce.c
defaults.lo: $(srcdir)/defaults.c $(devdir)/def_data.c $(devdir)/def_data.h \
$(devdir)/gram.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h \
$(incdir)/sudo_util.h $(srcdir)/defaults.h $(srcdir)/logging.h \
$(srcdir)/parse.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/defaults.c
env.lo: $(srcdir)/env.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_alloc.h $(incdir)/sudo_compat.h $(incdir)/sudo_conf.h \
$(incdir)/sudo_debug.h $(incdir)/sudo_fatal.h $(incdir)/sudo_gettext.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/env.c
find_path.lo: $(srcdir)/find_path.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/find_path.c
find_path.o: find_path.lo
fwtk.lo: $(authdir)/fwtk.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/fwtk.c
getdate.o: $(devdir)/getdate.c $(incdir)/sudo_compat.h $(top_builddir)/config.h
$(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(devdir)/getdate.c
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/getspwuid.c
goodpath.lo: $(srcdir)/goodpath.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/goodpath.c
goodpath.o: goodpath.lo
gram.lo: $(devdir)/gram.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/parse.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(srcdir)/toke.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h $(srcdir)/toke.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(devdir)/gram.c
group_plugin.lo: $(srcdir)/group_plugin.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h \
$(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/group_plugin.c
group_plugin.o: group_plugin.lo
hexchar.lo: $(srcdir)/hexchar.c $(devdir)/def_data.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/hexchar.c
hexchar.o: hexchar.lo
interfaces.lo: $(srcdir)/interfaces.c $(devdir)/def_data.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/interfaces.h $(srcdir)/logging.h \
$(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/interfaces.c
interfaces.o: interfaces.lo
iolog.lo: $(srcdir)/iolog.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/iolog.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/iolog.c
iolog_path.lo: $(srcdir)/iolog_path.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/iolog_path.c
iolog_path.o: iolog_path.lo
kerb5.lo: $(authdir)/kerb5.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/kerb5.c
ldap.lo: $(srcdir)/ldap.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_alloc.h $(incdir)/sudo_compat.h $(incdir)/sudo_conf.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_lbuf.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/parse.h \
- $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/ldap.c
linux_audit.lo: $(srcdir)/linux_audit.c $(incdir)/sudo_alloc.h \
$(incdir)/sudo_compat.h $(incdir)/sudo_debug.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/logging.c
logwrap.lo: $(srcdir)/logwrap.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/logwrap.c
logwrap.o: logwrap.lo
match.lo: $(srcdir)/match.c $(devdir)/def_data.h $(devdir)/gram.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/parse.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/match.c
match_addr.lo: $(srcdir)/match_addr.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/interfaces.h $(srcdir)/logging.h \
$(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/match_addr.c
match_addr.o: match_addr.lo
net_ifs.o: $(top_srcdir)/src/net_ifs.c $(incdir)/compat/stdbool.h \
$(incdir)/sudo_debug.h $(incdir)/sudo_fatal.h $(incdir)/sudo_gettext.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/pam.c
parse.lo: $(srcdir)/parse.c $(devdir)/def_data.h $(devdir)/gram.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_lbuf.h $(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h \
$(incdir)/sudo_util.h $(srcdir)/defaults.h $(srcdir)/logging.h \
$(srcdir)/parse.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/parse.c
passwd.lo: $(authdir)/passwd.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_alloc.h $(incdir)/sudo_compat.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/passwd.c
policy.lo: $(srcdir)/policy.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_alloc.h $(incdir)/sudo_compat.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/interfaces.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(srcdir)/sudoers_version.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(srcdir)/sudoers_version.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/policy.c
prompt.lo: $(srcdir)/prompt.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_alloc.h $(incdir)/sudo_compat.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/prompt.c
pwutil.lo: $(srcdir)/pwutil.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_alloc.h $(incdir)/sudo_compat.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/pwutil.h $(srcdir)/redblack.h \
- $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/pwutil.c
pwutil.o: pwutil.lo
pwutil_impl.lo: $(srcdir)/pwutil_impl.c $(devdir)/def_data.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/pwutil.h \
$(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/pwutil_impl.c
pwutil_impl.o: pwutil_impl.lo
redblack.lo: $(srcdir)/redblack.c $(devdir)/def_data.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/redblack.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/redblack.c
redblack.o: redblack.lo
rfc1938.lo: $(authdir)/rfc1938.c $(devdir)/def_data.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/rfc1938.c
secureware.lo: $(authdir)/secureware.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/secureware.c
securid5.lo: $(authdir)/securid5.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/securid5.c
set_perms.lo: $(srcdir)/set_perms.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/set_perms.c
sia.lo: $(authdir)/sia.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_alloc.h $(incdir)/sudo_compat.h $(incdir)/sudo_conf.h \
$(incdir)/sudo_debug.h $(incdir)/sudo_fatal.h $(incdir)/sudo_gettext.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/sia.c
solaris_audit.lo: $(srcdir)/solaris_audit.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h \
$(srcdir)/solaris_audit.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/solaris_audit.c
sssd.lo: $(srcdir)/sssd.c $(devdir)/def_data.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_alloc.h $(incdir)/sudo_compat.h $(incdir)/sudo_conf.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_lbuf.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/parse.h \
- $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/sssd.c
sudo_auth.lo: $(authdir)/sudo_auth.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(srcdir)/ins_classic.h $(srcdir)/ins_csops.h \
$(srcdir)/ins_goons.h $(srcdir)/insults.h $(srcdir)/logging.h \
$(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(authdir)/sudo_auth.c
sudo_nss.lo: $(srcdir)/sudo_nss.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_lbuf.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h \
$(incdir)/sudo_util.h $(srcdir)/defaults.h $(srcdir)/logging.h \
- $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(top_builddir)/config.h \
+ $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
$(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/sudo_nss.c
sudo_printf.o: $(srcdir)/sudo_printf.c $(incdir)/sudo_compat.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h \
$(incdir)/sudo_util.h $(srcdir)/auth/sudo_auth.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/sudo_nss.h \
- $(srcdir)/sudoers.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/sudoers.c
sudoers_debug.lo: $(srcdir)/sudoers_debug.c $(devdir)/def_data.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h \
$(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/sudoers_debug.c
sudoers_debug.o: sudoers_debug.lo
sudoreplay.o: $(srcdir)/sudoreplay.c $(incdir)/compat/getopt.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h \
$(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/interfaces.h $(srcdir)/logging.h $(srcdir)/parse.h \
- $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(srcdir)/tsgetgrpw.h \
+ $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
+ $(srcdir)/sudoers_debug.h $(srcdir)/tsgetgrpw.h \
$(top_builddir)/config.h $(top_builddir)/pathnames.h
$(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/testsudoers.c
timestamp.lo: $(srcdir)/timestamp.c $(devdir)/def_data.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h \
$(incdir)/sudo_util.h $(srcdir)/check.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/timestamp.c
timestr.lo: $(srcdir)/timestr.c $(incdir)/sudo_compat.h $(top_builddir)/config.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/timestr.c
$(incdir)/sudo_gettext.h $(incdir)/sudo_lbuf.h \
$(incdir)/sudo_plugin.h $(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/parse.h \
- $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(srcdir)/toke.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(srcdir)/toke.h $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(devdir)/toke.c
toke_util.lo: $(srcdir)/toke_util.c $(devdir)/def_data.h $(devdir)/gram.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/parse.h \
- $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(srcdir)/toke.h \
+ $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
+ $(srcdir)/sudoers_debug.h $(srcdir)/toke.h \
$(top_builddir)/config.h $(top_builddir)/pathnames.h
$(LIBTOOL) --mode=compile $(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/toke_util.c
toke_util.o: toke_util.lo
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(srcdir)/tsgetgrpw.h $(top_builddir)/config.h \
- $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(srcdir)/tsgetgrpw.h \
+ $(top_builddir)/config.h $(top_builddir)/pathnames.h
$(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/tsgetgrpw.c
visudo.o: $(srcdir)/visudo.c $(devdir)/def_data.h $(devdir)/gram.h \
$(incdir)/compat/getopt.h $(incdir)/compat/stdbool.h \
$(incdir)/sudo_gettext.h $(incdir)/sudo_plugin.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h $(srcdir)/defaults.h \
$(srcdir)/logging.h $(srcdir)/parse.h $(srcdir)/redblack.h \
- $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(srcdir)/sudoers_version.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudo_nss.h $(srcdir)/sudoers.h $(srcdir)/sudoers_debug.h \
+ $(srcdir)/sudoers_version.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/visudo.c
visudo_json.o: $(srcdir)/visudo_json.c $(devdir)/def_data.h $(devdir)/gram.h \
$(incdir)/compat/stdbool.h $(incdir)/sudo_alloc.h \
$(incdir)/sudo_queue.h $(incdir)/sudo_util.h \
$(srcdir)/defaults.h $(srcdir)/logging.h $(srcdir)/parse.h \
$(srcdir)/sudo_nss.h $(srcdir)/sudoers.h \
- $(top_builddir)/config.h $(top_builddir)/pathnames.h
+ $(srcdir)/sudoers_debug.h $(top_builddir)/config.h \
+ $(top_builddir)/pathnames.h
$(CC) -c $(CPPFLAGS) $(CFLAGS) $(PIE_CFLAGS) $(SSP_CFLAGS) $(DEFS) $(srcdir)/visudo_json.c
const struct alias *a1 = (const struct alias *)v1;
const struct alias *a2 = (const struct alias *)v2;
int res;
- debug_decl(alias_compare, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(alias_compare, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
if (v1 == NULL)
res = -1;
struct alias key;
struct rbnode *node;
struct alias *a = NULL;
- debug_decl(alias_get, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(alias_get, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
key.name = name;
key.type = type;
void
alias_put(struct alias *a)
{
- debug_decl(alias_put, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(alias_put, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
a->used = false;
debug_return;
}
{
static char errbuf[512];
struct alias *a;
- debug_decl(alias_add, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(alias_add, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
a = sudo_ecalloc(1, sizeof(*a));
a->name = name;
void
alias_apply(int (*func)(void *, void *), void *cookie)
{
- debug_decl(alias_apply, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(alias_apply, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
rbapply(aliases, func, cookie, inorder);
bool
no_aliases(void)
{
- debug_decl(no_aliases, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(no_aliases, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
debug_return_bool(rbisempty(aliases));
}
struct member *m;
struct sudo_command *c;
void *next;
- debug_decl(alias_free, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(alias_free, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
sudo_efree(a->name);
TAILQ_FOREACH_SAFE(m, &a->members, entries, next) {
{
struct rbnode *node;
struct alias key;
- debug_decl(alias_remove, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(alias_remove, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
key.name = name;
key.type = type;
void
init_aliases(void)
{
- debug_decl(init_aliases, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(init_aliases, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
if (aliases != NULL)
rbdestroy(aliases, alias_free);
audit_success(int argc, char *argv[])
{
int rc = 0;
- debug_decl(audit_success, SUDO_DEBUG_AUDIT, sudoers_debug_instance)
+ debug_decl(audit_success, SUDOERS_DEBUG_AUDIT, sudoers_debug_instance)
if (argv != NULL) {
#ifdef HAVE_BSM_AUDIT
audit_failure(int argc, char *argv[], char const *const fmt, ...)
{
int rc = 0;
- debug_decl(audit_success, SUDO_DEBUG_AUDIT, sudoers_debug_instance)
+ debug_decl(audit_success, SUDOERS_DEBUG_AUDIT, sudoers_debug_instance)
#if defined(HAVE_BSM_AUDIT) || defined(HAVE_LINUX_AUDIT)
if (argv != NULL) {
{
struct ktc_encryptionKey afs_key;
struct ktc_token afs_token;
- debug_decl(sudo_afs_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_afs_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Try to just check the password */
ka_StringToKey(pass, NULL, &afs_key);
char *pass, *message = NULL;
int result = 1, reenter = 0;
int rval = AUTH_SUCCESS;
- debug_decl(sudo_aix_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_aix_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
do {
pass = auth_getpass(prompt, def_passwd_timeout * 60,
int
sudo_aix_cleanup(struct passwd *pw, sudo_auth *auth)
{
- debug_decl(sudo_aix_cleanup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_aix_cleanup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Unset AUTHSTATE as it may not be correct for the runas user. */
if (sudo_unsetenv("AUTHSTATE") == -1)
bsdauth_init(struct passwd *pw, sudo_auth *auth)
{
static struct bsdauth_state state;
- debug_decl(bsdauth_init, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(bsdauth_init, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Get login class based on auth user, which may not be invoking user. */
if (pw->pw_class && *pw->pw_class)
int authok = 0;
sigaction_t sa, osa;
auth_session_t *as = ((struct bsdauth_state *) auth->data)->as;
- debug_decl(bsdauth_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(bsdauth_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* save old signal handler */
sigemptyset(&sa.sa_mask);
bsdauth_cleanup(struct passwd *pw, sudo_auth *auth)
{
struct bsdauth_state *state = auth->data;
- debug_decl(bsdauth_cleanup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(bsdauth_cleanup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (state != NULL) {
auth_close(state->as);
boolean32 reset_passwd;
sec_login_auth_src_t auth_src;
error_status_t status;
- debug_decl(sudo_dce_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_dce_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/*
* Create the local context of the DCE principal necessary
{
int error_stat;
unsigned char error_string[dce_c_error_string_len];
- debug_decl(check_dce_status, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(check_dce_status, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (input_status == rpc_s_ok)
debug_return_bool(0);
{
static Cfg *confp; /* Configuration entry struct */
char resp[128]; /* Response from the server */
- debug_decl(sudo_fwtk_init, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_fwtk_init, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if ((confp = cfg_read("sudo")) == (Cfg *)-1) {
sudo_warnx(U_("unable to read fwtk config"));
char buf[SUDO_CONV_REPL_MAX + 12]; /* General prupose buffer */
char resp[128]; /* Response from the server */
int error;
- debug_decl(sudo_fwtk_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_fwtk_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Send username to authentication server. */
(void) snprintf(buf, sizeof(buf), "authorize %s 'sudo'", pw->pw_name);
int
sudo_fwtk_cleanup(struct passwd *pw, sudo_auth *auth)
{
- debug_decl(sudo_fwtk_cleanup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_fwtk_cleanup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
auth_close();
debug_return_int(AUTH_SUCCESS);
sudo_krb5_setup(struct passwd *pw, char **promptp, sudo_auth *auth)
{
static char *krb5_prompt;
- debug_decl(sudo_krb5_init, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_krb5_init, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (krb5_prompt == NULL) {
krb5_context sudo_context;
krb5_context sudo_context;
krb5_error_code error;
char cache_name[64], *pname = pw->pw_name;
- debug_decl(sudo_krb5_init, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_krb5_init, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
auth->data = (void *) &sudo_krb5_data; /* Stash all our data here */
krb5_principal princ;
krb5_ccache ccache;
krb5_error_code error;
- debug_decl(sudo_krb5_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_krb5_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
sudo_context = ((sudo_krb5_datap) auth->data)->sudo_context;
princ = ((sudo_krb5_datap) auth->data)->princ;
krb5_ccache ccache;
krb5_error_code error;
krb5_get_init_creds_opt *opts = NULL;
- debug_decl(sudo_krb5_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_krb5_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
sudo_context = ((sudo_krb5_datap) auth->data)->sudo_context;
princ = ((sudo_krb5_datap) auth->data)->princ;
krb5_context sudo_context;
krb5_principal princ;
krb5_ccache ccache;
- debug_decl(sudo_krb5_cleanup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_krb5_cleanup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
sudo_context = ((sudo_krb5_datap) auth->data)->sudo_context;
princ = ((sudo_krb5_datap) auth->data)->princ;
krb5_error_code error;
krb5_principal server;
krb5_verify_init_creds_opt vopt;
- debug_decl(verify_krb_v5_tgt, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(verify_krb_v5_tgt, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/*
* Get the server principal for the local host.
{
static struct pam_conv pam_conv;
static int pam_status;
- debug_decl(sudo_pam_init, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_pam_init, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Initial PAM setup */
auth->data = (void *) &pam_status;
{
const char *s;
int *pam_status = (int *) auth->data;
- debug_decl(sudo_pam_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_pam_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
def_prompt = prompt; /* for converse */
sudo_pam_cleanup(struct passwd *pw, sudo_auth *auth)
{
int *pam_status = (int *) auth->data;
- debug_decl(sudo_pam_cleanup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_pam_cleanup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* If successful, we can't close the session until sudo_pam_end_session() */
if (*pam_status != PAM_SUCCESS || auth->end_session == NULL) {
{
int status = AUTH_SUCCESS;
int *pam_status = (int *) auth->data;
- debug_decl(sudo_pam_begin_session, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_pam_begin_session, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/*
* If there is no valid user we cannot open a PAM session.
sudo_pam_end_session(struct passwd *pw, sudo_auth *auth)
{
int status = AUTH_SUCCESS;
- debug_decl(sudo_pam_end_session, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_pam_end_session, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (pamh != NULL) {
/*
char *pass;
int n, type;
int ret = PAM_AUTH_ERR;
- debug_decl(converse, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(converse, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if ((*response = calloc(num_msg, sizeof(struct pam_response))) == NULL)
debug_return_int(PAM_SYSTEM_ERR);
int
sudo_passwd_init(struct passwd *pw, sudo_auth *auth)
{
- debug_decl(sudo_passwd_init, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_passwd_init, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
#ifdef HAVE_SKEYACCESS
if (skeyaccess(pw, user_tty, NULL, NULL) == 0)
char *pw_epasswd = auth->data;
size_t pw_len;
int matched = 0;
- debug_decl(sudo_passwd_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_passwd_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
pw_len = strlen(pw_epasswd);
sudo_auth *auth;
{
char *pw_epasswd = auth->data;
- debug_decl(sudo_passwd_cleanup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_passwd_cleanup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (pw_epasswd != NULL) {
memset_s(pw_epasswd, SUDO_CONV_REPL_MAX, 0, strlen(pw_epasswd));
static char *orig_prompt = NULL, *new_prompt = NULL;
static int op_len, np_size;
static struct RFC1938 rfc1938;
- debug_decl(sudo_rfc1938_setup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_rfc1938_setup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Stash a pointer to the rfc1938 struct if we have not initialized */
if (!auth->data)
int
sudo_rfc1938_verify(struct passwd *pw, char *pass, sudo_auth *auth)
{
- debug_decl(sudo_rfc1938_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_rfc1938_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (rfc1938verify((struct RFC1938 *) auth->data, pass) == 0)
debug_return_int(AUTH_SUCCESS);
{
#ifdef __alpha
extern int crypt_type;
- debug_decl(sudo_secureware_init, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_secureware_init, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (crypt_type == INT_MAX)
debug_return_int(AUTH_FAILURE); /* no shadow */
#else
- debug_decl(secureware_init, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(secureware_init, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
#endif
sudo_setspent();
auth->data = sudo_getepw(pw);
{
char *pw_epasswd = auth->data;
char *epass = NULL;
- debug_decl(sudo_secureware_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_secureware_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
#ifdef __alpha
{
extern int crypt_type;
sudo_auth *auth;
{
char *pw_epasswd = auth->data;
- debug_decl(sudo_secureware_cleanup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_secureware_cleanup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (pw_epasswd != NULL) {
memset_s(pw_epasswd, SUDO_CONV_REPL_MAX, 0, strlen(pw_epasswd));
sudo_securid_init(struct passwd *pw, sudo_auth *auth)
{
static SDI_HANDLE sd_dat; /* SecurID handle */
- debug_decl(sudo_securid_init, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_securid_init, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
auth->data = (void *) &sd_dat; /* For method-specific data */
{
SDI_HANDLE *sd = (SDI_HANDLE *) auth->data;
int retval;
- debug_decl(sudo_securid_setup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_securid_setup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Re-initialize SecurID every time. */
if (SD_Init(sd) != ACM_OK) {
{
SDI_HANDLE *sd = (SDI_HANDLE *) auth->data;
int rval;
- debug_decl(sudo_securid_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_securid_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
pass = auth_getpass("Enter your PASSCODE: ",
def_passwd_timeout * 60, SUDO_CONV_PROMPT_ECHO_OFF);
{
int rval;
sigset_t mask, omask;
- debug_decl(sudo_collect, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_collect, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
switch (rendition) {
case SIAFORM:
{
SIAENTITY *siah = NULL;
int i;
- debug_decl(sudo_sia_setup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_sia_setup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Rebuild argv for sia_ses_init() */
sudo_argc = NewArgc + 1;
sudo_sia_verify(struct passwd *pw, char *prompt, sudo_auth *auth)
{
SIAENTITY *siah = (SIAENTITY *) auth->data;
- debug_decl(sudo_sia_verify, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_sia_verify, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
def_prompt = prompt; /* for sudo_collect */
sudo_sia_cleanup(struct passwd *pw, sudo_auth *auth)
{
SIAENTITY *siah = (SIAENTITY *) auth->data;
- debug_decl(sudo_sia_cleanup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_sia_cleanup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
(void) sia_ses_release(&siah);
sudo_efree(sudo_argv);
{
sudo_auth *auth;
int status = AUTH_SUCCESS;
- debug_decl(sudo_auth_init, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_auth_init, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (auth_switch[0].name == NULL)
debug_return_int(0);
{
sudo_auth *auth;
int status = AUTH_SUCCESS;
- debug_decl(sudo_auth_cleanup, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_auth_cleanup, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Call cleanup routines. */
for (auth = auth_switch; auth->name; auth++) {
pass_warn(void)
{
const char *warning = def_badpass_message;
- debug_decl(pass_warn, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(pass_warn, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
#ifdef INSULT
if (def_insults)
sudo_auth *auth;
sigset_t mask, omask;
sigaction_t sa, saved_sigtstp;
- debug_decl(verify_user, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(verify_user, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Make sure we have at least one auth method. */
if (auth_switch[0].name == NULL) {
{
sudo_auth *auth;
int status = AUTH_SUCCESS;
- debug_decl(sudo_auth_begin_session, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_auth_begin_session, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
for (auth = auth_switch; auth->name; auth++) {
if (auth->begin_session && !IS_DISABLED(auth)) {
{
sudo_auth *auth;
bool needed = false;
- debug_decl(sudo_auth_needs_end_session, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_auth_needs_end_session, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
for (auth = auth_switch; auth->name; auth++) {
if (auth->end_session && !IS_DISABLED(auth)) {
{
sudo_auth *auth;
int status = AUTH_SUCCESS;
- debug_decl(sudo_auth_end_session, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_auth_end_session, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
for (auth = auth_switch; auth->name; auth++) {
if (auth->end_session && !IS_DISABLED(auth)) {
struct sudo_conv_message msg;
struct sudo_conv_reply repl;
sigset_t mask, omask;
- debug_decl(auth_getpass, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(auth_getpass, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Mask user input if pwfeedback set and echo is off. */
if (type == SUDO_CONV_PROMPT_ECHO_OFF && def_pwfeedback)
dump_auth_methods(void)
{
sudo_auth *auth;
- debug_decl(dump_auth_methods, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(dump_auth_methods, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
sudo_printf(SUDO_CONV_INFO_MSG, _("Authentication methods:"));
for (auth = auth_switch; auth->name; auth++)
unsigned char ch[4];
char *pos;
int i;
- debug_decl(base64_decode, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(base64_decode, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
/*
* Convert from base64 to binary. Each base64 char holds 6 bits of data
bool found = false;
ssize_t len;
FILE *fp;
- debug_decl(get_boottime, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(get_boottime, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/* read btime from /proc/stat */
fp = fopen("/proc/stat", "r");
{
size_t size;
int mib[2];
- debug_decl(get_boottime, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(get_boottime, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
mib[0] = CTL_KERN;
mib[1] = KERN_BOOTTIME;
get_boottime(struct timeval *tv)
{
struct utmpx *ut, key;
- debug_decl(get_boottime, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(get_boottime, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
memset(&key, 0, sizeof(key));
key.ut_type = BOOT_TIME;
get_boottime(struct timeval *tv)
{
struct utmp *ut, key;
- debug_decl(get_boottime, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(get_boottime, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
memset(&key, 0, sizeof(key));
key.ut_type = BOOT_TIME;
bool
get_boottime(struct timeval *tv)
{
- debug_decl(get_boottime, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(get_boottime, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
debug_return_bool(false);
}
#endif
auditinfo_addr_t ainfo_addr;
struct au_mask *mask;
int rc;
- debug_decl(audit_sudo_selected, SUDO_DEBUG_AUDIT, sudoers_debug_instance)
+ debug_decl(audit_sudo_selected, SUDOERS_DEBUG_AUDIT, sudoers_debug_instance)
if (getaudit_addr(&ainfo_addr, sizeof(ainfo_addr)) < 0) {
if (errno == ENOSYS) {
long au_cond;
int aufd, selected;
pid_t pid;
- debug_decl(bsm_audit_success, SUDO_DEBUG_AUDIT, sudoers_debug_instance)
+ debug_decl(bsm_audit_success, SUDOERS_DEBUG_AUDIT, sudoers_debug_instance)
/*
* If we are not auditing, don't cut an audit record; just return.
au_id_t auid;
pid_t pid;
int aufd;
- debug_decl(bsm_audit_success, SUDO_DEBUG_AUDIT, sudoers_debug_instance)
+ debug_decl(bsm_audit_success, SUDOERS_DEBUG_AUDIT, sudoers_debug_instance)
/*
* If we are not auditing, don't cut an audit record; just return.
check_user_interactive(int validated, int mode, struct passwd *auth_pw)
{
int status, rval = true;
- debug_decl(check_user_interactive, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(check_user_interactive, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Always need a password when -k was specified with the command. */
if (ISSET(mode, MODE_IGNORE_TICKET))
{
struct passwd *auth_pw;
int rval = -1;
- debug_decl(check_user, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(check_user, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/*
* Init authentication system regardless of whether we need a password.
ssize_t nread;
struct sudo_conv_message msg;
struct sudo_conv_reply repl;
- debug_decl(lecture, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(lecture, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (def_lecture == never ||
(def_lecture == once && already_lectured(status)))
user_is_exempt(void)
{
bool rval = false;
- debug_decl(user_is_exempt, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(user_is_exempt, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (def_exempt_group)
rval = user_in_group(sudo_user.pw, def_exempt_group);
get_authpw(int mode)
{
struct passwd *pw = NULL;
- debug_decl(get_authpw, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(get_authpw, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (ISSET(mode, (MODE_CHECK|MODE_LIST))) {
/* In list mode we always prompt for the user's password. */
struct list_member *item;
struct def_values *def;
char *desc;
- debug_decl(dump_defaults, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(dump_defaults, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
for (cur = sudo_defs_table; cur->name; cur++) {
if (cur->desc) {
{
struct sudo_defs_types *cur;
int num;
- debug_decl(set_default, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(set_default, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
for (cur = sudo_defs_table, num = 0; cur->name; cur++, num++) {
if (strcmp(var, cur->name) == 0)
{
static int firsttime = 1;
struct sudo_defs_types *def;
- debug_decl(init_defaults, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(init_defaults, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
/* Clear any old settings. */
if (!firsttime) {
{
struct defaults *def;
bool rc = true;
- debug_decl(update_defaults, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(update_defaults, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
TAILQ_FOREACH(def, &defaults, entries) {
switch (def->type) {
struct sudo_defs_types *cur;
struct defaults *def;
bool rc = true;
- debug_decl(check_defaults, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(check_defaults, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
TAILQ_FOREACH(def, &defaults, entries) {
switch (def->type) {
{
const char *errstr;
int i;
- debug_decl(store_int, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(store_int, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
if (op == false) {
def->sd_un.ival = 0;
{
const char *errstr;
unsigned int u;
- debug_decl(store_uint, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(store_uint, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
if (op == false) {
def->sd_un.uival = 0;
{
char *endp;
double d;
- debug_decl(store_float, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(store_float, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
if (op == false) {
def->sd_un.fval = 0.0;
store_tuple(char *val, struct sudo_defs_types *def, int op)
{
struct def_values *v;
- debug_decl(store_tuple, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(store_tuple, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
/*
* Look up tuple value by name to find enum def_tuple value.
static bool
store_str(char *val, struct sudo_defs_types *def, int op)
{
- debug_decl(store_str, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(store_str, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
sudo_efree(def->sd_un.str);
if (op == false)
store_list(char *str, struct sudo_defs_types *def, int op)
{
char *start, *end;
- debug_decl(store_list, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(store_list, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
/* Remove all old members. */
if (op == false || op == true)
store_syslogfac(char *val, struct sudo_defs_types *def, int op)
{
struct strmap *fac;
- debug_decl(store_syslogfac, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(store_syslogfac, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
if (op == false) {
def->sd_un.ival = false;
{
#ifdef LOG_NFACILITIES
struct strmap *fac;
- debug_decl(logfac2str, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(logfac2str, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
for (fac = facilities; fac->name && fac->num != n; fac++)
;
store_syslogpri(char *val, struct sudo_defs_types *def, int op)
{
struct strmap *pri;
- debug_decl(store_syslogpri, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(store_syslogpri, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
if (op == false || !val)
debug_return_bool(false);
logpri2str(int n)
{
struct strmap *pri;
- debug_decl(logpri2str, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(logpri2str, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
for (pri = priorities; pri->name && pri->num != n; pri++)
;
{
mode_t mode;
const char *errstr;
- debug_decl(store_mode, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(store_mode, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
if (op == false) {
def->sd_un.mode = 0777;
list_op(char *val, size_t len, struct sudo_defs_types *def, enum list_ops op)
{
struct list_member *cur, *prev = NULL;
- debug_decl(list_op, SUDO_DEBUG_DEFAULTS, sudoers_debug_instance)
+ debug_decl(list_op, SUDOERS_DEBUG_DEFAULTS, sudoers_debug_instance)
if (op == freeall) {
while ((cur = SLIST_FIRST(&def->sd_un.list)) != NULL) {
{
char * const *ep;
size_t len;
- debug_decl(env_init, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(env_init, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
if (envp == NULL) {
/* Reset to initial state but keep a pointer to what we allocated. */
sudo_putenv(char *str, bool dupcheck, bool overwrite)
{
int rval;
- debug_decl(sudo_putenv, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(sudo_putenv, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
sudo_debug_printf(SUDO_DEBUG_INFO, "sudo_putenv: %s", str);
char *estring;
size_t esize;
int rval = -1;
- debug_decl(sudo_setenv2, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(sudo_setenv2, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
esize = strlen(var) + 1 + strlen(val) + 1;
estring = sudo_emalloc(esize);
sudo_unsetenv(const char *name)
{
int rval;
- debug_decl(sudo_unsetenv, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(sudo_unsetenv, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
sudo_debug_printf(SUDO_DEBUG_INFO, "sudo_unsetenv: %s", name);
sudo_getenv(const char *name)
{
char *val;
- debug_decl(sudo_getenv, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(sudo_getenv, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
sudo_debug_printf(SUDO_DEBUG_INFO, "sudo_getenv: %s", name);
{
struct list_member *cur;
bool match = false;
- debug_decl(matches_env_list, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(matches_env_list, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
SLIST_FOREACH(cur, list, entries) {
size_t sep_pos, len = strlen(cur->value);
matches_env_delete(const char *var)
{
bool full_match; /* unused */
- debug_decl(matches_env_delete, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(matches_env_delete, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
/* Skip anything listed in env_delete. */
debug_return_bool(matches_env_list(var, &def_env_delete, &full_match));
matches_env_check(const char *var, bool *full_match)
{
int keepit = -1;
- debug_decl(matches_env_check, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(matches_env_check, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
/* Skip anything listed in env_check that includes '/' or '%'. */
if (matches_env_list(var, &def_env_check, full_match)) {
matches_env_keep(const char *var, bool *full_match)
{
bool keepit = false;
- debug_decl(matches_env_keep, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(matches_env_keep, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
/* Preserve SHELL variable for "sudo -s". */
if (ISSET(sudo_mode, MODE_SHELL) && strncmp(var, "SHELL=", 6) == 0) {
const char *cp;
int delete_it;
bool full_match = false;
- debug_decl(env_should_delete, SUDO_DEBUG_ENV, sudoers_debug_instance);
+ debug_decl(env_should_delete, SUDOERS_DEBUG_ENV, sudoers_debug_instance);
/* Skip variables with values beginning with () (bash functions) */
if ((cp = strchr(var, '=')) != NULL) {
int keepit;
bool full_match = false;
const char *cp;
- debug_decl(env_should_keep, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(env_should_keep, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
keepit = matches_env_check(var, &full_match);
if (keepit == -1)
{
char * const *ep;
bool rval = true;
- debug_decl(env_merge, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(env_merge, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
for (ep = envp; *ep != NULL; ep++) {
/* XXX - avoid checking value here, should only check name */
char idbuf[MAX_UID_T_LEN + 1];
unsigned int didvar;
bool reset_home = false;
- debug_decl(rebuild_env, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(rebuild_env, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
/*
* Either clean out the environment or reset to a safe default.
{
char * const *ep;
bool rval = true;
- debug_decl(insert_env_vars, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(insert_env_vars, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
/* Add user-specified environment variables. */
if (envp != NULL) {
char *eq, *bad = NULL;
size_t len, blen = 0, bsize = 0;
bool okvar, rval = true;
- debug_decl(validate_env_vars, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(validate_env_vars, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
if (env_vars == NULL)
debug_return_bool(true); /* nothing to do */
bool rval = true;
char *cp, *var, *val, *line = NULL;
size_t var_len, val_len, linesize = 0;
- debug_decl(read_env_file, SUDO_DEBUG_ENV, sudoers_debug_instance)
+ debug_decl(read_env_file, SUDOERS_DEBUG_ENV, sudoers_debug_instance)
if ((fp = fopen(path, "r")) == NULL) {
if (errno != ENOENT)
bool found = false; /* did we find the command? */
bool checkdot = false; /* check current dir? */
int len; /* length parameter */
- debug_decl(find_path, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(find_path, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (strlen(infile) >= PATH_MAX) {
errno = ENAMETOOLONG;
sudo_getepw(const struct passwd *pw)
{
char *epw = NULL;
- debug_decl(sudo_getepw, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_getepw, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* If there is a function to check for shadow enabled, use it... */
#ifdef HAVE_ISCOMSEC
void
sudo_setspent(void)
{
- debug_decl(sudo_setspent, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_setspent, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
#ifdef HAVE_GETPRPWNAM
setprpwent();
void
sudo_endspent(void)
{
- debug_decl(sudo_endspent, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(sudo_endspent, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
#ifdef HAVE_GETPRPWNAM
endprpwent();
{
struct stat sb;
bool rval = false;
- debug_decl(sudo_goodpath, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(sudo_goodpath, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (path != NULL && stat(path, &sb) == 0) {
/* Make sure path describes an executable regular file. */
void
sudoerserror(const char *s)
{
- debug_decl(sudoerserror, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(sudoerserror, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
/* If we last saw a newline the error is on the preceding line. */
if (last_token == COMMENT)
new_default(char *var, char *val, int op)
{
struct defaults *d;
- debug_decl(new_default, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(new_default, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
d = sudo_ecalloc(1, sizeof(struct defaults));
d->var = var;
new_member(char *name, int type)
{
struct member *m;
- debug_decl(new_member, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(new_member, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
m = sudo_ecalloc(1, sizeof(struct member));
m->name = name;
new_digest(int digest_type, const char *digest_str)
{
struct sudo_digest *dig;
- debug_decl(new_digest, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(new_digest, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
dig = sudo_emalloc(sizeof(*dig));
dig->digest_type = digest_type;
{
struct defaults *d;
struct member_list *binding;
- debug_decl(add_defaults, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(add_defaults, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
if (defs != NULL) {
/*
add_userspec(struct member *members, struct privilege *privs)
{
struct userspec *u;
- debug_decl(add_userspec, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(add_userspec, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
u = sudo_ecalloc(1, sizeof(*u));
HLTQ_TO_TAILQ(&u->users, members, entries);
struct member_list *binding;
struct defaults *d, *d_next;
struct userspec *us, *us_next;
- debug_decl(init_parser, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(init_parser, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
TAILQ_FOREACH_SAFE(us, &userspecs, entries, us_next) {
struct member *m, *m_next;
void
sudoerserror(const char *s)
{
- debug_decl(sudoerserror, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(sudoerserror, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
/* If we last saw a newline the error is on the preceding line. */
if (last_token == COMMENT)
new_default(char *var, char *val, int op)
{
struct defaults *d;
- debug_decl(new_default, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(new_default, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
d = sudo_ecalloc(1, sizeof(struct defaults));
d->var = var;
new_member(char *name, int type)
{
struct member *m;
- debug_decl(new_member, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(new_member, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
m = sudo_ecalloc(1, sizeof(struct member));
m->name = name;
new_digest(int digest_type, const char *digest_str)
{
struct sudo_digest *dig;
- debug_decl(new_digest, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(new_digest, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
dig = sudo_emalloc(sizeof(*dig));
dig->digest_type = digest_type;
{
struct defaults *d;
struct member_list *binding;
- debug_decl(add_defaults, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(add_defaults, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
if (defs != NULL) {
/*
add_userspec(struct member *members, struct privilege *privs)
{
struct userspec *u;
- debug_decl(add_userspec, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(add_userspec, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
u = sudo_ecalloc(1, sizeof(*u));
HLTQ_TO_TAILQ(&u->users, members, entries);
struct member_list *binding;
struct defaults *d, *d_next;
struct userspec *us, *us_next;
- debug_decl(init_parser, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(init_parser, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
TAILQ_FOREACH_SAFE(us, &userspecs, entries, us_next) {
struct member *m, *m_next;
char *args, path[PATH_MAX];
char **argv = NULL;
int len, rc = -1;
- debug_decl(group_plugin_load, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(group_plugin_load, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/*
* Fill in .so path and split out args (if any).
void
group_plugin_unload(void)
{
- debug_decl(group_plugin_unload, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(group_plugin_unload, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (group_plugin != NULL) {
(group_plugin->cleanup)();
group_plugin_query(const char *user, const char *group,
const struct passwd *pwd)
{
- debug_decl(group_plugin_query, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(group_plugin_query, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (group_plugin == NULL)
debug_return_bool(false);
int
group_plugin_load(char *plugin_info)
{
- debug_decl(group_plugin_load, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(group_plugin_load, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
debug_return_bool(false);
}
void
group_plugin_unload(void)
{
- debug_decl(group_plugin_unload, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(group_plugin_unload, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
debug_return;
}
group_plugin_query(const char *user, const char *group,
const struct passwd *pwd)
{
- debug_decl(group_plugin_query, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(group_plugin_query, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
debug_return_bool(false);
}
{
unsigned char result[2];
int i;
- debug_decl(hexchar, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(hexchar, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
for (i = 0; i < 2; i++) {
switch (s[i]) {
{
char *addrinfo, *addr, *mask;
struct interface *ifp;
- debug_decl(set_interfaces, SUDO_DEBUG_NETIF, sudoers_debug_instance)
+ debug_decl(set_interfaces, SUDOERS_DEBUG_NETIF, sudoers_debug_instance)
addrinfo = sudo_estrdup(ai);
for (addr = strtok(addrinfo, " \t"); addr != NULL; addr = strtok(NULL, " \t")) {
dump_interfaces(const char *ai)
{
char *cp, *addrinfo;
- debug_decl(set_interfaces, SUDO_DEBUG_NETIF, sudoers_debug_instance)
+ debug_decl(set_interfaces, SUDOERS_DEBUG_NETIF, sudoers_debug_instance)
addrinfo = sudo_estrdup(ai);
gid_t parent_gid = 0;
char *slash = path;
bool ok = true;
- debug_decl(io_mkdirs, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(io_mkdirs, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/* Fast path: not a temporary and already exists. */
if (!is_temp && stat(path, &sb) == 0) {
{
const char *errstr;
unsigned int value;
- debug_decl(io_set_max_sessid, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(io_set_max_sessid, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
value = strtonum(maxval, 0, SESSID_MAX, &errstr);
if (errstr != NULL) {
ssize_t nread;
char pathbuf[PATH_MAX];
static const char b36char[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
- debug_decl(io_nextid, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(io_nextid, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/*
* Create I/O log directory if it doesn't already exist.
{
size_t len;
bool is_temp = false;
- debug_decl(mkdir_iopath, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(mkdir_iopath, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
len = strlcpy(pathbuf, iolog_path, pathsize);
if (len >= pathsize) {
open_io_fd(char *pathbuf, size_t len, struct io_log_file *iol, bool docompress)
{
int fd;
- debug_decl(open_io_fd, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(open_io_fd, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
pathbuf[len] = '\0';
strlcat(pathbuf, iol->suffix, PATH_MAX);
id_t id;
uid_t runas_uid = 0;
gid_t runas_gid = 0;
- debug_decl(iolog_deserialize_info, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(iolog_deserialize_info, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
details->lines = 24;
details->cols = 80;
char * const *av;
FILE *fp;
int fd;
- debug_decl(write_info_log, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(write_info_log, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
pathbuf[len] = '\0';
strlcat(pathbuf, "/log", PATH_MAX);
const char *plugin_path = NULL;
size_t len;
int i, prev_instance, rval = -1;
- debug_decl(sudoers_io_open, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_io_open, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
sudo_conv = conversation;
sudo_printf = plugin_printf;
sudoers_io_close(int exit_status, int error)
{
int i, prev_instance;
- debug_decl(sudoers_io_close, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_io_close, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
sudoers_io_version(int verbose)
{
int prev_instance;
- debug_decl(sudoers_io_version, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_io_version, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
{
struct timeval now, delay;
int prev_instance, rval = true;
- debug_decl(sudoers_io_version, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_io_version, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
fill_seq(char *str, size_t strsize, char *logdir)
{
#ifdef SUDOERS_NO_SEQ
- debug_decl(fill_seq, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(fill_seq, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
debug_return_size_t(strlcpy(str, "%{seq}", strsize));
#else
static char sessid[7];
int len;
- debug_decl(fill_seq, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(fill_seq, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (sessid[0] == '\0') {
if (!io_nextid(logdir, def_iolog_dir, sessid))
static size_t
fill_user(char *str, size_t strsize, char *unused)
{
- debug_decl(fill_user, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(fill_user, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
debug_return_size_t(strlcpy(str, user_name, strsize));
}
{
struct group *grp;
size_t len;
- debug_decl(fill_group, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(fill_group, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if ((grp = sudo_getgrgid(user_gid)) != NULL) {
len = strlcpy(str, grp->gr_name, strsize);
static size_t
fill_runas_user(char *str, size_t strsize, char *unused)
{
- debug_decl(fill_runas_user, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(fill_runas_user, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
debug_return_size_t(strlcpy(str, runas_pw->pw_name, strsize));
}
{
struct group *grp;
size_t len;
- debug_decl(fill_runas_group, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(fill_runas_group, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (runas_gr != NULL) {
len = strlcpy(str, runas_gr->gr_name, strsize);
static size_t
fill_hostname(char *str, size_t strsize, char *unused)
{
- debug_decl(fill_hostname, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(fill_hostname, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
debug_return_size_t(strlcpy(str, user_shost, strsize));
}
static size_t
fill_command(char *str, size_t strsize, char *unused)
{
- debug_decl(fill_command, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(fill_command, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
debug_return_size_t(strlcpy(str, user_base, strsize));
}
struct path_escape *escapes = NULL;
int pass, oldlocale;
bool strfit;
- debug_decl(expand_iolog_path, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(expand_iolog_path, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/* Expanded path must be <= PATH_MAX */
if (prefix != NULL)
char *host, *port, defport[13];
char hostbuf[LINE_MAX * 2];
int len;
- debug_decl(sudo_ldap_conf_add_ports, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_conf_add_ports, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
hostbuf[0] = '\0';
len = snprintf(defport, sizeof(defport), ":%d", ldap_conf.port);
char hostbuf[LINE_MAX];
int nldap = 0, nldaps = 0;
int rc = -1;
- debug_decl(sudo_ldap_parse_uri, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_parse_uri, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
hostbuf[0] = '\0';
STAILQ_FOREACH(entry, uri_list, entries) {
struct ldap_config_str *uri;
size_t len = 0;
char *buf, *cp;
- debug_decl(sudo_ldap_join_uri, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_join_uri, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
STAILQ_FOREACH(uri, uri_list, entries) {
if (ldap_conf.ssl_mode == SUDO_LDAP_STARTTLS) {
{
LDAP *ld;
int rc = LDAP_CONNECT_ERROR;
- debug_decl(sudo_ldap_init, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_init, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
#ifdef HAVE_LDAPSSL_INIT
if (ldap_conf.ssl_mode != SUDO_LDAP_CLEAR) {
struct berval **bv, **p;
char *val;
int ret = false;
- debug_decl(sudo_ldap_check_non_unix_group, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_check_non_unix_group, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (!entry)
debug_return_bool(ret);
struct berval **bv, **p;
char *val;
bool ret = false;
- debug_decl(sudo_ldap_check_host, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_check_host, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (!entry)
debug_return_bool(ret);
struct berval **bv, **p;
char *val;
bool ret = false;
- debug_decl(sudo_ldap_check_runas_user, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_check_runas_user, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (!runas_pw)
debug_return_bool(UNSPEC);
struct berval **bv, **p;
char *val;
bool ret = false;
- debug_decl(sudo_ldap_check_runas_group, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_check_runas_group, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* runas_gr is only set if the user specified the -g flag */
if (!runas_gr)
sudo_ldap_check_runas(LDAP *ld, LDAPMessage *entry)
{
bool ret;
- debug_decl(sudo_ldap_check_runas, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_check_runas, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (!entry)
debug_return_bool(false);
{
char *ep, *cp = *cmnd;
int digest_type = SUDO_DIGEST_INVALID;
- debug_decl(sudo_ldap_check_command, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_check_command, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/*
* Check for and extract a digest prefix, e.g.
char *allowed_cmnd, *allowed_args, *val;
bool foundbang;
int ret = UNSPEC;
- debug_decl(sudo_ldap_check_command, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_check_command, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (!entry)
debug_return_bool(ret);
struct berval **bv, **p;
char ch, *var;
int ret = UNSPEC;
- debug_decl(sudo_ldap_check_bool, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_check_bool, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (entry == NULL)
debug_return_bool(ret);
{
struct berval **bv, **p;
char op, *var, *val;
- debug_decl(sudo_ldap_parse_options, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_parse_options, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (entry == NULL)
debug_return;
time_t now;
char timebuffer[sizeof("20120727121554.0Z")];
int bytes = 0;
- debug_decl(sudo_ldap_timefilter, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_timefilter, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* Make sure we have a formatted timestamp for __now__. */
time(&now);
sudo_ldap_build_default_filter(void)
{
char *filt;
- debug_decl(sudo_ldap_build_default_filter, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_build_default_filter, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (ldap_conf.search_filter)
sudo_easprintf(&filt, "(&%s(cn=defaults))", ldap_conf.search_filter);
struct group_list *grlist;
size_t sz = 0;
int i;
- debug_decl(sudo_ldap_build_pass1, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_build_pass1, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* If there is a filter, allocate space for the global AND. */
if (ldap_conf.timed || ldap_conf.search_filter)
sudo_ldap_build_pass2(void)
{
char *filt, timebuffer[TIMEFILTER_LENGTH + 1];
- debug_decl(sudo_ldap_build_pass2, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_build_pass2, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* Short circuit if no non-Unix group support. */
if (!def_use_netgroups && !def_group_plugin) {
{
unsigned char *result = NULL;
size_t len, reslen;
- debug_decl(sudo_ldap_decode_secret, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_decode_secret, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (strncasecmp(secret, "base64:", sizeof("base64:") - 1) == 0) {
/*
{
FILE *fp;
char buf[LINE_MAX];
- debug_decl(sudo_ldap_read_secret, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_read_secret, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if ((fp = fopen(path_ldap_secret, "r")) != NULL) {
if (fgets(buf, sizeof(buf), fp) != NULL) {
{
struct ldap_config_table *cur;
const char *errstr;
- debug_decl(sudo_ldap_parse_keyword, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_parse_keyword, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* Look up keyword in config tables */
for (cur = table; cur->conf_str != NULL; cur++) {
sudo_krb5_ccname_path(const char *old_ccname)
{
const char *ccname = old_ccname;
- debug_decl(sudo_krb5_ccname_path, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_krb5_ccname_path, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* Strip off leading FILE: or WRFILE: prefix. */
switch (ccname[0]) {
{
int fd = -1;
const char *ccname_path;
- debug_decl(sudo_check_krb5_ccname, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_check_krb5_ccname, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* Strip off prefix to get path name. */
ccname_path = sudo_krb5_ccname_path(ccname);
FILE *fp;
char *cp, *keyword, *value, *line = NULL;
size_t linesize = 0;
- debug_decl(sudo_ldap_read_config, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_read_config, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* defaults */
ldap_conf.version = 3;
#ifdef HAVE_LDAP_STR2DN
char *dn, *rdn = NULL;
LDAPDN tmpDN;
- debug_decl(sudo_ldap_get_first_rdn, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_get_first_rdn, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if ((dn = ldap_get_dn(ld, entry)) == NULL)
debug_return_str(NULL);
debug_return_str(rdn);
#else
char *dn, **edn;
- debug_decl(sudo_ldap_get_first_rdn, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_get_first_rdn, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if ((dn = ldap_get_dn(ld, entry)) == NULL)
return NULL;
LDAPMessage *entry, *result;
char *prefix, *filt;
int rc, count = 0;
- debug_decl(sudo_ldap_display_defaults, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_display_defaults, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (handle == NULL || handle->ld == NULL)
goto done;
sudo_ldap_display_bound_defaults(struct sudo_nss *nss, struct passwd *pw,
struct sudo_lbuf *lbuf)
{
- debug_decl(sudo_ldap_display_bound_defaults, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_display_bound_defaults, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
debug_return_int(0);
}
{
struct berval **bv, **p;
int count = 0;
- debug_decl(sudo_ldap_display_entry_short, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_display_entry_short, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
sudo_lbuf_append(lbuf, " (");
struct berval **bv, **p;
char *rdn;
int count = 0;
- debug_decl(sudo_ldap_display_entry_long, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_display_entry_long, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* extract the dn, only show the first rdn */
rdn = sudo_ldap_get_first_rdn(ld, entry);
struct ldap_result *lres;
LDAPMessage *entry;
int i, count = 0;
- debug_decl(sudo_ldap_display_privs, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_display_privs, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (handle == NULL || handle->ld == NULL)
goto done;
LDAPMessage *entry;
bool found = false;
int i;
- debug_decl(sudo_ldap_display_cmnd, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_display_cmnd, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (handle == NULL || handle->ld == NULL)
goto done;
int rc = 0;
unsigned int junk;
static bool initialized;
- debug_decl(sudo_set_krb5_ccache_name, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_set_krb5_ccache_name, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (!initialized) {
sudo_gss_krb5_ccache_name =
ssize_t nread, nwritten = -1;
static char new_ccname[sizeof(_PATH_TMP) + sizeof("sudocc_XXXXXXXX") - 1];
char buf[10240], *ret = NULL;
- debug_decl(sudo_krb5_copy_cc_file, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_krb5_copy_cc_file, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
old_ccname = sudo_krb5_ccname_path(old_ccname);
if (old_ccname != NULL) {
char *auth_id = (char *)_auth_id;
sasl_interact_t *interact = (sasl_interact_t *)_interact;
int rc = LDAP_SUCCESS;
- debug_decl(sudo_ldap_sasl_interact, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_sasl_interact, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
for (; interact->id != SASL_CB_LIST_END; interact++) {
if (interact->id != SASL_CB_USER) {
struct ldap_config_table *cur;
int ival, rc, errors = 0;
char *sval;
- debug_decl(sudo_ldap_set_options_table, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_set_options_table, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
for (cur = table; cur->conf_str != NULL; cur++) {
if (cur->opt_val == -1)
sudo_ldap_set_options_global(void)
{
int rc;
- debug_decl(sudo_ldap_set_options_global, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_set_options_global, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* Set ber options */
#ifdef LBER_OPT_DEBUG_LEVEL
sudo_ldap_set_options_conn(LDAP *ld)
{
int rc;
- debug_decl(sudo_ldap_set_options_conn, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_set_options_conn, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* Parse per-connection LDAP options table. */
rc = sudo_ldap_set_options_table(ld, ldap_conf_conn);
sudo_ldap_result_alloc(void)
{
struct ldap_result *result;
- debug_decl(sudo_ldap_result_alloc, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_result_alloc, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
result = sudo_ecalloc(1, sizeof(*result));
STAILQ_INIT(&result->searches);
sudo_ldap_result_free(struct ldap_result *lres)
{
struct ldap_search_result *s;
- debug_decl(sudo_ldap_result_free, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_result_free, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (lres != NULL) {
if (lres->nentries) {
LDAPMessage *searchresult)
{
struct ldap_search_result *news;
- debug_decl(sudo_ldap_result_add_search, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_result_add_search, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* Create new entry and add it to the end of the chain. */
news = sudo_ecalloc(1, sizeof(*news));
sudo_ldap_bind_s(LDAP *ld)
{
int rc;
- debug_decl(sudo_ldap_bind_s, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_bind_s, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
#ifdef HAVE_LDAP_SASL_INTERACTIVE_BIND_S
if (ldap_conf.rootuse_sasl == true ||
sigaction_t sa, saved_sa_pipe;
bool ldapnoinit = false;
struct sudo_ldap_handle *handle;
- debug_decl(sudo_ldap_open, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_open, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* Ignore SIGPIPE if we cannot bind to the server. */
memset(&sa, 0, sizeof(sa));
LDAPMessage *entry, *result;
char *filt;
int rc;
- debug_decl(sudo_ldap_setdefs, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_setdefs, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (handle == NULL || handle->ld == NULL)
debug_return_int(-1);
LDAPMessage *entry;
int i, rc, setenv_implied;
struct ldap_result *lres = NULL;
- debug_decl(sudo_ldap_lookup, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_lookup, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (handle == NULL || handle->ld == NULL)
debug_return_int(ret);
{
const struct ldap_entry_wrapper *aw = a;
const struct ldap_entry_wrapper *bw = b;
- debug_decl(ldap_entry_compare, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(ldap_entry_compare, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
debug_return_int(bw->order < aw->order ? -1 :
(bw->order > aw->order ? 1 : 0));
static struct ldap_search_result *
sudo_ldap_result_last_search(struct ldap_result *lres)
{
- debug_decl(sudo_ldap_result_last_search, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_result_last_search, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
debug_return_ptr(STAILQ_LAST(&lres->searches, ldap_search_result, entries));
}
struct berval **bv;
double order = 0.0;
char *ep;
- debug_decl(sudo_ldap_result_add_entry, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_result_add_entry, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/* Determine whether the entry has the sudoOrder attribute. */
last = sudo_ldap_result_last_search(lres);
sudo_ldap_result_free_nss(struct sudo_nss *nss)
{
struct sudo_ldap_handle *handle = nss->handle;
- debug_decl(sudo_ldap_result_free_nss, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_result_free_nss, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (handle->result != NULL) {
DPRINTF1("removing reusable search result");
LDAP *ld = handle->ld;
int pass, rc;
char *filt;
- debug_decl(sudo_ldap_result_get, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_result_get, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/*
* If we already have a cached result, return it so we don't have to
sudo_ldap_close(struct sudo_nss *nss)
{
struct sudo_ldap_handle *handle = nss->handle;
- debug_decl(sudo_ldap_close, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_ldap_close, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
if (handle != NULL) {
/* Free the result before unbinding; it may use the LDAP connection. */
linux_audit_open(void)
{
static int au_fd = -1;
- debug_decl(linux_audit_open, SUDO_DEBUG_AUDIT, sudoers_debug_instance)
+ debug_decl(linux_audit_open, SUDOERS_DEBUG_AUDIT, sudoers_debug_instance)
if (au_fd != -1)
debug_return_int(au_fd);
int au_fd, rc = -1;
char *command, *cp, **av;
size_t size, n;
- debug_decl(linux_audit_command, SUDO_DEBUG_AUDIT, sudoers_debug_instance)
+ debug_decl(linux_audit_command, SUDOERS_DEBUG_AUDIT, sudoers_debug_instance)
/* Don't return an error if auditing is not configured. */
if ((au_fd = linux_audit_open()) < 0)
#endif
char buf[MAXSYSLOGLEN+1];
va_list ap;
- debug_decl(mysyslog, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(mysyslog, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
va_start(ap, fmt);
#ifdef LOG_NFACILITIES
char *p, *tmp, save;
const char *fmt;
int oldlocale;
- debug_decl(do_syslog, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(do_syslog, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
sudoers_setlocale(SUDOERS_LOCALE_SUDOERS, &oldlocale);
mode_t oldmask;
int oldlocale;
FILE *fp;
- debug_decl(do_logfile, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(do_logfile, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
sudoers_setlocale(SUDOERS_LOCALE_SUDOERS, &oldlocale);
char *logline;
int oldlocale;
bool uid_changed;
- debug_decl(log_denial, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(log_denial, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
/* Handle auditing first (audit_failure() handles the locale itself). */
if (ISSET(status, FLAG_NO_USER | FLAG_NO_HOST))
log_failure(int status, int flags)
{
bool inform_user = true;
- debug_decl(log_failure, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(log_failure, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
/* The user doesn't always get to see the log message (path info). */
if (!ISSET(status, FLAG_NO_USER | FLAG_NO_HOST) && def_path_info &&
log_auth_failure(int status, unsigned int tries)
{
int flags = 0;
- debug_decl(log_auth_failure, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(log_auth_failure, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
/* Handle auditing first. */
audit_failure(NewArgc, NewArgv, N_("authentication failure"));
char *logline;
int oldlocale;
bool uid_changed;
- debug_decl(log_allowed, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(log_allowed, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
/* Log and mail messages should be in the sudoers locale. */
sudoers_setlocale(SUDOERS_LOCALE_SUDOERS, &oldlocale);
char *logline, *message;
bool uid_changed;
va_list ap2;
- debug_decl(vlog_error, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(vlog_error, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
/* Need extra copy of ap for sudo_vwarn()/sudo_vwarnx() below. */
if (!ISSET(flags, SLOG_NO_STDERR))
log_warning(int flags, const char *fmt, ...)
{
va_list ap;
- debug_decl(log_error, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(log_error, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
/* Log the error. */
va_start(ap, fmt);
log_warningx(int flags, const char *fmt, ...)
{
va_list ap;
- debug_decl(log_error, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(log_error, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
/* Log the error. */
va_start(ap, fmt);
NULL
};
#endif /* NO_ROOT_MAILER */
- debug_decl(send_mail, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(send_mail, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
/* If mailer is disabled just return. */
if (!def_mailerpath || !def_mailto)
static int
should_mail(int status)
{
- debug_decl(should_mail, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(should_mail, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
debug_return_bool(def_mail_always || ISSET(status, VALIDATE_ERROR) ||
(def_mail_no_user && ISSET(status, FLAG_NO_USER)) ||
#endif
const char *tsid = NULL;
size_t len = 0;
- debug_decl(new_logline, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(new_logline, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
#ifndef SUDOERS_NO_SEQ
/* A TSID may be a sudoers-style session ID or a free-form string. */
char *indent = "";
char *beg = line;
char *end;
- debug_decl(writeln_wrap, SUDO_DEBUG_LOGGING, sudoers_debug_instance)
+ debug_decl(writeln_wrap, SUDOERS_DEBUG_LOGGING, sudoers_debug_instance)
/*
* Print out line with word wrap around maxlen characters.
struct member *m;
struct alias *a;
int rval, matched = UNSPEC;
- debug_decl(userlist_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(userlist_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
TAILQ_FOREACH_REVERSE(m, list, member_list, entries) {
switch (m->type) {
int rval;
int user_matched = UNSPEC;
int group_matched = UNSPEC;
- debug_decl(runaslist_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(runaslist_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
if (runas_pw != NULL) {
/* If no runas user or runas group listed in sudoers, use default. */
struct member *m;
struct alias *a;
int rval, matched = UNSPEC;
- debug_decl(hostlist_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(hostlist_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
TAILQ_FOREACH_REVERSE(m, list, member_list, entries) {
switch (m->type) {
{
struct member *m;
int matched = UNSPEC;
- debug_decl(cmndlist_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(cmndlist_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
TAILQ_FOREACH_REVERSE(m, list, member_list, entries) {
matched = cmnd_matches(m);
struct alias *a;
struct sudo_command *c;
int rval, matched = UNSPEC;
- debug_decl(cmnd_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(cmnd_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
switch (m->type) {
case ALL:
command_args_match(const char *sudoers_cmnd, const char *sudoers_args)
{
int flags = 0;
- debug_decl(command_args_match, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(command_args_match, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
/*
* If no args specified in sudoers, any user args are allowed.
command_matches(const char *sudoers_cmnd, const char *sudoers_args, const struct sudo_digest *digest)
{
bool rc = false;
- debug_decl(command_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(command_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
/* Check for pseudo-commands */
if (sudoers_cmnd[0] != '/') {
static bool
command_matches_fnmatch(const char *sudoers_cmnd, const char *sudoers_args)
{
- debug_decl(command_matches_fnmatch, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(command_matches_fnmatch, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
/*
* Return true if fnmatch(3) succeeds AND
size_t dlen;
char **ap, *base, *cp;
glob_t gl;
- debug_decl(command_matches_glob, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(command_matches_glob, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
/*
* First check to see if we can avoid the call to glob(3).
command_matches_normal(const char *sudoers_cmnd, const char *sudoers_args, const struct sudo_digest *digest)
{
size_t dlen;
- debug_decl(command_matches_normal, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(command_matches_normal, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
dlen = strlen(sudoers_cmnd);
FILE *fp;
unsigned int i;
int h;
- debug_decl(digest_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(digest_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
for (i = 0; digest_functions[i].digest_name != NULL; i++) {
if (sd->digest_type == i) {
struct stat sudoers_stat;
const char *base;
size_t dlen;
- debug_decl(command_matches_normal, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(command_matches_normal, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
/* If it ends in '/' it is a directory spec. */
dlen = strlen(sudoers_cmnd);
static bool
command_matches_dir(const char *sudoers_dir, size_t dlen)
{
- debug_decl(command_matches_dir, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(command_matches_dir, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
debug_return_bool(strncmp(user_cmnd, sudoers_dir, dlen) == 0);
}
#else /* !SUDOERS_NAME_MATCH */
struct dirent *dent;
char buf[PATH_MAX];
DIR *dirp;
- debug_decl(command_matches_dir, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(command_matches_dir, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
/*
* Grot through directory entries, looking for user_base.
{
const char *host;
bool rc;
- debug_decl(hostname_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(hostname_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
host = strchr(pattern, '.') != NULL ? lhost : shost;
if (has_meta(pattern)) {
const char *errstr;
uid_t uid;
bool rc;
- debug_decl(userpw_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(userpw_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
if (pw != NULL && *sudoers_user == '#') {
uid = (uid_t) sudo_strtoid(sudoers_user + 1, NULL, NULL, &errstr);
const char *errstr;
gid_t gid;
bool rc;
- debug_decl(group_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(group_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
if (*sudoers_group == '#') {
gid = (gid_t) sudo_strtoid(sudoers_group + 1, NULL, NULL, &errstr);
{
int matched = false;
struct passwd *pw0 = NULL;
- debug_decl(usergr_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(usergr_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
/* make sure we have a valid usergroup, sudo style */
if (*group++ != '%') {
static int initialized;
#endif
bool rc = false;
- debug_decl(netgr_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(netgr_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
if (!def_use_netgroups) {
sudo_debug_printf(SUDO_DEBUG_INFO, "netgroups are disabled");
unsigned int j;
#endif
unsigned int family;
- debug_decl(addr_matches_if, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(addr_matches_if, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
#ifdef HAVE_STRUCT_IN6_ADDR
if (inet_pton(AF_INET6, n, &addr.ip6) == 1) {
#endif
unsigned int family;
const char *errstr;
- debug_decl(addr_matches_if, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(addr_matches_if, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
#ifdef HAVE_STRUCT_IN6_ADDR
if (inet_pton(AF_INET6, n, &addr.ip6) == 1)
{
char *m;
bool rc;
- debug_decl(addr_matches, SUDO_DEBUG_MATCH, sudoers_debug_instance)
+ debug_decl(addr_matches, SUDOERS_DEBUG_MATCH, sudoers_debug_instance)
/* If there's an explicit netmask, use it. */
if ((m = strchr(n, '/'))) {
int
sudo_file_open(struct sudo_nss *nss)
{
- debug_decl(sudo_file_open, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_open, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (def_ignore_local_sudoers)
debug_return_int(-1);
int
sudo_file_close(struct sudo_nss *nss)
{
- debug_decl(sudo_file_close, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_close, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
/* Free parser data structures and close sudoers file. */
init_parser(NULL, false);
int
sudo_file_parse(struct sudo_nss *nss)
{
- debug_decl(sudo_file_close, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_close, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (nss->handle == NULL)
debug_return_int(-1);
int
sudo_file_setdefs(struct sudo_nss *nss)
{
- debug_decl(sudo_file_setdefs, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_setdefs, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (nss->handle == NULL)
debug_return_int(-1);
struct privilege *priv;
struct userspec *us;
struct member *matching_user;
- debug_decl(sudo_file_lookup, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_lookup, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (nss->handle == NULL)
debug_return_int(validated);
sudo_file_append_cmnd(struct cmndspec *cs, struct cmndtag *tags,
struct sudo_lbuf *lbuf)
{
- debug_decl(sudo_file_append_cmnd, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_append_cmnd, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
#ifdef HAVE_PRIV_SET
if (cs->privs)
struct privilege *priv;
struct cmndtag tags;
int nfound = 0;
- debug_decl(sudo_file_display_priv_short, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_display_priv_short, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
/* gcc -Wuninitialized false positive */
tags.noexec = UNSPEC;
struct member *m;
struct privilege *priv;
int nfound = 0, olen;
- debug_decl(sudo_file_display_priv_long, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_display_priv_long, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
TAILQ_FOREACH(priv, &us->privileges, entries) {
if (hostlist_matches(&priv->hostlist) != ALLOW)
{
struct userspec *us;
int nfound = 0;
- debug_decl(sudo_file_display_priv, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_display_priv, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (nss->handle == NULL)
goto done;
struct defaults *d;
char *prefix;
int nfound = 0;
- debug_decl(sudo_file_display_defaults, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_display_defaults, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (nss->handle == NULL)
goto done;
struct sudo_lbuf *lbuf)
{
int nfound = 0;
- debug_decl(sudo_file_display_bound_defaults, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_display_bound_defaults, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
/* XXX - should only print ones that match what the user can do. */
nfound += display_bound_defaults(DEFAULTS_RUNAS, lbuf);
struct member *m;
char *dsep;
int atype, nfound = 0;
- debug_decl(display_bound_defaults, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(display_bound_defaults, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
switch (dtype) {
case DEFAULTS_HOST:
struct userspec *us;
int rval = 1;
int host_match, runas_match, cmnd_match;
- debug_decl(sudo_file_display_cmnd, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_file_display_cmnd, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (nss->handle == NULL)
goto done;
struct alias *a;
struct member *m;
struct sudo_command *c;
- debug_decl(_print_member, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(_print_member, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
switch (type) {
case ALL:
const char *plugin_path = NULL;
struct sudo_conf_debug_file_list debug_files = TAILQ_HEAD_INITIALIZER(debug_files);
int flags = 0;
- debug_decl(sudoers_policy_deserialize_info, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_deserialize_info, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
#define MATCHES(s, v) (strncmp(s, v, sizeof(v) - 1) == 0)
char **command_info;
int info_len = 0;
int rval = -1;
- debug_decl(sudoers_policy_exec_setup, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_exec_setup, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
/* Increase the length of command_info as needed, it is *not* checked. */
command_info = sudo_ecalloc(32, sizeof(char **));
{
struct sudoers_policy_open_info info;
int prev_instance, rval;
- debug_decl(sudoers_policy_open, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_open, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
sudo_version = version;
sudo_conv = conversation;
sudoers_policy_close(int exit_status, int error_code)
{
int prev_instance;
- debug_decl(sudoers_policy_close, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_close, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
sudoers_policy_init_session(struct passwd *pwd, char **user_env[])
{
int prev_instance, rval;
- debug_decl(sudoers_policy_init_session, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_init_session, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
{
struct sudoers_exec_args exec_args;
int prev_instance, rval;
- debug_decl(sudoers_policy_check, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_check, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
if (!ISSET(sudo_mode, MODE_EDIT))
sudoers_policy_validate(void)
{
int prev_instance, rval;
- debug_decl(sudoers_policy_validate, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_validate, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
user_cmnd = "validate";
sudoers_policy_invalidate(int remove)
{
int prev_instance;
- debug_decl(sudoers_policy_invalidate, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_invalidate, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
const char *list_user)
{
int prev_instance, rval = -1;
- debug_decl(sudoers_policy_list, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_list, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
sudoers_policy_version(int verbose)
{
int prev_instance;
- debug_decl(sudoers_policy_version, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_version, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
{
struct sudo_hook hook;
int prev_instance;
- debug_decl(sudoers_policy_register_hooks, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_register_hooks, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
prev_instance = sudo_debug_set_default_instance(sudoers_debug_instance);
int subst;
const char *p;
char *np, *new_prompt, *endp;
- debug_decl(expand_prompt, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(expand_prompt, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* How much space do we need to malloc for the prompt? */
subst = 0;
void
sudo_pw_addref(struct passwd *pw)
{
- debug_decl(sudo_pw_addref, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_pw_addref, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
ptr_to_item(pw)->refcnt++;
debug_return;
}
sudo_pw_delref_item(void *v)
{
struct cache_item *item = v;
- debug_decl(sudo_pw_delref_item, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_pw_delref_item, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (--item->refcnt == 0)
sudo_efree(item);
void
sudo_pw_delref(struct passwd *pw)
{
- debug_decl(sudo_pw_delref, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_pw_delref, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
sudo_pw_delref_item(ptr_to_item(pw));
debug_return;
}
{
struct cache_item key, *item;
struct rbnode *node;
- debug_decl(sudo_getpwuid, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_getpwuid, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
key.k.uid = uid;
if ((node = rbfind(pwcache_byuid, &key)) != NULL) {
struct cache_item key, *item;
struct rbnode *node;
size_t len;
- debug_decl(sudo_getpwnam, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_getpwnam, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
key.k.name = (char *) name;
if ((node = rbfind(pwcache_byname, &key)) != NULL) {
struct rbnode *node;
size_t len, name_len, home_len, shell_len;
int i;
- debug_decl(sudo_mkpwent, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_mkpwent, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
/* Optional arguments. */
if (home == NULL)
{
const char *errstr;
uid_t uid;
- debug_decl(sudo_fakepwnam, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_fakepwnam, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
uid = (uid_t) sudo_strtoid(user + 1, NULL, NULL, &errstr);
if (errstr != NULL) {
void
sudo_setpwent(void)
{
- debug_decl(sudo_setpwent, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_setpwent, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
setpwent();
if (pwcache_byuid == NULL)
void
sudo_freepwcache(void)
{
- debug_decl(sudo_freepwcache, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_freepwcache, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (pwcache_byuid != NULL) {
rbdestroy(pwcache_byuid, sudo_pw_delref_item);
void
sudo_endpwent(void)
{
- debug_decl(sudo_endpwent, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_endpwent, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
endpwent();
sudo_freepwcache();
void
sudo_gr_addref(struct group *gr)
{
- debug_decl(sudo_gr_addref, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_gr_addref, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
ptr_to_item(gr)->refcnt++;
debug_return;
}
sudo_gr_delref_item(void *v)
{
struct cache_item *item = v;
- debug_decl(sudo_gr_delref_item, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_gr_delref_item, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (--item->refcnt == 0)
sudo_efree(item);
void
sudo_gr_delref(struct group *gr)
{
- debug_decl(sudo_gr_delref, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_gr_delref, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
sudo_gr_delref_item(ptr_to_item(gr));
debug_return;
}
{
struct cache_item key, *item;
struct rbnode *node;
- debug_decl(sudo_getgrgid, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_getgrgid, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
key.k.gid = gid;
if ((node = rbfind(grcache_bygid, &key)) != NULL) {
struct cache_item key, *item;
struct rbnode *node;
size_t len;
- debug_decl(sudo_getgrnam, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_getgrnam, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
key.k.name = (char *) name;
if ((node = rbfind(grcache_byname, &key)) != NULL) {
struct rbnode *node;
size_t len, name_len;
int i;
- debug_decl(sudo_fakegrnam, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_fakegrnam, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
name_len = strlen(group);
len = sizeof(*gritem) + name_len + 1;
void
sudo_grlist_addref(struct group_list *grlist)
{
- debug_decl(sudo_gr_addref, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_gr_addref, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
ptr_to_item(grlist)->refcnt++;
debug_return;
}
sudo_grlist_delref_item(void *v)
{
struct cache_item *item = v;
- debug_decl(sudo_gr_delref_item, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_gr_delref_item, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (--item->refcnt == 0)
sudo_efree(item);
void
sudo_grlist_delref(struct group_list *grlist)
{
- debug_decl(sudo_gr_delref, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_gr_delref, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
sudo_grlist_delref_item(ptr_to_item(grlist));
debug_return;
}
void
sudo_setgrent(void)
{
- debug_decl(sudo_setgrent, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_setgrent, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
setgrent();
if (grcache_bygid == NULL)
void
sudo_freegrcache(void)
{
- debug_decl(sudo_freegrcache, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_freegrcache, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (grcache_bygid != NULL) {
rbdestroy(grcache_bygid, sudo_gr_delref_item);
void
sudo_endgrent(void)
{
- debug_decl(sudo_endgrent, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_endgrent, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
endgrent();
sudo_freegrcache();
struct cache_item key, *item;
struct rbnode *node;
size_t len;
- debug_decl(sudo_get_grlist, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_get_grlist, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
key.k.name = pw->pw_name;
if ((node = rbfind(grlist_cache, &key)) != NULL) {
{
struct cache_item key, *item;
struct rbnode *node;
- debug_decl(sudo_set_grlist, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_set_grlist, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
/*
* Cache group db entry if it doesn't already exist
const char *errstr;
int i;
bool matched = false;
- debug_decl(user_in_group, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(user_in_group, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if ((grlist = sudo_get_grlist(pw)) != NULL) {
/*
size_t nsize, psize, csize, gsize, dsize, ssize, total;
struct cache_item_pw *pwitem;
struct passwd *pw, *newpw;
- debug_decl(sudo_make_pwitem, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_make_pwitem, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
/* Look up by name or uid. */
pw = name ? getpwnam(name) : getpwuid(uid);
size_t nsize, psize, nmem, total, len;
struct cache_item_gr *gritem;
struct group *gr, *newgr;
- debug_decl(sudo_make_gritem, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_make_gritem, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
/* Look up by name or gid. */
gr = name ? getgrnam(name) : getgrgid(gid);
GETGROUPS_T *gids;
struct group *grp;
int i, ngids, groupname_len;
- debug_decl(sudo_make_grlist_item, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_make_grlist_item, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if (pw == sudo_user.pw && sudo_user.gids != NULL) {
gids = user_gids;
rbcreate(int (*compar)(const void *, const void*))
{
struct rbtree *tree;
- debug_decl(rbcreate, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(rbcreate, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
tree = (struct rbtree *) sudo_emalloc(sizeof(*tree));
tree->compar = compar;
rotate_left(struct rbtree *tree, struct rbnode *node)
{
struct rbnode *child;
- debug_decl(rotate_left, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(rotate_left, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
child = node->right;
node->right = child->left;
rotate_right(struct rbtree *tree, struct rbnode *node)
{
struct rbnode *child;
- debug_decl(rotate_right, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(rotate_right, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
child = node->left;
node->left = child->right;
struct rbnode *node = rbfirst(tree);
struct rbnode *parent = rbroot(tree);
int res;
- debug_decl(rbinsert, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(rbinsert, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
/* Find correct insertion point. */
while (node != rbnil(tree)) {
{
struct rbnode *node = rbfirst(tree);
int res;
- debug_decl(rbfind, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(rbfind, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
while (node != rbnil(tree)) {
if ((res = tree->compar(key, node->data)) == 0)
int (*func)(void *, void *), void *cookie, enum rbtraversal order)
{
int error;
- debug_decl(rbapply_node, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(rbapply_node, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
if (node != rbnil(tree)) {
if (order == preorder)
rbsuccessor(struct rbtree *tree, struct rbnode *node)
{
struct rbnode *succ;
- debug_decl(rbsuccessor, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(rbsuccessor, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
if ((succ = node->right) != rbnil(tree)) {
while (succ->left != rbnil(tree))
static void
_rbdestroy(struct rbtree *tree, struct rbnode *node, void (*destroy)(void *))
{
- debug_decl(_rbdestroy, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(_rbdestroy, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
if (node != rbnil(tree)) {
_rbdestroy(tree, node->left, destroy);
_rbdestroy(tree, node->right, destroy);
void
rbdestroy(struct rbtree *tree, void (*destroy)(void *))
{
- debug_decl(rbdestroy, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(rbdestroy, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
_rbdestroy(tree, rbfirst(tree), destroy);
sudo_efree(tree);
debug_return;
{
struct rbnode *x, *y;
void *data = z->data;
- debug_decl(rbdelete, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(rbdelete, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
if (z->left == rbnil(tree) || z->right == rbnil(tree))
y = z;
rbrepair(struct rbtree *tree, struct rbnode *node)
{
struct rbnode *sibling;
- debug_decl(rbrepair, SUDO_DEBUG_RBTREE, sudoers_debug_instance)
+ debug_decl(rbrepair, SUDOERS_DEBUG_RBTREE, sudoers_debug_instance)
while (node->color == black && node != rbfirst(tree)) {
if (node == node->parent->left) {
bool
rewind_perms(void)
{
- debug_decl(rewind_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(rewind_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth != 0) {
while (perm_stack_depth > 1) {
struct perm_state *state, *ostate = NULL;
char errbuf[1024];
const char *errstr = errbuf;
- debug_decl(set_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(set_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth == PERM_STACK_MAX) {
errstr = N_("perm stack overflow");
restore_perms(void)
{
struct perm_state *state, *ostate;
- debug_decl(restore_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(restore_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth < 2) {
sudo_warnx(U_("perm stack underflow"));
struct perm_state *state, *ostate = NULL;
char errbuf[1024];
const char *errstr = errbuf;
- debug_decl(set_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(set_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth == PERM_STACK_MAX) {
errstr = N_("perm stack overflow");
restore_perms(void)
{
struct perm_state *state, *ostate;
- debug_decl(restore_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(restore_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth < 2) {
sudo_warnx(U_("perm stack underflow"));
struct perm_state *state, *ostate = NULL;
char errbuf[1024];
const char *errstr = errbuf;
- debug_decl(set_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(set_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth == PERM_STACK_MAX) {
errstr = N_("perm stack overflow");
restore_perms(void)
{
struct perm_state *state, *ostate;
- debug_decl(restore_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(restore_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth < 2) {
sudo_warnx(U_("perm stack underflow"));
struct perm_state *state, *ostate = NULL;
char errbuf[1024];
const char *errstr = errbuf;
- debug_decl(set_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(set_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth == PERM_STACK_MAX) {
errstr = N_("perm stack overflow");
restore_perms(void)
{
struct perm_state *state, *ostate;
- debug_decl(restore_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(restore_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth < 2) {
sudo_warnx(U_("perm stack underflow"));
struct perm_state *state, *ostate = NULL;
char errbuf[1024];
const char *errstr = errbuf;
- debug_decl(set_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(set_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth == PERM_STACK_MAX) {
errstr = N_("perm stack overflow");
restore_perms(void)
{
struct perm_state *state, *ostate;
- debug_decl(restore_perms, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(restore_perms, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (perm_stack_depth < 2) {
sudo_warnx(U_("perm stack underflow"));
{
struct passwd *pw;
struct group_list *grlist;
- debug_decl(runas_setgroups, SUDO_DEBUG_PERMS, sudoers_debug_instance)
+ debug_decl(runas_setgroups, SUDOERS_DEBUG_PERMS, sudoers_debug_instance)
if (def_preserve_groups) {
sudo_grlist_addref(user_group_list);
sudo_sss_attrcpy(struct sss_sudo_attr *dst, const struct sss_sudo_attr *src)
{
unsigned int i;
- debug_decl(sudo_sss_attrcpy, SUDO_DEBUG_SSSD, sudoers_debug_instance)
+ debug_decl(sudo_sss_attrcpy, SUDOERS_DEBUG_SSSD, sudoers_debug_instance)
sudo_debug_printf(SUDO_DEBUG_DEBUG, "dst=%p, src=%p", dst, src);
sudo_debug_printf(SUDO_DEBUG_INFO, "sudo_emalloc: cnt=%d", src->num_values);
sudo_sss_rulecpy(struct sss_sudo_rule *dst, const struct sss_sudo_rule *src)
{
unsigned int i;
- debug_decl(sudo_sss_rulecpy, SUDO_DEBUG_SSSD, sudoers_debug_instance)
+ debug_decl(sudo_sss_rulecpy, SUDOERS_DEBUG_SSSD, sudoers_debug_instance)
sudo_debug_printf(SUDO_DEBUG_DEBUG, "dst=%p, src=%p", dst, src);
sudo_debug_printf(SUDO_DEBUG_INFO, "sudo_emalloc: cnt=%d", src->num_attrs);
struct sss_sudo_result *out_res;
unsigned int i, l;
int r;
- debug_decl(sudo_sss_filter_result, SUDO_DEBUG_SSSD, sudoers_debug_instance)
+ debug_decl(sudo_sss_filter_result, SUDOERS_DEBUG_SSSD, sudoers_debug_instance)
sudo_debug_printf(SUDO_DEBUG_DEBUG, "in_res=%p, count=%u, act=%s",
in_res, in_res ? in_res->num_rules : 0,
{
struct sudo_sss_handle *handle;
static const char path[] = _PATH_SSSD_LIB"/libsss_sudo.so";
- debug_decl(sudo_sss_open, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_open, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
/* Create a handle container. */
handle = sudo_emalloc(sizeof(struct sudo_sss_handle));
static int sudo_sss_close(struct sudo_nss *nss)
{
struct sudo_sss_handle *handle;
- debug_decl(sudo_sss_close, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_close, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (nss && nss->handle) {
handle = nss->handle;
// ok
static int sudo_sss_parse(struct sudo_nss *nss)
{
- debug_decl(sudo_sss_parse, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_parse, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
debug_return_int(0);
}
struct sss_sudo_rule *sss_rule;
uint32_t sss_error;
unsigned int i;
- debug_decl(sudo_sss_setdefs, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_setdefs, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (handle == NULL)
debug_return_int(-1);
static int sudo_sss_checkpw(struct sudo_nss *nss, struct passwd *pw)
{
struct sudo_sss_handle *handle = nss->handle;
- debug_decl(sudo_sss_checkpw, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_checkpw, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (pw->pw_name != handle->pw->pw_name ||
pw->pw_uid != handle->pw->pw_uid) {
char **val_array = NULL;
char *val;
int ret = false, i;
- debug_decl(sudo_sss_check_runas_user, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_check_runas_user, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (!runas_pw)
debug_return_int(UNSPEC);
char **val_array = NULL;
char *val;
int ret = false, i;
- debug_decl(sudo_sss_check_runas_group, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_check_runas_group, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
/* runas_gr is only set if the user specified the -g flag */
if (!runas_gr)
sudo_sss_check_runas(struct sudo_sss_handle *handle, struct sss_sudo_rule *rule)
{
bool ret;
- debug_decl(sudo_sss_check_runas, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_check_runas, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (rule == NULL)
debug_return_bool(false);
char **val_array, *val;
bool ret = false;
int i;
- debug_decl(sudo_sss_check_host, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_check_host, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (rule == NULL)
debug_return_bool(ret);
bool ret = false, netgroup_spec_found = false;
char **val_array, *val;
int i;
- debug_decl(sudo_sss_filter_user_netgroup, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_filter_user_netgroup, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (!handle || !rule)
debug_return_bool(ret);
struct sss_sudo_rule *rule, void *unused)
{
(void)unused;
- debug_decl(sudo_sss_result_filterp, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_result_filterp, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (sudo_sss_check_host(handle, rule) &&
sudo_sss_filter_user_netgroup(handle, rule))
struct sudo_sss_handle *handle = nss->handle;
struct sss_sudo_result *u_sss_result, *f_sss_result;
uint32_t sss_error = 0, ret;
- debug_decl(sudo_sss_result_get, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_result_get, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (sudo_sss_checkpw(nss, pw) != 0)
debug_return_ptr(NULL);
{
char ch, *var, **val_array = NULL;
int i, ret = UNSPEC;
- debug_decl(sudo_sss_check_bool, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_check_bool, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (rule == NULL)
debug_return_int(ret);
{
char *ep, *cp = *cmnd;
int digest_type = SUDO_DIGEST_INVALID;
- debug_decl(sudo_sss_check_command, SUDO_DEBUG_LDAP, sudoers_debug_instance)
+ debug_decl(sudo_sss_check_command, SUDOERS_DEBUG_LDAP, sudoers_debug_instance)
/*
* Check for and extract a digest prefix, e.g.
bool foundbang;
unsigned int i;
struct sudo_digest digest, *allowed_digest = NULL;
- debug_decl(sudo_sss_check_command, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_check_command, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (rule == NULL)
debug_return_int(ret);
int i;
char op, *v, *val;
char **val_array = NULL;
- debug_decl(sudo_sss_parse_options, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_parse_options, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (rule == NULL)
debug_return;
struct sss_sudo_result *sss_result = NULL;
struct sss_sudo_rule *rule;
uint32_t i, state = 0;
- debug_decl(sudo_sss_lookup, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_lookup, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
/* Fetch list of sudoRole entries that match user and host. */
sss_result = sudo_sss_result_get(nss, sudo_user.pw, &state);
struct sss_sudo_rule *rule;
unsigned int i;
bool found = false;
- debug_decl(sudo_sss_display_cmnd, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_display_cmnd, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (handle == NULL)
goto done;
char *prefix, *val, **val_array = NULL;
unsigned int i, j;
int count = 0;
- debug_decl(sudo_sss_display_defaults, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_display_defaults, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (handle == NULL)
goto done;
sudo_sss_display_bound_defaults(struct sudo_nss *nss,
struct passwd *pw, struct sudo_lbuf *lbuf)
{
- debug_decl(sudo_sss_display_bound_defaults, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_display_bound_defaults, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
debug_return_int(0);
}
{
char **val_array = NULL;
int count = 0, i;
- debug_decl(sudo_sss_display_entry_long, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_display_entry_long, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
/* get the RunAsUser Values from the entry */
sudo_lbuf_append(lbuf, " RunAsUsers: ");
{
char **val_array = NULL;
int count = 0, i;
- debug_decl(sudo_sss_display_entry_short, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_display_entry_short, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
sudo_lbuf_append(lbuf, " (");
struct sss_sudo_result *sss_result = NULL;
struct sss_sudo_rule *rule;
unsigned int i, count = 0;
- debug_decl(sudo_sss_display_privs, SUDO_DEBUG_SSSD, sudoers_debug_instance);
+ debug_decl(sudo_sss_display_privs, SUDOERS_DEBUG_SSSD, sudoers_debug_instance);
if (handle == NULL)
debug_return_int(-1);
bool saw_files = false;
bool got_match = false;
static struct sudo_nss_list snl = TAILQ_HEAD_INITIALIZER(snl);
- debug_decl(sudo_read_nss, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_read_nss, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if ((fp = fopen(_PATH_NSSWITCH_CONF, "r")) == NULL)
goto nomatch;
bool saw_ldap = false;
bool got_match = false;
static struct sudo_nss_list snl = TAILQ_HEAD_INITIALIZER(snl);
- debug_decl(sudo_read_nss, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_read_nss, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
if ((fp = fopen(_PATH_NETSVC_CONF, "r")) == NULL)
goto nomatch;
sudo_read_nss(void)
{
static struct sudo_nss_list snl = TAILQ_HEAD_INITIALIZER(snl);
- debug_decl(sudo_read_nss, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(sudo_read_nss, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
# ifdef HAVE_SSSD
TAILQ_INSERT_TAIL(&snl, &sudo_nss_sss, entries);
{
struct sudo_conv_message msg;
struct sudo_conv_reply repl;
- debug_decl(output, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(output, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
/* Call conversation function */
memset(&msg, 0, sizeof(msg));
struct sudo_lbuf defs, privs;
struct stat sb;
int cols, count, olen;
- debug_decl(display_privs, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(display_privs, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
cols = sudo_user.cols;
if (fstat(STDOUT_FILENO, &sb) == 0 && S_ISFIFO(sb.st_mode))
display_cmnd(struct sudo_nss_list *snl, struct passwd *pw)
{
struct sudo_nss *nss;
- debug_decl(display_cmnd, SUDO_DEBUG_NSS, sudoers_debug_instance)
+ debug_decl(display_cmnd, SUDOERS_DEBUG_NSS, sudoers_debug_instance)
TAILQ_FOREACH(nss, snl, entries) {
if (nss->display_cmnd(nss, pw) == 0)
volatile int sources = 0;
struct sudo_nss *nss, *nss_next;
int rval = -1;
- debug_decl(sudoers_policy_init, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_init, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
bindtextdomain("sudoers", LOCALEDIR);
struct sudo_nss *nss;
int cmnd_status = -1, oldlocale, validated;
volatile int rval = true;
- debug_decl(sudoers_policy_main, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_policy_main, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
/* Is root even allowed to run sudo? */
if (user_uid == 0 && !def_root_sudo) {
{
char * const * ep;
bool unknown_user = false;
- debug_decl(init_vars, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(init_vars, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
sudoers_initlocale(setlocale(LC_ALL, NULL), def_sudoers_locale);
{
int rval = FOUND;
char *path = user_path;
- debug_decl(set_cmnd, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(set_cmnd, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
/* Allocate user_stat for find_path() and match functions. */
user_stat = sudo_ecalloc(1, sizeof(struct stat));
{
struct stat sb;
FILE *fp = NULL;
- debug_decl(open_sudoers, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(open_sudoers, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
if (!set_perms(PERM_SUDOERS))
debug_return_ptr(NULL);
const int errflags = SLOG_RAW_MSG;
login_cap_t *lc;
bool rval = true;
- debug_decl(set_loginclass, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(set_loginclass, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
if (!def_use_loginclass)
goto done;
{
struct addrinfo *res0, hint;
char *p;
- debug_decl(set_fqdn, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(set_fqdn, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
memset(&hint, 0, sizeof(hint));
hint.ai_family = PF_UNSPEC;
set_runaspw(const char *user, bool quiet)
{
struct passwd *pw = NULL;
- debug_decl(set_runaspw, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(set_runaspw, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
if (*user == '#') {
const char *errstr;
set_runasgr(const char *group, bool quiet)
{
struct group *gr = NULL;
- debug_decl(set_runasgr, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(set_runasgr, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
if (*group == '#') {
const char *errstr;
sudoers_cleanup(void)
{
struct sudo_nss *nss;
- debug_decl(sudoers_cleanup, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(sudoers_cleanup, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
if (snl != NULL) {
TAILQ_FOREACH(nss, snl, entries) {
char *cp, **nargv, *editor, *editor_path = NULL;
int ac, i, nargc;
bool wasblank;
- debug_decl(resolve_editor, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(resolve_editor, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
/* Note: editor becomes part of argv_out and is not freed. */
editor = sudo_emalloc(edlen + 1);
const char *cp, *ep, *editor;
char *editor_path = NULL, **ev, *ev0[4];
size_t len;
- debug_decl(find_editor, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(find_editor, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
/*
* If any of SUDO_EDITOR, VISUAL or EDITOR are set, choose the first one.
struct stat statbuf;
char flagfile[PATH_MAX];
int fd, n;
- debug_decl(create_admin_success_flag, SUDO_DEBUG_PLUGIN, sudoers_debug_instance)
+ debug_decl(create_admin_success_flag, SUDOERS_DEBUG_PLUGIN, sudoers_debug_instance)
/* Check whether the user is in the admin group. */
if (!user_in_group(sudo_user.pw, "admin"))
#include "sudo_nss.h"
#include "sudo_plugin.h"
#include "sudo_conf.h"
-#include "sudo_debug.h"
#include "sudo_util.h"
+#include "sudoers_debug.h"
/*
* Password db and supplementary group IDs with associated group names.
int sudoers_debug_instance = SUDO_DEBUG_INSTANCE_INITIALIZER;
+static const char *const sudoers_debug_subsystems[] = {
+ "main",
+ "util",
+ "netif",
+ "plugin",
+ "event",
+ "audit",
+ "ldap",
+ "match",
+ "parser",
+ "alias",
+ "defaults",
+ "auth",
+ "env",
+ "logging",
+ "nss",
+ "rbtree",
+ "perms",
+ "sssd",
+ NULL
+};
+
+#define NUM_SUBSYSTEMS (sizeof(sudoers_debug_subsystems) / sizeof(sudoers_debug_subsystems[0]) - 1)
+
/*
* Parse the "filename flags,..." debug_flags entry and insert a new
* sudo_debug_file struct into debug_files.
/* Setup debugging if indicated. */
if (!TAILQ_EMPTY(debug_files)) {
if (plugin_path != NULL) {
- sudoers_debug_instance =
- sudo_debug_register(plugin_path, NULL, 0, debug_files);
+ sudoers_debug_instance = sudo_debug_register(plugin_path,
+ sudoers_debug_subsystems, NUM_SUBSYSTEMS, debug_files);
}
TAILQ_FOREACH_SAFE(debug_file, debug_files, entries, debug_next) {
TAILQ_REMOVE(debug_files, debug_file, entries);
--- /dev/null
+/*
+ * Copyright (c) 2014 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _SUDOERS_DEBUG_H
+#define _SUDOERS_DEBUG_H
+
+#include "sudo_debug.h"
+
+/*
+ * Sudoers debug subsystems.
+ * The first five entries must match the sudo front end.
+ * Note: order must match sudoers_debug_subsystems[]
+ */
+#define SUDOERS_DEBUG_MAIN ( 1<<16) /* main() */
+#define SUDOERS_DEBUG_UTIL ( 2<<16) /* utility functions */
+#define SUDOERS_DEBUG_NETIF ( 3<<16) /* network interface functions */
+#define SUDOERS_DEBUG_PLUGIN ( 4<<16) /* main plugin functions */
+#define SUDOERS_DEBUG_EVENT ( 5<<16) /* event handling */
+#define SUDOERS_DEBUG_AUDIT ( 6<<16) /* audit */
+#define SUDOERS_DEBUG_LDAP ( 7<<16) /* sudoers LDAP */
+#define SUDOERS_DEBUG_MATCH ( 8<<16) /* sudoers matching */
+#define SUDOERS_DEBUG_PARSER ( 9<<16) /* sudoers parser */
+#define SUDOERS_DEBUG_ALIAS (10<<16) /* sudoers alias functions */
+#define SUDOERS_DEBUG_DEFAULTS (11<<16) /* sudoers defaults settings */
+#define SUDOERS_DEBUG_AUTH (12<<16) /* authentication functions */
+#define SUDOERS_DEBUG_ENV (13<<16) /* environment handling */
+#define SUDOERS_DEBUG_LOGGING (14<<16) /* logging functions */
+#define SUDOERS_DEBUG_NSS (15<<16) /* network service switch */
+#define SUDOERS_DEBUG_RBTREE (16<<16) /* red-black tree functions */
+#define SUDOERS_DEBUG_PERMS (17<<16) /* uid/gid swapping functions */
+#define SUDOERS_DEBUG_SSSD (18<<16) /* sudoers SSSD */
+#define SUDOERS_DEBUG_ALL 0xffff0000 /* all subsystems */
+
+#endif /* _SUDOERS_DEBUG_H */
const char *errstr;
int match, host_match, runas_match, cmnd_match;
int ch, dflag, exitcode = 0;
- debug_decl(main, SUDO_DEBUG_MAIN, sudoers_debug_instance)
+ debug_decl(main, SUDOERS_DEBUG_MAIN, sudoers_debug_instance)
#if defined(SUDO_DEVEL) && defined(__OpenBSD__)
malloc_options = "AFGJPR";
set_runaspw(const char *user)
{
struct passwd *pw = NULL;
- debug_decl(set_runaspw, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(set_runaspw, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (*user == '#') {
const char *errstr;
set_runasgr(const char *group)
{
struct group *gr = NULL;
- debug_decl(set_runasgr, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(set_runasgr, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (*group == '#') {
const char *errstr;
struct stat sb;
FILE *fp = NULL;
char *sudoers_base;
- debug_decl(open_sudoers, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(open_sudoers, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
sudoers_base = strrchr(sudoers, '/');
if (sudoers_base != NULL)
print_member(struct member *m)
{
struct sudo_command *c;
- debug_decl(print_member, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_member, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (m->negated)
putchar('!');
{
struct defaults *d;
struct member *m;
- debug_decl(print_defaults, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_defaults, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
TAILQ_FOREACH(d, &defaults, entries) {
(void) fputs("Defaults", stdout);
struct alias *a = (struct alias *)v1;
struct member *m;
struct sudo_command *c;
- debug_decl(print_alias, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_alias, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
switch (a->type) {
case HOSTALIAS:
struct cmndspec *cs;
struct member *m;
struct cmndtag tags;
- debug_decl(print_privilege, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_privilege, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
TAILQ_FOREACH(m, &priv->hostlist, entries) {
if (m != TAILQ_FIRST(&priv->hostlist))
struct member *m;
struct userspec *us;
struct privilege *priv;
- debug_decl(print_userspecs, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_userspecs, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
TAILQ_FOREACH(us, &userspecs, entries) {
TAILQ_FOREACH(m, &us->users, entries) {
void
dump_sudoers(void)
{
- debug_decl(dump_sudoers, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(dump_sudoers, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
print_defaults();
static bool
ts_match_record(struct timestamp_entry *key, struct timestamp_entry *entry)
{
- debug_decl(ts_match_record, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(ts_match_record, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (entry->version != key->version)
debug_return_bool(false);
ts_find_record(int fd, struct timestamp_entry *key, struct timestamp_entry *entry)
{
struct timestamp_entry cur;
- debug_decl(ts_find_record, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(ts_find_record, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/*
* Look for a matching record.
struct timestamp_entry cur;
ssize_t nwritten;
off_t old_eof = (off_t)-1;
- debug_decl(ts_update_record, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(ts_update_record, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* First try the hint if one is given. */
if (timestamp_hint != (off_t)-1) {
gid_t parent_gid = 0;
char *slash = path;
bool rval = false;
- debug_decl(ts_mkdirs, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(ts_mkdirs, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
while ((slash = strchr(slash + 1, '/')) != NULL) {
*slash = '\0';
{
struct stat sb;
bool rval = false;
- debug_decl(ts_secure_dir, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(ts_secure_dir, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
sudo_debug_printf(SUDO_DEBUG_INFO|SUDO_DEBUG_LINENO, "checking %s", path);
switch (sudo_secure_dir(path, timestamp_uid, -1, &sb)) {
build_timestamp(struct passwd *pw)
{
int len;
- debug_decl(build_timestamp, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(build_timestamp, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
len = snprintf(timestamp_file, sizeof(timestamp_file), "%s/%s",
def_timestampdir, user_name);
bool uid_changed = false;
bool rval = false;
int fd;
- debug_decl(update_timestamp, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(update_timestamp, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Zero timeout means don't update the time stamp file. */
if (def_timestamp_timeout == 0)
int status = TS_ERROR; /* assume the worst */
struct stat sb;
int fd = -1;
- debug_decl(timestamp_status, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(timestamp_status, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
/* Reset time stamp offset hint. */
timestamp_hint = (off_t)-1;
struct timestamp_entry entry;
bool uid_changed = false;
int fd = -1;
- debug_decl(remove_timestamp, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(remove_timestamp, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (build_timestamp(NULL) == -1)
debug_return;
char status_file[PATH_MAX];
struct stat sb;
int len;
- debug_decl(already_lectured, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(already_lectured, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
if (ts_secure_dir(def_lecture_status_dir, false, true)) {
len = snprintf(status_file, sizeof(status_file), "%s/%s",
char lecture_status[PATH_MAX];
bool uid_changed = false;
int len, fd = -1;
- debug_decl(set_lectured, SUDO_DEBUG_AUTH, sudoers_debug_instance)
+ debug_decl(set_lectured, SUDOERS_DEBUG_AUTH, sudoers_debug_instance)
len = snprintf(lecture_status, sizeof(lecture_status), "%s/%s",
def_lecture_status_dir, user_name);
int max_paths = 32;
struct dirent *dent;
struct path_list **paths = NULL;
- debug_decl(read_dir_files, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(read_dir_files, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
dir = opendir(dirpath);
if (dir == NULL) {
{
struct path_list **paths = NULL;
int count, i;
- debug_decl(switch_dir, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(switch_dir, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
count = read_dir_files(dirpath, &paths);
if (count > 0) {
init_lexer(void)
{
struct path_list *pl;
- debug_decl(init_lexer, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(init_lexer, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
while (idepth) {
idepth--;
{
struct path_list *pl;
FILE *fp;
- debug_decl(_push_include, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(_push_include, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
/* push current state onto stack */
if (idepth >= istacksize) {
{
struct path_list *pl;
FILE *fp;
- debug_decl(pop_include, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(pop_include, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
if (idepth == 0)
debug_return_bool(false);
char *cp, *ep, *path, *pp;
int dirlen = 0, len = 0, subst = 0;
size_t shost_len = 0;
- debug_decl(parse_include, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(parse_include, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
/* Pull out path from #include line. */
cp = base + sizeof("#include");
/* XXX - assumes a final newline */
if (strchr(msg, '\n') != NULL)
{
- sudo_debug_printf2(NULL, NULL, 0, SUDO_DEBUG_PARSER|SUDO_DEBUG_DEBUG,
+ sudo_debug_printf2(NULL, NULL, 0, SUDOERS_DEBUG_PARSER|SUDO_DEBUG_DEBUG,
"%s:%d %s", sudoers, sudolineno, lbuf.buf);
lbuf.len = 0;
}
int max_paths = 32;
struct dirent *dent;
struct path_list **paths = NULL;
- debug_decl(read_dir_files, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(read_dir_files, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
dir = opendir(dirpath);
if (dir == NULL) {
{
struct path_list **paths = NULL;
int count, i;
- debug_decl(switch_dir, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(switch_dir, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
count = read_dir_files(dirpath, &paths);
if (count > 0) {
init_lexer(void)
{
struct path_list *pl;
- debug_decl(init_lexer, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(init_lexer, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
while (idepth) {
idepth--;
{
struct path_list *pl;
FILE *fp;
- debug_decl(_push_include, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(_push_include, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
/* push current state onto stack */
if (idepth >= istacksize) {
{
struct path_list *pl;
FILE *fp;
- debug_decl(pop_include, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(pop_include, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
if (idepth == 0)
debug_return_bool(false);
char *cp, *ep, *path, *pp;
int dirlen = 0, len = 0, subst = 0;
size_t shost_len = 0;
- debug_decl(parse_include, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(parse_include, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
/* Pull out path from #include line. */
cp = base + sizeof("#include");
/* XXX - assumes a final newline */
if (strchr(msg, '\n') != NULL)
{
- sudo_debug_printf2(NULL, NULL, 0, SUDO_DEBUG_PARSER|SUDO_DEBUG_DEBUG,
+ sudo_debug_printf2(NULL, NULL, 0, SUDOERS_DEBUG_PARSER|SUDO_DEBUG_DEBUG,
"%s:%d %s", sudoers, sudolineno, lbuf.buf);
lbuf.len = 0;
}
{
char *dst;
int h;
- debug_decl(fill_txt, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(fill_txt, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
dst = olen ? realloc(sudoerslval.string, olen + len + 1) : malloc(len + 1);
if (dst == NULL) {
append(const char *src, int len)
{
int olen = 0;
- debug_decl(append, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(append, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
if (sudoerslval.string != NULL)
olen = strlen(sudoerslval.string);
{
char *dst;
int i;
- debug_decl(fill_cmnd, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(fill_cmnd, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
arg_len = arg_size = 0;
{
int new_len;
char *p;
- debug_decl(fill_args, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(fill_args, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
if (sudoerslval.command.args == NULL) {
addspace = 0;
ipv6_valid(const char *s)
{
int nmatch = 0;
- debug_decl(ipv6_valid, SUDO_DEBUG_PARSER, sudoers_debug_instance)
+ debug_decl(ipv6_valid, SUDOERS_DEBUG_PARSER, sudoers_debug_instance)
for (; *s != '\0'; s++) {
if (s[0] == ':' && s[1] == ':') {
int ch, exitcode = 0;
bool quiet, strict, oldperms;
const char *export_path;
- debug_decl(main, SUDO_DEBUG_MAIN, sudoers_debug_instance)
+ debug_decl(main, SUDOERS_DEBUG_MAIN, sudoers_debug_instance)
#if defined(SUDO_DEVEL) && defined(__OpenBSD__)
{
ssize_t nread; /* number of bytes read */
struct stat sb; /* stat buffer */
bool rval = false; /* return value */
- debug_decl(edit_sudoers, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(edit_sudoers, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (fstat(sp->fd, &sb) == -1)
sudo_fatal(U_("unable to stat %s"), sp->path);
struct sudoersfile *sp, *last;
FILE *fp;
int ch;
- debug_decl(reparse_sudoers, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(reparse_sudoers, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/*
* Parse the edited sudoers files and do sanity checking
{
struct stat sb;
bool rval = false;
- debug_decl(install_sudoers, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(install_sudoers, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (!sp->modified) {
/*
whatnow(void)
{
int choice, c;
- debug_decl(whatnow, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(whatnow, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
for (;;) {
(void) fputs(_("What now? "), stdout);
setup_signals(void)
{
sigaction_t sa;
- debug_decl(setup_signals, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(setup_signals, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/*
* Setup signal handlers to cleanup nicely.
{
int status;
pid_t pid, rv;
- debug_decl(run_command, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(run_command, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
switch (pid = sudo_debug_fork()) {
case -1:
{
struct stat sb;
bool ok = true;
- debug_decl(check_owner, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(check_owner, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (stat(path, &sb) == 0) {
if (sb.st_uid != SUDOERS_UID || sb.st_gid != SUDOERS_GID) {
check_syntax(char *sudoers_path, bool quiet, bool strict, bool oldperms)
{
bool ok = false;
- debug_decl(check_syntax, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(check_syntax, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (strcmp(sudoers_path, "-") == 0) {
sudoersin = stdin;
struct sudoersfile *entry;
FILE *fp;
int open_flags;
- debug_decl(open_sudoers, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(open_sudoers, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (checkonly)
open_flags = O_RDONLY;
get_editor(char **args)
{
char *Editor, *EditorArgs, *EditorPath, *UserEditor, *UserEditorArgs;
- debug_decl(get_editor, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(get_editor, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/*
* Check VISUAL and EDITOR environment variables to see which editor
get_args(char *cmnd)
{
char *args;
- debug_decl(get_args, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(get_args, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
args = cmnd;
while (*args && !isblank((unsigned char) *args))
get_hostname(void)
{
char *p, thost[HOST_NAME_MAX + 1];
- debug_decl(get_hostname, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(get_hostname, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (gethostname(thost, sizeof(thost)) != -1) {
thost[sizeof(thost) - 1] = '\0';
struct member *m;
struct alias *a;
bool rval = true;
- debug_decl(alias_remove_recursive, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(alias_remove_recursive, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
if ((a = alias_remove(name, type)) != NULL) {
TAILQ_FOREACH(m, &a->members, entries) {
struct member *m;
struct alias *a;
int errors = 0;
- debug_decl(check_alias, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(check_alias, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
if ((a = alias_get(name, type)) != NULL) {
/* check alias contents */
struct userspec *us;
struct defaults *d;
int atype, errors = 0;
- debug_decl(check_aliases, SUDO_DEBUG_ALIAS, sudoers_debug_instance)
+ debug_decl(check_aliases, SUDOERS_DEBUG_ALIAS, sudoers_debug_instance)
alias_freelist = rbcreate(alias_compare);
print_pair_json(FILE *fp, const char *pre, const char *name,
const struct json_value *value, const char *post, int indent)
{
- debug_decl(print_pair_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_pair_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
print_indent(fp, indent);
printstr_json(FILE *fp, const char *pre, const char *str, const char *post,
int indent)
{
- debug_decl(printstr_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(printstr_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
print_indent(fp, indent);
if (pre != NULL)
struct sudo_command *c = (struct sudo_command *)m->name;
struct json_value value;
const char *digest_name;
- debug_decl(print_command_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_command_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
printstr_json(fp, "{", NULL, NULL, indent);
if (m->negated || c->digest != NULL) {
const char *typestr;
const char *errstr;
id_t id;
- debug_decl(print_member_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_member_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/* Most of the time we print a string. */
value.type = JSON_STRING;
struct alias *a = v1;
struct json_alias_closure *closure = v2;
struct member *m;
- debug_decl(print_alias_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_alias_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (a->type != closure->alias_type)
debug_return_int(0);
print_binding_json(FILE *fp, struct member_list *binding, int type, int indent)
{
struct member *m;
- debug_decl(print_binding_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_binding_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (TAILQ_EMPTY(binding))
debug_return;
{
char savech, *start, *end = def->val;
struct json_value value;
- debug_decl(print_defaults_list_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_defaults_list_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
fprintf(fp, "%*s{\n", indent, "");
indent += 4;
struct json_value value;
struct defaults *def, *next;
int type;
- debug_decl(print_defaults_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_defaults_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (TAILQ_EMPTY(&defaults))
debug_return_bool(need_comma);
int indent, bool need_comma)
{
struct json_alias_closure closure;
- debug_decl(print_aliases_by_type_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_aliases_by_type_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
closure.fp = fp;
closure.indent = indent;
static bool
print_aliases_json(FILE *fp, int indent, bool need_comma)
{
- debug_decl(print_aliases_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_aliases_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
need_comma = print_aliases_by_type_json(fp, USERALIAS, "User_Aliases",
indent, need_comma);
struct json_value value;
struct member *m;
bool last_one;
- debug_decl(print_cmndspec_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_cmndspec_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/* Open Cmnd_Spec object. */
fprintf(fp, "%*s{\n", indent, "");
struct privilege *priv;
struct member *m;
struct cmndspec *cs, *next;
- debug_decl(print_userspec_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_userspec_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
/*
* Each userspec struct may contain multiple privileges for
print_userspecs_json(FILE *fp, int indent, bool need_comma)
{
struct userspec *us;
- debug_decl(print_userspecs_json, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(print_userspecs_json, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (TAILQ_EMPTY(&userspecs))
debug_return_bool(need_comma);
bool ok = false, need_comma = false;
const int indent = 4;
FILE *export_fp = stdout;
- debug_decl(export_sudoers, SUDO_DEBUG_UTIL, sudoers_debug_instance)
+ debug_decl(export_sudoers, SUDOERS_DEBUG_UTIL, sudoers_debug_instance)
if (strcmp(sudoers_path, "-") == 0) {
sudoersin = stdin;
projects / sudo / commitdiff