Version the functions in libsudo_util

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_dir_v1(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_file_v1(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);
+
+#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 */

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_easprintf_v1(char **, const char *, ...) __printflike(2, 3);
-__dso_public int  sudo_evasprintf(char **, const char *, va_list) __printflike(2, 0);
+__dso_public int  sudo_evasprintf_v1(char **, const char *, va_list) __printflike(2, 0);
-__dso_public void *sudo_ecalloc(size_t, size_t) __malloc_like;
+__dso_public void *sudo_ecalloc_v1(size_t, size_t) __malloc_like;
-__dso_public void *sudo_emalloc(size_t) __malloc_like;
+__dso_public void *sudo_emalloc_v1(size_t) __malloc_like;
-__dso_public void *sudo_emallocarray(size_t, size_t) __malloc_like;
+__dso_public void *sudo_emallocarray_v1(size_t, size_t) __malloc_like;
-__dso_public void *sudo_erealloc(void *, size_t);
+__dso_public void *sudo_erealloc_v1(void *, size_t);
-__dso_public void *sudo_ereallocarray(void *, size_t, size_t);
+__dso_public void *sudo_ereallocarray_v1(void *, size_t, size_t);
-__dso_public void *sudo_erecalloc(void *, size_t, size_t, size_t);
+__dso_public void *sudo_erecalloc_v1(void *, size_t, size_t, size_t);
-__dso_public char *sudo_estrdup(const char *) __malloc_like;
+__dso_public char *sudo_estrdup_v1(const char *) __malloc_like;
-__dso_public char *sudo_estrndup(const char *, size_t) __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 */

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_askpass_path_v1(void);
-__dso_public const char *sudo_conf_sesh_path(void);
+__dso_public const char *sudo_conf_sesh_path_v1(void);
-__dso_public const char *sudo_conf_noexec_path(void);
+__dso_public const char *sudo_conf_noexec_path_v1(void);
-__dso_public const char *sudo_conf_plugin_dir_path(void);
+__dso_public const char *sudo_conf_plugin_dir_path_v1(void);
-__dso_public const char *sudo_conf_debug_flags(void);
+__dso_public const char *sudo_conf_debug_flags_v1(void);
-__dso_public struct plugin_info_list *sudo_conf_plugins(void);
+__dso_public struct plugin_info_list *sudo_conf_plugins_v1(void);
-__dso_public bool sudo_conf_disable_coredump(void);
+__dso_public bool sudo_conf_disable_coredump_v1(void);
-__dso_public bool sudo_conf_probe_interfaces(void);
+__dso_public bool sudo_conf_probe_interfaces_v1(void);
-__dso_public int sudo_conf_group_source(void);
+__dso_public int sudo_conf_group_source_v1(void);
-__dso_public int sudo_conf_max_groups(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 */

include/sudo_dso.h

@@ -40,10 +40,16 @@ struct sudo_preload_table {
 };
 
 /* Public functions. */
-__dso_public char *sudo_dso_strerror(void);
+__dso_public char *sudo_dso_strerror_v1(void);
-__dso_public int sudo_dso_unload(void *handle);
+__dso_public int sudo_dso_unload_v1(void *handle);
-__dso_public void *sudo_dso_findsym(void *handle, const char *symbol);
+__dso_public void *sudo_dso_findsym_v1(void *handle, const char *symbol);
-__dso_public void *sudo_dso_load(const char *path, int mode);
+__dso_public void *sudo_dso_load_v1(const char *path, int mode);
-__dso_public void sudo_dso_preload_table(struct sudo_preload_table *table);
+__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 */

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)

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_fatal sudo_fatal_nodebug_v1
-# define sudo_fatalx sudo_fatalx_nodebug
+# define sudo_fatalx sudo_fatalx_nodebug_v1
-# define sudo_warn sudo_warn_nodebug
+# define sudo_warn sudo_warn_nodebug_v1
-# define sudo_warnx sudo_warnx_nodebug
+# define sudo_warnx sudo_warnx_nodebug_v1
-# define sudo_vfatal(fmt, ap) sudo_vfatal_nodebug((fmt), (ap))
+# define sudo_vfatal(fmt, ap) sudo_vfatal_nodebug_v1((fmt), (ap))
-# define sudo_vfatalx(fmt, ap) sudo_vfatalx_nodebug((fmt), (ap))
+# define sudo_vfatalx(fmt, ap) sudo_vfatalx_nodebug_v1((fmt), (ap))
-# define sudo_vwarn(fmt, ap) sudo_vwarn_nodebug((fmt), (ap))
+# define sudo_vwarn(fmt, ap) sudo_vwarn_nodebug_v1((fmt), (ap))
-# define sudo_vwarnx(fmt, ap) sudo_vwarnx_nodebug((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_deregister_v1(void (*func)(void));
-__dso_public int  sudo_fatal_callback_register(void (*func)(void));
+__dso_public int  sudo_fatal_callback_register_v1(void (*func)(void));
-__dso_public char *sudo_warn_gettext(const char *msgid) __format_arg(1);
+__dso_public char *sudo_warn_gettext_v1(const char *msgid) __format_arg(1);
-__dso_public char *sudo_warn_strerror(int errnum);
+__dso_public char *sudo_warn_strerror_v1(int errnum);
-__dso_public void sudo_fatal_nodebug(const char *, ...) __printf0like(1, 2) __attribute__((__noreturn__));
+__dso_public void sudo_fatal_nodebug_v1(const char *, ...) __printf0like(1, 2) __attribute__((__noreturn__));
-__dso_public void sudo_fatalx_nodebug(const char *, ...) __printflike(1, 2) __attribute__((__noreturn__));
+__dso_public void sudo_fatalx_nodebug_v1(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_vfatal_nodebug_v1(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_vfatalx_nodebug_v1(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_warn_nodebug_v1(const char *, ...) __printf0like(1, 2);
-__dso_public void sudo_warnx_nodebug(const char *, ...) __printflike(1, 2);
+__dso_public void sudo_warnx_nodebug_v1(const char *, ...) __printflike(1, 2);
-__dso_public void sudo_vwarn_nodebug(const char *, va_list ap) __printf0like(1, 0);
+__dso_public void sudo_vwarn_nodebug_v1(const char *, va_list ap) __printf0like(1, 0);
-__dso_public void sudo_vwarnx_nodebug(const char *, va_list ap) __printflike(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_ */

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_init_v1(struct sudo_lbuf *, int (*)(const char *), int, const char *, int);
-__dso_public void sudo_lbuf_destroy(struct sudo_lbuf *);
+__dso_public void sudo_lbuf_destroy_v1(struct sudo_lbuf *);
-__dso_public void sudo_lbuf_append(struct sudo_lbuf *, const char *, ...) __printflike(2, 3);
+__dso_public void sudo_lbuf_append_v1(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_append_quoted_v1(struct sudo_lbuf *, const char *, const char *, ...) __printflike(3, 4);
-__dso_public void sudo_lbuf_print(struct sudo_lbuf *);
+__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 */

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_prep_user_v1(char *user, const char *tty);
-__dso_public int aix_restoreauthdb(void);
+#define aix_prep_user(_a, _b) aix_prep_user_v1((_a), (_b))
-__dso_public int aix_setauthdb(char *user);
+__dso_public int aix_restoreauthdb_v1(void);
-
+#define aix_restoreauthdb() aix_restoreauthdb_v1()
-/* strtobool.c */
+__dso_public int aix_setauthdb_v1(char *user);
-__dso_public int sudo_strtobool(const char *str);
+#define aix_setauthdb(_a) aix_setauthdb_v1((_a))
-
-/* 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);
 
 /* 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_cbreak_v1(int fd);
-__dso_public bool sudo_term_copy(int, int);
+#define sudo_term_cbreak(_a) sudo_term_cbreak_v1((_a))
-__dso_public bool sudo_term_noecho(int);
+__dso_public bool sudo_term_copy_v1(int src, int dst);
-__dso_public bool sudo_term_raw(int, int);
+#define sudo_term_copy(_a, _b) sudo_term_copy_v1((_a), (_b))
-__dso_public bool sudo_term_restore(int, bool);
+__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 */

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;

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;
 

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)

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;
 

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;

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);

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;

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;

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;

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);
 }

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)

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)
 

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;

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;

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;

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);
 }

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)

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)
 

lib/util/util.exp

@@ -19,26 +19,26 @@ SHA512Pad
 SHA512Transform
 SHA512Update
 _sudo_printf
-aix_prep_user
+aix_prep_user_v1
-aix_restoreauthdb
+aix_restoreauthdb_v1
-aix_setauthdb
+aix_setauthdb_v1
 closefrom_fallback
 initprogname
 isblank
 sudo_asprintf
 sudo_clock_gettime
 sudo_closefrom
-sudo_conf_askpass_path
+sudo_conf_askpass_path_v1
-sudo_conf_debug_flags
+sudo_conf_debug_flags_v1
-sudo_conf_disable_coredump
+sudo_conf_disable_coredump_v1
-sudo_conf_group_source
+sudo_conf_group_source_v1
-sudo_conf_max_groups
+sudo_conf_max_groups_v1
-sudo_conf_noexec_path
+sudo_conf_noexec_path_v1
-sudo_conf_plugin_dir_path
+sudo_conf_plugin_dir_path_v1
-sudo_conf_plugins
+sudo_conf_plugins_v1
-sudo_conf_probe_interfaces
+sudo_conf_probe_interfaces_v1
-sudo_conf_read
+sudo_conf_read_v1
-sudo_conf_sesh_path
+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_findsym_v1
-sudo_dso_load
+sudo_dso_load_v1
-sudo_dso_preload_table
+sudo_dso_preload_table_v1
-sudo_dso_strerror
+sudo_dso_strerror_v1
-sudo_dso_unload
+sudo_dso_unload_v1
-sudo_easprintf
+sudo_easprintf_v1
-sudo_ecalloc
+sudo_ecalloc_v1
-sudo_emalloc
+sudo_emalloc_v1
-sudo_emallocarray
+sudo_emallocarray_v1
-sudo_erealloc
+sudo_erealloc_v1
-sudo_ereallocarray
+sudo_ereallocarray_v1
-sudo_erecalloc
+sudo_erecalloc_v1
-sudo_estrdup
+sudo_estrdup_v1
-sudo_estrndup
+sudo_estrndup_v1
-sudo_ev_add
+sudo_ev_add_v1
-sudo_ev_alloc
+sudo_ev_alloc_v1
-sudo_ev_base_alloc
+sudo_ev_base_alloc_v1
-sudo_ev_base_free
+sudo_ev_base_free_v1
-sudo_ev_del
+sudo_ev_del_v1
-sudo_ev_free
+sudo_ev_free_v1
-sudo_ev_get_timeleft
+sudo_ev_get_timeleft_v1
-sudo_ev_got_break
+sudo_ev_got_break_v1
-sudo_ev_got_exit
+sudo_ev_got_exit_v1
-sudo_ev_loop
+sudo_ev_loop_v1
-sudo_ev_loopbreak
+sudo_ev_loopbreak_v1
-sudo_ev_loopcontinue
+sudo_ev_loopcontinue_v1
-sudo_ev_loopexit
+sudo_ev_loopexit_v1
-sudo_evasprintf
+sudo_evasprintf_v1
-sudo_fatal_callback_deregister
+sudo_fatal_callback_deregister_v1
-sudo_fatal_callback_register
+sudo_fatal_callback_register_v1
-sudo_fatal_nodebug
+sudo_fatal_nodebug_v1
-sudo_fatalx_nodebug
+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_v1
-sudo_lbuf_append_quoted
+sudo_lbuf_append_v1
-sudo_lbuf_destroy
+sudo_lbuf_destroy_v1
-sudo_lbuf_init
+sudo_lbuf_init_v1
-sudo_lbuf_print
+sudo_lbuf_print_v1
-sudo_lock_file
+sudo_lock_file_v1
 sudo_memrchr
 sudo_memset_s
 sudo_mkdtemp
 sudo_mkstemps
-sudo_new_key_val
+sudo_new_key_val_v1
-sudo_parse_gids
+sudo_parse_gids_v1
-sudo_parseln
+sudo_parseln_v1
 sudo_printf
 sudo_pw_dup
-sudo_secure_dir
+sudo_secure_dir_v1
-sudo_secure_file
+sudo_secure_file_v1
-sudo_setgroups
+sudo_setgroups_v1
 sudo_sig2str
 sudo_snprintf
 sudo_strlcat
 sudo_strlcpy
 sudo_strsignal
-sudo_strtobool
+sudo_strtobool_v1
-sudo_strtoid
+sudo_strtoid_v1
-sudo_strtomode
+sudo_strtomode_v1
 sudo_strtonum
-sudo_term_cbreak
+sudo_term_cbreak_v1
-sudo_term_copy
+sudo_term_copy_v1
-sudo_term_erase
+sudo_term_erase_v1
-sudo_term_kill
+sudo_term_kill_v1
-sudo_term_noecho
+sudo_term_noecho_v1
-sudo_term_raw
+sudo_term_raw_v1
-sudo_term_restore
+sudo_term_restore_v1
 sudo_utimes
 sudo_vasprintf
-sudo_vfatal_nodebug
+sudo_vfatal_nodebug_v1
-sudo_vfatalx_nodebug
+sudo_vfatalx_nodebug_v1
 sudo_vsnprintf
-sudo_vwarn_nodebug
+sudo_vwarn_nodebug_v1
-sudo_vwarnx_nodebug
+sudo_vwarnx_nodebug_v1
-sudo_warn_gettext
+sudo_warn_gettext_v1
-sudo_warn_nodebug
+sudo_warn_nodebug_v1
-sudo_warn_strerror
+sudo_warn_strerror_v1
-sudo_warnx_nodebug
+sudo_warnx_nodebug_v1

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;

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);
 }