*/
#include "includes.h"
+#include "printing.h"
#include "smbd/globals.h"
+#include "../librpc/gen_ndr/cli_spoolss.h"
+#include "rpc_client/cli_spoolss.h"
+#include "rpc_client/init_spoolss.h"
/****************************************************************************
Ensure we check the path in *exactly* the same way as W2K for a findfirst/findnext
bool check_fsp_open(connection_struct *conn, struct smb_request *req,
files_struct *fsp)
{
- if (!(fsp) || !(conn)) {
+ if ((fsp == NULL) || (conn == NULL)) {
reply_nterror(req, NT_STATUS_INVALID_HANDLE);
return False;
}
- if (((conn) != (fsp)->conn) || req->vuid != (fsp)->vuid) {
+ if ((conn != fsp->conn) || (req->vuid != fsp->vuid)) {
reply_nterror(req, NT_STATUS_INVALID_HANDLE);
return False;
}
if (!check_fsp_open(conn, req, fsp)) {
return False;
}
- if ((fsp)->is_directory) {
+ if (fsp->is_directory) {
reply_nterror(req, NT_STATUS_INVALID_DEVICE_REQUEST);
return False;
}
- if ((fsp)->fh->fd == -1) {
+ if (fsp->fh->fd == -1) {
reply_nterror(req, NT_STATUS_ACCESS_DENIED);
return False;
}
- (fsp)->num_smb_operations++;
+ fsp->num_smb_operations++;
return True;
}
return true;
}
-/****************************************************************************
- Check if we have a correct fsp. Replacement for the FSP_BELONGS_CONN macro
-****************************************************************************/
-
-bool fsp_belongs_conn(connection_struct *conn, struct smb_request *req,
- files_struct *fsp)
-{
- if ((fsp) && (conn) && ((conn)==(fsp)->conn)
- && (req->vuid == (fsp)->vuid)) {
- return True;
- }
-
- reply_nterror(req, NT_STATUS_INVALID_HANDLE);
- return False;
-}
-
-static bool netbios_session_retarget(const char *name, int name_type)
+static bool netbios_session_retarget(struct smbd_server_connection *sconn,
+ const char *name, int name_type)
{
char *trim_name;
char *trim_name_type;
bool ret = false;
uint8_t outbuf[10];
- if (get_socket_port(smbd_server_fd()) != 139) {
+ if (get_socket_port(sconn->sock) != 139) {
return false;
}
*(uint32_t *)(outbuf+4) = in_addr->sin_addr.s_addr;
*(uint16_t *)(outbuf+8) = htons(retarget_port);
- if (!srv_send_smb(smbd_server_fd(), (char *)outbuf, false, 0, false,
+ if (!srv_send_smb(sconn->sock, (char *)outbuf, false, 0, false,
NULL)) {
exit_server_cleanly("netbios_session_regarget: srv_send_smb "
"failed.");
Reply to a (netbios-level) special message.
****************************************************************************/
-void reply_special(char *inbuf)
+void reply_special(struct smbd_server_connection *sconn, char *inbuf)
{
int msg_type = CVAL(inbuf,0);
int msg_flags = CVAL(inbuf,1);
fstring name1,name2;
char name_type1, name_type2;
- struct smbd_server_connection *sconn = smbd_server_conn;
/*
* We only really use 4 bytes of the outbuf, but for the smb_setlen
DEBUG(2,("netbios connect: name1=%s0x%x name2=%s0x%x\n",
name1, name_type1, name2, name_type2));
- if (netbios_session_retarget(name1, name_type1)) {
+ if (netbios_session_retarget(sconn, name1, name_type1)) {
exit_server_cleanly("retargeted client");
}
add_session_user(sconn, get_remote_machine_name());
}
- reload_services(True);
+ reload_services(sconn->msg_ctx, True);
reopen_logs();
sconn->nbt.got_session = true;
DEBUG(5,("init msg_type=0x%x msg_flags=0x%x\n",
msg_type, msg_flags));
- srv_send_smb(smbd_server_fd(), outbuf, false, 0, false, NULL);
+ srv_send_smb(sconn->sock, outbuf, false, 0, false, NULL);
return;
}
const char *p;
DATA_BLOB password_blob;
TALLOC_CTX *ctx = talloc_tos();
- struct smbd_server_connection *sconn = smbd_server_conn;
+ struct smbd_server_connection *sconn = req->sconn;
START_PROFILE(SMBtcon);
char *path = NULL;
const char *p, *q;
uint16 tcon_flags;
- struct smbd_server_connection *sconn = smbd_server_conn;
+ struct smbd_server_connection *sconn = req->sconn;
START_PROFILE(SMBtconX);
TALLOC_CTX *ctx = talloc_tos();
bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
struct dptr_struct *dirptr = NULL;
- struct smbd_server_connection *sconn = smbd_server_conn;
+ struct smbd_server_connection *sconn = req->sconn;
START_PROFILE(SMBsearch);
NTSTATUS err;
bool path_contains_wcard = False;
TALLOC_CTX *ctx = talloc_tos();
- struct smbd_server_connection *sconn = smbd_server_conn;
+ struct smbd_server_connection *sconn = req->sconn;
START_PROFILE(SMBfclose);
SSVAL(req->outbuf,smb_vwv11,smb_action);
if (open_flags & EXTENDED_RESPONSE_REQUIRED) {
- SIVAL(req->outbuf, smb_vwv15, STD_RIGHT_ALL_ACCESS);
+ SIVAL(req->outbuf, smb_vwv15, SEC_STD_ALL);
}
chain_reply(req);
void reply_ulogoffX(struct smb_request *req)
{
- struct smbd_server_connection *sconn = smbd_server_conn;
+ struct smbd_server_connection *sconn = req->sconn;
user_struct *vuser;
START_PROFILE(SMBulogoffX);
memset(buf + ret, '\0', cur_read - ret);
}
- if (write_data(smbd_server_fd(),buf,cur_read) != cur_read) {
+ if (write_data(fsp->conn->sconn->sock, buf, cur_read)
+ != cur_read) {
SAFE_FREE(buf);
return -1;
}
size_t to_write;
to_write = MIN(SHORT_SEND_BUFSIZE, smb_maxcnt - nread);
- if (write_data(smbd_server_fd(), buf, to_write) != to_write) {
+ if (write_data(fsp->conn->sconn->sock, buf, to_write)
+ != to_write) {
exit_server_cleanly("sendfile_short_send: "
"write_data failed");
}
Return a readbraw error (4 bytes of zero).
****************************************************************************/
-static void reply_readbraw_error(void)
+static void reply_readbraw_error(struct smbd_server_connection *sconn)
{
char header[4];
SIVAL(header,0,0);
- smbd_lock_socket(smbd_server_conn);
- if (write_data(smbd_server_fd(),header,4) != 4) {
+ smbd_lock_socket(sconn);
+ if (write_data(sconn->sock,header,4) != 4) {
fail_readraw();
}
- smbd_unlock_socket(smbd_server_conn);
+ smbd_unlock_socket(sconn);
}
/****************************************************************************
size_t nread,
ssize_t mincount)
{
+ struct smbd_server_connection *sconn = req->sconn;
char *outbuf = NULL;
ssize_t ret=0;
if ( !req_is_in_chain(req) && (nread > 0) && (fsp->base_fsp == NULL) &&
(fsp->wcp == NULL) &&
- lp_use_sendfile(SNUM(conn), smbd_server_conn->smb1.signing_state) ) {
+ lp_use_sendfile(SNUM(conn), req->sconn->smb1.signing_state) ) {
ssize_t sendfile_read = -1;
char header[4];
DATA_BLOB header_blob;
_smb_setlen(header,nread);
header_blob = data_blob_const(header, 4);
- if ((sendfile_read = SMB_VFS_SENDFILE(smbd_server_fd(), fsp,
- &header_blob, startpos, nread)) == -1) {
+ sendfile_read = SMB_VFS_SENDFILE(sconn->sock, fsp,
+ &header_blob, startpos,
+ nread);
+ if (sendfile_read == -1) {
/* Returning ENOSYS means no data at all was sent.
* Do this as a normal read. */
if (errno == ENOSYS) {
if (!outbuf) {
DEBUG(0,("send_file_readbraw: TALLOC_ARRAY failed for size %u.\n",
(unsigned)(nread+4)));
- reply_readbraw_error();
+ reply_readbraw_error(sconn);
return;
}
}
_smb_setlen(outbuf,ret);
- if (write_data(smbd_server_fd(),outbuf,4+ret) != 4+ret)
+ if (write_data(sconn->sock, outbuf, 4+ret) != 4+ret)
fail_readraw();
TALLOC_FREE(outbuf);
void reply_readbraw(struct smb_request *req)
{
connection_struct *conn = req->conn;
+ struct smbd_server_connection *sconn = req->sconn;
ssize_t maxcount,mincount;
size_t nread = 0;
SMB_OFF_T startpos;
START_PROFILE(SMBreadbraw);
- if (srv_is_signing_active(smbd_server_conn) ||
+ if (srv_is_signing_active(sconn) ||
is_encrypted_packet(req->inbuf)) {
exit_server_cleanly("reply_readbraw: SMB signing/sealing is active - "
"raw reads/writes are disallowed.");
}
if (req->wct < 8) {
- reply_readbraw_error();
+ reply_readbraw_error(sconn);
END_PROFILE(SMBreadbraw);
return;
}
- if (smbd_server_conn->smb1.echo_handler.trusted_fde) {
+ if (sconn->smb1.echo_handler.trusted_fde) {
DEBUG(2,("SMBreadbraw rejected with NOT_SUPPORTED because of "
"'async smb echo handler = yes'\n"));
- reply_readbraw_error();
+ reply_readbraw_error(sconn);
END_PROFILE(SMBreadbraw);
return;
}
DEBUG(3,("reply_readbraw: fnum %d not valid "
"- cache prime?\n",
(int)SVAL(req->vwv+0, 0)));
- reply_readbraw_error();
+ reply_readbraw_error(sconn);
END_PROFILE(SMBreadbraw);
return;
}
(fsp->access_mask & FILE_EXECUTE)))) {
DEBUG(3,("reply_readbraw: fnum %d not readable.\n",
(int)SVAL(req->vwv+0, 0)));
- reply_readbraw_error();
+ reply_readbraw_error(sconn);
END_PROFILE(SMBreadbraw);
return;
}
DEBUG(0,("reply_readbraw: negative 64 bit "
"readraw offset (%.0f) !\n",
(double)startpos ));
- reply_readbraw_error();
+ reply_readbraw_error(sconn);
END_PROFILE(SMBreadbraw);
return;
}
&lock);
if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) {
- reply_readbraw_error();
+ reply_readbraw_error(sconn);
END_PROFILE(SMBreadbraw);
return;
}
files_struct *fsp;
struct byte_range_lock *br_lck = NULL;
char *p = NULL;
- struct smbd_server_connection *sconn = smbd_server_conn;
+ struct smbd_server_connection *sconn = req->sconn;
START_PROFILE(SMBlockread);
* Note that the requested lock size is unaffected by max_recv.
*/
- br_lck = do_lock(smbd_messaging_context(),
+ br_lck = do_lock(req->sconn->msg_ctx,
fsp,
(uint64_t)req->smbpid,
(uint64_t)numtoread,
int outsize = 0;
files_struct *fsp;
struct lock_struct lock;
- struct smbd_server_connection *sconn = smbd_server_conn;
+ struct smbd_server_connection *sconn = req->sconn;
START_PROFILE(SMBread);
if (!req_is_in_chain(req) &&
!is_encrypted_packet(req->inbuf) && (fsp->base_fsp == NULL) &&
(fsp->wcp == NULL) &&
- lp_use_sendfile(SNUM(conn), smbd_server_conn->smb1.signing_state) ) {
+ lp_use_sendfile(SNUM(conn), req->sconn->smb1.signing_state) ) {
uint8 headerbuf[smb_size + 12 * 2];
DATA_BLOB header;
construct_reply_common_req(req, (char *)headerbuf);
setup_readX_header(req, (char *)headerbuf, smb_maxcnt);
- if ((nread = SMB_VFS_SENDFILE(smbd_server_fd(), fsp, &header, startpos, smb_maxcnt)) == -1) {
+ nread = SMB_VFS_SENDFILE(req->sconn->sock, fsp, &header,
+ startpos, smb_maxcnt);
+ if (nread == -1) {
/* Returning ENOSYS means no data at all was sent.
Do this as a normal read. */
if (errno == ENOSYS) {
setup_readX_header(req, (char *)headerbuf, smb_maxcnt);
/* Send out the header. */
- if (write_data(smbd_server_fd(), (char *)headerbuf,
+ if (write_data(req->sconn->sock, (char *)headerbuf,
sizeof(headerbuf)) != sizeof(headerbuf)) {
DEBUG(0,("send_file_readX: write_data failed for file "
"%s (%s). Terminating\n", fsp_str_dbg(fsp),
return;
}
/* We currently don't do this on signed or sealed data. */
- if (srv_is_signing_active(smbd_server_conn) ||
+ if (srv_is_signing_active(req->sconn) ||
is_encrypted_packet(req->inbuf)) {
reply_nterror(req, NT_STATUS_NOT_SUPPORTED);
END_PROFILE(SMBreadX);
/* NT_STATUS_RETRY - fall back to sync read. */
}
- smbd_lock_socket(smbd_server_conn);
+ smbd_lock_socket(req->sconn);
send_file_readX(conn, req, fsp, startpos, smb_maxcnt);
- smbd_unlock_socket(smbd_server_conn);
+ smbd_unlock_socket(req->sconn);
out:
END_PROFILE(SMBreadX);
*/
SCVAL(req->inbuf,smb_com,SMBwritec);
- if (srv_is_signing_active(smbd_server_conn)) {
+ if (srv_is_signing_active(req->sconn)) {
END_PROFILE(SMBwritebraw);
exit_server_cleanly("reply_writebraw: SMB signing is active - "
"raw reads/writes are disallowed.");
return;
}
- if (smbd_server_conn->smb1.echo_handler.trusted_fde) {
+ if (req->sconn->smb1.echo_handler.trusted_fde) {
DEBUG(2,("SMBwritebraw rejected with NOT_SUPPORTED because of "
"'async smb echo handler = yes'\n"));
reply_nterror(req, NT_STATUS_NOT_SUPPORTED);
SCVAL(buf,smb_com,SMBwritebraw);
SSVALS(buf,smb_vwv0,0xFFFF);
show_msg(buf);
- if (!srv_send_smb(smbd_server_fd(),
+ if (!srv_send_smb(req->sconn->sock,
buf,
false, 0, /* no signing */
IS_CONN_ENCRYPTED(conn),
}
/* Now read the raw data into the buffer and write it */
- status = read_smb_length(smbd_server_fd(), buf, SMB_SECONDARY_WAIT,
+ status = read_smb_length(req->sconn->sock, buf, SMB_SECONDARY_WAIT,
&numtowrite);
if (!NT_STATUS_IS_OK(status)) {
exit_server_cleanly("secondary writebraw failed");
(int)tcount,(int)nwritten,(int)numtowrite));
}
- status = read_data(smbd_server_fd(), buf+4, numtowrite);
+ status = read_data(req->sconn->sock, buf+4, numtowrite);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("reply_writebraw: Oversize secondary write "
* sending a SMBkeepalive. Thanks to DaveCB at Sun for this.
* JRA.
*/
- if (!send_keepalive(smbd_server_fd())) {
+ if (!send_keepalive(req->sconn->sock)) {
exit_server_cleanly("reply_writebraw: send of "
"keepalive failed");
}
}
if (numtowrite && !fsp->print_file) {
- status = do_unlock(smbd_messaging_context(),
+ status = do_unlock(req->sconn->msg_ctx,
fsp,
(uint64_t)req->smbpid,
(uint64_t)numtowrite,
(2*14) + /* word count (including bcc) */ \
1 /* pad byte */)
-bool is_valid_writeX_buffer(const uint8_t *inbuf)
+bool is_valid_writeX_buffer(struct smbd_server_connection *sconn,
+ const uint8_t *inbuf)
{
size_t numtowrite;
connection_struct *conn = NULL;
unsigned int doff = 0;
size_t len = smb_len_large(inbuf);
- struct smbd_server_connection *sconn = smbd_server_conn;
if (is_encrypted_packet(inbuf)) {
/* Can't do this on encrypted
DEBUG(3,("lock fd=%d fnum=%d offset=%.0f count=%.0f\n",
fsp->fh->fd, fsp->fnum, (double)offset, (double)count));
- br_lck = do_lock(smbd_messaging_context(),
+ br_lck = do_lock(req->sconn->msg_ctx,
fsp,
(uint64_t)req->smbpid,
count,
count = (uint64_t)IVAL(req->vwv+1, 0);
offset = (uint64_t)IVAL(req->vwv+3, 0);
- status = do_unlock(smbd_messaging_context(),
+ status = do_unlock(req->sconn->msg_ctx,
fsp,
(uint64_t)req->smbpid,
count,
}
/* Open for exclusive use, write only. */
- status = print_fsp_open(req, conn, NULL, req->vuid, fsp);
+ status = print_spool_open(fsp, NULL, req->vuid);
if (!NT_STATUS_IS_OK(status)) {
file_free(req, fsp);
start_index, max_count));
{
- print_queue_struct *queue = NULL;
- print_status_struct status;
- int count = print_queue_status(SNUM(conn), &queue, &status);
- int num_to_get = ABS(max_count);
- int first = (max_count>0?start_index:start_index+max_count+1);
- int i;
-
- if (first >= count)
- num_to_get = 0;
- else
- num_to_get = MIN(num_to_get,count-first);
+ TALLOC_CTX *mem_ctx = talloc_tos();
+ NTSTATUS status;
+ WERROR werr;
+ const char *sharename = lp_servicename(SNUM(conn));
+ struct rpc_pipe_client *cli = NULL;
+ struct policy_handle handle;
+ struct spoolss_DevmodeContainer devmode_ctr;
+ union spoolss_JobInfo *info;
+ uint32_t count;
+ uint32_t num_to_get;
+ uint32_t first;
+ uint32_t i;
+
+ ZERO_STRUCT(handle);
+
+ status = rpc_connect_spoolss_pipe(conn, &cli);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0, ("reply_printqueue: "
+ "could not connect to spoolss: %s\n",
+ nt_errstr(status)));
+ reply_nterror(req, status);
+ goto out;
+ }
+
+ ZERO_STRUCT(devmode_ctr);
+
+ status = rpccli_spoolss_OpenPrinter(cli, mem_ctx,
+ sharename,
+ NULL, devmode_ctr,
+ SEC_FLAG_MAXIMUM_ALLOWED,
+ &handle,
+ &werr);
+ if (!NT_STATUS_IS_OK(status)) {
+ reply_nterror(req, status);
+ goto out;
+ }
+ if (!W_ERROR_IS_OK(werr)) {
+ reply_nterror(req, werror_to_ntstatus(werr));
+ goto out;
+ }
+
+ werr = rpccli_spoolss_enumjobs(cli, mem_ctx,
+ &handle,
+ 0, /* firstjob */
+ 0xff, /* numjobs */
+ 2, /* level */
+ 0, /* offered */
+ &count,
+ &info);
+ if (!W_ERROR_IS_OK(werr)) {
+ reply_nterror(req, werror_to_ntstatus(werr));
+ goto out;
+ }
+ if (max_count > 0) {
+ first = start_index;
+ } else {
+ first = start_index + max_count + 1;
+ }
+
+ if (first >= count) {
+ num_to_get = first;
+ } else {
+ num_to_get = first + MIN(ABS(max_count), count - first);
+ }
- for (i=first;i<first+num_to_get;i++) {
+ for (i = first; i < num_to_get; i++) {
char blob[28];
char *p = blob;
+ time_t qtime = spoolss_Time_to_time_t(&info[i].info2.submitted);
+ int qstatus;
+ uint16_t qrapjobid = pjobid_to_rap(sharename,
+ info[i].info2.job_id);
- srv_put_dos_date2(p,0,queue[i].time);
- SCVAL(p,4,(queue[i].status==LPQ_PRINTING?2:3));
- SSVAL(p,5, queue[i].job);
- SIVAL(p,7,queue[i].size);
- SCVAL(p,11,0);
+ if (info[i].info2.status == JOB_STATUS_PRINTING) {
+ qstatus = 2;
+ } else {
+ qstatus = 3;
+ }
+
+ srv_put_dos_date2(p, 0, qtime);
+ SCVAL(p, 4, qstatus);
+ SSVAL(p, 5, qrapjobid);
+ SIVAL(p, 7, info[i].info2.size);
+ SCVAL(p, 11, 0);
srvstr_push(blob, req->flags2, p+12,
- queue[i].fs_user, 16, STR_ASCII);
+ info[i].info2.notify_name, 16, STR_ASCII);
if (message_push_blob(
&req->outbuf,
data_blob_const(
blob, sizeof(blob))) == -1) {
reply_nterror(req, NT_STATUS_NO_MEMORY);
- END_PROFILE(SMBsplretq);
- return;
+ goto out;
}
}
SSVAL(smb_buf(req->outbuf),1,28*count);
}
- SAFE_FREE(queue);
- DEBUG(3,("%d entries returned in queue\n",count));
+ DEBUG(3, ("%u entries returned in queue\n",
+ (unsigned)count));
+
+out:
+ if (cli && is_valid_policy_hnd(&handle)) {
+ rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
+ }
+
}
END_PROFILE(SMBsplretq);
return;
}
- if (!CAN_PRINT(conn)) {
+ if (!fsp->print_file) {
reply_nterror(req, NT_STATUS_ACCESS_DENIED);
END_PROFILE(SMBsplwr);
return;
TALLOC_CTX *ctx = talloc_tos();
files_struct *fsp = NULL;
int info = 0;
- struct smbd_server_connection *sconn = smbd_server_conn;
+ struct smbd_server_connection *sconn = req->sconn;
START_PROFILE(SMBrmdir);
}
/* Send messages to all smbd's (not ourself) that the name has changed. */
- rename_share_filename(smbd_messaging_context(), lck, conn->connectpath,
+ rename_share_filename(conn->sconn->msg_ctx, lck, conn->connectpath,
smb_fname_dst);
}
return NT_STATUS_INVALID_PARAMETER;
}
- status = do_unlock(smbd_messaging_context(),
+ status = do_unlock(req->sconn->msg_ctx,
fsp,
e->smblctx,
e->count,
struct byte_range_lock *br_lck;
uint64_t block_smblctx;
- br_lck = do_lock(smbd_messaging_context(),
+ br_lck = do_lock(req->sconn->msg_ctx,
fsp,
e->smblctx,
e->count,
*
* Replacement for do_lock_spin(). JRA. */
- if (!smbd_server_conn->allow_smb2 &&
+ if (!req->sconn->using_smb2 &&
br_lck && lp_blocking_locks(SNUM(conn)) &&
lp_lock_spin_time() && !blocking_lock &&
NT_STATUS_EQUAL((status),
for(i--; i >= 0; i--) {
struct smbd_lock_element *e = &locks[i];
- do_unlock(smbd_messaging_context(),
+ do_unlock(req->sconn->msg_ctx,
fsp,
e->smblctx,
e->count,
git.samba.org / ira / wip.git / blobdiff