Version the functions in libsudo_util

diff --git a/include/secure_path.h b/include/secure_path.h
index fcc48e5100bd5d354be4ba3498cc20f8dc3e44bb..a378701c40033d8024da2b58b00f036f48a76d7f 100644 (file)
--- a/include/secure_path.h
+++ b/include/secure_path.h
@@ -24,8 +24,10 @@
 #define SUDO_PATH_WORLD_WRITABLE       -4
 #define SUDO_PATH_GROUP_WRITABLE       -5
 
-__dso_public int sudo_secure_dir(const char *path, uid_t uid, gid_t gid, struct stat *sbp);
-__dso_public int sudo_secure_file(const char *path, uid_t uid, gid_t gid, struct stat *sbp);
-__dso_public int sudo_secure_path(const char *path, unsigned int type, uid_t uid, gid_t gid, struct stat *sbp);
+__dso_public int sudo_secure_dir_v1(const char *path, uid_t uid, gid_t gid, struct stat *sbp);
+__dso_public int sudo_secure_file_v1(const char *path, uid_t uid, gid_t gid, struct stat *sbp);
+
+#define sudo_secure_dir(_a, _b, _c, _d) sudo_secure_dir_v1((_a), (_b), (_c), (_d))
+#define sudo_secure_file(_a, _b, _c, _d) sudo_secure_file_v1((_a), (_b), (_c), (_d))
 
 #endif /* _SUDO_SECURE_PATH_H */

diff --git a/include/sudo_alloc.h b/include/sudo_alloc.h
index b0b25611f74f283ea40123322b94a02817a4da97..77cac4a60061da6535dd9124e7962816b4eb7dd9 100644 (file)
--- a/include/sudo_alloc.h
+++ b/include/sudo_alloc.h
@@ -23,15 +23,26 @@
 #undef sudo_efree
 #define sudo_efree(x)  free((void *)(x))
 
-__dso_public int  sudo_easprintf(char **, const char *, ...) __printflike(2, 3);
-__dso_public int  sudo_evasprintf(char **, const char *, va_list) __printflike(2, 0);
-__dso_public void *sudo_ecalloc(size_t, size_t) __malloc_like;
-__dso_public void *sudo_emalloc(size_t) __malloc_like;
-__dso_public void *sudo_emallocarray(size_t, size_t) __malloc_like;
-__dso_public void *sudo_erealloc(void *, size_t);
-__dso_public void *sudo_ereallocarray(void *, size_t, size_t);
-__dso_public void *sudo_erecalloc(void *, size_t, size_t, size_t);
-__dso_public char *sudo_estrdup(const char *) __malloc_like;
-__dso_public char *sudo_estrndup(const char *, size_t) __malloc_like;
+__dso_public int  sudo_easprintf_v1(char **, const char *, ...) __printflike(2, 3);
+__dso_public int  sudo_evasprintf_v1(char **, const char *, va_list) __printflike(2, 0);
+__dso_public void *sudo_ecalloc_v1(size_t, size_t) __malloc_like;
+__dso_public void *sudo_emalloc_v1(size_t) __malloc_like;
+__dso_public void *sudo_emallocarray_v1(size_t, size_t) __malloc_like;
+__dso_public void *sudo_erealloc_v1(void *, size_t);
+__dso_public void *sudo_ereallocarray_v1(void *, size_t, size_t);
+__dso_public void *sudo_erecalloc_v1(void *, size_t, size_t, size_t);
+__dso_public char *sudo_estrdup_v1(const char *) __malloc_like;
+__dso_public char *sudo_estrndup_v1(const char *, size_t) __malloc_like;
+
+#define sudo_easprintf sudo_easprintf_v1
+#define sudo_evasprintf(_a, _b, _c) sudo_evasprintf_v1((_a), (_b), (_c))
+#define sudo_ecalloc(_a, _b) sudo_ecalloc_v1((_a), (_b))
+#define sudo_emalloc(_a) sudo_emalloc_v1((_a))
+#define sudo_emallocarray(_a, _b) sudo_emallocarray_v1((_a), (_b))
+#define sudo_erealloc(_a, _b) sudo_erealloc_v1((_a), (_b))
+#define sudo_ereallocarray(_a, _b, _c) sudo_ereallocarray_v1((_a), (_b), (_c))
+#define sudo_erecalloc(_a, _b, _c, _d) sudo_erecalloc_v1((_a), (_b), (_c), (_d))
+#define sudo_estrdup(_a) sudo_estrdup_v1((_a))
+#define sudo_estrndup(_a, _b) sudo_estrndup_v1((_a), (_b))
 
 #endif /* _SUDO_ALLOC_H */

diff --git a/include/sudo_conf.h b/include/sudo_conf.h
index e0a6912506583522d922ab4e3e3441bbf64bd879..0bcf70cc73d03abe2fac2c766d07325a707e22b1 100644 (file)
--- a/include/sudo_conf.h
+++ b/include/sudo_conf.h
@@ -33,18 +33,29 @@ struct plugin_info {
 TAILQ_HEAD(plugin_info_list, plugin_info);
 
 /* Read main sudo.conf file. */
-__dso_public void sudo_conf_read(const char *);
+__dso_public void sudo_conf_read_v1(const char *conf_file);
+#define sudo_conf_read(_a) sudo_conf_read_v1((_a))
 
 /* Accessor functions. */
-__dso_public const char *sudo_conf_askpass_path(void);
-__dso_public const char *sudo_conf_sesh_path(void);
-__dso_public const char *sudo_conf_noexec_path(void);
-__dso_public const char *sudo_conf_plugin_dir_path(void);
-__dso_public const char *sudo_conf_debug_flags(void);
-__dso_public struct plugin_info_list *sudo_conf_plugins(void);
-__dso_public bool sudo_conf_disable_coredump(void);
-__dso_public bool sudo_conf_probe_interfaces(void);
-__dso_public int sudo_conf_group_source(void);
-__dso_public int sudo_conf_max_groups(void);
+__dso_public const char *sudo_conf_askpass_path_v1(void);
+__dso_public const char *sudo_conf_sesh_path_v1(void);
+__dso_public const char *sudo_conf_noexec_path_v1(void);
+__dso_public const char *sudo_conf_plugin_dir_path_v1(void);
+__dso_public const char *sudo_conf_debug_flags_v1(void);
+__dso_public struct plugin_info_list *sudo_conf_plugins_v1(void);
+__dso_public bool sudo_conf_disable_coredump_v1(void);
+__dso_public bool sudo_conf_probe_interfaces_v1(void);
+__dso_public int sudo_conf_group_source_v1(void);
+__dso_public int sudo_conf_max_groups_v1(void);
+#define sudo_conf_askpass_path() sudo_conf_askpass_path_v1()
+#define sudo_conf_sesh_path() sudo_conf_sesh_path_v1()
+#define sudo_conf_noexec_path() sudo_conf_noexec_path_v1()
+#define sudo_conf_plugin_dir_path() sudo_conf_plugin_dir_path_v1()
+#define sudo_conf_debug_flags() sudo_conf_debug_flags_v1()
+#define sudo_conf_plugins() sudo_conf_plugins_v1()
+#define sudo_conf_disable_coredump() sudo_conf_disable_coredump_v1()
+#define sudo_conf_probe_interfaces() sudo_conf_probe_interfaces_v1()
+#define sudo_conf_group_source() sudo_conf_group_source_v1()
+#define sudo_conf_max_groups() sudo_conf_max_groups_v1()
 
 #endif /* _SUDO_CONF_H */

diff --git a/include/sudo_dso.h b/include/sudo_dso.h
index dfb51f63ee810f99da168f69232cecb180e28ed5..d953d5b8da27cafccfaaf8cd0bab530d369f90ff 100644 (file)
--- a/include/sudo_dso.h
+++ b/include/sudo_dso.h
@@ -40,10 +40,16 @@ struct sudo_preload_table {
 };
 
 /* Public functions. */
-__dso_public char *sudo_dso_strerror(void);
-__dso_public int sudo_dso_unload(void *handle);
-__dso_public void *sudo_dso_findsym(void *handle, const char *symbol);
-__dso_public void *sudo_dso_load(const char *path, int mode);
-__dso_public void sudo_dso_preload_table(struct sudo_preload_table *table);
+__dso_public char *sudo_dso_strerror_v1(void);
+__dso_public int sudo_dso_unload_v1(void *handle);
+__dso_public void *sudo_dso_findsym_v1(void *handle, const char *symbol);
+__dso_public void *sudo_dso_load_v1(const char *path, int mode);
+__dso_public void sudo_dso_preload_table_v1(struct sudo_preload_table *table);
+
+#define sudo_dso_strerror() sudo_dso_strerror_v1()
+#define sudo_dso_unload(_a) sudo_dso_unload_v1((_a))
+#define sudo_dso_findsym(_a, _b) sudo_dso_findsym_v1((_a), (_b))
+#define sudo_dso_load(_a, _b) sudo_dso_load_v1((_a), (_b))
+#define sudo_dso_preload_table(_a) sudo_dso_preload_table_v1((_a))
 
 #endif /* _SUDO_DSO_H */

diff --git a/include/sudo_event.h b/include/sudo_event.h
index 56f3221ee164962c01bcef4ce1a4f5cfd7fdff00..37bf364378fc9f5756876931db09337c50270d0d 100644 (file)
--- a/include/sudo_event.h
+++ b/include/sudo_event.h
@@ -83,43 +83,56 @@ struct sudo_event_base {
 };
 
 /* Allocate a new event base. */
-__dso_public struct sudo_event_base *sudo_ev_base_alloc(void);
+__dso_public struct sudo_event_base *sudo_ev_base_alloc_v1(void);
+#define sudo_ev_base_alloc() sudo_ev_base_alloc_v1()
 
 /* Free an event base. */
-__dso_public void sudo_ev_base_free(struct sudo_event_base *base);
+__dso_public void sudo_ev_base_free_v1(struct sudo_event_base *base);
+#define sudo_ev_base_free(_a) sudo_ev_base_free_v1((_a))
 
 /* Allocate a new event. */
-__dso_public struct sudo_event *sudo_ev_alloc(int fd, short events, sudo_ev_callback_t callback, void *closure);
+__dso_public struct sudo_event *sudo_ev_alloc_v1(int fd, short events, sudo_ev_callback_t callback, void *closure);
+#define sudo_ev_alloc(_a, _b, _c, _d) sudo_ev_alloc_v1((_a), (_b), (_c), (_d))
 
 /* Free an event. */
-__dso_public void sudo_ev_free(struct sudo_event *ev);
+__dso_public void sudo_ev_free_v1(struct sudo_event *ev);
+#define sudo_ev_free(_a) sudo_ev_free_v1((_a))
 
 /* Add an event, returns 0 on success, -1 on error */
-__dso_public int sudo_ev_add(struct sudo_event_base *head, struct sudo_event *ev, struct timeval *timo, bool tohead);
+__dso_public int sudo_ev_add_v1(struct sudo_event_base *head, struct sudo_event *ev, struct timeval *timo, bool tohead);
+#define sudo_ev_add(_a, _b, _c, _d) sudo_ev_add_v1((_a), (_b), (_c), (_d))
 
 /* Delete an event, returns 0 on success, -1 on error */
-__dso_public int sudo_ev_del(struct sudo_event_base *head, struct sudo_event *ev);
+__dso_public int sudo_ev_del_v1(struct sudo_event_base *head, struct sudo_event *ev);
+#define sudo_ev_del(_a, _b) sudo_ev_del_v1((_a), (_b))
 
 /* Main event loop, returns SUDO_CB_SUCCESS, SUDO_CB_BREAK or SUDO_CB_ERROR */
-__dso_public int sudo_ev_loop(struct sudo_event_base *head, int flags);
+__dso_public int sudo_ev_loop_v1(struct sudo_event_base *head, int flags);
+#define sudo_ev_loop(_a, _b) sudo_ev_loop_v1((_a), (_b))
 
 /* Return the remaining timeout associated with an event. */
-__dso_public int sudo_ev_get_timeleft(struct sudo_event *ev, struct timeval *tv);
+__dso_public int sudo_ev_get_timeleft_v1(struct sudo_event *ev, struct timeval *tv);
+#define sudo_ev_get_timeleft(_a, _b) sudo_ev_get_timeleft_v1((_a), (_b))
 
 /* Cause the event loop to exit after one run through. */
-__dso_public void sudo_ev_loopexit(struct sudo_event_base *base);
+__dso_public void sudo_ev_loopexit_v1(struct sudo_event_base *base);
+#define sudo_ev_loopexit(_a) sudo_ev_loopexit_v1((_a))
 
 /* Break out of the event loop right now. */
-__dso_public void sudo_ev_loopbreak(struct sudo_event_base *base);
+__dso_public void sudo_ev_loopbreak_v1(struct sudo_event_base *base);
+#define sudo_ev_loopbreak(_a) sudo_ev_loopbreak_v1((_a))
 
 /* Rescan for events and restart the event loop. */
-__dso_public void sudo_ev_loopcontinue(struct sudo_event_base *base);
+__dso_public void sudo_ev_loopcontinue_v1(struct sudo_event_base *base);
+#define sudo_ev_loopcontinue(_a) sudo_ev_loopcontinue_v1((_a))
 
 /* Returns true if event loop stopped due to sudo_ev_loopexit(). */
-__dso_public bool sudo_ev_got_exit(struct sudo_event_base *base);
+__dso_public bool sudo_ev_got_exit_v1(struct sudo_event_base *base);
+#define sudo_ev_got_exit(_a) sudo_ev_got_exit_v1((_a))
 
 /* Returns true if event loop stopped due to sudo_ev_loopbreak(). */
-__dso_public bool sudo_ev_got_break(struct sudo_event_base *base);
+__dso_public bool sudo_ev_got_break_v1(struct sudo_event_base *base);
+#define sudo_ev_got_break(_a) sudo_ev_got_break_v1((_a))
 
 /* Return the fd associated with an event. */
 #define sudo_ev_get_fd(_ev) ((_ev) ? (_ev)->fd : -1)

diff --git a/include/sudo_fatal.h b/include/sudo_fatal.h
index 865ae94b601431e024ffcfcc34e01f345c9d5a20..36051f20cda98059a17cae9c1b267c5a72458338 100644 (file)
--- a/include/sudo_fatal.h
+++ b/include/sudo_fatal.h
@@ -24,60 +24,60 @@
  * go to the debug file, if there is one.
  */
 #if (defined(SUDO_ERROR_WRAP) && SUDO_ERROR_WRAP == 0) || defined(NO_VARIADIC_MACROS)
-# define sudo_fatal sudo_fatal_nodebug
-# define sudo_fatalx sudo_fatalx_nodebug
-# define sudo_warn sudo_warn_nodebug
-# define sudo_warnx sudo_warnx_nodebug
-# define sudo_vfatal(fmt, ap) sudo_vfatal_nodebug((fmt), (ap))
-# define sudo_vfatalx(fmt, ap) sudo_vfatalx_nodebug((fmt), (ap))
-# define sudo_vwarn(fmt, ap) sudo_vwarn_nodebug((fmt), (ap))
-# define sudo_vwarnx(fmt, ap) sudo_vwarnx_nodebug((fmt), (ap))
+# define sudo_fatal sudo_fatal_nodebug_v1
+# define sudo_fatalx sudo_fatalx_nodebug_v1
+# define sudo_warn sudo_warn_nodebug_v1
+# define sudo_warnx sudo_warnx_nodebug_v1
+# define sudo_vfatal(fmt, ap) sudo_vfatal_nodebug_v1((fmt), (ap))
+# define sudo_vfatalx(fmt, ap) sudo_vfatalx_nodebug_v1((fmt), (ap))
+# define sudo_vwarn(fmt, ap) sudo_vwarn_nodebug_v1((fmt), (ap))
+# define sudo_vwarnx(fmt, ap) sudo_vwarnx_nodebug_v1((fmt), (ap))
 #else /* SUDO_ERROR_WRAP */
 # if defined(__GNUC__) && __GNUC__ == 2
 #  define sudo_fatal(fmt...) do {                                             \
     sudo_debug_printf2(__func__, __FILE__, __LINE__,                          \
        SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|SUDO_DEBUG_ERRNO|sudo_debug_subsys, \
        fmt);                                                                  \
-    sudo_fatal_nodebug(fmt);                                                  \
+    sudo_fatal_nodebug_v1(fmt);                                                       \
 } while (0)
 #  define sudo_fatalx(fmt...) do {                                            \
     sudo_debug_printf2(__func__, __FILE__, __LINE__,                          \
        SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|sudo_debug_subsys, fmt);            \
-    sudo_fatalx_nodebug(fmt);                                                 \
+    sudo_fatalx_nodebug_v1(fmt);                                                      \
 } while (0)
 #  define sudo_warn(fmt...) do {                                              \
     sudo_debug_printf2(__func__, __FILE__, __LINE__,                          \
        SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|SUDO_DEBUG_ERRNO|sudo_debug_subsys, \
        fmt);                                                                  \
-    sudo_warn_nodebug(fmt);                                                   \
+    sudo_warn_nodebug_v1(fmt);                                                \
 } while (0)
 #  define sudo_warnx(fmt...) do {                                             \
     sudo_debug_printf2(__func__, __FILE__, __LINE__,                          \
        SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|sudo_debug_subsys, fmt);            \
-    sudo_warnx_nodebug(fmt);                                                  \
+    sudo_warnx_nodebug_v1(fmt);                                                       \
 } while (0)
 # else
 #  define sudo_fatal(...) do {                                                \
     sudo_debug_printf2(__func__, __FILE__, __LINE__,                          \
        SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|SUDO_DEBUG_ERRNO|sudo_debug_subsys, \
        __VA_ARGS__);                                                          \
-    sudo_fatal_nodebug(__VA_ARGS__);                                          \
+    sudo_fatal_nodebug_v1(__VA_ARGS__);                                               \
 } while (0)
 #  define sudo_fatalx(...) do {                                                       \
     sudo_debug_printf2(__func__, __FILE__, __LINE__,                          \
        SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|sudo_debug_subsys, __VA_ARGS__);    \
-    sudo_fatalx_nodebug(__VA_ARGS__);                                         \
+    sudo_fatalx_nodebug_v1(__VA_ARGS__);                                              \
 } while (0)
 #  define sudo_warn(...) do {                                                 \
     sudo_debug_printf2(__func__, __FILE__, __LINE__,                          \
        SUDO_DEBUG_WARN|SUDO_DEBUG_LINENO|SUDO_DEBUG_ERRNO|sudo_debug_subsys,  \
        __VA_ARGS__);                                                          \
-    sudo_warn_nodebug(__VA_ARGS__);                                           \
+    sudo_warn_nodebug_v1(__VA_ARGS__);                                        \
 } while (0)
 #  define sudo_warnx(...) do {                                                \
     sudo_debug_printf2(__func__, __FILE__, __LINE__,                          \
        SUDO_DEBUG_WARN|SUDO_DEBUG_LINENO|sudo_debug_subsys, __VA_ARGS__);     \
-    sudo_warnx_nodebug(__VA_ARGS__);                                          \
+    sudo_warnx_nodebug_v1(__VA_ARGS__);                                               \
 } while (0)
 # endif /* __GNUC__ == 2 */
 # define sudo_vfatal(fmt, ap) do {                                            \
@@ -86,14 +86,14 @@
     sudo_debug_vprintf2(__func__, __FILE__, __LINE__,                         \
        SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|SUDO_DEBUG_ERRNO|sudo_debug_subsys, \
        (fmt), ap2);                                                           \
-    sudo_vfatal_nodebug((fmt), (ap));                                         \
+    sudo_vfatal_nodebug_v1((fmt), (ap));                                              \
 } while (0)
 # define sudo_vfatalx(fmt, ap) do {                                           \
     va_list ap2;                                                              \
     va_copy(ap2, (ap));                                                               \
     sudo_debug_vprintf2(__func__, __FILE__, __LINE__,                         \
        SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|sudo_debug_subsys, (fmt), ap2);     \
-    sudo_vfatalx_nodebug((fmt), (ap));                                        \
+    sudo_vfatalx_nodebug_v1((fmt), (ap));                                             \
 } while (0)
 # define sudo_vwarn(fmt, ap) do {                                             \
     va_list ap2;                                                              \
@@ -101,30 +101,43 @@
     sudo_debug_vprintf2(__func__, __FILE__, __LINE__,                         \
        SUDO_DEBUG_WARN|SUDO_DEBUG_LINENO|SUDO_DEBUG_ERRNO|sudo_debug_subsys,  \
        (fmt), ap2);                                                           \
-    sudo_vwarn_nodebug((fmt), (ap));                                          \
+    sudo_vwarn_nodebug_v1((fmt), (ap));                                               \
 } while (0)
 # define sudo_vwarnx(fmt, ap) do {                                            \
     va_list ap2;                                                              \
     va_copy(ap2, (ap));                                                               \
     sudo_debug_vprintf2(__func__, __FILE__, __LINE__,                         \
        SUDO_DEBUG_WARN|SUDO_DEBUG_LINENO|sudo_debug_subsys, (fmt), ap2);      \
-    sudo_vwarnx_nodebug((fmt), (ap));                                         \
+    sudo_vwarnx_nodebug_v1((fmt), (ap));                                              \
 } while (0)
 #endif /* SUDO_ERROR_WRAP */
 
 extern int (*sudo_printf)(int msg_type, const char *fmt, ...);
 
-__dso_public int  sudo_fatal_callback_deregister(void (*func)(void));
-__dso_public int  sudo_fatal_callback_register(void (*func)(void));
-__dso_public char *sudo_warn_gettext(const char *msgid) __format_arg(1);
-__dso_public char *sudo_warn_strerror(int errnum);
-__dso_public void sudo_fatal_nodebug(const char *, ...) __printf0like(1, 2) __attribute__((__noreturn__));
-__dso_public void sudo_fatalx_nodebug(const char *, ...) __printflike(1, 2) __attribute__((__noreturn__));
-__dso_public void sudo_vfatal_nodebug(const char *, va_list ap) __printf0like(1, 0) __attribute__((__noreturn__));
-__dso_public void sudo_vfatalx_nodebug(const char *, va_list ap) __printflike(1, 0) __attribute__((__noreturn__));
-__dso_public void sudo_warn_nodebug(const char *, ...) __printf0like(1, 2);
-__dso_public void sudo_warnx_nodebug(const char *, ...) __printflike(1, 2);
-__dso_public void sudo_vwarn_nodebug(const char *, va_list ap) __printf0like(1, 0);
-__dso_public void sudo_vwarnx_nodebug(const char *, va_list ap) __printflike(1, 0);
+__dso_public int  sudo_fatal_callback_deregister_v1(void (*func)(void));
+__dso_public int  sudo_fatal_callback_register_v1(void (*func)(void));
+__dso_public char *sudo_warn_gettext_v1(const char *msgid) __format_arg(1);
+__dso_public char *sudo_warn_strerror_v1(int errnum);
+__dso_public void sudo_fatal_nodebug_v1(const char *, ...) __printf0like(1, 2) __attribute__((__noreturn__));
+__dso_public void sudo_fatalx_nodebug_v1(const char *, ...) __printflike(1, 2) __attribute__((__noreturn__));
+__dso_public void sudo_vfatal_nodebug_v1(const char *, va_list ap) __printf0like(1, 0) __attribute__((__noreturn__));
+__dso_public void sudo_vfatalx_nodebug_v1(const char *, va_list ap) __printflike(1, 0) __attribute__((__noreturn__));
+__dso_public void sudo_warn_nodebug_v1(const char *, ...) __printf0like(1, 2);
+__dso_public void sudo_warnx_nodebug_v1(const char *, ...) __printflike(1, 2);
+__dso_public void sudo_vwarn_nodebug_v1(const char *, va_list ap) __printf0like(1, 0);
+__dso_public void sudo_vwarnx_nodebug_v1(const char *, va_list ap) __printflike(1, 0);
+
+#define sudo_fatal_callback_deregister(_a) sudo_fatal_callback_deregister_v1((_a))
+#define sudo_fatal_callback_register(_a) sudo_fatal_callback_register_v1((_a))
+#define sudo_warn_gettext(_a) sudo_warn_gettext_v1((_a))
+#define sudo_warn_strerror(_a) sudo_warn_strerror_v1((_a))
+#define sudo_fatal_nodebug sudo_fatal_nodebug_v1
+#define sudo_fatalx_nodebug sudo_fatalx_nodebug_v1
+#define sudo_vfatal_nodebug(_a, _b) sudo_vfatal_nodebug_v1((_a), (_b))
+#define sudo_vfatalx_nodebug(_a, _b) sudo_vfatalx_nodebug_v1((_a), (_b))
+#define sudo_warn_nodebug sudo_warn_nodebug_v1
+#define sudo_warnx_nodebug sudo_warnx_nodebug_v1
+#define sudo_vwarn_nodebug(_a, _b) sudo_vwarn_nodebug_v1((_a), (_b))
+#define sudo_vwarnx_nodebug(_a, _b) sudo_vwarnx_nodebug_v1((_a), (_b))
 
 #endif /* _SUDO_FATAL_H_ */

diff --git a/include/sudo_lbuf.h b/include/sudo_lbuf.h
index 85fb6b8e9ed8e0b6745dd1307aca8de3a9481f38..0d95dd327ddc0f9d6b3b70e441e709ffd044044d 100644 (file)
--- a/include/sudo_lbuf.h
+++ b/include/sudo_lbuf.h
@@ -33,10 +33,16 @@ struct sudo_lbuf {
     int cols;
 };
 
-__dso_public void sudo_lbuf_init(struct sudo_lbuf *, int (*)(const char *), int, const char *, int);
-__dso_public void sudo_lbuf_destroy(struct sudo_lbuf *);
-__dso_public void sudo_lbuf_append(struct sudo_lbuf *, const char *, ...) __printflike(2, 3);
-__dso_public void sudo_lbuf_append_quoted(struct sudo_lbuf *, const char *, const char *, ...) __printflike(3, 4);
-__dso_public void sudo_lbuf_print(struct sudo_lbuf *);
+__dso_public void sudo_lbuf_init_v1(struct sudo_lbuf *, int (*)(const char *), int, const char *, int);
+__dso_public void sudo_lbuf_destroy_v1(struct sudo_lbuf *);
+__dso_public void sudo_lbuf_append_v1(struct sudo_lbuf *, const char *, ...) __printflike(2, 3);
+__dso_public void sudo_lbuf_append_quoted_v1(struct sudo_lbuf *, const char *, const char *, ...) __printflike(3, 4);
+__dso_public void sudo_lbuf_print_v1(struct sudo_lbuf *);
+
+#define sudo_lbuf_init(_a, _b, _c, _d, _e) sudo_lbuf_init_v1((_a), (_b), (_c), (_d), (_e))
+#define sudo_lbuf_destroy(_a) sudo_lbuf_destroy_v1((_a))
+#define sudo_lbuf_append sudo_lbuf_append_v1
+#define sudo_lbuf_append_quoted sudo_lbuf_append_quoted_v1
+#define sudo_lbuf_print(_a) sudo_lbuf_print_v1((_a))
 
 #endif /* _SUDO_LBUF_H */

diff --git a/include/sudo_util.h b/include/sudo_util.h
index e37eab4979216d0c368a284ab12594e79e681950..9a652f2a7cfe04fa264fe7cd829be71d0dc91928 100644 (file)
--- a/include/sudo_util.h
+++ b/include/sudo_util.h
@@ -137,48 +137,65 @@
 #endif
 
 /* aix.c */
-__dso_public int aix_prep_user(char *user, const char *tty);
-__dso_public int aix_restoreauthdb(void);
-__dso_public int aix_setauthdb(char *user);
-
-/* strtobool.c */
-__dso_public int sudo_strtobool(const char *str);
-
-/* strtoid.c */
-__dso_public id_t sudo_strtoid(const char *str, const char *sep, char **endp, const char **errstr);
-
-/* strtomode.c */
-__dso_public int sudo_strtomode(const char *cp, const char **errstr);
+__dso_public int aix_prep_user_v1(char *user, const char *tty);
+#define aix_prep_user(_a, _b) aix_prep_user_v1((_a), (_b))
+__dso_public int aix_restoreauthdb_v1(void);
+#define aix_restoreauthdb() aix_restoreauthdb_v1()
+__dso_public int aix_setauthdb_v1(char *user);
+#define aix_setauthdb(_a) aix_setauthdb_v1((_a))
 
 /* gidlist.c */
-__dso_public int sudo_parse_gids(const char *gidstr, const gid_t *basegid, GETGROUPS_T **gidsp);
+__dso_public int sudo_parse_gids_v1(const char *gidstr, const gid_t *basegid, GETGROUPS_T **gidsp);
+#define sudo_parse_gids(_a, _b, _c) sudo_parse_gids_v1((_a), (_b), (_c))
 
 /* key_val.c */
-__dso_public char *sudo_new_key_val(const char *key, const char *value);
+__dso_public char *sudo_new_key_val_v1(const char *key, const char *value);
+#define sudo_new_key_val(_a, _b) sudo_new_key_val_v1((_a), (_b))
 
 /* locking.c */
 #define SUDO_LOCK      1               /* lock a file */
 #define SUDO_TLOCK     2               /* test & lock a file (non-blocking) */
 #define SUDO_UNLOCK    4               /* unlock a file */
-__dso_public bool sudo_lock_file(int, int);
+__dso_public bool sudo_lock_file_v1(int fd, int action);
+#define sudo_lock_file(_a, _b) sudo_lock_file_v1((_a), (_b))
 
 /* parseln.c */
-__dso_public ssize_t sudo_parseln(char **buf, size_t *bufsize, unsigned int *lineno, FILE *fp);
+__dso_public ssize_t sudo_parseln_v1(char **buf, size_t *bufsize, unsigned int *lineno, FILE *fp);
+#define sudo_parseln(_a, _b, _c, _d) sudo_parseln_v1((_a), (_b), (_c), (_d))
 
 /* progname.c */
 __dso_public void initprogname(const char *);
 
 /* setgroups.c */
-__dso_public int sudo_setgroups(int ngids, const GETGROUPS_T *gids);
+__dso_public int sudo_setgroups_v1(int ngids, const GETGROUPS_T *gids);
+#define sudo_setgroups(_a, _b) sudo_setgroups_v1((_a), (_b))
+
+/* strtobool.c */
+__dso_public int sudo_strtobool_v1(const char *str);
+#define sudo_strtobool(_a) sudo_strtobool_v1((_a))
+
+/* strtoid.c */
+__dso_public id_t sudo_strtoid_v1(const char *str, const char *sep, char **endp, const char **errstr);
+#define sudo_strtoid(_a, _b, _c, _d) sudo_strtoid_v1((_a), (_b), (_c), (_d))
+
+/* strtomode.c */
+__dso_public int sudo_strtomode_v1(const char *cp, const char **errstr);
+#define sudo_strtomode(_a, _b) sudo_strtomode_v1((_a), (_b))
 
 /* term.c */
-__dso_public bool sudo_term_cbreak(int);
-__dso_public bool sudo_term_copy(int, int);
-__dso_public bool sudo_term_noecho(int);
-__dso_public bool sudo_term_raw(int, int);
-__dso_public bool sudo_term_restore(int, bool);
+__dso_public bool sudo_term_cbreak_v1(int fd);
+#define sudo_term_cbreak(_a) sudo_term_cbreak_v1((_a))
+__dso_public bool sudo_term_copy_v1(int src, int dst);
+#define sudo_term_copy(_a, _b) sudo_term_copy_v1((_a), (_b))
+__dso_public bool sudo_term_noecho_v1(int fd);
+#define sudo_term_noecho(_a) sudo_term_noecho_v1((_a))
+__dso_public bool sudo_term_raw_v1(int fd, int isig);
+#define sudo_term_raw(_a, _b) sudo_term_raw_v1((_a), (_b))
+__dso_public bool sudo_term_restore_v1(int fd, bool flush);
+#define sudo_term_restore(_a, _b) sudo_term_restore_v1((_a), (_b))
 
 /* ttysize.c */
-__dso_public void sudo_get_ttysize(int *rowp, int *colp);
+__dso_public void sudo_get_ttysize_v1(int *rowp, int *colp);
+#define sudo_get_ttysize(_a, _b) sudo_get_ttysize_v1((_a), (_b))
 
 #endif /* _SUDO_UTIL_H */

diff --git a/lib/util/aix.c b/lib/util/aix.c
index 54baad7d84907aad281309d47e31fc60bae98710..2408b2789eace07023b1cc28f3d31961f8e8cd4c 100644 (file)
--- a/lib/util/aix.c
+++ b/lib/util/aix.c
@@ -141,7 +141,7 @@ aix_setlimits(char *user)
  * group lookups are made against the correct source (files, NIS, LDAP, etc).
  */
 int
-aix_setauthdb(char *user)
+aix_setauthdb_v1(char *user)
 {
     char *registry;
     debug_decl(aix_setauthdb, SUDO_DEBUG_UTIL)
@@ -167,7 +167,7 @@ aix_setauthdb(char *user)
  * Restore the saved administrative domain, if any.
  */
 int
-aix_restoreauthdb(void)
+aix_restoreauthdb_v1(void)
 {
     debug_decl(aix_setauthdb, SUDO_DEBUG_UTIL)
 
@@ -180,7 +180,7 @@ aix_restoreauthdb(void)
 #endif
 
 int
-aix_prep_user(char *user, const char *tty)
+aix_prep_user_v1(char *user, const char *tty)
 {
     char *info;
     int len;

diff --git a/lib/util/alloc.c b/lib/util/alloc.c
index a8af8c9516f99bc57b8659f205447dca0c785f47..5ac7b6547a01436157205ac4466b533b0787cd76 100644 (file)
--- a/lib/util/alloc.c
+++ b/lib/util/alloc.c
@@ -74,7 +74,7 @@
  * malloc(3) fails.
  */
 void *
-sudo_emalloc(size_t size)
+sudo_emalloc_v1(size_t size)
 {
     void *ptr;
 
@@ -91,7 +91,7 @@ sudo_emalloc(size_t size)
  * if overflow would occur or if the system malloc(3) fails.
  */
 void *
-sudo_emallocarray(size_t nmemb, size_t size)
+sudo_emallocarray_v1(size_t nmemb, size_t size)
 {
     void *ptr;
 
@@ -112,7 +112,7 @@ sudo_emallocarray(size_t nmemb, size_t size)
  * On success, the allocated space is zero-filled.
  */
 void *
-sudo_ecalloc(size_t nmemb, size_t size)
+sudo_ecalloc_v1(size_t nmemb, size_t size)
 {
     void *ptr;
 
@@ -135,7 +135,7 @@ sudo_ecalloc(size_t nmemb, size_t size)
  * if the system realloc(3) does not support this.
  */
 void *
-sudo_erealloc(void *ptr, size_t size)
+sudo_erealloc_v1(void *ptr, size_t size)
 {
 
     if (size == 0)
@@ -154,7 +154,7 @@ sudo_erealloc(void *ptr, size_t size)
  * realloc(3) does not support this.
  */
 void *
-sudo_ereallocarray(void *ptr, size_t nmemb, size_t size)
+sudo_ereallocarray_v1(void *ptr, size_t nmemb, size_t size)
 {
 
     if (nmemb == 0 || size == 0)
@@ -176,7 +176,7 @@ sudo_ereallocarray(void *ptr, size_t nmemb, size_t size)
  * with a NULL pointer even if the system realloc(3) does not support this.
  */
 void *
-sudo_erecalloc(void *ptr, size_t onmemb, size_t nmemb, size_t msize)
+sudo_erecalloc_v1(void *ptr, size_t onmemb, size_t nmemb, size_t msize)
 {
     size_t size;
 
@@ -201,7 +201,7 @@ sudo_erecalloc(void *ptr, size_t onmemb, size_t nmemb, size_t msize)
  * malloc(3) fails.  NOTE: unlike strdup(3), sudo_estrdup(NULL) is legal.
  */
 char *
-sudo_estrdup(const char *src)
+sudo_estrdup_v1(const char *src)
 {
     char *dst = NULL;
     size_t len;
@@ -220,7 +220,7 @@ sudo_estrdup(const char *src)
  * malloc(3) fails.  NOTE: unlike strdup(3), sudo_estrdup(NULL) is legal.
  */
 char *
-sudo_estrndup(const char *src, size_t maxlen)
+sudo_estrndup_v1(const char *src, size_t maxlen)
 {
     char *dst = NULL;
     size_t len = 0;
@@ -242,7 +242,7 @@ sudo_estrndup(const char *src, size_t maxlen)
  * returns -1 (out of memory).
  */
 int
-sudo_easprintf(char **ret, const char *fmt, ...)
+sudo_easprintf_v1(char **ret, const char *fmt, ...)
 {
     int len;
     va_list ap;
@@ -261,7 +261,7 @@ sudo_easprintf(char **ret, const char *fmt, ...)
  * returns -1 (out of memory).
  */
 int
-sudo_evasprintf(char **ret, const char *format, va_list args)
+sudo_evasprintf_v1(char **ret, const char *format, va_list args)
 {
     int len;
 

diff --git a/lib/util/event.c b/lib/util/event.c
index dc3d9769d6ee808398453179e551f6fc32e2f7b6..2f39a79f1367db61fafe11c506b25bb7bfa85e0d 100644 (file)
--- a/lib/util/event.c
+++ b/lib/util/event.c
@@ -53,7 +53,7 @@
 /* XXX - use non-exiting allocators? */
 
 struct sudo_event_base *
-sudo_ev_base_alloc(void)
+sudo_ev_base_alloc_v1(void)
 {
     struct sudo_event_base *base;
     debug_decl(sudo_ev_base_alloc, SUDO_DEBUG_EVENT)
@@ -70,7 +70,7 @@ sudo_ev_base_alloc(void)
 }
 
 void
-sudo_ev_base_free(struct sudo_event_base *base)
+sudo_ev_base_free_v1(struct sudo_event_base *base)
 {
     struct sudo_event *ev, *next;
     debug_decl(sudo_ev_base_free, SUDO_DEBUG_EVENT)
@@ -86,7 +86,7 @@ sudo_ev_base_free(struct sudo_event_base *base)
 }
 
 struct sudo_event *
-sudo_ev_alloc(int fd, short events, sudo_ev_callback_t callback, void *closure)
+sudo_ev_alloc_v1(int fd, short events, sudo_ev_callback_t callback, void *closure)
 {
     struct sudo_event *ev;
     debug_decl(sudo_ev_alloc, SUDO_DEBUG_EVENT)
@@ -104,7 +104,7 @@ sudo_ev_alloc(int fd, short events, sudo_ev_callback_t callback, void *closure)
 }
 
 void
-sudo_ev_free(struct sudo_event *ev)
+sudo_ev_free_v1(struct sudo_event *ev)
 {
     debug_decl(sudo_ev_free, SUDO_DEBUG_EVENT)
 
@@ -116,7 +116,7 @@ sudo_ev_free(struct sudo_event *ev)
 }
 
 int
-sudo_ev_add(struct sudo_event_base *base, struct sudo_event *ev,
+sudo_ev_add_v1(struct sudo_event_base *base, struct sudo_event *ev,
     struct timeval *timo, bool tohead)
 {
     debug_decl(sudo_ev_add, SUDO_DEBUG_EVENT)
@@ -182,7 +182,7 @@ sudo_ev_add(struct sudo_event_base *base, struct sudo_event *ev,
 }
 
 int
-sudo_ev_del(struct sudo_event_base *base, struct sudo_event *ev)
+sudo_ev_del_v1(struct sudo_event_base *base, struct sudo_event *ev)
 {
     debug_decl(sudo_ev_del, SUDO_DEBUG_EVENT)
 
@@ -239,7 +239,7 @@ sudo_ev_del(struct sudo_event_base *base, struct sudo_event *ev)
  * Returns 0 on success, 1 if no events registered  and -1 on error 
  */
 int
-sudo_ev_loop(struct sudo_event_base *base, int flags)
+sudo_ev_loop_v1(struct sudo_event_base *base, int flags)
 {
     struct timeval now;
     struct sudo_event *ev;
@@ -347,7 +347,7 @@ done:
 }
 
 void
-sudo_ev_loopexit(struct sudo_event_base *base)
+sudo_ev_loopexit_v1(struct sudo_event_base *base)
 {
     debug_decl(sudo_ev_loopexit, SUDO_DEBUG_EVENT)
     SET(base->flags, SUDO_EVBASE_LOOPEXIT);
@@ -355,7 +355,7 @@ sudo_ev_loopexit(struct sudo_event_base *base)
 }
 
 void
-sudo_ev_loopbreak(struct sudo_event_base *base)
+sudo_ev_loopbreak_v1(struct sudo_event_base *base)
 {
     debug_decl(sudo_ev_loopbreak, SUDO_DEBUG_EVENT)
     SET(base->flags, SUDO_EVBASE_LOOPBREAK);
@@ -363,7 +363,7 @@ sudo_ev_loopbreak(struct sudo_event_base *base)
 }
 
 void
-sudo_ev_loopcontinue(struct sudo_event_base *base)
+sudo_ev_loopcontinue_v1(struct sudo_event_base *base)
 {
     debug_decl(sudo_ev_loopcontinue, SUDO_DEBUG_EVENT)
     SET(base->flags, SUDO_EVBASE_LOOPCONT);
@@ -371,21 +371,21 @@ sudo_ev_loopcontinue(struct sudo_event_base *base)
 }
 
 bool
-sudo_ev_got_exit(struct sudo_event_base *base)
+sudo_ev_got_exit_v1(struct sudo_event_base *base)
 {
     debug_decl(sudo_ev_got_exit, SUDO_DEBUG_EVENT)
     debug_return_bool(ISSET(base->flags, SUDO_EVBASE_GOT_EXIT));
 }
 
 bool
-sudo_ev_got_break(struct sudo_event_base *base)
+sudo_ev_got_break_v1(struct sudo_event_base *base)
 {
     debug_decl(sudo_ev_got_break, SUDO_DEBUG_EVENT)
     debug_return_bool(ISSET(base->flags, SUDO_EVBASE_GOT_BREAK));
 }
 
 int
-sudo_ev_get_timeleft(struct sudo_event *ev, struct timeval *tv)
+sudo_ev_get_timeleft_v1(struct sudo_event *ev, struct timeval *tv)
 {
     struct timeval now;
     debug_decl(sudo_ev_get_timeleft, SUDO_DEBUG_EVENT)

diff --git a/lib/util/fatal.c b/lib/util/fatal.c
index e47bde8af96734ca83cfc5022d5345b3de1f68c3..be2e857b8b70798cf506153098627c1cbc9138e8 100644 (file)
--- a/lib/util/fatal.c
+++ b/lib/util/fatal.c
@@ -61,7 +61,7 @@ do_cleanup(void)
 }
 
 void
-sudo_fatal_nodebug(const char *fmt, ...)
+sudo_fatal_nodebug_v1(const char *fmt, ...)
 {
     va_list ap;
 
@@ -73,7 +73,7 @@ sudo_fatal_nodebug(const char *fmt, ...)
 }
 
 void
-sudo_fatalx_nodebug(const char *fmt, ...)
+sudo_fatalx_nodebug_v1(const char *fmt, ...)
 {
     va_list ap;
 
@@ -85,7 +85,7 @@ sudo_fatalx_nodebug(const char *fmt, ...)
 }
 
 void
-sudo_vfatal_nodebug(const char *fmt, va_list ap)
+sudo_vfatal_nodebug_v1(const char *fmt, va_list ap)
 {
     _warning(errno, fmt, ap);
     do_cleanup();
@@ -93,7 +93,7 @@ sudo_vfatal_nodebug(const char *fmt, va_list ap)
 }
 
 void
-sudo_vfatalx_nodebug(const char *fmt, va_list ap)
+sudo_vfatalx_nodebug_v1(const char *fmt, va_list ap)
 {
     _warning(0, fmt, ap);
     do_cleanup();
@@ -101,7 +101,7 @@ sudo_vfatalx_nodebug(const char *fmt, va_list ap)
 }
 
 void
-sudo_warn_nodebug(const char *fmt, ...)
+sudo_warn_nodebug_v1(const char *fmt, ...)
 {
     va_list ap;
 
@@ -111,7 +111,7 @@ sudo_warn_nodebug(const char *fmt, ...)
 }
 
 void
-sudo_warnx_nodebug(const char *fmt, ...)
+sudo_warnx_nodebug_v1(const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
@@ -120,13 +120,13 @@ sudo_warnx_nodebug(const char *fmt, ...)
 }
 
 void
-sudo_vwarn_nodebug(const char *fmt, va_list ap)
+sudo_vwarn_nodebug_v1(const char *fmt, va_list ap)
 {
     _warning(errno, fmt, ap);
 }
 
 void
-sudo_vwarnx_nodebug(const char *fmt, va_list ap)
+sudo_vwarnx_nodebug_v1(const char *fmt, va_list ap)
 {
     _warning(0, fmt, ap);
 }
@@ -158,7 +158,7 @@ _warning(int errnum, const char *fmt, va_list ap)
  * Register a callback to be run when sudo_fatal()/sudo_fatalx() is called.
  */
 int
-sudo_fatal_callback_register(void (*func)(void))
+sudo_fatal_callback_register_v1(void (*func)(void))
 {
     struct sudo_fatal_callback *cb;
 
@@ -182,7 +182,7 @@ sudo_fatal_callback_register(void (*func)(void))
  * Deregister a sudo_fatal()/sudo_fatalx() callback.
  */
 int
-sudo_fatal_callback_deregister(void (*func)(void))
+sudo_fatal_callback_deregister_v1(void (*func)(void))
 {
     struct sudo_fatal_callback *cb, **prev;
 

diff --git a/lib/util/gidlist.c b/lib/util/gidlist.c
index 898716f8f22f5b98dd97cb08255c9f2555fd8e5b..4355ca69f4c17b23f8a1ac5d48a476b011e90352 100644 (file)
--- a/lib/util/gidlist.c
+++ b/lib/util/gidlist.c
@@ -45,7 +45,7 @@
  * Returns the number of gids in the allocated array.
  */
 int
-sudo_parse_gids(const char *gidstr, const gid_t *basegid, GETGROUPS_T **gidsp)
+sudo_parse_gids_v1(const char *gidstr, const gid_t *basegid, GETGROUPS_T **gidsp)
 {
     int ngids = 0;
     GETGROUPS_T *gids;

diff --git a/lib/util/key_val.c b/lib/util/key_val.c
index e5ea21307acd84da094ef83da4f49e99e8be604f..79b0eb83a5a8e5e5568de8aa326bc49603aa3459 100644 (file)
--- a/lib/util/key_val.c
+++ b/lib/util/key_val.c
@@ -46,7 +46,7 @@
  * The caller is responsible for freeing the string.
  */
 char *
-sudo_new_key_val(const char *key, const char *val)
+sudo_new_key_val_v1(const char *key, const char *val)
 {
     size_t key_len = strlen(key);
     size_t val_len = strlen(val);

diff --git a/lib/util/lbuf.c b/lib/util/lbuf.c
index eb1156f974a84824fd31c1ef568e135aa15ab3fc..01096a4a4dddee4681335895de616b6f4f9e85af 100644 (file)
--- a/lib/util/lbuf.c
+++ b/lib/util/lbuf.c
@@ -49,7 +49,7 @@
 #include "sudo_debug.h"
 
 void
-sudo_lbuf_init(struct sudo_lbuf *lbuf, int (*output)(const char *),
+sudo_lbuf_init_v1(struct sudo_lbuf *lbuf, int (*output)(const char *),
     int indent, const char *continuation, int cols)
 {
     debug_decl(sudo_lbuf_init, SUDO_DEBUG_UTIL)
@@ -66,7 +66,7 @@ sudo_lbuf_init(struct sudo_lbuf *lbuf, int (*output)(const char *),
 }
 
 void
-sudo_lbuf_destroy(struct sudo_lbuf *lbuf)
+sudo_lbuf_destroy_v1(struct sudo_lbuf *lbuf)
 {
     debug_decl(sudo_lbuf_destroy, SUDO_DEBUG_UTIL)
 
@@ -92,7 +92,7 @@ sudo_lbuf_expand(struct sudo_lbuf *lbuf, int extra)
  * Any characters in set are quoted with a backslash.
  */
 void
-sudo_lbuf_append_quoted(struct sudo_lbuf *lbuf, const char *set, const char *fmt, ...)
+sudo_lbuf_append_quoted_v1(struct sudo_lbuf *lbuf, const char *set, const char *fmt, ...)
 {
     va_list ap;
     int len;
@@ -139,7 +139,7 @@ done:
  * Parse the format and append strings, only %s and %% escapes are supported.
  */
 void
-sudo_lbuf_append(struct sudo_lbuf *lbuf, const char *fmt, ...)
+sudo_lbuf_append_v1(struct sudo_lbuf *lbuf, const char *fmt, ...)
 {
     va_list ap;
     int len;
@@ -232,7 +232,7 @@ sudo_lbuf_println(struct sudo_lbuf *lbuf, char *line, int len)
  * The lbuf is reset on return.
  */
 void
-sudo_lbuf_print(struct sudo_lbuf *lbuf)
+sudo_lbuf_print_v1(struct sudo_lbuf *lbuf)
 {
     char *cp, *ep;
     int len;

diff --git a/lib/util/locking.c b/lib/util/locking.c
index d0be4b5b78ed0f7daddcd5ae960267590c729409..e5fef83327676b6aa4b6f015376c804df711cd24 100644 (file)
--- a/lib/util/locking.c
+++ b/lib/util/locking.c
@@ -65,7 +65,7 @@
  */
 #ifdef HAVE_LOCKF
 bool
-sudo_lock_file(int fd, int lockit)
+sudo_lock_file_v1(int fd, int lockit)
 {
     int op = 0;
     debug_decl(sudo_lock_file, SUDO_DEBUG_UTIL)
@@ -85,7 +85,7 @@ sudo_lock_file(int fd, int lockit)
 }
 #elif defined(HAVE_FLOCK)
 bool
-sudo_lock_file(int fd, int lockit)
+sudo_lock_file_v1(int fd, int lockit)
 {
     int op = 0;
     debug_decl(sudo_lock_file, SUDO_DEBUG_UTIL)
@@ -105,7 +105,7 @@ sudo_lock_file(int fd, int lockit)
 }
 #else
 bool
-sudo_lock_file(int fd, int lockit)
+sudo_lock_file_v1(int fd, int lockit)
 {
 #ifdef F_SETLK
     int func;

diff --git a/lib/util/parseln.c b/lib/util/parseln.c
index 16ffca79b6447649e27c6bf5719386fdc0c5f4d4..cdc25942ecb9b44c5bcda68652097f1d18d1514e 100644 (file)
--- a/lib/util/parseln.c
+++ b/lib/util/parseln.c
@@ -61,7 +61,7 @@
  *       could also make comment char and line continuation configurable
  */
 ssize_t
-sudo_parseln(char **bufp, size_t *bufsizep, unsigned int *lineno, FILE *fp)
+sudo_parseln_v1(char **bufp, size_t *bufsizep, unsigned int *lineno, FILE *fp)
 {
     size_t linesize = 0, total = 0;
     ssize_t len;

diff --git a/lib/util/secure_path.c b/lib/util/secure_path.c
index fd2f75c07274946ed6e993b90232cbfef2842b02..7a8eeb76a17da0cf119a78a99225d1d344b6d55a 100644 (file)
--- a/lib/util/secure_path.c
+++ b/lib/util/secure_path.c
@@ -37,7 +37,7 @@
 /*
  * Verify that path is the right type and not writable by other users.
  */
-int
+static int
 sudo_secure_path(const char *path, unsigned int type, uid_t uid, gid_t gid, struct stat *sbp)
 {
     struct stat sb;
@@ -68,7 +68,7 @@ sudo_secure_path(const char *path, unsigned int type, uid_t uid, gid_t gid, stru
  * Verify that path is a regular file and not writable by other users.
  */
 int
-sudo_secure_file(const char *path, uid_t uid, gid_t gid, struct stat *sbp)
+sudo_secure_file_v1(const char *path, uid_t uid, gid_t gid, struct stat *sbp)
 {
     return sudo_secure_path(path, _S_IFREG, uid, gid, sbp);
 }
@@ -77,7 +77,7 @@ sudo_secure_file(const char *path, uid_t uid, gid_t gid, struct stat *sbp)
  * Verify that path is a directory and not writable by other users.
  */
 int
-sudo_secure_dir(const char *path, uid_t uid, gid_t gid, struct stat *sbp)
+sudo_secure_dir_v1(const char *path, uid_t uid, gid_t gid, struct stat *sbp)
 {
     return sudo_secure_path(path, _S_IFDIR, uid, gid, sbp);
 }

diff --git a/lib/util/setgroups.c b/lib/util/setgroups.c
index 5bc823baae8888144dd2ffde5dc298e7091c16fa..f63d2f12c9e353f814ea4044e458fe33725cd3f6 100644 (file)
--- a/lib/util/setgroups.c
+++ b/lib/util/setgroups.c
@@ -40,7 +40,7 @@
 #include "sudo_util.h"
 
 int
-sudo_setgroups(int ngids, const GETGROUPS_T *gids)
+sudo_setgroups_v1(int ngids, const GETGROUPS_T *gids)
 {
     int maxgids, rval;
     debug_decl(sudo_setgroups, SUDO_DEBUG_UTIL)

diff --git a/lib/util/strtobool.c b/lib/util/strtobool.c
index 4dfa8e36d96a394ef419bdd9eac160b403a0ceda..5450a25c598a0c35d19809b361a413ae9e9b36de 100644 (file)
--- a/lib/util/strtobool.c
+++ b/lib/util/strtobool.c
@@ -42,7 +42,7 @@
 #include "sudo_util.h"
 
 int
-sudo_strtobool(const char *str)
+sudo_strtobool_v1(const char *str)
 {
     debug_decl(sudo_strtobool, SUDO_DEBUG_UTIL)
 

diff --git a/lib/util/strtoid.c b/lib/util/strtoid.c
index 8ba201838edf06b7b20159e16e7e4a1bf12f38f6..c311bb78665af4059f0e004a7a68567c5176091b 100644 (file)
--- a/lib/util/strtoid.c
+++ b/lib/util/strtoid.c
@@ -56,7 +56,7 @@
  * On error, returns 0 and sets errstr.
  */
 id_t
-sudo_strtoid(const char *p, const char *sep, char **endp, const char **errstr)
+sudo_strtoid_v1(const char *p, const char *sep, char **endp, const char **errstr)
 {
     char *ep;
     id_t rval = 0;

diff --git a/lib/util/strtomode.c b/lib/util/strtomode.c
index 3813d9344b8fb42ba90a6a0f2ce1ac5234550fc6..954ec827dfc15a70142387d3ebdfbfcb6b65cc15 100644 (file)
--- a/lib/util/strtomode.c
+++ b/lib/util/strtomode.c
@@ -42,7 +42,7 @@
  * On error, returns 0 and sets errstr.
  */
 int
-sudo_strtomode(const char *cp, const char **errstr)
+sudo_strtomode_v1(const char *cp, const char **errstr)
 {
     char *ep;
     long lval;

diff --git a/lib/util/sudo_conf.c b/lib/util/sudo_conf.c
index af96e8e0f7cdfedcde108fe22bf191763f2426de..74d8d645d4d537e9b920ed2e180ceb482cd34a92 100644 (file)
--- a/lib/util/sudo_conf.c
+++ b/lib/util/sudo_conf.c
@@ -317,20 +317,20 @@ set_plugin(const char *entry, const char *conf_file)
 }
 
 const char *
-sudo_conf_askpass_path(void)
+sudo_conf_askpass_path_v1(void)
 {
     return sudo_conf_data.paths[SUDO_CONF_ASKPASS_IDX].pval;
 }
 
 const char *
-sudo_conf_sesh_path(void)
+sudo_conf_sesh_path_v1(void)
 {
     return sudo_conf_data.paths[SUDO_CONF_SESH_IDX].pval;
 }
 
 #ifdef _PATH_SUDO_NOEXEC
 const char *
-sudo_conf_noexec_path(void)
+sudo_conf_noexec_path_v1(void)
 {
     return sudo_conf_data.paths[SUDO_CONF_NOEXEC_IDX].pval;
 }
@@ -338,44 +338,44 @@ sudo_conf_noexec_path(void)
 
 #ifdef _PATH_SUDO_PLUGIN_DIR
 const char *
-sudo_conf_plugin_dir_path(void)
+sudo_conf_plugin_dir_path_v1(void)
 {
     return sudo_conf_data.paths[SUDO_CONF_PLUGIN_IDX].pval;
 }
 #endif
 
 const char *
-sudo_conf_debug_flags(void)
+sudo_conf_debug_flags_v1(void)
 {
     return sudo_conf_data.debug_flags;
 }
 
 int
-sudo_conf_group_source(void)
+sudo_conf_group_source_v1(void)
 {
     return sudo_conf_data.group_source;
 }
 
 int
-sudo_conf_max_groups(void)
+sudo_conf_max_groups_v1(void)
 {
     return sudo_conf_data.max_groups;
 }
 
 struct plugin_info_list *
-sudo_conf_plugins(void)
+sudo_conf_plugins_v1(void)
 {
     return &sudo_conf_data.plugins;
 }
 
 bool
-sudo_conf_disable_coredump(void)
+sudo_conf_disable_coredump_v1(void)
 {
     return sudo_conf_data.disable_coredump;
 }
 
 bool
-sudo_conf_probe_interfaces(void)
+sudo_conf_probe_interfaces_v1(void)
 {
     return sudo_conf_data.probe_interfaces;
 }
@@ -384,7 +384,7 @@ sudo_conf_probe_interfaces(void)
  * Reads in /etc/sudo.conf and populates sudo_conf_data.
  */
 void
-sudo_conf_read(const char *conf_file)
+sudo_conf_read_v1(const char *conf_file)
 {
     struct sudo_conf_table *cur;
     struct stat sb;

diff --git a/lib/util/sudo_dso.c b/lib/util/sudo_dso.c
index 972d9d828dbd9898c2c9b44c17065b1fabdafa22..1cece29394bf69daef683e7329c34ed128d4af66 100644 (file)
--- a/lib/util/sudo_dso.c
+++ b/lib/util/sudo_dso.c
@@ -49,7 +49,7 @@
 static struct sudo_preload_table *preload_table;
 
 void
-sudo_dso_preload_table(struct sudo_preload_table *table)
+sudo_dso_preload_table_v1(struct sudo_preload_table *table)
 {
     preload_table = table;
 }
@@ -61,7 +61,7 @@ sudo_dso_preload_table(struct sudo_preload_table *table)
 # endif
 
 void *
-sudo_dso_load(const char *path, int mode)
+sudo_dso_load_v1(const char *path, int mode)
 {
     struct sudo_preload_table *pt;
     int flags = DYNAMIC_PATH | BIND_VERBOSE;
@@ -87,7 +87,7 @@ sudo_dso_load(const char *path, int mode)
 }
 
 int
-sudo_dso_unload(void *handle)
+sudo_dso_unload_v1(void *handle)
 {
     struct sudo_preload_table *pt;
 
@@ -103,7 +103,7 @@ sudo_dso_unload(void *handle)
 }
 
 void *
-sudo_dso_findsym(void *vhandle, const char *symbol)
+sudo_dso_findsym_v1(void *vhandle, const char *symbol)
 {
     struct sudo_preload_table *pt;
     shl_t handle = vhandle;
@@ -156,7 +156,7 @@ sudo_dso_findsym(void *vhandle, const char *symbol)
 }
 
 char *
-sudo_dso_strerror(void)
+sudo_dso_strerror_v1(void)
 {
     return strerror(errno);
 }
@@ -168,7 +168,7 @@ sudo_dso_strerror(void)
 # endif
 
 void *
-sudo_dso_load(const char *path, int mode)
+sudo_dso_load_v1(const char *path, int mode)
 {
     struct sudo_preload_table *pt;
     int flags = 0;
@@ -195,7 +195,7 @@ sudo_dso_load(const char *path, int mode)
 }
 
 int
-sudo_dso_unload(void *handle)
+sudo_dso_unload_v1(void *handle)
 {
     struct sudo_preload_table *pt;
 
@@ -211,7 +211,7 @@ sudo_dso_unload(void *handle)
 }
 
 void *
-sudo_dso_findsym(void *handle, const char *symbol)
+sudo_dso_findsym_v1(void *handle, const char *symbol)
 {
     struct sudo_preload_table *pt;
 
@@ -260,7 +260,7 @@ sudo_dso_findsym(void *handle, const char *symbol)
 }
 
 char *
-sudo_dso_strerror(void)
+sudo_dso_strerror_v1(void)
 {
     return dlerror();
 }
@@ -271,7 +271,7 @@ sudo_dso_strerror(void)
  * Emulate dlopen() using a static list of symbols compiled into sudo.
  */
 void *
-sudo_dso_load(const char *path, int mode)
+sudo_dso_load_v1(const char *path, int mode)
 {
     struct sudo_preload_table *pt;
 
@@ -286,7 +286,7 @@ sudo_dso_load(const char *path, int mode)
 }
 
 int
-sudo_dso_unload(void *handle)
+sudo_dso_unload_v1(void *handle)
 {
     struct sudo_preload_table *pt;
 
@@ -300,7 +300,7 @@ sudo_dso_unload(void *handle)
 }
 
 void *
-sudo_dso_findsym(void *handle, const char *symbol)
+sudo_dso_findsym_v1(void *handle, const char *symbol)
 {
     struct sudo_preload_table *pt;
 
@@ -320,7 +320,7 @@ sudo_dso_findsym(void *handle, const char *symbol)
 }
 
 char *
-sudo_dso_strerror(void)
+sudo_dso_strerror_v1(void)
 {
     return strerror(errno);
 }

diff --git a/lib/util/term.c b/lib/util/term.c
index 3b18ca556fe6d342f87e7c29aeaee73fb8bf8419..b8c0234ae95383b7907bf38d29ae988815d76b88 100644 (file)
--- a/lib/util/term.c
+++ b/lib/util/term.c
@@ -117,7 +117,7 @@ tcsetattr_nobg(int fd, int flags, struct termios *tp)
  * Returns true on success or false on failure.
  */
 bool
-sudo_term_restore(int fd, bool flush)
+sudo_term_restore_v1(int fd, bool flush)
 {
     debug_decl(term_restore, SUDO_DEBUG_UTIL)
 
@@ -135,7 +135,7 @@ sudo_term_restore(int fd, bool flush)
  * Returns true on success or false on failure.
  */
 bool
-sudo_term_noecho(int fd)
+sudo_term_noecho_v1(int fd)
 {
     debug_decl(term_noecho, SUDO_DEBUG_UTIL)
 
@@ -164,7 +164,7 @@ again:
  * Returns true on success or false on failure.
  */
 bool
-sudo_term_raw(int fd, int isig)
+sudo_term_raw_v1(int fd, int isig)
 {
     struct termios term;
     debug_decl(term_raw, SUDO_DEBUG_UTIL)
@@ -198,7 +198,7 @@ again:
  * Returns true on success or false on failure.
  */
 bool
-sudo_term_cbreak(int fd)
+sudo_term_cbreak_v1(int fd)
 {
     debug_decl(term_cbreak, SUDO_DEBUG_UTIL)
 
@@ -235,7 +235,7 @@ again:
  * Returns true on success or false on failure.
  */
 bool
-sudo_term_copy(int src, int dst)
+sudo_term_copy_v1(int src, int dst)
 {
     struct termios tt;
     debug_decl(term_copy, SUDO_DEBUG_UTIL)

diff --git a/lib/util/ttysize.c b/lib/util/ttysize.c
index de467f653ad4fcb7c7ff6a1551a038256b253cb5..c55e28152e8c1ebe4776c96f6b2c8a454d1f2128 100644 (file)
--- a/lib/util/ttysize.c
+++ b/lib/util/ttysize.c
@@ -71,7 +71,7 @@ get_ttysize_ioctl(int *rowp, int *colp)
 #endif /* TIOCGWINSZ */
 
 void
-sudo_get_ttysize(int *rowp, int *colp)
+sudo_get_ttysize_v1(int *rowp, int *colp)
 {
     debug_decl(sudo_get_ttysize, SUDO_DEBUG_EXEC)
 

diff --git a/lib/util/util.exp b/lib/util/util.exp
index 7c47a69e15000ffe1707519407a12075e3517534..5c66ebb1386bd063f9470ee0e02b9fd089c1a6ee 100644 (file)
--- a/lib/util/util.exp
+++ b/lib/util/util.exp
@@ -19,26 +19,26 @@ SHA512Pad
 SHA512Transform
 SHA512Update
 _sudo_printf
-aix_prep_user
-aix_restoreauthdb
-aix_setauthdb
+aix_prep_user_v1
+aix_restoreauthdb_v1
+aix_setauthdb_v1
 closefrom_fallback
 initprogname
 isblank
 sudo_asprintf
 sudo_clock_gettime
 sudo_closefrom
-sudo_conf_askpass_path
-sudo_conf_debug_flags
-sudo_conf_disable_coredump
-sudo_conf_group_source
-sudo_conf_max_groups
-sudo_conf_noexec_path
-sudo_conf_plugin_dir_path
-sudo_conf_plugins
-sudo_conf_probe_interfaces
-sudo_conf_read
-sudo_conf_sesh_path
+sudo_conf_askpass_path_v1
+sudo_conf_debug_flags_v1
+sudo_conf_disable_coredump_v1
+sudo_conf_group_source_v1
+sudo_conf_max_groups_v1
+sudo_conf_noexec_path_v1
+sudo_conf_plugin_dir_path_v1
+sudo_conf_plugins_v1
+sudo_conf_probe_interfaces_v1
+sudo_conf_read_v1
+sudo_conf_sesh_path_v1
 sudo_debug_enter
 sudo_debug_execve2
 sudo_debug_exit
@@ -56,45 +56,44 @@ sudo_debug_init
 sudo_debug_printf2
 sudo_debug_printf_nvm
 sudo_debug_vprintf2
-sudo_debug_write
 sudo_debug_write2
-sudo_dso_findsym
-sudo_dso_load
-sudo_dso_preload_table
-sudo_dso_strerror
-sudo_dso_unload
-sudo_easprintf
-sudo_ecalloc
-sudo_emalloc
-sudo_emallocarray
-sudo_erealloc
-sudo_ereallocarray
-sudo_erecalloc
-sudo_estrdup
-sudo_estrndup
-sudo_ev_add
-sudo_ev_alloc
-sudo_ev_base_alloc
-sudo_ev_base_free
-sudo_ev_del
-sudo_ev_free
-sudo_ev_get_timeleft
-sudo_ev_got_break
-sudo_ev_got_exit
-sudo_ev_loop
-sudo_ev_loopbreak
-sudo_ev_loopcontinue
-sudo_ev_loopexit
-sudo_evasprintf
-sudo_fatal_callback_deregister
-sudo_fatal_callback_register
-sudo_fatal_nodebug
-sudo_fatalx_nodebug
+sudo_dso_findsym_v1
+sudo_dso_load_v1
+sudo_dso_preload_table_v1
+sudo_dso_strerror_v1
+sudo_dso_unload_v1
+sudo_easprintf_v1
+sudo_ecalloc_v1
+sudo_emalloc_v1
+sudo_emallocarray_v1
+sudo_erealloc_v1
+sudo_ereallocarray_v1
+sudo_erecalloc_v1
+sudo_estrdup_v1
+sudo_estrndup_v1
+sudo_ev_add_v1
+sudo_ev_alloc_v1
+sudo_ev_base_alloc_v1
+sudo_ev_base_free_v1
+sudo_ev_del_v1
+sudo_ev_free_v1
+sudo_ev_get_timeleft_v1
+sudo_ev_got_break_v1
+sudo_ev_got_exit_v1
+sudo_ev_loop_v1
+sudo_ev_loopbreak_v1
+sudo_ev_loopcontinue_v1
+sudo_ev_loopexit_v1
+sudo_evasprintf_v1
+sudo_fatal_callback_deregister_v1
+sudo_fatal_callback_register_v1
+sudo_fatal_nodebug_v1
+sudo_fatalx_nodebug_v1
 sudo_fnmatch
 sudo_freeaddrinfo
 sudo_futimes
 sudo_gai_strerror
-sudo_get_ttysize
+sudo_get_ttysize_v1
 sudo_getaddrinfo
 sudo_getcwd
 sudo_getgrouplist
@@ -105,48 +104,48 @@ sudo_getprogname
 sudo_glob
 sudo_globfree
 sudo_inet_pton
-sudo_lbuf_append
-sudo_lbuf_append_quoted
-sudo_lbuf_destroy
-sudo_lbuf_init
-sudo_lbuf_print
-sudo_lock_file
+sudo_lbuf_append_quoted_v1
+sudo_lbuf_append_v1
+sudo_lbuf_destroy_v1
+sudo_lbuf_init_v1
+sudo_lbuf_print_v1
+sudo_lock_file_v1
 sudo_memrchr
 sudo_memset_s
 sudo_mkdtemp
 sudo_mkstemps
-sudo_new_key_val
-sudo_parse_gids
-sudo_parseln
+sudo_new_key_val_v1
+sudo_parse_gids_v1
+sudo_parseln_v1
 sudo_printf
 sudo_pw_dup
-sudo_secure_dir
-sudo_secure_file
-sudo_setgroups
+sudo_secure_dir_v1
+sudo_secure_file_v1
+sudo_setgroups_v1
 sudo_sig2str
 sudo_snprintf
 sudo_strlcat
 sudo_strlcpy
 sudo_strsignal
-sudo_strtobool
-sudo_strtoid
-sudo_strtomode
+sudo_strtobool_v1
+sudo_strtoid_v1
+sudo_strtomode_v1
 sudo_strtonum
-sudo_term_cbreak
-sudo_term_copy
-sudo_term_erase
-sudo_term_kill
-sudo_term_noecho
-sudo_term_raw
-sudo_term_restore
+sudo_term_cbreak_v1
+sudo_term_copy_v1
+sudo_term_erase_v1
+sudo_term_kill_v1
+sudo_term_noecho_v1
+sudo_term_raw_v1
+sudo_term_restore_v1
 sudo_utimes
 sudo_vasprintf
-sudo_vfatal_nodebug
-sudo_vfatalx_nodebug
+sudo_vfatal_nodebug_v1
+sudo_vfatalx_nodebug_v1
 sudo_vsnprintf
-sudo_vwarn_nodebug
-sudo_vwarnx_nodebug
-sudo_warn_gettext
-sudo_warn_nodebug
-sudo_warn_strerror
-sudo_warnx_nodebug
+sudo_vwarn_nodebug_v1
+sudo_vwarnx_nodebug_v1
+sudo_warn_gettext_v1
+sudo_warn_nodebug_v1
+sudo_warn_strerror_v1
+sudo_warnx_nodebug_v1

diff --git a/plugins/sudoers/locale.c b/plugins/sudoers/locale.c
index ca080451aa0b26f4f529066c739abe23445b26dc..e37424181c47ccd63c981ca7361fcea0a5311d35 100644 (file)
--- a/plugins/sudoers/locale.c
+++ b/plugins/sudoers/locale.c
@@ -112,7 +112,7 @@ sudoers_setlocale(int newlocale, int *prevlocale)
 
 #ifdef HAVE_LIBINTL_H
 char *
-sudo_warn_gettext(const char *msgid)
+sudo_warn_gettext_v1(const char *msgid)
 {
     int warning_locale;
     char *msg;
@@ -126,7 +126,7 @@ sudo_warn_gettext(const char *msgid)
 #endif /* HAVE_LIBINTL_H */
 
 char *
-sudo_warn_strerror(int errnum)
+sudo_warn_strerror_v1(int errnum)
 {
     int warning_locale;
     char *errmsg;

diff --git a/src/locale_stub.c b/src/locale_stub.c
index d19393b252ed0d81f5c482d101a95b2ddcf3c50e..7b57865851f7a664e60fd5b38be451598b82cdf9 100644 (file)
--- a/src/locale_stub.c
+++ b/src/locale_stub.c
@@ -36,7 +36,7 @@
 #ifdef HAVE_LIBINTL_H
 /* No need to swap locales in the front end. */
 char *
-sudo_warn_gettext(const char *msgid)
+sudo_warn_gettext_v1(const char *msgid)
 {
     return gettext(msgid);
 }
@@ -44,7 +44,7 @@ sudo_warn_gettext(const char *msgid)
 
 /* No need to swap locales in the front end. */
 char *
-sudo_warn_strerror(int errnum)
+sudo_warn_strerror_v1(int errnum)
 {
     return strerror(errnum);
 }