bool afs_login(connection_struct *conn)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
DATA_BLOB ticket;
char *afs_username = NULL;
char *cell = NULL;
}
afs_username = talloc_sub_advanced(ctx,
- lp_servicename(ctx, SNUM(conn)),
+ lp_servicename(ctx, lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name,
conn->connectpath,
conn->session_info->unix_token->gid,
#include "source3/param/param_proto.h"
-char *lp_servicename(TALLOC_CTX *ctx, int);
+char *lp_servicename(TALLOC_CTX *ctx, const struct loadparm_substitution *, int);
const char *lp_const_servicename(int);
bool lp_autoloaded(int);
const char *lp_dnsdomain(void);
static uint32_t vfswrap_fs_capabilities(struct vfs_handle_struct *handle,
enum timestamp_set_resolution *p_ts_res)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
connection_struct *conn = handle->conn;
uint32_t caps = FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
struct smb_filename *smb_fname_cpath = NULL;
"resolution of %s "
"available on share %s, directory %s\n",
*p_ts_res == TIMESTAMP_SET_MSEC ? "msec" : "sec",
- lp_servicename(talloc_tos(), conn->params->service),
+ lp_servicename(talloc_tos(), lp_sub, conn->params->service),
conn->connectpath ));
}
TALLOC_FREE(smb_fname_cpath);
static void dfs_samba4_disconnect(struct vfs_handle_struct *handle)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+
DEBUG(10,("dfs_samba4_disconnect() connect to service[%s].\n",
- lp_servicename(talloc_tos(), SNUM(handle->conn))));
+ lp_servicename(talloc_tos(), lp_sub, SNUM(handle->conn))));
SMB_VFS_NEXT_DISCONNECT(handle);
}
connection_struct *conn,
char *target)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
char *mapfilename = NULL;
char *filename_start = strchr_m(target, '@');
char *filename_end = NULL;
}
targethost = talloc_sub_full(ctx,
- lp_servicename(talloc_tos(), SNUM(conn)),
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name,
conn->connectpath,
conn->session_info->unix_token->gid,
static void fileid_disconnect(struct vfs_handle_struct *handle)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+
DEBUG(10,("fileid_disconnect() connect to service[%s].\n",
- lp_servicename(talloc_tos(), SNUM(handle->conn))));
+ lp_servicename(talloc_tos(), lp_sub, SNUM(handle->conn))));
SMB_VFS_NEXT_DISCONNECT(handle);
}
static char *audit_prefix(TALLOC_CTX *ctx, connection_struct *conn)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
char *prefix = NULL;
char *result;
return NULL;
}
result = talloc_sub_full(ctx,
- lp_servicename(talloc_tos(), SNUM(conn)),
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name,
conn->connectpath,
conn->session_info->unix_token->gid,
static void smb_full_audit_disconnect(vfs_handle_struct *handle)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+
SMB_VFS_NEXT_DISCONNECT(handle);
do_log(SMB_VFS_OP_DISCONNECT, True, handle,
- "%s", lp_servicename(talloc_tos(), SNUM(handle->conn)));
+ "%s", lp_servicename(talloc_tos(), lp_sub, SNUM(handle->conn)));
/* The bitmaps will be disconnected when the private
data is deleted. */
const struct smb_filename *smb_fname,
int flags)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
connection_struct *conn = handle->conn;
char *path_name = NULL;
char *temp_name = NULL;
bool exist;
int rc = -1;
- repository = talloc_sub_full(NULL, lp_servicename(talloc_tos(), SNUM(conn)),
+ repository = talloc_sub_full(NULL, lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name,
conn->connectpath,
conn->session_info->unix_token->gid,
connection_struct *conn,
const char *str)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+
return talloc_sub_full(mem_ctx,
- lp_servicename(mem_ctx, SNUM(conn)),
+ lp_servicename(mem_ctx, lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name,
conn->connectpath,
conn->session_info->unix_token->gid,
#include "lib/param/param_functions.c"
-FN_LOCAL_STRING(servicename, szService)
+FN_LOCAL_SUBSTITUTED_STRING(servicename, szService)
FN_LOCAL_CONST_STRING(const_servicename, szService)
/* These functions cannot be auto-generated */
tmp_ctx = talloc_stackframe();
for (iService = iNumServices - 1; iService >= 0; iService--) {
if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
char *servname;
if (snumused && snumused(sconn, iService)) {
continue;
}
- servname = lp_servicename(tmp_ctx, iService);
+ servname = lp_servicename(tmp_ctx, lp_sub, iService);
/* Remove from the share ACL db. */
DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
size_t end = 32;
if (!*label) {
- label = lp_servicename(ctx, snum);
+ label = lp_servicename(ctx, lp_sub, snum);
}
/*
struct messaging_context *msg_ctx,
int snum, uint32_t status)
{
- const char *sharename = lp_servicename(talloc_tos(), snum);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+ const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum);
if (sharename)
notify_printer_status_byname(ev, msg_ctx, sharename, status);
struct messaging_context *msg_ctx,
int snum, const char *driver_name)
{
- const char *sharename = lp_servicename(talloc_tos(), snum);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+ const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum);
send_notify_field_buffer(
ev, msg_ctx,
struct messaging_context *msg_ctx,
int snum, const char *comment)
{
- const char *sharename = lp_servicename(talloc_tos(), snum);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+ const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum);
send_notify_field_buffer(
ev, msg_ctx,
struct messaging_context *msg_ctx,
int snum, const char *share_name)
{
- const char *sharename = lp_servicename(talloc_tos(), snum);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+ const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum);
send_notify_field_buffer(
ev, msg_ctx,
struct messaging_context *msg_ctx,
int snum, const char *printername)
{
- const char *sharename = lp_servicename(talloc_tos(), snum);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+ const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum);
send_notify_field_buffer(
ev, msg_ctx,
struct messaging_context *msg_ctx,
int snum, const char *port_name)
{
- const char *sharename = lp_servicename(talloc_tos(), snum);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+ const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum);
send_notify_field_buffer(
ev, msg_ctx,
struct messaging_context *msg_ctx,
int snum, const char *location)
{
- const char *sharename = lp_servicename(talloc_tos(), snum);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+ const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum);
send_notify_field_buffer(
ev, msg_ctx,
struct messaging_context *msg_ctx,
int snum, const char *sepfile)
{
- const char *sharename = lp_servicename(talloc_tos(), snum);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+ const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum);
send_notify_field_buffer(
ev, msg_ctx,
struct dcerpc_binding_handle *b,
const struct spoolss_DriverInfo8 *r)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
int snum;
int n_services = lp_numservices();
bool in_use = false;
}
result = winreg_get_printer(mem_ctx, b,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
continue; /* skip */
WERROR check_published_printers(struct messaging_context *msg_ctx)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
ADS_STATUS ads_rc;
ADS_STRUCT *ads = NULL;
int snum;
}
result = winreg_get_printer_internal(tmp_ctx, session_info, msg_ctx,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
continue;
if (do_sub && snum != -1) {
syscmd = talloc_sub_advanced(ctx,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
current_user_info.unix_name,
"",
get_current_gid(NULL),
return;
}
lpqcommand = talloc_sub_full(ctx,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
current_user_info.unix_name,
"",
get_current_gid(NULL),
return;
}
lprmcommand = talloc_sub_full(ctx,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
current_user_info.unix_name,
"",
get_current_gid(NULL),
goto fail;
}
lpq_cmd = talloc_sub_full(tmp_ctx,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
current_user_info.unix_name,
"",
get_current_gid(NULL),
struct tdb_print_db *pdb, int snum,
int *pcount, print_queue_struct **ppqueue)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
TDB_DATA data, cgdata, jcdata;
print_queue_struct *queue = NULL;
uint32_t qcount = 0;
uint32_t i;
int max_reported_jobs = lp_max_reported_print_jobs(snum);
bool ret = false;
- const char* sharename = lp_servicename(talloc_tos(), snum);
+ const char* sharename = lp_servicename(talloc_tos(), lp_sub, snum);
TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx);
if (tmp_ctx == NULL) {
return false;
status = NT_STATUS_NO_MEMORY;
goto done;
}
- pf->svcname = lp_servicename(pf, SNUM(fsp->conn));
+ pf->svcname = lp_servicename(pf, lp_sub, SNUM(fsp->conn));
/* the document name is derived from the file name.
* "Remote Downlevel Document" is added in front to
msg_ctx,
NULL,
lp_servicename(session_info,
+ lp_sub,
snum),
&pinfo2)) {
nt_printer_publish(session_info,
struct spoolss_PrinterInfo2 *pinfo2,
TALLOC_CTX *mem_ctx)
{
- SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(talloc_tos(), snum));
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+
+ SETUP_SPOOLSS_NOTIFY_DATA_STRING(data, lp_servicename(talloc_tos(), lp_sub, snum));
}
/*******************************************************************
uint32_t id,
TALLOC_CTX *mem_ctx)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
int field_num,j;
enum spoolss_NotifyType type;
uint16_t field;
DEBUG(4,("construct_notify_printer_info: Notify type: [%s], number of notify info: [%d] on printer: [%s]\n",
(type == PRINTER_NOTIFY_TYPE ? "PRINTER_NOTIFY_TYPE" : "JOB_NOTIFY_TYPE"),
- option_type->count, lp_servicename(talloc_tos(), snum)));
+ option_type->count, lp_servicename(talloc_tos(), lp_sub, snum)));
for(field_num=0; field_num < option_type->count; field_num++) {
field = option_type->fields[field_num].field;
struct spoolss_NotifyInfo *info,
TALLOC_CTX *mem_ctx)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
int snum;
struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
int n_services=lp_numservices();
result = winreg_get_printer_internal(mem_ctx,
get_session_info_system(),
p->msg_ctx,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
DEBUG(4, ("printserver_notify_info: "
"Failed to get printer [%s]\n",
- lp_servicename(talloc_tos(), snum)));
+ lp_servicename(talloc_tos(), lp_sub, snum)));
continue;
}
struct spoolss_NotifyInfo *info,
TALLOC_CTX *mem_ctx)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
int snum;
struct printer_handle *Printer = find_printer_index_by_hnd(p, hnd);
int i;
result = winreg_get_printer_internal(mem_ctx,
get_session_info_system(),
p->msg_ctx,
- lp_servicename(talloc_tos(), snum), &pinfo2);
+ lp_servicename(talloc_tos(), lp_sub, snum), &pinfo2);
if (!W_ERROR_IS_OK(result)) {
result = WERR_INVALID_HANDLE;
goto err_pdb_drop;
return result;
}
- r->sharename = lp_servicename(mem_ctx, snum);
+ r->sharename = lp_servicename(mem_ctx, lp_sub, snum);
W_ERROR_HAVE_NO_MEMORY(r->sharename);
r->portname = talloc_strdup(mem_ctx, info2->portname);
W_ERROR_HAVE_NO_MEMORY(r->portname);
struct spoolss_PrinterInfo7 *r,
int snum)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
const struct auth_session_info *session_info;
struct spoolss_PrinterInfo2 *pinfo2 = NULL;
char *printer;
session_info = get_session_info_system();
SMB_ASSERT(session_info != NULL);
- printer = lp_servicename(tmp_ctx, snum);
+ printer = lp_servicename(tmp_ctx, lp_sub, snum);
if (printer == NULL) {
DEBUG(0, ("invalid printer snum %d\n", snum));
werr = WERR_INVALID_PARAMETER;
struct spoolss_SetPrinterInfo7 *info7)
{
#ifdef HAVE_ADS
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
struct spoolss_PrinterInfo2 *pinfo2 = NULL;
WERROR result;
int snum;
result = winreg_get_printer_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
return WERR_INVALID_HANDLE;
int position, int snum,
struct spoolss_PrinterInfo2 *pinfo2)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
struct tm *t;
t = gmtime(&queue->time);
r->job_id = jobid;
- r->printer_name = lp_servicename(mem_ctx, snum);
+ r->printer_name = lp_servicename(mem_ctx, lp_sub, snum);
W_ERROR_HAVE_NO_MEMORY(r->printer_name);
r->server_name = talloc_strdup(mem_ctx, pinfo2->servername);
W_ERROR_HAVE_NO_MEMORY(r->server_name);
struct spoolss_PrinterInfo2 *pinfo2,
struct spoolss_DeviceMode *devmode)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
struct tm *t;
t = gmtime(&queue->time);
r->job_id = jobid;
- r->printer_name = lp_servicename(mem_ctx, snum);
+ r->printer_name = lp_servicename(mem_ctx, lp_sub, snum);
W_ERROR_HAVE_NO_MEMORY(r->printer_name);
r->server_name = talloc_strdup(mem_ctx, pinfo2->servername);
W_ERROR_HAVE_NO_MEMORY(r->server_name);
WERROR _spoolss_SetPrinterDataEx(struct pipes_struct *p,
struct spoolss_SetPrinterDataEx *r)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
struct spoolss_PrinterInfo2 *pinfo2 = NULL;
int snum = 0;
WERROR result = WERR_OK;
}
result = winreg_get_printer(tmp_ctx, b,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
goto done;
static void init_srv_share_info_0(struct pipes_struct *p,
struct srvsvc_NetShareInfo0 *r, int snum)
{
- r->name = lp_servicename(talloc_tos(), snum);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+
+ r->name = lp_servicename(talloc_tos(), lp_sub, snum);
}
/*******************************************************************
{
const struct loadparm_substitution *lp_sub =
loadparm_s3_global_substitution();
- char *net_name = lp_servicename(talloc_tos(), snum);
+ char *net_name = lp_servicename(talloc_tos(), lp_sub, snum);
char *remark = lp_comment(p->mem_ctx, lp_sub, snum);
if (remark) {
remark = talloc_sub_full(
- p->mem_ctx, lp_servicename(talloc_tos(), snum),
+ p->mem_ctx, lp_servicename(talloc_tos(), lp_sub, snum),
get_current_username(), lp_path(talloc_tos(), lp_sub, snum),
p->session_info->unix_token->uid, get_current_username(),
"", remark);
char *path = NULL;
int max_connections = lp_max_connections(snum);
uint32_t max_uses = max_connections!=0 ? max_connections : (uint32_t)-1;
- char *net_name = lp_servicename(talloc_tos(), snum);
+ char *net_name = lp_servicename(talloc_tos(), lp_sub, snum);
remark = lp_comment(p->mem_ctx, lp_sub, snum);
if (remark) {
remark = talloc_sub_full(
- p->mem_ctx, lp_servicename(talloc_tos(), snum),
+ p->mem_ctx, lp_servicename(talloc_tos(), lp_sub, snum),
get_current_username(), lp_path(talloc_tos(), lp_sub, snum),
p->session_info->unix_token->uid, get_current_username(),
"", remark);
{
const struct loadparm_substitution *lp_sub =
loadparm_s3_global_substitution();
- const char *net_name = lp_servicename(talloc_tos(), snum);
+ const char *net_name = lp_servicename(talloc_tos(), lp_sub, snum);
char *remark = lp_comment(p->mem_ctx, lp_sub, snum);
if (remark) {
remark = talloc_sub_full(
- p->mem_ctx, lp_servicename(talloc_tos(), snum),
+ p->mem_ctx, lp_servicename(talloc_tos(), lp_sub, snum),
get_current_username(), lp_path(talloc_tos(), lp_sub, snum),
p->session_info->unix_token->uid, get_current_username(),
"", remark);
{
const struct loadparm_substitution *lp_sub =
loadparm_s3_global_substitution();
- const char *net_name = lp_servicename(talloc_tos(), snum);
+ const char *net_name = lp_servicename(talloc_tos(), lp_sub, snum);
char *path = NULL;
struct security_descriptor *sd = NULL;
struct sec_desc_buf *sd_buf = NULL;
if (remark) {
remark = talloc_sub_full(
- p->mem_ctx, lp_servicename(talloc_tos(), snum),
+ p->mem_ctx, lp_servicename(talloc_tos(), lp_sub, snum),
get_current_username(), lp_path(talloc_tos(), lp_sub, snum),
p->session_info->unix_token->uid, get_current_username(),
"", remark);
string_replace(path, '/', '\\');
}
- sd = get_share_security(ctx, lp_servicename(talloc_tos(), snum), &sd_size);
+ sd = get_share_security(ctx, lp_servicename(talloc_tos(), lp_sub, snum), &sd_size);
sd_buf = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
if (remark) {
remark = talloc_sub_full(
- p->mem_ctx, lp_servicename(talloc_tos(), snum),
+ p->mem_ctx, lp_servicename(talloc_tos(), lp_sub, snum),
get_current_username(), lp_path(talloc_tos(), lp_sub, snum),
p->session_info->unix_token->uid, get_current_username(),
"", remark);
struct sec_desc_buf **r,
int snum)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
struct security_descriptor *sd;
struct sec_desc_buf *sd_buf = NULL;
size_t sd_size;
TALLOC_CTX *ctx = p->mem_ctx;
- sd = get_share_security(ctx, lp_servicename(talloc_tos(), snum), &sd_size);
+ sd = get_share_security(ctx, lp_servicename(talloc_tos(), lp_sub, snum), &sd_size);
if (sd) {
sd_buf = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
}
static bool is_hidden_share(int snum)
{
- const char *net_name = lp_servicename(talloc_tos(), snum);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+ const char *net_name = lp_servicename(talloc_tos(), lp_sub, snum);
return (net_name[strlen(net_name) - 1] == '$') ? True : False;
}
static bool is_enumeration_allowed(struct pipes_struct *p,
int snum)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+
if (!lp_access_based_share_enum(snum)) {
return true;
}
}
return share_access_check(p->session_info->security_token,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
FILE_READ_DATA, NULL);
}
uint32_t *total_entries,
bool all_shares)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
uint32_t num_entries = 0;
uint32_t alloc_entries = 0;
int num_services = 0;
is_enumeration_allowed(p, snum) &&
(all_shares || !is_hidden_share(snum)) ) {
DEBUG(10, ("counting service %s\n",
- lp_servicename(talloc_tos(), snum) ? lp_servicename(talloc_tos(), snum) : "(null)"));
+ lp_servicename(talloc_tos(), lp_sub, snum) ? lp_servicename(talloc_tos(), lp_sub, snum) : "(null)"));
allowed[snum] = true;
num_entries++;
} else {
DEBUG(10, ("NOT counting service %s\n",
- lp_servicename(talloc_tos(), snum) ? lp_servicename(talloc_tos(), snum) : "(null)"));
+ lp_servicename(talloc_tos(), lp_sub, snum) ? lp_servicename(talloc_tos(), lp_sub, snum) : "(null)"));
}
}
size_t sd_size;
NTSTATUS status;
- old_sd = get_share_security(p->mem_ctx, lp_servicename(talloc_tos(), snum), &sd_size);
+ old_sd = get_share_security(p->mem_ctx, lp_servicename(talloc_tos(), lp_sub, snum), &sd_size);
if (old_sd && !security_descriptor_equal(old_sd, psd)) {
status = set_share_security(share_name, psd);
void conn_force_tdis(struct smbd_server_connection *sconn, const char *sharename)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
connection_struct *conn, *next;
bool close_all = false;
if (close_all) {
do_close = true;
- } else if (strequal(lp_servicename(talloc_tos(), SNUM(conn)),
+ } else if (strequal(lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
sharename)) {
DEBUG(1, ("conn_force_tdis: Forcing close of "
"share '%s' (wire_id=0x%08x)\n",
bool connections_snum_used(struct smbd_server_connection *unused, int snum)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
int active;
- active = count_current_connections(lp_servicename(talloc_tos(), snum),
+ active = count_current_connections(lp_servicename(talloc_tos(), lp_sub, snum),
true);
if (active > 0) {
return true;
files_struct *fsp,
bool sparse)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
uint32_t old_dosmode;
uint32_t new_dosmode;
NTSTATUS status;
"on readonly share[%s]\n",
smb_fname_str_dbg(fsp->fsp_name),
sparse,
- lp_servicename(talloc_tos(), SNUM(conn))));
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn))));
return NT_STATUS_MEDIA_WRITE_PROTECTED;
}
files_struct **result,
DATA_BLOB *new_cookie)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
struct share_mode_lock *lck;
struct share_mode_entry e;
struct files_struct *fsp = NULL;
{
DEBUG(5, ("vfs_default_durable_reconnect: denying durable "
"share[%s] is not writeable anymore\n",
- lp_servicename(talloc_tos(), SNUM(conn))));
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn))));
TALLOC_FREE(lck);
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
uint32_t access_mask,
files_struct **result)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
files_struct *fsp = NULL;
NTSTATUS status;
if (!NT_STATUS_IS_OK(status)) {
DEBUG(10, ("open_fake_file: smbd_calculate_access_mask "
"on service[%s] file[%s] returned %s\n",
- lp_servicename(talloc_tos(), SNUM(conn)),
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
smb_fname_str_dbg(smb_fname),
nt_errstr(status)));
return status;
if (geteuid() != sec_initial_uid()) {
DEBUG(3, ("open_fake_file_shared: access_denied to "
"service[%s] file[%s] user[%s]\n",
- lp_servicename(talloc_tos(), SNUM(conn)),
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
smb_fname_str_dbg(smb_fname),
conn->session_info->unix_info->unix_name));
return NT_STATUS_ACCESS_DENIED;
int snum, char **dst, char *src, int *p_space_remaining)
{
TALLOC_CTX *ctx = talloc_tos();
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
char *buf = NULL;
int l;
*p_space_remaining = 0;
return 0;
}
- buf = talloc_string_sub(ctx, buf,"%S", lp_servicename(ctx, snum));
+ buf = talloc_string_sub(ctx, buf,"%S", lp_servicename(ctx, lp_sub, snum));
if (!buf) {
*p_space_remaining = 0;
return 0;
}
buf = talloc_sub_full(ctx,
- lp_servicename(ctx, SNUM(conn)),
+ lp_servicename(ctx, lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name,
conn->connectpath,
conn->session_info->unix_token->gid,
static int StrlenExpanded(connection_struct *conn, int snum, char *s)
{
TALLOC_CTX *ctx = talloc_tos();
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
char *buf = NULL;
if (!s) {
return 0;
if (!buf) {
return 0;
}
- buf = talloc_string_sub(ctx,buf,"%S",lp_servicename(ctx, snum));
+ buf = talloc_string_sub(ctx,buf,"%S",lp_servicename(ctx, lp_sub, snum));
if (!buf) {
return 0;
}
buf = talloc_sub_full(ctx,
- lp_servicename(ctx, SNUM(conn)),
+ lp_servicename(ctx, lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name,
conn->connectpath,
conn->session_info->unix_token->gid,
baseaddr = p;
}
- push_ascii(p,lp_servicename(talloc_tos(), snum),13, STR_TERMINATE);
+ push_ascii(p,lp_servicename(talloc_tos(), lp_sub, snum),13, STR_TERMINATE);
if (uLevel > 0) {
int type;
int *rdata_len,
int *rparam_len )
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
char *str2 = skip_string(param,tpscnt,str1);
char *p = skip_string(param,tpscnt,str2);
if (!(lp_browseable(i) && lp_snum_ok(i))) {
continue;
}
- push_ascii_fstring(servicename_dos, lp_servicename(talloc_tos(), i));
+ push_ascii_fstring(servicename_dos, lp_servicename(talloc_tos(), lp_sub, i));
/* Maximum name length = 13. */
if( lp_browseable( i ) && lp_snum_ok( i ) && (strlen(servicename_dos) < 13)) {
total++;
}
push_ascii_fstring(servicename_dos,
- lp_servicename(talloc_tos(), i));
+ lp_servicename(talloc_tos(), lp_sub, i));
if (lp_browseable(i) && lp_snum_ok(i) && (strlen(servicename_dos) < 13)) {
if (fill_share_info( conn,i,uLevel,&p,&f_len,&p2,&s_len,*rdata ) < 0) {
break;
struct dfs_path *pdp, /* MUST BE TALLOCED */
bool *ppath_contains_wcard)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
char *pathname_local;
char *p,*temp;
char *servicename;
}
/* Is this really our servicename ? */
- if (conn && !( strequal(servicename, lp_servicename(talloc_tos(), SNUM(conn)))
+ if (conn && !( strequal(servicename, lp_servicename(talloc_tos(), lp_sub, SNUM(conn)))
|| (strequal(servicename, HOMES_NAME)
- && strequal(lp_servicename(talloc_tos(), SNUM(conn)),
+ && strequal(lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
get_current_username()) )) ) {
DEBUG(10,("parse_dfs_path: %s is not our servicename\n",
servicename));
char **pp_path_out,
bool *ppath_contains_wcard)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
NTSTATUS status;
bool search_wcard_flag = (ucf_flags &
(UCF_COND_ALLOW_WCARD_LCOMP|UCF_ALWAYS_ALLOW_WCARD_LCOMP));
return NT_STATUS_OK;
}
- if (!( strequal(pdp->servicename, lp_servicename(talloc_tos(), SNUM(conn)))
+ if (!( strequal(pdp->servicename, lp_servicename(talloc_tos(), lp_sub, SNUM(conn)))
|| (strequal(pdp->servicename, HOMES_NAME)
- && strequal(lp_servicename(talloc_tos(), SNUM(conn)),
+ && strequal(lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
conn->session_info->unix_info->sanitized_username) )) ) {
/* The given sharename doesn't match this connection. */
const char *dname = NULL;
char *talloced = NULL;
const char *connect_path = lp_path(frame, lp_sub, snum);
- char *service_name = lp_servicename(frame, snum);
+ char *service_name = lp_servicename(frame, lp_sub, snum);
const char *msdfs_proxy = lp_msdfs_proxy(frame, lp_sub, snum);
struct conn_struct_tos *c = NULL;
connection_struct *conn = NULL;
uint32_t data_count,
uint32_t max_data_count)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
NTSTATUS nt_status = NT_STATUS_OK;
char *params = *ppparams;
char *pdata = *ppdata;
/* access check */
if (get_current_uid(conn) != sec_initial_uid()) {
DEBUG(1,("get_user_quota: access_denied service [%s] user "
- "[%s]\n", lp_servicename(talloc_tos(), SNUM(conn)),
+ "[%s]\n", lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name));
nt_status = NT_STATUS_ACCESS_DENIED;
goto error;
uint32_t data_count,
uint32_t max_data_count)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
char *params = *ppparams;
char *pdata = *ppdata;
int data_len=0,param_len=0;
/* access check */
if (get_current_uid(conn) != sec_initial_uid()) {
DEBUG(1,("set_user_quota: access_denied service [%s] user "
- "[%s]\n", lp_servicename(talloc_tos(), SNUM(conn)),
+ "[%s]\n", lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name));
status = NT_STATUS_ACCESS_DENIED;
goto error;
struct smb_filename *smb_dname,
uint32_t file_attributes)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
mode_t mode;
char *parent_dir = NULL;
NTSTATUS status;
if (!CAN_WRITE(conn) || (access_mask & ~(conn->share_access))) {
DEBUG(5,("mkdir_internal: failing share access "
- "%s\n", lp_servicename(talloc_tos(), SNUM(conn))));
+ "%s\n", lp_servicename(talloc_tos(), lp_sub, SNUM(conn))));
return NT_STATUS_ACCESS_DENIED;
}
static connection_struct *switch_message(uint8_t type, struct smb_request *req)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
int flags;
uint64_t session_tag;
connection_struct *conn = NULL;
if (req->cmd != SMBtrans2 && req->cmd != SMBtranss2) {
DEBUG(1,("service[%s] requires encryption"
"%s ACCESS_DENIED. mid=%llu\n",
- lp_servicename(talloc_tos(), SNUM(conn)),
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
smb_fn_name(type),
(unsigned long long)req->mid));
reply_nterror(req, NT_STATUS_ACCESS_DENIED);
void reply_tcon_and_X(struct smb_request *req)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
connection_struct *conn = req->conn;
const char *service = NULL;
TALLOC_CTX *ctx = talloc_tos();
if (lp_msdfs_root(SNUM(conn)) && lp_host_msdfs()) {
DEBUG(2,("Serving %s as a Dfs root\n",
- lp_servicename(ctx, SNUM(conn)) ));
+ lp_servicename(ctx, lp_sub, SNUM(conn)) ));
optional_support |= SMB_SHARE_IN_DFS;
}
void reply_ioctl(struct smb_request *req)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
connection_struct *conn = req->conn;
uint16_t device;
uint16_t function;
status = srvstr_push((char *)req->outbuf, req->flags2,
p+18,
lp_servicename(talloc_tos(),
+ lp_sub,
SNUM(conn)),
13, STR_TERMINATE|STR_ASCII, &len);
if (!NT_STATUS_IS_OK(status)) {
void reply_printqueue(struct smb_request *req)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
connection_struct *conn = req->conn;
int max_count;
int start_index;
TALLOC_CTX *mem_ctx = talloc_tos();
NTSTATUS status;
WERROR werr;
- const char *sharename = lp_servicename(mem_ctx, SNUM(conn));
+ const char *sharename = lp_servicename(mem_ctx, lp_sub, SNUM(conn));
struct rpc_pipe_client *cli = NULL;
struct dcerpc_binding_handle *b = NULL;
struct policy_handle handle;
const char *pdev,
NTSTATUS *pstatus)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
struct smbXsrv_tcon *tcon;
NTSTATUS status;
struct connection_struct *conn;
return NULL;
}
- tcon->global->share_name = lp_servicename(tcon->global, SNUM(conn));
+ tcon->global->share_name = lp_servicename(tcon->global, lp_sub, SNUM(conn));
if (tcon->global->share_name == NULL) {
conn_free(conn);
TALLOC_FREE(tcon);
bool user_ok_token(const char *username, const char *domain,
const struct security_token *token, int snum)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+
if (lp_invalid_users(snum) != NULL) {
if (token_contains_name_in_list(username, domain,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
token,
lp_invalid_users(snum))) {
DEBUG(10, ("User %s in 'invalid users'\n", username));
if (lp_valid_users(snum) != NULL) {
if (!token_contains_name_in_list(username, domain,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
token,
lp_valid_users(snum))) {
DEBUG(10, ("User %s not in 'valid users'\n",
}
DEBUG(10, ("user_ok_token: share %s is ok for unix user %s\n",
- lp_servicename(talloc_tos(), snum), username));
+ lp_servicename(talloc_tos(), lp_sub, snum), username));
return True;
}
const struct security_token *token,
connection_struct *conn)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
int snum = SNUM(conn);
bool result = conn->read_only;
if (lp_read_list(snum) != NULL) {
if (token_contains_name_in_list(username, domain,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
token,
lp_read_list(snum))) {
result = True;
if (lp_write_list(snum) != NULL) {
if (token_contains_name_in_list(username, domain,
- lp_servicename(talloc_tos(), snum),
+ lp_servicename(talloc_tos(), lp_sub, snum),
token,
lp_write_list(snum))) {
result = False;
}
DEBUG(10,("is_share_read_only_for_user: share %s is %s for unix user "
- "%s\n", lp_servicename(talloc_tos(), snum),
+ "%s\n", lp_servicename(talloc_tos(), lp_sub, snum),
result ? "read-only" : "read-write", username));
return result;
snum = compat_vuser->homes_snum;
} else if ((compat_vuser->homes_snum != -1)
&& strequal(service,
- lp_servicename(talloc_tos(), compat_vuser->homes_snum))) {
+ lp_servicename(talloc_tos(), lp_sub, compat_vuser->homes_snum))) {
snum = compat_vuser->homes_snum;
} else {
snum = find_service(talloc_tos(), service, &service);
}
tcon->global->share_name = lp_servicename(tcon->global,
+ lp_sub,
SNUM(compat_conn));
if (tcon->global->share_name == NULL) {
conn_free(compat_conn);
unsigned char *create_volume_objectid(connection_struct *conn, unsigned char objid[16])
{
- E_md4hash(lp_servicename(talloc_tos(), SNUM(conn)),objid);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+
+ E_md4hash(lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),objid);
return objid;
}
char **ppdata,
int *ret_data_len)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
char *pdata, *end_data;
int data_len = 0;
size_t len = 0;
* Add volume serial number - hash of a combination of
* the called hostname and the service name.
*/
- SIVAL(pdata,0,str_checksum(lp_servicename(talloc_tos(), snum)) ^ (str_checksum(get_local_machine_name())<<16) );
+ SIVAL(pdata,0,str_checksum(lp_servicename(talloc_tos(), lp_sub, snum)) ^ (str_checksum(get_local_machine_name())<<16) );
/*
* Win2k3 and previous mess this up by sending a name length
* one byte short. I believe only older clients (OS/2 Win9x) use
* Add volume serial number - hash of a combination of
* the called hostname and the service name.
*/
- SIVAL(pdata,8,str_checksum(lp_servicename(talloc_tos(), snum)) ^
+ SIVAL(pdata,8,str_checksum(lp_servicename(talloc_tos(), lp_sub, snum)) ^
(str_checksum(get_local_machine_name())<<16));
/* Max label len is 32 characters. */
DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
(int)strlen(vname),vname,
- lp_servicename(talloc_tos(), snum)));
+ lp_servicename(talloc_tos(), lp_sub, snum)));
if (max_data_bytes >= 24 && data_len > max_data_bytes) {
/* the client only requested a portion of the
volume label */
if (get_current_uid(conn) != 0) {
DEBUG(0,("get_user_quota: access_denied "
"service [%s] user [%s]\n",
- lp_servicename(talloc_tos(), SNUM(conn)),
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name));
return NT_STATUS_ACCESS_DENIED;
}
status = vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE,
NULL, "as);
if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(talloc_tos(), SNUM(conn))));
+ DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(talloc_tos(), lp_sub, SNUM(conn))));
return status;
}
data_len = 48;
DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",
- lp_servicename(talloc_tos(), SNUM(conn))));
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn))));
/* Unknown1 24 NULL bytes*/
SBIG_UINT(pdata,0,(uint64_t)0);
return NT_STATUS_INVALID_LEVEL;
#endif /* EOPNOTSUPP */
} else {
- DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(talloc_tos(), SNUM(conn))));
+ DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(talloc_tos(), lp_sub, SNUM(conn))));
return NT_STATUS_DOS(ERRSRV, ERRerror);
}
break;
files_struct *fsp,
const DATA_BLOB *qdata)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
NTSTATUS status;
SMB_NTQUOTA_STRUCT quotas;
/* access check */
if ((get_current_uid(conn) != 0) || !CAN_WRITE(conn)) {
DEBUG(3, ("set_fsquota: access_denied service [%s] user [%s]\n",
- lp_servicename(talloc_tos(), SNUM(conn)),
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
conn->session_info->unix_info->unix_name));
return NT_STATUS_ACCESS_DENIED;
}
/* now set the quotas */
if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, "as)!=0) {
DEBUG(1, ("vfs_set_ntquota() failed for service [%s]\n",
- lp_servicename(talloc_tos(), SNUM(conn))));
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn))));
status = map_nt_error_from_unix(errno);
} else {
status = NT_STATUS_OK;
char **ppdata, int total_data,
unsigned int max_data_bytes)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
struct smbXsrv_connection *xconn = req->xconn;
char *pdata = *ppdata;
char *params = *pparams;
uint16_t info_level;
DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",
- lp_servicename(talloc_tos(), SNUM(conn))));
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn))));
/* */
if (total_params < 4) {
char **ppdata, int total_data,
unsigned int max_data_bytes)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
char *pdata = *ppdata;
files_struct *fsp = file_fsp(req, SVAL(req->vwv+15, 0));
NTSTATUS status;
return;
}
status = srvstr_push(pdata, req->flags2, pdata+18,
- lp_servicename(talloc_tos(), SNUM(conn)), 13,
+ lp_servicename(talloc_tos(), lp_sub, SNUM(conn)), 13,
STR_ASCII|STR_TERMINATE, &len); /* Service name */
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
static NTSTATUS cmd_connect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
{
- SMB_VFS_CONNECT(vfs->conn, lp_servicename(talloc_tos(), SNUM(vfs->conn)), "vfstest");
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+
+ SMB_VFS_CONNECT(vfs->conn, lp_servicename(talloc_tos(), lp_sub, SNUM(vfs->conn)), "vfstest");
return NT_STATUS_OK;
}
for (i=0; i<lp_numservices(); i++) {
TALLOC_CTX *frame = talloc_stackframe();
- const char *service = lp_servicename(frame, i);
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
+ const char *service = lp_servicename(frame, lp_sub, i);
if (service == NULL) {
continue;
*/
static void do_per_share_checks(int s)
{
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
const char **deny_list = lp_hosts_deny(s);
const char **allow_list = lp_hosts_allow(s);
const char **vfs_objects = NULL;
"(%s) for service %s.\n\n",
hasstar ? *hasstar : *hasquery,
deny_list[i],
- lp_servicename(talloc_tos(), s));
+ lp_servicename(talloc_tos(), lp_sub, s));
}
}
}
"list (%s) for service %s.\n\n",
hasstar ? *hasstar : *hasquery,
allow_list[i],
- lp_servicename(talloc_tos(), s));
+ lp_servicename(talloc_tos(), lp_sub, s));
}
}
}
fprintf(stderr, "Invalid combination of parameters for service "
"%s. Level II oplocks can only be set if oplocks "
"are also set.\n\n",
- lp_servicename(talloc_tos(), s));
+ lp_servicename(talloc_tos(), lp_sub, s));
}
if (!lp_store_dos_attributes(s) && lp_map_hidden(s)
"Invalid combination of parameters for service %s. Map "
"hidden can only work if create mask includes octal "
"01 (S_IXOTH).\n\n",
- lp_servicename(talloc_tos(), s));
+ lp_servicename(talloc_tos(), lp_sub, s));
}
if (!lp_store_dos_attributes(s) && lp_map_hidden(s)
&& (lp_force_create_mode(s) & S_IXOTH))
"Invalid combination of parameters for service "
"%s. Map hidden can only work if force create mode "
"excludes octal 01 (S_IXOTH).\n\n",
- lp_servicename(talloc_tos(), s));
+ lp_servicename(talloc_tos(), lp_sub, s));
}
if (!lp_store_dos_attributes(s) && lp_map_system(s)
&& !(lp_create_mask(s) & S_IXGRP))
"Invalid combination of parameters for service "
"%s. Map system can only work if create mask includes "
"octal 010 (S_IXGRP).\n\n",
- lp_servicename(talloc_tos(), s));
+ lp_servicename(talloc_tos(), lp_sub, s));
}
if (!lp_store_dos_attributes(s) && lp_map_system(s)
&& (lp_force_create_mode(s) & S_IXGRP))
"Invalid combination of parameters for service "
"%s. Map system can only work if force create mode "
"excludes octal 010 (S_IXGRP).\n\n",
- lp_servicename(talloc_tos(), s));
+ lp_servicename(talloc_tos(), lp_sub, s));
}
if (lp_printing(s) == PRINT_CUPS && *(lp_print_command(s)) != '\0') {
fprintf(stderr,
"Warning: Service %s defines a print command, but "
"parameter is ignored when using CUPS libraries.\n\n",
- lp_servicename(talloc_tos(), s));
+ lp_servicename(talloc_tos(), lp_sub, s));
}
vfs_objects = lp_vfs_objects(s);
int main(int argc, const char *argv[])
{
const char *config_file = get_dyn_CONFIGFILE();
+ const struct loadparm_substitution *lp_sub =
+ loadparm_s3_global_substitution();
int s;
static int silent_mode = False;
static int show_all_parameters = False;
if (allow_access(lp_hosts_deny(-1), lp_hosts_allow(-1), cname, caddr)
&& allow_access(lp_hosts_deny(s), lp_hosts_allow(s), cname, caddr)) {
fprintf(stderr,"Allow connection from %s (%s) to %s\n",
- cname,caddr,lp_servicename(talloc_tos(), s));
+ cname,caddr,lp_servicename(talloc_tos(), lp_sub, s));
} else {
fprintf(stderr,"Deny connection from %s (%s) to %s\n",
- cname,caddr,lp_servicename(talloc_tos(), s));
+ cname,caddr,lp_servicename(talloc_tos(), lp_sub, s));
}
}
}
projects / thirdparty / samba.git / commitdiff
