return NT_STATUS_LOGON_FAILURE;
}
- if (nt_status != NT_STATUS_NOPROBLEMO) {
+ if (nt_status != NT_STATUS_OK) {
nt_status = check_rhosts_security(user_info, server_info);
}
- if ((lp_security() == SEC_DOMAIN) && (nt_status != NT_STATUS_NOPROBLEMO)) {
+ if ((lp_security() == SEC_DOMAIN) && (nt_status != NT_STATUS_OK)) {
nt_status = check_domain_security(user_info, server_info);
}
- if ((lp_security() == SEC_SERVER) && (nt_status != NT_STATUS_NOPROBLEMO)) {
+ if ((lp_security() == SEC_SERVER) && (nt_status != NT_STATUS_OK)) {
nt_status = check_server_security(user_info, server_info);
}
smb_user_control(user_info->smb_username.str, nt_status);
}
- if (nt_status != NT_STATUS_NOPROBLEMO) {
+ if (nt_status != NT_STATUS_OK) {
if ((user_info->plaintext_password.len > 0)
&& (!lp_plaintext_to_smbpasswd())) {
nt_status = check_unix_security(user_info, server_info);
}
}
- if ((nt_status == NT_STATUS_NOPROBLEMO) && !done_pam) {
+ if ((nt_status == NT_STATUS_OK) && !done_pam) {
/* We might not be root if we are an RPC call */
become_root();
nt_status = smb_pam_accountcheck(user_info->smb_username.str);
unbecome_root();
}
- if (nt_status == NT_STATUS_NOPROBLEMO) {
+ if (nt_status == NT_STATUS_OK) {
DEBUG(5, ("check_password: Password for user %s suceeded\n", user_info->smb_username.str));
} else {
DEBUG(3, ("check_password: Password for user %s FAILED with error %s\n", user_info->smb_username.str, get_nt_error_msg(nt_status)));
/* The password could be either NTLM or plain LM. Try NTLM first, but fall-through as
required. */
- if (pass_check_smb(user, lp_workgroup(), NULL, 0, (unsigned char *)password, pwlen) == NT_STATUS_NOPROBLEMO) {
+ if (pass_check_smb(user, lp_workgroup(), NULL, 0, (unsigned char *)password, pwlen) == NT_STATUS_OK) {
return True;
}
- if (pass_check_smb(user, lp_workgroup(), (unsigned char *)password, pwlen, NULL, 0) == NT_STATUS_NOPROBLEMO) {
+ if (pass_check_smb(user, lp_workgroup(), (unsigned char *)password, pwlen, NULL, 0) == NT_STATUS_OK) {
return True;
}
become_root();
if (check_hosts_equiv(user_info->smb_username.str)) {
- nt_status = NT_STATUS_NOPROBLEMO;
+ nt_status = NT_STATUS_OK;
}
unbecome_root();
if (lp_null_passwords())
{
DEBUG(3,("Account for user '%s' has no password and null passwords are allowed.\n", user_info->smb_username.str));
- return(NT_STATUS_NOPROBLEMO);
+ return(NT_STATUS_OK);
}
else
{
user_info->requested_domain.str,
(char *)server_info->session_key))
{
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
DEBUG(4,("smb_password_ok: NTLMv2 password check failed\n"));
nt_pw, user_info->chal,
server_info->session_key)) {
DEBUG(4,("smb_password_ok: NT MD4 password check succeeded\n"));
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
} else {
DEBUG(4,("smb_password_ok: NT MD4 password check failed\n"));
return NT_STATUS_WRONG_PASSWORD;
lm_pw, user_info->chal,
server_info->session_key)) {
DEBUG(4,("smb_password_ok: LM password check succeeded\n"));
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
} else {
DEBUG(4,("smb_password_ok: LM password check failed\n"));
return NT_STATUS_WRONG_PASSWORD;
/* Make this cli_nt_error() when the conversion is in */
nt_status = NT_STATUS_LOGON_FAILURE;
} else {
- nt_status = NT_STATUS_NOPROBLEMO;
+ nt_status = NT_STATUS_OK;
}
/* if logged in as guest then reject */
nt_status = (pass_check(user_info->smb_username.str, user_info->plaintext_password.str,
user_info->plaintext_password.len,
lp_update_encrypted() ? update_smbpassword_file : NULL)
- ? NT_STATUS_NOPROBLEMO : NT_STATUS_LOGON_FAILURE);
+ ? NT_STATUS_OK : NT_STATUS_LOGON_FAILURE);
unbecome_root();
return nt_status;
{
struct passwd *pwd=NULL;
- if(nt_status == NT_STATUS_NOPROBLEMO) {
+ if(nt_status == NT_STATUS_OK) {
/*
* User validated ok against Domain controller.
* If the admin wants us to try and create a UNIX
if (smb_pam_error_handler(pamh, pam_error, msg, dbglvl))
return True;
- if (*nt_status == NT_STATUS_NOPROBLEMO) {
+ if (*nt_status == NT_STATUS_OK) {
/* Complain LOUDLY */
DEBUG(0, ("smb_pam_nt_status_error_handler: PAM: BUG: PAM and NT_STATUS \
error MISMATCH, forcing to NT_STATUS_LOGON_FAILURE"));
break;
case PAM_SUCCESS:
DEBUG(4, ("smb_pam_auth: PAM: User %s Authenticated OK\n", user));
- nt_status = NT_STATUS_NOPROBLEMO;
+ nt_status = NT_STATUS_OK;
break;
default:
DEBUG(0, ("smb_pam_auth: PAM: UNKNOWN ERROR while authenticating user %s\n", user));
break;
case PAM_SUCCESS:
DEBUG(4, ("smb_pam_account: PAM: Account OK for User: %s\n", user));
- nt_status = NT_STATUS_NOPROBLEMO;
+ nt_status = NT_STATUS_OK;
break;
default:
nt_status = NT_STATUS_ACCOUNT_DISABLED;
break;
case PAM_SUCCESS:
DEBUG(4, ("smb_pam_setcred: PAM: SetCredentials OK for User: %s\n", user));
- nt_status = NT_STATUS_NOPROBLEMO;
+ nt_status = NT_STATUS_OK;
break;
default:
DEBUG(0, ("smb_pam_setcred: PAM: UNKNOWN PAM ERROR (%d) during SetCredentials for User: %s\n", pam_error, user));
/* Ignore PAM if told to. */
if (!lp_obey_pam_restrictions())
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
if ((pconv = smb_setup_pam_conv(smb_pam_conv, user, NULL, NULL)) == NULL)
return False;
if (!smb_pam_start(&pamh, user, NULL, pconv))
return NT_STATUS_ACCOUNT_DISABLED;
- if ((nt_status = smb_pam_account(pamh, user)) != NT_STATUS_NOPROBLEMO)
+ if ((nt_status = smb_pam_account(pamh, user)) != NT_STATUS_OK)
DEBUG(0, ("smb_pam_accountcheck: PAM: Account Validation Failed - Rejecting User %s!\n", user));
smb_pam_end(pamh, pconv);
if (!smb_pam_start(&pamh, user, NULL, pconv))
return NT_STATUS_LOGON_FAILURE;
- if ((nt_status = smb_pam_auth(pamh, user)) != NT_STATUS_NOPROBLEMO) {
+ if ((nt_status = smb_pam_auth(pamh, user)) != NT_STATUS_OK) {
DEBUG(0, ("smb_pam_passcheck: PAM: smb_pam_auth failed - Rejecting User %s !\n", user));
smb_pam_end(pamh, pconv);
return nt_status;
}
- if ((nt_status = smb_pam_account(pamh, user)) != NT_STATUS_NOPROBLEMO) {
+ if ((nt_status = smb_pam_account(pamh, user)) != NT_STATUS_OK) {
DEBUG(0, ("smb_pam_passcheck: PAM: smb_pam_account failed - Rejecting User %s !\n", user));
smb_pam_end(pamh, pconv);
return nt_status;
}
- if ((nt_status = smb_pam_setcred(pamh, user)) != NT_STATUS_NOPROBLEMO) {
+ if ((nt_status = smb_pam_setcred(pamh, user)) != NT_STATUS_OK) {
DEBUG(0, ("smb_pam_passcheck: PAM: smb_pam_setcred failed - Rejecting User %s !\n", user));
smb_pam_end(pamh, pconv);
return nt_status;
/* If PAM not used, no PAM restrictions on accounts. */
uint32 smb_pam_accountcheck(char * user)
{
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/* If PAM not used, also no PAM restrictions on sessions. */
{
#ifdef WITH_PAM
- return (smb_pam_passcheck(this_user, password) == NT_STATUS_NOPROBLEMO);
+ return (smb_pam_passcheck(this_user, password) == NT_STATUS_OK);
#endif /* WITH_PAM */
#ifdef WITH_AFS
uint32 default_priority;
uint32 starttime;
uint32 untiltime;
- uint32 status;
+ NTSTATUS status;
uint32 cjobs;
uint32 averageppm;
fstring servername;
we start supporting NT error codes in Samba. They were extracted
using a loop in smbclient then printing a netmon sniff to a file */
-#define NT_STATUS_NOPROBLEMO NT_STATUS(0x0)
#define NT_STATUS_OK NT_STATUS(0x0)
#define NT_STATUS_UNSUCCESSFUL NT_STATUS(0xC0000000 | 1)
#define NT_STATUS_NOT_IMPLEMENTED NT_STATUS(0xC0000000 | 2)
} info;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} BRS_R_QUERY_INFO;
/* RPC_HDR_FAULT - fault rpc header */
typedef struct rpc_hdr_fault_info
{
- uint32 status;
+ NTSTATUS status;
uint32 reserved; /* 0x0000 0000 */
} RPC_HDR_FAULT;
/* status == 1 if dfs exists. */
typedef struct dfs_r_dfs_exist
{
- uint32 status;
+ NTSTATUS status;
}
DFS_R_DFS_EXIST;
typedef struct dfs_r_dfs_add
{
- uint32 status;
+ NTSTATUS status;
}
DFS_R_DFS_ADD;
typedef struct dfs_r_dfs_remove
{
- uint32 status;
+ NTSTATUS status;
}
DFS_R_DFS_REMOVE;
uint32 level;
uint32 ptr_ctr;
DFS_INFO_CTR ctr;
- uint32 status;
+ NTSTATUS status;
}
DFS_R_DFS_GET_INFO;
uint32 ptr_num_entries2;
uint32 num_entries2;
ENUM_HND reshnd;
- uint32 status;
+ NTSTATUS status;
}
DFS_R_DFS_ENUM;
NETLOGON_INFO_1 info1;
} logon;
- uint32 status;
+ NTSTATUS status;
} NET_R_LOGON_CTRL;
/********************************************************
} logon;
- uint32 status; /* return code */
+ NTSTATUS status; /* return code */
} NET_R_LOGON_CTRL2;
{
UNISTR2 uni_trust_dom_name[MAX_TRUST_DOMS];
- uint32 status; /* return code */
+ NTSTATUS status; /* return code */
} NET_R_TRUST_DOM_LIST;
/* NET_R_REQ_CHAL */
typedef struct net_r_req_chal_info
{
- DOM_CHAL srv_chal; /* server challenge */
-
- uint32 status; /* return code */
-
+ DOM_CHAL srv_chal; /* server challenge */
+ NTSTATUS status; /* return code */
} NET_R_REQ_CHAL;
/* NET_Q_AUTH */
typedef struct net_r_auth_info
{
DOM_CHAL srv_chal; /* server-calculated credentials */
- uint32 status; /* return code */
+ NTSTATUS status; /* return code */
} NET_R_AUTH;
/* NET_Q_AUTH_2 */
DOM_CHAL srv_chal; /* server-calculated credentials */
NEG_FLAGS srv_flgs; /* usually 0x0000 01ff */
- uint32 status; /* return code */
+ NTSTATUS status; /* return code */
} NET_R_AUTH_2;
{
DOM_CRED srv_cred; /* server-calculated credentials */
- uint32 status; /* return code */
+ NTSTATUS status; /* return code */
} NET_R_SRV_PWSET;
uint32 auth_resp; /* 1 - Authoritative response; 0 - Non-Auth? */
- uint32 status; /* return code */
+ NTSTATUS status; /* return code */
} NET_R_SAM_LOGON;
uint32 buffer_creds; /* undocumented buffer pointer */
DOM_CRED srv_creds; /* server credentials. server time stamp appears to be ignored. */
- uint32 status; /* return code */
+ NTSTATUS status; /* return code */
} NET_R_SAM_LOGOFF;
typedef struct r_reg_open_hkcr_info
{
POLICY_HND pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_OPEN_HKCR;
typedef struct r_reg_open_hklm_info
{
POLICY_HND pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
}
REG_R_OPEN_HKLM;
typedef struct r_reg_open_hku_info
{
POLICY_HND pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_OPEN_HKU;
/* REG_R_FLUSH_KEY */
typedef struct r_reg_open_flush_key_info
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_FLUSH_KEY;
/* REG_R_SET_KEY_SEC */
typedef struct r_reg_set_key_sec_info
{
- uint32 status;
+ NTSTATUS status;
} REG_R_SET_KEY_SEC;
BUFHDR hdr_sec; /* header for security data */
SEC_DESC_BUF *data; /* security data */
- uint32 status;
+ NTSTATUS status;
} REG_R_GET_KEY_SEC;
/* REG_R_CREATE_VALUE */
typedef struct r_reg_create_value_info
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_CREATE_VALUE;
uint32 ptr2; /* pointer */
uint32 len_value2; /* */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_ENUM_VALUE;
POLICY_HND key_pol; /* policy handle */
uint32 unknown; /* 0x0000 0000 */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_CREATE_KEY;
{
POLICY_HND key_pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_DELETE_KEY;
{
POLICY_HND key_pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_DELETE_VALUE;
uint32 sec_desc; /* 0x0000 0078 */
NTTIME mod_time; /* modified time */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_QUERY_KEY;
typedef struct r_reg_unk_1a_info
{
uint32 unknown; /* 0x0500 0000 */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_UNK_1A;
{
POLICY_HND pol; /* policy handle. should be all zeros. */
- uint32 status; /* return code */
+ NTSTATUS status; /* return code */
} REG_R_CLOSE;
uint32 ptr3; /* pointer */
NTTIME time; /* current time? */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_ENUM_KEY;
uint32 ptr_len;
uint32 buf_len;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_INFO;
typedef struct r_reg_open_entry_info
{
POLICY_HND pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_OPEN_ENTRY;
/* REG_R_SHUTDOWN */
typedef struct r_reg_shutdown_info
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_SHUTDOWN;
/* REG_R_ABORT_SHUTDOWN */
typedef struct r_reg_abort_shutdown_info
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} REG_R_ABORT_SHUTDOWN;
typedef struct r_samr_close_hnd_info
{
POLICY_HND pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_CLOSE_HND;
uint16 unknown_0; /* 0000 */
uint16 unknown_1; /* 0x0016 or 0x0015 */
uint32 unknown_2; /* 0x0000 0000 */
- uint32 status;
+ NTSTATUS status;
} SAMR_R_GET_USRDOM_PWINFO;
uint32 ptr;
SEC_DESC_BUF *buf;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_QUERY_SEC_OBJ;
SAM_UNK_CTR *ctr;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_QUERY_DOMAIN_INFO;
uint32 ptr_sid;
DOM_SID2 dom_sid;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_LOOKUP_DOMAIN;
typedef struct r_samr_open_domain_info
{
POLICY_HND domain_pol; /* policy handle associated with the SID */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_OPEN_DOMAIN;
uint32 num_entries4;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_ENUM_DOMAINS;
uint32 num_entries4;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_ENUM_DOM_USERS;
uint32 num_entries4;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_ENUM_DOM_GROUPS;
uint32 num_entries4;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_ENUM_DOM_ALIASES;
SAM_DISPINFO_CTR *ctr;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_QUERY_DISPINFO;
typedef struct r_samr_delete_dom_group_info
{
POLICY_HND pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_DELETE_DOM_GROUP;
POLICY_HND pol; /* policy handle */
uint32 rid;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_CREATE_DOM_GROUP;
uint32 ptr;
GROUP_INFO_CTR *ctr;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_QUERY_GROUPINFO;
/* SAMR_R_SET_GROUPINFO - SAM Group Info */
typedef struct r_samr_set_group_info
{
- uint32 status;
+ NTSTATUS status;
} SAMR_R_SET_GROUPINFO;
typedef struct r_samr_delete_dom_alias_info
{
POLICY_HND pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_DELETE_DOM_ALIAS;
POLICY_HND alias_pol; /* policy handle */
uint32 rid;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_CREATE_DOM_ALIAS;
uint32 ptr;
ALIAS_INFO_CTR ctr;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_QUERY_ALIASINFO;
/* SAMR_R_SET_ALIASINFO - SAM alias info */
typedef struct r_samr_set_aliasinfo_info
{
- uint32 status;
+ NTSTATUS status;
} SAMR_R_SET_ALIASINFO;
DOM_GID *gid; /* group info */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_QUERY_USERGROUPS;
/* SAMR_R_SET_USERINFO2 - set sam info */
typedef struct r_samr_set_user_info2
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_SET_USERINFO2;
/* SAMR_R_SET_USERINFO - set sam info */
typedef struct r_samr_set_user_info
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_SET_USERINFO;
uint32 ptr; /* pointer */
SAM_USERINFO_CTR *ctr;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_QUERY_USERINFO;
uint32 num_entries2;
uint32 *rid; /* domain RIDs being looked up */
- uint32 status; /* return code */
+ NTSTATUS status; /* return code */
} SAMR_R_QUERY_USERALIASES;
uint32 *types; /* SID_ENUM type */
- uint32 status; /* return code */
+ NTSTATUS status; /* return code */
} SAMR_R_LOOKUP_NAMES;
uint32 *type; /* SID_ENUM type */
- uint32 status;
+ NTSTATUS status;
} SAMR_R_LOOKUP_RIDS;
typedef struct r_samr_open_user_info
{
POLICY_HND user_pol; /* policy handle associated with unknown id */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_OPEN_USER;
uint32 unknown_0; /* 0x0007 03ff */
uint32 user_rid; /* user RID */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_CREATE_USER;
typedef struct r_samr_delete_dom_user_info
{
POLICY_HND pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_DELETE_DOM_USER;
uint32 num_attrs;
uint32 *attr;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_QUERY_GROUPMEM;
/* SAMR_R_DEL_GROUPMEM - probably an del group member */
typedef struct r_samr_del_group_mem_info
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_DEL_GROUPMEM;
/* SAMR_R_ADD_GROUPMEM - probably an add group member */
typedef struct r_samr_add_group_mem_info
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_ADD_GROUPMEM;
typedef struct r_samr_open_group_info
{
POLICY_HND pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_OPEN_GROUP;
DOM_SID2 *sid;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_QUERY_ALIASMEM;
/* SAMR_R_ADD_ALIASMEM - add alias member */
typedef struct r_samr_add_alias_mem_info
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_ADD_ALIASMEM;
/* SAMR_R_DEL_ALIASMEM - delete alias member */
typedef struct r_samr_del_alias_mem_info
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_DEL_ALIASMEM;
typedef struct r_samr_open_alias_info
{
POLICY_HND pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_OPEN_ALIAS;
typedef struct r_samr_connect_anon_info
{
POLICY_HND connect_pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_CONNECT_ANON;
typedef struct r_samr_connect_info
{
POLICY_HND connect_pol; /* policy handle */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_CONNECT;
uint16 unk_0;
uint16 unk_1;
uint16 unk_2;
- uint32 status;
+ NTSTATUS status;
} SAMR_R_GET_DOM_PWINFO;
/* SAMR_R_CHGPASSWD_USER */
typedef struct r_samr_chgpasswd_user_info
{
- uint32 status; /* 0 == OK, C000006A (NT_STATUS_WRONG_PASSWORD) */
+ NTSTATUS status; /* 0 == OK, C000006A (NT_STATUS_WRONG_PASSWORD) */
} SAMR_R_CHGPASSWD_USER;
/* SAMR_R_UNKNOWN_2D - probably an open */
typedef struct r_samr_unknown_2d_info
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SAMR_R_UNKNOWN_2D;
typedef struct spool_r_open_printer_ex
{
POLICY_HND handle; /* handle used along all transactions (20*uint8) */
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_OPEN_PRINTER_EX;
uint32 size;
uint8 *data;
uint32 needed;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_GETPRINTERDATA;
typedef struct spool_r_deleteprinterdata
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_DELETEPRINTERDATA;
typedef struct spool_r_closeprinter
{
POLICY_HND handle;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_CLOSEPRINTER;
typedef struct spool_r_startpageprinter
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_STARTPAGEPRINTER;
typedef struct spool_r_endpageprinter
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENDPAGEPRINTER;
typedef struct spool_r_deleteprinterdriver
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_DELETEPRINTERDRIVER;
typedef struct spool_r_startdocprinter
{
uint32 jobid;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_STARTDOCPRINTER;
typedef struct spool_r_enddocprinter
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENDDOCPRINTER;
typedef struct spool_r_writeprinter
{
uint32 buffer_written;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_WRITEPRINTER;
typedef struct spool_r_rffpcnex
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_RFFPCNEX;
{
uint32 info_ptr;
SPOOL_NOTIFY_INFO info;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_RFNPCNEX;
typedef struct spool_r_fcpn
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_FCPN;
uint32 unknown16;
uint32 change_id;
uint32 unknown18;
- uint32 status;
+ NTSTATUS status;
uint32 unknown20;
uint32 c_setprinter;
uint32 defaultpriority;
uint32 starttime;
uint32 untiltime;
- uint32 status;
+ NTSTATUS status;
uint32 cjobs;
uint32 averageppm;
}
NEW_BUFFER *buffer;
uint32 needed; /* bytes needed */
uint32 returned; /* number of printers */
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENUMPRINTERS;
{
NEW_BUFFER *buffer;
uint32 needed;
- uint32 status;
+ NTSTATUS status;
} SPOOL_R_GETPRINTER;
typedef struct driver_info_1
uint32 needed;
uint32 servermajorversion;
uint32 serverminorversion;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_GETPRINTERDRIVER2;
{
NEW_BUFFER *buffer;
uint32 needed;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ADDJOB;
UNISTR document;
UNISTR datatype;
UNISTR text_status;
- uint32 status;
+ NTSTATUS status;
uint32 priority;
uint32 position;
uint32 totalpages;
DEVICEMODE *devmode;
UNISTR text_status;
/* SEC_DESC sec_desc;*/
- uint32 status;
+ NTSTATUS status;
uint32 priority;
uint32 position;
uint32 starttime;
NEW_BUFFER *buffer;
uint32 needed;
uint32 returned;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENUMJOBS;
typedef struct spool_r_schedulejob
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_SCHEDULEJOB;
NEW_BUFFER *buffer;
uint32 needed; /* bytes needed */
uint32 returned; /* number of printers */
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENUMPORTS;
typedef struct spool_r_setjob
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_SETJOB;
NEW_BUFFER *buffer;
uint32 needed;
uint32 returned;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENUMPRINTERDRIVERS;
NEW_BUFFER *buffer;
uint32 needed;
uint32 numofforms;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENUMFORMS;
{
NEW_BUFFER *buffer;
uint32 needed;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_GETFORM;
uint32 default_priority;
uint32 starttime;
uint32 untiltime;
- uint32 status;
+ NTSTATUS status;
uint32 cjobs;
uint32 averageppm;
UNISTR2 servername;
typedef struct spool_r_setprinter
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_SETPRINTER;
typedef struct spool_r_addprinter
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ADDPRINTER;
typedef struct spool_r_deleteprinter
{
POLICY_HND handle;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_DELETEPRINTER;
typedef struct spool_r_abortprinter
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ABORTPRINTER;
typedef struct spool_r_addprinterex
{
POLICY_HND handle;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ADDPRINTEREX;
typedef struct spool_r_addprinterdriver
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ADDPRINTERDRIVER;
{
NEW_BUFFER *buffer;
uint32 needed;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_GETPRINTERDRIVERDIR;
typedef struct spool_r_addprintprocessor
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ADDPRINTPROCESSOR;
NEW_BUFFER *buffer;
uint32 needed;
uint32 returned;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENUMPRINTPROCESSORS;
NEW_BUFFER *buffer;
uint32 needed;
uint32 returned;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENUMPRINTPROCDATATYPES;
NEW_BUFFER *buffer;
uint32 needed;
uint32 returned;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENUMPRINTMONITORS;
uint32 datasize;
uint8 *data;
uint32 realdatasize;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ENUMPRINTERDATA;
typedef struct spool_r_setprinterdata
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_SETPRINTERDATA;
typedef struct spool_r_addform
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_ADDFORM;
typedef struct spool_r_setform
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_SETFORM;
typedef struct spool_r_deleteform
{
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_DELETEFORM;
{
NEW_BUFFER *buffer;
uint32 needed;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_GETJOB;
typedef struct spool_r_replyopenprinter
{
POLICY_HND handle;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_REPLYOPENPRINTER;
typedef struct spool_r_replycloseprinter
{
POLICY_HND handle;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_REPLYCLOSEPRINTER;
typedef struct spool_r_rrpcn
{
uint32 unknown0;
- uint32 status;
+ NTSTATUS status;
}
SPOOL_R_REPLY_RRPCN;
uint32 preferred_len; /* preferred maximum length (0xffff ffff) */
uint32 total_entries; /* total number of entries */
ENUM_HND enum_hnd;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_Q_NET_DISK_ENUM, SRV_R_NET_DISK_ENUM;
typedef struct net_name_validate {
UNISTR2 uni_name; /*name to validate*/
uint32 type;
uint32 flags;
- uint32 status;
+ NTSTATUS status;
} SRV_Q_NET_NAME_VALIDATE, SRV_R_NET_NAME_VALIDATE;
/* SESS_INFO_0 (pointers to level 0 session info strings) */
uint32 total_entries; /* total number of entries */
ENUM_HND enum_hnd;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_R_NET_SESS_ENUM;
uint32 total_entries; /* total number of entries */
ENUM_HND enum_hnd;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_R_NET_CONN_ENUM;
uint32 total_entries; /* total number of entries */
ENUM_HND enum_hnd;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_R_NET_SHARE_ENUM;
typedef struct r_net_share_get_info_info
{
SRV_SHARE_INFO info;
- uint32 status;
+ NTSTATUS status;
} SRV_R_NET_SHARE_GET_INFO;
{
uint32 switch_value; /* switch value */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_R_NET_SHARE_SET_INFO;
{
uint32 switch_value; /* switch value */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_R_NET_SHARE_ADD;
/* SRV_R_NET_SHARE_DEL */
typedef struct r_net_share_del
{
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_R_NET_SHARE_DEL;
uint32 total_entries; /* total number of files */
ENUM_HND enum_hnd;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_R_NET_FILE_ENUM;
{
SRV_INFO_CTR *ctr;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_R_NET_SRV_GET_INFO;
{
uint32 switch_value; /* switch value */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_R_NET_SRV_SET_INFO;
uint32 ptr_srv_tod; /* pointer to TOD */
TIME_OF_DAY_INFO *tod;
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} SRV_R_NET_REMOTE_TOD;
uint32 ptr_secdesc;
uint32 size_secdesc;
SEC_DESC *sec_desc;
- uint32 status;
+ NTSTATUS status;
} SRV_R_NET_FILE_QUERY_SECDESC;
/* SRV_Q_NET_FILE_SET_SECDESC */
/* SRV_R_NET_FILE_SET_SECDESC */
typedef struct r_net_file_set_secdesc
{
- uint32 status;
+ NTSTATUS status;
} SRV_R_NET_FILE_SET_SECDESC;
#endif /* _RPC_SRVSVC_H */
uint32 ptr_1; /* pointer 1 */
WKS_INFO_100 *wks100; /* workstation info level 100 */
- uint32 status; /* return status */
+ NTSTATUS status; /* return status */
} WKS_R_QUERY_INFO;
uint32 high;
} NTTIME;
-#ifdef __GNUC__XX
+#ifdef __GNUC__XX_NOT_YET
typedef struct {uint32 v;} NTSTATUS;
#define NT_STATUS(x) ((NTSTATUS) { x })
#define NT_STATUS_V(x) ((x).v)
#endif
#define NT_STATUS_IS_OK(x) (NT_STATUS_V(x) == 0)
-#define NT_STATUS_IS_ERR(x) (NT_STATUS_V(x) & 0xc0000000)
+#define NT_STATUS_IS_ERR(x) ((NT_STATUS_V(x) & 0xc0000000) == 0xc0000000)
/* Allowable account control bits */
#define ACB_DISABLED 0x0001 /* 1 = User account disabled */
****************************************************************************/
static uint32 do_command(struct client_info *info, char *line)
{
- uint32 status = 0x0;
+ NTSTATUS status = 0x0;
int i;
if (!get_cmd_args(line))
****************************************************************************/
static uint32 process(struct client_info *info, char *cmd_str)
{
- uint32 status = 0;
+ NTSTATUS status = 0;
pstring line;
char *cmd = cmd_str;
****************************************************************************/
int command_main(int argc, char *argv[])
{
- uint32 status;
+ NTSTATUS status;
mode_t myumask = 0755;
char progname[255], path[255], *s;
pstring msg;
*/
*granted = acc_granted;
- *status = NT_STATUS_NOPROBLEMO;
+ *status = NT_STATUS_OK;
return True;
}
if (!status || !acc_granted)
return False;
- *status = NT_STATUS_NOPROBLEMO;
+ *status = NT_STATUS_OK;
*acc_granted = 0;
DEBUG(10,("se_access_check: requested access %x, for uid %u\n",
/* ACL must have something in it */
if (!sd || (sd && (!(sd->type & SEC_DESC_DACL_PRESENT) || sd->dacl == NULL))) {
- *status = NT_STATUS_NOPROBLEMO;
+ *status = NT_STATUS_OK;
*acc_granted = acc_desired;
DEBUG(5, ("se_access_check: no sd or blank DACL, access allowed\n"));
return True;
if (tmp_acc_desired == 0) {
*acc_granted = acc_desired;
- *status = NT_STATUS_NOPROBLEMO;
+ *status = NT_STATUS_OK;
DEBUG(5,("se_access_check: access (%x) granted.\n", (unsigned int)acc_desired ));
return True;
}
if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1 ) {
if( DEBUGLVL( dlevel ) ) {
dbgtext( "open_socket_in(): setsockopt: " );
- dbgtext( "SO_REUSEADDR = %d ", val?"True":"False" );
+ dbgtext( "SO_REUSEADDR = %s ", val?"True":"False" );
dbgtext( "on port %d failed ", port );
dbgtext( "with error = %s\n", strerror(errno) );
}
*dfs_exists = (r.status == 1);
- result = NT_STATUS_NOPROBLEMO;
+ result = NT_STATUS_OK;
done:
prs_mem_free(&qbuf);
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*pol = r.pol;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*pol = r.pol;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*pol = r.pol;
}
result = r.status;
- if (result != NT_STATUS_NOPROBLEMO && result != 0x00000107 &&
+ if (result != NT_STATUS_OK && result != 0x00000107 &&
result != (0xC0000000 | NT_STATUS_NONE_MAPPED)) {
/* An actual error occured */
goto done;
}
- result = NT_STATUS_NOPROBLEMO;
+ result = NT_STATUS_OK;
/* Return output parameters */
result = r.status;
- if (result != NT_STATUS_NOPROBLEMO &&
+ if (result != NT_STATUS_OK &&
result != (0xC0000000 | NT_STATUS_NONE_MAPPED)) {
/* An actual error occured */
goto done;
}
- result = NT_STATUS_NOPROBLEMO;
+ result = NT_STATUS_OK;
/* Return output parameters */
goto done;
}
- if ((result = r.status) != NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) != NT_STATUS_OK) {
goto done;
}
0x8000001a (NT_STATUS_UNABLE_TO_FREE_VM) so we ignore it and
pretend everything is OK. */
- if (result != NT_STATUS_NOPROBLEMO &&
+ if (result != NT_STATUS_OK &&
result != NT_STATUS_UNABLE_TO_FREE_VM) {
/* An actual error ocured */
goto done;
}
- result = NT_STATUS_NOPROBLEMO;
+ result = NT_STATUS_OK;
/* Return output parameters */
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*connect_pol = r.connect_pol;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*connect_pol = r.pol;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*domain_pol = r.domain_pol;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*user_pol = r.user_pol;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*group_pol = r.pol;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*num_groups = r.num_entries;
*gid = r.gid;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*num_mem = r.num_entries;
*rid = r.rid;
*attr = r.attr;
result = r.status;
- if (result != NT_STATUS_NOPROBLEMO &&
+ if (result != NT_STATUS_OK &&
result != STATUS_MORE_ENTRIES) {
goto done;
}
/* Return output parameters */
- if ((result = r.status) != NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) != NT_STATUS_OK) {
goto done;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*alias_pol = r.pol;
}
/* Return output parameters */
- if ((result = r.status) != NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) != NT_STATUS_OK) {
goto done;
}
result = r.status;
- if (result != NT_STATUS_NOPROBLEMO &&
+ if (result != NT_STATUS_OK &&
result != STATUS_MORE_ENTRIES) {
goto done;
}
/* Return output parameters */
- if ((result = r.status) != NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) != NT_STATUS_OK) {
goto done;
}
/* Return output parameters */
- if ((result = r.status) != NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) != NT_STATUS_OK) {
goto done;
}
/* Return output parameters */
- if ((result = r.status) != NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) != NT_STATUS_OK) {
goto done;
}
/* Return output parameters */
- if ((result = r.status) != NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) != NT_STATUS_OK) {
goto done;
}
/* Return output parameters */
- if ((result = r.status) != NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) != NT_STATUS_OK) {
goto done;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*pol = r.handle;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
*pol = r.handle;
}
/* Return output parameters */
- if (((result=r.status) == NT_STATUS_NOPROBLEMO) && (*returned = r.returned))
+ if (((result=r.status) == NT_STATUS_OK) && (*returned = r.returned))
{
switch (level) {
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO &&
+ if ((result = r.status) == NT_STATUS_OK &&
r.returned > 0) {
*returned = r.returned;
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO) {
+ if ((result = r.status) == NT_STATUS_OK) {
switch (level) {
case 0:
}
/* Return output parameters */
- if ((result = r.status) == NT_STATUS_NOPROBLEMO)
+ if ((result = r.status) == NT_STATUS_OK)
{
switch (level)
}
/* Return output parameters */
- if (((result=r.status) == NT_STATUS_NOPROBLEMO) &&
+ if (((result=r.status) == NT_STATUS_OK) &&
(r.returned != 0))
{
*returned = r.returned;
}
/* Return output parameters */
- if ((result=r.status) == NT_STATUS_NOPROBLEMO)
+ if ((result=r.status) == NT_STATUS_OK)
{
switch (level)
{
use it, otherwise figure out a server from the 'password server' param.
************************************************************************/
-uint32 domain_client_validate(const auth_usersupplied_info *user_info,
+NTSTATUS domain_client_validate(const auth_usersupplied_info *user_info,
auth_serversupplied_info *server_info,
char *server, unsigned char *trust_passwd,
time_t last_change_time)
struct cli_state cli;
uint32 smb_uid_low;
BOOL connected_ok = False;
- uint32 status;
+ NTSTATUS status;
/*
* Check that the requested domain is not our own machine name.
if ((status = cli_nt_login_network(&cli, user_info, smb_uid_low,
&ctr, &info3))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
DEBUG(0,("domain_client_validate: unable to validate password "
"for user %s in domain %s to Domain controller %s. "
"Error was %s.\n", user_info->smb_username.str,
user_info->domain.str, remote_machine,
get_nt_error_msg(status)));
} else {
- status = NT_STATUS_NOPROBLEMO;
+ status = NT_STATUS_OK;
}
/*
* send here. JRA.
*/
- if (status == NT_STATUS_NOPROBLMO) {
+ if (NT_STATUS_IS_OK(status)) {
if(cli_nt_logoff(&cli, &ctr) == False) {
DEBUG(0,("domain_client_validate: unable to log off user %s in domain \
%s to Domain controller %s. Error was %s.\n", user, domain, remote_machine, cli_errstr(&cli)));
{ERRDOS, ERRbadfile, NT_STATUS_NO_SUCH_FILE},
{ERRDOS, ERRbadpath, NT_STATUS_OBJECT_PATH_NOT_FOUND},
{ERRDOS, ERRnofids, NT_STATUS_TOO_MANY_OPENED_FILES},
- {ERRDOS, ERRnoaccess, NT_STATUS_INVALID_LOCK_SEQUENCE},
+ {ERRDOS, ERRnoaccess, NT_STATUS_ACCESS_DENIED},
{ERRDOS, ERRbadfid, NT_STATUS_INVALID_HANDLE},
{ERRDOS, ERRnomem, NT_STATUS_INSUFFICIENT_RESOURCES},
{ERRDOS, ERRbadaccess, NT_STATUS_INVALID_LOCK_SEQUENCE},
DEBUG(3,("smbc_error %d %d (0x%x) -> %d\n",
(int)eclass, (int)ecode, (int)ecode, ret));
} else {
- uint32 status;
+ NTSTATUS status;
status = cli_nt_error(c);
ret = cli_errno_from_nt(status);
if (!ok) return NT_STATUS_FILE_LOCK_CONFLICT;
- return NT_STATUS_NOPROBLEMO; /* Got lock */
+ return NT_STATUS_OK; /* Got lock */
}
/****************************************************************************
des_access, &pol->handle);
done:
- if (result != NT_STATUS_NOPROBLEMO && pol->cli) {
+ if (result != NT_STATUS_OK && pol->cli) {
if (pol->cli->initialised)
cli_shutdown(pol->cli);
free(pol->cli);
}
- return (result == NT_STATUS_NOPROBLEMO);
+ return (result == NT_STATUS_OK);
}
/****************************************************************************
ret = cli_lsa_enum_trust_dom(hnd->cli, hnd->mem_ctx, &hnd->handle,
enum_ctx, num_doms, names, sids);
- return (ret == NT_STATUS_NOPROBLEMO);
+ return (ret == NT_STATUS_OK);
}
/****************************************************************************
ret = cli_lsa_query_info_policy(hnd->cli, hnd->mem_ctx, &hnd->handle,
info_class, domain_name, domain_sid);
- return (ret == NT_STATUS_NOPROBLEMO);
+ return (ret == NT_STATUS_OK);
}
/****************************************************************************
ret = cli_lsa_lookup_names(hnd->cli, hnd->mem_ctx, &hnd->handle,
num_names, names, sids, types, num_sids);
- return (ret == NT_STATUS_NOPROBLEMO);
+ return (ret == NT_STATUS_OK);
}
/****************************************************************************
ret = cli_lsa_lookup_sids(hnd->cli, hnd->mem_ctx, &hnd->handle,
num_sids, sids, names, types, num_names);
- return (ret == NT_STATUS_NOPROBLEMO);
+ return (ret == NT_STATUS_OK);
}
/****************************************************************************
ret = cli_lsa_close(hnd->cli, hnd->mem_ctx, &hnd->handle);
- return (ret == NT_STATUS_NOPROBLEMO);
+ return (ret == NT_STATUS_OK);
}
ret = cli_samr_close(hnd->cli, hnd->mem_ctx, &hnd->handle);
- return (ret == NT_STATUS_NOPROBLEMO);
+ return (ret == NT_STATUS_OK);
}
access_mask, &pol->handle);
done:
- if (result != NT_STATUS_NOPROBLEMO && pol->cli) {
+ if (result != NT_STATUS_OK && pol->cli) {
if (pol->cli->initialised)
cli_shutdown(pol->cli);
free(pol->cli);
}
- return (result == NT_STATUS_NOPROBLEMO);
+ return (result == NT_STATUS_OK);
}
sid,
&domain_pol->handle);
- if (ret == NT_STATUS_NOPROBLEMO) {
+ if (ret == NT_STATUS_OK) {
domain_pol->cli = connect_pol->cli;
domain_pol->mem_ctx = connect_pol->mem_ctx;
return True;
ret = cli_samr_enum_dom_groups(pol->cli, pol->mem_ctx, &pol->handle,
start_idx, size, sam, num_sam_groups);
- return (ret == NT_STATUS_NOPROBLEMO);
+ return (ret == NT_STATUS_OK);
}
/****************************************************************************
if ((result = cli_samr_open_user(pol->cli, pol->mem_ctx,
&pol->handle, MAXIMUM_ALLOWED_ACCESS,
user_rid, &user_pol))
- != NT_STATUS_NOPROBLEMO)
+ != NT_STATUS_OK)
goto done;
got_user_pol = True;
if ((result = cli_samr_query_userinfo(pol->cli, pol->mem_ctx,
&user_pol, info_level, ctr))
- != NT_STATUS_NOPROBLEMO)
+ != NT_STATUS_OK)
goto done;
done:
if (got_user_pol) cli_samr_close(pol->cli, pol->mem_ctx, &user_pol);
- return (result == NT_STATUS_NOPROBLEMO);
+ return (result == NT_STATUS_OK);
}
/****************************************************************************
ret = cli_samr_open_user(pol->cli, pol->mem_ctx, &pol->handle,
access_mask, rid, user_pol);
- return (ret == NT_STATUS_NOPROBLEMO);
+ return (ret == NT_STATUS_OK);
}
BOOL wb_samr_query_usergroups(CLI_POLICY_HND *pol, uint32 *num_groups,
ret = cli_samr_query_usergroups(pol->cli, pol->mem_ctx, &pol->handle,
num_groups, gid);
- return (ret == NT_STATUS_NOPROBLEMO);
+ return (ret == NT_STATUS_OK);
}
BOOL wb_get_samr_query_groupinfo(CLI_POLICY_HND *pol, uint32 info_level,
if ((result = cli_samr_open_group(pol->cli, pol->mem_ctx,
&pol->handle, MAXIMUM_ALLOWED_ACCESS,
group_rid, &group_pol))
- != NT_STATUS_NOPROBLEMO)
+ != NT_STATUS_OK)
goto done;
got_group_pol = True;
if ((result = cli_samr_query_groupinfo(pol->cli, pol->mem_ctx,
&group_pol, info_level,
- ctr)) != NT_STATUS_NOPROBLEMO)
+ ctr)) != NT_STATUS_OK)
goto done;
done:
if (got_group_pol) cli_samr_close(pol->cli, pol->mem_ctx, &group_pol);
- return (result == NT_STATUS_NOPROBLEMO);
+ return (result == NT_STATUS_OK);
}
BOOL wb_sam_query_groupmem(CLI_POLICY_HND *pol, uint32 group_rid,
if ((result = cli_samr_open_group(pol->cli, pol->mem_ctx,
&pol->handle, MAXIMUM_ALLOWED_ACCESS,
group_rid, &group_pol))
- != NT_STATUS_NOPROBLEMO)
+ != NT_STATUS_OK)
goto done;
got_group_pol = True;
if ((result = cli_samr_query_groupmem(pol->cli, pol->mem_ctx,
&group_pol, num_names, rid_mem,
name_types))
- != NT_STATUS_NOPROBLEMO)
+ != NT_STATUS_OK)
goto done;
/* Call cli_samr_lookup_rids() in bunches of ~1000 rids to avoid
&tmp_num_names,
&tmp_names, &tmp_types);
- if (result != NT_STATUS_NOPROBLEMO)
+ if (result != NT_STATUS_OK)
goto done;
/* Copy result into array. The talloc system will take
if (got_group_pol)
cli_samr_close(pol->cli, pol->mem_ctx, &group_pol);
- return (result == NT_STATUS_NOPROBLEMO);
+ return (result == NT_STATUS_OK);
}
BOOL wb_samr_query_dom_info(CLI_POLICY_HND *pol, uint16 switch_value,
ret = cli_samr_query_dom_info(pol->cli, pol->mem_ctx,
&pol->handle, switch_value, ctr);
- return (ret == NT_STATUS_NOPROBLEMO);
+ return (ret == NT_STATUS_OK);
}
/* Unlike all the others, the status code of this function is actually used
static BOOL get_sam_group_entries(struct getent_state *ent)
{
- uint32 status, num_entries, start_ndx = 0;
+ NTSTATUS status, num_entries, start_ndx = 0;
struct acct_info *name_list = NULL;
if (ent->got_all_sam_entries) {
/* Pass back result code - zero for success, other values for
specific failures. */
- DEBUG(3, ("secret is %s\n", (result == NT_STATUS_NOPROBLEMO) ?
+ DEBUG(3, ("secret is %s\n", (result == NT_STATUS_OK) ?
"good" : "bad"));
done:
server_state.controller, trust_passwd,
last_change_time);
- return (result == NT_STATUS_NOPROBLEMO) ? WINBINDD_OK : WINBINDD_ERROR;
+ return (result == NT_STATUS_OK) ? WINBINDD_OK : WINBINDD_ERROR;
}
/* Challenge Response Authentication Protocol */
server_state.controller, trust_passwd,
last_change_time);
- return (result == NT_STATUS_NOPROBLEMO) ? WINBINDD_OK : WINBINDD_ERROR;
+ return (result == NT_STATUS_OK) ? WINBINDD_OK : WINBINDD_ERROR;
}
/* Change a user password */
static BOOL get_sam_user_entries(struct getent_state *ent)
{
- uint32 status, num_entries;
+ NTSTATUS status, num_entries;
SAM_DISPINFO_1 info1;
SAM_DISPINFO_CTR ctr;
struct getpwent_user *name_list = NULL;
ctr.sam.info1 = &info1;
for (domain = domain_list; domain; domain = domain->next) {
- uint32 status, start_ndx = 0;
+ NTSTATUS status, start_ndx = 0;
/* Skip domains other than WINBINDD_DOMAIN environment
variable */
if (cli_samr_query_usergroups(domain->sam_dom_handle.cli,
domain->sam_dom_handle.mem_ctx,
&user_pol, num_groups, user_groups)
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
result = False;
goto done;
}
uint32 *start_ndx, uint16 info_level,
uint32 *num_entries, SAM_DISPINFO_CTR *ctr)
{
- uint32 status;
+ NTSTATUS status;
status = wb_samr_query_dispinfo(&domain->sam_dom_handle, start_ndx,
info_level, num_entries, ctr);
if (smb_pam_error_handler(pamh, pam_error, msg, dbglvl))
return True;
- if (*nt_status == NT_STATUS_NOPROBLEMO) {
+ if (*nt_status == NT_STATUS_OK) {
/* Complain LOUDLY */
DEBUG(0, ("smb_pam_nt_status_error_handler: PAM: BUG: PAM and NT_STATUS \
error MISMATCH, forcing to NT_STATUS_LOGON_FAILURE"));
break;
case PAM_SUCCESS:
DEBUG(4, ("smb_pam_auth: PAM: User %s Authenticated OK\n", user));
- nt_status = NT_STATUS_NOPROBLEMO;
+ nt_status = NT_STATUS_OK;
break;
default:
DEBUG(0, ("smb_pam_auth: PAM: UNKNOWN ERROR while authenticating user %s\n", user));
break;
case PAM_SUCCESS:
DEBUG(4, ("smb_pam_account: PAM: Account OK for User: %s\n", user));
- nt_status = NT_STATUS_NOPROBLEMO;
+ nt_status = NT_STATUS_OK;
break;
default:
nt_status = NT_STATUS_ACCOUNT_DISABLED;
break;
case PAM_SUCCESS:
DEBUG(4, ("smb_pam_setcred: PAM: SetCredentials OK for User: %s\n", user));
- nt_status = NT_STATUS_NOPROBLEMO;
+ nt_status = NT_STATUS_OK;
break;
default:
DEBUG(0, ("smb_pam_setcred: PAM: UNKNOWN PAM ERROR (%d) during SetCredentials for User: %s\n", pam_error, user));
/* Ignore PAM if told to. */
if (!lp_obey_pam_restrictions())
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
if ((pconv = smb_setup_pam_conv(smb_pam_conv, user, NULL, NULL)) == NULL)
return False;
if (!smb_pam_start(&pamh, user, NULL, pconv))
return NT_STATUS_ACCOUNT_DISABLED;
- if ((nt_status = smb_pam_account(pamh, user)) != NT_STATUS_NOPROBLEMO)
+ if ((nt_status = smb_pam_account(pamh, user)) != NT_STATUS_OK)
DEBUG(0, ("smb_pam_accountcheck: PAM: Account Validation Failed - Rejecting User %s!\n", user));
smb_pam_end(pamh, pconv);
if (!smb_pam_start(&pamh, user, NULL, pconv))
return NT_STATUS_LOGON_FAILURE;
- if ((nt_status = smb_pam_auth(pamh, user)) != NT_STATUS_NOPROBLEMO) {
+ if ((nt_status = smb_pam_auth(pamh, user)) != NT_STATUS_OK) {
DEBUG(0, ("smb_pam_passcheck: PAM: smb_pam_auth failed - Rejecting User %s !\n", user));
smb_pam_end(pamh, pconv);
return nt_status;
}
- if ((nt_status = smb_pam_account(pamh, user)) != NT_STATUS_NOPROBLEMO) {
+ if ((nt_status = smb_pam_account(pamh, user)) != NT_STATUS_OK) {
DEBUG(0, ("smb_pam_passcheck: PAM: smb_pam_account failed - Rejecting User %s !\n", user));
smb_pam_end(pamh, pconv);
return nt_status;
}
- if ((nt_status = smb_pam_setcred(pamh, user)) != NT_STATUS_NOPROBLEMO) {
+ if ((nt_status = smb_pam_setcred(pamh, user)) != NT_STATUS_OK) {
DEBUG(0, ("smb_pam_passcheck: PAM: smb_pam_setcred failed - Rejecting User %s !\n", user));
smb_pam_end(pamh, pconv);
return nt_status;
/* If PAM not used, no PAM restrictions on accounts. */
uint32 smb_pam_accountcheck(char * user)
{
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/* If PAM not used, also no PAM restrictions on sessions. */
{
#ifdef WITH_PAM
- return (smb_pam_passcheck(this_user, password) == NT_STATUS_NOPROBLEMO);
+ return (smb_pam_passcheck(this_user, password) == NT_STATUS_OK);
#endif /* WITH_PAM */
#ifdef WITH_AFS
driver->driverpath, user, &err)) == -1)
return err;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/****************************************************************************
driver->driverpath, user, &err)) == -1)
return err;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/****************************************************************************
uint32 save_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level, NT_PRINTER_PARAM *param)
{
- uint32 status = ERRsuccess;
+ NTSTATUS status = ERRsuccess;
switch (level)
{
Remove a printer driver from the TDB. This assumes that the the driver was
previously looked up.
***************************************************************************/
-uint32 delete_printer_driver (NT_PRINTER_DRIVER_INFO_LEVEL_3 *i)
+NTSTATUS delete_printer_driver (NT_PRINTER_DRIVER_INFO_LEVEL_3 *i)
{
pstring key;
fstring arch;
DEBUG(5,("delete_printer_driver: [%s] driver delete successful.\n",
i->name));
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
prs_struct ps;
TALLOC_CTX *mem_ctx = NULL;
fstring key;
- uint32 status;
+ NTSTATUS status;
mem_ctx = talloc_init();
if (mem_ctx == NULL)
return r_l.status;
}
- result = NT_STATUS_NOPROBLEMO;
+ result = NT_STATUS_OK;
if (p) {
if (t_names.ptr_trans_names != 0
/****************************************************************************
do a LSA Logon Control2
****************************************************************************/
-BOOL cli_net_logon_ctrl2(struct cli_state *cli, uint32 status_level)
+BOOL cli_net_logon_ctrl2(struct cli_state *cli, NTSTATUS status_level)
{
prs_struct rbuf;
prs_struct buf;
result = cli_net_sam_logon_internal(cli, ctr, user_info3,
validation_level);
- if(result == NT_STATUS_NOPROBLEMO) {
+ if(result == NT_STATUS_OK) {
DEBUG(10,("cli_net_sam_logon: Success \n"));
} else if (result == NT_STATUS_INVALID_INFO_CLASS) {
DEBUG(10,("cli_net_sam_logon: STATUS INVALID INFO CLASS \n"));
if(spoolss_io_r_enumprinterdrivers("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
DEBUG(3,("SPOOLSS_ENUMPRINTERDRIVERS: %s\n", get_nt_error_msg(r_o.status)));
}
if(new_spoolss_io_r_enumprinters("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
/* report error code */
DEBUG(3,("SPOOLSS_ENUMPRINTERS: %s\n", get_nt_error_msg(r_o.status)));
if(new_spoolss_io_r_enumports("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
DEBUG(3,("SPOOLSS_ENUMPORTS: %s\n", get_nt_error_msg(r_o.status)));
}
if(spoolss_io_r_enumjobs("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
DEBUG(3,("SPOOLSS_ENUMJOBS: %s\n", get_nt_error_msg(r_o.status)));
}
if(spoolss_io_r_enumprinterdata("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
DEBUG(3,("SPOOLSS_ENUMPRINTERDATA: %s\n", get_nt_error_msg(r_o.status)));
}
if(!spoolss_io_r_getprinter("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
DEBUG(3,("SPOOLSS_GETPRINTER: %s\n", get_nt_error_msg(r_o.status)));
}
if(spoolss_io_r_getprinterdriver2("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
DEBUG(3,("SPOOLSS_GETPRINTERDRIVER2: %s\n", get_nt_error_msg(r_o.status)));
}
if(spoolss_io_r_addprinterex("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
/* report error code */
DEBUG(3,("SPOOLSS_ADDPRINTEREX: %s\n", get_nt_error_msg(r_o.status)));
if(spoolss_io_r_getprinterdata("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
DEBUG(3,("SPOOLSS_GETPRINTERDATA: %s\n", get_nt_error_msg(r_o.status)));
}
if(spoolss_io_r_getprinterdriverdir("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
DEBUG(3,("SPOOLSS_GETPRINTERDRIVERDIRECTORY: %s\n", get_nt_error_msg(r_o.status)));
}
if(spoolss_io_r_addprinterdriver("", &r_o, &rbuf, 0))
{
- if (r_o.status != NT_STATUS_NOPROBLEMO)
+ if (r_o.status != NT_STATUS_OK)
{
/* report error code */
DEBUG(3,("SPOOLSS_ADDPRINTERDRIVER: %s\n", get_nt_error_msg(r_o.status)));
do a reply open printer
****************************************************************************/
-BOOL cli_spoolss_reply_open_printer(struct cli_state *cli, char *printer, uint32 localprinter, uint32 type, uint32 *status, POLICY_HND *handle)
+BOOL cli_spoolss_reply_open_printer(struct cli_state *cli, char *printer, uint32 localprinter, uint32 type, NTSTATUS *status, POLICY_HND *handle)
{
prs_struct rbuf;
prs_struct buf;
****************************************************************************/
BOOL cli_spoolss_reply_rrpcn(struct cli_state *cli, POLICY_HND *handle,
- uint32 change_low, uint32 change_high, uint32 *status)
+ uint32 change_low, uint32 change_high, NTSTATUS *status)
{
prs_struct rbuf;
prs_struct buf;
do a reply open printer
****************************************************************************/
-BOOL cli_spoolss_reply_close_printer(struct cli_state *cli, POLICY_HND *handle, uint32 *status)
+BOOL cli_spoolss_reply_close_printer(struct cli_state *cli, POLICY_HND *handle, NTSTATUS *status)
{
prs_struct rbuf;
prs_struct buf;
BOOL msrpc_spoolss_enum_printers(char* srv_name, uint32 flags,
uint32 level, PRINTER_INFO_CTR ctr)
{
- uint32 status;
+ NTSTATUS status;
NEW_BUFFER buffer;
uint32 needed;
uint32 returned;
needed, &needed, &returned);
}
- if (status!=NT_STATUS_NOPROBLEMO)
+ if (status!=NT_STATUS_OK)
{
DEBUG(0,("spoolss_enum_printers: %s\n", get_nt_error_msg(status)));
if (mem_ctx)
BOOL msrpc_spoolss_enum_ports(char* srv_name,
uint32 level, PORT_INFO_CTR *ctr)
{
- uint32 status;
+ NTSTATUS status;
NEW_BUFFER buffer;
uint32 needed;
uint32 returned;
report(out_hnd, "\tstatus:[%d (%x)]\n", status, status);
- if (status!=NT_STATUS_NOPROBLEMO)
+ if (status!=NT_STATUS_OK)
{
if (mem_ctx)
talloc_destroy(mem_ctx);
void *fn)
{
POLICY_HND hnd;
- uint32 status;
+ NTSTATUS status;
uint32 needed;
uint32 size;
char *data;
if (mem_ctx)
talloc_destroy(mem_ctx);
- if (status != NT_STATUS_NOPROBLEMO)
+ if (status != NT_STATUS_OK)
{
if (!spoolss_closeprinter(&hnd))
return NT_STATUS_ACCESS_DENIED;
void ***ctr, JOB_INFO_FN(fn))
{
POLICY_HND hnd;
- uint32 status;
+ NTSTATUS status;
NEW_BUFFER buffer;
uint32 needed;
uint32 returned;
if (mem_ctx)
talloc_destroy(mem_ctx);
- if (status!=NT_STATUS_NOPROBLEMO) {
+ if (status!=NT_STATUS_OK) {
if (!spoolss_closeprinter(&hnd))
return False;
return False;
const char* station, const char* user_name )
{
POLICY_HND hnd;
- uint32 status;
+ NTSTATUS status;
uint32 idx;
uint32 valuelen;
uint16 *value;
value, rvaluelen, type, datalen, data, rdatalen);
- if (status!=NT_STATUS_NOPROBLEMO) {
+ if (status!=NT_STATUS_OK) {
/*
* the check on this if statement is redundant
* since is the status is bad we're going to
PRINTER_INFO_CTR ctr)
{
POLICY_HND hnd;
- uint32 status=0;
+ NTSTATUS status=0;
NEW_BUFFER buffer;
uint32 needed=1000;
TALLOC_CTX *mem_ctx = NULL;
report(out_hnd, "\tstatus:[%d (%x)]\n", status, status);
- if (status!=NT_STATUS_NOPROBLEMO)
+ if (status!=NT_STATUS_OK)
{
if (mem_ctx)
talloc_destroy(mem_ctx);
if (mem_ctx)
talloc_destroy(mem_ctx);
- if (status!=NT_STATUS_NOPROBLEMO) {
+ if (status!=NT_STATUS_OK) {
if (!spoolss_closeprinter(&hnd))
return False;
return False;
PRINTER_DRIVER_CTR ctr)
{
POLICY_HND hnd;
- uint32 status=0;
+ NTSTATUS status=0;
NEW_BUFFER buffer;
uint32 needed;
TALLOC_CTX *mem_ctx = NULL;
/* report(out_hnd, "\tstatus:[%d (%x)]\n", status, status); */
- if (status!=NT_STATUS_NOPROBLEMO)
+ if (status!=NT_STATUS_OK)
{
if (mem_ctx)
talloc_destroy(mem_ctx);
if (mem_ctx)
talloc_destroy(mem_ctx);
- if (status!=NT_STATUS_NOPROBLEMO) {
+ if (status!=NT_STATUS_OK) {
if (!spoolss_closeprinter(&hnd))
return False;
return False;
const char *environment, const uint32 level,
PRINTER_DRIVER_CTR ctr)
{
- uint32 status=0;
+ NTSTATUS status=0;
NEW_BUFFER buffer;
uint32 needed;
uint32 returned;
report(out_hnd, "\tstatus:[%d (%x)]\n", status, status);
- if (status!=NT_STATUS_NOPROBLEMO)
+ if (status!=NT_STATUS_OK)
{
if (mem_ctx)
talloc_destroy(mem_ctx);
****************************************************************************/
BOOL msrpc_spoolss_getprinterdriverdir(char* srv_name, char* env_name, uint32 level, DRIVER_DIRECTORY_CTR ctr)
{
- uint32 status;
+ NTSTATUS status;
NEW_BUFFER buffer;
uint32 needed;
TALLOC_CTX *mem_ctx = NULL;
report(out_hnd, "\tstatus:[%d (%x)]\n", status, status);
- if (status!=NT_STATUS_NOPROBLEMO)
+ if (status!=NT_STATUS_OK)
{
if (mem_ctx)
talloc_destroy(mem_ctx);
void init_r_enum_trust_dom(TALLOC_CTX *ctx, LSA_R_ENUM_TRUST_DOM *r_e, uint32 enum_context,
char *domain_name, DOM_SID *domain_sid,
- uint32 status)
+ NTSTATUS status)
{
DEBUG(5, ("init_r_enum_trust_dom\n"));
********************************************************************/
void init_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol,
uint32 buf_len, uint8 *buf,
- uint32 status)
+ NTSTATUS status)
{
r_i->ptr = 1;
init_buf_hdr(&r_i->hdr_sec, buf_len, buf_len);
********************************************************************/
BOOL init_reg_r_info(uint32 include_keyval, REG_R_INFO *r_r,
- BUFFER2* buf, uint32 type, uint32 status)
+ BUFFER2* buf, uint32 type, NTSTATUS status)
{
if(r_r == NULL)
return False;
********************************************************************/
void init_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
- POLICY_HND *pol, uint32 status)
+ POLICY_HND *pol, NTSTATUS status)
{
memcpy(&r_r->pol, pol, sizeof(r_r->pol));
r_r->status = status;
********************************************************************/
void init_samr_r_lookup_domain(SAMR_R_LOOKUP_DOMAIN * r_u,
- DOM_SID *dom_sid, uint32 status)
+ DOM_SID *dom_sid, NTSTATUS status)
{
DEBUG(5, ("init_samr_r_lookup_domain\n"));
Init.
********************************************************************/
-void init_samr_r_get_usrdom_pwinfo(SAMR_R_GET_USRDOM_PWINFO *r_u, uint32 status)
+void init_samr_r_get_usrdom_pwinfo(SAMR_R_GET_USRDOM_PWINFO *r_u, NTSTATUS status)
{
DEBUG(5, ("init_samr_r_get_usrdom_pwinfo\n"));
void init_samr_r_query_dom_info(SAMR_R_QUERY_DOMAIN_INFO * r_u,
uint16 switch_value, SAM_UNK_CTR * ctr,
- uint32 status)
+ NTSTATUS status)
{
DEBUG(5, ("init_samr_r_query_dom_info\n"));
inits a SAM_DISPINFO_1 structure.
********************************************************************/
-uint32 init_sam_dispinfo_1(TALLOC_CTX *ctx, SAM_DISPINFO_1 *sam, uint32 *num_entries,
+NTSTATUS init_sam_dispinfo_1(TALLOC_CTX *ctx, SAM_DISPINFO_1 *sam, uint32 *num_entries,
uint32 *data_size, uint32 start_idx,
SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
{
max_entries, max_data_size));
if (max_entries==0)
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
sam->sam=(SAM_ENTRY1 *)talloc(ctx, max_entries*sizeof(SAM_ENTRY1));
if (!sam->sam)
*num_entries = i;
*data_size = dsize;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
inits a SAM_DISPINFO_2 structure.
********************************************************************/
-uint32 init_sam_dispinfo_2(TALLOC_CTX *ctx, SAM_DISPINFO_2 *sam, uint32 *num_entries,
+NTSTATUS init_sam_dispinfo_2(TALLOC_CTX *ctx, SAM_DISPINFO_2 *sam, uint32 *num_entries,
uint32 *data_size, uint32 start_idx,
SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
{
max_data_size = *data_size;
if (max_entries==0)
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
if (!(sam->sam=(SAM_ENTRY2 *)talloc(ctx, max_entries*sizeof(SAM_ENTRY2))))
return NT_STATUS_NO_MEMORY;
*num_entries = i;
*data_size = dsize;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
inits a SAM_DISPINFO_3 structure.
********************************************************************/
-uint32 init_sam_dispinfo_3(TALLOC_CTX *ctx, SAM_DISPINFO_3 *sam, uint32 *num_entries,
+NTSTATUS init_sam_dispinfo_3(TALLOC_CTX *ctx, SAM_DISPINFO_3 *sam, uint32 *num_entries,
uint32 *data_size, uint32 start_idx,
DOMAIN_GRP * grp)
{
max_data_size = *data_size;
if (max_entries==0)
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
if (!(sam->sam=(SAM_ENTRY3 *)talloc(ctx, max_entries*sizeof(SAM_ENTRY3))))
return NT_STATUS_NO_MEMORY;
*num_entries = i;
*data_size = dsize;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
inits a SAM_DISPINFO_4 structure.
********************************************************************/
-uint32 init_sam_dispinfo_4(TALLOC_CTX *ctx, SAM_DISPINFO_4 *sam, uint32 *num_entries,
+NTSTATUS init_sam_dispinfo_4(TALLOC_CTX *ctx, SAM_DISPINFO_4 *sam, uint32 *num_entries,
uint32 *data_size, uint32 start_idx,
SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
{
max_data_size = *data_size;
if (max_entries==0)
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
if (!(sam->sam=(SAM_ENTRY4 *)talloc(ctx, max_entries*sizeof(SAM_ENTRY4))))
return NT_STATUS_NO_MEMORY;
*num_entries = i;
*data_size = dsize;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
inits a SAM_DISPINFO_5 structure.
********************************************************************/
-uint32 init_sam_dispinfo_5(TALLOC_CTX *ctx, SAM_DISPINFO_5 *sam, uint32 *num_entries,
+NTSTATUS init_sam_dispinfo_5(TALLOC_CTX *ctx, SAM_DISPINFO_5 *sam, uint32 *num_entries,
uint32 *data_size, uint32 start_idx,
DOMAIN_GRP * grp)
{
max_data_size = *data_size;
if (max_entries==0)
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
if (!(sam->sam=(SAM_ENTRY5 *)talloc(ctx, max_entries*sizeof(SAM_ENTRY5))))
return NT_STATUS_NO_MEMORY;
*num_entries = i;
*data_size = dsize;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
void init_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO * r_u,
uint32 num_entries, uint32 data_size,
uint16 switch_level, SAM_DISPINFO_CTR * ctr,
- uint32 status)
+ NTSTATUS status)
{
DEBUG(5, ("init_samr_r_query_dispinfo: level %d\n", switch_level));
********************************************************************/
void init_samr_r_del_groupmem(SAMR_R_DEL_GROUPMEM * r_u, POLICY_HND *pol,
- uint32 status)
+ NTSTATUS status)
{
DEBUG(5, ("init_samr_r_del_groupmem\n"));
********************************************************************/
void init_samr_r_add_groupmem(SAMR_R_ADD_GROUPMEM * r_u, POLICY_HND *pol,
- uint32 status)
+ NTSTATUS status)
{
DEBUG(5, ("init_samr_r_add_groupmem\n"));
inits a SAMR_R_SET_GROUPINFO structure.
********************************************************************/
-void init_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO * r_u, uint32 status)
+void init_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO * r_u, NTSTATUS status)
{
DEBUG(5, ("init_samr_r_set_groupinfo\n"));
********************************************************************/
void init_samr_r_query_groupinfo(SAMR_R_QUERY_GROUPINFO * r_u,
- GROUP_INFO_CTR * ctr, uint32 status)
+ GROUP_INFO_CTR * ctr, NTSTATUS status)
{
DEBUG(5, ("init_samr_r_query_groupinfo\n"));
void init_samr_r_query_groupmem(SAMR_R_QUERY_GROUPMEM * r_u,
uint32 num_entries, uint32 *rid,
- uint32 *attr, uint32 status)
+ uint32 *attr, NTSTATUS status)
{
DEBUG(5, ("init_samr_r_query_groupmem\n"));
void init_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS * r_u,
uint32 num_gids, DOM_GID * gid,
- uint32 status)
+ NTSTATUS status)
{
DEBUG(5, ("init_samr_r_query_usergroups\n"));
********************************************************************/
void init_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO * r_u,
- ALIAS_INFO_CTR * ctr, uint32 status)
+ ALIAS_INFO_CTR * ctr, NTSTATUS status)
{
DEBUG(5, ("init_samr_r_query_aliasinfo\n"));
void init_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES * r_u,
uint32 num_rids, uint32 *rid,
- uint32 status)
+ NTSTATUS status)
{
DEBUG(5, ("init_samr_r_query_useraliases\n"));
********************************************************************/
void init_samr_r_delete_dom_alias(SAMR_R_DELETE_DOM_ALIAS * r_u,
- uint32 status)
+ NTSTATUS status)
{
DEBUG(5, ("init_samr_r_delete_dom_alias\n"));
void init_samr_r_query_aliasmem(SAMR_R_QUERY_ALIASMEM * r_u,
uint32 num_sids, DOM_SID2 * sid,
- uint32 status)
+ NTSTATUS status)
{
DEBUG(5, ("init_samr_r_query_aliasmem\n"));
inits a SAMR_Q_LOOKUP_NAMES structure.
********************************************************************/
-uint32 init_samr_q_lookup_names(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_NAMES * q_u,
+NTSTATUS init_samr_q_lookup_names(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_NAMES * q_u,
POLICY_HND *pol, uint32 flags,
uint32 num_names, char **name)
{
init_unistr2(&q_u->uni_name[i], name[i], len_name); /* unicode string for machine account */
}
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
inits a SAMR_R_LOOKUP_NAMES structure.
********************************************************************/
-uint32 init_samr_r_lookup_names(TALLOC_CTX *ctx, SAMR_R_LOOKUP_NAMES * r_u,
+NTSTATUS init_samr_r_lookup_names(TALLOC_CTX *ctx, SAMR_R_LOOKUP_NAMES * r_u,
uint32 num_rids,
uint32 *rid, uint32 *type,
- uint32 status)
+ NTSTATUS status)
{
DEBUG(5, ("init_samr_r_lookup_names\n"));
r_u->status = status;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
inits a SAM_USERINFO_CTR structure.
********************************************************************/
-uint32 make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
+NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
uint16 switch_value,
SAM_USER_INFO_21 * usr)
{
return NT_STATUS_INVALID_INFO_CLASS;
}
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
********************************************************************/
void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
- SAM_USERINFO_CTR * ctr, uint32 status)
+ SAM_USERINFO_CTR * ctr, NTSTATUS status)
{
DEBUG(5, ("init_samr_r_query_userinfo\n"));
inits a SAMR_R_SET_USERINFO structure.
********************************************************************/
-void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, uint32 status)
+void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
{
DEBUG(5, ("init_samr_r_set_userinfo\n"));
inits a SAMR_R_SET_USERINFO2 structure.
********************************************************************/
-void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, uint32 status)
+void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
{
DEBUG(5, ("init_samr_r_set_userinfo2\n"));
inits a SAMR_R_CHGPASSWD_USER structure.
********************************************************************/
-void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, uint32 status)
+void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
{
DEBUG(5, ("init_r_chgpasswd_user\n"));
********************************************************************/
void init_srv_r_net_srv_get_info(SRV_R_NET_SRV_GET_INFO *srv,
- uint32 switch_value, SRV_INFO_CTR *ctr, uint32 status)
+ uint32 switch_value, SRV_INFO_CTR *ctr, NTSTATUS status)
{
DEBUG(5,("init_srv_r_net_srv_get_info\n"));
********************************************************************/
void init_srv_r_net_srv_set_info(SRV_R_NET_SRV_SET_INFO *srv,
- uint32 switch_value, uint32 status)
+ uint32 switch_value, NTSTATUS status)
{
DEBUG(5,("init_srv_r_net_srv_set_info\n"));
********************************************************************/
void init_wks_r_query_info(WKS_R_QUERY_INFO *r_u,
- uint32 switch_value, WKS_INFO_100 *wks100,
- int status)
+ uint32 switch_value, WKS_INFO_100 *wks100,
+ NTSTATUS status)
{
DEBUG(5,("init_wks_r_unknown_0: %d\n", __LINE__));
if(!create_msdfs_link(&jn, exists))
return NERR_DfsCantCreateJunctionPoint;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
uint32 _dfs_remove(pipes_struct *p, DFS_Q_DFS_REMOVE *q_u, DFS_R_DFS_REMOVE *r_u)
}
}
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
static BOOL init_reply_dfs_info_1(struct junction_map* j, DFS_INFO_1* dfs1, int num_j)
default:
return NT_STATUS_INVALID_LEVEL;
}
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
uint32 _dfs_enum(pipes_struct *p, DFS_Q_DFS_ENUM *q_u, DFS_R_DFS_ENUM *r_u)
if (mapped_count == 0)
r_l->status = NT_STATUS_NONE_MAPPED;
else
- r_l->status = NT_STATUS_NOPROBLEMO;
+ r_l->status = NT_STATUS_OK;
}
/***************************************************************************
if (mapped_count == 0)
r_l->status = NT_STATUS_NONE_MAPPED;
else
- r_l->status = NT_STATUS_NOPROBLEMO;
+ r_l->status = NT_STATUS_OK;
}
/***************************************************************************
if (!create_policy_hnd(p, &r_u->pol, NULL, NULL))
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/***************************************************************************
_lsa_open_policy
***************************************************************************/
-uint32 _lsa_open_policy(pipes_struct *p, LSA_Q_OPEN_POL *q_u, LSA_R_OPEN_POL *r_u)
+NTSTATUS _lsa_open_policy(pipes_struct *p, LSA_Q_OPEN_POL *q_u, LSA_R_OPEN_POL *r_u)
{
/* lkclXXXX having decoded it, ignore all fields in the open policy! */
if (!create_policy_hnd(p, &r_u->pol, NULL, NULL))
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/***************************************************************************
_lsa_enum_trust_dom - this needs fixing to do more than return NULL ! JRA.
***************************************************************************/
-uint32 _lsa_enum_trust_dom(pipes_struct *p, LSA_Q_ENUM_TRUST_DOM *q_u, LSA_R_ENUM_TRUST_DOM *r_u)
+NTSTATUS _lsa_enum_trust_dom(pipes_struct *p, LSA_Q_ENUM_TRUST_DOM *q_u, LSA_R_ENUM_TRUST_DOM *r_u)
{
uint32 enum_context = 0;
char *dom_name = NULL;
/* set up the LSA QUERY INFO response */
init_r_enum_trust_dom(p->mem_ctx, r_u, enum_context, dom_name, dom_sid,
- dom_name != NULL ? NT_STATUS_NOPROBLEMO : NT_STATUS_UNABLE_TO_FREE_VM);
+ dom_name != NULL ? NT_STATUS_OK : NT_STATUS_UNABLE_TO_FREE_VM);
return r_u->status;
}
_lsa_query_info. See the POLICY_INFOMATION_CLASS docs at msdn.
***************************************************************************/
-uint32 _lsa_query_info(pipes_struct *p, LSA_Q_QUERY_INFO *q_u, LSA_R_QUERY_INFO *r_u)
+NTSTATUS _lsa_query_info(pipes_struct *p, LSA_Q_QUERY_INFO *q_u, LSA_R_QUERY_INFO *r_u)
{
LSA_INFO_UNION *info = &r_u->dom;
DOM_SID domain_sid;
char *name = NULL;
DOM_SID *sid = NULL;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
if (!find_policy_by_hnd(p, &q_u->pol, NULL))
return NT_STATUS_INVALID_HANDLE;
info->id2.count1 = 7;
info->id2.count2 = 7;
if ((info->id2.auditsettings = (uint32 *)talloc(p->mem_ctx,7*sizeof(uint32))) == NULL)
- return False;
+ return NT_STATUS_NO_MEMORY;
for (i = 0; i < 7; i++)
info->id2.auditsettings[i] = 3;
break;
break;
}
- if(r_u->status == NT_STATUS_NOPROBLEMO) {
+ if (NT_STATUS_IS_OK(r_u->status)) {
r_u->undoc_buffer = 0x22000000; /* bizarre */
r_u->info_class = q_u->info_class;
}
_lsa_lookup_sids
***************************************************************************/
-uint32 _lsa_lookup_sids(pipes_struct *p, LSA_Q_LOOKUP_SIDS *q_u, LSA_R_LOOKUP_SIDS *r_u)
+NTSTATUS _lsa_lookup_sids(pipes_struct *p, LSA_Q_LOOKUP_SIDS *q_u, LSA_R_LOOKUP_SIDS *r_u)
{
DOM_SID2 *sid = q_u->sids.sid;
int num_entries = q_u->sids.num_entries;
lsa_reply_lookup_names
***************************************************************************/
-uint32 _lsa_lookup_names(pipes_struct *p,LSA_Q_LOOKUP_NAMES *q_u, LSA_R_LOOKUP_NAMES *r_u)
+NTSTATUS _lsa_lookup_names(pipes_struct *p,LSA_Q_LOOKUP_NAMES *q_u, LSA_R_LOOKUP_NAMES *r_u)
{
UNISTR2 *names = q_u->uni_name;
int num_entries = q_u->num_entries;
_lsa_close. Also weird - needs to check if lsa handle is correct. JRA.
***************************************************************************/
-uint32 _lsa_close(pipes_struct *p, LSA_Q_CLOSE *q_u, LSA_R_CLOSE *r_u)
+NTSTATUS _lsa_close(pipes_struct *p, LSA_Q_CLOSE *q_u, LSA_R_CLOSE *r_u)
{
if (!find_policy_by_hnd(p, &q_u->pol, NULL))
return NT_STATUS_INVALID_HANDLE;
close_policy_hnd(p, &q_u->pol);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/***************************************************************************
"No more secrets Marty...." :-).
***************************************************************************/
-uint32 _lsa_open_secret(pipes_struct *p, LSA_Q_OPEN_SECRET *q_u, LSA_R_OPEN_SECRET *r_u)
+NTSTATUS _lsa_open_secret(pipes_struct *p, LSA_Q_OPEN_SECRET *q_u, LSA_R_OPEN_SECRET *r_u)
{
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
_lsa_enum_privs.
***************************************************************************/
-uint32 _lsa_enum_privs(pipes_struct *p, LSA_Q_ENUM_PRIVS *q_u, LSA_R_ENUM_PRIVS *r_u)
+NTSTATUS _lsa_enum_privs(pipes_struct *p, LSA_Q_ENUM_PRIVS *q_u, LSA_R_ENUM_PRIVS *r_u)
{
uint32 i;
return NT_STATUS_INVALID_HANDLE;
if (enum_context >= PRIV_ALL_INDEX)
- return 0x8000001A;
+ return NT_STATUS_UNABLE_TO_FREE_VM;
entries = (LSA_PRIV_ENTRY *)talloc_zero(p->mem_ctx, sizeof(LSA_PRIV_ENTRY) * (PRIV_ALL_INDEX-enum_context));
if (entries==NULL)
init_lsa_r_enum_privs(r_u, i+enum_context, PRIV_ALL_INDEX-enum_context, entries);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/***************************************************************************
_lsa_priv_get_dispname.
***************************************************************************/
-uint32 _lsa_priv_get_dispname(pipes_struct *p, LSA_Q_PRIV_GET_DISPNAME *q_u, LSA_R_PRIV_GET_DISPNAME *r_u)
+NTSTATUS _lsa_priv_get_dispname(pipes_struct *p, LSA_Q_PRIV_GET_DISPNAME *q_u, LSA_R_PRIV_GET_DISPNAME *r_u)
{
fstring name_asc;
fstring desc_asc;
r_u->ptr_info=0xdeadbeef;
r_u->lang_id=q_u->lang_id;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/***************************************************************************
_lsa_enum_accounts.
***************************************************************************/
-uint32 _lsa_enum_accounts(pipes_struct *p, LSA_Q_ENUM_ACCOUNTS *q_u, LSA_R_ENUM_ACCOUNTS *r_u)
+NTSTATUS _lsa_enum_accounts(pipes_struct *p, LSA_Q_ENUM_ACCOUNTS *q_u, LSA_R_ENUM_ACCOUNTS *r_u)
{
GROUP_MAP *map=NULL;
int num_entries=0;
/* get the list of mapped groups (domain, local, builtin) */
if(!enum_group_mapping(SID_NAME_UNKNOWN, &map, &num_entries, ENUM_ONLY_MAPPED))
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
sids->ptr_sid = (uint32 *)talloc_zero(p->mem_ctx, (num_entries-q_u->enum_context)*sizeof(uint32));
sids->sid = (DOM_SID2 *)talloc_zero(p->mem_ctx, (num_entries-q_u->enum_context)*sizeof(DOM_SID2));
init_lsa_r_enum_accounts(r_u, j);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
-uint32 _lsa_unk_get_connuser(pipes_struct *p, LSA_Q_UNK_GET_CONNUSER *q_u, LSA_R_UNK_GET_CONNUSER *r_u)
+NTSTATUS _lsa_unk_get_connuser(pipes_struct *p, LSA_Q_UNK_GET_CONNUSER *q_u, LSA_R_UNK_GET_CONNUSER *r_u)
{
fstring username, domname;
int ulen, dlen;
r_u->ptr_dom_name = 1;
init_unistr2(&r_u->uni2_dom_name, domname, dlen);
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
return r_u->status;
}
***************************************************************************/
-uint32 _lsa_open_account(pipes_struct *p, LSA_Q_OPENACCOUNT *q_u, LSA_R_OPENACCOUNT *r_u)
+NTSTATUS _lsa_open_account(pipes_struct *p, LSA_Q_OPENACCOUNT *q_u, LSA_R_OPENACCOUNT *r_u)
{
struct lsa_info *info;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* find the connection policy handle. */
if (!find_policy_by_hnd(p, &q_u->pol, NULL))
***************************************************************************/
-uint32 _lsa_enum_privsaccount(pipes_struct *p, LSA_Q_ENUMPRIVSACCOUNT *q_u, LSA_R_ENUMPRIVSACCOUNT *r_u)
+NTSTATUS _lsa_enum_privsaccount(pipes_struct *p, LSA_Q_ENUMPRIVSACCOUNT *q_u, LSA_R_ENUMPRIVSACCOUNT *r_u)
{
struct lsa_info *info=NULL;
GROUP_MAP map;
LUID_ATTR *set=NULL;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* find the connection policy handle. */
if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
***************************************************************************/
-uint32 _lsa_getsystemaccount(pipes_struct *p, LSA_Q_GETSYSTEMACCOUNT *q_u, LSA_R_GETSYSTEMACCOUNT *r_u)
+NTSTATUS _lsa_getsystemaccount(pipes_struct *p, LSA_Q_GETSYSTEMACCOUNT *q_u, LSA_R_GETSYSTEMACCOUNT *r_u)
{
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* find the connection policy handle. */
if (!find_policy_by_hnd(p, &q_u->pol, NULL))
*************************************************************************/
static void init_net_r_req_chal(NET_R_REQ_CHAL *r_c,
- DOM_CHAL *srv_chal, int status)
+ DOM_CHAL *srv_chal, NTSTATUS status)
{
DEBUG(6,("init_net_r_req_chal: %d\n", __LINE__));
memcpy(r_c->srv_chal.data, srv_chal->data, sizeof(srv_chal->data));
#define LOGON_CTRL_REPL_NEEDED 0x01
#define LOGON_CTRL_REPL_IN_PROGRESS 0x02
-uint32 _net_logon_ctrl(pipes_struct *p, NET_Q_LOGON_CTRL *q_u,
+NTSTATUS _net_logon_ctrl(pipes_struct *p, NET_Q_LOGON_CTRL *q_u,
NET_R_LOGON_CTRL *r_u)
{
uint32 flags = 0x0;
net_reply_logon_ctrl2:
*************************************************************************/
-uint32 _net_logon_ctrl2(pipes_struct *p, NET_Q_LOGON_CTRL2 *q_u, NET_R_LOGON_CTRL2 *r_u)
+NTSTATUS _net_logon_ctrl2(pipes_struct *p, NET_Q_LOGON_CTRL2 *q_u, NET_R_LOGON_CTRL2 *r_u)
{
/* lkclXXXX - guess what - absolutely no idea what these are! */
uint32 flags = 0x0;
net_reply_trust_dom_list:
*************************************************************************/
-uint32 _net_trust_dom_list(pipes_struct *p, NET_Q_TRUST_DOM_LIST *q_u, NET_R_TRUST_DOM_LIST *r_u)
+NTSTATUS _net_trust_dom_list(pipes_struct *p, NET_Q_TRUST_DOM_LIST *q_u, NET_R_TRUST_DOM_LIST *r_u)
{
char *trusted_domain = "test_domain";
uint32 num_trust_domains = 1;
***********************************************************************************/
static void init_net_r_srv_pwset(NET_R_SRV_PWSET *r_s,
- DOM_CRED *srv_cred, int status)
+ DOM_CRED *srv_cred, NTSTATUS status)
{
DEBUG(5,("init_net_r_srv_pwset: %d\n", __LINE__));
_net_req_chal
*************************************************************************/
-uint32 _net_req_chal(pipes_struct *p, NET_Q_REQ_CHAL *q_u, NET_R_REQ_CHAL *r_u)
+NTSTATUS _net_req_chal(pipes_struct *p, NET_Q_REQ_CHAL *q_u, NET_R_REQ_CHAL *r_u)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
fstring mach_acct;
if (!get_valid_user_struct(p->vuid))
init_net_r_auth:
*************************************************************************/
-static void init_net_r_auth(NET_R_AUTH *r_a, DOM_CHAL *resp_cred, int status)
+static void init_net_r_auth(NET_R_AUTH *r_a, DOM_CHAL *resp_cred, NTSTATUS status)
{
memcpy(r_a->srv_chal.data, resp_cred->data, sizeof(resp_cred->data));
r_a->status = status;
_net_auth
*************************************************************************/
-uint32 _net_auth(pipes_struct *p, NET_Q_AUTH *q_u, NET_R_AUTH *r_u)
+NTSTATUS _net_auth(pipes_struct *p, NET_Q_AUTH *q_u, NET_R_AUTH *r_u)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
DOM_CHAL srv_cred;
UTIME srv_time;
*************************************************************************/
static void init_net_r_auth_2(NET_R_AUTH_2 *r_a,
- DOM_CHAL *resp_cred, NEG_FLAGS *flgs, int status)
+ DOM_CHAL *resp_cred, NEG_FLAGS *flgs, NTSTATUS status)
{
memcpy(r_a->srv_chal.data, resp_cred->data, sizeof(resp_cred->data));
memcpy(&r_a->srv_flgs, flgs, sizeof(r_a->srv_flgs));
_net_auth_2
*************************************************************************/
-uint32 _net_auth_2(pipes_struct *p, NET_Q_AUTH_2 *q_u, NET_R_AUTH_2 *r_u)
+NTSTATUS _net_auth_2(pipes_struct *p, NET_Q_AUTH_2 *q_u, NET_R_AUTH_2 *r_u)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
DOM_CHAL srv_cred;
UTIME srv_time;
NEG_FLAGS srv_flgs;
_net_srv_pwset
*************************************************************************/
-uint32 _net_srv_pwset(pipes_struct *p, NET_Q_SRV_PWSET *q_u, NET_R_SRV_PWSET *r_u)
+NTSTATUS _net_srv_pwset(pipes_struct *p, NET_Q_SRV_PWSET *q_u, NET_R_SRV_PWSET *r_u)
{
- uint32 status = NT_STATUS_WRONG_PASSWORD;
+ NTSTATUS status = NT_STATUS_WRONG_PASSWORD;
DOM_CRED srv_cred;
pstring mach_acct;
SAM_ACCOUNT *sampass=NULL;
unbecome_root();
if (ret)
- status = NT_STATUS_NOPROBLEMO;
+ status = NT_STATUS_OK;
/* set up the LSA Server Password Set response */
init_net_r_srv_pwset(r_u, &srv_cred, status);
_net_sam_logoff:
*************************************************************************/
-uint32 _net_sam_logoff(pipes_struct *p, NET_Q_SAM_LOGOFF *q_u, NET_R_SAM_LOGOFF *r_u)
+NTSTATUS _net_sam_logoff(pipes_struct *p, NET_Q_SAM_LOGOFF *q_u, NET_R_SAM_LOGOFF *r_u)
{
DOM_CRED srv_cred;
r_u->buffer_creds = 1; /* yes, we have valid server credentials */
memcpy(&r_u->srv_creds, &srv_cred, sizeof(r_u->srv_creds));
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
return r_u->status;
}
_net_logon_any: Use the new authentications subsystem to log in.
*************************************************************************/
-static uint32 _net_logon_any(NET_ID_INFO_CTR *ctr, char *user, char *domain, char *sess_key)
+static NTSTATUS _net_logon_any(NET_ID_INFO_CTR *ctr, char *user, char *domain, char *sess_key)
{
- uint32 nt_status = NT_STATUS_LOGON_FAILURE;
+ NTSTATUS nt_status = NT_STATUS_LOGON_FAILURE;
unsigned char local_lm_response[24];
unsigned char local_nt_response[24];
nt_status = check_password(&user_info, &server_info);
- DEBUG(5, ("_net_logon_any: exited with status %d\n", nt_status));
+ DEBUG(5, ("_net_logon_any: exited with status %s\n",
+ get_nt_error_msg(nt_status)));
return nt_status;
-
}
_net_sam_logon
*************************************************************************/
-uint32 _net_sam_logon(pipes_struct *p, NET_Q_SAM_LOGON *q_u, NET_R_SAM_LOGON *r_u)
+NTSTATUS _net_sam_logon(pipes_struct *p, NET_Q_SAM_LOGON *q_u, NET_R_SAM_LOGON *r_u)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
NET_USER_INFO_3 *usr_info = NULL;
DOM_CRED srv_cred;
SAM_ACCOUNT *sampass = NULL;
/* Check account and password */
- if (status != NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_V(status))
return status;
pdb_init_sam(&sampass);
*/
if(p->fault_state) {
- setup_fault_pdu(p, 0x1c010002);
+ setup_fault_pdu(p, NT_STATUS(0x1c010002));
return True;
}
become_root();
- if(!(p->ntlmssp_auth_validated =
- pass_check_smb_with_chal(pipe_user_name, domain,
- (uchar*)p->challenge,
- lm_owf, lm_pw_len,
- nt_owf, nt_pw_len) == NT_STATUS_NOPROBLEMO)) {
+ p->ntlmssp_auth_validated =
+ NT_STATUS_IS_OK(pass_check_smb_with_chal(pipe_user_name, domain,
+ (uchar*)p->challenge,
+ lm_owf, lm_pw_len,
+ nt_owf, nt_pw_len));
+ if (!p->ntlmssp_auth_validated) {
DEBUG(1,("api_pipe_ntlmssp_verify: User %s\\%s from machine %s \
failed authentication on named pipe %s.\n", domain, pipe_user_name, wks, p->name ));
unbecome_root();
Marshall a fault pdu.
*******************************************************************/
-BOOL setup_fault_pdu(pipes_struct *p, uint32 status)
+BOOL setup_fault_pdu(pipes_struct *p, NTSTATUS status)
{
prs_struct outgoing_pdu;
RPC_HDR fault_hdr;
* and not put the pipe into fault state. JRA.
*/
DEBUG(4, ("unknown\n"));
- setup_fault_pdu(p, 0x1c010002);
+ setup_fault_pdu(p, NT_STATUS(0x1c010002));
return True;
}
DEBUG(10,("process_complete_pdu: pipe %s in fault state.\n",
p->name ));
set_incoming_fault(p);
- setup_fault_pdu(p, 0x1c010002);
+ setup_fault_pdu(p, NT_STATUS(0x1c010002));
return (ssize_t)data_len;
}
if (!reply) {
DEBUG(3,("process_complete_pdu: DCE/RPC fault sent on pipe %s\n", p->pipe_srv_name));
set_incoming_fault(p);
- setup_fault_pdu(p, 0x1c010002);
+ setup_fault_pdu(p, NT_STATUS(0x1c010002));
prs_mem_free(&rpc_in);
} else {
/*
reg_reply_unknown_1
********************************************************************/
-uint32 _reg_close(pipes_struct *p, REG_Q_CLOSE *q_u, REG_R_CLOSE *r_u)
+NTSTATUS _reg_close(pipes_struct *p, REG_Q_CLOSE *q_u, REG_R_CLOSE *r_u)
{
/* set up the REG unknown_1 response */
ZERO_STRUCT(r_u->pol);
if (!close_policy_hnd(p, &q_u->pol))
return NT_STATUS_OBJECT_NAME_INVALID;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
reg_reply_open
********************************************************************/
-uint32 _reg_open(pipes_struct *p, REG_Q_OPEN_HKLM *q_u, REG_R_OPEN_HKLM *r_u)
+NTSTATUS _reg_open(pipes_struct *p, REG_Q_OPEN_HKLM *q_u, REG_R_OPEN_HKLM *r_u)
{
if (!create_policy_hnd(p, &r_u->pol, free_reg_info, NULL))
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
reg_reply_open_entry
********************************************************************/
-uint32 _reg_open_entry(pipes_struct *p, REG_Q_OPEN_ENTRY *q_u, REG_R_OPEN_ENTRY *r_u)
+NTSTATUS _reg_open_entry(pipes_struct *p, REG_Q_OPEN_ENTRY *q_u, REG_R_OPEN_ENTRY *r_u)
{
POLICY_HND pol;
fstring name;
if (!create_policy_hnd(p, &pol, free_reg_info, (void *)info))
return NT_STATUS_TOO_MANY_SECRETS; /* ha ha very droll */
- init_reg_r_open_entry(r_u, &pol, NT_STATUS_NOPROBLEMO);
+ init_reg_r_open_entry(r_u, &pol, NT_STATUS_OK);
DEBUG(5,("reg_open_entry: %d\n", __LINE__));
reg_reply_info
********************************************************************/
-uint32 _reg_info(pipes_struct *p, REG_Q_INFO *q_u, REG_R_INFO *r_u)
+NTSTATUS _reg_info(pipes_struct *p, REG_Q_INFO *q_u, REG_R_INFO *r_u)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
char *key = NULL;
uint32 type=0x1; /* key type: REG_SZ */
if ( strequal(name, "RefusePasswordChange") ) {
type=0xF770;
- status = ERRbadfile;
+ status = NT_STATUS_NO_SUCH_FILE;
init_unistr2(uni_key, "", 0);
init_buffer2(buf, (uint8*) uni_key->buffer, uni_key->uni_str_len*2);
#define SHUTDOWN_F_STRING "-f"
-uint32 _reg_shutdown(pipes_struct *p, REG_Q_SHUTDOWN *q_u, REG_R_SHUTDOWN *r_u)
+NTSTATUS _reg_shutdown(pipes_struct *p, REG_Q_SHUTDOWN *q_u, REG_R_SHUTDOWN *r_u)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
pstring shutdown_script;
UNISTR2 unimsg = q_u->uni_msg;
pstring message;
return status;
}
-uint32 _reg_abort_shutdown(pipes_struct *p, REG_Q_ABORT_SHUTDOWN *q_u, REG_R_ABORT_SHUTDOWN *r_u)
+NTSTATUS _reg_abort_shutdown(pipes_struct *p, REG_Q_ABORT_SHUTDOWN *q_u, REG_R_ABORT_SHUTDOWN *r_u)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
pstring abort_shutdown_script;
pstrcpy(abort_shutdown_script, lp_abort_shutdown_script());
DEBUG(0,("api_samr_set_userinfo: Unable to unmarshall SAMR_Q_SET_USERINFO.\n"));
/* Fix for W2K SP2 */
if (q_u.switch_value == 0x1a) {
- setup_fault_pdu(p, 0x1c000006);
+ setup_fault_pdu(p, NT_STATUS(0x1c000006));
return True;
}
return False;
dynamically returns the correct user info..... JRA.
********************************************************************/
-static uint32 get_sampwd_entries(SAM_USER_INFO_21 *pw_buf, int start_idx,
+static NTSTATUS get_sampwd_entries(SAM_USER_INFO_21 *pw_buf, int start_idx,
int *total_entries, int *num_entries,
int max_num_entries, uint16 acb_mask)
{
if (not_finished)
return STATUS_MORE_ENTRIES;
else
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
-static uint32 jf_get_sampwd_entries(SAM_USER_INFO_21 *pw_buf, int start_idx,
+static NTSTATUS jf_get_sampwd_entries(SAM_USER_INFO_21 *pw_buf, int start_idx,
int *total_entries, uint32 *num_entries,
int max_num_entries, uint16 acb_mask)
{
if (not_finished)
return STATUS_MORE_ENTRIES;
else
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
#if 0 /* This function appears to be unused! */
_samr_close_hnd
********************************************************************/
-uint32 _samr_close_hnd(pipes_struct *p, SAMR_Q_CLOSE_HND *q_u, SAMR_R_CLOSE_HND *r_u)
+NTSTATUS _samr_close_hnd(pipes_struct *p, SAMR_Q_CLOSE_HND *q_u, SAMR_R_CLOSE_HND *r_u)
{
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* close the policy handle */
if (!close_policy_hnd(p, &q_u->pol))
samr_reply_open_domain
********************************************************************/
-uint32 _samr_open_domain(pipes_struct *p, SAMR_Q_OPEN_DOMAIN *q_u, SAMR_R_OPEN_DOMAIN *r_u)
+NTSTATUS _samr_open_domain(pipes_struct *p, SAMR_Q_OPEN_DOMAIN *q_u, SAMR_R_OPEN_DOMAIN *r_u)
{
struct samr_info *info;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* find the connection policy handle. */
if (!find_policy_by_hnd(p, &q_u->pol, NULL))
static uint32 get_lsa_policy_samr_rid(struct samr_info *info)
{
if (!info) {
- DEBUG(3,("Error getting policy\n"));
- return 0xffffffff;
+ DEBUG(3,("Error getting policy\n"));
+ return 0xffffffff;
}
return info->sid.sub_auths[info->sid.num_auths-1];
_samr_get_usrdom_pwinfo
********************************************************************/
-uint32 _samr_get_usrdom_pwinfo(pipes_struct *p, SAMR_Q_GET_USRDOM_PWINFO *q_u, SAMR_R_GET_USRDOM_PWINFO *r_u)
+NTSTATUS _samr_get_usrdom_pwinfo(pipes_struct *p, SAMR_Q_GET_USRDOM_PWINFO *q_u, SAMR_R_GET_USRDOM_PWINFO *r_u)
{
struct samr_info *info = NULL;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* find the policy handle. open a policy on it. */
if (!find_policy_by_hnd(p, &q_u->user_pol, (void **)&info)) {
return NT_STATUS_OBJECT_TYPE_MISMATCH;
}
- init_samr_r_get_usrdom_pwinfo(r_u, NT_STATUS_NOPROBLEMO);
+ init_samr_r_get_usrdom_pwinfo(r_u, NT_STATUS_OK);
DEBUG(5,("_samr_get_usrdom_pwinfo: %d\n", __LINE__));
samr_make_usr_obj_sd
********************************************************************/
-static uint32 samr_make_usr_obj_sd(TALLOC_CTX *ctx, SEC_DESC_BUF **buf, DOM_SID *usr_sid)
+static NTSTATUS samr_make_usr_obj_sd(TALLOC_CTX *ctx, SEC_DESC_BUF **buf, DOM_SID *usr_sid)
{
extern DOM_SID global_sid_World;
DOM_SID adm_sid;
if((*buf = make_sec_desc_buf(ctx, sd_size, psd)) == NULL)
return NT_STATUS_NO_MEMORY;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
static BOOL get_lsa_policy_samr_sid(pipes_struct *p, POLICY_HND *pol, DOM_SID *sid)
_samr_query_sec_obj
********************************************************************/
-uint32 _samr_query_sec_obj(pipes_struct *p, SAMR_Q_QUERY_SEC_OBJ *q_u, SAMR_R_QUERY_SEC_OBJ *r_u)
+NTSTATUS _samr_query_sec_obj(pipes_struct *p, SAMR_Q_QUERY_SEC_OBJ *q_u, SAMR_R_QUERY_SEC_OBJ *r_u)
{
DOM_SID pol_sid;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* Get the SID. */
r_u->status = samr_make_usr_obj_sd(p->mem_ctx, &r_u->buf, &pol_sid);
- if (r_u->status == NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_IS_OK(r_u->status))
r_u->ptr = 1;
return r_u->status;
samr_reply_enum_dom_users
********************************************************************/
-uint32 _samr_enum_dom_users(pipes_struct *p, SAMR_Q_ENUM_DOM_USERS *q_u, SAMR_R_ENUM_DOM_USERS *r_u)
+NTSTATUS _samr_enum_dom_users(pipes_struct *p, SAMR_Q_ENUM_DOM_USERS *q_u, SAMR_R_ENUM_DOM_USERS *r_u)
{
SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES];
int num_entries = 0;
int total_entries = 0;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* find the policy handle. open a policy on it. */
if (!find_policy_by_hnd(p, &q_u->pol, NULL))
MAX_SAM_ENTRIES, q_u->acb_mask);
unbecome_root();
- if (r_u->status != NT_STATUS_NOPROBLEMO && r_u->status != STATUS_MORE_ENTRIES)
+ if (NT_STATUS_IS_ERR(r_u->status))
return r_u->status;
samr_clear_passwd_fields(pass, num_entries);
Get the group entries - similar to get_sampwd_entries().
********************************************************************/
-static BOOL get_group_alias_entries(TALLOC_CTX *ctx, DOMAIN_GRP **d_grp, DOM_SID *sid, uint32 start_idx,
+static NTSTATUS get_group_alias_entries(TALLOC_CTX *ctx, DOMAIN_GRP **d_grp, DOM_SID *sid, uint32 start_idx,
uint32 *p_num_entries, uint32 max_entries)
{
fstring sid_str;
DEBUG(10,("get_group_alias_entries: returning %d entries\n", *p_num_entries));
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
Get the group entries - similar to get_sampwd_entries().
********************************************************************/
-static uint32 get_group_domain_entries(TALLOC_CTX *ctx, DOMAIN_GRP **d_grp, DOM_SID *sid, uint32 start_idx,
+static NTSTATUS get_group_domain_entries(TALLOC_CTX *ctx, DOMAIN_GRP **d_grp, DOM_SID *sid, uint32 start_idx,
uint32 *p_num_entries, uint32 max_entries)
{
GROUP_MAP *map=NULL;
*p_num_entries = num_entries;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
a real PDC. JRA.
********************************************************************/
-uint32 _samr_enum_dom_groups(pipes_struct *p, SAMR_Q_ENUM_DOM_GROUPS *q_u, SAMR_R_ENUM_DOM_GROUPS *r_u)
+NTSTATUS _samr_enum_dom_groups(pipes_struct *p, SAMR_Q_ENUM_DOM_GROUPS *q_u, SAMR_R_ENUM_DOM_GROUPS *r_u)
{
DOMAIN_GRP *grp=NULL;
uint32 num_entries;
DOM_SID sid;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
if (!get_lsa_policy_samr_sid(p, &q_u->pol, &sid))
return NT_STATUS_INVALID_HANDLE;
samr_reply_enum_dom_aliases
********************************************************************/
-uint32 _samr_enum_dom_aliases(pipes_struct *p, SAMR_Q_ENUM_DOM_ALIASES *q_u, SAMR_R_ENUM_DOM_ALIASES *r_u)
+NTSTATUS _samr_enum_dom_aliases(pipes_struct *p, SAMR_Q_ENUM_DOM_ALIASES *q_u, SAMR_R_ENUM_DOM_ALIASES *r_u)
{
DOMAIN_GRP *grp=NULL;
uint32 num_entries = 0;
fstring sid_str;
DOM_SID sid;
+ NTSTATUS status;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
if (!get_lsa_policy_samr_sid(p, &q_u->pol, &sid))
return NT_STATUS_INVALID_HANDLE;
sid_to_string(sid_str, &sid);
DEBUG(5,("samr_reply_enum_dom_aliases: sid %s\n", sid_str));
- if (get_group_alias_entries(p->mem_ctx, &grp, &sid, q_u->start_idx, &num_entries, MAX_SAM_ENTRIES)!=NT_STATUS_NOPROBLEMO)
- return NT_STATUS_ACCESS_DENIED;
+ status = get_group_alias_entries(p->mem_ctx, &grp, &sid, q_u->start_idx,
+ &num_entries, MAX_SAM_ENTRIES);
+ if (NT_STATUS_IS_ERR(status)) return status;
make_group_sam_entry_list(p->mem_ctx, &r_u->sam, &r_u->uni_grp_name, num_entries, grp);
samr_reply_query_dispinfo
********************************************************************/
-uint32 _samr_query_dispinfo(pipes_struct *p, SAMR_Q_QUERY_DISPINFO *q_u, SAMR_R_QUERY_DISPINFO *r_u)
+NTSTATUS _samr_query_dispinfo(pipes_struct *p, SAMR_Q_QUERY_DISPINFO *q_u, SAMR_R_QUERY_DISPINFO *r_u)
{
SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES];
DOMAIN_GRP *grps=NULL;
int total_entries = 0;
uint32 data_size = 0;
DOM_SID sid;
- uint32 disp_ret;
+ NTSTATUS disp_ret;
SAM_DISPINFO_CTR *ctr;
DEBUG(5, ("samr_reply_query_dispinfo: %d\n", __LINE__));
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
if (!get_lsa_policy_samr_sid(p, &q_u->domain_pol, &sid))
return NT_STATUS_INVALID_HANDLE;
MAX_SAM_ENTRIES, acb_mask);
#endif
unbecome_root();
- if (r_u->status!=STATUS_MORE_ENTRIES && r_u->status!=NT_STATUS_NOPROBLEMO) {
+ if (NT_STATUS_IS_ERR(r_u->status)) {
DEBUG(5, ("get_sampwd_entries: failed\n"));
return r_u->status;
}
case 0x3:
case 0x5:
r_u->status = get_group_domain_entries(p->mem_ctx, &grps, &sid, q_u->start_idx, &num_entries, MAX_SAM_ENTRIES);
- if (r_u->status != NT_STATUS_NOPROBLEMO)
- return NT_STATUS_ACCESS_DENIED;
+ if (NT_STATUS_IS_ERR(r_u->status))
+ return r_u->status;
break;
default:
DEBUG(0,("_samr_query_dispinfo: Unknown info level (%u)\n", (unsigned int)q_u->switch_level ));
return NT_STATUS_NO_MEMORY;
}
disp_ret = init_sam_dispinfo_1(p->mem_ctx, ctr->sam.info1, &num_entries, &data_size, q_u->start_idx, pass);
- if (disp_ret != NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_IS_ERR(disp_ret))
return disp_ret;
break;
case 0x2:
return NT_STATUS_NO_MEMORY;
}
disp_ret = init_sam_dispinfo_2(p->mem_ctx, ctr->sam.info2, &num_entries, &data_size, q_u->start_idx, pass);
- if (disp_ret != NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_IS_ERR(disp_ret))
return disp_ret;
break;
case 0x3:
return NT_STATUS_NO_MEMORY;
}
disp_ret = init_sam_dispinfo_3(p->mem_ctx, ctr->sam.info3, &num_entries, &data_size, q_u->start_idx, grps);
- if (disp_ret != NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_IS_ERR(disp_ret))
return disp_ret;
break;
case 0x4:
return NT_STATUS_NO_MEMORY;
}
disp_ret = init_sam_dispinfo_4(p->mem_ctx, ctr->sam.info4, &num_entries, &data_size, q_u->start_idx, pass);
- if (disp_ret != NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_IS_ERR(disp_ret))
return disp_ret;
break;
case 0x5:
return NT_STATUS_NO_MEMORY;
}
disp_ret = init_sam_dispinfo_5(p->mem_ctx, ctr->sam.info5, &num_entries, &data_size, q_u->start_idx, grps);
- if (disp_ret != NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_IS_ERR(disp_ret))
return disp_ret;
break;
default:
samr_reply_query_aliasinfo
********************************************************************/
-uint32 _samr_query_aliasinfo(pipes_struct *p, SAMR_Q_QUERY_ALIASINFO *q_u, SAMR_R_QUERY_ALIASINFO *r_u)
+NTSTATUS _samr_query_aliasinfo(pipes_struct *p, SAMR_Q_QUERY_ALIASINFO *q_u, SAMR_R_QUERY_ALIASINFO *r_u)
{
fstring alias_desc = "Local Unix group";
fstring alias="";
uint32 alias_rid;
struct samr_info *info = NULL;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
DEBUG(5,("_samr_query_aliasinfo: %d\n", __LINE__));
uint32 rid[MAX_SAM_ENTRIES];
int num_rids = q_u->num_sids1;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
DEBUG(5,("_samr_lookup_ids: %d\n", __LINE__));
num_rids = 1;
rid[0] = BUILTIN_ALIAS_RID_USERS;
- init_samr_r_lookup_ids(&r_u, num_rids, rid, NT_STATUS_NOPROBLEMO);
+ init_samr_r_lookup_ids(&r_u, num_rids, rid, NT_STATUS_OK);
DEBUG(5,("_samr_lookup_ids: %d\n", __LINE__));
_samr_lookup_names
********************************************************************/
-uint32 _samr_lookup_names(pipes_struct *p, SAMR_Q_LOOKUP_NAMES *q_u, SAMR_R_LOOKUP_NAMES *r_u)
+NTSTATUS _samr_lookup_names(pipes_struct *p, SAMR_Q_LOOKUP_NAMES *q_u, SAMR_R_LOOKUP_NAMES *r_u)
{
uint32 rid[MAX_SAM_ENTRIES];
enum SID_NAME_USE type[MAX_SAM_ENTRIES];
int num_rids = q_u->num_names2;
DOM_SID pol_sid;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
DEBUG(5,("_samr_lookup_names: %d\n", __LINE__));
DOM_SID sid;
if(local_lookup_name(global_myname, name, &sid, &type[i])) {
sid_split_rid( &sid, &rid[i]);
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
}
}
}
_samr_chgpasswd_user
********************************************************************/
-uint32 _samr_chgpasswd_user(pipes_struct *p, SAMR_Q_CHGPASSWD_USER *q_u, SAMR_R_CHGPASSWD_USER *r_u)
+NTSTATUS _samr_chgpasswd_user(pipes_struct *p, SAMR_Q_CHGPASSWD_USER *q_u, SAMR_R_CHGPASSWD_USER *r_u)
{
fstring user_name;
fstring wks;
DEBUG(5,("_samr_chgpasswd_user: %d\n", __LINE__));
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
rpcstr_pull(user_name, q_u->uni_user_name.buffer, sizeof(user_name), q_u->uni_user_name.uni_str_len*2, 0);
rpcstr_pull(wks, q_u->uni_dest_host.buffer, sizeof(wks), q_u->uni_dest_host.uni_str_len,0);
_samr_lookup_rids
********************************************************************/
-uint32 _samr_lookup_rids(pipes_struct *p, SAMR_Q_LOOKUP_RIDS *q_u, SAMR_R_LOOKUP_RIDS *r_u)
+NTSTATUS _samr_lookup_rids(pipes_struct *p, SAMR_Q_LOOKUP_RIDS *q_u, SAMR_R_LOOKUP_RIDS *r_u)
{
fstring group_names[MAX_SAM_ENTRIES];
uint32 *group_attrs = NULL;
int num_rids = q_u->num_rids1;
int i;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
DEBUG(5,("_samr_lookup_rids: %d\n", __LINE__));
sid_append_rid(&sid, q_u->rid[i]);
if (lookup_sid(&sid, domname, tmpname, &type)) {
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
group_attrs[i] = (uint32)type;
fstrcpy(group_names[i],tmpname);
DEBUG(5,("_samr_lookup_rids: %s:%d\n", group_names[i], group_attrs[i]));
_api_samr_open_user. Safe - gives out no passwd info.
********************************************************************/
-uint32 _api_samr_open_user(pipes_struct *p, SAMR_Q_OPEN_USER *q_u, SAMR_R_OPEN_USER *r_u)
+NTSTATUS _api_samr_open_user(pipes_struct *p, SAMR_Q_OPEN_USER *q_u, SAMR_R_OPEN_USER *r_u)
{
SAM_ACCOUNT *sampass=NULL;
DOM_SID sid;
struct samr_info *info = NULL;
BOOL ret;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* find the domain policy handle. */
if (!find_policy_by_hnd(p, &domain_pol, NULL))
user. JRA.
*************************************************************************/
-static uint32 get_user_info_12(pipes_struct *p, SAM_USER_INFO_12 * id12, uint32 user_rid)
+static NTSTATUS get_user_info_12(pipes_struct *p, SAM_USER_INFO_12 * id12, uint32 user_rid)
{
SAM_ACCOUNT *smbpass=NULL;
BOOL ret;
pdb_free_sam(smbpass);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*************************************************************************
_samr_query_userinfo
********************************************************************/
-uint32 _samr_query_userinfo(pipes_struct *p, SAMR_Q_QUERY_USERINFO *q_u, SAMR_R_QUERY_USERINFO *r_u)
+NTSTATUS _samr_query_userinfo(pipes_struct *p, SAMR_Q_QUERY_USERINFO *q_u, SAMR_R_QUERY_USERINFO *r_u)
{
SAM_USERINFO_CTR *ctr;
uint32 rid = 0;
struct samr_info *info = NULL;
- r_u->status=NT_STATUS_NOPROBLEMO;
+ r_u->status=NT_STATUS_OK;
/* search for the handle */
if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
if (ctr->info.id12 == NULL)
return NT_STATUS_NO_MEMORY;
- if ((r_u->status = get_user_info_12(p, ctr->info.id12, rid)) != NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_IS_ERR(r_u->status = get_user_info_12(p, ctr->info.id12, rid)))
return r_u->status;
break;
samr_reply_query_usergroups
********************************************************************/
-uint32 _samr_query_usergroups(pipes_struct *p, SAMR_Q_QUERY_USERGROUPS *q_u, SAMR_R_QUERY_USERGROUPS *r_u)
+NTSTATUS _samr_query_usergroups(pipes_struct *p, SAMR_Q_QUERY_USERGROUPS *q_u, SAMR_R_QUERY_USERGROUPS *r_u)
{
SAM_ACCOUNT *sam_pass=NULL;
DOM_GID *gids = NULL;
struct samr_info *info = NULL;
BOOL ret;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
DEBUG(5,("_samr_query_usergroups: %d\n", __LINE__));
_samr_query_dom_info
********************************************************************/
-uint32 _samr_query_dom_info(pipes_struct *p, SAMR_Q_QUERY_DOMAIN_INFO *q_u, SAMR_R_QUERY_DOMAIN_INFO *r_u)
+NTSTATUS _samr_query_dom_info(pipes_struct *p, SAMR_Q_QUERY_DOMAIN_INFO *q_u, SAMR_R_QUERY_DOMAIN_INFO *r_u)
{
SAM_UNK_CTR *ctr;
ZERO_STRUCTP(ctr);
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
DEBUG(5,("_samr_query_dom_info: %d\n", __LINE__));
return NT_STATUS_INVALID_INFO_CLASS;
}
- init_samr_r_query_dom_info(r_u, q_u->switch_value, ctr, NT_STATUS_NOPROBLEMO);
+ init_samr_r_query_dom_info(r_u, q_u->switch_value, ctr, NT_STATUS_OK);
DEBUG(5,("_samr_query_dom_info: %d\n", __LINE__));
_api_samr_create_user
********************************************************************/
-uint32 _api_samr_create_user(pipes_struct *p, SAMR_Q_CREATE_USER *q_u, SAMR_R_CREATE_USER *r_u)
+NTSTATUS _api_samr_create_user(pipes_struct *p, SAMR_Q_CREATE_USER *q_u, SAMR_R_CREATE_USER *r_u)
{
SAM_ACCOUNT *sam_pass=NULL;
fstring mach_acct;
pdb_free_sam(sam_pass);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
samr_reply_connect_anon
********************************************************************/
-uint32 _samr_connect_anon(pipes_struct *p, SAMR_Q_CONNECT_ANON *q_u, SAMR_R_CONNECT_ANON *r_u)
+NTSTATUS _samr_connect_anon(pipes_struct *p, SAMR_Q_CONNECT_ANON *q_u, SAMR_R_CONNECT_ANON *r_u)
{
struct samr_info *info = NULL;
/* set up the SAMR connect_anon response */
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* associate the user's SID with the new handle. */
if ((info = (struct samr_info *)malloc(sizeof(struct samr_info))) == NULL)
samr_reply_connect
********************************************************************/
-uint32 _samr_connect(pipes_struct *p, SAMR_Q_CONNECT *q_u, SAMR_R_CONNECT *r_u)
+NTSTATUS _samr_connect(pipes_struct *p, SAMR_Q_CONNECT *q_u, SAMR_R_CONNECT *r_u)
{
struct samr_info *info = NULL;
DEBUG(5,("_samr_connect: %d\n", __LINE__));
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* associate the user's SID with the new handle. */
if ((info = (struct samr_info *)malloc(sizeof(struct samr_info))) == NULL)
api_samr_lookup_domain
**********************************************************************/
-uint32 _samr_lookup_domain(pipes_struct *p, SAMR_Q_LOOKUP_DOMAIN *q_u, SAMR_R_LOOKUP_DOMAIN *r_u)
+NTSTATUS _samr_lookup_domain(pipes_struct *p, SAMR_Q_LOOKUP_DOMAIN *q_u, SAMR_R_LOOKUP_DOMAIN *r_u)
{
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
if (!find_policy_by_hnd(p, &q_u->connect_pol, NULL))
return NT_STATUS_INVALID_HANDLE;
api_samr_enum_domains
**********************************************************************/
-uint32 _samr_enum_domains(pipes_struct *p, SAMR_Q_ENUM_DOMAINS *q_u, SAMR_R_ENUM_DOMAINS *r_u)
+NTSTATUS _samr_enum_domains(pipes_struct *p, SAMR_Q_ENUM_DOMAINS *q_u, SAMR_R_ENUM_DOMAINS *r_u)
{
uint32 num_entries = 2;
fstring dom[2];
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
fstrcpy(dom[0],global_myworkgroup);
fstrcpy(dom[1],"Builtin");
api_samr_open_alias
********************************************************************/
-uint32 _api_samr_open_alias(pipes_struct *p, SAMR_Q_OPEN_ALIAS *q_u, SAMR_R_OPEN_ALIAS *r_u)
+NTSTATUS _api_samr_open_alias(pipes_struct *p, SAMR_Q_OPEN_ALIAS *q_u, SAMR_R_OPEN_ALIAS *r_u)
{
DOM_SID sid;
POLICY_HND domain_pol = q_u->dom_pol;
POLICY_HND *alias_pol = &r_u->pol;
struct samr_info *info = NULL;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* get the domain policy. */
if (!find_policy_by_hnd(p, &domain_pol, NULL))
samr_reply_set_userinfo
********************************************************************/
-uint32 _samr_set_userinfo(pipes_struct *p, SAMR_Q_SET_USERINFO *q_u, SAMR_R_SET_USERINFO *r_u)
+NTSTATUS _samr_set_userinfo(pipes_struct *p, SAMR_Q_SET_USERINFO *q_u, SAMR_R_SET_USERINFO *r_u)
{
uint32 rid = 0x0;
DOM_SID sid;
DEBUG(5, ("_samr_set_userinfo: %d\n", __LINE__));
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
if (p->ntlmssp_auth_validated) {
memcpy(&user, &p->pipe_user, sizeof(user));
samr_reply_set_userinfo2
********************************************************************/
-uint32 _samr_set_userinfo2(pipes_struct *p, SAMR_Q_SET_USERINFO2 *q_u, SAMR_R_SET_USERINFO2 *r_u)
+NTSTATUS _samr_set_userinfo2(pipes_struct *p, SAMR_Q_SET_USERINFO2 *q_u, SAMR_R_SET_USERINFO2 *r_u)
{
DOM_SID sid;
uint32 rid = 0x0;
DEBUG(5, ("samr_reply_set_userinfo2: %d\n", __LINE__));
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
/* find the policy handle. open a policy on it. */
if (!get_lsa_policy_samr_sid(p, pol, &sid))
_samr_query_aliasmem
*********************************************************************/
-uint32 _samr_query_useraliases(pipes_struct *p, SAMR_Q_QUERY_USERALIASES *q_u, SAMR_R_QUERY_USERALIASES *r_u)
+NTSTATUS _samr_query_useraliases(pipes_struct *p, SAMR_Q_QUERY_USERALIASES *q_u, SAMR_R_QUERY_USERALIASES *r_u)
{
uint32 *rid=NULL;
int num_rids;
rid[0] = BUILTIN_ALIAS_RID_USERS;
- init_samr_r_query_useraliases(r_u, num_rids, rid, NT_STATUS_NOPROBLEMO);
+ init_samr_r_query_useraliases(r_u, num_rids, rid, NT_STATUS_OK);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
_samr_query_aliasmem
*********************************************************************/
-uint32 _samr_query_aliasmem(pipes_struct *p, SAMR_Q_QUERY_ALIASMEM *q_u, SAMR_R_QUERY_ALIASMEM *r_u)
+NTSTATUS _samr_query_aliasmem(pipes_struct *p, SAMR_Q_QUERY_ALIASMEM *q_u, SAMR_R_QUERY_ALIASMEM *r_u)
{
int i;
}
DEBUG(10, ("sid is %s\n", alias_sid_str));
- init_samr_r_query_aliasmem(r_u, num_uids, sid, NT_STATUS_NOPROBLEMO);
+ init_samr_r_query_aliasmem(r_u, num_uids, sid, NT_STATUS_OK);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
_samr_query_groupmem
*********************************************************************/
-uint32 _samr_query_groupmem(pipes_struct *p, SAMR_Q_QUERY_GROUPMEM *q_u, SAMR_R_QUERY_GROUPMEM *r_u)
+NTSTATUS _samr_query_groupmem(pipes_struct *p, SAMR_Q_QUERY_GROUPMEM *q_u, SAMR_R_QUERY_GROUPMEM *r_u)
{
int num_uids = 0;
int i;
attr[i] = SID_NAME_USER;
}
- init_samr_r_query_groupmem(r_u, num_uids, rid, attr, NT_STATUS_NOPROBLEMO);
+ init_samr_r_query_groupmem(r_u, num_uids, rid, attr, NT_STATUS_OK);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
_samr_add_aliasmem
*********************************************************************/
-uint32 _samr_add_aliasmem(pipes_struct *p, SAMR_Q_ADD_ALIASMEM *q_u, SAMR_R_ADD_ALIASMEM *r_u)
+NTSTATUS _samr_add_aliasmem(pipes_struct *p, SAMR_Q_ADD_ALIASMEM *q_u, SAMR_R_ADD_ALIASMEM *r_u)
{
DOM_SID alias_sid;
fstring alias_sid_str;
if(!user_in_group_list(pwd->pw_name, grp_name))
return NT_STATUS_MEMBER_NOT_IN_ALIAS; /* don't know what to reply else */
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
_samr_del_aliasmem
*********************************************************************/
-uint32 _samr_del_aliasmem(pipes_struct *p, SAMR_Q_DEL_ALIASMEM *q_u, SAMR_R_DEL_ALIASMEM *r_u)
+NTSTATUS _samr_del_aliasmem(pipes_struct *p, SAMR_Q_DEL_ALIASMEM *q_u, SAMR_R_DEL_ALIASMEM *r_u)
{
- DEBUG(0,("_samr_del_aliasmem: Not yet implemented.\n"));
- return False;
+ DEBUG(0,("_samr_del_aliasmem: Not yet implemented.\n"));
+ return NT_STATUS_NOT_IMPLEMENTED;
}
/*********************************************************************
_samr_add_groupmem
*********************************************************************/
-uint32 _samr_add_groupmem(pipes_struct *p, SAMR_Q_ADD_GROUPMEM *q_u, SAMR_R_ADD_GROUPMEM *r_u)
+NTSTATUS _samr_add_groupmem(pipes_struct *p, SAMR_Q_ADD_GROUPMEM *q_u, SAMR_R_ADD_GROUPMEM *r_u)
{
DOM_SID group_sid;
fstring group_sid_str;
if(!user_in_group_list(pwd->pw_name, grp_name))
return NT_STATUS_MEMBER_NOT_IN_GROUP; /* don't know what to reply else */
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
_samr_del_groupmem
*********************************************************************/
-uint32 _samr_del_groupmem(pipes_struct *p, SAMR_Q_DEL_GROUPMEM *q_u, SAMR_R_DEL_GROUPMEM *r_u)
+NTSTATUS _samr_del_groupmem(pipes_struct *p, SAMR_Q_DEL_GROUPMEM *q_u, SAMR_R_DEL_GROUPMEM *r_u)
{
- DEBUG(0,("_samr_del_groupmem: Not yet implemented.\n"));
- return False;
+ DEBUG(0,("_samr_del_groupmem: Not yet implemented.\n"));
+ return NT_STATUS_NOT_IMPLEMENTED;
}
/*********************************************************************
_samr_delete_dom_user
*********************************************************************/
-uint32 _samr_delete_dom_user(pipes_struct *p, SAMR_Q_DELETE_DOM_USER *q_u, SAMR_R_DELETE_DOM_USER *r_u )
+NTSTATUS _samr_delete_dom_user(pipes_struct *p, SAMR_Q_DELETE_DOM_USER *q_u, SAMR_R_DELETE_DOM_USER *r_u )
{
- DEBUG(0,("_samr_delete_dom_user: Not yet implemented.\n"));
- return False;
+ DEBUG(0,("_samr_delete_dom_user: Not yet implemented.\n"));
+ return NT_STATUS_NOT_IMPLEMENTED;
}
/*********************************************************************
_samr_delete_dom_group
*********************************************************************/
-uint32 _samr_delete_dom_group(pipes_struct *p, SAMR_Q_DELETE_DOM_GROUP *q_u, SAMR_R_DELETE_DOM_GROUP *r_u)
+NTSTATUS _samr_delete_dom_group(pipes_struct *p, SAMR_Q_DELETE_DOM_GROUP *q_u, SAMR_R_DELETE_DOM_GROUP *r_u)
{
DOM_SID group_sid;
DOM_SID dom_sid;
if (!close_policy_hnd(p, &q_u->group_pol))
return NT_STATUS_OBJECT_NAME_INVALID;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
_samr_delete_dom_alias
*********************************************************************/
-uint32 _samr_delete_dom_alias(pipes_struct *p, SAMR_Q_DELETE_DOM_ALIAS *q_u, SAMR_R_DELETE_DOM_ALIAS *r_u)
+NTSTATUS _samr_delete_dom_alias(pipes_struct *p, SAMR_Q_DELETE_DOM_ALIAS *q_u, SAMR_R_DELETE_DOM_ALIAS *r_u)
{
DOM_SID alias_sid;
DOM_SID dom_sid;
if (!close_policy_hnd(p, &q_u->alias_pol))
return NT_STATUS_OBJECT_NAME_INVALID;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
_samr_create_dom_group
*********************************************************************/
-uint32 _samr_create_dom_group(pipes_struct *p, SAMR_Q_CREATE_DOM_GROUP *q_u, SAMR_R_CREATE_DOM_GROUP *r_u)
+NTSTATUS _samr_create_dom_group(pipes_struct *p, SAMR_Q_CREATE_DOM_GROUP *q_u, SAMR_R_CREATE_DOM_GROUP *r_u)
{
DOM_SID dom_sid;
DOM_SID info_sid;
if (!create_policy_hnd(p, &r_u->pol, free_samr_info, (void *)info))
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
_samr_create_dom_alias
*********************************************************************/
-uint32 _samr_create_dom_alias(pipes_struct *p, SAMR_Q_CREATE_DOM_ALIAS *q_u, SAMR_R_CREATE_DOM_ALIAS *r_u)
+NTSTATUS _samr_create_dom_alias(pipes_struct *p, SAMR_Q_CREATE_DOM_ALIAS *q_u, SAMR_R_CREATE_DOM_ALIAS *r_u)
{
DOM_SID dom_sid;
fstring name;
if (!create_policy_hnd(p, &r_u->alias_pol, free_samr_info, (void *)info))
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
level 1 send also the number of users of that group
*********************************************************************/
-uint32 _samr_query_groupinfo(pipes_struct *p, SAMR_Q_QUERY_GROUPINFO *q_u, SAMR_R_QUERY_GROUPINFO *r_u)
+NTSTATUS _samr_query_groupinfo(pipes_struct *p, SAMR_Q_QUERY_GROUPINFO *q_u, SAMR_R_QUERY_GROUPINFO *r_u)
{
DOM_SID group_sid;
GROUP_MAP map;
return NT_STATUS_INVALID_INFO_CLASS;
}
- init_samr_r_query_groupinfo(r_u, ctr, NT_STATUS_NOPROBLEMO);
+ init_samr_r_query_groupinfo(r_u, ctr, NT_STATUS_OK);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
update a domain group's comment.
*********************************************************************/
-uint32 _samr_set_groupinfo(pipes_struct *p, SAMR_Q_SET_GROUPINFO *q_u, SAMR_R_SET_GROUPINFO *r_u)
+NTSTATUS _samr_set_groupinfo(pipes_struct *p, SAMR_Q_SET_GROUPINFO *q_u, SAMR_R_SET_GROUPINFO *r_u)
{
DOM_SID group_sid;
GROUP_MAP map;
if(!add_mapping_entry(&map, TDB_REPLACE))
return NT_STATUS_NO_SUCH_GROUP;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
update a domain group's comment.
*********************************************************************/
-uint32 _samr_set_aliasinfo(pipes_struct *p, SAMR_Q_SET_ALIASINFO *q_u, SAMR_R_SET_ALIASINFO *r_u)
+NTSTATUS _samr_set_aliasinfo(pipes_struct *p, SAMR_Q_SET_ALIASINFO *q_u, SAMR_R_SET_ALIASINFO *r_u)
{
DOM_SID group_sid;
GROUP_MAP map;
if(!add_mapping_entry(&map, TDB_REPLACE))
return NT_STATUS_NO_SUCH_GROUP;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
_samr_get_dom_pwinfo
*********************************************************************/
-uint32 _samr_get_dom_pwinfo(pipes_struct *p, SAMR_Q_GET_DOM_PWINFO *q_u, SAMR_R_GET_DOM_PWINFO *r_u)
+NTSTATUS _samr_get_dom_pwinfo(pipes_struct *p, SAMR_Q_GET_DOM_PWINFO *q_u, SAMR_R_GET_DOM_PWINFO *r_u)
{
/* Actually, returning zeros here works quite well :-). */
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
_samr_open_group
*********************************************************************/
-uint32 _samr_open_group(pipes_struct *p, SAMR_Q_OPEN_GROUP *q_u, SAMR_R_OPEN_GROUP *r_u)
+NTSTATUS _samr_open_group(pipes_struct *p, SAMR_Q_OPEN_GROUP *q_u, SAMR_R_OPEN_GROUP *r_u)
{
DOM_SID sid;
GROUP_MAP map;
if (!create_policy_hnd(p, &r_u->pol, free_samr_info, (void *)info))
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*********************************************************************
_samr_unknown_2d
*********************************************************************/
-uint32 _samr_unknown_2d(pipes_struct *p, SAMR_Q_UNKNOWN_2D *q_u, SAMR_R_UNKNOWN_2D *r_u)
+NTSTATUS _samr_unknown_2d(pipes_struct *p, SAMR_Q_UNKNOWN_2D *q_u, SAMR_R_UNKNOWN_2D *r_u)
{
- DEBUG(0,("_samr_unknown_2d: Not yet implemented.\n"));
- return False;
+ DEBUG(0,("_samr_unknown_2d: Not yet implemented.\n"));
+ return NT_STATUS_NOT_IMPLEMENTED;
}
automatically set the winprint processor for printer
entries later. Used to debug the LexMark Optra S 1855 PCL
driver --jerry */
- r_u.status = NT_STATUS_NOPROBLEMO;
+ r_u.status = NT_STATUS_OK;
if(!spoolss_io_r_addprintprocessor("", &r_u, rdata, 0)) {
DEBUG(0,("spoolss_io_r_addprintprocessor: unable to marshall SPOOL_R_ADDPRINTPROCESSOR.\n"));
static void srv_spoolss_replycloseprinter(POLICY_HND *handle)
{
- uint32 status;
+ NTSTATUS status;
/* weird if the test succeds !!! */
if (smb_connections==0) {
/****************************************************************************
delete a printer given a handle
****************************************************************************/
-static uint32 delete_printer_handle(pipes_struct *p, POLICY_HND *hnd)
+static NTSTATUS delete_printer_handle(pipes_struct *p, POLICY_HND *hnd)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
if (!Printer) {
DEBUG(0,("delete_printer_handle: Invalid handle (%s)\n", OUR_HANDLE(hnd)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
if (del_a_printer(Printer->dev.handlename) != 0) {
DEBUG(3,("Error deleting printer %s\n", Printer->dev.handlename));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
/* Check calling user has permission to delete printer. Note that
if (!print_access_check(NULL, -1, PRINTER_ACCESS_ADMINISTER)) {
DEBUG(3, ("printer delete denied by security descriptor\n"));
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
if (*lp_deleteprinter_cmd()) {
DEBUG(10,("Running [%s]\n", command));
ret = smbrun(command, NULL);
if (ret != 0) {
- return ERRbadfid; /* What to return here? */
+ return NT_STATUS_INVALID_HANDLE; /* What to return here? */
}
DEBUGADD(10,("returned [%d]\n", ret));
if ( ( i = lp_servicenumber( Printer->dev.handlename ) ) >= 0 ) {
lp_killservice( i );
- return ERRsuccess;
+ return NT_STATUS_OK;
} else
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
static void srv_spoolss_receive_message(int msg_type, pid_t src, void *buf, size_t len)
{
fstring printer;
- uint32 status;
+ NTSTATUS status;
struct pipes_struct *p;
struct policy *pol;
struct handle_list *hl;
* called from the spoolss dispatcher
********************************************************************/
-uint32 _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u, SPOOL_R_OPEN_PRINTER_EX *r_u)
+NTSTATUS _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u, SPOOL_R_OPEN_PRINTER_EX *r_u)
{
#if 0
- uint32 result = ERRsuccess;
+ uint32 result = NT_STATUS_OK;
#endif
UNISTR2 *printername = NULL;
printername = &q_u->printername;
if (printername == NULL)
- return ERRinvalidprintername;
+ return NT_STATUS_OBJECT_NAME_INVALID;
/* some sanity check because you can open a printer or a print server */
/* aka: \\server\printer or \\server */
DEBUGADD(3,("checking name: %s\n",name));
if (!open_printer_hnd(p, handle, name))
- return ERRinvalidprintername;
+ return NT_STATUS_OBJECT_NAME_INVALID;
/*
if (printer_default->datatype_ptr != NULL)
if (!set_printer_hnd_accesstype(p, handle, printer_default->access_required)) {
close_printer_handle(p, handle);
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
/*
if (handle_is_printserver(p, handle)) {
if (printer_default->access_required == 0) {
- return ERRsuccess;
+ return NT_STATUS_OK;
}
else if ((printer_default->access_required & SERVER_ACCESS_ADMINISTER ) == SERVER_ACCESS_ADMINISTER) {
if (!lp_ms_add_printer_wizard()) {
close_printer_handle(p, handle);
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
else if (user.uid == 0 || user_in_list(uidtoname(user.uid), lp_printer_admin(snum))) {
- return ERRsuccess;
+ return NT_STATUS_OK;
}
else {
close_printer_handle(p, handle);
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
}
}
doesn't have print permission. */
if (!get_printer_snum(p, handle, &snum))
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
/* map an empty access mask to the minimum access mask */
if (printer_default->access_required == 0x0)
if (!print_access_check(&user, snum, printer_default->access_required)) {
DEBUG(3, ("access DENIED for printer open\n"));
close_printer_handle(p, handle);
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
/*
#endif
}
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
* _spoolss_enddocprinter_internal.
********************************************************************/
-static uint32 _spoolss_enddocprinter_internal(pipes_struct *p, POLICY_HND *handle)
+static NTSTATUS _spoolss_enddocprinter_internal(pipes_struct *p, POLICY_HND *handle)
{
Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
if (!Printer) {
DEBUG(0,("_spoolss_enddocprinter_internal: Invalid handle (%s)\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
Printer->document_started=False;
print_job_end(Printer->jobid,True);
/* error codes unhandled so far ... */
- return 0x0;
+ return NT_STATUS_OK;
}
/********************************************************************
* api_spoolss_closeprinter
********************************************************************/
-uint32 _spoolss_closeprinter(pipes_struct *p, SPOOL_Q_CLOSEPRINTER *q_u, SPOOL_R_CLOSEPRINTER *r_u)
+NTSTATUS _spoolss_closeprinter(pipes_struct *p, SPOOL_Q_CLOSEPRINTER *q_u, SPOOL_R_CLOSEPRINTER *r_u)
{
POLICY_HND *handle = &q_u->handle;
memcpy(&r_u->handle, &q_u->handle, sizeof(r_u->handle));
if (!close_printer_handle(p, handle))
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
********************************************************************/
-uint32 _spoolss_deleteprinter(pipes_struct *p, SPOOL_Q_DELETEPRINTER *q_u, SPOOL_R_DELETEPRINTER *r_u)
+NTSTATUS _spoolss_deleteprinter(pipes_struct *p, SPOOL_Q_DELETEPRINTER *q_u, SPOOL_R_DELETEPRINTER *r_u)
{
POLICY_HND *handle = &q_u->handle;
-
Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
- uint32 result;
+ NTSTATUS result;
if (Printer && Printer->document_started)
_spoolss_enddocprinter_internal(p, handle); /* print job was not closed */
result = delete_printer_handle(p, handle);
- if (result == ERRsuccess) {
+ if (NT_STATUS_IS_OK(result)) {
srv_spoolss_sendnotify(p, handle);
}
* --jerry
********************************************************************/
-uint32 _spoolss_deleteprinterdriver(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIVER *q_u,
+NTSTATUS _spoolss_deleteprinterdriver(pipes_struct *p, SPOOL_Q_DELETEPRINTERDRIVER *q_u,
SPOOL_R_DELETEPRINTERDRIVER *r_u)
{
fstring driver;
/* check that we have a valid driver name first */
if ((version=get_version_id(arch)) == -1) {
- /* this is what NT returns */
- return ERRinvalidenvironment;
+ return NT_STATUS_REVISION_MISMATCH;
}
ZERO_STRUCT(info);
if (get_a_printer_driver (&info, 3, driver, arch, version) != 0) {
- /* this is what NT returns */
- return ERRunknownprinterdriver;
+ return NT_STATUS_DRIVER_ORDINAL_NOT_FOUND;
}
if (printer_driver_in_use(arch, driver))
{
- /* this is what NT returns */
- return ERRprinterdriverinuse;
+ return NT_STATUS_NETWORK_BUSY;
}
return delete_printer_driver(info.info_3);
* spoolss_getprinterdata
********************************************************************/
-uint32 _spoolss_getprinterdata(pipes_struct *p, SPOOL_Q_GETPRINTERDATA *q_u, SPOOL_R_GETPRINTERDATA *r_u)
+NTSTATUS _spoolss_getprinterdata(pipes_struct *p, SPOOL_Q_GETPRINTERDATA *q_u, SPOOL_R_GETPRINTERDATA *r_u)
{
POLICY_HND *handle = &q_u->handle;
UNISTR2 *valuename = &q_u->valuename;
if (!Printer) {
if((*data=(uint8 *)malloc(4*sizeof(uint8))) == NULL)
- return ERRnomem;
+ return NT_STATUS_NO_MEMORY;
DEBUG(0,("_spoolss_getprinterdata: Invalid handle (%s).\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
unistr2_to_ascii(value, valuename, sizeof(value)-1);
/* reply this param doesn't exist */
if (*out_size) {
if((*data=(uint8 *)talloc_zero(p->mem_ctx, *out_size*sizeof(uint8))) == NULL)
- return ERRnomem;
+ return NT_STATUS_NO_MEMORY;
} else {
*data = NULL;
}
- return ERRinvalidparam;
+ return NT_STATUS_INVALID_PARAMETER;
}
if (*needed > *out_size)
- return ERRmoredata;
+ return STATUS_MORE_ENTRIES;
else {
- return ERRsuccess;
+ return NT_STATUS_OK;
}
}
****************************************************************************/
static BOOL srv_spoolss_replyopenprinter(char *printer, uint32 localprinter, uint32 type, POLICY_HND *handle)
{
- uint32 status;
+ NTSTATUS status;
/*
* If it's the first connection, contact the client
* called from api_spoolss_rffpcnex
********************************************************************/
-uint32 _spoolss_rffpcnex(pipes_struct *p, SPOOL_Q_RFFPCNEX *q_u, SPOOL_R_RFFPCNEX *r_u)
+NTSTATUS _spoolss_rffpcnex(pipes_struct *p, SPOOL_Q_RFFPCNEX *q_u, SPOOL_R_RFFPCNEX *r_u)
{
POLICY_HND *handle = &q_u->handle;
uint32 flags = q_u->flags;
if (!Printer) {
DEBUG(0,("_spoolss_rffpcnex: Invalid handle (%s).\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
Printer->notify.flags=flags;
&Printer->notify.client_hnd))
Printer->notify.client_connected=True;
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/*******************************************************************
*
********************************************************************/
-static uint32 printserver_notify_info(pipes_struct *p, POLICY_HND *hnd,
+static NTSTATUS printserver_notify_info(pipes_struct *p, POLICY_HND *hnd,
SPOOL_NOTIFY_INFO *info,
TALLOC_CTX *mem_ctx)
{
}
*/
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/*******************************************************************
info->data[i].id, info->data[i].size, info->data[i].enc_type));
}
*/
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
* spoolss_rfnpcnex
********************************************************************/
-uint32 _spoolss_rfnpcnex( pipes_struct *p, SPOOL_Q_RFNPCNEX *q_u, SPOOL_R_RFNPCNEX *r_u)
+NTSTATUS _spoolss_rfnpcnex( pipes_struct *p, SPOOL_Q_RFNPCNEX *q_u, SPOOL_R_RFNPCNEX *r_u)
{
POLICY_HND *handle = &q_u->handle;
/* uint32 change = q_u->change; - notused. */
SPOOL_NOTIFY_INFO *info = &r_u->info;
Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
- uint32 result = ERRbadfid;
+ NTSTATUS result = NT_STATUS_INVALID_HANDLE;
/* we always have a NOTIFY_INFO struct */
r_u->info_ptr=0x1;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
* handle enumeration of printers at level 1
********************************************************************/
-static uint32 enumprinters_level1( uint32 flags, fstring name,
+static NTSTATUS enumprinters_level1( uint32 flags, fstring name,
NEW_BUFFER *buffer, uint32 offered,
uint32 *needed, uint32 *returned)
{
if (flags & PRINTER_ENUM_NETWORK)
return enum_all_printers_info_1_network(buffer, offered, needed, returned);
- return ERRsuccess; /* NT4sp5 does that */
+ return NT_STATUS_OK; /* NT4sp5 does that */
}
/********************************************************************
* handle enumeration of printers at level 2
********************************************************************/
-static uint32 enumprinters_level2( uint32 flags, fstring servername,
+static NTSTATUS enumprinters_level2( uint32 flags, fstring servername,
NEW_BUFFER *buffer, uint32 offered,
uint32 *needed, uint32 *returned)
{
if (flags & PRINTER_ENUM_REMOTE)
return ERRunknownlevel;
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
* handle enumeration of printers at level 5
********************************************************************/
-static uint32 enumprinters_level5( uint32 flags, fstring servername,
+static NTSTATUS enumprinters_level5( uint32 flags, fstring servername,
NEW_BUFFER *buffer, uint32 offered,
uint32 *needed, uint32 *returned)
{
/* return enum_all_printers_info_5(buffer, offered, needed, returned);*/
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
* called from api_spoolss_enumprinters (see this to understand)
********************************************************************/
-uint32 _spoolss_enumprinters( pipes_struct *p, SPOOL_Q_ENUMPRINTERS *q_u, SPOOL_R_ENUMPRINTERS *r_u)
+NTSTATUS _spoolss_enumprinters( pipes_struct *p, SPOOL_Q_ENUMPRINTERS *q_u, SPOOL_R_ENUMPRINTERS *r_u)
{
uint32 flags = q_u->flags;
UNISTR2 *servername = &q_u->servername;
/****************************************************************************
****************************************************************************/
-static uint32 getprinter_level_0(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getprinter_level_0(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_0 *printer=NULL;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-static uint32 getprinter_level_1(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getprinter_level_1(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_1 *printer=NULL;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-static uint32 getprinter_level_2(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getprinter_level_2(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_2 *printer=NULL;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-static uint32 getprinter_level_3(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getprinter_level_3(int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_3 *printer=NULL;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_getprinter(pipes_struct *p, SPOOL_Q_GETPRINTER *q_u, SPOOL_R_GETPRINTER *r_u)
+NTSTATUS _spoolss_getprinter(pipes_struct *p, SPOOL_Q_GETPRINTER *q_u, SPOOL_R_GETPRINTER *r_u)
{
POLICY_HND *handle = &q_u->handle;
uint32 level = q_u->level;
*needed=0;
if (!get_printer_snum(p, handle, &snum))
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
switch (level) {
case 0:
/********************************************************************
* construct_printer_driver_info_1
********************************************************************/
-static uint32 construct_printer_driver_info_1(DRIVER_INFO_1 *info, int snum, fstring servername, fstring architecture, uint32 version)
+static NTSTATUS construct_printer_driver_info_1(DRIVER_INFO_1 *info, int snum, fstring servername, fstring architecture, uint32 version)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
NT_PRINTER_DRIVER_INFO_LEVEL driver;
free_a_printer(&printer,2);
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
* construct_printer_driver_info_2
* fill a printer_info_2 struct
********************************************************************/
-static uint32 construct_printer_driver_info_2(DRIVER_INFO_2 *info, int snum, fstring servername, fstring architecture, uint32 version)
+static NTSTATUS construct_printer_driver_info_2(DRIVER_INFO_2 *info, int snum, fstring servername, fstring architecture, uint32 version)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
NT_PRINTER_DRIVER_INFO_LEVEL driver;
free_a_printer(&printer,2);
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
* construct_printer_info_3
* fill a printer_info_3 struct
********************************************************************/
-static uint32 construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum, fstring servername, fstring architecture, uint32 version)
+static NTSTATUS construct_printer_driver_info_3(DRIVER_INFO_3 *info, int snum, fstring servername, fstring architecture, uint32 version)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
NT_PRINTER_DRIVER_INFO_LEVEL driver;
- uint32 status=0;
+ NTSTATUS status=0;
ZERO_STRUCT(driver);
status=get_a_printer(&printer, 2, lp_servicename(snum) );
free_a_printer(&printer,2);
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
* construct_printer_info_6
* fill a printer_info_6 struct
********************************************************************/
-static uint32 construct_printer_driver_info_6(DRIVER_INFO_6 *info, int snum, fstring servername, fstring architecture, uint32 version)
+static NTSTATUS construct_printer_driver_info_6(DRIVER_INFO_6 *info, int snum, fstring servername, fstring architecture, uint32 version)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
NT_PRINTER_DRIVER_INFO_LEVEL driver;
- uint32 status=0;
+ NTSTATUS status=0;
ZERO_STRUCT(driver);
status=get_a_printer(&printer, 2, lp_servicename(snum) );
free_a_printer(&printer,2);
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
/****************************************************************************
****************************************************************************/
-static uint32 getprinterdriver2_level1(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getprinterdriver2_level1(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
DRIVER_INFO_1 *info=NULL;
- uint32 status;
+ NTSTATUS status;
if((info=(DRIVER_INFO_1 *)malloc(sizeof(DRIVER_INFO_1))) == NULL)
return ERRnomem;
status=construct_printer_driver_info_1(info, snum, servername, architecture, version);
- if (status != ERRsuccess) {
+ if (status != NT_STATUS_OK) {
safe_free(info);
return status;
}
if (*needed > offered)
return ERRinsufficientbuffer;
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-static uint32 getprinterdriver2_level2(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getprinterdriver2_level2(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
DRIVER_INFO_2 *info=NULL;
- uint32 status;
+ NTSTATUS status;
if((info=(DRIVER_INFO_2 *)malloc(sizeof(DRIVER_INFO_2))) == NULL)
return ERRnomem;
status=construct_printer_driver_info_2(info, snum, servername, architecture, version);
- if (status != ERRsuccess) {
+ if (status != NT_STATUS_OK) {
safe_free(info);
return status;
}
if (*needed > offered)
return ERRinsufficientbuffer;
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-static uint32 getprinterdriver2_level3(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getprinterdriver2_level3(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
DRIVER_INFO_3 info;
- uint32 status;
+ NTSTATUS status;
ZERO_STRUCT(info);
status=construct_printer_driver_info_3(&info, snum, servername, architecture, version);
- if (status != ERRsuccess) {
+ if (status != NT_STATUS_OK) {
return status;
}
if (*needed > offered)
return ERRinsufficientbuffer;
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-static uint32 getprinterdriver2_level6(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getprinterdriver2_level6(fstring servername, fstring architecture, uint32 version, int snum, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
DRIVER_INFO_6 info;
- uint32 status;
+ NTSTATUS status;
ZERO_STRUCT(info);
status=construct_printer_driver_info_6(&info, snum, servername, architecture, version);
- if (status != ERRsuccess) {
+ if (status != NT_STATUS_OK) {
return status;
}
if (*needed > offered)
return ERRinsufficientbuffer;
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_getprinterdriver2(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVER2 *q_u, SPOOL_R_GETPRINTERDRIVER2 *r_u)
+NTSTATUS _spoolss_getprinterdriver2(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVER2 *q_u, SPOOL_R_GETPRINTERDRIVER2 *r_u)
{
POLICY_HND *handle = &q_u->handle;
UNISTR2 *uni_arch = &q_u->architecture;
unistr2_to_ascii(architecture, uni_arch, sizeof(architecture)-1);
if (!get_printer_snum(p, handle, &snum))
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
switch (level) {
case 1:
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_startpageprinter(pipes_struct *p, SPOOL_Q_STARTPAGEPRINTER *q_u, SPOOL_R_STARTPAGEPRINTER *r_u)
+NTSTATUS _spoolss_startpageprinter(pipes_struct *p, SPOOL_Q_STARTPAGEPRINTER *q_u, SPOOL_R_STARTPAGEPRINTER *r_u)
{
POLICY_HND *handle = &q_u->handle;
}
DEBUG(3,("Error in startpageprinter printer handle\n"));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_endpageprinter(pipes_struct *p, SPOOL_Q_ENDPAGEPRINTER *q_u, SPOOL_R_ENDPAGEPRINTER *r_u)
+NTSTATUS _spoolss_endpageprinter(pipes_struct *p, SPOOL_Q_ENDPAGEPRINTER *q_u, SPOOL_R_ENDPAGEPRINTER *r_u)
{
POLICY_HND *handle = &q_u->handle;
if (!Printer) {
DEBUG(0,("_spoolss_endpageprinter: Invalid handle (%s).\n",OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
Printer->page_started=False;
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/********************************************************************
*
********************************************************************/
-uint32 _spoolss_startdocprinter(pipes_struct *p, SPOOL_Q_STARTDOCPRINTER *q_u, SPOOL_R_STARTDOCPRINTER *r_u)
+NTSTATUS _spoolss_startdocprinter(pipes_struct *p, SPOOL_Q_STARTDOCPRINTER *q_u, SPOOL_R_STARTDOCPRINTER *r_u)
{
POLICY_HND *handle = &q_u->handle;
/* uint32 level = q_u->doc_info_container.level; - notused. */
if (!Printer) {
DEBUG(0,("_spoolss_startdocprinter: Invalid handle (%s)\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
get_current_user(&user, p);
/* get the share number of the printer */
if (!get_printer_snum(p, handle, &snum)) {
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
unistr2_to_ascii(jobname, &info_1->docname, sizeof(jobname));
*
********************************************************************/
-uint32 _spoolss_enddocprinter(pipes_struct *p, SPOOL_Q_ENDDOCPRINTER *q_u, SPOOL_R_ENDDOCPRINTER *r_u)
+NTSTATUS _spoolss_enddocprinter(pipes_struct *p, SPOOL_Q_ENDDOCPRINTER *q_u, SPOOL_R_ENDDOCPRINTER *r_u)
{
POLICY_HND *handle = &q_u->handle;
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_writeprinter(pipes_struct *p, SPOOL_Q_WRITEPRINTER *q_u, SPOOL_R_WRITEPRINTER *r_u)
+NTSTATUS _spoolss_writeprinter(pipes_struct *p, SPOOL_Q_WRITEPRINTER *q_u, SPOOL_R_WRITEPRINTER *r_u)
{
POLICY_HND *handle = &q_u->handle;
uint32 buffer_size = q_u->buffer_size;
if (!Printer) {
DEBUG(0,("_spoolss_writeprinter: Invalid handle (%s)\n",OUR_HANDLE(handle)));
r_u->buffer_written = q_u->buffer_size2;
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
(*buffer_written) = print_job_write(Printer->jobid, (char *)buffer, buffer_size);
* called from the spoolss dispatcher
*
********************************************************************/
-static uint32 control_printer(POLICY_HND *handle, uint32 command,
+static NTSTATUS control_printer(POLICY_HND *handle, uint32 command,
pipes_struct *p)
{
struct current_user user;
if (!Printer) {
DEBUG(0,("control_printer: Invalid handle (%s)\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
if (!get_printer_snum(p, handle, &snum))
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
switch (command) {
case PRINTER_CONTROL_PAUSE:
* api_spoolss_abortprinter
********************************************************************/
-uint32 _spoolss_abortprinter(pipes_struct *p, SPOOL_Q_ABORTPRINTER *q_u, SPOOL_R_ABORTPRINTER *r_u)
+NTSTATUS _spoolss_abortprinter(pipes_struct *p, SPOOL_Q_ABORTPRINTER *q_u, SPOOL_R_ABORTPRINTER *r_u)
{
POLICY_HND *handle = &q_u->handle;
* called by spoolss_api_setprinter
* when updating a printer description
********************************************************************/
-static uint32 update_printer_sec(POLICY_HND *handle, uint32 level,
+static NTSTATUS update_printer_sec(POLICY_HND *handle, uint32 level,
const SPOOL_PRINTER_INFO_LEVEL *info,
pipes_struct *p, SEC_DESC_BUF *secdesc_ctr)
{
DEBUG(0,("update_printer_sec: Invalid handle (%s)\n",
OUR_HANDLE(handle)));
- result = ERRbadfid;
+ result = NT_STATUS_INVALID_HANDLE;
goto done;
}
new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
if (sec_desc_equal(new_secdesc_ctr->sec, old_secdesc_ctr->sec)) {
- result = ERRsuccess;
+ result = NT_STATUS_OK;
goto done;
}
information. */
if (!print_access_check(&user, snum, PRINTER_ACCESS_ADMINISTER)) {
- result = ERRnoaccess;
+ result = NT_STATUS_ACCESS_DENIED;
goto done;
}
* when updating a printer description
********************************************************************/
-static uint32 update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
+static NTSTATUS update_printer(pipes_struct *p, POLICY_HND *handle, uint32 level,
const SPOOL_PRINTER_INFO_LEVEL *info,
DEVICEMODE *devmode)
{
DEBUG(8,("update_printer\n"));
- result = ERRsuccess;
+ result = NT_STATUS_OK;
if (level!=2) {
DEBUG(0,("Send a mail to samba@samba.org\n"));
}
if (!Printer) {
- result = ERRbadfid;
+ result = NT_STATUS_INVALID_HANDLE;
goto done;
}
if (!get_printer_snum(p, handle, &snum)) {
- result = ERRbadfid;
+ result = NT_STATUS_INVALID_HANDLE;
goto done;
}
if((get_a_printer(&printer, 2, lp_servicename(snum)) != 0) ||
(get_a_printer(&old_printer, 2, lp_servicename(snum)) != 0)) {
- result = ERRbadfid;
+ result = NT_STATUS_INVALID_HANDLE;
goto done;
}
if (nt_printer_info_level_equal(printer, old_printer)) {
DEBUG(3, ("printer info has not changed\n"));
- result = ERRsuccess;
+ result = NT_STATUS_OK;
goto done;
}
if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
DEBUG(3, ("printer property change denied by security "
"descriptor\n"));
- result = ERRnoaccess;
+ result = NT_STATUS_ACCESS_DENIED;
goto done;
}
if (*lp_addprinter_cmd() )
if ( !add_printer_hook(printer) ) {
- result = ERRnoaccess;
+ result = NT_STATUS_ACCESS_DENIED;
goto done;
}
if (add_a_printer(*printer, 2)!=0) {
/* I don't really know what to return here !!! */
- result = ERRnoaccess;
+ result = NT_STATUS_ACCESS_DENIED;
goto done;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_setprinter(pipes_struct *p, SPOOL_Q_SETPRINTER *q_u, SPOOL_R_SETPRINTER *r_u)
+NTSTATUS _spoolss_setprinter(pipes_struct *p, SPOOL_Q_SETPRINTER *q_u, SPOOL_R_SETPRINTER *r_u)
{
POLICY_HND *handle = &q_u->handle;
uint32 level = q_u->level;
if (!Printer) {
DEBUG(0,("_spoolss_setprinter: Invalid handle (%s)\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
/* check the level */
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_fcpn(pipes_struct *p, SPOOL_Q_FCPN *q_u, SPOOL_R_FCPN *r_u)
+NTSTATUS _spoolss_fcpn(pipes_struct *p, SPOOL_Q_FCPN *q_u, SPOOL_R_FCPN *r_u)
{
POLICY_HND *handle = &q_u->handle;
if (!Printer) {
DEBUG(0,("_spoolss_fcpn: Invalid handle (%s)\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
if (Printer->notify.client_connected==True)
free_spool_notify_option(&Printer->notify.option);
Printer->notify.client_connected=False;
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_addjob(pipes_struct *p, SPOOL_Q_ADDJOB *q_u, SPOOL_R_ADDJOB *r_u)
+NTSTATUS _spoolss_addjob(pipes_struct *p, SPOOL_Q_ADDJOB *q_u, SPOOL_R_ADDJOB *r_u)
{
/* that's an [in out] buffer (despite appearences to the contrary) */
spoolss_move_buffer(q_u->buffer, &r_u->buffer);
/****************************************************************************
Enumjobs at level 1.
****************************************************************************/
-static uint32 enumjobs_level1(print_queue_struct *queue, int snum,
+static NTSTATUS enumjobs_level1(print_queue_struct *queue, int snum,
NEW_BUFFER *buffer, uint32 offered,
uint32 *needed, uint32 *returned)
{
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
Enumjobs at level 2.
****************************************************************************/
-static uint32 enumjobs_level2(print_queue_struct *queue, int snum,
+static NTSTATUS enumjobs_level2(print_queue_struct *queue, int snum,
NEW_BUFFER *buffer, uint32 offered,
uint32 *needed, uint32 *returned)
{
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
Enumjobs.
****************************************************************************/
-uint32 _spoolss_enumjobs( pipes_struct *p, SPOOL_Q_ENUMJOBS *q_u, SPOOL_R_ENUMJOBS *r_u)
+NTSTATUS _spoolss_enumjobs( pipes_struct *p, SPOOL_Q_ENUMJOBS *q_u, SPOOL_R_ENUMJOBS *r_u)
{
POLICY_HND *handle = &q_u->handle;
/* uint32 firstjob = q_u->firstjob; - notused. */
*returned=0;
if (!get_printer_snum(p, handle, &snum))
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
*returned = print_queue_status(snum, &queue, &prt_status);
DEBUGADD(4,("count:[%d], status:[%d], [%s]\n", *returned, prt_status.status, prt_status.message));
if (*returned == 0) {
safe_free(queue);
- return ERRsuccess;
+ return NT_STATUS_OK;
}
switch (level) {
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_schedulejob( pipes_struct *p, SPOOL_Q_SCHEDULEJOB *q_u, SPOOL_R_SCHEDULEJOB *r_u)
+NTSTATUS _spoolss_schedulejob( pipes_struct *p, SPOOL_Q_SCHEDULEJOB *q_u, SPOOL_R_SCHEDULEJOB *r_u)
{
return 0x0;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_setjob(pipes_struct *p, SPOOL_Q_SETJOB *q_u, SPOOL_R_SETJOB *r_u)
+NTSTATUS _spoolss_setjob(pipes_struct *p, SPOOL_Q_SETJOB *q_u, SPOOL_R_SETJOB *r_u)
{
POLICY_HND *handle = &q_u->handle;
uint32 jobid = q_u->jobid;
memset(&prt_status, 0, sizeof(prt_status));
if (!get_printer_snum(p, handle, &snum)) {
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
if (!print_job_exists(jobid)) {
/****************************************************************************
Enumerates all printer drivers at level 1.
****************************************************************************/
-static uint32 enumprinterdrivers_level1(fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
+static NTSTATUS enumprinterdrivers_level1(fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
int i;
int ndrivers;
}
for (i=0; i<ndrivers; i++) {
- uint32 status;
+ NTSTATUS status;
DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
ZERO_STRUCT(driver);
if ((status = get_a_printer_driver(&driver, 3, list[i], architecture, version)) != 0) {
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
Enumerates all printer drivers at level 2.
****************************************************************************/
-static uint32 enumprinterdrivers_level2(fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
+static NTSTATUS enumprinterdrivers_level2(fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
int i;
int ndrivers;
}
for (i=0; i<ndrivers; i++) {
- uint32 status;
+ NTSTATUS status;
DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
ZERO_STRUCT(driver);
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
Enumerates all printer drivers at level 3.
****************************************************************************/
-static uint32 enumprinterdrivers_level3(fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
+static NTSTATUS enumprinterdrivers_level3(fstring servername, fstring architecture, NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
int i;
int ndrivers;
}
for (i=0; i<ndrivers; i++) {
- uint32 status;
+ NTSTATUS status;
DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
ZERO_STRUCT(driver);
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
Enumerates all printer drivers.
****************************************************************************/
-uint32 _spoolss_enumprinterdrivers( pipes_struct *p, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, SPOOL_R_ENUMPRINTERDRIVERS *r_u)
+NTSTATUS _spoolss_enumprinterdrivers( pipes_struct *p, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, SPOOL_R_ENUMPRINTERDRIVERS *r_u)
{
/* UNISTR2 *name = &q_u->name; - notused. */
UNISTR2 *environment = &q_u->environment;
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_enumforms(pipes_struct *p, SPOOL_Q_ENUMFORMS *q_u, SPOOL_R_ENUMFORMS *r_u)
+NTSTATUS _spoolss_enumforms(pipes_struct *p, SPOOL_Q_ENUMFORMS *q_u, SPOOL_R_ENUMFORMS *r_u)
{
/* POLICY_HND *handle = &q_u->handle; - notused. */
uint32 level = q_u->level;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
default:
safe_free(list);
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_getform(pipes_struct *p, SPOOL_Q_GETFORM *q_u, SPOOL_R_GETFORM *r_u)
+NTSTATUS _spoolss_getform(pipes_struct *p, SPOOL_Q_GETFORM *q_u, SPOOL_R_GETFORM *r_u)
{
/* POLICY_HND *handle = &q_u->handle; - notused. */
uint32 level = q_u->level;
DEBUGADD(5,("Number of forms [%d]\n", numofforms));
if (numofforms == 0)
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
switch (level) {
safe_free(list);
if (i == numofforms) {
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
}
/* check the required size. */
DEBUGADD(6,("adding form %s [%d] to buffer\n", form_name, i));
smb_io_form_1("", buffer, &form_1, 0);
- return ERRsuccess;
+ return NT_STATUS_OK;
default:
safe_free(list);
/****************************************************************************
enumports level 1.
****************************************************************************/
-static uint32 enumports_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
+static NTSTATUS enumports_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
PORT_INFO_1 *ports=NULL;
int i=0;
if (fd != -1)
close(fd);
/* Is this the best error to return here? */
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
numlines = 0;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
enumports level 2.
****************************************************************************/
-static uint32 enumports_level_2(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
+static NTSTATUS enumports_level_2(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
PORT_INFO_2 *ports=NULL;
int i=0;
if (fd != -1)
close(fd);
/* Is this the best error to return here? */
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
numlines = 0;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
enumports.
****************************************************************************/
-uint32 _spoolss_enumports( pipes_struct *p, SPOOL_Q_ENUMPORTS *q_u, SPOOL_R_ENUMPORTS *r_u)
+NTSTATUS _spoolss_enumports( pipes_struct *p, SPOOL_Q_ENUMPORTS *q_u, SPOOL_R_ENUMPORTS *r_u)
{
/* UNISTR2 *name = &q_u->name; - notused. */
uint32 level = q_u->level;
/****************************************************************************
****************************************************************************/
-static uint32 spoolss_addprinterex_level_2( pipes_struct *p, const UNISTR2 *uni_srv_name,
+static NTSTATUS spoolss_addprinterex_level_2( pipes_struct *p, const UNISTR2 *uni_srv_name,
const SPOOL_PRINTER_INFO_LEVEL *info,
uint32 unk0, uint32 unk1, uint32 unk2, uint32 unk3,
uint32 user_switch, const SPOOL_USER_CTR *user,
if (*lp_addprinter_cmd() )
if ( !add_printer_hook(printer) ) {
free_a_printer(&printer,2);
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
slprintf(name, sizeof(name)-1, "\\\\%s\\%s", global_myname,
if ((snum = print_queue_snum(printer->info_2->sharename)) == -1) {
free_a_printer(&printer,2);
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
/* you must be a printer admin to add a new printer */
if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
free_a_printer(&printer,2);
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
/*
/* write the ASCII on disk */
if (add_a_printer(*printer, 2) != 0) {
free_a_printer(&printer,2);
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
if (!open_printer_hnd(p, handle, name)) {
/* Handle open failed - remove addition. */
del_a_printer(printer->info_2->sharename);
free_a_printer(&printer,2);
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
free_a_printer(&printer,2);
srv_spoolss_sendnotify(p, handle);
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_addprinterex( pipes_struct *p, SPOOL_Q_ADDPRINTEREX *q_u, SPOOL_R_ADDPRINTEREX *r_u)
+NTSTATUS _spoolss_addprinterex( pipes_struct *p, SPOOL_Q_ADDPRINTEREX *q_u, SPOOL_R_ADDPRINTEREX *r_u)
{
UNISTR2 *uni_srv_name = &q_u->server_name;
uint32 level = q_u->level;
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_addprinterdriver(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVER *q_u, SPOOL_R_ADDPRINTERDRIVER *r_u)
+NTSTATUS _spoolss_addprinterdriver(pipes_struct *p, SPOOL_Q_ADDPRINTERDRIVER *q_u, SPOOL_R_ADDPRINTERDRIVER *r_u)
{
/* UNISTR2 *server_name = &q_u->server_name; - notused. */
uint32 level = q_u->level;
SPOOL_PRINTER_DRIVER_INFO_LEVEL *info = &q_u->info;
- uint32 err = ERRsuccess;
+ uint32 err = NT_STATUS_OK;
NT_PRINTER_DRIVER_INFO_LEVEL driver;
struct current_user user;
}
DEBUG(5,("Cleaning driver's information\n"));
- if ((err = clean_up_driver_struct(driver, level, &user)) != ERRsuccess )
+ if ((err = clean_up_driver_struct(driver, level, &user)) != NT_STATUS_OK )
goto done;
DEBUG(5,("Moving driver to final destination\n"));
if(!move_driver_to_download_area(driver, level, &user, &err)) {
if (err == 0)
- err = ERRnoaccess;
+ err = NT_STATUS_ACCESS_DENIED;
goto done;
}
if (add_a_printer_driver(driver, level)!=0) {
- err = ERRnoaccess;
+ err = NT_STATUS_ACCESS_DENIED;
goto done;
}
/****************************************************************************
****************************************************************************/
-static uint32 getprinterdriverdir_level_1(UNISTR2 *name, UNISTR2 *uni_environment, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getprinterdriverdir_level_1(UNISTR2 *name, UNISTR2 *uni_environment, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
pstring path;
pstring long_archi;
if (*needed > offered)
return ERRinsufficientbuffer;
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_getprinterdriverdirectory(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, SPOOL_R_GETPRINTERDRIVERDIR *r_u)
+NTSTATUS _spoolss_getprinterdriverdirectory(pipes_struct *p, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, SPOOL_R_GETPRINTERDRIVERDIR *r_u)
{
UNISTR2 *name = &q_u->name;
UNISTR2 *uni_environment = &q_u->environment;
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, SPOOL_R_ENUMPRINTERDATA *r_u)
+NTSTATUS _spoolss_enumprinterdata(pipes_struct *p, SPOOL_Q_ENUMPRINTERDATA *q_u, SPOOL_R_ENUMPRINTERDATA *r_u)
{
POLICY_HND *handle = &q_u->handle;
uint32 idx = q_u->index;
if (!Printer) {
DEBUG(0,("_spoolss_enumprinterdata: Invalid handle (%s).\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
if (!get_printer_snum(p,handle, &snum))
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
if (get_a_printer(&printer, 2, lp_servicename(snum)) != 0)
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
/*
* The NT machine wants to know the biggest size of value and data
DEBUG(6,("final values: [%d], [%d]\n", *out_value_len, *out_data_len));
free_a_printer(&printer, 2);
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/*
safe_free(data);
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_setprinterdata( pipes_struct *p, SPOOL_Q_SETPRINTERDATA *q_u, SPOOL_R_SETPRINTERDATA *r_u)
+NTSTATUS _spoolss_setprinterdata( pipes_struct *p, SPOOL_Q_SETPRINTERDATA *q_u, SPOOL_R_SETPRINTERDATA *r_u)
{
POLICY_HND *handle = &q_u->handle;
UNISTR2 *value = &q_u->value;
NT_PRINTER_INFO_LEVEL *printer = NULL;
NT_PRINTER_PARAM *param = NULL, old_param;
int snum=0;
- uint32 status = 0x0;
+ NTSTATUS status = 0x0;
Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
DEBUG(5,("spoolss_setprinterdata\n"));
if (!Printer) {
DEBUG(0,("_spoolss_setprinterdata: Invalid handle (%s).\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
if (!get_printer_snum(p,handle, &snum))
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
status = get_a_printer(&printer, 2, lp_servicename(snum));
if (status != 0x0)
old_param.data_len) == 0) {
DEBUG(3, ("setprinterdata hasn't changed\n"));
- status = ERRsuccess;
+ status = NT_STATUS_OK;
goto done;
}
}
if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
DEBUG(3, ("security descriptor change denied by existing "
"security descriptor\n"));
- status = ERRnoaccess;
+ status = NT_STATUS_ACCESS_DENIED;
goto done;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_deleteprinterdata(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATA *q_u, SPOOL_R_DELETEPRINTERDATA *r_u)
+NTSTATUS _spoolss_deleteprinterdata(pipes_struct *p, SPOOL_Q_DELETEPRINTERDATA *q_u, SPOOL_R_DELETEPRINTERDATA *r_u)
{
POLICY_HND *handle = &q_u->handle;
UNISTR2 *value = &q_u->valuename;
NT_PRINTER_INFO_LEVEL *printer = NULL;
NT_PRINTER_PARAM param;
int snum=0;
- uint32 status = 0x0;
+ NTSTATUS status = 0x0;
Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
DEBUG(5,("spoolss_deleteprinterdata\n"));
if (!Printer) {
DEBUG(0,("_spoolss_deleteprinterdata: Invalid handle (%s).\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
if (!get_printer_snum(p, handle, &snum))
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
if (!print_access_check(NULL, snum, PRINTER_ACCESS_ADMINISTER)) {
DEBUG(3, ("_spoolss_deleteprinterdata: printer properties "
"change denied by existing security descriptor\n"));
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
status = get_a_printer(&printer, 2, lp_servicename(snum));
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_addform( pipes_struct *p, SPOOL_Q_ADDFORM *q_u, SPOOL_R_ADDFORM *r_u)
+NTSTATUS _spoolss_addform( pipes_struct *p, SPOOL_Q_ADDFORM *q_u, SPOOL_R_ADDFORM *r_u)
{
POLICY_HND *handle = &q_u->handle;
/* uint32 level = q_u->level; - notused. */
if (!Printer) {
DEBUG(0,("_spoolss_addform: Invalid handle (%s).\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
/* can't add if builtin */
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_deleteform( pipes_struct *p, SPOOL_Q_DELETEFORM *q_u, SPOOL_R_DELETEFORM *r_u)
+NTSTATUS _spoolss_deleteform( pipes_struct *p, SPOOL_Q_DELETEFORM *q_u, SPOOL_R_DELETEFORM *r_u)
{
POLICY_HND *handle = &q_u->handle;
UNISTR2 *form_name = &q_u->name;
if (!Printer) {
DEBUG(0,("_spoolss_deleteform: Invalid handle (%s).\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
/* can't delete if builtin */
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_setform(pipes_struct *p, SPOOL_Q_SETFORM *q_u, SPOOL_R_SETFORM *r_u)
+NTSTATUS _spoolss_setform(pipes_struct *p, SPOOL_Q_SETFORM *q_u, SPOOL_R_SETFORM *r_u)
{
POLICY_HND *handle = &q_u->handle;
/* UNISTR2 *uni_name = &q_u->name; - notused. */
if (!Printer) {
DEBUG(0,("_spoolss_setform: Invalid handle (%s).\n", OUR_HANDLE(handle)));
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
}
/* can't set if builtin */
if (get_a_builtin_ntform(&form->name,&tmpForm)) {
/****************************************************************************
enumprintprocessors level 1.
****************************************************************************/
-static uint32 enumprintprocessors_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
+static NTSTATUS enumprintprocessors_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
PRINTPROCESSOR_1 *info_1=NULL;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_enumprintprocessors(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, SPOOL_R_ENUMPRINTPROCESSORS *r_u)
+NTSTATUS _spoolss_enumprintprocessors(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, SPOOL_R_ENUMPRINTPROCESSORS *r_u)
{
/* UNISTR2 *name = &q_u->name; - notused. */
/* UNISTR2 *environment = &q_u->environment; - notused. */
/****************************************************************************
enumprintprocdatatypes level 1.
****************************************************************************/
-static uint32 enumprintprocdatatypes_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
+static NTSTATUS enumprintprocdatatypes_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
PRINTPROCDATATYPE_1 *info_1=NULL;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_enumprintprocdatatypes(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u)
+NTSTATUS _spoolss_enumprintprocdatatypes(pipes_struct *p, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u)
{
/* UNISTR2 *name = &q_u->name; - notused. */
/* UNISTR2 *processor = &q_u->processor; - notused. */
enumprintmonitors level 1.
****************************************************************************/
-static uint32 enumprintmonitors_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
+static NTSTATUS enumprintmonitors_level_1(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
PRINTMONITOR_1 *info_1=NULL;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
enumprintmonitors level 2.
****************************************************************************/
-static uint32 enumprintmonitors_level_2(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
+static NTSTATUS enumprintmonitors_level_2(NEW_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
PRINTMONITOR_2 *info_2=NULL;
return ERRinsufficientbuffer;
}
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_enumprintmonitors(pipes_struct *p, SPOOL_Q_ENUMPRINTMONITORS *q_u, SPOOL_R_ENUMPRINTMONITORS *r_u)
+NTSTATUS _spoolss_enumprintmonitors(pipes_struct *p, SPOOL_Q_ENUMPRINTMONITORS *q_u, SPOOL_R_ENUMPRINTMONITORS *r_u)
{
/* UNISTR2 *name = &q_u->name; - notused. */
uint32 level = q_u->level;
/****************************************************************************
****************************************************************************/
-static uint32 getjob_level_1(print_queue_struct *queue, int count, int snum, uint32 jobid, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getjob_level_1(print_queue_struct *queue, int count, int snum, uint32 jobid, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
int i=0;
BOOL found=False;
safe_free(queue);
safe_free(info_1);
/* I shoud reply something else ... I can't find the good one */
- return ERRsuccess;
+ return NT_STATUS_OK;
}
fill_job_info_1(info_1, &(queue[i-1]), i, snum);
if (*needed > offered)
return ERRinsufficientbuffer;
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-static uint32 getjob_level_2(print_queue_struct *queue, int count, int snum, uint32 jobid, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
+static NTSTATUS getjob_level_2(print_queue_struct *queue, int count, int snum, uint32 jobid, NEW_BUFFER *buffer, uint32 offered, uint32 *needed)
{
int i=0;
BOOL found=False;
safe_free(queue);
safe_free(info_2);
/* I shoud reply something else ... I can't find the good one */
- return ERRsuccess;
+ return NT_STATUS_OK;
}
if (get_a_printer(&ntprinter, 2, lp_servicename(snum)) !=0) {
if (*needed > offered)
return ERRinsufficientbuffer;
else
- return ERRsuccess;
+ return NT_STATUS_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 _spoolss_getjob( pipes_struct *p, SPOOL_Q_GETJOB *q_u, SPOOL_R_GETJOB *r_u)
+NTSTATUS _spoolss_getjob( pipes_struct *p, SPOOL_Q_GETJOB *q_u, SPOOL_R_GETJOB *r_u)
{
POLICY_HND *handle = &q_u->handle;
uint32 jobid = q_u->jobid;
*needed=0;
if (!get_printer_snum(p, handle, &snum))
- return ERRbadfid;
+ return NT_STATUS_INVALID_HANDLE;
count = print_queue_status(snum, &queue, &prt_status);
BOOL share_access_check(connection_struct *conn, int snum, uint16 vuid, uint32 desired_access)
{
- uint32 granted, status;
+ uint32 granted;
+ NTSTATUS status;
TALLOC_CTX *mem_ctx = NULL;
SEC_DESC *psd = NULL;
size_t sd_size;
if (init_srv_share_info_ctr(p, &r_n->ctr, info_level,
&resume_hnd, &r_n->total_entries, all)) {
- r_n->status = NT_STATUS_NOPROBLEMO;
+ r_n->status = NT_STATUS_OK;
} else {
r_n->status = NT_STATUS_INVALID_INFO_CLASS;
}
static void init_srv_r_net_share_get_info(pipes_struct *p, SRV_R_NET_SHARE_GET_INFO *r_n,
char *share_name, uint32 info_level)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
int snum;
DEBUG(5,("init_srv_r_net_share_get_info: %d\n", __LINE__));
status = NT_STATUS_BAD_NETWORK_NAME;
}
- r_n->info.ptr_share_ctr = (status == NT_STATUS_NOPROBLEMO) ? 1 : 0;
+ r_n->info.ptr_share_ctr = NT_STATUS_IS_OK(status) ? 1 : 0;
r_n->status = status;
}
makes a SRV_R_NET_SESS_ENUM structure.
********************************************************************/
-static uint32 init_srv_sess_info_ctr(SRV_SESS_INFO_CTR *ctr,
+static NTSTATUS init_srv_sess_info_ctr(SRV_SESS_INFO_CTR *ctr,
int switch_value, uint32 *resume_hnd, uint32 *total_entries)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
DEBUG(5,("init_srv_sess_info_ctr: %d\n", __LINE__));
ctr->switch_value = switch_value;
else
r_n->status = init_srv_sess_info_ctr(r_n->ctr, switch_value, &resume_hnd, &r_n->total_entries);
- if (r_n->status != NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_IS_ERR(r_n->status))
resume_hnd = 0;
init_enum_hnd(&r_n->enum_hnd, resume_hnd);
makes a SRV_R_NET_CONN_ENUM structure.
********************************************************************/
-static uint32 init_srv_conn_info_ctr(SRV_CONN_INFO_CTR *ctr,
+static NTSTATUS init_srv_conn_info_ctr(SRV_CONN_INFO_CTR *ctr,
int switch_value, uint32 *resume_hnd, uint32 *total_entries)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
DEBUG(5,("init_srv_conn_info_ctr: %d\n", __LINE__));
ctr->switch_value = switch_value;
else
r_n->status = init_srv_conn_info_ctr(r_n->ctr, switch_value, &resume_hnd, &r_n->total_entries);
- if (r_n->status != NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_IS_ERR(r_n->status))
resume_hnd = 0;
init_enum_hnd(&r_n->enum_hnd, resume_hnd);
makes a SRV_R_NET_FILE_ENUM structure.
********************************************************************/
-static uint32 init_srv_file_info_ctr(SRV_FILE_INFO_CTR *ctr,
+static NTSTATUS init_srv_file_info_ctr(SRV_FILE_INFO_CTR *ctr,
int switch_value, uint32 *resume_hnd, uint32 *total_entries)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
DEBUG(5,("init_srv_file_info_ctr: %d\n", __LINE__));
ctr->switch_value = switch_value;
else
r_n->status = init_srv_file_info_ctr(r_n->ctr, switch_value, &resume_hnd, &(r_n->total_entries));
- if (r_n->status != NT_STATUS_NOPROBLEMO)
+ if (NT_STATUS_IS_ERR(r_n->status))
resume_hnd = 0;
init_enum_hnd(&r_n->enum_hnd, resume_hnd);
net server get info
********************************************************************/
-uint32 _srv_net_srv_get_info(pipes_struct *p, SRV_Q_NET_SRV_GET_INFO *q_u, SRV_R_NET_SRV_GET_INFO *r_u)
+NTSTATUS _srv_net_srv_get_info(pipes_struct *p, SRV_Q_NET_SRV_GET_INFO *q_u, SRV_R_NET_SRV_GET_INFO *r_u)
{
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
SRV_INFO_CTR *ctr = (SRV_INFO_CTR *)talloc(p->mem_ctx, sizeof(SRV_INFO_CTR));
if (!ctr)
net server set info
********************************************************************/
-uint32 _srv_net_srv_set_info(pipes_struct *p, SRV_Q_NET_SRV_SET_INFO *q_u, SRV_R_NET_SRV_SET_INFO *r_u)
+NTSTATUS _srv_net_srv_set_info(pipes_struct *p, SRV_Q_NET_SRV_SET_INFO *q_u, SRV_R_NET_SRV_SET_INFO *r_u)
{
/* NT gives "Windows NT error 0xc00000022" if we return
NT_STATUS_ACCESS_DENIED here so just pretend everything is OK. */
- uint32 status = NT_STATUS_NOPROBLEMO;
+ NTSTATUS status = NT_STATUS_OK;
DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
net file enum
********************************************************************/
-uint32 _srv_net_file_enum(pipes_struct *p, SRV_Q_NET_FILE_ENUM *q_u, SRV_R_NET_FILE_ENUM *r_u)
+NTSTATUS _srv_net_file_enum(pipes_struct *p, SRV_Q_NET_FILE_ENUM *q_u, SRV_R_NET_FILE_ENUM *r_u)
{
r_u->ctr = (SRV_FILE_INFO_CTR *)talloc(p->mem_ctx, sizeof(SRV_FILE_INFO_CTR));
if (!r_u->ctr)
net conn enum
********************************************************************/
-uint32 _srv_net_conn_enum(pipes_struct *p, SRV_Q_NET_CONN_ENUM *q_u, SRV_R_NET_CONN_ENUM *r_u)
+NTSTATUS _srv_net_conn_enum(pipes_struct *p, SRV_Q_NET_CONN_ENUM *q_u, SRV_R_NET_CONN_ENUM *r_u)
{
DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
net sess enum
********************************************************************/
-uint32 _srv_net_sess_enum(pipes_struct *p, SRV_Q_NET_SESS_ENUM *q_u, SRV_R_NET_SESS_ENUM *r_u)
+NTSTATUS _srv_net_sess_enum(pipes_struct *p, SRV_Q_NET_SESS_ENUM *q_u, SRV_R_NET_SESS_ENUM *r_u)
{
DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
Net share enum all.
********************************************************************/
-uint32 _srv_net_share_enum_all(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
+NTSTATUS _srv_net_share_enum_all(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
{
DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
Net share enum.
********************************************************************/
-uint32 _srv_net_share_enum(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
+NTSTATUS _srv_net_share_enum(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
{
DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
Net share get info.
********************************************************************/
-uint32 _srv_net_share_get_info(pipes_struct *p, SRV_Q_NET_SHARE_GET_INFO *q_u, SRV_R_NET_SHARE_GET_INFO *r_u)
+NTSTATUS _srv_net_share_get_info(pipes_struct *p, SRV_Q_NET_SHARE_GET_INFO *q_u, SRV_R_NET_SHARE_GET_INFO *r_u)
{
fstring share_name;
Net share set info. Modify share details.
********************************************************************/
-uint32 _srv_net_share_set_info(pipes_struct *p, SRV_Q_NET_SHARE_SET_INFO *q_u, SRV_R_NET_SHARE_SET_INFO *r_u)
+NTSTATUS _srv_net_share_set_info(pipes_struct *p, SRV_Q_NET_SHARE_SET_INFO *q_u, SRV_R_NET_SHARE_SET_INFO *r_u)
{
struct current_user user;
pstring command;
r_u->switch_value = 0;
if (strequal(share_name,"IPC$") || strequal(share_name,"ADMIN$") || strequal(share_name,"global"))
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
snum = find_service(share_name);
/* Does this share exist ? */
if (snum < 0)
- return ERRnosuchshare;
+ return NT_STATUS_BAD_NETWORK_NAME;
/* No change to printer shares. */
if (lp_print_ok(snum))
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
get_current_user(&user,p);
if (user.uid != 0)
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
switch (q_u->info_level) {
case 1:
/* Not enough info in a level 1 to do anything. */
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
case 2:
unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(share_name));
unistr2_to_ascii(pathname, &q_u->info.share.info2.info_2_str.uni_path, sizeof(share_name));
map_generic_share_sd_bits(psd);
break;
case 1005:
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
case 1501:
fstrcpy(pathname, lp_pathname(snum));
fstrcpy(comment, lp_comment(snum));
/* We can only modify disk shares. */
if (type != STYPE_DISKTREE)
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
/* Check if the pathname is valid. */
if (!(ptr = valid_share_pathname( pathname )))
- return ERRbadpath;
+ return NT_STATUS_OBJECT_PATH_INVALID;
/* Ensure share name, pathname and comment don't contain '"' characters. */
string_replace(share_name, '"', ' ');
if (strcmp(ptr, lp_pathname(snum)) || strcmp(comment, lp_comment(snum)) ) {
if (!lp_change_share_cmd() || !*lp_change_share_cmd())
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\"",
lp_change_share_cmd(), CONFIGFILE, share_name, ptr, comment);
DEBUG(10,("_srv_net_share_set_info: Running [%s]\n", command ));
if ((ret = smbrun(command, NULL)) != 0) {
DEBUG(0,("_srv_net_share_set_info: Running [%s] returned (%d)\n", command, ret ));
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
/* Tell everyone we updated smb.conf. */
DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
Net share add. Call 'add_share_command "sharename" "pathname" "comment" "read only = xxx"'
********************************************************************/
-uint32 _srv_net_share_add(pipes_struct *p, SRV_Q_NET_SHARE_ADD *q_u, SRV_R_NET_SHARE_ADD *r_u)
+NTSTATUS _srv_net_share_add(pipes_struct *p, SRV_Q_NET_SHARE_ADD *q_u, SRV_R_NET_SHARE_ADD *r_u)
{
struct current_user user;
pstring command;
if (user.uid != 0) {
DEBUG(10,("_srv_net_share_add: uid != 0. Access denied.\n"));
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
if (!lp_add_share_cmd() || !*lp_add_share_cmd()) {
DEBUG(10,("_srv_net_share_add: No add share command\n"));
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
switch (q_u->info_level) {
case 1:
/* Not enough info in a level 1 to do anything. */
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
case 2:
unistr2_to_ascii(share_name, &q_u->info.share.info2.info_2_str.uni_netname, sizeof(share_name));
unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(share_name));
break;
case 1005:
/* DFS only level. */
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
default:
DEBUG(5,("_srv_net_share_add: unsupported switch value %d\n", q_u->info_level));
return NT_STATUS_INVALID_INFO_CLASS;
}
if (strequal(share_name,"IPC$") || strequal(share_name,"ADMIN$") || strequal(share_name,"global"))
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
snum = find_service(share_name);
/* Share already exists. */
if (snum >= 0)
- return ERRfilexists;
+ return NT_STATUS_OBJECT_NAME_COLLISION;
/* We can only add disk shares. */
if (type != STYPE_DISKTREE)
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
/* Check if the pathname is valid. */
if (!(ptr = valid_share_pathname( pathname )))
- return ERRbadpath;
+ return NT_STATUS_OBJECT_PATH_INVALID;
/* Ensure share name, pathname and comment don't contain '"' characters. */
string_replace(share_name, '"', ' ');
DEBUG(10,("_srv_net_share_add: Running [%s]\n", command ));
if ((ret = smbrun(command, NULL)) != 0) {
DEBUG(0,("_srv_net_share_add: Running [%s] returned (%d)\n", command, ret ));
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
if (psd) {
DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
a parameter.
********************************************************************/
-uint32 _srv_net_share_del(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
+NTSTATUS _srv_net_share_del(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
{
struct current_user user;
pstring command;
unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
if (strequal(share_name,"IPC$") || strequal(share_name,"ADMIN$") || strequal(share_name,"global"))
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
snum = find_service(share_name);
if (snum < 0)
- return ERRnosuchshare;
+ return NT_STATUS_BAD_NETWORK_NAME;
/* No change to printer shares. */
if (lp_print_ok(snum))
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
get_current_user(&user,p);
if (user.uid != 0)
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
if (!lp_delete_share_cmd() || !*lp_delete_share_cmd())
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\"",
lp_delete_share_cmd(), CONFIGFILE, lp_servicename(snum));
DEBUG(10,("_srv_net_share_del: Running [%s]\n", command ));
if ((ret = smbrun(command, NULL)) != 0) {
DEBUG(0,("_srv_net_share_del: Running [%s] returned (%d)\n", command, ret ));
- return ERRnoaccess;
+ return NT_STATUS_ACCESS_DENIED;
}
/* Delete the SD in the database. */
lp_killservice(snum);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/*******************************************************************
time of day
********************************************************************/
-uint32 _srv_net_remote_tod(pipes_struct *p, SRV_Q_NET_REMOTE_TOD *q_u, SRV_R_NET_REMOTE_TOD *r_u)
+NTSTATUS _srv_net_remote_tod(pipes_struct *p, SRV_Q_NET_REMOTE_TOD *q_u, SRV_R_NET_REMOTE_TOD *r_u)
{
TIME_OF_DAY_INFO *tod;
struct tm *t;
r_u->tod = tod;
r_u->ptr_srv_tod = 0x1;
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
Win9x NT tools get security descriptor.
***********************************************************************************/
-uint32 _srv_net_file_query_secdesc(pipes_struct *p, SRV_Q_NET_FILE_QUERY_SECDESC *q_u,
+NTSTATUS _srv_net_file_query_secdesc(pipes_struct *p, SRV_Q_NET_FILE_QUERY_SECDESC *q_u,
SRV_R_NET_FILE_QUERY_SECDESC *r_u)
{
SEC_DESC *psd = NULL;
BOOL bad_path;
int access_mode;
int action;
- int ecode;
+ NTSTATUS ecode;
struct current_user user;
fstring user_name;
connection_struct *conn = NULL;
ZERO_STRUCT(st);
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
unistr2_to_ascii(qualname, &q_u->uni_qual_name, sizeof(qualname));
if (conn == NULL) {
DEBUG(3,("_srv_net_file_query_secdesc: Unable to connect to %s\n", qualname));
- r_u->status = (uint32)ecode;
+ r_u->status = ecode;
goto error_exit;
}
if (!fsp) {
DEBUG(3,("_srv_net_file_query_secdesc: Unable to open file %s\n", filename));
- r_u->status = ERRnoaccess;
+ r_u->status = NT_STATUS_ACCESS_DENIED;
goto error_exit;
}
}
if (sd_size == 0) {
DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", filename));
- r_u->status = ERRnoaccess;
+ r_u->status = NT_STATUS_ACCESS_DENIED;
goto error_exit;
}
Win9x NT tools set security descriptor.
***********************************************************************************/
-uint32 _srv_net_file_set_secdesc(pipes_struct *p, SRV_Q_NET_FILE_SET_SECDESC *q_u,
+NTSTATUS _srv_net_file_set_secdesc(pipes_struct *p, SRV_Q_NET_FILE_SET_SECDESC *q_u,
SRV_R_NET_FILE_SET_SECDESC *r_u)
{
BOOL ret;
BOOL bad_path;
int access_mode;
int action;
- int ecode;
+ NTSTATUS ecode;
struct current_user user;
fstring user_name;
connection_struct *conn = NULL;
ZERO_STRUCT(st);
- r_u->status = NT_STATUS_NOPROBLEMO;
+ r_u->status = NT_STATUS_OK;
unistr2_to_ascii(qualname, &q_u->uni_qual_name, sizeof(qualname));
if (conn == NULL) {
DEBUG(3,("_srv_net_file_set_secdesc: Unable to connect to %s\n", qualname));
- r_u->status = (uint32)ecode;
+ r_u->status = ecode;
goto error_exit;
}
if (!become_user(conn, conn->vuid)) {
DEBUG(0,("_srv_net_file_set_secdesc: Can't become connected user!\n"));
- r_u->status = ERRnoaccess;
+ r_u->status = NT_STATUS_ACCESS_DENIED;
goto error_exit;
}
became_user = True;
if (!fsp) {
DEBUG(3,("_srv_net_file_set_secdesc: Unable to open file %s\n", filename));
- r_u->status = ERRnoaccess;
+ r_u->status = NT_STATUS_ACCESS_DENIED;
goto error_exit;
}
}
if (ret == False) {
DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", filename));
- r_u->status = ERRnoaccess;
+ r_u->status = NT_STATUS_ACCESS_DENIED;
goto error_exit;
}
return disk;
}
-uint32 _srv_net_disk_enum(pipes_struct *p, SRV_Q_NET_DISK_ENUM *q_u, SRV_R_NET_DISK_ENUM *r_u)
+NTSTATUS _srv_net_disk_enum(pipes_struct *p, SRV_Q_NET_DISK_ENUM *q_u, SRV_R_NET_DISK_ENUM *r_u)
{
uint32 i;
const char *disk_name;
uint32 resume=get_enum_hnd(&q_u->enum_hnd);
- r_u->status=NT_STATUS_NOPROBLEMO;
+ r_u->status=NT_STATUS_OK;
r_u->total_entries = init_server_disk_enum(&resume);
return r_u->status;
}
-uint32 _srv_net_name_validate(pipes_struct *p, SRV_Q_NET_NAME_VALIDATE *q_u, SRV_R_NET_NAME_VALIDATE *r_u)
+NTSTATUS _srv_net_name_validate(pipes_struct *p, SRV_Q_NET_NAME_VALIDATE *q_u, SRV_R_NET_NAME_VALIDATE *r_u)
{
int snum;
fstring share_name;
- r_u->status=NT_STATUS_NOPROBLEMO;
+ r_u->status=NT_STATUS_OK;
switch(q_u->type) {
default:
/*unsupported type*/
- r_u->status = ERRunknownlevel;
+ r_u->status = NT_STATUS_INVALID_LEVEL;
break;
}
/*******************************************************************
Look up a local (domain) rid and return a name and type.
********************************************************************/
-uint32 local_lookup_group_name(uint32 rid, char *group_name, uint32 *type)
+NTSTATUS local_lookup_group_name(uint32 rid, char *group_name, uint32 *type)
{
int i = 0;
(*type) = SID_NAME_DOM_GRP;
{
fstrcpy(group_name, domain_group_rids[i].name);
DEBUG(5,(" = %s\n", group_name));
- return 0x0;
+ return NT_STATUS_OK;
}
DEBUG(5,(" none mapped\n"));
/*******************************************************************
Look up a local alias rid and return a name and type.
********************************************************************/
-uint32 local_lookup_alias_name(uint32 rid, char *alias_name, uint32 *type)
+NTSTATUS local_lookup_alias_name(uint32 rid, char *alias_name, uint32 *type)
{
int i = 0;
(*type) = SID_NAME_WKN_GRP;
{
fstrcpy(alias_name, builtin_alias_rids[i].name);
DEBUG(5,(" = %s\n", alias_name));
- return 0x0;
+ return NT_STATUS_OK;
}
DEBUG(5,(" none mapped\n"));
/*******************************************************************
Look up a local user rid and return a name and type.
********************************************************************/
-uint32 local_lookup_user_name(uint32 rid, char *user_name, uint32 *type)
+NTSTATUS local_lookup_user_name(uint32 rid, char *user_name, uint32 *type)
{
SAM_ACCOUNT *sampwd=NULL;
int i = 0;
if (domain_user_rids[i].rid != 0) {
fstrcpy(user_name, domain_user_rids[i].name);
DEBUG(5,(" = %s\n", user_name));
- return 0x0;
+ return NT_STATUS_OK;
}
pdb_init_sam(&sampwd);
fstrcpy(user_name, pdb_get_username(sampwd) );
DEBUG(5,(" = %s\n", user_name));
pdb_free_sam(sampwd);
- return 0x0;
+ return NT_STATUS_OK;
}
DEBUG(5,(" none mapped\n"));
/*******************************************************************
Look up a local (domain) group name and return a rid
********************************************************************/
-uint32 local_lookup_group_rid(char *group_name, uint32 *rid)
+NTSTATUS local_lookup_group_rid(char *group_name, uint32 *rid)
{
char *grp_name;
int i = -1; /* start do loop at -1 */
} while (grp_name != NULL && !strequal(grp_name, group_name));
- return (grp_name != NULL) ? 0 : NT_STATUS_NONE_MAPPED;
+ return (grp_name != NULL) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
}
/*******************************************************************
Look up a local (BUILTIN) alias name and return a rid
********************************************************************/
-uint32 local_lookup_alias_rid(char *alias_name, uint32 *rid)
+NTSTATUS local_lookup_alias_rid(char *alias_name, uint32 *rid)
{
char *als_name;
int i = -1; /* start do loop at -1 */
} while (als_name != NULL && !strequal(als_name, alias_name));
- return (als_name != NULL) ? 0 : NT_STATUS_NONE_MAPPED;
+ return (als_name != NULL) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
}
/*******************************************************************
Look up a local user name and return a rid
********************************************************************/
-uint32 local_lookup_user_rid(char *user_name, uint32 *rid)
+NTSTATUS local_lookup_user_rid(char *user_name, uint32 *rid)
{
SAM_ACCOUNT *sampass=NULL;
BOOL ret;
if (ret == True) {
(*rid) = pdb_get_user_rid(sampass);
pdb_free_sam(sampass);
- return 0x0;
+ return NT_STATUS_OK;
}
pdb_free_sam(sampass);
********************************************************************/
-uint32 _wks_query_info(pipes_struct *p, WKS_Q_QUERY_INFO *q_u, WKS_R_QUERY_INFO *r_u)
+NTSTATUS _wks_query_info(pipes_struct *p, WKS_Q_QUERY_INFO *q_u, WKS_R_QUERY_INFO *r_u)
{
WKS_INFO_100 *wks100 = NULL;
return NT_STATUS_NO_MEMORY;
create_wks_info_100(wks100);
- init_wks_r_query_info(r_u, q_u->switch_value, wks100, NT_STATUS_NOPROBLEMO);
+ init_wks_r_query_info(r_u, q_u->switch_value, wks100, NT_STATUS_OK);
DEBUG(5,("_wks_query_info: %d\n", __LINE__));
result = cli_dfs_exist(cli, mem_ctx, &dfs_exists);
- if (result == NT_STATUS_NOPROBLEMO)
+ if (result == NT_STATUS_OK)
printf("dfs is %spresent\n", dfs_exists ? "" : "not ");
cli_nt_session_close(cli);
/* Call RPC function */
if ((result = cli_dfs_enum(cli, mem_ctx, info_level, &ctr))
- == NT_STATUS_NOPROBLEMO) {
+ == NT_STATUS_OK) {
/* Print results */
display_dfs_info_ctr(&ctr);
if ((result = cli_dfs_get_info(cli, mem_ctx, entrypath, servername,
sharename, info_level, &ctr))
- == NT_STATUS_NOPROBLEMO) {
+ == NT_STATUS_OK) {
/* Print results */
if ((result = cli_lsa_open_policy(cli, mem_ctx, True,
SEC_RIGHTS_MAXIMUM_ALLOWED,
- &pol)) != NT_STATUS_NOPROBLEMO) {
+ &pol)) != NT_STATUS_OK) {
goto done;
}
if ((result = cli_lsa_query_info_policy(cli, mem_ctx, &pol, info_class,
domain_name, &dom_sid))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_lsa_open_policy(cli, mem_ctx, True,
SEC_RIGHTS_MAXIMUM_ALLOWED,
- &pol)) != NT_STATUS_NOPROBLEMO) {
+ &pol)) != NT_STATUS_OK) {
goto done;
}
if ((result = cli_lsa_lookup_names(cli, mem_ctx, &pol, argc - 1,
&argv[1], &sids, &types, &num_names) !=
- NT_STATUS_NOPROBLEMO)) {
+ NT_STATUS_OK)) {
goto done;
}
if ((result = cli_lsa_open_policy(cli, mem_ctx, True,
SEC_RIGHTS_MAXIMUM_ALLOWED,
- &pol)) != NT_STATUS_NOPROBLEMO) {
+ &pol)) != NT_STATUS_OK) {
goto done;
}
if ((result = cli_lsa_lookup_sids(cli, mem_ctx, &pol, argc - 1, sids,
&names, &types, &num_names) !=
- NT_STATUS_NOPROBLEMO)) {
+ NT_STATUS_OK)) {
goto done;
}
if ((result = cli_lsa_open_policy(cli, mem_ctx, True,
SEC_RIGHTS_MAXIMUM_ALLOWED,
- &pol)) != NT_STATUS_NOPROBLEMO) {
+ &pol)) != NT_STATUS_OK) {
goto done;
}
if ((result = cli_lsa_enum_trust_dom(cli, mem_ctx, &pol, &enum_ctx,
&num_domains, &domain_names,
&domain_sids)
- != NT_STATUS_NOPROBLEMO)) {
+ != NT_STATUS_OK)) {
goto done;
}
}
if ((result = cli_netlogon_logon_ctrl2(cli, mem_ctx, query_level))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
#if 0
if ((result = cli_netlogon_logon_ctrl(cli, mem_ctx, query_level))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
#endif
/* create an entry */
result = cli_reg_shutdown(cli, mem_ctx, srv_name, msg, timeout, flgs);
- if (result == NT_STATUS_NOPROBLEMO)
+ if (result == NT_STATUS_OK)
DEBUG(5,("cmd_reg_shutdown: query succeeded\n"));
else
DEBUG(5,("cmd_reg_shutdown: query failed\n"));
result = cli_reg_abort_shutdown(cli, mem_ctx, srv_name);
- if (result == NT_STATUS_NOPROBLEMO)
+ if (result == NT_STATUS_OK)
DEBUG(5,("cmd_reg_abort_shutdown: query succeeded\n"));
else
DEBUG(5,("cmd_reg_abort_shutdown: query failed\n"));
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol)) !=
- NT_STATUS_NOPROBLEMO) {
+ NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
MAXIMUM_ALLOWED_ACCESS,
user_rid, &user_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_query_userinfo(cli, mem_ctx, &user_pol,
info_level, &user_ctr))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol)) !=
- NT_STATUS_NOPROBLEMO) {
+ NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_group(cli, mem_ctx, &domain_pol,
MAXIMUM_ALLOWED_ACCESS,
group_rid, &group_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_query_groupinfo(cli, mem_ctx, &group_pol,
info_level, &group_ctr))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol)) !=
- NT_STATUS_NOPROBLEMO) {
+ NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
MAXIMUM_ALLOWED_ACCESS,
user_rid, &user_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_query_usergroups(cli, mem_ctx, &user_pol,
&num_groups, &user_gids))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol)) !=
- NT_STATUS_NOPROBLEMO) {
+ NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_group(cli, mem_ctx, &domain_pol,
MAXIMUM_ALLOWED_ACCESS,
group_rid, &group_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_query_groupmem(cli, mem_ctx, &group_pol,
&num_members, &group_rids,
&group_attrs))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol)) !=
- NT_STATUS_NOPROBLEMO) {
+ NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol)) !=
- NT_STATUS_NOPROBLEMO) {
+ NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_alias(cli, mem_ctx, &domain_pol,
MAXIMUM_ALLOWED_ACCESS,
alias_rid, &alias_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_query_aliasmem(cli, mem_ctx, &alias_pol,
&num_members, &alias_sids))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_query_dom_info(cli, mem_ctx, &domain_pol,
switch_value, &ctr))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_create_dom_user(cli, mem_ctx, &domain_pol,
acct_name, acb_info, unknown,
&user_pol, &user_rid))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_lookup_names(cli, mem_ctx, &domain_pol,
flags, num_names, names,
&num_rids, &rids, &name_types))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_lookup_rids(cli, mem_ctx, &domain_pol,
flags, num_rids, rids,
&num_names, &names, &name_types))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
MAXIMUM_ALLOWED_ACCESS,
&domain_sid, &domain_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
flags, 1, &argv[1],
&num_rids, &user_rids,
&name_types))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
MAXIMUM_ALLOWED_ACCESS,
user_rids[0], &user_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
}
/* Delete user */
if ((result = cli_samr_delete_dom_user(cli, mem_ctx, &user_pol))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
int argc, char **argv)
{
printf ("(*) This command is not currently implemented.\n");
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/****************************************************************************
if (argc != 2) {
printf("Usage: %s <printername>\n", argv[0]);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (!cli)
result = cli_spoolss_open_printer_ex (cli, mem_ctx, printername, "",
MAXIMUM_ALLOWED_ACCESS, servername, user, &hnd);
- if (result == NT_STATUS_NOPROBLEMO) {
+ if (result == NT_STATUS_OK) {
printf ("Printer %s opened successfully\n", printername);
result = cli_spoolss_close_printer (cli, mem_ctx, &hnd);
- if (result != NT_STATUS_NOPROBLEMO) {
+ if (result != NT_STATUS_OK) {
printf ("Error closing printer handle! (%s)\n", get_nt_error_msg(result));
}
}
if (argc > 2)
{
printf("Usage: %s [level]\n", argv[0]);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (!(mem_ctx=talloc_init()))
result = cli_spoolss_enum_printers(cli, mem_ctx, PRINTER_ENUM_LOCAL,
info_level, &returned, &ctr);
- if (result == NT_STATUS_NOPROBLEMO)
+ if (result == NT_STATUS_OK)
{
if (!returned)
printf ("No Printers printers returned.\n");
if (argc > 2) {
printf("Usage: %s [level]\n", argv[0]);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (!(mem_ctx=talloc_init()))
result = cli_spoolss_enum_ports(cli, mem_ctx, info_level, &returned, &ctr);
- if (result == NT_STATUS_NOPROBLEMO) {
+ if (result == NT_STATUS_OK) {
int i;
for (i = 0; i < returned; i++) {
if (argc == 1 || argc > 3) {
printf("Usage: %s <printername> [level]\n", argv[0]);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (!(mem_ctx=talloc_init()))
/* get a printer handle */
if ((result = cli_spoolss_open_printer_ex(
cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS, servername,
- user, &pol)) != NT_STATUS_NOPROBLEMO) {
+ user, &pol)) != NT_STATUS_OK) {
goto done;
}
/* Get printer info */
if ((result = cli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto done;
}
if ((argc == 1) || (argc > 3))
{
printf("Usage: %s <printername> [level]\n", argv[0]);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (!(mem_ctx=talloc_init()))
/* Open a printer handle */
if ((result=cli_spoolss_open_printer_ex (cli, mem_ctx, printername, "",
- MAXIMUM_ALLOWED_ACCESS, servername, user, &pol)) != NT_STATUS_NOPROBLEMO)
+ MAXIMUM_ALLOWED_ACCESS, servername, user, &pol)) != NT_STATUS_OK)
{
printf ("Error opening printer handle for %s!\n", printername);
return result;
switch (result)
{
- case ERRsuccess:
+ case NT_STATUS_OK:
break;
case ERRunknownprinterdriver:
talloc_destroy(mem_ctx);
if (result==ERRunknownprinterdriver)
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
else
return result;
if (argc > 2)
{
printf("Usage: enumdrivers [level]\n");
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (!(mem_ctx=talloc_init()))
continue;
- if (result != NT_STATUS_NOPROBLEMO)
+ if (result != NT_STATUS_OK)
{
printf ("Error getting driver for environment [%s] - %s\n",
archi_table[i].long_archi, get_nt_error_msg(result));
talloc_destroy(mem_ctx);
if (result==ERRunknownprinterdriver)
- return ERRsuccess;
+ return NT_STATUS_OK;
else
return result;
if (argc > 2)
{
printf("Usage: %s [environment]\n", argv[0]);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
/* Initialise RPC connection */
/* Get the directory. Only use Info level 1 */
if ((result = cli_spoolss_getprinterdriverdir (cli, mem_ctx, 1, env, &ctr))
- != NT_STATUS_NOPROBLEMO)
+ != NT_STATUS_OK)
{
return result;
}
printf ("\t<Config File Name>:<Help File Name>:<Language Monitor Name>:\\\n");
printf ("\t<Default Data Type>:<Comma Separated list of Files>\n");
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (!(mem_ctx=talloc_init()))
ctr.info3 = &info3;
if ((result = cli_spoolss_addprinterdriver (cli, mem_ctx, level, &ctr))
- != NT_STATUS_NOPROBLEMO)
+ != NT_STATUS_OK)
{
return result;
}
if (argc != 5)
{
printf ("Usage: %s <name> <shared name> <driver> <port>\n", argv[0]);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (!(mem_ctx=talloc_init()))
ctr.printers_2 = &info2;
if ((result = cli_spoolss_addprinterex (cli, mem_ctx, level, &ctr))
- != NT_STATUS_NOPROBLEMO)
+ != NT_STATUS_OK)
{
cli_nt_session_close (cli);
return result;
if (argc != 3)
{
printf ("Usage: %s <printer> <driver>\n", argv[0]);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (!(mem_ctx=talloc_init()))
/* get a printer handle */
if ((result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
MAXIMUM_ALLOWED_ACCESS, servername, user, &pol))
- != NT_STATUS_NOPROBLEMO)
+ != NT_STATUS_OK)
{
goto done;
}
/* Get printer info */
ZERO_STRUCT (info2);
ctr.printers_2 = &info2;
- if ((result = cli_spoolss_getprinter(cli, mem_ctx, &pol, level, &ctr)) != NT_STATUS_NOPROBLEMO)
+ if ((result = cli_spoolss_getprinter(cli, mem_ctx, &pol, level, &ctr)) != NT_STATUS_OK)
{
printf ("Unable to retrieve printer information!\n");
goto done;
/* set the printer driver */
init_unistr(&ctr.printers_2->drivername, argv[2]);
- if ((result = cli_spoolss_setprinter(cli, mem_ctx, &pol, level, &ctr, 0)) != NT_STATUS_NOPROBLEMO)
+ if ((result = cli_spoolss_setprinter(cli, mem_ctx, &pol, level, &ctr, 0)) != NT_STATUS_OK)
{
printf ("SetPrinter call failed!\n");
goto done;;
if (argc != 2)
{
printf ("Usage: %s <driver>\n", argv[0]);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (!(mem_ctx=talloc_init()))
{
/* make the call to remove the driver */
if ((result = cli_spoolss_deleteprinterdriver(cli, mem_ctx,
- archi_table[i].long_archi, argv[1])) != NT_STATUS_NOPROBLEMO)
+ archi_table[i].long_archi, argv[1])) != NT_STATUS_OK)
{
printf ("Failed to remove driver %s for arch [%s] - error %s!\n",
argv[1], archi_table[i].long_archi, get_nt_error_msg(result));
cli_nt_session_close (cli);
talloc_destroy(mem_ctx);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if ((result = cli_srvsvc_net_srv_get_info(cli, mem_ctx, info_level,
&ctr)
- != NT_STATUS_NOPROBLEMO)) {
+ != NT_STATUS_OK)) {
goto done;
}
if ((result = cli_lsa_open_policy(cli, mem_ctx, True,
SEC_RIGHTS_MAXIMUM_ALLOWED,
- &pol) != NT_STATUS_NOPROBLEMO)) {
+ &pol) != NT_STATUS_OK)) {
goto error;
}
if ((result = cli_lsa_query_info_policy(cli, mem_ctx, &pol, info_class,
domain_name, &domain_sid))
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
goto error;
}
error:
fprintf(stderr, "could not obtain sid for domain %s\n", cli->domain);
- if (result != NT_STATUS_NOPROBLEMO) {
+ if (result != NT_STATUS_OK) {
fprintf(stderr, "error: %s\n", get_nt_error_msg(result));
}
{
if (argc > 2) {
printf("Usage: %s [debuglevel]\n", argv[0]);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
if (argc == 2) {
printf("debuglevel is %d\n", DEBUGLEVEL);
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
static uint32 cmd_quit(struct cli_state *cli, int argc, char **argv)
{
exit(0);
- return NT_STATUS_NOPROBLEMO; /* NOTREACHED */
+ return NT_STATUS_OK; /* NOTREACHED */
}
/* Build in rpcclient commands */
return NT_STATUS_LOGON_FAILURE;
}
- if (nt_status != NT_STATUS_NOPROBLEMO) {
+ if (nt_status != NT_STATUS_OK) {
nt_status = check_rhosts_security(user_info, server_info);
}
- if ((lp_security() == SEC_DOMAIN) && (nt_status != NT_STATUS_NOPROBLEMO)) {
+ if ((lp_security() == SEC_DOMAIN) && (nt_status != NT_STATUS_OK)) {
nt_status = check_domain_security(user_info, server_info);
}
- if ((lp_security() == SEC_SERVER) && (nt_status != NT_STATUS_NOPROBLEMO)) {
+ if ((lp_security() == SEC_SERVER) && (nt_status != NT_STATUS_OK)) {
nt_status = check_server_security(user_info, server_info);
}
smb_user_control(user_info->smb_username.str, nt_status);
}
- if (nt_status != NT_STATUS_NOPROBLEMO) {
+ if (nt_status != NT_STATUS_OK) {
if ((user_info->plaintext_password.len > 0)
&& (!lp_plaintext_to_smbpasswd())) {
nt_status = check_unix_security(user_info, server_info);
}
}
- if ((nt_status == NT_STATUS_NOPROBLEMO) && !done_pam) {
+ if ((nt_status == NT_STATUS_OK) && !done_pam) {
/* We might not be root if we are an RPC call */
become_root();
nt_status = smb_pam_accountcheck(user_info->smb_username.str);
unbecome_root();
}
- if (nt_status == NT_STATUS_NOPROBLEMO) {
+ if (nt_status == NT_STATUS_OK) {
DEBUG(5, ("check_password: Password for user %s suceeded\n", user_info->smb_username.str));
} else {
DEBUG(3, ("check_password: Password for user %s FAILED with error %s\n", user_info->smb_username.str, get_nt_error_msg(nt_status)));
/* The password could be either NTLM or plain LM. Try NTLM first, but fall-through as
required. */
- if (pass_check_smb(user, lp_workgroup(), NULL, 0, (unsigned char *)password, pwlen) == NT_STATUS_NOPROBLEMO) {
+ if (pass_check_smb(user, lp_workgroup(), NULL, 0, (unsigned char *)password, pwlen) == NT_STATUS_OK) {
return True;
}
- if (pass_check_smb(user, lp_workgroup(), (unsigned char *)password, pwlen, NULL, 0) == NT_STATUS_NOPROBLEMO) {
+ if (pass_check_smb(user, lp_workgroup(), (unsigned char *)password, pwlen, NULL, 0) == NT_STATUS_OK) {
return True;
}
become_root();
if (check_hosts_equiv(user_info->smb_username.str)) {
- nt_status = NT_STATUS_NOPROBLEMO;
+ nt_status = NT_STATUS_OK;
}
unbecome_root();
/* Make this cli_nt_error() when the conversion is in */
nt_status = NT_STATUS_LOGON_FAILURE;
} else {
- nt_status = NT_STATUS_NOPROBLEMO;
+ nt_status = NT_STATUS_OK;
}
/* if logged in as guest then reject */
if (lp_null_passwords())
{
DEBUG(3,("Account for user '%s' has no password and null passwords are allowed.\n", user_info->smb_username.str));
- return(NT_STATUS_NOPROBLEMO);
+ return(NT_STATUS_OK);
}
else
{
user_info->requested_domain.str,
(char *)server_info->session_key))
{
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
}
DEBUG(4,("smb_password_ok: NTLMv2 password check failed\n"));
nt_pw, user_info->chal,
server_info->session_key)) {
DEBUG(4,("smb_password_ok: NT MD4 password check succeeded\n"));
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
} else {
DEBUG(4,("smb_password_ok: NT MD4 password check failed\n"));
return NT_STATUS_WRONG_PASSWORD;
lm_pw, user_info->chal,
server_info->session_key)) {
DEBUG(4,("smb_password_ok: LM password check succeeded\n"));
- return NT_STATUS_NOPROBLEMO;
+ return NT_STATUS_OK;
} else {
DEBUG(4,("smb_password_ok: LM password check failed\n"));
return NT_STATUS_WRONG_PASSWORD;
nt_status = (pass_check(user_info->smb_username.str, user_info->plaintext_password.str,
user_info->plaintext_password.len,
lp_update_encrypted() ? update_smbpassword_file : NULL)
- ? NT_STATUS_NOPROBLEMO : NT_STATUS_LOGON_FAILURE);
+ ? NT_STATUS_OK : NT_STATUS_LOGON_FAILURE);
unbecome_root();
return nt_status;
{
struct passwd *pwd=NULL;
- if(nt_status == NT_STATUS_NOPROBLEMO) {
+ if(nt_status == NT_STATUS_OK) {
/*
* User validated ok against Domain controller.
* If the admin wants us to try and create a UNIX
}
}
- return error_packet(outbuf,NT_STATUS_OK,eclass,ecode,line);
+ return error_packet(outbuf,NT_STATUS(0),eclass,ecode,line);
}
}
SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2)&~FLAGS2_32_BIT_ERROR_CODES);
- SVAL(outbuf,smb_rcls) = eclass;
+ SSVAL(outbuf,smb_rcls,eclass);
SSVAL(outbuf,smb_err,ecode);
DEBUG(3,("error packet at line %d cmd=%d (%s) eclass=%d ecode=%d\n",
do some basic sainity checks on the share.
This function modifies dev, ecode.
****************************************************************************/
-static BOOL share_sanity_checks(int snum, char* service, char *dev, int *ecode)
+static NTSTATUS share_sanity_checks(int snum, char* service, char *dev)
{
if (!lp_snum_ok(snum) ||
!check_access(smbd_server_fd(),
lp_hostsallow(snum), lp_hostsdeny(snum))) {
- *ecode = ERRaccess;
- return False;
+ return NT_STATUS_ACCESS_DENIED;
}
/* you can only connect to the IPC$ service as an ipc device */
strupper(dev);
if (!lp_print_ok(snum) && (strncmp(dev,"LPT",3) == 0)) {
DEBUG(1,("Attempt to connect to non-printer as a printer\n"));
- *ecode = ERRinvdevice;
- return False;
+ return NT_STATUS_BAD_DEVICE_TYPE;
}
/* Behave as a printer if we are supposed to */
if (lp_print_ok(snum) && (strcmp(dev, "A:") == 0)) {
pstrcpy(dev, "LPT1:");
}
- return True;
+
+ return NT_STATUS_OK;
}
/****************************************************************************
make a connection to a service
****************************************************************************/
-connection_struct *make_connection(char *service,char *user,char *password, int pwlen, char *dev,uint16 vuid, int *ecode)
+connection_struct *make_connection(char *service,char *user,char *password,
+ int pwlen, char *dev,uint16 vuid, NTSTATUS *status)
{
int snum;
struct passwd *pass = NULL;
if (snum < 0) {
if (strequal(service,"IPC$") || strequal(service,"ADMIN$")) {
DEBUG(3,("refusing IPC connection\n"));
- *ecode = ERRnoipc;
+ *status = NT_STATUS_ACCESS_DENIED;
return NULL;
}
DEBUG(0,("%s (%s) couldn't find service %s\n",
remote_machine, client_addr(), service));
- *ecode = ERRnosuchshare;
+ *status = NT_STATUS_BAD_NETWORK_PATH;
return NULL;
}
fstring dos_username;
fstrcpy(dos_username, user);
return(make_connection(dos_username,user,password,
- pwlen,dev,vuid,ecode));
+ pwlen,dev,vuid,status));
}
if(lp_security() != SEC_SHARE) {
fstring dos_username;
fstrcpy(user,validated_username(vuid));
fstrcpy(dos_username, user);
- return(make_connection(dos_username,user,password,pwlen,dev,vuid,ecode));
+ return(make_connection(dos_username,user,password,pwlen,dev,vuid,status));
}
} else {
/* Security = share. Try with current_user_info.smb_name
fstring dos_username;
fstrcpy(user,current_user_info.smb_name);
fstrcpy(dos_username, user);
- return(make_connection(dos_username,user,password,pwlen,dev,vuid,ecode));
+ return(make_connection(dos_username,user,password,pwlen,dev,vuid,status));
}
}
}
- if (!share_sanity_checks(snum, service, dev, ecode)) {
+ if (NT_STATUS_IS_ERR(share_sanity_checks(snum, service, dev))) {
return NULL;
}
/* shall we let them in? */
if (!authorise_login(snum,user,password,pwlen,&guest,&force,vuid)) {
DEBUG( 2, ( "Invalid username/password for %s [%s]\n", service, user ) );
- *ecode = ERRbadpw;
+ *status = NT_STATUS_WRONG_PASSWORD;
return NULL;
}
conn = conn_new();
if (!conn) {
DEBUG(0,("Couldn't find free connection.\n"));
- *ecode = ERRnoresource;
+ *status = NT_STATUS_INSUFFICIENT_RESOURCES;
return NULL;
}
if (pass == NULL) {
DEBUG(0,( "Couldn't find account %s\n",user));
- *ecode = ERRbaduid;
+ *status = NT_STATUS_NO_SUCH_USER;
conn_free(conn);
return NULL;
}
if (!can_write) {
if (!share_access_check(conn, snum, vuid, FILE_READ_DATA)) {
/* No access, read or write. */
- *ecode = ERRaccess;
+ *status = NT_STATUS_ACCESS_DENIED;
DEBUG(0,( "make_connection: connection to %s denied due to security descriptor.\n",
service ));
conn_free(conn);
lp_max_connections(SNUM(conn)),
False)) {
DEBUG(1,("too many connections - rejected\n"));
- *ecode = ERRnoresource;
+ *status = NT_STATUS_INSUFFICIENT_RESOURCES;
conn_free(conn);
return NULL;
}
lp_servicename(SNUM(conn)),
lp_max_connections(SNUM(conn)));
conn_free(conn);
- *ecode = ERRsrverror;
+ *status = NT_STATUS_UNSUCCESSFUL;
return NULL;
}
}
lp_servicename(SNUM(conn)),
lp_max_connections(SNUM(conn)));
conn_free(conn);
- *ecode = ERRbadpw;
+ *status = NT_STATUS_WRONG_PASSWORD;
return NULL;
}
lp_servicename(SNUM(conn)),
lp_max_connections(SNUM(conn)));
conn_free(conn);
- *ecode = ERRnosuchshare;
+ *status = NT_STATUS_BAD_NETWORK_NAME;
return NULL;
}
DEBUG(1,("preexec gave %d - failing connection\n", ret));
yield_connection(conn, lp_servicename(SNUM(conn)), lp_max_connections(SNUM(conn)));
conn_free(conn);
- *ecode = ERRsrverror;
+ *status = NT_STATUS_UNSUCCESSFUL;
return NULL;
}
}
/****************************************************************************
look for a partial hit
****************************************************************************/
-static void trans2_check_hit(char *format, int op, int level, uint32 status)
+static void trans2_check_hit(char *format, int op, int level, NTSTATUS status)
{
switch (status) {
case NT_STATUS_INVALID_LEVEL:
if (ret == 0) break;
*data_len += 2;
}
- if (ret == NT_STATUS_NOPROBLEMO) {
+ if (ret == NT_STATUS_OK) {
printf("found %s level=%d data_len=%d rparam_len=%d rdata_len=%d\n",
format, level, *data_len, *rparam_len, *rdata_len);
} else {
int param_len = 0;
int rparam_len, rdata_len;
pstring param, data;
- uint32 status;
+ NTSTATUS status;
memset(data, 0, sizeof(data));
data_len = 4;
/****************************************************************************
look for a partial hit
****************************************************************************/
-static void nttrans_check_hit(char *format, int op, int level, uint32 status)
+static void nttrans_check_hit(char *format, int op, int level, NTSTATUS status)
{
switch (status) {
case NT_STATUS_INVALID_LEVEL:
if (ret == 0) break;
*data_len += 2;
}
- if (ret == NT_STATUS_NOPROBLEMO) {
+ if (ret == NT_STATUS_OK) {
printf("found %s level=%d data_len=%d rparam_len=%d rdata_len=%d\n",
format, level, *data_len, *rparam_len, *rdata_len);
} else {
int param_len = 0;
int rparam_len, rdata_len;
pstring param, data;
- uint32 status;
+ NTSTATUS status;
memset(data, 0, sizeof(data));
data_len = 4;
}
} else {
- uint32 status;
+ NTSTATUS status;
/* Check NT error */
if (cli_lsa_open_policy(&lsa_cli, lsa_cli.mem_ctx, True,
GENERIC_EXECUTE_ACCESS, &pol)
- != NT_STATUS_NOPROBLEMO) {
+ != NT_STATUS_OK) {
return False;
}
if (!cacls_open_policy_hnd() ||
cli_lsa_lookup_sids(&lsa_cli, lsa_cli.mem_ctx, &pol, 1, sid, &names, &types,
- &num_names) != NT_STATUS_NOPROBLEMO ||
+ &num_names) != NT_STATUS_OK ||
!names || !names[0]) {
return;
}
if (!cacls_open_policy_hnd() ||
cli_lsa_lookup_names(&lsa_cli, lsa_cli.mem_ctx, &pol, 1, &str, &sids, &types,
- &num_sids) != NT_STATUS_NOPROBLEMO) {
+ &num_sids) != NT_STATUS_OK) {
result = False;
goto done;
}
/* Macro for checking RPC error codes to make things more readable */
#define CHECK_RPC_ERR(rpc, msg) \
- if ((result = rpc) != NT_STATUS_NOPROBLEMO) { \
+ if ((result = rpc) != NT_STATUS_OK) { \
DEBUG(0, (msg ": %s\n", get_nt_error_msg(result))); \
goto done; \
}
#define CHECK_RPC_ERR_DEBUG(rpc, debug_args) \
- if ((result = rpc) != NT_STATUS_NOPROBLEMO) { \
+ if ((result = rpc) != NT_STATUS_OK) { \
DEBUG(0, debug_args); \
goto done; \
}
("could not re-open existing user %s: %s\n",
acct_name, get_nt_error_msg(result)));
- } else if (result != NT_STATUS_NOPROBLEMO) {
+ } else if (result != NT_STATUS_OK) {
DEBUG(0, ("error creating domain user: %s\n",
get_nt_error_msg(result)));
goto done;
git.samba.org / samba.git / commitdiff