This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
+#include "system/filesys.h"
+#include "libcli/raw/libcliraw.h"
+#include "libcli/libcli.h"
/****************************************************************************
Hard/Symlink a file (UNIX extensions).
****************************************************************************/
-static NTSTATUS cli_link_internal(struct cli_tree *tree,
+static NTSTATUS smbcli_link_internal(struct smbcli_tree *tree,
const char *fname_src,
- const char *fname_dst, BOOL hard_link)
+ const char *fname_dst, bool hard_link)
{
union smb_setfileinfo parms;
NTSTATUS status;
if (hard_link) {
parms.generic.level = RAW_SFILEINFO_UNIX_HLINK;
- parms.unix_hlink.file.fname = fname_src;
+ parms.unix_hlink.in.file.path = fname_src;
parms.unix_hlink.in.link_dest = fname_dst;
} else {
parms.generic.level = RAW_SFILEINFO_UNIX_LINK;
- parms.unix_link.file.fname = fname_src;
+ parms.unix_link.in.file.path = fname_src;
parms.unix_link.in.link_dest = fname_dst;
}
/****************************************************************************
Map standard UNIX permissions onto wire representations.
****************************************************************************/
-static uint32_t unix_perms_to_wire(mode_t perms)
+uint32_t unix_perms_to_wire(mode_t perms)
{
- unsigned int ret = 0;
+ uint_t ret = 0;
ret |= ((perms & S_IXOTH) ? UNIX_X_OTH : 0);
ret |= ((perms & S_IWOTH) ? UNIX_W_OTH : 0);
/****************************************************************************
Symlink a file (UNIX extensions).
****************************************************************************/
-NTSTATUS cli_unix_symlink(struct cli_tree *tree, const char *fname_src,
+NTSTATUS smbcli_unix_symlink(struct smbcli_tree *tree, const char *fname_src,
const char *fname_dst)
{
- return cli_link_internal(tree, fname_src, fname_dst, False);
+ return smbcli_link_internal(tree, fname_src, fname_dst, false);
}
/****************************************************************************
Hard a file (UNIX extensions).
****************************************************************************/
-NTSTATUS cli_unix_hardlink(struct cli_tree *tree, const char *fname_src,
+NTSTATUS smbcli_unix_hardlink(struct smbcli_tree *tree, const char *fname_src,
const char *fname_dst)
{
- return cli_link_internal(tree, fname_src, fname_dst, True);
+ return smbcli_link_internal(tree, fname_src, fname_dst, true);
}
/****************************************************************************
Chmod or chown a file internal (UNIX extensions).
****************************************************************************/
-static NTSTATUS cli_unix_chmod_chown_internal(struct cli_tree *tree,
+static NTSTATUS smbcli_unix_chmod_chown_internal(struct smbcli_tree *tree,
const char *fname,
uint32_t mode, uint32_t uid,
uint32_t gid)
NTSTATUS status;
parms.generic.level = SMB_SFILEINFO_UNIX_BASIC;
- parms.unix_basic.file.fname = fname;
+ parms.unix_basic.in.file.path = fname;
parms.unix_basic.in.uid = uid;
parms.unix_basic.in.gid = gid;
parms.unix_basic.in.mode = mode;
chmod a file (UNIX extensions).
****************************************************************************/
-NTSTATUS cli_unix_chmod(struct cli_tree *tree, const char *fname, mode_t mode)
+NTSTATUS smbcli_unix_chmod(struct smbcli_tree *tree, const char *fname, mode_t mode)
{
- return cli_unix_chmod_chown_internal(tree, fname,
+ return smbcli_unix_chmod_chown_internal(tree, fname,
unix_perms_to_wire(mode),
SMB_UID_NO_CHANGE,
SMB_GID_NO_CHANGE);
/****************************************************************************
chown a file (UNIX extensions).
****************************************************************************/
-NTSTATUS cli_unix_chown(struct cli_tree *tree, const char *fname, uid_t uid,
+NTSTATUS smbcli_unix_chown(struct smbcli_tree *tree, const char *fname, uid_t uid,
gid_t gid)
{
- return cli_unix_chmod_chown_internal(tree, fname, SMB_MODE_NO_CHANGE,
+ return smbcli_unix_chmod_chown_internal(tree, fname, SMB_MODE_NO_CHANGE,
(uint32_t)uid, (uint32_t)gid);
}
/****************************************************************************
Rename a file.
****************************************************************************/
-NTSTATUS cli_rename(struct cli_tree *tree, const char *fname_src,
+NTSTATUS smbcli_rename(struct smbcli_tree *tree, const char *fname_src,
const char *fname_dst)
{
union smb_rename parms;
/****************************************************************************
Delete a file.
****************************************************************************/
-NTSTATUS cli_unlink(struct cli_tree *tree, const char *fname)
+NTSTATUS smbcli_unlink(struct smbcli_tree *tree, const char *fname)
{
- struct smb_unlink parms;
+ union smb_unlink parms;
- parms.in.pattern = fname;
+ parms.unlink.in.pattern = fname;
if (strchr(fname, '*')) {
- parms.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+ parms.unlink.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
} else {
- parms.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
+ parms.unlink.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
}
return smb_raw_unlink(tree, &parms);
/****************************************************************************
Create a directory.
****************************************************************************/
-NTSTATUS cli_mkdir(struct cli_tree *tree, const char *dname)
+NTSTATUS smbcli_mkdir(struct smbcli_tree *tree, const char *dname)
{
union smb_mkdir parms;
/****************************************************************************
Remove a directory.
****************************************************************************/
-NTSTATUS cli_rmdir(struct cli_tree *tree, const char *dname)
+NTSTATUS smbcli_rmdir(struct smbcli_tree *tree, const char *dname)
{
struct smb_rmdir parms;
/****************************************************************************
Set or clear the delete on close flag.
****************************************************************************/
-NTSTATUS cli_nt_delete_on_close(struct cli_tree *tree, int fnum, BOOL flag)
+NTSTATUS smbcli_nt_delete_on_close(struct smbcli_tree *tree, int fnum,
+ bool flag)
{
union smb_setfileinfo parms;
NTSTATUS status;
parms.disposition_info.level = RAW_SFILEINFO_DISPOSITION_INFO;
- parms.disposition_info.file.fnum = fnum;
+ parms.disposition_info.in.file.fnum = fnum;
parms.disposition_info.in.delete_on_close = flag;
status = smb_raw_setfileinfo(tree, &parms);
Create/open a file - exposing the full horror of the NT API :-).
Used in CIFS-on-CIFS NTVFS.
****************************************************************************/
-int cli_nt_create_full(struct cli_tree *tree, const char *fname,
+int smbcli_nt_create_full(struct smbcli_tree *tree, const char *fname,
uint32_t CreatFlags, uint32_t DesiredAccess,
uint32_t FileAttributes, uint32_t ShareAccess,
uint32_t CreateDisposition, uint32_t CreateOptions,
open_parms.ntcreatex.in.fname = fname;
status = smb_raw_open(tree, mem_ctx, &open_parms);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (NT_STATUS_IS_OK(status)) {
- return open_parms.ntcreatex.out.fnum;
+ return open_parms.ntcreatex.out.file.fnum;
}
return -1;
Open a file (using SMBopenx)
WARNING: if you open with O_WRONLY then getattrE won't work!
****************************************************************************/
-int cli_open(struct cli_tree *tree, const char *fname, int flags,
+int smbcli_open(struct smbcli_tree *tree, const char *fname, int flags,
int share_mode)
{
union smb_open open_parms;
- unsigned openfn=0;
- unsigned accessmode=0;
+ uint_t openfn=0;
+ uint_t accessmode=0;
TALLOC_CTX *mem_ctx;
NTSTATUS status;
open_parms.openx.in.fname = fname;
status = smb_raw_open(tree, mem_ctx, &open_parms);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (NT_STATUS_IS_OK(status)) {
- return open_parms.openx.out.fnum;
+ return open_parms.openx.out.file.fnum;
}
return -1;
/****************************************************************************
Close a file.
****************************************************************************/
-NTSTATUS cli_close(struct cli_tree *tree, int fnum)
+NTSTATUS smbcli_close(struct smbcli_tree *tree, int fnum)
{
union smb_close close_parms;
NTSTATUS status;
close_parms.close.level = RAW_CLOSE_CLOSE;
- close_parms.close.in.fnum = fnum;
+ close_parms.close.in.file.fnum = fnum;
close_parms.close.in.write_time = 0;
status = smb_raw_close(tree, &close_parms);
return status;
send a lock with a specified locktype
this is used for testing LOCKING_ANDX_CANCEL_LOCK
****************************************************************************/
-NTSTATUS cli_locktype(struct cli_tree *tree, int fnum,
+NTSTATUS smbcli_locktype(struct smbcli_tree *tree, int fnum,
uint32_t offset, uint32_t len, int timeout,
- unsigned char locktype)
+ uint8_t locktype)
{
union smb_lock parms;
struct smb_lock_entry lock[1];
NTSTATUS status;
parms.lockx.level = RAW_LOCK_LOCKX;
- parms.lockx.in.fnum = fnum;
+ parms.lockx.in.file.fnum = fnum;
parms.lockx.in.mode = locktype;
parms.lockx.in.timeout = timeout;
parms.lockx.in.ulock_cnt = 0;
/****************************************************************************
Lock a file.
****************************************************************************/
-NTSTATUS cli_lock(struct cli_tree *tree, int fnum,
+NTSTATUS smbcli_lock(struct smbcli_tree *tree, int fnum,
uint32_t offset, uint32_t len, int timeout,
enum brl_type lock_type)
{
NTSTATUS status;
parms.lockx.level = RAW_LOCK_LOCKX;
- parms.lockx.in.fnum = fnum;
+ parms.lockx.in.file.fnum = fnum;
parms.lockx.in.mode = (lock_type == READ_LOCK? 1 : 0);
parms.lockx.in.timeout = timeout;
parms.lockx.in.ulock_cnt = 0;
/****************************************************************************
Unlock a file.
****************************************************************************/
-NTSTATUS cli_unlock(struct cli_tree *tree, int fnum, uint32_t offset, uint32_t len)
+NTSTATUS smbcli_unlock(struct smbcli_tree *tree, int fnum, uint32_t offset, uint32_t len)
{
union smb_lock parms;
struct smb_lock_entry lock[1];
NTSTATUS status;
parms.lockx.level = RAW_LOCK_LOCKX;
- parms.lockx.in.fnum = fnum;
+ parms.lockx.in.file.fnum = fnum;
parms.lockx.in.mode = 0;
parms.lockx.in.timeout = 0;
parms.lockx.in.ulock_cnt = 1;
/****************************************************************************
Lock a file with 64 bit offsets.
****************************************************************************/
-NTSTATUS cli_lock64(struct cli_tree *tree, int fnum,
- SMB_OFF_T offset, SMB_OFF_T len, int timeout,
+NTSTATUS smbcli_lock64(struct smbcli_tree *tree, int fnum,
+ off_t offset, off_t len, int timeout,
enum brl_type lock_type)
{
union smb_lock parms;
NTSTATUS status;
if (!(tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES)) {
- return cli_lock(tree, fnum, offset, len, timeout, lock_type);
+ return smbcli_lock(tree, fnum, offset, len, timeout, lock_type);
}
parms.lockx.level = RAW_LOCK_LOCKX;
- parms.lockx.in.fnum = fnum;
+ parms.lockx.in.file.fnum = fnum;
ltype = (lock_type == READ_LOCK? 1 : 0);
ltype |= LOCKING_ANDX_LARGE_FILES;
/****************************************************************************
Unlock a file with 64 bit offsets.
****************************************************************************/
-NTSTATUS cli_unlock64(struct cli_tree *tree, int fnum, SMB_OFF_T offset,
- SMB_OFF_T len)
+NTSTATUS smbcli_unlock64(struct smbcli_tree *tree, int fnum, off_t offset,
+ off_t len)
{
union smb_lock parms;
struct smb_lock_entry lock[1];
NTSTATUS status;
if (!(tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES)) {
- return cli_unlock(tree, fnum, offset, len);
+ return smbcli_unlock(tree, fnum, offset, len);
}
parms.lockx.level = RAW_LOCK_LOCKX;
- parms.lockx.in.fnum = fnum;
+ parms.lockx.in.file.fnum = fnum;
parms.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
parms.lockx.in.timeout = 0;
parms.lockx.in.ulock_cnt = 1;
/****************************************************************************
Do a SMBgetattrE call.
****************************************************************************/
-NTSTATUS cli_getattrE(struct cli_tree *tree, int fnum,
+NTSTATUS smbcli_getattrE(struct smbcli_tree *tree, int fnum,
uint16_t *attr, size_t *size,
time_t *c_time, time_t *a_time, time_t *m_time)
{
NTSTATUS status;
parms.getattre.level = RAW_FILEINFO_GETATTRE;
- parms.getattre.in.fnum = fnum;
+ parms.getattre.in.file.fnum = fnum;
status = smb_raw_fileinfo(tree, NULL, &parms);
/****************************************************************************
Do a SMBgetatr call
****************************************************************************/
-NTSTATUS cli_getatr(struct cli_tree *tree, const char *fname,
+NTSTATUS smbcli_getatr(struct smbcli_tree *tree, const char *fname,
uint16_t *attr, size_t *size, time_t *t)
{
union smb_fileinfo parms;
NTSTATUS status;
parms.getattr.level = RAW_FILEINFO_GETATTR;
- parms.getattr.in.fname = fname;
+ parms.getattr.in.file.path = fname;
status = smb_raw_pathinfo(tree, NULL, &parms);
/****************************************************************************
Do a SMBsetatr call.
****************************************************************************/
-NTSTATUS cli_setatr(struct cli_tree *tree, const char *fname, uint16_t mode,
+NTSTATUS smbcli_setatr(struct smbcli_tree *tree, const char *fname, uint16_t mode,
time_t t)
{
union smb_setfileinfo parms;
- NTSTATUS status;
parms.setattr.level = RAW_SFILEINFO_SETATTR;
+ parms.setattr.in.file.path = fname;
parms.setattr.in.attrib = mode;
parms.setattr.in.write_time = t;
- parms.setattr.file.fname = fname;
- status = smb_raw_setpathinfo(tree, &parms);
+ return smb_raw_setpathinfo(tree, &parms);
+}
- return status;
+/****************************************************************************
+ Do a setfileinfo basic_info call.
+****************************************************************************/
+NTSTATUS smbcli_fsetatr(struct smbcli_tree *tree, int fnum, uint16_t mode,
+ NTTIME create_time, NTTIME access_time,
+ NTTIME write_time, NTTIME change_time)
+{
+ union smb_setfileinfo parms;
+
+ parms.basic_info.level = RAW_SFILEINFO_BASIC_INFO;
+ parms.basic_info.in.file.fnum = fnum;
+ parms.basic_info.in.attrib = mode;
+ parms.basic_info.in.create_time = create_time;
+ parms.basic_info.in.access_time = access_time;
+ parms.basic_info.in.write_time = write_time;
+ parms.basic_info.in.change_time = change_time;
+
+ return smb_raw_setfileinfo(tree, &parms);
+}
+
+
+/****************************************************************************
+ truncate a file to a given size
+****************************************************************************/
+NTSTATUS smbcli_ftruncate(struct smbcli_tree *tree, int fnum, uint64_t size)
+{
+ union smb_setfileinfo parms;
+
+ parms.end_of_file_info.level = RAW_SFILEINFO_END_OF_FILE_INFO;
+ parms.end_of_file_info.in.file.fnum = fnum;
+ parms.end_of_file_info.in.size = size;
+
+ return smb_raw_setfileinfo(tree, &parms);
}
/****************************************************************************
Check for existence of a dir.
****************************************************************************/
-NTSTATUS cli_chkpath(struct cli_tree *tree, const char *path)
+NTSTATUS smbcli_chkpath(struct smbcli_tree *tree, const char *path)
{
- struct smb_chkpath parms;
+ union smb_chkpath parms;
char *path2;
NTSTATUS status;
path2 = strdup("\\");
}
- parms.in.path = path2;
-
+ parms.chkpath.in.path = path2;
+
status = smb_raw_chkpath(tree, &parms);
free(path2);
/****************************************************************************
Query disk space.
****************************************************************************/
-NTSTATUS cli_dskattr(struct cli_tree *tree, int *bsize, int *total, int *avail)
+NTSTATUS smbcli_dskattr(struct smbcli_tree *tree, uint32_t *bsize,
+ uint64_t *total, uint64_t *avail)
{
union smb_fsinfo fsinfo_parms;
TALLOC_CTX *mem_ctx;
NTSTATUS status;
- mem_ctx = talloc_init("cli_dskattr");
+ mem_ctx = talloc_init("smbcli_dskattr");
- fsinfo_parms.dskattr.level = RAW_QFS_DSKATTR;
+ fsinfo_parms.dskattr.level = RAW_QFS_SIZE_INFO;
status = smb_raw_fsinfo(tree, mem_ctx, &fsinfo_parms);
if (NT_STATUS_IS_OK(status)) {
- *bsize = fsinfo_parms.dskattr.out.block_size;
- *total = fsinfo_parms.dskattr.out.units_total;
- *avail = fsinfo_parms.dskattr.out.units_free;
+ *bsize = fsinfo_parms.size_info.out.bytes_per_sector * fsinfo_parms.size_info.out.sectors_per_unit;
+ *total = fsinfo_parms.size_info.out.total_alloc_units;
+ *avail = fsinfo_parms.size_info.out.avail_alloc_units;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
/****************************************************************************
Create and open a temporary file.
****************************************************************************/
-int cli_ctemp(struct cli_tree *tree, const char *path, char **tmp_path)
+int smbcli_ctemp(struct smbcli_tree *tree, const char *path, char **tmp_path)
{
union smb_open open_parms;
TALLOC_CTX *mem_ctx;
open_parms.openx.level = RAW_OPEN_CTEMP;
open_parms.ctemp.in.attrib = 0;
open_parms.ctemp.in.directory = path;
+ open_parms.ctemp.in.write_time = 0;
status = smb_raw_open(tree, mem_ctx, &open_parms);
if (tmp_path) {
*tmp_path = strdup(open_parms.ctemp.out.name);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (NT_STATUS_IS_OK(status)) {
- return open_parms.ctemp.out.fnum;
+ return open_parms.ctemp.out.file.fnum;
}
return -1;
}
git.samba.org / ira / wip.git / blobdiff