smb_write.c revision da6c28aaf62fa55f0fdb8004aa40f88f23bf53f0
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <smbsrv/smb_incl.h>
#include <smbsrv/smb_fsops.h>
#define SMB_WRMODE_WRITE_THRU 0x0001
#define SMB_WRMODE_IS_STABLE(M) ((M) & SMB_WRMODE_WRITE_THRU)
typedef struct smb_write_param {
struct vardata_block w_vdb;
/*
* Write count bytes at the specified offset in a file. The offset is
* limited to 32-bits. If the count is zero, the file is truncated to
* the length specified by the offset.
*
* The response count indicates the actual number of bytes written, which
* will equal the requested count on success. If request and response
* counts differ but there is no error, the client will assume that the
* server encountered a resource issue.
*/
int
{
int rc;
if (rc != 0) {
/* NOTREACHED */
}
/* NOTREACHED */
}
} else {
/* NOTREACHED */
}
}
if (rc != 0) {
/* NOTREACHED */
}
return (SDRC_NORMAL_REPLY);
}
/*
* Write count bytes to a file and then close the file. This function
* can only be used to write to 32-bit offsets and the client must set
* WordCount (6 or 12) correctly in order to locate the data to be
* written. If an error occurs on the write, the file should still be
* closed. If Count is 0, the file is truncated (or extended) to offset.
*
* If the last_write time is non-zero, last_write should be used to set
* the mtime. Otherwise the file system stamps the mtime. Failure to
* set mtime should not result in an error response.
*/
int
{
int rc = 0;
} else {
}
if (rc != 0) {
/* NOTREACHED */
}
/* NOTREACHED */
}
} else {
/*
* There may be a bug here: should this be "3.#B"?
*/
/* NOTREACHED */
}
}
if (rc != 0) {
/* NOTREACHED */
}
/* NOTREACHED */
}
return (SDRC_NORMAL_REPLY);
}
/*
* Write count bytes to a file at the specified offset and then unlock
* them. Write behind is safe because the client should have the range
* locked and this request is allowed to extend the file - note that
* offest is limited to 32-bits. It is an error for count to be zero.
*
* The SmbLockAndRead/SmbWriteAndUnlock sub-dialect is only valid on disk
* files. Reject any attempt to use it on other shares.
*
* The response count indicates the actual number of bytes written, which
* will equal the requested count on success. If request and response
* counts differ but there is no error, the client will assume that the
* server encountered a resource issue.
*/
int
{
int rc = 0;
/* NOTREACHED */
}
&remcnt);
if (rc != 0) {
/* NOTREACHED */
}
/* NOTREACHED */
}
/* NOTREACHED */
}
/* NOTREACHED */
}
/* NOTREACHED */
}
if (result != NT_STATUS_SUCCESS) {
/* NOTREACHED */
}
return (SDRC_NORMAL_REPLY);
}
/*
* Write bytes to a file (SMB Core). This request was extended in
* LM 0.12 to support 64-bit offsets, indicated by sending a wct of
* 14, instead of 12, and including additional offset information.
*
* A ByteCount of 0 does not truncate the file - use SMB_COM_WRITE
* to truncate a file. A zero length merely transfers zero bytes.
*
* If bit 0 of WriteMode is set, Fid must refer to a disk file and
* the data must be on stable storage before responding.
*/
int
{
int rc = 0;
&data_offset, &off_high);
data_offset -= 63;
} else {
&data_offset);
data_offset -= 59;
}
if (rc != 0) {
/* NOTREACHED */
}
/* NOTREACHED */
}
/* NOTREACHED */
}
/* NOTREACHED */
}
/* NOTREACHED */
}
}
return (SDRC_NORMAL_REPLY);
}
/*
*
* Returns errno values.
*/
int
{
int rc = 0;
case STYPE_DISKTREE:
if (rc != NT_STATUS_SUCCESS) {
/* NOTREACHED */
}
}
}
if (rc)
return (rc);
}
}
break;
case STYPE_IPC:
break;
default:
break;
}
if (rc != 0)
return (rc);
return (rc);
}
/*
* Truncate a disk file to the specified offset.
* Typically, w_count will be zero here.
*
* Returns errno values.
*/
int
{
int rc;
return (0);
if (rc != NT_STATUS_SUCCESS) {
/* NOTREACHED */
}
}
/*
* XXX what if the file has been opened only with
* FILE_APPEND_DATA?
*/
if (rc != NT_STATUS_SUCCESS) {
/* NOTREACHED */
}
return (rc);
return (0);
}
/*
* Set the file size using the value in the node. The file will only be
* updated if NODE_FLAGS_SET_SIZE is set. It is safe to pass a null node
* pointer, we just return success.
*
* The node attributes are refreshed here from the file system. So any
* attributes that are affected by file size changes, i.e. the mtime,
* will be current.
*
* Note that smb_write_andx cannot be used to reduce the file size so,
* if this is required, smb_write is called with a count of zero and
* the appropriate file length in offset. The file should be resized
* to the length specified by the offset.
*
* Returns 0 on success. Otherwise returns EACCES.
*/
int
{
return (0);
return (0);
if (dosattr & SMB_FA_READONLY) {
return (EACCES);
}
return (0);
}
/*
* write_complete is sent acknowledge completion of raw write requests.
* We never send raw write commands to other servers so, if we receive a
* write_complete, we treat it as an error.
*/
int
{
/* NOT REACHED */
return (0);
}
/*
* The Write Block Multiplexed protocol is used to maximize performance
* when writing a large block of data.
*
* The mpx sub protocol is not supported because we support only
* connection oriented transports and NT supports SMB_COM_READ_MPX
* only over connectionless transports.
*/
int /*ARGSUSED*/
{
return (SDRC_UNIMPLEMENTED);
}
int /*ARGSUSED*/
{
return (SDRC_UNIMPLEMENTED);
}