static SMB_OFF_T vfs_my_module_maxsize(vfs_handle_struct *handle)
{
SMB_OFF_T maxsize;
maxsize = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
"vfs_my_module", "maxsize", "536870912"));
return maxsize;
}
/****************************************************************************
Build the print command in the supplied buffer. This means getting the
print command for the service and inserting the printer name and the
print file name. Return NULL on error, else the passed buffer pointer.
****************************************************************************/
static char *build_print_command(int cnum, char *command, char *syscmd, char *filename1)
{
int snum = SNUM(cnum);
char *tstr;
pstring filename;
/* get the print command for the service. */
tstr = command;
if (!syscmd || !tstr) {
DEBUG(0,("No print command for service `%s'\n", SERVICE(snum)));
return (NULL);
}
/* copy the command into the buffer for extensive meddling. */
StrnCpy(syscmd, tstr, sizeof(pstring) - 1);
/* look for "%s" in the string. If there is no %s, we cannot print. */
if (!strstr(syscmd, "%s") && !strstr(syscmd, "%f")) {
DEBUG(2,("WARNING! No placeholder for the filename in the print command for service %s!\n", SERVICE(snum)));
}
if (strstr(syscmd,"%s")) {
int iOffset = PTR_DIFF(strstr(syscmd, "%s"),syscmd);
/* construct the full path for the filename, shouldn't be necessary unless
the subshell causes a "cd" to be executed.
Only use the full path if there isn't a / preceding the %s */
if (iOffset==0 || syscmd[iOffset-1] != '/') {
StrnCpy(filename,Connections[cnum].connectpath,sizeof(filename)-1);
trim_string(filename,"","/");
pstrcat(filename,"/");
pstrcat(filename,filename1);
}
else
pstrcpy(filename,filename1);
string_sub(syscmd, "%s", filename);
}
string_sub(syscmd, "%f", filename1);
/* Does the service have a printername? If not, make a fake and empty */
/* printer name. That way a %p is treated sanely if no printer */
/* name was specified to replace it. This eventuality is logged. */
tstr = PRINTERNAME(snum);
if (tstr == NULL || tstr[0] == '\0') {
DEBUG(3,( "No printer name - using %s.\n", SERVICE(snum)));
tstr = SERVICE(snum);
}
string_sub(syscmd, "%p", tstr);
standard_sub(cnum,syscmd);
return (syscmd);
}
static const char *recycle_repository(vfs_handle_struct *handle)
{
const char *tmp_str = NULL;
tmp_str = lp_parm_const_string(SNUM(handle->conn), "recycle", "repository",".recycle");
DEBUG(10, ("recycle: repository = %s\n", tmp_str));
return tmp_str;
}
static int recycle_maxsize(vfs_handle_struct *handle)
{
int maxsize;
maxsize = lp_parm_int(SNUM(handle->conn), "recycle", "maxsize", -1);
DEBUG(10, ("recycle: maxsize = %d\n", maxsize));
return maxsize;
}
static bool recycle_versions(vfs_handle_struct *handle)
{
bool ret;
ret = lp_parm_bool(SNUM(handle->conn), "recycle", "versions", False);
DEBUG(10, ("recycle: versions = %s\n", ret?"True":"False"));
return ret;
}
static bool recycle_touch(vfs_handle_struct *handle)
{
bool ret;
ret = lp_parm_bool(SNUM(handle->conn), "recycle", "touch", False);
DEBUG(10, ("recycle: touch = %s\n", ret?"True":"False"));
return ret;
}
static NTSTATUS do_lock(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type)
{
NTSTATUS status;
if (!lp_locking(SNUM(conn)))
return NT_STATUS_OK;
/* NOTE! 0 byte long ranges ARE allowed and should be stored */
DEBUG(10,("do_lock: lock type %s start=%.0f len=%.0f requested for file %s\n",
lock_type_name(lock_type), (double)offset, (double)count, fsp->fsp_name ));
if (OPEN_FSP(fsp) && fsp->can_lock && (fsp->conn == conn)) {
status = brl_lock(fsp->dev, fsp->inode, fsp->fnum,
lock_pid, sys_getpid(), conn->cnum,
offset, count,
lock_type);
if (NT_STATUS_IS_OK(status) && lp_posix_locking(SNUM(conn))) {
/*
* Try and get a POSIX lock on this range.
* Note that this is ok if it is a read lock
* overlapping on a different fd. JRA.
*/
if (!set_posix_lock(fsp, offset, count, lock_type)) {
status = NT_STATUS_LOCK_NOT_GRANTED;
/*
* We failed to map - we must now remove the brl
* lock entry.
*/
(void)brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
lock_pid, sys_getpid(), conn->cnum,
offset, count, False);
}
}
}
return status;
}
void close_cnum(connection_struct *conn, uint16 vuid)
{
if (IS_IPC(conn)) {
pipe_close_conn(conn);
} else {
file_close_conn(conn);
dptr_closecnum(conn);
}
change_to_root_user();
DEBUG(IS_IPC(conn)?3:1, ("%s (%s) closed connection to service %s\n",
get_remote_machine_name(),
conn->client_address,
lp_servicename(SNUM(conn))));
/* Call VFS disconnect hook */
SMB_VFS_DISCONNECT(conn);
yield_connection(conn, lp_servicename(SNUM(conn)));
/* make sure we leave the directory available for unmount */
vfs_ChDir(conn, "/");
/* execute any "postexec = " line */
if (*lp_postexec(SNUM(conn)) &&
change_to_user(conn, vuid)) {
pstring cmd;
pstrcpy(cmd,lp_postexec(SNUM(conn)));
standard_sub_advanced(lp_servicename(SNUM(conn)), conn->user,
conn->connectpath, conn->gid,
get_current_username(),
current_user_info.domain,
cmd, sizeof(cmd));
smbrun(cmd,NULL);
change_to_root_user();
}
change_to_root_user();
/* execute any "root postexec = " line */
if (*lp_rootpostexec(SNUM(conn))) {
pstring cmd;
pstrcpy(cmd,lp_rootpostexec(SNUM(conn)));
standard_sub_advanced(lp_servicename(SNUM(conn)), conn->user,
conn->connectpath, conn->gid,
get_current_username(),
current_user_info.domain,
cmd, sizeof(cmd));
smbrun(cmd,NULL);
}
conn_free(conn);
}
static int prealloc_connect(
struct vfs_handle_struct * handle,
const char * service,
const char * user)
{
module_debug = lp_parm_int(SNUM(handle->conn),
MODULE, "msglevel", 100);
return SMB_VFS_NEXT_CONNECT(handle, service, user);
}
static int streams_xattr_connect(vfs_handle_struct *handle,
const char *service, const char *user)
{
struct streams_xattr_config *config;
const char *default_prefix = SAMBA_XATTR_DOSSTREAM_PREFIX;
const char *prefix;
int rc;
rc = SMB_VFS_NEXT_CONNECT(handle, service, user);
if (rc != 0) {
return rc;
}
config = talloc_zero(handle->conn, struct streams_xattr_config);
if (config == NULL) {
DEBUG(1, ("talloc_zero() failed\n"));
errno = ENOMEM;
return -1;
}
prefix = lp_parm_const_string(SNUM(handle->conn),
"streams_xattr", "prefix",
default_prefix);
config->prefix = talloc_strdup(config, prefix);
if (config->prefix == NULL) {
DEBUG(1, ("talloc_strdup() failed\n"));
errno = ENOMEM;
return -1;
}
config->prefix_len = strlen(config->prefix);
DEBUG(10, ("streams_xattr using stream prefix: %s\n", config->prefix));
config->store_stream_type = lp_parm_bool(SNUM(handle->conn),
"streams_xattr",
"store_stream_type",
true);
SMB_VFS_HANDLE_SET_DATA(handle, config,
NULL, struct stream_xattr_config,
return -1);
return 0;
}
NTSTATUS check_name(connection_struct *conn, const char *name)
{
NTSTATUS status = check_veto_path(conn, name);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!lp_widelinks(SNUM(conn)) || !lp_symlinks(SNUM(conn))) {
status = check_reduced_name(conn,name);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(5,("check_name: name %s failed with %s\n",name,
nt_errstr(status)));
return status;
}
}
return NT_STATUS_OK;
}
static bool recycle_keep_dir_tree(vfs_handle_struct *handle)
{
bool ret;
ret = lp_parm_bool(SNUM(handle->conn), "recycle", "keeptree", False);
DEBUG(10, ("recycle_bin: keeptree = %s\n", ret?"True":"False"));
return ret;
}
int file_ntimes(connection_struct *conn, const struct smb_filename *smb_fname,
struct smb_file_time *ft)
{
int ret = -1;
errno = 0;
DEBUG(6, ("file_ntime: actime: %s",
time_to_asc(convert_timespec_to_time_t(ft->atime))));
DEBUG(6, ("file_ntime: modtime: %s",
time_to_asc(convert_timespec_to_time_t(ft->mtime))));
DEBUG(6, ("file_ntime: ctime: %s",
time_to_asc(convert_timespec_to_time_t(ft->ctime))));
DEBUG(6, ("file_ntime: createtime: %s",
time_to_asc(convert_timespec_to_time_t(ft->create_time))));
/* Don't update the time on read-only shares */
/* We need this as set_filetime (which can be called on
close and other paths) can end up calling this function
without the NEED_WRITE protection. Found by :
Leo Weppelman <*****@*****.**>
*/
if (!CAN_WRITE(conn)) {
return 0;
}
if(SMB_VFS_NTIMES(conn, smb_fname, ft) == 0) {
return 0;
}
if((errno != EPERM) && (errno != EACCES)) {
return -1;
}
if(!lp_dos_filetimes(SNUM(conn))) {
return -1;
}
/* We have permission (given by the Samba admin) to
break POSIX semantics and allow a user to change
the time on a file they don't own but can write to
(as DOS does).
*/
/* Check if we have write access. */
if (can_write_to_file(conn, smb_fname)) {
/* We are allowed to become root and change the filetime. */
become_root();
ret = SMB_VFS_NTIMES(conn, smb_fname, ft);
unbecome_root();
}
return ret;
}
uint32 dos_mode(connection_struct *conn, const char *path,SMB_STRUCT_STAT *sbuf)
{
uint32 result = 0;
DEBUG(8,("dos_mode: %s\n", path));
if (!VALID_STAT(*sbuf)) {
return 0;
}
/* First do any modifications that depend on the path name. */
/* hide files with a name starting with a . */
if (lp_hide_dot_files(SNUM(conn))) {
const char *p = strrchr_m(path,'/');
if (p) {
p++;
} else {
p = path;
}
if (p[0] == '.' && p[1] != '.' && p[1] != 0) {
result |= aHIDDEN;
}
}
/* Get the DOS attributes from an EA by preference. */
if (get_ea_dos_attribute(conn, path, sbuf, &result)) {
result |= set_sparse_flag(sbuf);
} else {
result |= dos_mode_from_sbuf(conn, path, sbuf);
}
if (S_ISREG(sbuf->st_mode)) {
result |= set_offline_flag(conn, path);
}
/* Optimization : Only call is_hidden_path if it's not already
hidden. */
if (!(result & aHIDDEN) && IS_HIDDEN_PATH(conn,path)) {
result |= aHIDDEN;
}
DEBUG(8,("dos_mode returning "));
if (result & aHIDDEN) DEBUG(8, ("h"));
if (result & aRONLY ) DEBUG(8, ("r"));
if (result & aSYSTEM) DEBUG(8, ("s"));
if (result & aDIR ) DEBUG(8, ("d"));
if (result & aARCH ) DEBUG(8, ("a"));
if (result & FILE_ATTRIBUTE_SPARSE ) DEBUG(8, ("[sparse]"));
DEBUG(8,("\n"));
return(result);
}
static NTSTATUS vfs_worm_create_file(vfs_handle_struct *handle,
struct smb_request *req,
uint16_t root_dir_fid,
struct smb_filename *smb_fname,
uint32_t access_mask,
uint32_t share_access,
uint32_t create_disposition,
uint32_t create_options,
uint32_t file_attributes,
uint32_t oplock_request,
uint64_t allocation_size,
uint32_t private_flags,
struct security_descriptor *sd,
struct ea_list *ea_list,
files_struct **result,
int *pinfo)
{
bool readonly = false;
const uint32_t write_access_flags =
FILE_WRITE_DATA | FILE_APPEND_DATA |
FILE_WRITE_ATTRIBUTES | DELETE_ACCESS |
WRITE_DAC_ACCESS | WRITE_OWNER_ACCESS;
NTSTATUS status;
if (VALID_STAT(smb_fname->st)) {
double age;
age = timespec_elapsed(&smb_fname->st.st_ex_ctime);
if (age > lp_parm_int(SNUM(handle->conn), "worm",
"grace_period", 3600)) {
readonly = true;
}
}
if (readonly && (access_mask & write_access_flags)) {
return NT_STATUS_ACCESS_DENIED;
}
status = SMB_VFS_NEXT_CREATE_FILE(
handle, req, root_dir_fid, smb_fname, access_mask,
share_access, create_disposition, create_options,
file_attributes, oplock_request, allocation_size,
private_flags, sd, ea_list, result, pinfo);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
/*
* Access via MAXIMUM_ALLOWED_ACCESS?
*/
if (readonly && ((*result)->access_mask & write_access_flags)) {
close_file(req, *result, NORMAL_CLOSE);
return NT_STATUS_ACCESS_DENIED;
}
return NT_STATUS_OK;
}
const char* get_configuration_file(const struct connection_struct *conn, fstring module_name, fstring paramconf)
#endif
{
static fstring config_file;
#if (SAMBA_VERSION_MAJOR==2 && SAMBA_VERSION_RELEASE>=4) || SAMBA_VERSION_MAJOR==3
#if !(SMB_VFS_INTERFACE_VERSION >= 6)
pstring opts_str;
PROTOTYPE_CONST char *p;
#endif
#endif
#if (SMB_VFS_INTERFACE_VERSION >= 6)
fstrcpy(config_file, lp_parm_const_string(SNUM(conn),module_name,"config-file",paramconf));
#else
pstrcpy(opts_str, (const char*) lp_vfs_options(SNUM(conn)));
if( !*opts_str ) {
DEBUG(3, ("samba-vscan: no configuration file set - using default value (%s).\n", lp_vfs_options(SNUM(conn))));
} else {
p = opts_str;
if ( next_token(&p, config_file, "=", sizeof(config_file)) ) {
trim_string(config_file, " ", " ");
if ( !strequal("config-file", config_file) ) {
DEBUG(3, ("samba-vscan - connect: options %s is not config-file\n", config_file));
/* setting default value */
fstrcpy(config_file, paramconf);
} else {
if ( !next_token(&p, config_file," \n",sizeof(config_file)) ) {
DEBUG(3, ("samba-vscan - connect: no option after config-file=\n"));
/* setting default value */
fstrcpy(config_file, paramconf);
} else {
trim_string(config_file, " ", " ");
DEBUG(3, ("samba-vscan - connect: config file name is %s\n", config_file));
}
}
}
}
#endif /* #if (SMB_VFS_INTERFACE_VERSION >= 6)*/
return config_file;
}
static uint32_t onefs_fs_capabilities(struct vfs_handle_struct *handle)
{
uint32_t result = 0;
if (!lp_parm_bool(SNUM(handle->conn), PARM_ONEFS_TYPE,
PARM_IGNORE_STREAMS, PARM_IGNORE_STREAMS_DEFAULT)) {
result |= FILE_NAMED_STREAMS;
}
return result | SMB_VFS_NEXT_FS_CAPABILITIES(handle);
}
/*
work out the location of the base directory for snapshots of this share
*/
static const char *shadow_copy2_find_basedir(TALLOC_CTX *mem_ctx, vfs_handle_struct *handle)
{
const char *basedir = lp_parm_const_string(SNUM(handle->conn), "shadow", "basedir", NULL);
/* other its the filesystem mount point */
if (basedir == NULL) {
basedir = find_mount_point(mem_ctx, handle);
}
return basedir;
}
NTSTATUS check_name(connection_struct *conn, const pstring name)
{
if (IS_VETO_PATH(conn, name)) {
/* Is it not dot or dot dot. */
if (!((name[0] == '.') && (!name[1] || (name[1] == '.' && !name[2])))) {
DEBUG(5,("check_name: file path name %s vetoed\n",name));
return map_nt_error_from_unix(ENOENT);
}
}
if (!lp_widelinks(SNUM(conn)) || !lp_symlinks(SNUM(conn))) {
NTSTATUS status = reduce_name(conn,name);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(5,("check_name: name %s failed with %s\n",name, nt_errstr(status)));
return status;
}
}
return NT_STATUS_OK;
}
static SMB_OFF_T recycle_minsize(vfs_handle_struct *handle)
{
SMB_OFF_T minsize;
minsize = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
"recycle", "minsize", NULL));
DEBUG(10, ("recycle: minsize = %lu\n", (long unsigned int)minsize));
return minsize;
}
NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
{
/*
* Only allow delete on close for writable files.
*/
if ((dosmode & FILE_ATTRIBUTE_READONLY) &&
!lp_delete_readonly(SNUM(fsp->conn))) {
DEBUG(10,("can_set_delete_on_close: file %s delete on close "
"flag set but file attribute is readonly.\n",
fsp_str_dbg(fsp)));
return NT_STATUS_CANNOT_DELETE;
}
/*
* Only allow delete on close for writable shares.
*/
if (!CAN_WRITE(fsp->conn)) {
DEBUG(10,("can_set_delete_on_close: file %s delete on "
"close flag set but write access denied on share.\n",
fsp_str_dbg(fsp)));
return NT_STATUS_ACCESS_DENIED;
}
/*
* Only allow delete on close for files/directories opened with delete
* intent.
*/
if (!(fsp->access_mask & DELETE_ACCESS)) {
DEBUG(10,("can_set_delete_on_close: file %s delete on "
"close flag set but delete access denied.\n",
fsp_str_dbg(fsp)));
return NT_STATUS_ACCESS_DENIED;
}
/* Don't allow delete on close for non-empty directories. */
if (fsp->is_directory) {
SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
/* Or the root of a share. */
if (ISDOT(fsp->fsp_name->base_name)) {
DEBUG(10,("can_set_delete_on_close: can't set delete on "
"close for the root of a share.\n"));
return NT_STATUS_ACCESS_DENIED;
}
return can_delete_directory(fsp->conn,
fsp->fsp_name->base_name);
}
return NT_STATUS_OK;
}
/* fake timestamps */
static void onefs_adjust_stat_time(struct connection_struct *conn,
const char *fname, SMB_STRUCT_STAT *sbuf)
{
struct onefs_vfs_share_config cfg;
struct timeval tv_now = {0, 0};
bool static_mtime = False;
bool static_atime = False;
if (!onefs_get_config(SNUM(conn),
ONEFS_VFS_CONFIG_FAKETIMESTAMPS, &cfg)) {
return;
}
if (IS_MTIME_STATIC_PATH(conn, &cfg, fname)) {
sbuf->st_ex_mtime = sbuf->st_ex_btime;
static_mtime = True;
}
if (IS_ATIME_STATIC_PATH(conn, &cfg, fname)) {
sbuf->st_ex_atime = sbuf->st_ex_btime;
static_atime = True;
}
if (IS_CTIME_NOW_PATH(conn, &cfg, fname)) {
if (cfg.ctime_slop < 0) {
sbuf->st_ex_btime.tv_sec = INT_MAX - 1;
} else {
GetTimeOfDay(&tv_now);
sbuf->st_ex_btime.tv_sec = tv_now.tv_sec +
cfg.ctime_slop;
}
}
if (!static_mtime && IS_MTIME_NOW_PATH(conn,&cfg,fname)) {
if (cfg.mtime_slop < 0) {
sbuf->st_ex_mtime.tv_sec = INT_MAX - 1;
} else {
if (tv_now.tv_sec == 0)
GetTimeOfDay(&tv_now);
sbuf->st_ex_mtime.tv_sec = tv_now.tv_sec +
cfg.mtime_slop;
}
}
if (!static_atime && IS_ATIME_NOW_PATH(conn,&cfg,fname)) {
if (cfg.atime_slop < 0) {
sbuf->st_ex_atime.tv_sec = INT_MAX - 1;
} else {
if (tv_now.tv_sec == 0)
GetTimeOfDay(&tv_now);
sbuf->st_ex_atime.tv_sec = tv_now.tv_sec +
cfg.atime_slop;
}
}
}
void standard_sub_conn(connection_struct *conn, char *str, size_t len)
{
char *s;
s = alloc_sub_advanced(SNUM(conn), conn->user, conn->connectpath,
conn->gid, smb_user_name, str);
if ( s ) {
strncpy( str, s, len );
SAFE_FREE( s );
}
}
static void onefs_load_faketimestamp_config(struct connection_struct *conn,
struct onefs_vfs_share_config *cfg)
{
const char **parm;
int snum = SNUM(conn);
parm = lp_parm_string_list(snum, PARM_ONEFS_TYPE, PARM_ATIME_NOW,
PARM_ATIME_NOW_DEFAULT);
if (parm) {
cfg->init_flags |= ONEFS_VFS_CONFIG_FAKETIMESTAMPS;
set_namearray(&cfg->atime_now_list,*parm);
}
parm = lp_parm_string_list(snum, PARM_ONEFS_TYPE, PARM_CTIME_NOW,
PARM_CTIME_NOW_DEFAULT);
if (parm) {
cfg->init_flags |= ONEFS_VFS_CONFIG_FAKETIMESTAMPS;
set_namearray(&cfg->ctime_now_list,*parm);
}
parm = lp_parm_string_list(snum, PARM_ONEFS_TYPE, PARM_MTIME_NOW,
PARM_MTIME_NOW_DEFAULT);
if (parm) {
cfg->init_flags |= ONEFS_VFS_CONFIG_FAKETIMESTAMPS;
set_namearray(&cfg->mtime_now_list,*parm);
}
parm = lp_parm_string_list(snum, PARM_ONEFS_TYPE, PARM_ATIME_STATIC,
PARM_ATIME_STATIC_DEFAULT);
if (parm) {
cfg->init_flags |= ONEFS_VFS_CONFIG_FAKETIMESTAMPS;
set_namearray(&cfg->atime_static_list,*parm);
}
parm = lp_parm_string_list(snum, PARM_ONEFS_TYPE, PARM_MTIME_STATIC,
PARM_MTIME_STATIC_DEFAULT);
if (parm) {
cfg->init_flags |= ONEFS_VFS_CONFIG_FAKETIMESTAMPS;
set_namearray(&cfg->mtime_static_list,*parm);
}
cfg->atime_slop = lp_parm_int(snum, PARM_ONEFS_TYPE, PARM_ATIME_SLOP,
PARM_ATIME_SLOP_DEFAULT);
cfg->ctime_slop = lp_parm_int(snum, PARM_ONEFS_TYPE, PARM_CTIME_SLOP,
PARM_CTIME_SLOP_DEFAULT);
cfg->mtime_slop = lp_parm_int(snum, PARM_ONEFS_TYPE, PARM_MTIME_SLOP,
PARM_MTIME_SLOP_DEFAULT);
}
BOOL set_current_service(connection_struct *conn, uint16 flags, BOOL do_chdir)
{
static connection_struct *last_conn;
static uint16 last_flags;
int snum;
if (!conn) {
last_conn = NULL;
return(False);
}
conn->lastused_count++;
snum = SNUM(conn);
if (do_chdir &&
vfs_ChDir(conn,conn->connectpath) != 0 &&
vfs_ChDir(conn,conn->origpath) != 0) {
DEBUG(0,("chdir (%s) failed\n",
conn->connectpath));
return(False);
}
if ((conn == last_conn) && (last_flags == flags)) {
return(True);
}
last_conn = conn;
last_flags = flags;
/* Obey the client case sensitivity requests - only for clients that support it. */
switch (lp_casesensitive(snum)) {
case Auto:
{
/* We need this uglyness due to DOS/Win9x clients that lie about case insensitivity. */
enum remote_arch_types ra_type = get_remote_arch();
if ((ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
/* Client can't support per-packet case sensitive pathnames. */
conn->case_sensitive = False;
} else {
conn->case_sensitive = !(flags & FLAG_CASELESS_PATHNAMES);
}
}
break;
case True:
conn->case_sensitive = True;
break;
default:
conn->case_sensitive = False;
break;
}
return(True);
}
static enum sock_type smb_traffic_analyzer_connMode(vfs_handle_struct *handle)
{
connection_struct *conn = handle->conn;
const char *Mode;
Mode=lp_parm_const_string(SNUM(conn), "smb_traffic_analyzer","mode", \
"internet_socket");
if (strstr(Mode,"unix_domain_socket")) {
return UNIX_DOMAIN_SOCKET;
} else {
return INTERNET_SOCKET;
}
}
static int connect_acl_xattr(struct vfs_handle_struct *handle,
const char *service,
const char *user)
{
int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
if (ret < 0) {
return ret;
}
/* Ensure we have "inherit acls = yes" if we're
* using this module. */
DEBUG(2,("connect_acl_xattr: setting 'inherit acls = true' "
"and 'dos filemode = true' for service %s\n",
service ));
lp_do_parameter(SNUM(handle->conn), "inherit acls", "true");
lp_do_parameter(SNUM(handle->conn), "dos filemode", "true");
return 0;
}
static uint32 set_offline_flag(connection_struct *conn, const char *const path)
{
if (ISDOT(path) || ISDOTDOT(path)) {
return 0;
}
if (!lp_dmapi_support(SNUM(conn)) || !dmapi_have_session()) {
return 0;
}
return dmapi_file_flags(path);
}
void close_cnum(connection_struct *conn, uint64_t vuid)
{
file_close_conn(conn);
if (!IS_IPC(conn)) {
dptr_closecnum(conn);
}
change_to_root_user();
DEBUG(IS_IPC(conn)?3:2, ("%s (%s) closed connection to service %s\n",
get_remote_machine_name(),
tsocket_address_string(conn->sconn->remote_address,
talloc_tos()),
lp_servicename(talloc_tos(), SNUM(conn))));
/* make sure we leave the directory available for unmount */
vfs_ChDir(conn, "/");
/* Call VFS disconnect hook */
SMB_VFS_DISCONNECT(conn);
/* execute any "postexec = " line */
if (*lp_postexec(talloc_tos(), SNUM(conn)) &&
change_to_user(conn, vuid)) {
char *cmd = talloc_sub_advanced(talloc_tos(),
lp_servicename(talloc_tos(), SNUM(conn)),
conn->session_info->unix_info->unix_name,
conn->connectpath,
conn->session_info->unix_token->gid,
conn->session_info->unix_info->sanitized_username,
conn->session_info->info->domain_name,
lp_postexec(talloc_tos(), SNUM(conn)));
smbrun(cmd,NULL);
TALLOC_FREE(cmd);
change_to_root_user();
}
change_to_root_user();
/* execute any "root postexec = " line */
if (*lp_root_postexec(talloc_tos(), SNUM(conn))) {
char *cmd = talloc_sub_advanced(talloc_tos(),
lp_servicename(talloc_tos(), SNUM(conn)),
conn->session_info->unix_info->unix_name,
conn->connectpath,
conn->session_info->unix_token->gid,
conn->session_info->unix_info->sanitized_username,
conn->session_info->info->domain_name,
lp_root_postexec(talloc_tos(), SNUM(conn)));
smbrun(cmd,NULL);
TALLOC_FREE(cmd);
}
conn_free(conn);
}
uint32_t dos_mode_msdfs(connection_struct *conn,
const struct smb_filename *smb_fname)
{
uint32_t result = 0;
DEBUG(8,("dos_mode_msdfs: %s\n", smb_fname_str_dbg(smb_fname)));
if (!VALID_STAT(smb_fname->st)) {
return 0;
}
/* First do any modifications that depend on the path name. */
/* hide files with a name starting with a . */
if (lp_hide_dot_files(SNUM(conn))) {
const char *p = strrchr_m(smb_fname->base_name, '/');
if (p) {
p++;
} else {
p = smb_fname->base_name;
}
/* Only . and .. are not hidden. */
if (p[0] == '.' && !((p[1] == '\0') ||
(p[1] == '.' && p[2] == '\0'))) {
result |= FILE_ATTRIBUTE_HIDDEN;
}
}
result |= dos_mode_from_sbuf(conn, smb_fname);
/* Optimization : Only call is_hidden_path if it's not already
hidden. */
if (!(result & FILE_ATTRIBUTE_HIDDEN) &&
IS_HIDDEN_PATH(conn, smb_fname->base_name)) {
result |= FILE_ATTRIBUTE_HIDDEN;
}
if (result == 0) {
result = FILE_ATTRIBUTE_NORMAL;
}
result = filter_mode_by_protocol(result);
/*
* Add in that it is a reparse point
*/
result |= FILE_ATTRIBUTE_REPARSE_POINT;
dos_mode_debug_print(__func__, result);
return(result);
}
