if (getuserattr(user, lim, &val, SEC_INT) != 0 &&
getuserattr("default", lim, &val, SEC_INT) != 0) {
- return(-1);
+ return -1;
}
*valp = val;
- return(0);
+ return 0;
}
static void
res = 1;
else if ((res = strcmp(a1->name, a2->name)) == 0)
res = a1->type - a2->type;
- return(res);
+ return res;
}
/*
*/
a = node->data;
if (a->seqno == alias_seqno)
- return(NULL);
+ return NULL;
a->seqno = alias_seqno;
}
- return(a);
+ return a;
}
/*
if (rbinsert(aliases, a)) {
snprintf(errbuf, sizeof(errbuf), "Alias `%s' already defined", name);
alias_free(a);
- return(errbuf);
+ return errbuf;
}
- return(NULL);
+ return NULL;
}
/*
int
no_aliases()
{
- return(rbisempty(aliases));
+ return rbisempty(aliases);
}
/*
key.name = name;
key.type = type;
if ((node = rbfind(aliases, &key)) == NULL)
- return(NULL);
+ return NULL;
a = rbdelete(aliases, node);
- return(a);
+ return a;
}
void
if ((ptr = malloc(size)) == NULL)
errorx(1, "unable to allocate memory");
- return(ptr);
+ return ptr;
}
/*
size *= nmemb;
if ((ptr = malloc(size)) == NULL)
errorx(1, "unable to allocate memory");
- return(ptr);
+ return ptr;
}
/*
ptr = ptr ? realloc(ptr, size) : malloc(size);
if (ptr == NULL)
errorx(1, "unable to allocate memory");
- return(ptr);
+ return ptr;
}
/*
ptr = ptr ? realloc(ptr, size) : malloc(size);
if (ptr == NULL)
errorx(1, "unable to allocate memory");
- return(ptr);
+ return ptr;
}
/*
dst = (char *) emalloc(size);
(void) memcpy(dst, src, size);
}
- return(dst);
+ return dst;
}
/*
if (len == -1)
errorx(1, "unable to allocate memory");
- return(len);
+ return len;
}
/*
if ((len = vasprintf(ret, format, args)) == -1)
errorx(1, "unable to allocate memory");
- return(len);
+ return len;
}
/*
0, /* lifetime */
&afs_token, /* token */
0) == 0) /* new */
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
/* Fall back on old method XXX - needed? */
setpag();
NULL, /* expiration ptr (unused) */
0, /* spare */
NULL) == 0) /* reason */
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
free(message);
zero_bytes(pass, strlen(pass));
}
- return(rval);
+ return rval;
}
int
/* Unset AUTHSTATE as it may not be correct for the runas user. */
unsetenv("AUTHSTATE");
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
if ((as = auth_open()) == NULL) {
log_error(USE_ERRNO|NO_EXIT|NO_MAIL,
"unable to begin bsd authentication");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
/* XXX - maybe sanity check the auth style earlier? */
if (login_style == NULL) {
log_error(NO_EXIT|NO_MAIL, "invalid authentication type");
auth_close(as);
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
if (auth_setitem(as, AUTHV_STYLE, login_style) < 0 ||
auth_setitem(as, AUTHV_CLASS, login_class) < 0) {
log_error(NO_EXIT|NO_MAIL, "unable to setup authentication");
auth_close(as);
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
auth->data = (void *) as;
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
int
(void) sigaction(SIGCHLD, &osa, NULL);
if (authok)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
if (!pass)
- return(AUTH_INTR);
+ return AUTH_INTR;
if ((s = auth_getvalue(as, "errormsg")) != NULL)
log_error(NO_EXIT|NO_MAIL, "%s", s);
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
int
auth_close(as);
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
sec_login_no_flags, &login_context, &status)) {
if (check_dce_status(status, "sec_login_setup_identity(1):"))
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
password_rec.key.key_type = sec_passwd_plain;
password_rec.key.tagged_union.plain = (idl_char *) plain_pw;
&reset_passwd, &auth_src, &status)) {
if (check_dce_status(status, "sec_login_validate_identity(1):"))
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
/*
* Certify that the DCE Security Server used to set
if (!sec_login_certify_identity(login_context, &status)) {
(void) fprintf(stderr, "Whoa! Bogus authentication server!\n");
(void) check_dce_status(status,"sec_login_certify_identity(1):");
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
if (check_dce_status(status, "sec_login_certify_identity(2):"))
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
/*
* Sets the network credentials to those specified
*/
sec_login_set_context(login_context, &status);
if (check_dce_status(status, "sec_login_set_context:"))
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
/*
* Oops, your credentials were no good. Possibly
if (auth_src != sec_login_auth_src_network) {
(void) fprintf(stderr,
"You have no network credentials.\n");
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
/* Check if the password has aged and is thus no good */
if (reset_passwd) {
(void) fprintf(stderr,
"Your DCE password needs resetting.\n");
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
/*
sec_login_get_pwent(login_context, (sec_login_passwd_t) &temp_pw,
&status);
if (check_dce_status(status, "sec_login_get_pwent:"))
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
/*
* If we get to here, then the pwent above properly fetched
* somewhere later in the program.
*/
sec_login_purge_context(&login_context, &status);
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
} else {
if(check_dce_status(status, "sec_login_validate_identity(2):"))
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
sec_login_purge_context(&login_context, &status);
if(check_dce_status(status, "sec_login_purge_context:"))
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
}
(void) check_dce_status(status, "sec_login_setup_identity(2):");
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
/* Returns 0 for DCE "ok" status, 1 otherwise */
unsigned char error_string[dce_c_error_string_len];
if (input_status == rpc_s_ok)
- return(0);
+ return 0;
dce_error_inq_text(input_status, error_string, &error_stat);
(void) fprintf(stderr, "%s %s\n", comment, error_string);
- return(1);
+ return 1;
}
if ((confp = cfg_read("sudo")) == (Cfg *)-1) {
warningx("cannot read fwtk config");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
if (auth_open(confp)) {
warningx("cannot connect to authentication server");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
/* Get welcome message from auth server */
if (auth_recv(resp, sizeof(resp))) {
warningx("lost connection to authentication server");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
if (strncmp(resp, "Authsrv ready", 13) != 0) {
warningx("authentication server error:\n%s", resp);
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
int
restart:
if (auth_send(buf) || auth_recv(resp, sizeof(resp))) {
warningx("lost connection to authentication server");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
/* Get the password/response from the user. */
goto restart;
} else {
warningx("%s", resp);
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
if (!pass) { /* ^C or error */
- return(AUTH_INTR);
+ return AUTH_INTR;
}
/* Send the user's response to the server */
done:
zero_bytes(pass, strlen(pass));
zero_bytes(buf, strlen(buf));
- return(error);
+ return error;
}
int
{
auth_close();
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
/* Don't try to verify root */
if (pw->pw_uid == 0)
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
/* Get the local realm, or retrun failure (no krb.conf) */
if (krb_get_lrealm(realm, 1) != KSUCCESS)
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
/* Stash a pointer to the realm (used in kerb4_verify) */
auth->data = (void *) realm;
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
int
switch (error) {
case INTK_OK:
dest_tkt(); /* we are done with the temp ticket */
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
break;
case INTK_BADPW:
case KDC_PR_UNKNOWN:
krb_err_txt[error]);
}
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
error = krb5_init_context(&(sudo_krb5_data.sudo_context));
#endif
if (error)
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
sudo_context = sudo_krb5_data.sudo_context;
if ((error = krb5_parse_name(sudo_context, pw->pw_name,
log_error(NO_EXIT|NO_MAIL,
"%s: unable to parse '%s': %s", auth->name, pw->pw_name,
error_message(error));
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
princ = sudo_krb5_data.princ;
log_error(NO_EXIT|NO_MAIL,
"%s: unable to unparse princ ('%s'): %s", auth->name,
pw->pw_name, error_message(error));
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
/* Only rewrite prompt if user didn't specify their own. */
log_error(NO_EXIT|NO_MAIL,
"%s: unable to resolve ccache: %s", auth->name,
error_message(error));
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
ccache = sudo_krb5_data.ccache;
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
#ifdef HAVE_KRB5_VERIFY_USER
ccache = ((sudo_krb5_datap) auth->data)->ccache;
error = krb5_verify_user(sudo_context, princ, ccache, pass, 1, NULL);
- return (error ? AUTH_FAILURE : AUTH_SUCCESS);
+ return error ? AUTH_FAILURE : AUTH_SUCCESS;
}
#else
int
}
if (creds)
krb5_free_cred_contents(sudo_context, creds);
- return (error ? AUTH_FAILURE : AUTH_SUCCESS);
+ return error ? AUTH_FAILURE : AUTH_SUCCESS;
}
#endif
krb5_free_context(sudo_context);
}
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
#ifndef HAVE_KRB5_VERIFY_USER
log_error(NO_EXIT|NO_MAIL,
"%s: unable to get host principal: %s", auth_name,
error_message(error));
- return(-1);
+ return -1;
}
/* Initialize verify opts and set secure mode */
log_error(NO_EXIT|NO_MAIL,
"%s: Cannot verify TGT! Possible attack!: %s", auth_name,
error_message(error));
- return(error);
+ return error;
}
#endif
if (pam_status != PAM_SUCCESS) {
log_error(USE_ERRNO|NO_EXIT|NO_MAIL, "unable to initialize PAM");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
/*
else
(void) pam_set_item(pamh, PAM_TTY, user_ttypath);
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
int
*pam_status = pam_acct_mgmt(pamh, PAM_SILENT);
switch (*pam_status) {
case PAM_SUCCESS:
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
case PAM_AUTH_ERR:
log_error(NO_EXIT|NO_MAIL,
"account validation failure, is your account locked?");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
case PAM_NEW_AUTHTOK_REQD:
log_error(NO_EXIT|NO_MAIL, "%s, %s",
"Account or password is expired",
*pam_status = pam_chauthtok(pamh,
PAM_CHANGE_EXPIRED_AUTHTOK);
if (*pam_status == PAM_SUCCESS)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
if ((s = pam_strerror(pamh, *pam_status)))
log_error(NO_EXIT|NO_MAIL, "pam_chauthtok: %s", s);
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
case PAM_AUTHTOK_EXPIRED:
log_error(NO_EXIT|NO_MAIL,
"Password expired, contact your system administrator");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
case PAM_ACCT_EXPIRED:
log_error(NO_EXIT|NO_MAIL, "%s %s",
"Account expired or PAM config lacks an \"account\"",
"section for sudo, contact your system administrator");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
/* FALLTHROUGH */
case PAM_AUTH_ERR:
if (gotintr) {
/* error or ^C from tgetpass() */
- return(AUTH_INTR);
+ return AUTH_INTR;
}
case PAM_MAXTRIES:
case PAM_PERM_DENIED:
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
default:
if ((s = pam_strerror(pamh, *pam_status)))
log_error(NO_EXIT|NO_MAIL, "pam_authenticate: %s", s);
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
}
/* If successful, we can't close the session until pam_prep_user() */
if (auth->status == AUTH_SUCCESS)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
*pam_status = pam_end(pamh, *pam_status | PAM_DATA_SILENT);
- return(*pam_status == PAM_SUCCESS ? AUTH_SUCCESS : AUTH_FAILURE);
+ return *pam_status == PAM_SUCCESS ? AUTH_SUCCESS : AUTH_FAILURE;
}
int
pamh = NULL;
}
#endif
- return(status == PAM_SUCCESS ? AUTH_SUCCESS : AUTH_FAILURE);
+ return status == PAM_SUCCESS ? AUTH_SUCCESS : AUTH_FAILURE;
}
int
#endif
status = pam_end(pamh, PAM_SUCCESS | PAM_DATA_SILENT);
}
- return(status == PAM_SUCCESS ? AUTH_SUCCESS : AUTH_FAILURE);
+ return status == PAM_SUCCESS ? AUTH_SUCCESS : AUTH_FAILURE;
}
/*
int n, flags, std_prompt;
if ((*response = malloc(num_msg * sizeof(struct pam_response))) == NULL)
- return(PAM_SYSTEM_ERR);
+ return PAM_SYSTEM_ERR;
zero_bytes(*response, num_msg * sizeof(struct pam_response));
for (pr = *response, pm = *msg, n = num_msg; n--; pr++, pm++) {
}
}
- return(PAM_SUCCESS);
+ return PAM_SUCCESS;
err:
/* Zero and free allocated memory and return an error. */
zero_bytes(*response, num_msg * sizeof(struct pam_response));
free(*response);
*response = NULL;
- return(gotintr ? PAM_AUTH_ERR : PAM_CONV_ERR);
+ return gotintr ? PAM_AUTH_ERR : PAM_CONV_ERR;
}
{
#ifdef HAVE_SKEYACCESS
if (skeyaccess(pw, user_tty, NULL, NULL) == 0)
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
#endif
sudo_setspent();
auth->data = sudo_getepw(pw);
sudo_endspent();
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
int
/* Ultrix shadow passwords may use crypt16() */
error = strcmp(pw_epasswd, (char *) crypt16(pass, pw_epasswd));
if (!error)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
#endif /* HAVE_GETAUTHUID */
/*
else
error = strcmp(pw_epasswd, epass);
- return(error ? AUTH_FAILURE : AUTH_SUCCESS);
+ return error ? AUTH_FAILURE : AUTH_SUCCESS;
}
int
zero_bytes(pw_epasswd, strlen(pw_epasswd));
efree(pw_epasswd);
}
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
if (rfc1938challenge(&rfc1938, pw->pw_name, challenge, sizeof(challenge))) {
if (IS_ONEANDONLY(auth)) {
warningx("you do not exist in the %s database", auth->name);
- return(AUTH_FATAL);
+ return AUTH_FATAL;
} else {
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
}
orig_prompt, challenge);
*promptp = new_prompt;
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
int
{
if (rfc1938verify((struct RFC1938 *) auth->data, pass) == 0)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
else
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
extern int crypt_type;
if (crypt_type == INT_MAX)
- return(AUTH_FAILURE); /* no shadow */
+ return AUTH_FAILURE; /* no shadow */
#endif
sudo_setspent();
auth->data = sudo_getepw(pw);
sudo_endspent();
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
int
# ifdef HAVE_DISPCRYPT
if (strcmp(pw_epasswd, dispcrypt(pass, pw_epasswd, crypt_type)) == 0)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
# else
if (crypt_type == AUTH_CRYPT_BIGCRYPT) {
if (strcmp(pw_epasswd, bigcrypt(pass, pw_epasswd)) == 0)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
} else if (crypt_type == AUTH_CRYPT_CRYPT16) {
if (strcmp(pw_epasswd, crypt(pass, pw_epasswd)) == 0)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
# endif /* HAVE_DISPCRYPT */
#elif defined(HAVE_BIGCRYPT)
if (strcmp(pw_epasswd, bigcrypt(pass, pw_epasswd)) == 0)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
#endif /* __alpha */
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
int
zero_bytes(pw_epasswd, strlen(pw_epasswd));
efree(pw_epasswd);
}
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
auth->data = (void *) &sd_dat; /* For method-specific data */
if (creadcfg() == 0)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
else
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
int
if (sd_init(sd) == 0) {
/* The programmer's guide says username is 32 bytes */
strlcpy(sd->username, pw->pw_name, 32);
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
} else {
warningx("unable to contact the SecurID server");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
}
rval = sd_auth(sd);
sd_close();
if (rval == ACM_OK)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
else
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
/* Start communications */
if (AceInitialize() != SD_FALSE)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
warningx("failed to initialise the ACE API library");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
/*
/* Re-initialize SecurID every time. */
if (SD_Init(sd) != ACM_OK) {
warningx("unable to contact the SecurID server");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
/* Lock new PIN code */
switch (retval) {
case ACM_OK:
warningx("User ID locked for SecurID Authentication");
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
case ACE_UNDEFINED_USERNAME:
warningx("invalid username length for SecurID");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
case ACE_ERR_INVALID_HANDLE:
warningx("invalid Authentication Handle for SecurID");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
case ACM_ACCESS_DENIED:
warningx("SecurID communication failed");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
default:
warningx("unknown SecurID error");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
}
SD_Close(*sd);
/* Return stored state to calling process */
- return(rval);
+ return rval;
}
log_error(USE_ERRNO|NO_EXIT|NO_MAIL,
"unable to initialize SIA session");
- return(AUTH_FATAL);
+ return AUTH_FATAL;
}
auth->data = (void *) siah;
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
int
/* XXX - need a way to detect user hitting return or EOF at prompt */
if (sia_ses_reauthent(sudo_collect, siah) == SIASUCCESS)
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
else
- return(AUTH_FAILURE);
+ return AUTH_FAILURE;
}
int
SIAENTITY *siah = (SIAENTITY *) auth->data;
(void) sia_ses_release(&siah);
- return(AUTH_SUCCESS);
+ return AUTH_SUCCESS;
}
mask = &ainfo_addr.ai_mask;
sorf = (sf == 0) ? AU_PRS_SUCCESS : AU_PRS_FAILURE;
rc = au_preselect(AUE_sudo, mask, sorf, AU_PRS_REREAD);
- return (rc);
+ return rc;
}
void
} else
new_prompt = old_prompt;
- return(new_prompt);
+ return new_prompt;
oflow:
/* We pre-allocate enough space, so this should never happen. */
user_is_exempt()
{
if (!def_exempt_group)
- return(FALSE);
- return(user_in_group(sudo_user.pw, def_exempt_group));
+ return FALSE;
+ return user_in_group(sudo_user.pw, def_exempt_group);
}
/*
if (status == TS_ERROR) {
if (timestamp_uid != 0)
set_perms(PERM_ROOT);
- return(status);
+ return status;
}
/*
done:
if (timestamp_uid != 0)
set_perms(PERM_ROOT);
- return(status);
+ return status;
}
/*
pw = sudo_user.pw;
}
- return(pw);
+ return pw;
}
}
if (!cur->name) {
warningx("unknown defaults entry `%s'", var);
- return(FALSE);
+ return FALSE;
}
switch (cur->type & T_MASK) {
warningx("value `%s' is invalid for option `%s'", val, var);
else
warningx("no value specified for `%s'", var);
- return(FALSE);
+ return FALSE;
}
break;
case T_LOGPRI:
warningx("value `%s' is invalid for option `%s'", val, var);
else
warningx("no value specified for `%s'", var);
- return(FALSE);
+ return FALSE;
}
break;
case T_STR:
/* Check for bogus boolean usage or lack of a value. */
if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
warningx("no value specified for `%s'", var);
- return(FALSE);
+ return FALSE;
}
}
if (ISSET(cur->type, T_PATH) && val && *val != '/') {
warningx("values for `%s' must start with a '/'", var);
- return(FALSE);
+ return FALSE;
}
if (!store_str(val, cur, op)) {
warningx("value `%s' is invalid for option `%s'", val, var);
- return(FALSE);
+ return FALSE;
}
break;
case T_INT:
/* Check for bogus boolean usage or lack of a value. */
if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
warningx("no value specified for `%s'", var);
- return(FALSE);
+ return FALSE;
}
}
if (!store_int(val, cur, op)) {
warningx("value `%s' is invalid for option `%s'", val, var);
- return(FALSE);
+ return FALSE;
}
break;
case T_UINT:
/* Check for bogus boolean usage or lack of a value. */
if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
warningx("no value specified for `%s'", var);
- return(FALSE);
+ return FALSE;
}
}
if (!store_uint(val, cur, op)) {
warningx("value `%s' is invalid for option `%s'", val, var);
- return(FALSE);
+ return FALSE;
}
break;
case T_FLOAT:
/* Check for bogus boolean usage or lack of a value. */
if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
warningx("no value specified for `%s'", var);
- return(FALSE);
+ return FALSE;
}
}
if (!store_float(val, cur, op)) {
warningx("value `%s' is invalid for option `%s'", val, var);
- return(FALSE);
+ return FALSE;
}
break;
case T_MODE:
/* Check for bogus boolean usage or lack of a value. */
if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
warningx("no value specified for `%s'", var);
- return(FALSE);
+ return FALSE;
}
}
if (!store_mode(val, cur, op)) {
warningx("value `%s' is invalid for option `%s'", val, var);
- return(FALSE);
+ return FALSE;
}
break;
case T_FLAG:
if (val) {
warningx("option `%s' does not take a value", var);
- return(FALSE);
+ return FALSE;
}
cur->sd_un.flag = op;
break;
/* Check for bogus boolean usage or lack of a value. */
if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
warningx("no value specified for `%s'", var);
- return(FALSE);
+ return FALSE;
}
}
if (!store_list(val, cur, op)) {
warningx("value `%s' is invalid for option `%s'", val, var);
- return(FALSE);
+ return FALSE;
}
break;
case T_TUPLE:
if (!val && !ISSET(cur->type, T_BOOL)) {
warningx("no value specified for `%s'", var);
- return(FALSE);
+ return FALSE;
}
if (!store_tuple(val, cur, op)) {
warningx("value `%s' is invalid for option `%s'", val, var);
- return(FALSE);
+ return FALSE;
}
break;
}
- return(TRUE);
+ return TRUE;
}
/*
break;
}
}
- return(rc);
+ return rc;
}
static int
} else {
l = strtol(val, &endp, 10);
if (*endp != '\0')
- return(FALSE);
+ return FALSE;
/* XXX - should check against INT_MAX */
def->sd_un.ival = (int)l;
}
if (def->callback)
- return(def->callback(val));
- return(TRUE);
+ return def->callback(val);
+ return TRUE;
}
static int
} else {
l = strtol(val, &endp, 10);
if (*endp != '\0' || l < 0)
- return(FALSE);
+ return FALSE;
/* XXX - should check against INT_MAX */
def->sd_un.ival = (unsigned int)l;
}
if (def->callback)
- return(def->callback(val));
- return(TRUE);
+ return def->callback(val);
+ return TRUE;
}
static int
} else {
d = strtod(val, &endp);
if (*endp != '\0')
- return(FALSE);
+ return FALSE;
/* XXX - should check against HUGE_VAL */
def->sd_un.fval = d;
}
if (def->callback)
- return(def->callback(val));
- return(TRUE);
+ return def->callback(val);
+ return TRUE;
}
static int
}
}
if (v->sval == NULL)
- return(FALSE);
+ return FALSE;
}
if (def->callback)
- return(def->callback(val));
- return(TRUE);
+ return def->callback(val);
+ return TRUE;
}
static int
else
def->sd_un.str = estrdup(val);
if (def->callback)
- return(def->callback(val));
- return(TRUE);
+ return def->callback(val);
+ return TRUE;
}
static int
list_op(start, end - start, def, op == '-' ? delete : add);
} while (*end++ != '\0');
}
- return(TRUE);
+ return TRUE;
}
static int
if (op == FALSE) {
def->sd_un.ival = FALSE;
- return(TRUE);
+ return TRUE;
}
#ifdef LOG_NFACILITIES
if (!val)
- return(FALSE);
+ return FALSE;
for (fac = facilities; fac->name && strcmp(val, fac->name); fac++)
;
if (fac->name == NULL)
- return(FALSE); /* not found */
+ return FALSE; /* not found */
def->sd_un.ival = fac->num;
#else
def->sd_un.ival = -1;
#endif /* LOG_NFACILITIES */
- return(TRUE);
+ return TRUE;
}
static const char *
for (fac = facilities; fac->name && fac->num != n; fac++)
;
- return(fac->name);
+ return fac->name;
#else
- return("default");
+ return "default";
#endif /* LOG_NFACILITIES */
}
struct strmap *pri;
if (op == FALSE || !val)
- return(FALSE);
+ return FALSE;
for (pri = priorities; pri->name && strcmp(val, pri->name); pri++)
;
if (pri->name == NULL)
- return(FALSE); /* not found */
+ return FALSE; /* not found */
def->sd_un.ival = pri->num;
- return(TRUE);
+ return TRUE;
}
static const char *
for (pri = priorities; pri->name && pri->num != n; pri++)
;
- return(pri->name);
+ return pri->name;
}
static int
} else {
l = strtol(val, &endp, 8);
if (*endp != '\0' || l < 0 || l > 0777)
- return(FALSE);
+ return FALSE;
def->sd_un.mode = (mode_t)l;
}
if (def->callback)
- return(def->callback(val));
- return(TRUE);
+ return def->callback(val);
+ return TRUE;
}
static void
if (!var || *var == '\0') {
errno = EINVAL;
- return(-1);
+ return -1;
}
if (env.envp == NULL)
errorx(1, "setenv: corrupted envp, len mismatch");
#endif
sudo_putenv(estring, TRUE, overwrite);
- return(0);
+ return 0;
}
/*
#ifdef UNSETENV_VOID
return;
#else
- return(-1);
+ return -1;
#endif
}
}
env.env_len = ep - env.envp;
#ifndef UNSETENV_VOID
- return(0);
+ return 0;
#endif
}
if (strchr(string, '=') == NULL) {
errno = EINVAL;
- return(-1);
+ return -1;
}
#ifdef ENV_DEBUG
if (env.envp[env.env_len] != NULL)
errorx(1, "putenv: corrupted envp, len mismatch");
#endif
sudo_putenv((char *)string, TRUE, TRUE);
- return(0);
+ return 0;
}
/*
break;
}
}
- return(match);
+ return match;
}
/*
break;
}
}
- return(keepit);
+ return keepit;
}
/*
break;
}
}
- return(keepit);
+ return keepit;
}
/*
my_execve(path, argv, envp);
cstat->type = CMD_ERRNO;
cstat->val = errno;
- return(127);
+ return 127;
}
/*
break;
}
- return(rval);
+ return rval;
}
/*
#if defined(HAVE_FUTIME) || defined(HAVE_FUTIMES)
if (fd != -1)
- return(futimes(fd, tvp ? times : NULL));
+ return futimes(fd, tvp ? times : NULL);
else
#endif
if (path != NULL)
- return(utimes(path, tvp ? times : NULL));
+ return utimes(path, tvp ? times : NULL);
else
- return(-1);
+ return -1;
}
/*
op = F_ULOCK;
break;
}
- return(lockf(fd, op, 0) == 0);
+ return lockf(fd, op, 0) == 0;
}
#elif HAVE_FLOCK
int
op = LOCK_UN;
break;
}
- return(flock(fd, op) == 0);
+ return flock(fd, op) == 0;
}
#else
int
lock.l_whence = SEEK_SET;
func = (lockit == SUDO_LOCK) ? F_SETLKW : F_SETLK;
- return(fcntl(fd, func, &lock) == 0);
+ return fcntl(fd, func, &lock) == 0;
#else
- return(TRUE);
+ return TRUE;
#endif
}
#endif
for (cp = buf; isblank((unsigned char)*cp); cp++)
continue;
}
- return(cp);
+ return cp;
}
strlcpy(command, infile, sizeof(command)); /* paranoia */
if (sudo_goodpath(command, sbp)) {
*outfile = command;
- return(FOUND);
+ return FOUND;
} else
- return(NOT_FOUND);
+ return NOT_FOUND;
}
if (path == NULL)
- return(NOT_FOUND);
+ return NOT_FOUND;
path = estrdup(path);
origpath = path;
errorx(1, "%s: File name too long", infile);
result = sudo_goodpath(command, sbp);
if (result && ignore_dot)
- return(NOT_FOUND_DOT);
+ return NOT_FOUND_DOT;
}
if (result) {
*outfile = result;
- return(FOUND);
+ return FOUND;
} else
- return(NOT_FOUND);
+ return NOT_FOUND;
}
switch (c = *pattern++) {
case EOS:
if (ISSET(flags, FNM_LEADING_DIR) && *string == '/')
- return (0);
- return (*string == EOS ? 0 : FNM_NOMATCH);
+ return 0;
+ return *string == EOS ? 0 : FNM_NOMATCH;
case '?':
if (*string == EOS)
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
if (*string == '/' && ISSET(flags, FNM_PATHNAME))
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
if (*string == '.' && ISSET(flags, FNM_PERIOD) &&
(string == stringstart ||
(ISSET(flags, FNM_PATHNAME) && *(string - 1) == '/')))
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
++string;
break;
case '*':
if (*string == '.' && ISSET(flags, FNM_PERIOD) &&
(string == stringstart ||
(ISSET(flags, FNM_PATHNAME) && *(string - 1) == '/')))
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
/* Optimize for pattern with * at end or before /. */
if (c == EOS) {
if (ISSET(flags, FNM_PATHNAME))
- return (ISSET(flags, FNM_LEADING_DIR) ||
+ return ISSET(flags, FNM_LEADING_DIR) ||
strchr(string, '/') == NULL ?
- 0 : FNM_NOMATCH);
+ 0 : FNM_NOMATCH;
else
- return (0);
+ return 0;
} else if (c == '/' && ISSET(flags, FNM_PATHNAME)) {
if ((string = strchr(string, '/')) == NULL)
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
break;
}
/* General case, use recursion. */
while ((test = *string) != EOS) {
if (!fnmatch(pattern, string, flags & ~FNM_PERIOD))
- return (0);
+ return 0;
if (test == '/' && ISSET(flags, FNM_PATHNAME))
break;
++string;
}
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
case '[':
if (*string == EOS)
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
if (*string == '/' && ISSET(flags, FNM_PATHNAME))
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
if (*string == '.' && ISSET(flags, FNM_PERIOD) &&
(string == stringstart ||
(ISSET(flags, FNM_PATHNAME) && *(string - 1) == '/')))
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
switch (rangematch(pattern, *string, flags, &newp)) {
case RANGE_ERROR:
pattern = newp;
break;
case RANGE_NOMATCH:
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
}
++string;
break;
if (c != *string && !(ISSET(flags, FNM_CASEFOLD) &&
(tolower((unsigned char)c) ==
tolower((unsigned char)*string))))
- return (FNM_NOMATCH);
+ return FNM_NOMATCH;
++string;
break;
}
if (c == '\\' && !ISSET(flags, FNM_NOESCAPE))
c = *pattern++;
if (c == EOS)
- return (RANGE_ERROR);
+ return RANGE_ERROR;
if (c == '/' && ISSET(flags, FNM_PATHNAME))
- return (RANGE_NOMATCH);
+ return RANGE_NOMATCH;
if (ISSET(flags, FNM_CASEFOLD))
c = tolower((unsigned char)c);
if (*pattern == '-'
if (c2 == '\\' && !ISSET(flags, FNM_NOESCAPE))
c2 = *pattern++;
if (c2 == EOS)
- return (RANGE_ERROR);
+ return RANGE_ERROR;
if (ISSET(flags, FNM_CASEFOLD))
c2 = tolower((unsigned char)c2);
if (c <= test && test <= c2)
} while ((c = *pattern++) != ']');
*newp = (char *)pattern;
- return (ok == negate ? RANGE_NOMATCH : RANGE_MATCH);
+ return ok == negate ? RANGE_NOMATCH : RANGE_MATCH;
}
static int
if ((colon = strchr(pattern, ':')) == NULL || colon[1] != ']') {
*ep = pattern - 2;
- return(RANGE_ERROR);
+ return RANGE_ERROR;
}
*ep = colon + 2;
len = (size_t)(colon - pattern);
*ep = colon + strlen(colon);
rval = RANGE_ERROR;
}
- return(rval);
+ return rval;
}
}
if (openpty(master, slave, name, NULL, NULL) != 0)
- return(0);
+ return 0;
if (chown(name, ttyuid, ttygid) != 0)
- return(0);
- return(1);
+ return 0;
+ return 1;
}
#elif defined(HAVE__GETPTY)
/* IRIX-style dynamic ptys (may fork) */
line = _getpty(master, O_RDWR, S_IRUSR|S_IWUSR|S_IWGRP, 0);
if (line == NULL)
- return (0);
+ return 0;
*slave = open(line, O_RDWR|O_NOCTTY, 0);
if (*slave == -1) {
close(*master);
- return(0);
+ return 0;
}
(void) chown(line, ttyuid, -1);
strlcpy(name, line, namesz);
- return(1);
+ return 1;
}
#elif defined(HAVE_GRANTPT)
# ifndef HAVE_POSIX_OPENPT
# else
fd = open("/dev/ptmx", oflag);
# endif
- return(fd);
+ return fd;
}
# endif /* HAVE_POSIX_OPENPT */
*master = posix_openpt(O_RDWR|O_NOCTTY);
if (*master == -1)
- return(0);
+ return 0;
(void) grantpt(*master); /* may fork */
if (unlockpt(*master) != 0) {
close(*master);
- return(0);
+ return 0;
}
line = ptsname(*master);
if (line == NULL) {
close(*master);
- return(0);
+ return 0;
}
*slave = open(line, O_RDWR|O_NOCTTY, 0);
if (*slave == -1) {
close(*master);
- return(0);
+ return 0;
}
# if defined(I_PUSH) && !defined(_AIX)
ioctl(*slave, I_PUSH, "ptem"); /* pseudo tty emulation module */
# endif
(void) chown(line, ttyuid, -1);
strlcpy(name, line, namesz);
- return(1);
+ return 1;
}
#else /* Old-style BSD ptys */
*master = open(line, O_RDWR|O_NOCTTY, 0);
if (*master == -1) {
if (errno == ENOENT)
- return(0); /* out of ptys */
+ return 0; /* out of ptys */
continue; /* already in use */
}
line[sizeof("/dev/p") - 2] = 't';
*slave = open(line, O_RDWR|O_NOCTTY, 0);
if (*slave != -1) {
strlcpy(name, line, namesz);
- return(1); /* success */
+ return 1; /* success */
}
(void) close(*master);
}
}
- return(0);
+ return 0;
}
#endif /* HAVE_OPENPTY */
ptsize = 0;
if (!size) {
errno = EINVAL;
- return (NULL);
+ return NULL;
}
ept = pt + size;
} else {
if ((pt = malloc(ptsize = 1024 - 4)) == NULL)
- return (NULL);
+ return NULL;
ept = pt + ptsize;
}
bpt = ept - 1;
*/
bcopy(bpt, pt, ept - bpt);
free(up);
- return (pt);
+ return pt;
}
/*
free(up);
if (dir)
(void)closedir(dir);
- return (NULL);
+ return NULL;
}
memcpy(*bufp, buf, len);
(*bufp)[len] = '\0';
}
- return(buf ? len : -1);
+ return buf ? len : -1;
}
#else
ssize_t
}
*bufp = buf;
*bufsizep = bufsize;
- return(len);
+ return len;
}
#endif
else
progname = Argv[0];
}
- return(progname);
+ return progname;
}
/* If there is a function to check for shadow enabled, use it... */
#ifdef HAVE_ISCOMSEC
if (!iscomsec())
- return(estrdup(pw->pw_passwd));
+ return estrdup(pw->pw_passwd);
#endif /* HAVE_ISCOMSEC */
#ifdef HAVE_ISSECURE
if (!issecure())
- return(estrdup(pw->pw_passwd));
+ return estrdup(pw->pw_passwd);
#endif /* HAVE_ISSECURE */
epw = NULL;
epw = estrdup(spw->ufld.fd_encrypt);
}
if (epw)
- return(epw);
+ return epw;
}
#endif /* HAVE_GETPRPWNAM */
#ifdef HAVE_GETSPNAM
if ((spw = getspnam(pw->pw_name)) && spw->sp_pwdp)
epw = estrdup(spw->sp_pwdp);
if (epw)
- return(epw);
+ return epw;
}
#endif /* HAVE_GETSPNAM */
#ifdef HAVE_GETSPWUID
if ((spw = getspwuid(pw->pw_uid)) && spw->pw_passwd)
epw = estrdup(spw->pw_passwd);
if (epw)
- return(epw);
+ return epw;
}
#endif /* HAVE_GETSPWUID */
#ifdef HAVE_GETPWANAM
if ((spw = getpwanam(pw->pw_name)) && spw->pwa_passwd)
epw = estrdup(spw->pwa_passwd);
if (epw)
- return(epw);
+ return epw;
}
#endif /* HAVE_GETPWANAM */
#ifdef HAVE_GETAUTHUID
if ((spw = getauthuid(pw->pw_uid)) && spw->a_password)
epw = estrdup(spw->a_password);
if (epw)
- return(epw);
+ return epw;
}
#endif /* HAVE_GETAUTHUID */
/* Fall back on normal password. */
- return(estrdup(pw->pw_passwd));
+ return estrdup(pw->pw_passwd);
}
void
rval = (int)time(&tv->tv_sec);
tv->tv_usec = 0;
#endif
- return (rval);
+ return rval;
}
#endif
if ((err = glob1(patbuf, patbuf + PATH_MAX - 1, pglob)) != 0)
- return(err);
+ return err;
/*
* If there was no match we are going to append the pattern
*/
if (pglob->gl_pathc == oldpathc) {
if (pglob->gl_flags & GLOB_NOCHECK)
- return(globextend(pattern, pglob));
+ return globextend(pattern, pglob);
else
- return(GLOB_NOMATCH);
+ return GLOB_NOMATCH;
}
if (!(pglob->gl_flags & GLOB_NOSORT))
qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,
pglob->gl_pathc - oldpathc, sizeof(char *), compare);
- return(0);
+ return 0;
}
static int
compare(p, q)
const void *p, *q;
{
- return(strcmp(*(char **)p, *(char **)q));
+ return strcmp(*(char **)p, *(char **)q);
}
static int
/* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
if (*pattern == EOS)
- return(0);
- return(glob2(pathbuf, pathbuf + PATH_MAX - 1,
+ return 0;
+ return glob2(pathbuf, pathbuf + PATH_MAX - 1,
pathbuf, pathbuf + PATH_MAX - 1,
- pattern, pattern_last, pglob));
+ pattern, pattern_last, pglob);
}
/*
if (*pattern == EOS) { /* End of pattern? */
*pathend = EOS;
if (g_lstat(pathbuf, &sb, pglob))
- return(0);
+ return 0;
if (((pglob->gl_flags & GLOB_MARK) &&
pathend[-1] != SEP) && (S_ISDIR(sb.st_mode) ||
(g_stat(pathbuf, &sb, pglob) == 0) &&
S_ISDIR(sb.st_mode)))) {
if (pathend+1 > pathend_last)
- return (1);
+ return 1;
*pathend++ = SEP;
*pathend = EOS;
}
++pglob->gl_matchc;
- return(globextend(pathbuf, pglob));
+ return globextend(pathbuf, pglob);
}
/* Find end of next segment, copy tentatively to pathend. */
if (ismeta(*p))
anymeta = 1;
if (q+1 > pathend_last)
- return (1);
+ return 1;
*q++ = *p++;
}
pattern = p;
while (*pattern == SEP) {
if (pathend+1 > pathend_last)
- return (1);
+ return 1;
*pathend++ = *pattern++;
}
} else
/* Need expansion, recurse. */
- return(glob3(pathbuf, pathbuf_last, pathend,
+ return glob3(pathbuf, pathbuf_last, pathend,
pathend_last, pattern, pattern_last,
- p, pattern_last, pglob));
+ p, pattern_last, pglob);
}
/* NOTREACHED */
}
char buf[PATH_MAX];
if (pathend > pathend_last)
- return (1);
+ return 1;
*pathend = EOS;
errno = 0;
/* TODO: don't call for ENOENT or ENOTDIR? */
if (pglob->gl_errfunc) {
if (g_Ctoc(pathbuf, buf, sizeof(buf)))
- return(GLOB_ABORTED);
+ return GLOB_ABORTED;
if (pglob->gl_errfunc(buf, errno) ||
pglob->gl_flags & GLOB_ERR)
- return(GLOB_ABORTED);
+ return GLOB_ABORTED;
}
- return(0);
+ return 0;
}
err = 0;
}
closedir(dirp);
- return(err);
+ return err;
}
/*
free(pglob->gl_pathv);
pglob->gl_pathv = NULL;
}
- return(GLOB_NOSPACE);
+ return GLOB_NOSPACE;
}
if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {
if ((copy = malloc(len)) != NULL) {
if (g_Ctoc(path, copy, len)) {
free(copy);
- return(GLOB_NOSPACE);
+ return GLOB_NOSPACE;
}
pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
}
pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
- return(copy == NULL ? GLOB_NOSPACE : 0);
+ return copy == NULL ? GLOB_NOSPACE : 0;
}
/*
switch (c & M_MASK) {
case M_ALL:
if (pat == patend)
- return(1);
+ return 1;
do {
if (match(name, pat, patend))
- return(1);
+ return 1;
} while (*name++ != EOS);
- return(0);
+ return 0;
case M_ONE:
if (*name++ == EOS)
- return(0);
+ return 0;
break;
case M_SET:
ok = 0;
if ((k = *name++) == EOS)
- return(0);
+ return 0;
if ((negate_range = ((*pat & M_MASK) == M_NOT)) != EOS)
++pat;
while (((c = *pat++) & M_MASK) != M_END) {
ok = 1;
}
if (ok == negate_range)
- return(0);
+ return 0;
break;
default:
if (*name++ != c)
- return(0);
+ return 0;
break;
}
}
- return(*name == EOS);
+ return *name == EOS;
}
/* Free allocated data belonging to a glob_t structure. */
buf[1] = '\0';
} else {
if (g_Ctoc(str, buf, sizeof(buf)))
- return(NULL);
+ return NULL;
}
- return(opendir(buf));
+ return opendir(buf);
}
static int
char buf[PATH_MAX];
if (g_Ctoc(fn, buf, sizeof(buf)))
- return(-1);
- return(lstat(buf, sb));
+ return -1;
+ return lstat(buf, sb);
}
static int
char buf[PATH_MAX];
if (g_Ctoc(fn, buf, sizeof(buf)))
- return(-1);
- return(stat(buf, sb));
+ return -1;
+ return stat(buf, sb);
}
static Char *
{
do {
if (*str == ch)
- return ((Char *)str);
+ return (Char *)str;
} while (*str++);
- return (NULL);
+ return NULL;
}
static int
while (len--) {
if ((*buf++ = *str++) == EOS)
- return (0);
+ return 0;
}
- return (1);
+ return 1;
}
#ifdef DEBUG
/* Check for brain damage */
if (path == NULL || path[0] == '\0')
- return(NULL);
+ return NULL;
if (stat(path, &sb))
- return(NULL);
+ return NULL;
/* Make sure path describes an executable regular file. */
if (!S_ISREG(sb.st_mode) || !(sb.st_mode & 0000111)) {
errno = EACCES;
- return(NULL);
+ return NULL;
}
if (sbp != NULL)
(void) memcpy(sbp, &sb, sizeof(struct stat));
- return((char *)path);
+ return (char *)path;
}
d->prev = d;
d->next = NULL;
- return(d);
+ return d;
}
static struct member *
m->prev = m;
m->next = NULL;
- return(m);
+ return m;
}
/*
d->prev = d;
d->next = NULL;
- return(d);
+ return d;
}
static struct member *
m->prev = m;
m->next = NULL;
- return(m);
+ return m;
}
/*
pathbuf[len - i] = '/';
}
- return(len);
+ return len;
}
static void *
isblank(ch)
int ch;
{
- return(ch == ' ' || ch == '\t');
+ return ch == ' ' || ch == '\t';
}
struct winsize wsize;
if (ioctl(STDERR_FILENO, TIOCGWINSZ, &wsize) == 0 && wsize.ws_col != 0)
- return((int)wsize.ws_col);
+ return (int)wsize.ws_col;
#endif
/* Fall back on $COLUMNS. */
if ((p = getenv("COLUMNS")) == NULL || (cols = atoi(p)) <= 0)
cols = 80;
- return(cols);
+ return cols;
}
void
done:
efree(buf);
- return(rc);
+ return rc;
toobig:
errorx(1, "sudo_ldap_parse_uri: out of space building hostbuf");
/* Usually just a single entry. */
if (uri_list->next == NULL)
- return(estrdup(uri_list->val));
+ return estrdup(uri_list->val);
for (uri = uri_list; uri != NULL; uri = uri->next) {
len += strlen(uri->val) + 1;
*cp++ = ' ';
}
cp[-1] = '\0';
- return(buf);
+ return buf;
}
#endif /* HAVE_LDAP_INITIALIZE */
done:
*ldp = ld;
- return(rc);
+ return rc;
}
/*
int ret = FALSE;
if (!entry)
- return(ret);
+ return ret;
/* get the values from the entry */
bv = ldap_get_values_len(ld, entry, "sudoUser");
if (bv == NULL)
- return(ret);
+ return ret;
/* walk through values */
for (p = bv; *p != NULL && !ret; p++) {
ldap_value_free_len(bv); /* cleanup */
- return(ret);
+ return ret;
}
/*
int ret = FALSE;
if (!entry)
- return(ret);
+ return ret;
/* get the values from the entry */
bv = ldap_get_values_len(ld, entry, "sudoHost");
if (bv == NULL)
- return(ret);
+ return ret;
/* walk through values */
for (p = bv; *p != NULL && !ret; p++) {
ldap_value_free_len(bv); /* cleanup */
- return(ret);
+ return ret;
}
static int
int ret = FALSE;
if (!runas_pw)
- return(UNSPEC);
+ return UNSPEC;
/* get the runas user from the entry */
bv = ldap_get_values_len(ld, entry, "sudoRunAsUser");
* what the user specified on the command line.
*/
if (bv == NULL)
- return(!strcasecmp(runas_pw->pw_name, def_runas_default));
+ return !strcasecmp(runas_pw->pw_name, def_runas_default);
/* walk through values returned, looking for a match */
for (p = bv; *p != NULL && !ret; p++) {
ldap_value_free_len(bv); /* cleanup */
- return(ret);
+ return ret;
}
static int
/* runas_gr is only set if the user specified the -g flag */
if (!runas_gr)
- return(UNSPEC);
+ return UNSPEC;
/* get the values from the entry */
bv = ldap_get_values_len(ld, entry, "sudoRunAsGroup");
if (bv == NULL)
- return(ret);
+ return ret;
/* walk through values returned, looking for a match */
for (p = bv; *p != NULL && !ret; p++) {
ldap_value_free_len(bv); /* cleanup */
- return(ret);
+ return ret;
}
/*
int ret;
if (!entry)
- return(FALSE);
+ return FALSE;
ret = sudo_ldap_check_runas_user(ld, entry) != FALSE &&
sudo_ldap_check_runas_group(ld, entry) != FALSE;
- return(ret);
+ return ret;
}
/*
int foundbang, ret = UNSPEC;
if (!entry)
- return(ret);
+ return ret;
bv = ldap_get_values_len(ld, entry, "sudoCommand");
if (bv == NULL)
- return(ret);
+ return ret;
for (p = bv; *p != NULL && ret != FALSE; p++) {
val = (*p)->bv_val;
ldap_value_free_len(bv); /* more cleanup */
- return(ret);
+ return ret;
}
/*
int ret = UNSPEC;
if (entry == NULL)
- return(UNSPEC);
+ return UNSPEC;
bv = ldap_get_values_len(ld, entry, "sudoOption");
if (bv == NULL)
- return(ret);
+ return ret;
/* walk through options */
for (p = bv; *p != NULL; p++) {
ldap_value_free_len(bv);
- return(ret);
+ return ret;
}
/*
}
done:
- return(bytes);
+ return bytes;
}
/*
}
strlcat(buf, ")", sz); /* closes the global OR or the global AND */
- return(buf);
+ return buf;
}
/*
buf = estrdup("sudoUser=+*");
}
- return(buf);
+ return buf;
}
/*
case 'y':
case 'Y':
if (strcasecmp(s, "yes") == 0)
- return(TRUE);
+ return TRUE;
break;
case 't':
case 'T':
if (strcasecmp(s, "true") == 0)
- return(TRUE);
+ return TRUE;
break;
case 'o':
case 'O':
if (strcasecmp(s, "on") == 0)
- return(TRUE);
+ return TRUE;
if (strcasecmp(s, "off") == 0)
- return(FALSE);
+ return FALSE;
break;
case 'n':
case 'N':
if (strcasecmp(s, "no") == 0)
- return(FALSE);
+ return FALSE;
break;
case 'f':
case 'F':
if (strcasecmp(s, "false") == 0)
- return(FALSE);
+ return FALSE;
break;
}
- return(-1);
+ return -1;
}
static void
ldap_conf.rootuse_sasl = -1;
if ((fp = fopen(_PATH_LDAP_CONF, "r")) == NULL)
- return(FALSE);
+ return FALSE;
while ((cp = sudo_parseln(fp)) != NULL) {
if (*cp == '\0')
fprintf(stderr, "===================\n");
}
if (!ldap_conf.base)
- return(FALSE); /* if no base is defined, ignore LDAP */
+ return FALSE; /* if no base is defined, ignore LDAP */
if (ldap_conf.bind_timelimit > 0)
ldap_conf.bind_timelimit *= 1000; /* convert to ms */
if (ldap_conf.uri) {
struct ldap_config_list_str *uri = ldap_conf.uri;
if (sudo_ldap_parse_uri(uri) != 0)
- return(FALSE);
+ return FALSE;
do {
ldap_conf.uri = uri->next;
efree(uri);
}
}
#endif
- return(TRUE);
+ return TRUE;
}
/*
LDAPDN tmpDN;
if ((dn = ldap_get_dn(ld, entry)) == NULL)
- return(NULL);
+ return NULL;
if (ldap_str2dn(dn, &tmpDN, LDAP_DN_FORMAT_LDAP) == LDAP_SUCCESS) {
ldap_rdn2str(tmpDN[0], &rdn, LDAP_DN_FORMAT_UFN);
ldap_dnfree(tmpDN);
}
ldap_memfree(dn);
- return(rdn);
+ return rdn;
#else
char *dn, **edn;
if ((dn = ldap_get_dn(ld, entry)) == NULL)
- return(NULL);
+ return NULL;
edn = ldap_explode_dn(dn, 1);
ldap_memfree(dn);
- return(edn ? edn[0] : NULL);
+ return edn ? edn[0] : NULL;
#endif
}
ldap_msgfree(result);
}
done:
- return(count);
+ return count;
}
/*
struct passwd *pw;
struct lbuf *lbuf;
{
- return(0);
+ return 0;
}
/*
}
lbuf_append(lbuf, "\n", NULL);
- return(count);
+ return count;
}
/*
ldap_value_free_len(bv);
}
- return(count);
+ return count;
}
/*
}
done:
- return(count);
+ return count;
}
static int
if (found)
printf("%s%s%s\n", safe_cmnd ? safe_cmnd : user_cmnd,
user_args ? " " : "", user_args ? user_args : "");
- return(!found);
+ return !found;
}
#ifdef HAVE_LDAP_SASL_INTERACTIVE_BIND_S
for (; interact->id != SASL_CB_LIST_END; interact++) {
if (interact->id != SASL_CB_USER)
- return(LDAP_PARAM_ERROR);
+ return LDAP_PARAM_ERROR;
if (auth_id != NULL)
interact->result = auth_id;
interact->result = estrdup(interact->result);
#endif /* SASL_VERSION_MAJOR < 2 */
}
- return(LDAP_SUCCESS);
+ return LDAP_SUCCESS;
}
#endif /* HAVE_LDAP_SASL_INTERACTIVE_BIND_S */
if (rc != LDAP_OPT_SUCCESS) {
warningx("ldap_set_option: %s -> %d: %s",
cur->conf_str, ival, ldap_err2string(rc));
- return(-1);
+ return -1;
}
DPRINTF(("ldap_set_option: %s -> %d", cur->conf_str, ival), 1);
}
if (rc != LDAP_OPT_SUCCESS) {
warningx("ldap_set_option: %s -> %s: %s",
cur->conf_str, sval, ldap_err2string(rc));
- return(-1);
+ return -1;
}
DPRINTF(("ldap_set_option: %s -> %s", cur->conf_str, sval), 1);
}
if (rc != LDAP_OPT_SUCCESS) {
warningx("ldap_set_option(TIMEOUT, %ld): %s",
(long)tv.tv_sec, ldap_err2string(rc));
- return(-1);
+ return -1;
}
DPRINTF(("ldap_set_option(LDAP_OPT_TIMEOUT, %ld)",
(long)tv.tv_sec), 1);
if (rc != LDAP_OPT_SUCCESS) {
warningx("ldap_set_option(NETWORK_TIMEOUT, %ld): %s",
(long)tv.tv_sec, ldap_err2string(rc));
- return(-1);
+ return -1;
}
DPRINTF(("ldap_set_option(LDAP_OPT_NETWORK_TIMEOUT, %ld)",
(long)tv.tv_sec), 1);
if (rc != LDAP_SUCCESS) {
warningx("ldap_set_option(LDAP_OPT_X_TLS, LDAP_OPT_X_TLS_HARD): %s",
ldap_err2string(rc));
- return(-1);
+ return -1;
}
DPRINTF(("ldap_set_option(LDAP_OPT_X_TLS, LDAP_OPT_X_TLS_HARD)"), 1);
}
#endif
- return(0);
+ return 0;
}
/*
result->allocated_entries = 0;
result->user_matches = FALSE;
result->host_matches = FALSE;
- return(result);
+ return result;
}
/*
} else {
lres->searches = news;
}
- return(news);
+ return news;
}
/*
}
if (rc != LDAP_SUCCESS) {
warningx("ldap_sasl_interactive_bind_s(): %s", ldap_err2string(rc));
- return(-1);
+ return -1;
}
DPRINTF(("ldap_sasl_interactive_bind_s() ok"), 1);
} else
NULL, NULL, NULL);
if (rc != LDAP_SUCCESS) {
warningx("ldap_sasl_bind_s(): %s", ldap_err2string(rc));
- return(-1);
+ return -1;
}
DPRINTF(("ldap_sasl_bind_s() ok"), 1);
}
rc = ldap_simple_bind_s(ld, ldap_conf.binddn, ldap_conf.bindpw);
if (rc != LDAP_SUCCESS) {
warningx("ldap_simple_bind_s(): %s", ldap_err2string(rc));
- return(-1);
+ return -1;
}
DPRINTF(("ldap_simple_bind_s() ok"), 1);
}
#endif
- return(0);
+ return 0;
}
/*
struct sudo_ldap_handle *handle;
if (!sudo_ldap_read_config())
- return(-1);
+ return -1;
/* Prevent reading of user ldaprc and system defaults. */
if (getenv("LDAPNOINIT") == NULL) {
rc = sudo_ldap_init(&ld, ldap_conf.host, ldap_conf.port);
if (rc != LDAP_SUCCESS) {
warningx("unable to initialize LDAP: %s", ldap_err2string(rc));
- return(-1);
+ return -1;
}
if (ldapnoinit)
/* Set LDAP options */
if (sudo_ldap_set_options(ld) < 0)
- return(-1);
+ return -1;
if (ldap_conf.ssl_mode == SUDO_LDAP_STARTTLS) {
#if defined(HAVE_LDAP_START_TLS_S)
rc = ldap_start_tls_s(ld, NULL, NULL);
if (rc != LDAP_SUCCESS) {
warningx("ldap_start_tls_s(): %s", ldap_err2string(rc));
- return(-1);
+ return -1;
}
DPRINTF(("ldap_start_tls_s() ok"), 1);
#elif defined(HAVE_LDAP_SSL_CLIENT_INIT) && defined(HAVE_LDAP_START_TLS_S_NP)
if (ldap_ssl_client_init(NULL, NULL, 0, &rc) != LDAP_SUCCESS) {
warningx("ldap_ssl_client_init(): %s", ldap_err2string(rc));
- return(-1);
+ return -1;
}
rc = ldap_start_tls_s_np(ld, NULL);
if (rc != LDAP_SUCCESS) {
warningx("ldap_start_tls_s_np(): %s", ldap_err2string(rc));
- return(-1);
+ return -1;
}
DPRINTF(("ldap_start_tls_s_np() ok"), 1);
#else
/* Actually connect */
if (sudo_ldap_bind_s(ld) != 0)
- return(-1);
+ return -1;
/* Create a handle container. */
handle = emalloc(sizeof(struct sudo_ldap_handle));
handle->groups = NULL;
nss->handle = handle;
- return(0);
+ return 0;
}
static int
int rc;
if (handle == NULL || handle->ld == NULL)
- return(-1);
+ return -1;
ld = handle->ld;
for (base = ldap_conf.base; base != NULL; base = base->next) {
ldap_msgfree(result);
}
- return(0);
+ return 0;
}
/*
struct ldap_result *lres = NULL;
if (handle == NULL || handle->ld == NULL)
- return(ret);
+ return ret;
ld = handle->ld;
/* Fetch list of sudoRole entries that match user and host. */
CLR(ret, FLAG_NO_HOST);
DPRINTF(("sudo_ldap_lookup(%d)=0x%02x", pwflag, ret), 1);
- return(ret);
+ return ret;
}
/*
const struct ldap_entry_wrapper *aw = a;
const struct ldap_entry_wrapper *bw = b;
- return(bw->order < aw->order ? -1 :
- (bw->order > aw->order ? 1 : 0));
+ return bw->order < aw->order ? -1 :
+ (bw->order > aw->order ? 1 : 0);
}
/*
while (result->next)
result = result->next;
}
- return(result);
+ return result;
}
/*
lres->entries[lres->nentries - 1].entry = entry;
lres->entries[lres->nentries - 1].order = order;
- return(&lres->entries[lres->nentries - 1]);
+ return &lres->entries[lres->nentries - 1];
}
/*
strcmp(pw->pw_name, handle->username) == 0) {
DPRINTF(("reusing previous result (user %s) with %d entries",
handle->username, handle->result->nentries), 1);
- return(handle->result);
+ return handle->result;
}
/* User mismatch, cached result cannot be used. */
DPRINTF(("removing result (user %s), new search (user %s)",
handle->username = estrdup(pw->pw_name);
handle->groups = user_groups;
- return(lres);
+ return lres;
}
/*
efree(nss->handle);
nss->handle = NULL;
}
- return(0);
+ return 0;
}
/*
sudo_ldap_parse(nss)
struct sudo_nss *nss;
{
- return(0);
+ return 0;
}
#if 0
}
DPRINTF(("sudo_ldap_result_from_search: %d entries found",
result->nentries), 2);
- return(result);
+ return result;
}
#endif
h->last->next = NULL;
}
}
- return (last);
+ return last;
}
/*
int status;
{
- return(def_mail_always || ISSET(status, VALIDATE_ERROR) ||
+ return def_mail_always || ISSET(status, VALIDATE_ERROR) ||
(def_mail_no_user && ISSET(status, FLAG_NO_USER)) ||
(def_mail_no_host && ISSET(status, FLAG_NO_HOST)) ||
- (def_mail_no_perms && !ISSET(status, VALIDATE_OK)));
+ (def_mail_no_perms && !ISSET(status, VALIDATE_OK));
}
#define LL_TTY_STR "TTY="
goto toobig;
}
- return (line);
+ return line;
toobig:
errorx(1, "internal error: insufficient space for log line");
}
if (matched != UNSPEC)
break;
}
- return(matched);
+ return matched;
}
int
struct member_list *list;
{
alias_seqno++;
- return(_userlist_matches(pw, list));
+ return _userlist_matches(pw, list);
}
/*
if (runas_pw != NULL) {
/* If no runas user or runas group listed in sudoers, use default. */
if (tq_empty(user_list) && tq_empty(group_list))
- return(userpw_matches(def_runas_default, runas_pw->pw_name, runas_pw));
+ return userpw_matches(def_runas_default, runas_pw->pw_name, runas_pw);
tq_foreach_rev(user_list, m) {
switch (m->type) {
}
if (user_matched == DENY || group_matched == DENY)
- return(DENY);
+ return DENY;
if (user_matched == group_matched || runas_gr == NULL)
- return(user_matched);
- return(UNSPEC);
+ return user_matched;
+ return UNSPEC;
}
int
struct member_list *group_list;
{
alias_seqno++;
- return(_runaslist_matches(user_list ? user_list : &empty,
- group_list ? group_list : &empty));
+ return _runaslist_matches(user_list ? user_list : &empty,
+ group_list ? group_list : &empty);
}
/*
if (matched != UNSPEC)
break;
}
- return(matched);
+ return matched;
}
int
struct member_list *list;
{
alias_seqno++;
- return(_hostlist_matches(list));
+ return _hostlist_matches(list);
}
/*
if (matched != UNSPEC)
break;
}
- return(matched);
+ return matched;
}
int
struct member_list *list;
{
alias_seqno++;
- return(_cmndlist_matches(list));
+ return _cmndlist_matches(list);
}
/*
matched = !m->negated;
break;
}
- return(matched);
+ return matched;
}
static int
*/
if (strcmp(sudoers_cmnd, "sudoedit") != 0 ||
strcmp(user_cmnd, "sudoedit") != 0)
- return(FALSE);
+ return FALSE;
if (command_args_match(sudoers_cmnd, sudoers_args)) {
efree(safe_cmnd);
safe_cmnd = estrdup(sudoers_cmnd);
- return(TRUE);
+ return TRUE;
} else
- return(FALSE);
+ return FALSE;
}
if (has_meta(sudoers_cmnd)) {
* use glob(3) and/or fnmatch(3) to do the matching.
*/
if (def_fast_glob)
- return(command_matches_fnmatch(sudoers_cmnd, sudoers_args));
- return(command_matches_glob(sudoers_cmnd, sudoers_args));
+ return command_matches_fnmatch(sudoers_cmnd, sudoers_args);
+ return command_matches_glob(sudoers_cmnd, sudoers_args);
}
- return(command_matches_normal(sudoers_cmnd, sudoers_args));
+ return command_matches_normal(sudoers_cmnd, sudoers_args);
}
static int
* else return false.
*/
if (fnmatch(sudoers_cmnd, user_cmnd, FNM_PATHNAME) != 0)
- return(FALSE);
+ return FALSE;
if (command_args_match(sudoers_cmnd, sudoers_args)) {
if (safe_cmnd)
free(safe_cmnd);
safe_cmnd = estrdup(user_cmnd);
- return(TRUE);
+ return TRUE;
} else
- return(FALSE);
+ return FALSE;
}
static int
if ((base = strrchr(sudoers_cmnd, '/')) != NULL) {
base++;
if (!has_meta(base) && strcmp(user_base, base) != 0)
- return(FALSE);
+ return FALSE;
}
}
/*
#define GLOB_FLAGS (GLOB_NOSORT | GLOB_MARK | GLOB_BRACE | GLOB_TILDE)
if (glob(sudoers_cmnd, GLOB_FLAGS, NULL, &gl) != 0 || gl.gl_pathc == 0) {
globfree(&gl);
- return(FALSE);
+ return FALSE;
}
/* For each glob match, compare basename, st_dev and st_ino. */
for (ap = gl.gl_pathv; (cp = *ap) != NULL; ap++) {
dlen = strlen(cp);
if (cp[dlen - 1] == '/') {
if (command_matches_dir(cp, dlen))
- return(TRUE);
+ return TRUE;
continue;
}
}
globfree(&gl);
if (cp == NULL)
- return(FALSE);
+ return FALSE;
if (command_args_match(sudoers_cmnd, sudoers_args)) {
efree(safe_cmnd);
safe_cmnd = estrdup(user_cmnd);
- return(TRUE);
+ return TRUE;
}
- return(FALSE);
+ return FALSE;
}
static int
/* If it ends in '/' it is a directory spec. */
dlen = strlen(sudoers_cmnd);
if (sudoers_cmnd[dlen - 1] == '/')
- return(command_matches_dir(sudoers_cmnd, dlen));
+ return command_matches_dir(sudoers_cmnd, dlen);
/* Only proceed if user_base and basename(sudoers_cmnd) match */
if ((base = strrchr(sudoers_cmnd, '/')) == NULL)
base++;
if (strcmp(user_base, base) != 0 ||
stat(sudoers_cmnd, &sudoers_stat) == -1)
- return(FALSE);
+ return FALSE;
/*
* Return true if inode/device matches AND
if (user_stat != NULL &&
(user_stat->st_dev != sudoers_stat.st_dev ||
user_stat->st_ino != sudoers_stat.st_ino))
- return(FALSE);
+ return FALSE;
if (command_args_match(sudoers_cmnd, sudoers_args)) {
efree(safe_cmnd);
safe_cmnd = estrdup(sudoers_cmnd);
- return(TRUE);
+ return TRUE;
}
- return(FALSE);
+ return FALSE;
}
/*
*/
dirp = opendir(sudoers_dir);
if (dirp == NULL)
- return(FALSE);
+ return FALSE;
if (strlcpy(buf, sudoers_dir, sizeof(buf)) >= sizeof(buf)) {
closedir(dirp);
- return(FALSE);
+ return FALSE;
}
while ((dent = readdir(dirp)) != NULL) {
/* ignore paths > PATH_MAX (XXX - log) */
}
closedir(dirp);
- return(dent != NULL);
+ return dent != NULL;
}
static int
if (ifp->addr.ip4.s_addr == addr.ip4.s_addr ||
(ifp->addr.ip4.s_addr & ifp->netmask.ip4.s_addr)
== addr.ip4.s_addr)
- return(TRUE);
+ return TRUE;
break;
#ifdef HAVE_IN6_ADDR
case AF_INET6:
if (memcmp(ifp->addr.ip6.s6_addr, addr.ip6.s6_addr,
sizeof(addr.ip6.s6_addr)) == 0)
- return(TRUE);
+ return TRUE;
for (j = 0; j < sizeof(addr.ip6.s6_addr); j++) {
if ((ifp->addr.ip6.s6_addr[j] & ifp->netmask.ip6.s6_addr[j]) != addr.ip6.s6_addr[j])
break;
}
if (j == sizeof(addr.ip6.s6_addr))
- return(TRUE);
+ return TRUE;
#endif
}
}
- return(FALSE);
+ return FALSE;
}
static int
switch(family) {
case AF_INET:
if ((ifp->addr.ip4.s_addr & mask.ip4.s_addr) == addr.ip4.s_addr)
- return(TRUE);
+ return TRUE;
#ifdef HAVE_IN6_ADDR
case AF_INET6:
for (j = 0; j < sizeof(addr.ip6.s6_addr); j++) {
break;
}
if (j == sizeof(addr.ip6.s6_addr))
- return(TRUE);
+ return TRUE;
#endif /* HAVE_IN6_ADDR */
}
}
- return(FALSE);
+ return FALSE;
}
/*
} else
retval = addr_matches_if(n);
- return(retval);
+ return retval;
}
/*
{
if (has_meta(pattern)) {
if (strchr(pattern, '.'))
- return(!fnmatch(pattern, lhost, FNM_CASEFOLD));
+ return !fnmatch(pattern, lhost, FNM_CASEFOLD);
else
- return(!fnmatch(pattern, shost, FNM_CASEFOLD));
+ return !fnmatch(pattern, shost, FNM_CASEFOLD);
} else {
if (strchr(pattern, '.'))
- return(!strcasecmp(lhost, pattern));
+ return !strcasecmp(lhost, pattern);
else
- return(!strcasecmp(shost, pattern));
+ return !strcasecmp(shost, pattern);
}
}
if (pw != NULL && *sudoers_user == '#') {
uid_t uid = (uid_t) atoi(sudoers_user + 1);
if (uid == pw->pw_uid)
- return(TRUE);
+ return TRUE;
}
- return(strcmp(sudoers_user, user) == 0);
+ return strcmp(sudoers_user, user) == 0;
}
/*
if (*sudoers_group == '#') {
gid_t gid = (gid_t) atoi(sudoers_group + 1);
if (gid == gr->gr_gid)
- return(TRUE);
+ return TRUE;
}
- return(strcmp(gr->gr_name, sudoers_group) == 0);
+ return strcmp(gr->gr_name, sudoers_group) == 0;
}
/*
if (pw0 != NULL)
pw_delref(pw0);
- return(matched);
+ return matched;
}
/*
/* make sure we have a valid netgroup, sudo style */
if (*netgr++ != '+')
- return(FALSE);
+ return FALSE;
#ifdef HAVE_GETDOMAINNAME
/* get the domain name (if any) */
#ifdef HAVE_INNETGR
if (innetgr(netgr, lhost, user, domain))
- return(TRUE);
+ return TRUE;
else if (lhost != shost && innetgr(netgr, shost, user, domain))
- return(TRUE);
+ return TRUE;
#endif /* HAVE_INNETGR */
- return(FALSE);
+ return FALSE;
}
cp = (unsigned char *)s + n;
do {
if (*(--cp) == (unsigned char)c)
- return((void *)cp);
+ return (void *)cp;
} while (--n != 0);
}
- return((void *)0);
+ return (void *)0;
}
;
if (path + slen >= ep) {
errno = EINVAL;
- return(-1);
+ return -1;
}
ep -= slen;
fd = open(path, O_CREAT|O_EXCL|O_RDWR, S_IRUSR|S_IWUSR);
if (fd != -1 || errno != EEXIST)
- return(fd);
+ return fd;
} while (--tries);
errno = EEXIST;
- return(-1);
+ return -1;
}
#ifdef HAVE_RANDOM
initialized = 1;
}
- return(RAND() & 0xffffffff);
+ return RAND() & 0xffffffff;
}
fd = open(_PATH_DEV_SYSTRACE, O_RDONLY, 0644);
if (fd == -1)
- return(-1);
+ return -1;
serrno = errno;
#ifdef SYSTR_CLONE
if (fcntl(fd, F_SETFD, 1) == -1) /* really needed? */
goto bad;
- return(fd);
+ return fd;
bad:
close(fd);
errno = serrno;
- return(-1);
+ return -1;
}
static void
struct emulation *emul;
if ((entry = find_child(msgp->msg_pid)) == NULL)
- return(-1);
+ return -1;
for (emul = emulations; emul != NULL; emul++)
if (strcmp(emul->name, msgp->msg_data.msg_emul.emul) == 0) {
entry->action = emul->action;
- return(set_policy(fd, entry));
+ return set_policy(fd, entry);
}
- return(-1);
+ return -1;
}
/*
for (cur = children.first; cur != NULL; cur = cur->next) {
if (cur->pid == pid)
- return(cur);
+ return cur;
}
- return(NULL);
+ return NULL;
}
/*
pol.strp_num = -1;
pol.strp_maxents = SYSTRACE_MAXENTS;
if (ioctl(fd, STRIOCPOLICY, &pol) == -1)
- return(-1);
+ return -1;
pol.strp_op = SYSTR_POLICY_ASSIGN;
pol.strp_pid = child->pid;
if (ioctl(fd, STRIOCPOLICY, &pol) == -1)
- return(-1);
+ return -1;
for (i = 0; i < SYSTRACE_MAXENTS; i++) {
pol.strp_op = SYSTR_POLICY_MODIFY;
}
}
if (ioctl(fd, STRIOCPOLICY, &pol) == -1)
- return(-1);
+ return -1;
}
- return(0);
+ return 0;
}
/*
io.strio_op = SYSTR_READ;
if ((rval = ioctl(fd, STRIOCIO, &io)) != 0)
warning("systrace_read: STRIOCIO");
- return(rval ? -1 : (ssize_t)io.strio_len);
+ return rval ? -1 : (ssize_t)io.strio_len;
}
/*
bufsiz -= nread;
} else {
if (errno != EINVAL || chunksiz == 1)
- return(-1);
+ return -1;
chunksiz >>= 1; /* chunksiz too big, halve it */
}
}
if (cp == buf)
warningx("read empty string, chunksize == %d", chunksiz); /* XXX, should not happen but does */
#endif
- return(bufsiz >= chunksiz ? cp - buf : -1);
+ return bufsiz >= chunksiz ? cp - buf : -1;
}
static struct syscallhandler *
if ((child = find_child(pid)) == NULL) {
warningx("unable to find child with pid %d", pid);
- return(NULL);
+ return NULL;
}
for (sca = child->action; sca->code != -1; sca++) {
if (sca->code == code)
- return(&sca->handler);
+ return &sca->handler;
}
- return(NULL);
+ return NULL;
}
#define SUDO_USER 0
io.strio_op = SYSTR_WRITE;
if ((rval = ioctl(fd, STRIOCIO, &io)) != 0)
warning("systrace_write: STRIOCIO");
- return(rval ? -1 : (ssize_t)io.strio_len);
+ return rval ? -1 : (ssize_t)io.strio_len;
}
/*
envep = envbuf + (sizeof(envbuf) / sizeof(char *));
for (envp = envbuf; envp < envep; envp++, off += sizeof(char *)) {
if (systrace_read(fd, pid, off, &ap, sizeof(ap)) == -1)
- return(-1);
+ return -1;
if ((*envp = ap) == NULL)
break;
memset(buf, 0, sizeof(buf));
if ((len = read_string(fd, pid, ap, buf, sizeof(buf))) == -1)
- return(-1);
+ return -1;
if (buf[0] == 'S') {
if (strncmp(buf, "SUDO_USER=", 10) == 0) {
offsets[SUDO_USER] = off;
if (replace[SUDO_USER]) {
n = snprintf(cp, sizeof(buf) - (cp - buf), "SUDO_USER=%s", user_name);
if (n < 0 || n >= sizeof(buf) - (cp - buf))
- return(-1);
+ return -1;
replace[SUDO_USER] = cp;
cp += n + 1;
}
n = snprintf(cp, sizeof(buf) - (cp - buf), "SUDO_COMMAND=%s%s%s",
user_cmnd, user_args ? " " : "", user_args ? user_args : "");
if (n < 0 || n >= sizeof(buf) - (cp - buf))
- return(-1);
+ return -1;
replace[SUDO_COMMAND] = cp;
cp += n + 1;
}
n = snprintf(cp, sizeof(buf) - (cp - buf), "SUDO_UID=%lu",
(unsigned long) user_uid);
if (n < 0 || n >= sizeof(buf) - (cp - buf))
- return(-1);
+ return -1;
replace[SUDO_UID] = cp;
cp += n + 1;
}
n = snprintf(cp, sizeof(buf) - (cp - buf), "SUDO_GID=%lu",
(unsigned long) user_gid);
if (n < 0 || n >= sizeof(buf) - (cp - buf))
- return(-1);
+ return -1;
replace[SUDO_GID] = cp;
cp += n + 1;
}
inject.stri_addr = buf;
inject.stri_len = cp - buf;
if (ioctl(fd, STRIOCINJECT, &inject) != 0)
- return(-1);
+ return -1;
n = (offsets[SUDO_USER] == NULL) + (offsets[SUDO_COMMAND] == NULL) +
(offsets[SUDO_UID] == NULL) + (offsets[SUDO_GID] == NULL);
/*
continue;
ap = inject.stri_addr + (replace[n] - buf);
if (systrace_write(fd, pid, offsets[n], &ap, sizeof(ap)) == -1)
- return(-1);
+ return -1;
}
} else {
/*
*envp = inject.stri_addr + (replace[SUDO_GID] - buf);
}
if (envp + n >= envep)
- return(-1);
+ return -1;
if (offsets[SUDO_USER] == NULL)
*envp++ = inject.stri_addr + (replace[SUDO_USER] - buf);
if (offsets[SUDO_COMMAND] == NULL)
repl.strr_off[0] = 0;
repl.strr_offlen[0] = (char *)envp - (char *)envbuf;
if (ioctl(fd, STRIOCREPLACE, &repl) != 0)
- return(-1);
+ return -1;
}
}
- return(0);
+ return 0;
}
#endif /* STRIOCINJECT */
*/
memset(pbuf, 0, sizeof(pbuf));
if (read_string(fd, pid, (void *)askp->args[0], pbuf, sizeof(pbuf)) == -1)
- return(-1);
+ return -1;
if ((user_base = strrchr(user_cmnd = pbuf, '/')) != NULL)
user_base++;
else
off = (char *)askp->args[1];
for (cp = abuf, ep = abuf + sizeof(abuf); cp < ep; off += sizeof(char *)) {
if (systrace_read(fd, pid, off, &ap, sizeof(ap)) == -1)
- return(-1);
+ return -1;
if (ap == NULL)
break; /* end of args */
if (argc + 1 >= argc_max) {
argv = erealloc3(argv, argc_max, sizeof(char *));
}
if ((len = read_string(fd, pid, ap, cp, ep - cp)) == -1)
- return(-1);
+ return -1;
argv[argc++] = cp;
cp += len;
}
}
efree(argv);
- return(0);
+ return 0;
}
static void
if (initialized == 0) {
initialized = 1;
*policyp = SYSTR_POLICY_PERMIT;
- return(0);
+ return 0;
}
/* Failure should not be possible. */
if ((info = find_child(pid)) == NULL) {
*policyp = SYSTR_POLICY_NEVER;
*errorp = ECHILD;
- return(0);
+ return 0;
}
/* Fill in user_cmnd, user_base, user_args and user_stat. */
if (decode_args(fd, pid, askp) != 0) {
if (errno == EBUSY)
- return(-1);
+ return -1;
*policyp = SYSTR_POLICY_NEVER;
*errorp = errno;
- return(0);
+ return 0;
}
/* Get process cwd. */
rval = ioctl(fd, STRIOCGETCWD, &pid);
if (rval == -1 || getcwd(user_cwd, sizeof(user_cwd)) == NULL) {
if (rval == -1 && errno == EBUSY)
- return(-1);
+ return -1;
warningx("cannot get working directory");
(void) strlcpy(user_cwd, "unknown", sizeof(user_cwd));
}
warning("can't restore cwd");
*policyp = SYSTR_POLICY_NEVER;
*errorp = EACCES;
- return(0);
+ return 0;
}
if (rval != -1 && ioctl(fd, STRIOCRESCWD, 0) != 0)
warning("can't restore cwd");
*policyp = SYSTR_POLICY_NEVER;
*errorp = EACCES;
}
- return(validated);
+ return validated;
}
/*
rval = -1;
}
#endif
- return(rval);
+ return rval;
}
/*
rts->tv_sec = endtime.tv_sec;
rts->tv_nsec = endtime.tv_usec * 1000;
}
- return(rval);
+ return rval;
}
struct sudo_nss *nss;
{
if (def_ignore_local_sudoers)
- return(-1);
+ return -1;
nss->handle = open_sudoers(_PATH_SUDOERS, FALSE, NULL);
- return(nss->handle ? 0 : -1);
+ return nss->handle ? 0 : -1;
}
int
nss->handle = NULL;
yyin = NULL;
}
- return(0);
+ return 0;
}
/*
struct sudo_nss *nss;
{
if (nss->handle == NULL)
- return(-1);
+ return -1;
init_parser(_PATH_SUDOERS, 0);
yyin = nss->handle;
if (yyparse() != 0 || parse_error) {
log_error(NO_EXIT, "parse error in %s near line %d",
errorfile, errorlineno);
- return(-1);
+ return -1;
}
- return(0);
+ return 0;
}
/*
struct sudo_nss *nss;
{
if (nss->handle == NULL)
- return(-1);
+ return -1;
if (!update_defaults(SETDEF_GENERIC|SETDEF_HOST|SETDEF_USER))
- return(-1);
- return(0);
+ return -1;
+ return 0;
}
/*
struct userspec *us;
if (nss->handle == NULL)
- return(validated);
+ return validated;
/*
* Only check the actual command if pwflag is not set.
SET(validated, FLAG_CHECK_USER);
else if (pwcheck == never || nopass == TRUE)
def_authenticate = FALSE;
- return(validated);
+ return validated;
}
/* Need to be runas user while stat'ing things. */
CLR(validated, VALIDATE_OK);
}
set_perms(PERM_ROOT);
- return(validated);
+ return validated;
}
#define TAG_CHANGED(t) \
}
lbuf_append(lbuf, "\n", NULL);
}
- return(nfound);
+ return nfound;
}
static int
nfound++;
}
}
- return(nfound);
+ return nfound;
}
int
nfound += sudo_file_display_priv_short(pw, us, lbuf);
}
done:
- return(nfound);
+ return nfound;
}
/*
nfound++;
}
done:
- return(nfound);
+ return nfound;
}
/*
nfound += display_bound_defaults(DEFAULTS_RUNAS, lbuf);
nfound += display_bound_defaults(DEFAULTS_CMND, lbuf);
- return(nfound);
+ return nfound;
}
/*
dsep = "!";
break;
default:
- return(-1);
+ return -1;
}
/* printf("Per-%s Defaults entries:\n", dname); */
tq_foreach_fwd(&defaults, d) {
lbuf_append(lbuf, d->op == FALSE ? "!" : "", d->var, NULL);
}
- return(nfound);
+ return nfound;
}
int
rval = 0;
}
done:
- return(rval);
+ return rval;
}
/*
if (NewArgc == 0 && mode == MODE_RUN && !ISSET(flags, MODE_SHELL))
SET(flags, (MODE_IMPLIED_SHELL | MODE_SHELL));
- return(mode | flags);
+ return mode | flags;
}
static int
{
const struct cache_item *ci1 = (const struct cache_item *) v1;
const struct cache_item *ci2 = (const struct cache_item *) v2;
- return(ci1->k.uid - ci2->k.uid);
+ return ci1->k.uid - ci2->k.uid;
}
/*
{
const struct cache_item *ci1 = (const struct cache_item *) v1;
const struct cache_item *ci2 = (const struct cache_item *) v2;
- return(strcmp(ci1->k.name, ci2->k.name));
+ return strcmp(ci1->k.name, ci2->k.name);
}
#define FIELD_SIZE(src, name, size) \
/* Allocate space for struct item, struct passwd and the strings. */
if ((item = malloc(total)) == NULL)
- return(NULL);
+ return NULL;
cp = (char *) item + sizeof(struct cache_item);
/*
item->d.pw = newpw;
item->refcnt = 1;
- return(item);
+ return item;
}
void
#endif
done:
item->refcnt++;
- return(item->d.pw);
+ return item->d.pw;
}
/*
#endif
done:
item->refcnt++;
- return(item->d.pw);
+ return item->d.pw;
}
/*
}
}
item->refcnt++;
- return(pw);
+ return pw;
}
void
{
const struct cache_item *ci1 = (const struct cache_item *) v1;
const struct cache_item *ci2 = (const struct cache_item *) v2;
- return(ci1->k.gid - ci2->k.gid);
+ return ci1->k.gid - ci2->k.gid;
}
/*
total += strlen(name) + 1;
if ((item = malloc(total)) == NULL)
- return(NULL);
+ return NULL;
cp = (char *) item + sizeof(struct cache_item);
/*
item->d.gr = newgr;
item->refcnt = 1;
- return(item);
+ return item;
}
void
}
done:
item->refcnt++;
- return(item->d.gr);
+ return item->d.gr;
}
/*
}
done:
item->refcnt++;
- return(item->d.gr);
+ return item->d.gr;
}
/*
}
}
item->refcnt++;
- return(gr);
+ return gr;
}
void
done:
if (grp != NULL)
gr_delref(grp);
- return(retval);
+ return retval;
}
tree->root.color = black;
tree->root.data = NULL;
- return(tree);
+ return tree;
}
/*
while (node != rbnil(tree)) {
parent = node;
if ((res = tree->compar(data, node->data)) == 0)
- return(node);
+ return node;
node = res < 0 ? node->left : node->right;
}
}
}
rbfirst(tree)->color = black; /* first node is always black */
- return(NULL);
+ return NULL;
}
/*
while (node != rbnil(tree)) {
if ((res = tree->compar(key, node->data)) == 0)
- return(node);
+ return node;
node = res < 0 ? node->left : node->right;
}
- return(NULL);
+ return NULL;
}
/*
if (node != rbnil(tree)) {
if (order == preorder)
if ((error = func(node->data, cookie)) != 0)
- return(error);
+ return error;
if ((error = rbapply_node(tree, node->left, func, cookie, order)) != 0)
- return(error);
+ return error;
if (order == inorder)
if ((error = func(node->data, cookie)) != 0)
- return(error);
+ return error;
if ((error = rbapply_node(tree, node->right, func, cookie, order)) != 0)
- return(error);
+ return error;
if (order == postorder)
if ((error = func(node->data, cookie)) != 0)
- return(error);
+ return error;
}
- return (0);
+ return 0;
}
/*
if (succ == rbroot(tree))
succ = rbnil(tree);
}
- return(succ);
+ return succ;
}
/*
}
free(z);
- return (data);
+ return data;
}
/*
CLR(perm, PERM_MASK);
if (perm == current_perm)
- return(1);
+ return 1;
switch (perm) {
case PERM_ROOT:
}
current_perm = perm;
- return(1);
+ return 1;
bad:
warningx("%s: %s", errstr,
errno == EAGAIN ? "too many processes" : strerror(errno));
if (noexit)
- return(0);
+ return 0;
exit(1);
}
CLR(perm, PERM_MASK);
if (perm == current_perm)
- return(1);
+ return 1;
switch (perm) {
case PERM_ROOT:
}
current_perm = perm;
- return(1);
+ return 1;
bad:
warningx("%s: %s", errstr,
errno == EAGAIN ? "too many processes" : strerror(errno));
if (noexit)
- return(0);
+ return 0;
exit(1);
}
CLR(perm, PERM_MASK);
if (perm == current_perm)
- return(1);
+ return 1;
/*
* Since we only have setuid() and seteuid() and semantics
}
current_perm = perm;
- return(1);
+ return 1;
bad:
warningx("%s: %s", errstr,
errno == EAGAIN ? "too many processes" : strerror(errno));
if (noexit)
- return(0);
+ return 0;
exit(1);
}
CLR(perm, PERM_MASK);
if (perm == current_perm)
- return(1);
+ return 1;
switch (perm) {
case PERM_ROOT:
}
current_perm = perm;
- return(1);
+ return 1;
bad:
warningx("%s: %s", errstr,
errno == EAGAIN ? "too many processes" : strerror(errno));
if (noexit)
- return(0);
+ return 0;
exit(1);
}
# endif /* HAVE_SETEUID */
if (!error && osa)
osa->sa_flags ^= SV_INTERRUPT; /* flip SV_INTERRUPT as above */
- return(error);
+ return error;
}
int
{
*set = 0;
- return(0);
+ return 0;
}
int
{
*set = ~0;;
- return(0);
+ return 0;
}
int
if (signo <= 0 || signo >= NSIG) {
errno = EINVAL;
- return(-1);
+ return -1;
}
SET(*set, sigmask(signo));
- return(0);
+ return 0;
}
int
if (signo <= 0 || signo >= NSIG) {
errno = EINVAL;
- return(-1);
+ return -1;
}
CLR(*set, sigmask(signo));
- return(0);
+ return 0;
}
int
int signo;
{
- return(ISSET(*set, sigmask(signo)));
+ return ISSET(*set, sigmask(signo));
}
int
mask = sigsetmask(*set);
break;
default:
- return(-1);
+ return -1;
}
if (mask == -1)
- return(-1);
+ return -1;
if (oset)
*oset = mask;
- return(0);
+ return 0;
}
do {
if (*p++ == c)
- return ((void *)(p - 1));
+ return (void *)(p - 1);
} while (--n != 0);
}
- return (NULL);
+ return NULL;
}
#endif /* !HAVE_MEMCHR */
case 10:
if (val < 10) { /* many numbers are 1 digit */
*--cp = to_char(val);
- return (cp);
+ return cp;
}
/*
* On many machines, unsigned arithmetic is harder than
default: /* oops */
abort();
}
- return (cp);
+ return cp;
}
/* Identical to __ultoa, but for quads. */
/* quick test for small values; __ultoa is typically much faster */
/* (perhaps instead we should run until small, then call __ultoa?) */
if (val <= (unsigned long long)ULONG_MAX)
- return (__ultoa((unsigned long)val, endp, base, octzero, xdigs));
+ return __ultoa((unsigned long)val, endp, base, octzero, xdigs);
switch (base) {
case 10:
if (val < 10) {
*--cp = to_char(val % 10);
- return (cp);
+ return cp;
}
if (val > LLONG_MAX) {
*--cp = to_char(val % 10);
default: /* oops */
abort();
}
- return (cp);
+ return cp;
}
# endif /* !SIZEOF_LONG_INT */
#endif /* HAVE_LONG_LONG_INT */
done:
if (strsize)
*str = '\0';
- return (ret);
+ return ret;
/* NOTREACHED */
}
va_list ap;
{
- return (xxxprintf(&str, n, 0, fmt, ap));
+ return xxxprintf(&str, n, 0, fmt, ap);
}
#endif /* HAVE_VSNPRINTF */
#endif
ret = xxxprintf(&str, n, 0, fmt, ap);
va_end(ap);
- return (ret);
+ return ret;
}
#endif /* HAVE_SNPRINTF */
va_list ap;
{
- return (xxxprintf(str, 0, 1, fmt, ap));
+ return xxxprintf(str, 0, 1, fmt, ap);
}
#endif /* HAVE_VASPRINTF */
#endif
ret = xxxprintf(str, 0, 1, fmt, ap);
va_end(ap);
- return (ret);
+ return ret;
}
#endif /* HAVE_ASPRINTF */
extern char *sys_errlist[];
if (n > 0 && n < sys_nerr)
- return(sys_errlist[n]);
+ return sys_errlist[n];
errno = EINVAL;
- return("Unknown error");
+ return "Unknown error";
}
n = siz - dlen;
if (n == 0)
- return(dlen + strlen(s));
+ return dlen + strlen(s);
while (*s != '\0') {
if (n != 1) {
*d++ = *s;
}
*d = '\0';
- return(dlen + (s - src)); /* count does not include NUL */
+ return dlen + (s - src); /* count does not include NUL */
}
;
}
- return(s - src - 1); /* count does not include NUL */
+ return s - src - 1; /* count does not include NUL */
}
int signo;
{
if (signo > 0 && signo < NSIG)
- return((char *)my_sys_siglist[signo]);
- return("Unknown signal");
+ return (char *)my_sys_siglist[signo];
+ return "Unknown signal";
}
if (!runas_user && !runas_group)
set_runaspw(def_runas_default); /* may have been updated above */
- return(rval);
+ return rval;
}
/*
rval = TRUE;
done:
- return(rval);
+ return rval;
}
/*
pw_delref(runas_pw);
if (runas_gr != NULL)
gr_delref(runas_gr);
- return(exitcode);
+ return exitcode;
}
/*
}
set_perms(PERM_ROOT); /* change back to root */
- return(fp);
+ return fp;
}
/*
#define DUMMY_BODY \
{ \
errno = EACCES; \
- return(-1); \
+ return -1; \
}
#ifdef __STDC__
if (tq_empty(&snl))
tq_append(&snl, &sudo_nss_file);
- return(&snl);
+ return &snl;
}
#else /* HAVE_LDAP && _PATH_NSSWITCH_CONF */
if (tq_empty(&snl))
tq_append(&snl, &sudo_nss_file);
- return(&snl);
+ return &snl;
}
# else /* !_PATH_NETSVC_CONF && !_PATH_NSSWITCH_CONF */
# endif
tq_append(&snl, &sudo_nss_file);
- return(&snl);
+ return &snl;
}
# endif /* !HAVE_LDAP || !_PATH_NETSVC_CONF */
tq_foreach_fwd(snl, nss) {
if (nss->display_cmnd(nss, pw) == 0)
- return(0);
+ return 0;
}
- return(1);
+ return 1;
}
errorx(1, "unmatched ')' in expression");
if (node_stack[stack_top])
sn->next = node_stack[stack_top]->next;
- return(av - argv + 1);
+ return av - argv + 1;
bad:
default:
errorx(1, "unknown search term \"%s\"", *av);
if (not)
errorx(1, "illegal trailing \"!\"");
- return(av - argv);
+ return av - argv;
}
static int
if (sn->negated)
matched = !matched;
}
- return(matched);
+ return matched;
}
static int
d = opendir(pathbuf);
if (d == NULL && errno != ENOTDIR) {
warning("cannot opendir %s", pathbuf);
- return(-1);
+ return -1;
}
while ((dp = readdir(d)) != NULL) {
if (NAMLEN(dp) != 2 || !isalnum((unsigned char)dp->d_name[0]) ||
printf("GROUP=%s ; ", li.runas_group);
printf("TSID=%s ; COMMAND=%s\n", idstr, li.cmd);
}
- return(0);
+ return 0;
}
static int
closedir(d2);
}
closedir(d1);
- return(0);
+ return 0;
}
/*
int flags = TCSASOFT;
flags |= flush ? TCSAFLUSH : TCSADRAIN;
if (tcsetattr(fd, flags, &oterm) != 0)
- return(0);
+ return 0;
changed = 0;
}
- return(1);
+ return 1;
}
int
int fd;
{
if (!changed && tcgetattr(fd, &oterm) != 0)
- return(0);
+ return 0;
(void) memcpy(&term, &oterm, sizeof(term));
CLR(term.c_lflag, ECHO|ECHONL);
#ifdef VSTATUS
#endif
if (tcsetattr(fd, TCSADRAIN|TCSASOFT, &term) == 0) {
changed = 1;
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
#if defined(HAVE_TERMIOS_H) || defined(HAVE_TERMIO_H)
struct termios term;
if (!changed && tcgetattr(fd, &oterm) != 0)
- return(0);
+ return 0;
(void) memcpy(&term, &oterm, sizeof(term));
/* Set terminal to raw mode */
term.c_cc[VMIN] = 1;
SET(term.c_lflag, ISIG);
if (tcsetattr(fd, TCSADRAIN|TCSASOFT, &term) == 0) {
changed = 1;
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
int
int fd;
{
if (!changed && tcgetattr(fd, &oterm) != 0)
- return(0);
+ return 0;
(void) memcpy(&term, &oterm, sizeof(term));
/* Set terminal to half-cooked mode */
term.c_cc[VMIN] = 1;
term_erase = term.c_cc[VERASE];
term_kill = term.c_cc[VKILL];
changed = 1;
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
int
struct termios tt;
if (tcgetattr(src, &tt) != 0)
- return(0);
+ return 0;
/* XXX - add TCSANOW compat define */
if (tcsetattr(dst, TCSANOW|TCSASOFT, &tt) != 0)
- return(0);
- return(1);
+ return 0;
+ return 1;
}
#else /* SGTTY */
int isig;
{
if (!changed && ioctl(fd, TIOCGETP, &oterm) != 0)
- return(0);
+ return 0;
(void) memcpy(&term, &oterm, sizeof(term));
/* Set terminal to raw mode */
/* XXX - how to support isig? */
SET(term.sg_flags, RAW);
if (ioctl(fd, TIOCSETP, &term) == 0) {
changed = 1;
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
int
int fd;
{
if (!changed && ioctl(fd, TIOCGETP, &oterm) != 0)
- return(0);
+ return 0;
(void) memcpy(&term, &oterm, sizeof(term));
/* Set terminal to half-cooked mode */
CLR(term.c_lflag, ECHO);
term_erase = term.sg_erase;
term_kill = term.sg_kill;
changed = 1;
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
int
if (ioctl(src, TIOCGETP, &b) != 0 || ioctl(src, TIOCGETC, &tc) != 0 ||
ioctl(src, TIOCGETD, &l) != 0 || ioctl(src, TIOCGLTC, &lc) != 0 ||
ioctl(src, TIOCLGET, &lb)) {
- return(0);
+ return 0;
}
if (ioctl(dst, TIOCSETP, &b) != 0 || ioctl(dst, TIOCSETC, &tc) != 0 ||
ioctl(dst, TIOCSLTC, &lc) != 0 || ioctl(dst, TIOCLSET, &lb) != 0 ||
ioctl(dst, TIOCSETD, &l) != 0) {
- return(0);
+ return 0;
}
- return(1);
+ return 1;
}
#endif
sudo_getepw(pw)
const struct passwd *pw;
{
- return (pw->pw_passwd);
+ return pw->pw_passwd;
}
void
int isdir;
int *keepopen;
{
- return(fopen(path, "r"));
+ return fopen(path, "r");
}
void
set_perms(perm)
int perm;
{
- return(1);
+ return 1;
}
void
fputs(m->name, stdout);
}
putchar('\n');
- return(0);
+ return 0;
}
void
/* If using a helper program to get the password, run it instead. */
if (ISSET(flags, TGP_ASKPASS) && user_askpass)
- return(sudo_askpass(prompt));
+ return sudo_askpass(prompt);
restart:
for (i = 0; i < NSIG; i++)
if (save_errno)
errno = save_errno;
- return(pass);
+ return pass;
}
/*
(void) close(pfd[0]);
(void) sigaction(SIGPIPE, &saved_sa_pipe, NULL);
- return(pass);
+ return pass;
}
extern int term_erase, term_kill;
if (left == 0) {
errno = EINVAL;
- return(NULL); /* sanity */
+ return NULL; /* sanity */
}
while (--left) {
}
}
- return(nr == 1 ? buf : NULL);
+ return nr == 1 ? buf : NULL;
}
static void
if ((fd = open(_PATH_TTY, O_RDWR|O_NOCTTY)) != -1)
close(fd);
- return(fd != -1);
+ return fd != -1;
}
/* strftime() does not guarantee to NUL-terminate so we must check. */
buf[sizeof(buf) - 1] = '\0';
if (strftime(buf, sizeof(buf), s, timeptr) && buf[sizeof(buf) - 1] == '\0')
- return(buf);
+ return buf;
#endif /* HAVE_STRFTIME */
else
s[15] = '\0'; /* don't care about year */
- return(s);
+ return s;
}
LEXTRACE("DEFVAR ");
if (!fill(yytext, yyleng))
yyterminate();
- return(DEFVAR);
+ return DEFVAR;
}
YY_BREAK
{
BEGIN STARTDEFS;
LEXTRACE(", ");
- return(',');
+ return ',';
} /* return ',' */
YY_BREAK
case 4:
#line 146 "toke.l"
{
LEXTRACE("= ");
- return('=');
+ return '=';
} /* return '=' */
YY_BREAK
case 5:
#line 151 "toke.l"
{
LEXTRACE("+= ");
- return('+');
+ return '+';
} /* return '+' */
YY_BREAK
case 6:
#line 156 "toke.l"
{
LEXTRACE("-= ");
- return('-');
+ return '-';
} /* return '-' */
YY_BREAK
case 7:
LEXTRACE("WORD(2) ");
if (!fill(yytext, yyleng))
yyterminate();
- return(WORD);
+ return WORD;
}
YY_BREAK
{
LEXTRACE("ENDSTR ");
BEGIN INDEFS;
- return(WORD);
+ return WORD;
}
YY_BREAK
case 11:
{
BEGIN INITIAL;
yyless(0);
- return(COMMAND);
+ return COMMAND;
} /* end of command line args */
YY_BREAK
case 16:
case ':':
yyless(n);
LEXTRACE("DEFAULTS_USER ");
- return(DEFAULTS_USER);
+ return DEFAULTS_USER;
case '>':
yyless(n);
LEXTRACE("DEFAULTS_RUNAS ");
- return(DEFAULTS_RUNAS);
+ return DEFAULTS_RUNAS;
case '@':
yyless(n);
LEXTRACE("DEFAULTS_HOST ");
- return(DEFAULTS_HOST);
+ return DEFAULTS_HOST;
case '!':
yyless(n);
LEXTRACE("DEFAULTS_CMND ");
- return(DEFAULTS_CMND);
+ return DEFAULTS_CMND;
default:
LEXTRACE("DEFAULTS ");
- return(DEFAULTS);
+ return DEFAULTS;
}
}
YY_BREAK
switch (yytext[n]) {
case 'H':
LEXTRACE("HOSTALIAS ");
- return(HOSTALIAS);
+ return HOSTALIAS;
case 'C':
LEXTRACE("CMNDALIAS ");
- return(CMNDALIAS);
+ return CMNDALIAS;
case 'U':
LEXTRACE("USERALIAS ");
- return(USERALIAS);
+ return USERALIAS;
case 'R':
LEXTRACE("RUNASALIAS ");
- return(RUNASALIAS);
+ return RUNASALIAS;
}
}
YY_BREAK
{
/* cmnd does not require passwd for this user */
LEXTRACE("NOPASSWD ");
- return(NOPASSWD);
+ return NOPASSWD;
}
YY_BREAK
case 22:
{
/* cmnd requires passwd for this user */
LEXTRACE("PASSWD ");
- return(PASSWD);
+ return PASSWD;
}
YY_BREAK
case 23:
#line 322 "toke.l"
{
LEXTRACE("NOEXEC ");
- return(NOEXEC);
+ return NOEXEC;
}
YY_BREAK
case 24:
#line 327 "toke.l"
{
LEXTRACE("EXEC ");
- return(EXEC);
+ return EXEC;
}
YY_BREAK
case 25:
#line 332 "toke.l"
{
LEXTRACE("SETENV ");
- return(SETENV);
+ return SETENV;
}
YY_BREAK
case 26:
#line 337 "toke.l"
{
LEXTRACE("NOSETENV ");
- return(NOSETENV);
+ return NOSETENV;
}
YY_BREAK
case 27:
#line 342 "toke.l"
{
LEXTRACE("LOG_OUTPUT ");
- return(LOG_OUTPUT);
+ return LOG_OUTPUT;
}
YY_BREAK
case 28:
#line 347 "toke.l"
{
LEXTRACE("NOLOG_OUTPUT ");
- return(NOLOG_OUTPUT);
+ return NOLOG_OUTPUT;
}
YY_BREAK
case 29:
#line 352 "toke.l"
{
LEXTRACE("LOG_INPUT ");
- return(LOG_INPUT);
+ return LOG_INPUT;
}
YY_BREAK
case 30:
#line 357 "toke.l"
{
LEXTRACE("NOLOG_INPUT ");
- return(NOLOG_INPUT);
+ return NOLOG_INPUT;
}
YY_BREAK
case 31:
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("NETGROUP ");
- return(NETGROUP);
+ return NETGROUP;
}
YY_BREAK
case 32:
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("USERGROUP ");
- return(USERGROUP);
+ return USERGROUP;
}
YY_BREAK
case 33:
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("NTWKADDR ");
- return(NTWKADDR);
+ return NTWKADDR;
}
YY_BREAK
case 34:
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("NTWKADDR ");
- return(NTWKADDR);
+ return NTWKADDR;
}
YY_BREAK
case 35:
{
if (!ipv6_valid(yytext)) {
LEXTRACE("ERROR ");
- return(ERROR);
+ return ERROR;
}
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("NTWKADDR ");
- return(NTWKADDR);
+ return NTWKADDR;
}
YY_BREAK
case 36:
{
if (!ipv6_valid(yytext)) {
LEXTRACE("ERROR ");
- return(ERROR);
+ return ERROR;
}
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("NTWKADDR ");
- return(NTWKADDR);
+ return NTWKADDR;
}
YY_BREAK
case 37:
{
if (strcmp(yytext, "ALL") == 0) {
LEXTRACE("ALL ");
- return(ALL);
+ return ALL;
}
#ifdef HAVE_SELINUX
/* XXX - restrict type/role to initial state */
if (strcmp(yytext, "TYPE") == 0) {
LEXTRACE("TYPE ");
- return(TYPE);
+ return TYPE;
}
if (strcmp(yytext, "ROLE") == 0) {
LEXTRACE("ROLE ");
- return(ROLE);
+ return ROLE;
}
#endif /* HAVE_SELINUX */
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("ALIAS ");
- return(ALIAS);
+ return ALIAS;
}
YY_BREAK
case 38:
if (!fill_cmnd(yytext, yyleng))
yyterminate();
LEXTRACE("COMMAND ");
- return(COMMAND);
+ return COMMAND;
}
YY_BREAK
case 39:
LEXTRACE("COMMAND ");
if (!fill_cmnd(yytext, yyleng))
yyterminate();
- return(COMMAND);
+ return COMMAND;
} else {
BEGIN GOTCMND;
LEXTRACE("COMMAND ");
switch (yytext[1]) {
case '%':
LEXTRACE("USERGROUP ");
- return(USERGROUP);
+ return USERGROUP;
case '+':
LEXTRACE("NETGROUP ");
- return(NETGROUP);
+ return NETGROUP;
default:
LEXTRACE("WORD(4) ");
- return(WORD);
+ return WORD;
}
}
YY_BREAK
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("WORD(5) ");
- return(WORD);
+ return WORD;
}
YY_BREAK
case 43:
#line 491 "toke.l"
{
LEXTRACE("( ");
- return ('(');
+ return '(';
}
YY_BREAK
case 44:
#line 496 "toke.l"
{
LEXTRACE(") ");
- return(')');
+ return ')';
}
YY_BREAK
case 45:
#line 501 "toke.l"
{
LEXTRACE(", ");
- return(',');
+ return ',';
} /* return ',' */
YY_BREAK
case 46:
#line 506 "toke.l"
{
LEXTRACE("= ");
- return('=');
+ return '=';
} /* return '=' */
YY_BREAK
case 47:
#line 511 "toke.l"
{
LEXTRACE(": ");
- return(':');
+ return ':';
} /* return ':' */
YY_BREAK
case 48:
#line 516 "toke.l"
{
if (yyleng % 2 == 1)
- return('!'); /* return '!' */
+ return '!'; /* return '!' */
}
YY_BREAK
case 49:
BEGIN INITIAL;
++sudolineno;
LEXTRACE("\n");
- return(COMMENT);
+ return COMMENT;
} /* return newline */
YY_BREAK
case 50:
BEGIN INITIAL;
++sudolineno;
LEXTRACE("\n");
- return(COMMENT);
+ return COMMENT;
} /* comment, not uid/gid */
YY_BREAK
case 53:
#line 545 "toke.l"
{
LEXTRACE("ERROR ");
- return(ERROR);
+ return ERROR;
} /* parse error */
YY_BREAK
case YY_STATE_EOF(INITIAL):
if (YY_START != INITIAL) {
BEGIN INITIAL;
LEXTRACE("ERROR ");
- return(ERROR);
+ return ERROR;
}
if (!pop_include())
yyterminate();
s++;
}
}
- return((unsigned char)result);
+ return (unsigned char)result;
}
static int
dst = olen ? realloc(yylval.string, olen + len + 1) : malloc(len + 1);
if (dst == NULL) {
yyerror("unable to allocate memory");
- return(FALSE);
+ return FALSE;
}
yylval.string = dst;
}
}
*dst = '\0';
- return(TRUE);
+ return TRUE;
}
static int
if (yylval.string != NULL)
olen = strlen(yylval.string);
- return(_fill(src, len, olen));
+ return _fill(src, len, olen);
}
#define SPECIAL(c) \
dst = yylval.command.cmnd = (char *) malloc(len + 1);
if (yylval.command.cmnd == NULL) {
yyerror("unable to allocate memory");
- return(FALSE);
+ return FALSE;
}
/* Copy the string and collapse any escaped sudo-specific characters. */
*dst = '\0';
yylval.command.args = NULL;
- return(TRUE);
+ return TRUE;
}
static int
if (p == NULL) {
efree(yylval.command.args);
yyerror("unable to allocate memory");
- return(FALSE);
+ return FALSE;
} else
yylval.command.args = p;
}
*p++ = ' ';
if (strlcpy(p, s, arg_size - (p - yylval.command.args)) != len) {
yyerror("fill_args: buffer overflow"); /* paranoia */
- return(FALSE);
+ return FALSE;
}
arg_len = new_len;
- return(TRUE);
+ return TRUE;
}
struct path_list {
const struct path_list * const *p1 = v1;
const struct path_list * const *p2 = v2;
- return(strcmp((*p1)->path, (*p2)->path));
+ return strcmp((*p1)->path, (*p2)->path);
}
static char *
if (!(dir = opendir(dirpath))) {
yyerror(dirpath);
- return(NULL);
+ return NULL;
}
while ((dent = readdir(dir))) {
/* Ignore files that end in '~' or have a '.' in them. */
}
done:
efree(dirpath);
- return(path);
+ return path;
bad:
while (first != NULL) {
pl = first;
efree(sorted);
efree(dirpath);
efree(path);
- return(NULL);
+ return NULL;
}
#define MAX_SUDOERS_DEPTH 128
if (idepth >= istacksize) {
if (idepth > MAX_SUDOERS_DEPTH) {
yyerror("too many levels of includes");
- return(FALSE);
+ return FALSE;
}
istacksize += SUDOERS_STACK_INCREMENT;
istack = (struct include_stack *) realloc(istack,
sizeof(*istack) * istacksize);
if (istack == NULL) {
yyerror("unable to allocate memory");
- return(FALSE);
+ return FALSE;
}
}
if (isdir) {
if (!(path = switch_dir(&istack[idepth], path))) {
/* switch_dir() called yyerror() for us */
- return(FALSE);
+ return FALSE;
}
while ((fp = open_sudoers(path, FALSE, &keepopen)) == NULL) {
/* Unable to open path in includedir, go to next one, if any. */
efree(path);
if ((pl = istack[idepth].more) == NULL)
- return(FALSE);
+ return FALSE;
path = pl->path;
istack[idepth].more = pl->next;
efree(pl);
} else {
if ((fp = open_sudoers(path, TRUE, &keepopen)) == NULL) {
yyerror(path);
- return(FALSE);
+ return FALSE;
}
istack[idepth].more = NULL;
}
sudoers = path;
yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
- return(TRUE);
+ return TRUE;
}
static int
FILE *fp;
if (idepth == 0)
- return(FALSE);
+ return FALSE;
if (!keepopen)
fclose(YY_CURRENT_BUFFER->yy_input_file);
sudolineno = istack[idepth].lineno;
keepopen = istack[idepth].keepopen;
}
- return(TRUE);
+ return TRUE;
}
static char *
if (*ep != '\0')
yyless((int)(ep - base));
- return(path);
+ return path;
}
/*
nmatch = 0; /* reset if we hit netmask */
}
- return (nmatch <= 1);
+ return nmatch <= 1;
}
LEXTRACE("DEFVAR ");
if (!fill(yytext, yyleng))
yyterminate();
- return(DEFVAR);
+ return DEFVAR;
}
<INDEFS>{
, {
BEGIN STARTDEFS;
LEXTRACE(", ");
- return(',');
+ return ',';
} /* return ',' */
= {
LEXTRACE("= ");
- return('=');
+ return '=';
} /* return '=' */
\+= {
LEXTRACE("+= ");
- return('+');
+ return '+';
} /* return '+' */
-= {
LEXTRACE("-= ");
- return('-');
+ return '-';
} /* return '-' */
\" {
LEXTRACE("WORD(2) ");
if (!fill(yytext, yyleng))
yyterminate();
- return(WORD);
+ return WORD;
}
}
\" {
LEXTRACE("ENDSTR ");
BEGIN INDEFS;
- return(WORD);
+ return WORD;
}
\\ {
[#:\,=\n] {
BEGIN INITIAL;
yyless(0);
- return(COMMAND);
+ return COMMAND;
} /* end of command line args */
[^#\\:, \t\n]+ {
case ':':
yyless(n);
LEXTRACE("DEFAULTS_USER ");
- return(DEFAULTS_USER);
+ return DEFAULTS_USER;
case '>':
yyless(n);
LEXTRACE("DEFAULTS_RUNAS ");
- return(DEFAULTS_RUNAS);
+ return DEFAULTS_RUNAS;
case '@':
yyless(n);
LEXTRACE("DEFAULTS_HOST ");
- return(DEFAULTS_HOST);
+ return DEFAULTS_HOST;
case '!':
yyless(n);
LEXTRACE("DEFAULTS_CMND ");
- return(DEFAULTS_CMND);
+ return DEFAULTS_CMND;
default:
LEXTRACE("DEFAULTS ");
- return(DEFAULTS);
+ return DEFAULTS;
}
}
switch (yytext[n]) {
case 'H':
LEXTRACE("HOSTALIAS ");
- return(HOSTALIAS);
+ return HOSTALIAS;
case 'C':
LEXTRACE("CMNDALIAS ");
- return(CMNDALIAS);
+ return CMNDALIAS;
case 'U':
LEXTRACE("USERALIAS ");
- return(USERALIAS);
+ return USERALIAS;
case 'R':
LEXTRACE("RUNASALIAS ");
- return(RUNASALIAS);
+ return RUNASALIAS;
}
}
NOPASSWD[[:blank:]]*: {
/* cmnd does not require passwd for this user */
LEXTRACE("NOPASSWD ");
- return(NOPASSWD);
+ return NOPASSWD;
}
PASSWD[[:blank:]]*: {
/* cmnd requires passwd for this user */
LEXTRACE("PASSWD ");
- return(PASSWD);
+ return PASSWD;
}
NOEXEC[[:blank:]]*: {
LEXTRACE("NOEXEC ");
- return(NOEXEC);
+ return NOEXEC;
}
EXEC[[:blank:]]*: {
LEXTRACE("EXEC ");
- return(EXEC);
+ return EXEC;
}
SETENV[[:blank:]]*: {
LEXTRACE("SETENV ");
- return(SETENV);
+ return SETENV;
}
NOSETENV[[:blank:]]*: {
LEXTRACE("NOSETENV ");
- return(NOSETENV);
+ return NOSETENV;
}
LOG_OUTPUT[[:blank:]]*: {
LEXTRACE("LOG_OUTPUT ");
- return(LOG_OUTPUT);
+ return LOG_OUTPUT;
}
NOLOG_OUTPUT[[:blank:]]*: {
LEXTRACE("NOLOG_OUTPUT ");
- return(NOLOG_OUTPUT);
+ return NOLOG_OUTPUT;
}
LOG_INPUT[[:blank:]]*: {
LEXTRACE("LOG_INPUT ");
- return(LOG_INPUT);
+ return LOG_INPUT;
}
NOLOG_INPUT[[:blank:]]*: {
LEXTRACE("NOLOG_INPUT ");
- return(NOLOG_INPUT);
+ return NOLOG_INPUT;
}
\+{WORD} {
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("NETGROUP ");
- return(NETGROUP);
+ return NETGROUP;
}
\%:?{WORD} {
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("USERGROUP ");
- return(USERGROUP);
+ return USERGROUP;
}
{IPV4ADDR}(\/{IPV4ADDR})? {
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("NTWKADDR ");
- return(NTWKADDR);
+ return NTWKADDR;
}
{IPV4ADDR}\/([12][0-9]*|3[0-2]*) {
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("NTWKADDR ");
- return(NTWKADDR);
+ return NTWKADDR;
}
{IPV6ADDR}(\/{IPV6ADDR})? {
if (!ipv6_valid(yytext)) {
LEXTRACE("ERROR ");
- return(ERROR);
+ return ERROR;
}
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("NTWKADDR ");
- return(NTWKADDR);
+ return NTWKADDR;
}
{IPV6ADDR}\/([0-9]|[1-9][0-9]|1[01][0-9]|12[0-8]) {
if (!ipv6_valid(yytext)) {
LEXTRACE("ERROR ");
- return(ERROR);
+ return ERROR;
}
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("NTWKADDR ");
- return(NTWKADDR);
+ return NTWKADDR;
}
[[:upper:]][[:upper:][:digit:]_]* {
if (strcmp(yytext, "ALL") == 0) {
LEXTRACE("ALL ");
- return(ALL);
+ return ALL;
}
#ifdef HAVE_SELINUX
/* XXX - restrict type/role to initial state */
if (strcmp(yytext, "TYPE") == 0) {
LEXTRACE("TYPE ");
- return(TYPE);
+ return TYPE;
}
if (strcmp(yytext, "ROLE") == 0) {
LEXTRACE("ROLE ");
- return(ROLE);
+ return ROLE;
}
#endif /* HAVE_SELINUX */
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("ALIAS ");
- return(ALIAS);
+ return ALIAS;
}
<GOTDEFS>({PATH}|sudoedit) {
if (!fill_cmnd(yytext, yyleng))
yyterminate();
LEXTRACE("COMMAND ");
- return(COMMAND);
+ return COMMAND;
}
sudoedit {
LEXTRACE("COMMAND ");
if (!fill_cmnd(yytext, yyleng))
yyterminate();
- return(COMMAND);
+ return COMMAND;
} else {
BEGIN GOTCMND;
LEXTRACE("COMMAND ");
switch (yytext[1]) {
case '%':
LEXTRACE("USERGROUP ");
- return(USERGROUP);
+ return USERGROUP;
case '+':
LEXTRACE("NETGROUP ");
- return(NETGROUP);
+ return NETGROUP;
default:
LEXTRACE("WORD(4) ");
- return(WORD);
+ return WORD;
}
}
if (!fill(yytext, yyleng))
yyterminate();
LEXTRACE("WORD(5) ");
- return(WORD);
+ return WORD;
}
\( {
LEXTRACE("( ");
- return ('(');
+ return '(';
}
\) {
LEXTRACE(") ");
- return(')');
+ return ')';
}
, {
LEXTRACE(", ");
- return(',');
+ return ',';
} /* return ',' */
= {
LEXTRACE("= ");
- return('=');
+ return '=';
} /* return '=' */
: {
LEXTRACE(": ");
- return(':');
+ return ':';
} /* return ':' */
<*>!+ {
if (yyleng % 2 == 1)
- return('!'); /* return '!' */
+ return '!'; /* return '!' */
}
<*>\n {
BEGIN INITIAL;
++sudolineno;
LEXTRACE("\n");
- return(COMMENT);
+ return COMMENT;
} /* return newline */
<*>[[:blank:]]+ { /* throw away space/tabs */
BEGIN INITIAL;
++sudolineno;
LEXTRACE("\n");
- return(COMMENT);
+ return COMMENT;
} /* comment, not uid/gid */
<*>. {
LEXTRACE("ERROR ");
- return(ERROR);
+ return ERROR;
} /* parse error */
<*><<EOF>> {
if (YY_START != INITIAL) {
BEGIN INITIAL;
LEXTRACE("ERROR ");
- return(ERROR);
+ return ERROR;
}
if (!pop_include())
yyterminate();
s++;
}
}
- return((unsigned char)result);
+ return (unsigned char)result;
}
static int
dst = olen ? realloc(yylval.string, olen + len + 1) : malloc(len + 1);
if (dst == NULL) {
yyerror("unable to allocate memory");
- return(FALSE);
+ return FALSE;
}
yylval.string = dst;
}
}
*dst = '\0';
- return(TRUE);
+ return TRUE;
}
static int
if (yylval.string != NULL)
olen = strlen(yylval.string);
- return(_fill(src, len, olen));
+ return _fill(src, len, olen);
}
#define SPECIAL(c) \
dst = yylval.command.cmnd = (char *) malloc(len + 1);
if (yylval.command.cmnd == NULL) {
yyerror("unable to allocate memory");
- return(FALSE);
+ return FALSE;
}
/* Copy the string and collapse any escaped sudo-specific characters. */
*dst = '\0';
yylval.command.args = NULL;
- return(TRUE);
+ return TRUE;
}
static int
if (p == NULL) {
efree(yylval.command.args);
yyerror("unable to allocate memory");
- return(FALSE);
+ return FALSE;
} else
yylval.command.args = p;
}
*p++ = ' ';
if (strlcpy(p, s, arg_size - (p - yylval.command.args)) != len) {
yyerror("fill_args: buffer overflow"); /* paranoia */
- return(FALSE);
+ return FALSE;
}
arg_len = new_len;
- return(TRUE);
+ return TRUE;
}
struct path_list {
const struct path_list * const *p1 = v1;
const struct path_list * const *p2 = v2;
- return(strcmp((*p1)->path, (*p2)->path));
+ return strcmp((*p1)->path, (*p2)->path);
}
static char *
if (!(dir = opendir(dirpath))) {
yyerror(dirpath);
- return(NULL);
+ return NULL;
}
while ((dent = readdir(dir))) {
/* Ignore files that end in '~' or have a '.' in them. */
}
done:
efree(dirpath);
- return(path);
+ return path;
bad:
while (first != NULL) {
pl = first;
efree(sorted);
efree(dirpath);
efree(path);
- return(NULL);
+ return NULL;
}
#define MAX_SUDOERS_DEPTH 128
if (idepth >= istacksize) {
if (idepth > MAX_SUDOERS_DEPTH) {
yyerror("too many levels of includes");
- return(FALSE);
+ return FALSE;
}
istacksize += SUDOERS_STACK_INCREMENT;
istack = (struct include_stack *) realloc(istack,
sizeof(*istack) * istacksize);
if (istack == NULL) {
yyerror("unable to allocate memory");
- return(FALSE);
+ return FALSE;
}
}
if (isdir) {
if (!(path = switch_dir(&istack[idepth], path))) {
/* switch_dir() called yyerror() for us */
- return(FALSE);
+ return FALSE;
}
while ((fp = open_sudoers(path, FALSE, &keepopen)) == NULL) {
/* Unable to open path in includedir, go to next one, if any. */
efree(path);
if ((pl = istack[idepth].more) == NULL)
- return(FALSE);
+ return FALSE;
path = pl->path;
istack[idepth].more = pl->next;
efree(pl);
} else {
if ((fp = open_sudoers(path, TRUE, &keepopen)) == NULL) {
yyerror(path);
- return(FALSE);
+ return FALSE;
}
istack[idepth].more = NULL;
}
sudoers = path;
yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
- return(TRUE);
+ return TRUE;
}
static int
FILE *fp;
if (idepth == 0)
- return(FALSE);
+ return FALSE;
if (!keepopen)
fclose(YY_CURRENT_BUFFER->yy_input_file);
sudolineno = istack[idepth].lineno;
keepopen = istack[idepth].keepopen;
}
- return(TRUE);
+ return TRUE;
}
static char *
if (*ep != '\0')
yyless((int)(ep - base));
- return(path);
+ return path;
}
/*
nmatch = 0; /* reset if we hit netmask */
}
- return (nmatch <= 1);
+ return nmatch <= 1;
}
char *cp, *colon;
if ((colon = fgets(pwbuf, sizeof(pwbuf), pwf)) == NULL)
- return(NULL);
+ return NULL;
zero_bytes(&pw, sizeof(pw));
if ((colon = strchr(cp = colon, ':')) == NULL)
- return(NULL);
+ return NULL;
*colon++ = '\0';
pw.pw_name = cp;
if ((colon = strchr(cp = colon, ':')) == NULL)
- return(NULL);
+ return NULL;
*colon++ = '\0';
pw.pw_passwd = cp;
if ((colon = strchr(cp = colon, ':')) == NULL)
- return(NULL);
+ return NULL;
*colon++ = '\0';
pw.pw_uid = atoi(cp);
if ((colon = strchr(cp = colon, ':')) == NULL)
- return(NULL);
+ return NULL;
*colon++ = '\0';
pw.pw_gid = atoi(cp);
if ((colon = strchr(cp = colon, ':')) == NULL)
- return(NULL);
+ return NULL;
*colon++ = '\0';
pw.pw_gecos = cp;
if ((colon = strchr(cp = colon, ':')) == NULL)
- return(NULL);
+ return NULL;
*colon++ = '\0';
pw.pw_dir = cp;
pw.pw_shell = colon;
len = strlen(colon);
if (len > 0 && colon[len - 1] == '\n')
colon[len - 1] = '\0';
- return(&pw);
+ return &pw;
}
struct passwd *
if (pwf == NULL) {
if ((pwf = fopen(pwfile, "r")) == NULL)
- return(NULL);
+ return NULL;
fcntl(fileno(pwf), F_SETFD, FD_CLOEXEC);
} else {
rewind(pwf);
fclose(pwf);
pwf = NULL;
}
- return(pw);
+ return pw;
}
struct passwd *
if (pwf == NULL) {
if ((pwf = fopen(pwfile, "r")) == NULL)
- return(NULL);
+ return NULL;
fcntl(fileno(pwf), F_SETFD, FD_CLOEXEC);
} else {
rewind(pwf);
fclose(pwf);
pwf = NULL;
}
- return(pw);
+ return pw;
}
void
int n;
if ((colon = fgets(grbuf, sizeof(grbuf), grf)) == NULL)
- return(NULL);
+ return NULL;
zero_bytes(&gr, sizeof(gr));
if ((colon = strchr(cp = colon, ':')) == NULL)
- return(NULL);
+ return NULL;
*colon++ = '\0';
gr.gr_name = cp;
if ((colon = strchr(cp = colon, ':')) == NULL)
- return(NULL);
+ return NULL;
*colon++ = '\0';
gr.gr_passwd = cp;
if ((colon = strchr(cp = colon, ':')) == NULL)
- return(NULL);
+ return NULL;
*colon++ = '\0';
gr.gr_gid = atoi(cp);
len = strlen(colon);
gr.gr_mem[n++] = NULL;
} else
gr.gr_mem = NULL;
- return(&gr);
+ return &gr;
}
struct group *
if (grf == NULL) {
if ((grf = fopen(grfile, "r")) == NULL)
- return(NULL);
+ return NULL;
fcntl(fileno(grf), F_SETFD, FD_CLOEXEC);
} else {
rewind(grf);
fclose(grf);
grf = NULL;
}
- return(gr);
+ return gr;
}
struct group *
if (grf == NULL) {
if ((grf = fopen(grfile, "r")) == NULL)
- return(NULL);
+ return NULL;
fcntl(fileno(grf), F_SETFD, FD_CLOEXEC);
} else {
rewind(grf);
fclose(grf);
grf = NULL;
}
- return(gr);
+ return gr;
}
utb.actime = (time_t)(times[0].tv_sec + times[0].tv_usec / 1000000);
utb.modtime = (time_t)(times[1].tv_sec + times[1].tv_usec / 1000000);
- return(utime(file, &utb));
+ return utime(file, &utb);
} else
- return(utime(file, NULL));
+ return utime(file, NULL);
}
#endif /* !HAVE_UTIMES */
utb.actime = (time_t)(times[0].tv_sec + times[0].tv_usec / 1000000);
utb.modtime = (time_t)(times[1].tv_sec + times[1].tv_usec / 1000000);
- return(futime(fd, &utb));
+ return futime(fd, &utb);
} else
- return(futime(fd, NULL));
+ return futime(fd, NULL);
}
#endif /* HAVE_FUTIME */
if( vas_group ) v_group_free( sudo_vas_ctx, vas_group );
if( vas_user ) v_user_free( sudo_vas_ctx, vas_user );
- return(rval);
+ return rval;
}
if (stat(sp->tpath, &sb) < 0) {
warningx("cannot stat temporary file (%s), %s unchanged",
sp->tpath, sp->path);
- return(FALSE);
+ return FALSE;
}
if (sb.st_size == 0 && orig_size != 0) {
warningx("zero length temporary file (%s), %s unchanged",
sp->tpath, sp->path);
sp->modified = TRUE;
- return(FALSE);
+ return FALSE;
}
} else {
warningx("editor (%s) failed, %s unchanged", editor, sp->path);
- return(FALSE);
+ return FALSE;
}
/* Set modified bit if use changed the file. */
else
warningx("%s unchanged", sp->tpath);
- return(TRUE);
+ return TRUE;
}
/*
}
} while (parse_error);
- return(TRUE);
+ return TRUE;
}
/*
if (chown(sp->tpath, SUDOERS_UID, SUDOERS_GID) != 0) {
warning("unable to set (uid, gid) of %s to (%d, %d)",
sp->tpath, SUDOERS_UID, SUDOERS_GID);
- return(FALSE);
+ return FALSE;
}
if (chmod(sp->tpath, SUDOERS_MODE) != 0) {
warning("unable to change mode of %s to 0%o", sp->tpath,
SUDOERS_MODE);
- return(FALSE);
+ return FALSE;
}
}
(void) unlink(sp->tpath);
efree(sp->tpath);
sp->tpath = NULL;
- return(FALSE);
+ return FALSE;
}
efree(sp->tpath);
sp->tpath = NULL;
} else {
warning("error renaming %s, %s unchanged", sp->tpath, sp->path);
(void) unlink(sp->tpath);
- return(FALSE);
+ return FALSE;
}
}
- return(TRUE);
+ return TRUE;
}
/* STUB */
int
user_is_exempt()
{
- return(FALSE);
+ return FALSE;
}
/* STUB */
sudo_getepw(pw)
const struct passwd *pw;
{
- return (pw->pw_passwd);
+ return pw->pw_passwd;
}
/*
case 'e':
case 'x':
case 'Q':
- return(choice);
+ return choice;
default:
(void) puts("Options are:");
(void) puts(" (e)dit sudoers file again");
} while (rv == -1 && errno == EINTR);
if (rv == -1 || !WIFEXITED(status))
- return(-1);
- return(WEXITSTATUS(status));
+ return -1;
+ return WEXITSTATUS(status);
}
static int
}
}
- return(error);
+ return error;
}
/*
if (entry->fd == -1) {
warning("%s", entry->path);
efree(entry);
- return(NULL);
+ return NULL;
}
if (!lock_file(entry->fd, SUDO_TLOCK))
errorx(1, "%s busy, try again later", entry->path);
}
if (keepopen != NULL)
*keepopen = TRUE;
- return(fp);
+ return fp;
}
static char *
errorx(1, "no editor found (editor path = %s)", def_editor);
}
*args = EditorArgs;
- return(Editor);
+ return Editor;
}
/*
while (*args && isblank((unsigned char) *args))
args++;
}
- return(*args ? args : NULL);
+ return *args ? args : NULL;
}
/*
a = alias_remove(name, type);
if (a)
rbinsert(alias_freelist, a);
- return(error);
+ return error;
}
/*
if (!no_aliases() && !quiet)
alias_apply(print_unused, strict ? "Error" : "Warning");
- return (strict ? error : 0);
+ return strict ? error : 0;
}
static void
a->type == HOSTALIAS ? "Host" : a->type == CMNDALIAS ? "Cmnd" :
a->type == USERALIAS ? "User" : a->type == RUNASALIAS ? "Runas" :
"Unknown", a->name);
- return(0);
+ return 0;
}
/*
projects / sudo / commitdiff