#include <stdarg.h>
-#undef efree
-#define efree(x) free((void *)(x))
+#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);
len = sudo_easprintf(&info, "NAME=%s%cLOGIN=%s%cLOGNAME=%s%cTTY=%s%c",
user, '\0', user, '\0', user, '\0', tty ? tty : "", '\0');
(void)usrinfo(SETUINFO, info, len);
- efree(info);
+ sudo_efree(info);
#ifdef HAVE_SETAUTHDB
/* set administrative domain */
TAILQ_INIT(&base->events);
TAILQ_INIT(&base->timeouts);
if (sudo_ev_base_alloc_impl(base) != 0) {
- efree(base);
+ sudo_efree(base);
base = NULL;
}
sudo_ev_del(base, ev);
}
sudo_ev_base_free_impl(base);
- efree(base);
+ sudo_efree(base);
debug_return;
}
sudo_ev_base_free_impl(struct sudo_event_base *base)
{
debug_decl(sudo_ev_base_free_impl, SUDO_DEBUG_EVENT)
- efree(base->pfds);
+ sudo_efree(base->pfds);
debug_return;
}
sudo_ev_base_free_impl(struct sudo_event_base *base)
{
debug_decl(sudo_ev_base_free_impl, SUDO_DEBUG_EVENT)
- efree(base->readfds_in);
- efree(base->writefds_in);
- efree(base->readfds_out);
- efree(base->writefds_out);
+ sudo_efree(base->readfds_in);
+ sudo_efree(base->writefds_in);
+ sudo_efree(base->readfds_out);
+ sudo_efree(base->writefds_out);
debug_return;
}
sudo_printf(SUDO_CONV_ERROR_MSG,
_("%s: %s\n"), getprogname(), str ? str : "(null)");
}
- efree(str);
+ sudo_efree(str);
}
/*
{
debug_decl(sudo_lbuf_destroy, SUDO_DEBUG_UTIL)
- efree(lbuf->buf);
+ sudo_efree(lbuf->buf);
lbuf->buf = NULL;
debug_return;
debug_file = sudo_estrndup(entry, filelen);
debug_flags = sudo_estrdup(debug_flags);
sudo_debug_init(debug_file, debug_flags);
- efree(debug_file);
+ sudo_efree(debug_file);
sudo_conf_data.debug_flags = debug_flags;
}
/* Restore locale if needed. */
if (prev_locale[0] != 'C' || prev_locale[1] != '\0')
setlocale(LC_ALL, prev_locale);
- efree(prev_locale);
+ sudo_efree(prev_locale);
}
void *next;
debug_decl(alias_free, SUDO_DEBUG_ALIAS)
- efree(a->name);
+ sudo_efree(a->name);
TAILQ_FOREACH_SAFE(m, &a->members, entries, next) {
if (m->type == COMMAND) {
c = (struct sudo_command *) m->name;
- efree(c->cmnd);
- efree(c->args);
+ sudo_efree(c->cmnd);
+ sudo_efree(c->args);
}
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
- efree(a);
+ sudo_efree(a);
debug_return;
}
SUDO_CONV_PROMPT_ECHO_OFF);
if (pass == NULL)
break;
- efree(message);
+ sudo_efree(message);
message = NULL;
result = authenticate(pw->pw_name, pass, &reenter, &message);
memset_s(pass, SUDO_CONV_REPL_MAX, 0, strlen(pass));
}
rval = pass ? AUTH_FAILURE : AUTH_INTR;
}
- efree(message);
+ sudo_efree(message);
debug_return_int(rval);
}
done:
if (sudo_krb5_instance != NULL)
- efree(pname);
+ sudo_efree(pname);
debug_return_int(error ? AUTH_FAILURE : AUTH_SUCCESS);
}
status = PAM_SYSTEM_ERR;
*user_envp = env_get();
env_init(NULL);
- efree(pam_envp);
+ sudo_efree(pam_envp);
/* XXX - we leak any duplicates that were in pam_envp */
}
}
if (pw_epasswd != NULL) {
memset_s(pw_epasswd, SUDO_CONV_REPL_MAX, 0, strlen(pw_epasswd));
- efree(pw_epasswd);
+ sudo_efree(pw_epasswd);
}
debug_return_int(AUTH_SUCCESS);
}
if (pw_epasswd != NULL) {
memset_s(pw_epasswd, SUDO_CONV_REPL_MAX, 0, strlen(pw_epasswd));
- efree(pw_epasswd);
+ sudo_efree(pw_epasswd);
}
debug_return_int(AUTH_SUCCESS);
}
debug_decl(sudo_sia_cleanup, SUDO_DEBUG_AUTH)
(void) sia_ses_release(&siah);
- efree(sudo_argv);
+ sudo_efree(sudo_argv);
debug_return_int(AUTH_SUCCESS);
}
rval = verify_user(auth_pw, prompt, validated);
if (rval == true && lectured)
set_lectured();
- efree(prompt);
+ sudo_efree(prompt);
}
/* Only update timestamp if user was validated. */
if (rval == true && ISSET(validated, VALIDATE_OK) &&
for (def = sudo_defs_table; def->name; def++) {
switch (def->type & T_MASK) {
case T_STR:
- efree(def->sd_un.str);
+ sudo_efree(def->sd_un.str);
def->sd_un.str = NULL;
break;
case T_LIST:
{
debug_decl(store_str, SUDO_DEBUG_DEFAULTS)
- efree(def->sd_un.str);
+ sudo_efree(def->sd_un.str);
if (op == false)
def->sd_un.str = NULL;
else
if (op == freeall) {
while ((cur = SLIST_FIRST(&def->sd_un.list)) != NULL) {
SLIST_REMOVE_HEAD(&def->sd_un.list, entries);
- efree(cur->value);
- efree(cur);
+ sudo_efree(cur->value);
+ sudo_efree(cur);
}
debug_return;
}
SLIST_REMOVE_HEAD(&def->sd_un.list, entries);
else
SLIST_REMOVE_AFTER(prev, entries);
- efree(cur->value);
- efree(cur);
+ sudo_efree(cur->value);
+ sudo_efree(cur);
break;
}
prev = cur;
/* Free the old envp we allocated, if any. */
if (env.old_envp != NULL)
- efree((void *)env.old_envp);
+ sudo_efree((void *)env.old_envp);
}
debug_return;
rval = sudo_putenv(estring, dupcheck, overwrite);
}
if (rval == -1)
- efree(estring);
+ sudo_efree(estring);
debug_return_int(rval);
}
if (user_args) {
sudo_easprintf(&cp, "SUDO_COMMAND=%s %s", user_cmnd, user_args);
if (sudo_putenv(cp, true, true) == -1) {
- efree(cp);
+ sudo_efree(cp);
goto bad;
}
} else {
goto bad;
/* Free old environment. */
- efree(old_envp);
+ sudo_efree(old_envp);
debug_return_bool(true);
/* XXX - audit? */
log_warningx(0,
N_("sorry, you are not allowed to set the following environment variables: %s"), bad);
- efree(bad);
+ sudo_efree(bad);
rval = false;
}
debug_return_bool(rval);
*/
len = snprintf(command, sizeof(command), "%s/%s", path, infile);
if (len <= 0 || (size_t)len >= sizeof(command)) {
- efree(origpath);
+ sudo_efree(origpath);
errno = ENAMETOOLONG;
debug_return_int(NOT_FOUND_ERROR);
}
path = n + 1;
} while (n);
- efree(origpath);
+ sudo_efree(origpath);
/*
* Check current dir if dot was in the PATH
struct privilege *priv, *priv_next;
TAILQ_FOREACH_SAFE(m, &us->users, entries, m_next) {
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
TAILQ_FOREACH_SAFE(priv, &us->privileges, entries, priv_next) {
struct member_list *runasuserlist = NULL, *runasgrouplist = NULL;
#endif /* HAVE_PRIV_SET */
TAILQ_FOREACH_SAFE(m, &priv->hostlist, entries, m_next) {
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
TAILQ_FOREACH_SAFE(cs, &priv->cmndlist, entries, cs_next) {
#ifdef HAVE_SELINUX
/* Only free the first instance of a role/type. */
if (cs->role != role) {
role = cs->role;
- efree(cs->role);
+ sudo_efree(cs->role);
}
if (cs->type != type) {
type = cs->type;
- efree(cs->type);
+ sudo_efree(cs->type);
}
#endif /* HAVE_SELINUX */
#ifdef HAVE_PRIV_SET
/* Only free the first instance of privs/limitprivs. */
if (cs->privs != privs) {
privs = cs->privs;
- efree(cs->privs);
+ sudo_efree(cs->privs);
}
if (cs->limitprivs != limitprivs) {
limitprivs = cs->limitprivs;
- efree(cs->limitprivs);
+ sudo_efree(cs->limitprivs);
}
#endif /* HAVE_PRIV_SET */
/* Only free the first instance of runas user/group lists. */
if (cs->runasuserlist && cs->runasuserlist != runasuserlist) {
runasuserlist = cs->runasuserlist;
TAILQ_FOREACH_SAFE(m, runasuserlist, entries, m_next) {
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
- efree(runasuserlist);
+ sudo_efree(runasuserlist);
}
if (cs->runasgrouplist && cs->runasgrouplist != runasgrouplist) {
runasgrouplist = cs->runasgrouplist;
TAILQ_FOREACH_SAFE(m, runasgrouplist, entries, m_next) {
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
- efree(runasgrouplist);
+ sudo_efree(runasgrouplist);
}
if (cs->cmnd->type == COMMAND) {
struct sudo_command *c =
(struct sudo_command *) cs->cmnd->name;
- efree(c->cmnd);
- efree(c->args);
+ sudo_efree(c->cmnd);
+ sudo_efree(c->args);
}
- efree(cs->cmnd->name);
- efree(cs->cmnd);
- efree(cs);
+ sudo_efree(cs->cmnd->name);
+ sudo_efree(cs->cmnd);
+ sudo_efree(cs);
}
- efree(priv);
+ sudo_efree(priv);
}
- efree(us);
+ sudo_efree(us);
}
TAILQ_INIT(&userspecs);
if (m->type == COMMAND) {
struct sudo_command *c =
(struct sudo_command *) m->name;
- efree(c->cmnd);
- efree(c->args);
+ sudo_efree(c->cmnd);
+ sudo_efree(c->args);
}
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
- efree(d->binding);
+ sudo_efree(d->binding);
}
- efree(d->var);
- efree(d->val);
- efree(d);
+ sudo_efree(d->var);
+ sudo_efree(d->val);
+ sudo_efree(d);
}
TAILQ_INIT(&defaults);
init_lexer();
- efree(sudoers);
+ sudo_efree(sudoers);
sudoers = path ? sudo_estrdup(path) : NULL;
parse_error = false;
HLTQ_TO_TAILQ(cs->runasgrouplist,
yyvsp[-4].runas->runasgroups, entries);
}
- efree(yyvsp[-4].runas);
+ sudo_efree(yyvsp[-4].runas);
}
#ifdef HAVE_SELINUX
cs->role = yyvsp[-3].seinfo.role;
HLTQ_TO_TAILQ(cs->runasgrouplist,
$1->runasgroups, entries);
}
- efree($1);
+ sudo_efree($1);
}
#ifdef HAVE_SELINUX
cs->role = $2.role;
struct privilege *priv, *priv_next;
TAILQ_FOREACH_SAFE(m, &us->users, entries, m_next) {
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
TAILQ_FOREACH_SAFE(priv, &us->privileges, entries, priv_next) {
struct member_list *runasuserlist = NULL, *runasgrouplist = NULL;
#endif /* HAVE_PRIV_SET */
TAILQ_FOREACH_SAFE(m, &priv->hostlist, entries, m_next) {
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
TAILQ_FOREACH_SAFE(cs, &priv->cmndlist, entries, cs_next) {
#ifdef HAVE_SELINUX
/* Only free the first instance of a role/type. */
if (cs->role != role) {
role = cs->role;
- efree(cs->role);
+ sudo_efree(cs->role);
}
if (cs->type != type) {
type = cs->type;
- efree(cs->type);
+ sudo_efree(cs->type);
}
#endif /* HAVE_SELINUX */
#ifdef HAVE_PRIV_SET
/* Only free the first instance of privs/limitprivs. */
if (cs->privs != privs) {
privs = cs->privs;
- efree(cs->privs);
+ sudo_efree(cs->privs);
}
if (cs->limitprivs != limitprivs) {
limitprivs = cs->limitprivs;
- efree(cs->limitprivs);
+ sudo_efree(cs->limitprivs);
}
#endif /* HAVE_PRIV_SET */
/* Only free the first instance of runas user/group lists. */
if (cs->runasuserlist && cs->runasuserlist != runasuserlist) {
runasuserlist = cs->runasuserlist;
TAILQ_FOREACH_SAFE(m, runasuserlist, entries, m_next) {
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
- efree(runasuserlist);
+ sudo_efree(runasuserlist);
}
if (cs->runasgrouplist && cs->runasgrouplist != runasgrouplist) {
runasgrouplist = cs->runasgrouplist;
TAILQ_FOREACH_SAFE(m, runasgrouplist, entries, m_next) {
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
- efree(runasgrouplist);
+ sudo_efree(runasgrouplist);
}
if (cs->cmnd->type == COMMAND) {
struct sudo_command *c =
(struct sudo_command *) cs->cmnd->name;
- efree(c->cmnd);
- efree(c->args);
+ sudo_efree(c->cmnd);
+ sudo_efree(c->args);
}
- efree(cs->cmnd->name);
- efree(cs->cmnd);
- efree(cs);
+ sudo_efree(cs->cmnd->name);
+ sudo_efree(cs->cmnd);
+ sudo_efree(cs);
}
- efree(priv);
+ sudo_efree(priv);
}
- efree(us);
+ sudo_efree(us);
}
TAILQ_INIT(&userspecs);
if (m->type == COMMAND) {
struct sudo_command *c =
(struct sudo_command *) m->name;
- efree(c->cmnd);
- efree(c->args);
+ sudo_efree(c->cmnd);
+ sudo_efree(c->args);
}
- efree(m->name);
- efree(m);
+ sudo_efree(m->name);
+ sudo_efree(m);
}
- efree(d->binding);
+ sudo_efree(d->binding);
}
- efree(d->var);
- efree(d->val);
- efree(d);
+ sudo_efree(d->var);
+ sudo_efree(d->val);
+ sudo_efree(d);
}
TAILQ_INIT(&defaults);
init_lexer();
- efree(sudoers);
+ sudo_efree(sudoers);
sudoers = path ? sudo_estrdup(path) : NULL;
parse_error = false;
rc = (group_plugin->init)(GROUP_API_VERSION, sudo_printf, argv);
done:
- efree(argv);
+ sudo_efree(argv);
if (rc != true) {
if (group_handle != NULL) {
inet_pton(AF_INET6, mask, &ifp->netmask.ip6) != 1)
#endif
{
- efree(ifp);
+ sudo_efree(ifp);
continue;
}
} else {
ifp->family = AF_INET;
if (inet_pton(AF_INET, addr, &ifp->addr.ip4) != 1 ||
inet_pton(AF_INET, mask, &ifp->netmask.ip4) != 1) {
- efree(ifp);
+ sudo_efree(ifp);
continue;
}
}
SLIST_INSERT_HEAD(&interfaces, ifp, entries);
}
- efree(addrinfo);
+ sudo_efree(addrinfo);
debug_return;
}
for (cp = strtok(addrinfo, " \t"); cp != NULL; cp = strtok(NULL, " \t"))
sudo_printf(SUDO_CONV_INFO_MSG, "\t%s\n", cp);
- efree(addrinfo);
+ sudo_efree(addrinfo);
debug_return;
}
rval = true;
done:
- efree(tofree);
+ sudo_efree(tofree);
if (details.runas_pw)
sudo_pw_delref(details.runas_pw);
sudo_endpwent();
debug_return_str(path);
bad:
- efree(path);
+ sudo_efree(path);
debug_return_str(NULL);
}
}
}
- efree(ldap_conf.host);
+ sudo_efree(ldap_conf.host);
ldap_conf.host = sudo_estrdup(hostbuf);
debug_return_bool(true);
sudo_warnx(U_("starttls not supported when using ldaps"));
ldap_conf.ssl_mode = SUDO_LDAP_SSL;
}
- efree(buf);
+ sudo_efree(buf);
}
buf = NULL;
/* Store parsed URI(s) in host for ldap_create() or ldap_init(). */
- efree(ldap_conf.host);
+ sudo_efree(ldap_conf.host);
ldap_conf.host = sudo_estrdup(hostbuf);
rc = LDAP_SUCCESS;
done:
- efree(buf);
+ sudo_efree(buf);
debug_return_int(rc);
toobig:
DPRINTF2("ldap sudoCommand '%s' ... %s",
val, ret == true ? "MATCH!" : "not");
- efree(allowed_cmnd); /* cleanup */
+ sudo_efree(allowed_cmnd); /* cleanup */
if (allowed_digest != NULL)
- efree(allowed_digest->digest_str);
+ sudo_efree(allowed_digest->digest_str);
}
ldap_value_free_len(bv); /* more cleanup */
/* case var Boolean True */
set_default(var, NULL, true);
}
- efree(var);
+ sudo_efree(var);
}
ldap_value_free_len(bv);
if (fgets(buf, sizeof(buf), fp) != NULL) {
buf[strcspn(buf, "\n")] = '\0';
/* copy to bindpw and binddn */
- efree(ldap_conf.bindpw);
+ sudo_efree(ldap_conf.bindpw);
ldap_conf.bindpw = sudo_ldap_decode_secret(buf);
if (ldap_conf.bindpw == NULL)
ldap_conf.bindpw = sudo_estrdup(buf);
- efree(ldap_conf.binddn);
+ sudo_efree(ldap_conf.binddn);
ldap_conf.binddn = ldap_conf.rootbinddn;
ldap_conf.rootbinddn = NULL;
}
}
break;
case CONF_STR:
- efree(*(char **)(cur->valp));
+ sudo_efree(*(char **)(cur->valp));
*(char **)(cur->valp) = *value ? sudo_estrdup(value) : NULL;
break;
case CONF_LIST_STR:
debug_return_bool(false);
while ((uri = STAILQ_FIRST(&ldap_conf.uri)) != NULL) {
STAILQ_REMOVE_HEAD(&ldap_conf.uri, entries);
- efree(uri);
+ sudo_efree(uri);
}
ldap_conf.port = LDAP_PORT;
}
memcpy(ldap_conf.search_filter + 1, cp, len);
ldap_conf.search_filter[len + 1] = ')';
ldap_conf.search_filter[len + 2] = '\0';
- efree(cp);
+ sudo_efree(cp);
}
} else if (ldap_conf.bindpw) {
cp = sudo_ldap_decode_secret(ldap_conf.bindpw);
if (cp != NULL) {
- efree(ldap_conf.bindpw);
+ sudo_efree(ldap_conf.bindpw);
ldap_conf.bindpw = cp;
}
}
if (ldap_conf.tls_keypw) {
cp = sudo_ldap_decode_secret(ldap_conf.tls_keypw);
if (cp != NULL) {
- efree(ldap_conf.tls_keypw);
+ sudo_efree(ldap_conf.tls_keypw);
ldap_conf.tls_keypw = cp;
}
}
if (result)
ldap_msgfree(result);
}
- efree(filt);
+ sudo_efree(filt);
done:
debug_return_int(count);
}
if (lres != NULL) {
if (lres->nentries) {
- efree(lres->entries);
+ sudo_efree(lres->entries);
lres->entries = NULL;
}
while ((s = STAILQ_FIRST(&lres->searches)) != NULL) {
STAILQ_REMOVE_HEAD(&lres->searches, entries);
ldap_msgfree(s->searchresult);
- efree(s);
+ sudo_efree(s);
}
- efree(lres);
+ sudo_efree(lres);
}
debug_return;
}
if (buf != NULL) {
DPRINTF2("ldap_initialize(ld, %s)", buf);
rc = ldap_initialize(&ld, buf);
- efree(buf);
+ sudo_efree(buf);
if (rc != LDAP_SUCCESS) {
sudo_warnx(U_("unable to initialize LDAP: %s"),
ldap_err2string(rc));
if (result)
ldap_msgfree(result);
}
- efree(filt);
+ sudo_efree(filt);
debug_return_int(0);
}
DPRINTF1("removing reusable search result");
sudo_ldap_result_free(handle->result);
if (handle->username) {
- efree(handle->username);
+ sudo_efree(handle->username);
handle->username = NULL;
}
handle->grlist = NULL;
}
DPRINTF1("result now has %d entries", lres->nentries);
}
- efree(filt);
+ sudo_efree(filt);
}
}
}
/* Free the handle container. */
- efree(nss->handle);
+ sudo_efree(nss->handle);
nss->handle = NULL;
}
debug_return_int(0);
rc = 0;
done:
- efree(command);
+ sudo_efree(command);
debug_return_int(rc);
}
sudoers_initlocale(const char *ulocale, const char *slocale)
{
if (ulocale != NULL) {
- efree(user_locale);
+ sudo_efree(user_locale);
user_locale = sudo_estrdup(ulocale);
}
if (slocale != NULL) {
- efree(sudoers_locale);
+ sudo_efree(sudoers_locale);
sudoers_locale = sudo_estrdup(slocale);
}
}
res = setlocale(LC_ALL, sudoers_locale ? sudoers_locale : "C");
if (res == NULL && sudoers_locale != NULL) {
if (strcmp(sudoers_locale, "C") != 0) {
- efree(sudoers_locale);
+ sudo_efree(sudoers_locale);
sudoers_locale = sudo_estrdup("C");
res = setlocale(LC_ALL, "C");
}
* Print out full_line with word wrap around def_loglinelen chars.
*/
writeln_wrap(fp, full_line, len, def_loglinelen);
- efree(full_line);
+ sudo_efree(full_line);
}
(void) fflush(fp);
(void) sudo_lock_file(fileno(fp), SUDO_UNLOCK);
if (uid_changed)
restore_perms();
- efree(logline);
+ sudo_efree(logline);
/* Restore locale. */
sudoers_setlocale(oldlocale, NULL);
if (uid_changed)
restore_perms();
- efree(logline);
+ sudo_efree(logline);
sudoers_setlocale(oldlocale, NULL);
logline = message;
} else {
logline = new_logline(message, ISSET(flags, SLOG_USE_ERRNO) ? serrno : 0);
- efree(message);
+ sudo_efree(message);
}
/* Become root if we are not already. */
if (uid_changed)
restore_perms();
- efree(logline);
+ sudo_efree(logline);
sudoers_setlocale(oldlocale, NULL);
strlcat(line, evstr, len) >= len ||
strlcat(line, " ; ", len) >= len)
goto toobig;
- efree(evstr);
+ sudo_efree(evstr);
}
if (user_cmnd != NULL) {
if (strlcat(line, LL_CMND_STR, len) >= len)
if (strcmp(sudoers_cmnd, "sudoedit") == 0 &&
strcmp(user_cmnd, "sudoedit") == 0 &&
command_args_match(sudoers_cmnd, sudoers_args)) {
- efree(safe_cmnd);
+ sudo_efree(safe_cmnd);
safe_cmnd = sudo_estrdup(sudoers_cmnd);
rc = true;
}
if (user_stat == NULL ||
(user_stat->st_dev == sudoers_stat.st_dev &&
user_stat->st_ino == sudoers_stat.st_ino)) {
- efree(safe_cmnd);
+ sudo_efree(safe_cmnd);
safe_cmnd = sudo_estrdup(cp);
break;
}
debug_return_bool(false);
if (command_args_match(sudoers_cmnd, sudoers_args)) {
- efree(safe_cmnd);
+ sudo_efree(safe_cmnd);
safe_cmnd = sudo_estrdup(user_cmnd);
debug_return_bool(true);
}
if (strcmp(user_cmnd, sudoers_cmnd) == 0) {
if (command_args_match(sudoers_cmnd, sudoers_args)) {
- efree(safe_cmnd);
+ sudo_efree(safe_cmnd);
safe_cmnd = sudo_estrdup(sudoers_cmnd);
debug_return_bool(true);
}
/* XXX - log functions not available but we should log very loudly */
debug_return_bool(false);
}
- efree(safe_cmnd);
+ sudo_efree(safe_cmnd);
safe_cmnd = sudo_estrdup(sudoers_cmnd);
debug_return_bool(true);
}
if (user_stat == NULL ||
(user_stat->st_dev == sudoers_stat.st_dev &&
user_stat->st_ino == sudoers_stat.st_ino)) {
- efree(safe_cmnd);
+ sudo_efree(safe_cmnd);
safe_cmnd = sudo_estrdup(buf);
break;
}
}
}
if (domain == NULL)
- efree(buf);
+ sudo_efree(buf);
#endif /* HAVE_GETDOMAINNAME */
return domain;
}
sudo_grlist_delref(user_group_list);
user_group_list = NULL;
}
- efree(user_gids);
+ sudo_efree(user_gids);
user_gids = NULL;
debug_return;
debug_decl(sudo_pw_delref_item, SUDO_DEBUG_NSS)
if (--item->refcnt == 0)
- efree(item);
+ sudo_efree(item);
debug_return;
}
pwitem->cache.k.uid = pw->pw_uid;
if ((node = rbinsert(pwcache_byuid, &pwitem->cache)) != NULL) {
/* Already exists, free the item we created. */
- efree(pwitem);
+ sudo_efree(pwitem);
pwitem = (struct cache_item_pw *) node->data;
}
} else {
pwitem->cache.k.name = pw->pw_name;
if ((node = rbinsert(pwcache_byname, &pwitem->cache)) != NULL) {
/* Already exists, free the item we created. */
- efree(pwitem);
+ sudo_efree(pwitem);
pwitem = (struct cache_item_pw *) node->data;
}
}
debug_decl(sudo_gr_delref_item, SUDO_DEBUG_NSS)
if (--item->refcnt == 0)
- efree(item);
+ sudo_efree(item);
debug_return;
}
if (errstr != NULL) {
sudo_debug_printf(SUDO_DEBUG_DEBUG|SUDO_DEBUG_DIAG,
"gid %s %s", group, errstr);
- efree(gritem);
+ sudo_efree(gritem);
debug_return_ptr(NULL);
}
gritem->cache.k.gid = gr->gr_gid;
if ((node = rbinsert(grcache_bygid, &gritem->cache)) != NULL) {
/* Already exists, free the item we created. */
- efree(gritem);
+ sudo_efree(gritem);
gritem = (struct cache_item_gr *) node->data;
}
} else {
gritem->cache.k.name = gr->gr_name;
if ((node = rbinsert(grcache_byname, &gritem->cache)) != NULL) {
/* Already exists, free the item we created. */
- efree(gritem);
+ sudo_efree(gritem);
gritem = (struct cache_item_gr *) node->data;
}
}
debug_decl(sudo_gr_delref_item, SUDO_DEBUG_NSS)
if (--item->refcnt == 0)
- efree(item);
+ sudo_efree(item);
debug_return;
}
ngids = NGROUPS_MAX * 2;
gids = sudo_emallocarray(ngids, sizeof(GETGROUPS_T));
if (getgrouplist(pw->pw_name, pw->pw_gid, gids, &ngids) == -1) {
- efree(gids);
+ sudo_efree(gids);
gids = sudo_emallocarray(ngids, sizeof(GETGROUPS_T));
if (getgrouplist(pw->pw_name, pw->pw_gid, gids, &ngids) == -1)
ngids = -1;
}
}
if (ngids <= 0) {
- efree(gids);
+ sudo_efree(gids);
debug_return_ptr(NULL);
}
len = strlen(grp->gr_name) + 1;
if (cp - (char *)grlitem + len > total) {
total += len + groupname_len;
- efree(grlitem);
+ sudo_efree(grlitem);
sudo_gr_delref(grp);
goto again;
}
}
}
grlist->ngroups = ngroups;
- efree(gids);
+ sudo_efree(gids);
#ifdef HAVE_SETAUTHDB
aix_restoreauthdb();
_rbdestroy(tree, node->right, destroy);
if (destroy != NULL)
destroy(node->data);
- efree(node);
+ sudo_efree(node);
}
debug_return;
}
{
debug_decl(rbdestroy, SUDO_DEBUG_RBTREE)
_rbdestroy(tree, rbfirst(tree), destroy);
- efree(tree);
+ sudo_efree(tree);
debug_return;
}
out_res->rules =
sudo_ereallocarray(out_res->rules, l, sizeof(struct sss_sudo_rule));
} else {
- efree(out_res->rules);
+ sudo_efree(out_res->rules);
out_res->rules = NULL;
}
}
if (nss && nss->handle) {
handle = nss->handle;
sudo_dso_unload(handle->ssslib);
- efree(nss->handle);
+ sudo_efree(nss->handle);
}
debug_return_int(0);
}
sudo_debug_printf(SUDO_DEBUG_INFO, "sssd/ldap sudoCommand '%s' ... %s",
val, ret == true ? "MATCH!" : "not");
- efree(allowed_cmnd); /* cleanup */
+ sudo_efree(allowed_cmnd); /* cleanup */
if (allowed_digest != NULL)
- efree(allowed_digest->digest_str);
+ sudo_efree(allowed_digest->digest_str);
}
handle->fn_free_values(val_array); /* more cleanup */
/* case var Boolean True */
set_default(v, NULL, true);
}
- efree(v);
+ sudo_efree(v);
}
handle->fn_free_values(val_array);
goto bad;
if (ISSET(sudo_mode, MODE_EDIT)) {
- efree(safe_cmnd);
+ sudo_efree(safe_cmnd);
safe_cmnd = find_editor(NewArgc - 1, NewArgv + 1, &edit_argv);
if (safe_cmnd == NULL)
goto bad;
N_("unable to resolve host %s"), user_host);
} else {
if (user_shost != user_host)
- efree(user_shost);
- efree(user_host);
+ sudo_efree(user_shost);
+ sudo_efree(user_host);
user_host = sudo_estrdup(res0->ai_canonname);
freeaddrinfo(res0);
if ((p = strchr(user_host, '.')) != NULL)
cp = strtok(editor, " \t");
if (cp == NULL ||
find_path(cp, &editor_path, NULL, getenv("PATH"), 0) != FOUND) {
- efree(editor);
+ sudo_efree(editor);
debug_return_str(NULL);
}
nargv = (char **) sudo_emallocarray(nargc + 1 + nfiles + 1, sizeof(char *));
}
}
fclose(fp);
- efree(buf);
+ sudo_efree(buf);
debug_return_ptr(li);
bad:
if (fp != NULL)
fclose(fp);
- efree(buf);
+ sudo_efree(buf);
free_log_info(li);
debug_return_ptr(NULL);
}
free_log_info(struct log_info *li)
{
if (li != NULL) {
- efree(li->cwd);
- efree(li->user);
- efree(li->runas_user);
- efree(li->runas_group);
- efree(li->tty);
- efree(li->cmd);
- efree(li);
+ sudo_efree(li->cwd);
+ sudo_efree(li->user);
+ sudo_efree(li->runas_user);
+ sudo_efree(li->runas_group);
+ sudo_efree(li->tty);
+ sudo_efree(li->cmd);
+ sudo_efree(li);
}
}
errno = ENAMETOOLONG;
sudo_fatal("%s/%s/log", dir, sessions[i]);
}
- efree(sessions[i]);
+ sudo_efree(sessions[i]);
/* Check for dir with a log file. */
if (lstat(pathbuf, &sb) == 0 && S_ISREG(sb.st_mode)) {
find_sessions(pathbuf, re, user, tty);
}
}
- efree(sessions);
+ sudo_efree(sessions);
debug_return_int(0);
}
if (asprintf(&path, "%s/%s", dirpath, dent->d_name) == -1)
goto bad;
if (stat(path, &sb) != 0 || !S_ISREG(sb.st_mode)) {
- efree(path);
+ sudo_efree(path);
continue;
}
pl = malloc(sizeof(*pl));
if (pl == NULL) {
- efree(path);
+ sudo_efree(path);
goto bad;
}
pl->path = path;
max_paths <<= 1;
tmp = realloc(paths, sizeof(*paths) * max_paths);
if (tmp == NULL) {
- efree(path);
- efree(pl);
+ sudo_efree(path);
+ sudo_efree(pl);
goto bad;
}
paths = tmp;
}
closedir(dir);
if (count == 0) {
- efree(paths);
+ sudo_efree(paths);
paths = NULL;
}
*pathsp = paths;
if (dir != NULL)
closedir(dir);
for (i = 0; i < count; i++) {
- efree(paths[i]->path);
- efree(paths[i]);
+ sudo_efree(paths[i]->path);
+ sudo_efree(paths[i]);
}
- efree(paths);
+ sudo_efree(paths);
debug_return_int(-1);
}
for (i = 0; i < count; i++) {
SLIST_INSERT_HEAD(&stack->more, paths[i], entries);
}
- efree(paths);
+ sudo_efree(paths);
}
debug_return_int(count);
idepth--;
while ((pl = SLIST_FIRST(&istack[idepth].more)) != NULL) {
SLIST_REMOVE_HEAD(&istack[idepth].more, entries);
- efree(pl->path);
- efree(pl);
+ sudo_efree(pl->path);
+ sudo_efree(pl);
}
- efree(istack[idepth].path);
+ sudo_efree(istack[idepth].path);
if (idepth && !istack[idepth].keepopen)
fclose(istack[idepth].bs->yy_input_file);
sudoers_delete_buffer(istack[idepth].bs);
}
- efree(istack);
+ sudo_efree(istack);
istack = NULL;
istacksize = idepth = 0;
sudolineno = 1;
count = switch_dir(&istack[idepth], path);
if (count <= 0) {
/* switch_dir() called sudoerserror() for us */
- efree(path);
+ sudo_efree(path);
debug_return_bool(count ? false : true);
}
/* Parse the first dir entry we can open, leave the rest for later. */
do {
- efree(path);
+ sudo_efree(path);
if ((pl = SLIST_FIRST(&istack[idepth].more)) == NULL) {
/* Unable to open any files in include dir, not an error. */
debug_return_bool(true);
}
SLIST_REMOVE_HEAD(&istack[idepth].more, entries);
path = pl->path;
- efree(pl);
+ sudo_efree(pl);
} while ((fp = open_sudoers(path, false, &keepopen)) == NULL);
} else {
if ((fp = open_sudoers(path, true, &keepopen)) == NULL) {
SLIST_REMOVE_HEAD(&istack[idepth - 1].more, entries);
fp = open_sudoers(pl->path, false, &keepopen);
if (fp != NULL) {
- efree(sudoers);
+ sudo_efree(sudoers);
sudoers = pl->path;
sudolineno = 1;
sudoers_switch_to_buffer(sudoers_create_buffer(fp, YY_BUF_SIZE));
- efree(pl);
+ sudo_efree(pl);
break;
}
/* Unable to open path in include dir, go to next one. */
- efree(pl->path);
- efree(pl);
+ sudo_efree(pl->path);
+ sudo_efree(pl);
}
/* If no path list, just pop the last dir on the stack. */
if (pl == NULL) {
idepth--;
sudoers_switch_to_buffer(istack[idepth].bs);
- efree(sudoers);
+ sudo_efree(sudoers);
sudoers = istack[idepth].path;
sudolineno = istack[idepth].lineno;
keepopen = istack[idepth].keepopen;
if (asprintf(&path, "%s/%s", dirpath, dent->d_name) == -1)
goto bad;
if (stat(path, &sb) != 0 || !S_ISREG(sb.st_mode)) {
- efree(path);
+ sudo_efree(path);
continue;
}
pl = malloc(sizeof(*pl));
if (pl == NULL) {
- efree(path);
+ sudo_efree(path);
goto bad;
}
pl->path = path;
max_paths <<= 1;
tmp = realloc(paths, sizeof(*paths) * max_paths);
if (tmp == NULL) {
- efree(path);
- efree(pl);
+ sudo_efree(path);
+ sudo_efree(pl);
goto bad;
}
paths = tmp;
}
closedir(dir);
if (count == 0) {
- efree(paths);
+ sudo_efree(paths);
paths = NULL;
}
*pathsp = paths;
if (dir != NULL)
closedir(dir);
for (i = 0; i < count; i++) {
- efree(paths[i]->path);
- efree(paths[i]);
+ sudo_efree(paths[i]->path);
+ sudo_efree(paths[i]);
}
- efree(paths);
+ sudo_efree(paths);
debug_return_int(-1);
}
for (i = 0; i < count; i++) {
SLIST_INSERT_HEAD(&stack->more, paths[i], entries);
}
- efree(paths);
+ sudo_efree(paths);
}
debug_return_int(count);
idepth--;
while ((pl = SLIST_FIRST(&istack[idepth].more)) != NULL) {
SLIST_REMOVE_HEAD(&istack[idepth].more, entries);
- efree(pl->path);
- efree(pl);
+ sudo_efree(pl->path);
+ sudo_efree(pl);
}
- efree(istack[idepth].path);
+ sudo_efree(istack[idepth].path);
if (idepth && !istack[idepth].keepopen)
fclose(istack[idepth].bs->yy_input_file);
sudoers_delete_buffer(istack[idepth].bs);
}
- efree(istack);
+ sudo_efree(istack);
istack = NULL;
istacksize = idepth = 0;
sudolineno = 1;
count = switch_dir(&istack[idepth], path);
if (count <= 0) {
/* switch_dir() called sudoerserror() for us */
- efree(path);
+ sudo_efree(path);
debug_return_bool(count ? false : true);
}
/* Parse the first dir entry we can open, leave the rest for later. */
do {
- efree(path);
+ sudo_efree(path);
if ((pl = SLIST_FIRST(&istack[idepth].more)) == NULL) {
/* Unable to open any files in include dir, not an error. */
debug_return_bool(true);
}
SLIST_REMOVE_HEAD(&istack[idepth].more, entries);
path = pl->path;
- efree(pl);
+ sudo_efree(pl);
} while ((fp = open_sudoers(path, false, &keepopen)) == NULL);
} else {
if ((fp = open_sudoers(path, true, &keepopen)) == NULL) {
SLIST_REMOVE_HEAD(&istack[idepth - 1].more, entries);
fp = open_sudoers(pl->path, false, &keepopen);
if (fp != NULL) {
- efree(sudoers);
+ sudo_efree(sudoers);
sudoers = pl->path;
sudolineno = 1;
sudoers_switch_to_buffer(sudoers_create_buffer(fp, YY_BUF_SIZE));
- efree(pl);
+ sudo_efree(pl);
break;
}
/* Unable to open path in include dir, go to next one. */
- efree(pl->path);
- efree(pl);
+ sudo_efree(pl->path);
+ sudo_efree(pl);
}
/* If no path list, just pop the last dir on the stack. */
if (pl == NULL) {
idepth--;
sudoers_switch_to_buffer(istack[idepth].bs);
- efree(sudoers);
+ sudo_efree(sudoers);
sudoers = istack[idepth].path;
sudolineno = istack[idepth].lineno;
keepopen = istack[idepth].keepopen;
(char *) realloc(sudoerslval.command.args, arg_size) :
(char *) malloc(arg_size);
if (p == NULL) {
- efree(sudoerslval.command.args);
+ sudo_efree(sudoerslval.command.args);
sudo_warn(NULL);
sudoerserror(NULL);
debug_return_bool(false);
* mv(1) in case sp->tpath and sp->path are on different file systems.
*/
if (rename(sp->tpath, sp->path) == 0) {
- efree(sp->tpath);
+ sudo_efree(sp->tpath);
sp->tpath = NULL;
} else {
if (errno == EXDEV) {
sudo_warnx(U_("command failed: '%s %s %s', %s unchanged"),
_PATH_MV, sp->tpath, sp->path, sp->path);
(void) unlink(sp->tpath);
- efree(sp->tpath);
+ sudo_efree(sp->tpath);
sp->tpath = NULL;
goto done;
}
- efree(sp->tpath);
+ sudo_efree(sp->tpath);
sp->tpath = NULL;
} else {
sudo_warn(U_("error renaming %s, %s unchanged"), sp->tpath, sp->path);
entry->doedit = doedit;
if (entry->fd == -1) {
sudo_warn("%s", entry->path);
- efree(entry);
+ sudo_efree(entry);
debug_return_ptr(NULL);
}
if (!checkonly && !sudo_lock_file(entry->fd, SUDO_TLOCK))
* find one that exists, is regular, and is executable.
*/
if (Editor == NULL || *Editor == '\0') {
- efree(EditorPath);
+ sudo_efree(EditorPath);
EditorPath = sudo_estrdup(def_editor);
Editor = strtok(EditorPath, ":");
do {
sudo_ev_free(signal_event);
sudo_ev_free(backchannel_event);
TAILQ_FOREACH_SAFE(sigfwd, &sigfwd_list, entries, sigfwd_next) {
- efree(sigfwd);
+ sudo_efree(sigfwd);
}
TAILQ_INIT(&sigfwd_list);
done:
nsent = send(sock, &cstat, sizeof(cstat), 0);
} while (nsent == -1 && errno == EINTR);
TAILQ_REMOVE(&sigfwd_list, sigfwd, entries);
- efree(sigfwd);
+ sudo_efree(sigfwd);
if (nsent != sizeof(cstat)) {
if (errno == EPIPE) {
struct sigforward *sigfwd_next;
"broken pipe writing to child over backchannel");
/* Other end of socket gone, empty out sigfwd_list. */
TAILQ_FOREACH_SAFE(sigfwd, &sigfwd_list, entries, sigfwd_next) {
- efree(sigfwd);
+ sudo_efree(sigfwd);
}
TAILQ_INIT(&sigfwd_list);
/* XXX - child (monitor) is dead, we should exit too? */
nargv[1] = (char *)path;
memcpy(nargv + 2, argv + 1, argc * sizeof(char *));
execve(_PATH_BSHELL, nargv, envp);
- efree(nargv);
+ sudo_efree(nargv);
}
return -1;
}
/* Free I/O buffers. */
while ((iob = SLIST_FIRST(&iobufs)) != NULL) {
SLIST_REMOVE_HEAD(&iobufs, entries);
- efree(iob);
+ sudo_efree(iob);
}
/* Restore terminal settings. */
SLIST_REMOVE_HEAD(head, entries);
else
SLIST_REMOVE_AFTER(prev, entries);
- efree(hook);
+ sudo_efree(hook);
break;
}
prev = hook;
info->path = slpath;
status = sudo_stat_plugin(info, fullpath, pathsize, sb);
if (status == 0) {
- efree((void *)sopath);
+ sudo_efree((void *)sopath);
} else {
- efree(slpath);
+ sudo_efree(slpath);
info->path = sopath;
errno = serrno;
}
info->path = SUDOERS_PLUGIN;
/* info->options = NULL; */
rval = sudo_load_plugin(policy_plugin, io_plugins, info);
- efree(info);
+ sudo_efree(info);
if (!rval)
goto done;
info->path = SUDOERS_PLUGIN;
/* info->options = NULL; */
rval = sudo_load_plugin(policy_plugin, io_plugins, info);
- efree(info);
+ sudo_efree(info);
if (!rval)
goto done;
}
#ifdef HAVE_FREEIFADDRS
freeifaddrs(ifaddrs);
#else
- efree(ifaddrs);
+ sudo_efree(ifaddrs);
#endif
debug_return_int(num_interfaces);
}
if (ifconf->ifc_len + sizeof(struct ifreq) < buflen)
break;
buflen += BUFSIZ;
- efree(ifconf_buf);
+ sudo_efree(ifconf_buf);
}
/* Allocate space for the maximum number of interfaces that could exist. */
}
done:
- efree(ifconf_buf);
+ sudo_efree(ifconf_buf);
(void) close(sock);
debug_return_int(num_interfaces);
pfd_new->highfd = fd;
pfd_new->flags = fcntl(fd, F_GETFD);
if (pfd_new->flags == -1) {
- efree(pfd_new);
+ sudo_efree(pfd_new);
debug_return_int(-1);
}
/* already preserved */
sudo_debug_printf(SUDO_DEBUG_DEBUG|SUDO_DEBUG_LINENO,
"fd %d already preserved", fd);
- efree(pfd_new);
+ sudo_efree(pfd_new);
break;
}
if (fd < pfd->highfd) {
cp = ttyname(fd);
if (cp != NULL) {
if (tty_libc == NULL || strcmp(cp, tty_libc) != 0) {
- efree(tty_libc);
+ sudo_efree(tty_libc);
tty_libc = sudo_estrdup(cp);
}
if (tty_sudo != NULL && strcmp(tty_libc, tty_sudo) == 0) {
tty_sudo ? tty_sudo : "none", tty_libc ? tty_sudo : "none");
}
- efree(tty_libc);
- efree(tty_sudo);
+ sudo_efree(tty_libc);
+ sudo_efree(tty_sudo);
exit(rval);
}
message, NULL, NULL, ttyn, 1);
if (rc <= 0)
sudo_warn(U_("unable to send audit message"));
- efree(message);
+ sudo_efree(message);
close(au_fd);
}
debug_return_ptr(new_context);
bad:
- efree(typebuf);
+ sudo_efree(typebuf);
context_free(context);
freecon(new_context);
debug_return_ptr(NULL);
ud->ngroups = system_maxgroups << 1;
for (tries = 0; tries < 10 && rval == -1; tries++) {
ud->ngroups <<= 1;
- efree(ud->groups);
+ sudo_efree(ud->groups);
ud->groups = sudo_emallocarray(ud->ngroups, sizeof(GETGROUPS_T));
rval = getgrouplist(ud->username, ud->gid, ud->groups, &ud->ngroups);
}
if (ud->ngroups < maxgroups || group_source == GROUP_SOURCE_STATIC) {
ud->groups = sudo_emallocarray(ud->ngroups, sizeof(GETGROUPS_T));
if (getgroups(ud->ngroups, ud->groups) < 0) {
- efree(ud->groups);
+ sudo_efree(ud->groups);
ud->groups = NULL;
}
}
if (user_info[i] == NULL)
sudo_fatal(NULL);
ud->tty = user_info[i] + sizeof("tty=") - 1;
- efree(cp);
+ sudo_efree(cp);
}
if (gethostname(host, sizeof(host)) == 0)
}
cp = colon + 1;
} while (colon);
- efree(path);
+ sudo_efree(path);
}
}
}
/* Remove from io_plugins list and free. */
TAILQ_REMOVE(&io_plugins, plugin, entries);
- efree(plugin);
+ sudo_efree(plugin);
debug_return;
}
if (d != NULL)
closedir(d);
for (i = 0; i < num_subdirs; i++)
- efree(subdirs[i]);
- efree(subdirs);
+ sudo_efree(subdirs[i]);
+ sudo_efree(subdirs);
debug_return_str(devname);
}
sudo_debug_printf(SUDO_DEBUG_WARN,
"unable to resolve tty via KERN_PROC: %s", strerror(errno));
}
- efree(ki_proc);
+ sudo_efree(ki_proc);
debug_return_str(tty);
}
}
}
}
- efree(line);
+ sudo_efree(line);
}
debug_return_str(tty);
projects / sudo / commitdiff