int cli_errno(struct cli_state *cli) { NTSTATUS status; if (cli_is_nt_error(cli)) { status = cli_nt_error(cli); return map_errno_from_nt_status(status); } if (cli_is_dos_error(cli)) { uint8 eclass; uint32 ecode; cli_dos_error(cli, &eclass, &ecode); status = dos_to_ntstatus(eclass, ecode); return map_errno_from_nt_status(status); } /* * Yuck! A special case for this Vista error. Since its high-order * byte isn't 0xc0, it doesn't match cli_is_nt_error() above. */ status = cli_nt_error(cli); if (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INACCESSIBLE_SYSTEM_SHORTCUT)) { return EACCES; } /* for other cases */ return EINVAL; }
int error_packet(char *outbuf, uint8 eclass, uint32 ecode, NTSTATUS ntstatus, int line, const char *file) { int outsize = set_message(outbuf,0,0,True); BOOL force_nt_status = False; BOOL force_dos_status = False; if (override_ERR_class != SMB_SUCCESS || !NT_STATUS_IS_OK(override_ERR_ntstatus)) { eclass = override_ERR_class; ecode = override_ERR_code; ntstatus = override_ERR_ntstatus; override_ERR_class = SMB_SUCCESS; override_ERR_code = 0; override_ERR_ntstatus = NT_STATUS_OK; } if (eclass == (uint8)-1) { force_nt_status = True; } else if (NT_STATUS_IS_INVALID(ntstatus)) { force_dos_status = True; } if (force_nt_status || (!force_dos_status && lp_nt_status_support() && (global_client_caps & CAP_STATUS32))) { /* We're returning an NT error. */ if (NT_STATUS_V(ntstatus) == 0 && eclass) { ntstatus = dos_to_ntstatus(eclass, ecode); } SIVAL(outbuf,smb_rcls,NT_STATUS_V(ntstatus)); SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2)|FLAGS2_32_BIT_ERROR_CODES); DEBUG(3,("error packet at %s(%d) cmd=%d (%s) %s\n", file, line, (int)CVAL(outbuf,smb_com), smb_fn_name(CVAL(outbuf,smb_com)), nt_errstr(ntstatus))); } else { /* We're returning a DOS error only. */ if (eclass == 0 && NT_STATUS_V(ntstatus)) { ntstatus_to_dos(ntstatus, &eclass, &ecode); } SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2)&~FLAGS2_32_BIT_ERROR_CODES); SSVAL(outbuf,smb_rcls,eclass); SSVAL(outbuf,smb_err,ecode); DEBUG(3,("error packet at %s(%d) cmd=%d (%s) eclass=%d ecode=%d\n", file, line, (int)CVAL(outbuf,smb_com), smb_fn_name(CVAL(outbuf,smb_com)), eclass, ecode)); } return outsize; }
NTSTATUS cli_trans(TALLOC_CTX *mem_ctx, struct cli_state *cli, uint8_t trans_cmd, const char *pipe_name, uint16_t fid, uint16_t function, int flags, uint16_t *setup, uint8_t num_setup, uint8_t max_setup, uint8_t *param, uint32_t num_param, uint32_t max_param, uint8_t *data, uint32_t num_data, uint32_t max_data, uint16_t *recv_flags2, uint16_t **rsetup, uint8_t min_rsetup, uint8_t *num_rsetup, uint8_t **rparam, uint32_t min_rparam, uint32_t *num_rparam, uint8_t **rdata, uint32_t min_rdata, uint32_t *num_rdata) { NTSTATUS status; uint8_t additional_flags = 0; uint8_t clear_flags = 0; uint16_t additional_flags2 = 0; uint16_t clear_flags2 = 0; status = smb1cli_trans(mem_ctx, cli->conn, trans_cmd, additional_flags, clear_flags, additional_flags2, clear_flags2, cli->timeout, cli->smb1.pid, cli->smb1.tcon, cli->smb1.session, pipe_name, fid, function, flags, setup, num_setup, max_setup, param, num_param, max_param, data, num_data, max_data, recv_flags2, rsetup, min_rsetup, num_rsetup, rparam, min_rparam, num_rparam, rdata, min_rdata, num_rdata); cli->raw_status = status; if (NT_STATUS_IS_DOS(status) && cli->map_dos_errors) { uint8_t eclass = NT_STATUS_DOS_CLASS(status); uint16_t ecode = NT_STATUS_DOS_CODE(status); /* * TODO: is it really a good idea to do a mapping here? * * The old cli_pull_error() also does it, so I do not change * the behavior yet. */ status = dos_to_ntstatus(eclass, ecode); } return status; }
static int truncate_unless_locked(struct connection_struct *conn, files_struct *fsp) { SMB_BIG_UINT mask = (SMB_BIG_UINT)-1; if (is_locked(fsp,fsp->conn,mask,0,WRITE_LOCK,True)){ errno = EACCES; unix_ERR_class = ERRDOS; unix_ERR_code = ERRlock; unix_ERR_ntstatus = dos_to_ntstatus(ERRDOS, ERRlock); return -1; } else { return conn->vfs_ops.ftruncate(fsp,fsp->fd,0); } }
NTSTATUS cli_get_nt_error(struct cli_state *cli) { if (cli_is_nt_error(cli)) { return cli_nt_error(cli); } else if (cli_is_dos_error(cli)) { uint32 ecode; uint8 eclass; cli_dos_error(cli, &eclass, &ecode); return dos_to_ntstatus(eclass, ecode); } else { /* Something went wrong, we don't know what. */ return NT_STATUS_UNSUCCESSFUL; } }
NTSTATUS cli_nt_error(struct cli_state *cli) { /* Deal with socket errors first. */ if (!cli_state_is_connected(cli)) { return NT_STATUS_CONNECTION_DISCONNECTED; } if (NT_STATUS_IS_DOS(cli->raw_status)) { int e_class = NT_STATUS_DOS_CLASS(cli->raw_status); int code = NT_STATUS_DOS_CODE(cli->raw_status); return dos_to_ntstatus(e_class, code); } return cli->raw_status; }
NTSTATUS cli_nt_error(struct cli_state *cli) { int flgs2 = SVAL(cli->inbuf,smb_flg2); /* Deal with socket errors first. */ if (cli->fd == -1 && cli->smb_rw_error) { return cli_smb_rw_error_to_ntstatus(cli); } if (!(flgs2 & FLAGS2_32_BIT_ERROR_CODES)) { int e_class = CVAL(cli->inbuf,smb_rcls); int code = SVAL(cli->inbuf,smb_err); return dos_to_ntstatus(e_class, code); } return NT_STATUS(IVAL(cli->inbuf,smb_rcls)); }
void error_packet_set(char *outbuf, uint8 eclass, uint32 ecode, NTSTATUS ntstatus, int line, const char *file) { BOOL force_nt_status = False; BOOL force_dos_status = False; if (eclass == (uint8)-1) { force_nt_status = True; } else if (NT_STATUS_IS_DOS(ntstatus)) { force_dos_status = True; } if (force_nt_status || (!force_dos_status && lp_nt_status_support() && (global_client_caps & CAP_STATUS32))) { /* We're returning an NT error. */ if (NT_STATUS_V(ntstatus) == 0 && eclass) { ntstatus = dos_to_ntstatus(eclass, ecode); } SIVAL(outbuf,smb_rcls,NT_STATUS_V(ntstatus)); SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2)|FLAGS2_32_BIT_ERROR_CODES); DEBUG(3,("error packet at %s(%d) cmd=%d (%s) %s\n", file, line, (int)CVAL(outbuf,smb_com), smb_fn_name(CVAL(outbuf,smb_com)), nt_errstr(ntstatus))); } else { /* We're returning a DOS error only. */ if (NT_STATUS_IS_DOS(ntstatus)) { eclass = NT_STATUS_DOS_CLASS(ntstatus); ecode = NT_STATUS_DOS_CODE(ntstatus); } else if (eclass == 0 && NT_STATUS_V(ntstatus)) { ntstatus_to_dos(ntstatus, &eclass, &ecode); } SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2)&~FLAGS2_32_BIT_ERROR_CODES); SSVAL(outbuf,smb_rcls,eclass); SSVAL(outbuf,smb_err,ecode); DEBUG(3,("error packet at %s(%d) cmd=%d (%s) eclass=%d ecode=%d\n", file, line, (int)CVAL(outbuf,smb_com), smb_fn_name(CVAL(outbuf,smb_com)), eclass, ecode)); } }
NTSTATUS cli_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx, uint16_t *recv_flags2, uint16_t **setup, uint8_t min_setup, uint8_t *num_setup, uint8_t **param, uint32_t min_param, uint32_t *num_param, uint8_t **data, uint32_t min_data, uint32_t *num_data) { NTSTATUS status; void *parent = talloc_parent(req); struct cli_trans_state *state = talloc_get_type(parent, struct cli_trans_state); bool map_dos_errors = true; status = smb1cli_trans_recv(req, mem_ctx, recv_flags2, setup, min_setup, num_setup, param, min_param, num_param, data, min_data, num_data); if (state) { map_dos_errors = state->cli->map_dos_errors; state->cli->raw_status = status; talloc_free(state->ptr); state = NULL; } if (NT_STATUS_IS_DOS(status) && map_dos_errors) { uint8_t eclass = NT_STATUS_DOS_CLASS(status); uint16_t ecode = NT_STATUS_DOS_CODE(status); /* * TODO: is it really a good idea to do a mapping here? * * The old cli_pull_error() also does it, so I do not change * the behavior yet. */ status = dos_to_ntstatus(eclass, ecode); } return status; }