result = cli_full_connection(&cli,
- global_myname(),
+ lp_netbios_name(),
server,
NULL, 0,
service, "A:",
DEBUG(0,("attempt_machine_password_change: unable to lock "
"the machine account password for machine %s in "
"domain %s.\n",
- global_myname(), lp_workgroup() ));
+ lp_netbios_name(), lp_workgroup() ));
return;
}
trust_passwd_hash, &lct, NULL)) {
DEBUG(0,("attempt_machine_password_change: unable to read the "
"machine account password for %s in domain %s.\n",
- global_myname(), lp_workgroup()));
+ lp_netbios_name(), lp_workgroup()));
TALLOC_FREE(lock);
return;
}
}
/* Attempt connection */
- result = cli_full_connection(cli, global_myname(), dc_name, dc_ss, 0,
+ result = cli_full_connection(cli, lp_netbios_name(), dc_name, dc_ss, 0,
"IPC$", "IPC", "", "", "", 0, Undefined);
if (!NT_STATUS_IS_OK(result)) {
result = rpccli_netlogon_setup_creds(netlogon_pipe,
dc_name, /* server name */
domain, /* domain */
- global_myname(), /* client name */
+ lp_netbios_name(), /* client name */
account_name, /* machine account name */
machine_pwd,
sec_chan_type,
p, p,
user_info->logon_parameters, /* flags such as 'allow
* workstation logon' */
- global_myname(), /* server name */
+ lp_netbios_name(), /* server name */
user_info->client.account_name, /* user name logging on. */
user_info->client.domain_name, /* domain name */
user_info->workstation_name, /* workstation name */
DEBUG(10, ("default_nc = %s\n", default_nc));
myname = talloc_asprintf_strupper_m(talloc_tos(), "%s$",
- global_myname());
+ lp_netbios_name());
if (myname == NULL) {
DEBUG(10, ("talloc failed\n"));
status = NT_STATUS_NO_MEMORY;
dump_data(10, machine_password, 16);
status = rpccli_netlogon_setup_creds(
- p, global_myname(), lp_workgroup(), global_myname(),
- global_myname(), machine_password, SEC_CHAN_BDC, &neg_flags);
+ p, lp_netbios_name(), lp_workgroup(), lp_netbios_name(),
+ lp_netbios_name(), machine_password, SEC_CHAN_BDC, &neg_flags);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(10, ("rpccli_netlogon_setup_creds failed: %s\n",
is_standalone = false;
}
- netbios_name = global_myname();
+ netbios_name = lp_netbios_name();
netbios_domain = lp_workgroup();
/* This should be a 'netbios domain -> DNS domain' mapping */
dns_domain = get_mydnsdomname(talloc_tos());
}
status = cli_connect_nb(desthost, &dest_ss, 0, 0x20,
- global_myname(), Undefined, &cli);
+ lp_netbios_name(), Undefined, &cli);
if (NT_STATUS_IS_OK(status)) {
DEBUG(3,("connected to password server %s\n",desthost));
connected_ok = True;
baduser = talloc_asprintf(mem_ctx,
"%s%s",
INVALID_USER_PREFIX,
- global_myname());
+ lp_netbios_name());
if (!baduser) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_MEMORY;
}
- status = samu_to_SamInfo3(result, sampass, global_myname(),
+ status = samu_to_SamInfo3(result, sampass, lp_netbios_name(),
&result->info3, &result->extra);
TALLOC_FREE(sampass);
if (!NT_STATUS_IS_OK(status)) {
struct auth_serversupplied_info *server_info;
static const char zeros[16] = {0};
const char *guest_account = lp_guestaccount();
- const char *domain = global_myname();
+ const char *domain = lp_netbios_name();
struct netr_SamInfo3 info3;
TALLOC_CTX *tmp_ctx;
NTSTATUS status;
return false;
}
truncname[ulen-1] = '\0';
- ret = strequal(truncname, global_myname());
+ ret = strequal(truncname, lp_netbios_name());
SAFE_FREE(truncname);
return ret;
}
return NT_STATUS_NO_SUCH_USER;
}
- status = samu_to_SamInfo3(result, sampass, global_myname(),
+ status = samu_to_SamInfo3(result, sampass, lp_netbios_name(),
&result->info3, &result->extra);
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(result);
static int port = 0;
static char *service;
static char *desthost;
-static char *calling_name;
static bool grepable = false;
static char *cmdstr = NULL;
const char *cmd_ptr = NULL;
status = cli_connect_nb(desthost, have_ip ? &dest_ss : NULL,
port ? port : 139, name_type,
- calling_name, Undefined, &cli);
+ lp_netbios_name(), Undefined, &cli);
if (!NT_STATUS_IS_OK(status)) {
d_printf("Connection to %s failed. Error %s\n", desthost, nt_errstr(status));
return 1;
exit(ENOMEM);
}
- /* initialize the netbios name so we can determine whether or
- not it was set by a command line option */
-
- set_global_myname( "" );
-
/* set default debug level to 1 regardless of what smb.conf sets */
setup_logging( "smbclient", DEBUG_DEFAULT_STDERR );
load_case_tables();
poptGetArg(pc));
}
- calling_name = talloc_strdup(frame, global_myname() );
- if (!calling_name) {
- exit(ENOMEM);
- }
-
if ( override_logfile )
setup_logging( lp_logfile(), DEBUG_FILE );
}
}
- if ( strlen(calling_name) != 0 ) {
- set_global_myname( calling_name );
- } else {
- TALLOC_FREE(calling_name);
- calling_name = talloc_strdup(frame, global_myname() );
- }
-
smb_encrypt = get_cmdline_auth_info_smb_encrypt(auth_info);
if (!init_names()) {
fprintf(stderr, "init_names() failed\n");
struct passwd *Get_Pwnam_alloc(TALLOC_CTX *mem_ctx, const char *user);
/* The following definitions come from lib/util_names.c */
-void gfree_netbios_names(void);
-bool set_global_myname(const char *myname);
-const char *global_myname(void);
-bool set_global_myworkgroup(const char *myworkgroup);
const char *get_global_sam_name(void);
/* The following definitions come from lib/util.c */
const char *lp_passwordserver(void);
const char *lp_name_resolve_order(void);
const char *lp_netbios_scope(void);
+const char *lp_netbios_name(void);
const char *lp_workgroup(void);
const char *lp_realm(void);
const char *lp_dnsdomain(void);
struct SERVER_INFO_101 i;
i.sv101_platform_id = PLATFORM_ID_NT;
- i.sv101_name = global_myname();
+ i.sv101_name = lp_netbios_name();
i.sv101_version_major = lp_major_announce_version();
i.sv101_version_minor = lp_minor_announce_version();
i.sv101_type = lp_default_server_announce();
case 'n':
if (arg) {
- set_global_myname(arg);
+ lp_set_cmdline("netbios name", arg);
}
break;
const char *get_local_machine_name(void)
{
if (!local_machine || !*local_machine) {
- return global_myname();
+ return lp_netbios_name();
}
return local_machine;
if (local_machine_name && *local_machine_name) {
server_name = talloc_strdup(ctx, local_machine_name);
} else {
- server_name = talloc_strdup(ctx, global_myname());
+ server_name = talloc_strdup(ctx, lp_netbios_name());
}
if (!server_name) {
if (local_machine_name && *local_machine_name) {
a_string = realloc_string_sub(a_string, "%L", local_machine_name);
} else {
- a_string = realloc_string_sub(a_string, "%L", global_myname());
+ a_string = realloc_string_sub(a_string, "%L", lp_netbios_name());
}
break;
case 'N':
return false;
}
- if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
+ if (asprintf(&account, "%s$@%s", lp_netbios_name(), lp_realm()) < 0) {
return false;
}
Definitions for all names.
***********************************************************************/
-static char *smb_myname;
-static char *smb_myworkgroup;
static int smb_num_netbios_names;
static char **smb_my_netbios_names;
void gfree_names(void)
{
- gfree_netbios_names();
free_netbios_names_array();
free_local_machine_name();
}
for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
;
- if ( global_myname() && *global_myname())
+ if ( lp_netbios_name() && *lp_netbios_name())
namecount++;
/* Allocate space for the netbios aliases */
/* Use the global_myname string first */
namecount=0;
- if ( global_myname() && *global_myname()) {
- set_my_netbios_names( global_myname(), namecount );
+ if ( lp_netbios_name() && *lp_netbios_name()) {
+ set_my_netbios_names( lp_netbios_name(), namecount );
namecount++;
}
{
int n;
- if (global_myname() == NULL || *global_myname() == '\0') {
- if (!set_global_myname(myhostname())) {
- DEBUG( 0, ( "init_names: malloc fail.\n" ) );
- return False;
- }
- }
-
if (!set_netbios_aliases(lp_netbios_aliases())) {
DEBUG( 0, ( "init_names: malloc fail.\n" ) );
return False;
}
- set_local_machine_name(global_myname(),false);
+ set_local_machine_name(lp_netbios_name(),false);
DEBUG( 5, ("Netbios name list:-\n") );
for( n=0; my_netbios_names(n); n++ ) {
return( True );
}
-/***********************************************************************
- Allocate and set myname. Ensure upper case.
-***********************************************************************/
-
-bool set_global_myname(const char *myname)
-{
- SAFE_FREE(smb_myname);
- smb_myname = SMB_STRDUP(myname);
- if (!smb_myname)
- return False;
- strupper_m(smb_myname);
- return True;
-}
-
-const char *global_myname(void)
-{
- return smb_myname;
-}
-
/******************************************************************
get the default domain/netbios name to be used when dealing
with our passdb list of accounts
if (IS_DC) {
return lp_workgroup();
}
- return global_myname();
+ return lp_netbios_name();
}
-void gfree_netbios_names(void)
-{
- SAFE_FREE( smb_myname );
- SAFE_FREE( smb_myworkgroup );
-}
}
/* Optimize for the common case */
- if (strequal(servername, global_myname())) {
+ if (strequal(servername, lp_netbios_name())) {
return true;
}
NT_STATUS_HAVE_NO_MEMORY(auth_princ);
local_service = talloc_asprintf(mem_ctx, "%s$@%s",
- global_myname(), lp_realm());
+ lp_netbios_name(), lp_realm());
NT_STATUS_HAVE_NO_MEMORY(local_service);
ret = kerberos_kinit_password_ext(auth_princ,
{
fstring salt;
- fstr_sprintf( salt, "host/%s.%s@", global_myname(), lp_realm() );
+ fstr_sprintf( salt, "host/%s.%s@", lp_netbios_name(), lp_realm() );
strlower_m( salt );
fstrcat( salt, lp_realm() );
goto out;
}
- my_fqdn = ads_get_dnshostname(ads, tmpctx, global_myname());
+ my_fqdn = ads_get_dnshostname(ads, tmpctx, lp_netbios_name());
if (!my_fqdn) {
DEBUG(0, (__location__ ": unable to determine machine "
"account's dns name in AD!\n"));
goto out;
}
- machine_name = ads_get_samaccountname(ads, tmpctx, global_myname());
+ machine_name = ads_get_samaccountname(ads, tmpctx, lp_netbios_name());
if (!machine_name) {
DEBUG(0, (__location__ ": unable to determine machine "
"account's short name in AD!\n"));
"'%s'\n", princ_s));
aderr = ads_add_service_principal_name(ads,
- global_myname(), my_fqdn, srvPrinc);
+ lp_netbios_name(), my_fqdn, srvPrinc);
if (!ADS_ERR_OK(aderr)) {
DEBUG(1, (__location__ ": failed to "
"ads_add_service_principal_name.\n"));
}
}
- kvno = (krb5_kvno)ads_get_machine_kvno(ads, global_myname());
+ kvno = (krb5_kvno)ads_get_machine_kvno(ads, lp_netbios_name());
if (kvno == -1) {
/* -1 indicates failure, everything else is OK */
DEBUG(1, (__location__ ": ads_get_machine_kvno failed to "
goto out;
}
- kvno = (krb5_kvno)ads_get_machine_kvno(ads, global_myname());
+ kvno = (krb5_kvno)ads_get_machine_kvno(ads, lp_netbios_name());
if (kvno == -1) {
/* -1 indicates a failure */
DEBUG(1, (__location__ ": Error determining the kvno.\n"));
goto out;
}
- aderr = ads_clear_service_principal_names(ads, global_myname());
+ aderr = ads_clear_service_principal_names(ads, lp_netbios_name());
if (!ADS_ERR_OK(aderr)) {
DEBUG(1, (__location__ ": Error while clearing service "
"principal listings in LDAP.\n"));
goto done;
}
- machine_name = talloc_strdup(tmpctx, global_myname());
+ machine_name = talloc_strdup(tmpctx, lp_netbios_name());
if (!machine_name) {
ret = -1;
goto done;
account_name = lp_workgroup();
} else {
/* always use the sAMAccountName for security = domain */
- /* global_myname()$@REA.LM */
+ /* lp_netbios_name()$@REA.LM */
if ( lp_security() == SEC_DOMAIN ) {
- fstr_sprintf( acct_name, "%s$", global_myname() );
+ fstr_sprintf( acct_name, "%s$", lp_netbios_name() );
account_name = acct_name;
}
else
- /* This looks like host/global_myname()@REA.LM */
+ /* This looks like host/lp_netbios_name()@REA.LM */
account_name = ads->auth.user_name;
}
* clients might want to use for authenticating to the file
* service. We allow name$,{host,cifs}/{name,fqdn,name.REALM}. */
- fstrcpy(my_name, global_myname());
+ fstrcpy(my_name, lp_netbios_name());
my_fqdn[0] = '\0';
- name_to_fqdn(my_fqdn, global_myname());
+ name_to_fqdn(my_fqdn, lp_netbios_name());
err = asprintf(&valid_princ_formats[0],
"%s$@%s", my_name, lp_realm());
krb5_auth_con_setflags( context, auth_context, flags );
}
- if (asprintf(&host_princ_s, "%s$", global_myname()) == -1) {
+ if (asprintf(&host_princ_s, "%s$", lp_netbios_name()) == -1) {
goto out;
}
/* Must use the userPrincipalName value here or sAMAccountName
and not servicePrincipalName; found by Guenther Deschner */
- if (asprintf(&ads->auth.user_name, "%s$", global_myname() ) == -1) {
+ if (asprintf(&ads->auth.user_name, "%s$", lp_netbios_name() ) == -1) {
DEBUG(0,("ads_connect: asprintf fail.\n"));
ads->auth.user_name = NULL;
}
int count = 0;
char *name = NULL;
- status = ads_find_machine_acct(ads, &res, global_myname());
+ status = ads_find_machine_acct(ads, &res, lp_netbios_name());
if (!ADS_ERR_OK(status)) {
DEBUG(0,("ads_get_dnshostname: Failed to find account for %s\n",
- global_myname()));
+ lp_netbios_name()));
goto out;
}
status = ads_find_machine_acct(ads, &res, machine_name);
if (!ADS_ERR_OK(status)) {
DEBUG(0,("ads_get_upn: Failed to find account for %s\n",
- global_myname()));
+ lp_netbios_name()));
goto out;
}
int count = 0;
char *name = NULL;
- status = ads_find_machine_acct(ads, &res, global_myname());
+ status = ads_find_machine_acct(ads, &res, lp_netbios_name());
if (!ADS_ERR_OK(status)) {
DEBUG(0,("ads_get_dnshostname: Failed to find account for %s\n",
- global_myname()));
+ lp_netbios_name()));
goto out;
}
struct ntlmssp_state *ntlmssp_state;
nt_status = ntlmssp_client_start(NULL,
- global_myname(),
+ lp_netbios_name(),
lp_workgroup(),
lp_client_ntlmv2_auth(),
&ntlmssp_state);
talloc_set_destructor(ctx, libnet_destroy_JoinCtx);
- ctx->in.machine_name = talloc_strdup(mem_ctx, global_myname());
+ ctx->in.machine_name = talloc_strdup(mem_ctx, lp_netbios_name());
W_ERROR_HAVE_NO_MEMORY(ctx->in.machine_name);
krb5_cc_env = getenv(KRB5_ENV_CCNAME);
talloc_set_destructor(ctx, libnet_destroy_UnjoinCtx);
- ctx->in.machine_name = talloc_strdup(mem_ctx, global_myname());
+ ctx->in.machine_name = talloc_strdup(mem_ctx, lp_netbios_name());
W_ERROR_HAVE_NO_MEMORY(ctx->in.machine_name);
krb5_cc_env = getenv(KRB5_ENV_CCNAME);
NTSTATUS result, status;
NTSTATUS callback_status;
const char *logon_server = ctx->cli->desthost;
- const char *computername = global_myname();
+ const char *computername = lp_netbios_name();
struct netr_Authenticator credential;
struct netr_Authenticator return_authenticator;
uint16_t restart_state = 0;
sp_ctx->mech = SPNEGO_NTLMSSP;
status = auth_ntlmssp_client_start(sp_ctx,
- global_myname(),
+ lp_netbios_name(),
lp_workgroup(),
lp_client_ntlmv2_auth(),
&sp_ctx->mech_ctx.ntlmssp_state);
char *host_princ_s = NULL;
int err;
- err = asprintf(&host_princ_s, "%s$@%s", global_myname(), lp_realm());
+ err = asprintf(&host_princ_s, "%s$@%s", lp_netbios_name(), lp_realm());
if (err == -1) {
return -1;
}
switch (b->transport) {
case NCACN_NP:
- b->host = talloc_asprintf(b, "\\\\%s", global_myname());
+ b->host = talloc_asprintf(b, "\\\\%s", lp_netbios_name());
if (b->host == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
cli_temp_set_signing(cli);
status = ntlmssp_client_start(state,
- global_myname(),
+ lp_netbios_name(),
lp_workgroup(),
lp_client_ntlmv2_auth(),
&state->ntlmssp_state);
my_sid = *sid;
}
- my_acct_name = talloc_asprintf(talloc_tos(), "%s$", global_myname());
+ my_acct_name = talloc_asprintf(talloc_tos(), "%s$", lp_netbios_name());
if (my_acct_name == NULL) {
goto fail;
}
s = &packet.req.logon;
s->request_count = 0;
- s->computer_name = global_myname();
+ s->computer_name = lp_netbios_name();
s->user_name = my_acct_name;
s->mailslot_name = my_mailslot;
s->acct_control = ACB_WSTRUST;
ret = cli_prep_mailslot(false, NBT_MAILSLOT_NTLOGON, 0,
(char *)blob.data, blob.length,
- global_myname(), 0, domain_name, 0x1c,
+ lp_netbios_name(), 0, domain_name, 0x1c,
dc_ss, dgm_id, p);
fail:
TALLOC_FREE(frame);
return NT_STATUS_NO_MEMORY;
}
status = ntlmssp_client_start(NULL,
- global_myname(),
+ lp_netbios_name(),
lp_workgroup(),
lp_client_ntlmv2_auth(),
&es->s.ntlmssp_state);
return ENOMEM;
}
- put_name(buf, global_myname(), ' ', 0x20);
+ put_name(buf, lp_netbios_name(), ' ', 0x20);
#if defined(HAVE_MAGIC_IN_KRB5_ADDRESS) && defined(HAVE_ADDRTYPE_IN_KRB5_ADDRESS) /* MIT */
{
* our hostname etc
*/
char *netbios_name;
- if (global_myname()) {
- netbios_name = SMB_STRDUP(global_myname());
+ if (lp_netbios_name()) {
+ netbios_name = SMB_STRDUP(lp_netbios_name());
} else {
/*
* Hmmm, I want to get hostname as well, but I am too
zero_sockaddr(&ss);
nt_status = cli_full_connection(&ipc_cli,
- global_myname(), server,
+ lp_netbios_name(), server,
&ss, 0, "IPC$", "?????",
*pp_username,
*pp_workgroup,
state->called_type =
(called_type != -1) ? called_type : 0x20;
state->calling_name =
- (calling_name != NULL) ? calling_name : global_myname();
+ (calling_name != NULL) ? calling_name : lp_netbios_name();
state->calling_type =
(calling_type != -1) ? calling_type : 0x00;
/* setup the anonymous connection */
- status = cli_full_connection( &cli, global_myname(), dc_name, &dc_ss, 0, "IPC$", "IPC",
+ status = cli_full_connection( &cli, lp_netbios_name(), dc_name, &dc_ss, 0, "IPC$", "IPC",
"", "", "", 0, Undefined);
if ( !NT_STATUS_IS_OK(status) )
goto done;
/* if this next call fails, then give up. We can't do
password changes on BDC's --jerry */
- if (!NT_STATUS_IS_OK(cli_full_connection(&cli, global_myname(), dc_name,
+ if (!NT_STATUS_IS_OK(cli_full_connection(&cli, lp_netbios_name(), dc_name,
NULL, 0,
"IPC$", "IPC",
"", "",
/* Set the state back to DOMAIN_NONE. */
work->dom_state = DOMAIN_NONE;
- if((servrec = find_server_in_workgroup( work, global_myname())) == NULL) {
+ if((servrec = find_server_in_workgroup( work, lp_netbios_name())) == NULL) {
DEBUG(0,("become_domain_master_fail: Error - cannot find server %s \
in workgroup %s on subnet %s\n",
- global_myname(), work->work_group, subrec->subnet_name));
+ lp_netbios_name(), work->work_group, subrec->subnet_name));
return;
}
return;
}
- if((servrec = find_server_in_workgroup( work, global_myname())) == NULL) {
+ if((servrec = find_server_in_workgroup( work, lp_netbios_name())) == NULL) {
DEBUG(0,("become_domain_master_stage2: Error - cannot find server %s \
in workgroup %s on subnet %s\n",
- global_myname(), regname, subrec->subnet_name));
+ lp_netbios_name(), regname, subrec->subnet_name));
work->dom_state = DOMAIN_NONE;
return;
}
subrec->work_changed = True;
if( DEBUGLVL( 0 ) ) {
- dbgtext( "*****\n\nSamba server %s ", global_myname() );
+ dbgtext( "*****\n\nSamba server %s ", lp_netbios_name() );
dbgtext( "is now a domain master browser for " );
dbgtext( "workgroup %s ", work->work_group );
dbgtext( "on subnet %s\n\n*****\n", subrec->subnet_name );
will stop us syncing with ourself if we are also
a local master browser. */
- make_nmb_name(&nmbname, global_myname(), 0x20);
+ make_nmb_name(&nmbname, lp_netbios_name(), 0x20);
work->dmb_name = nmbname;
return;
}
- if((servrec = find_server_in_workgroup( work, global_myname())) == NULL) {
+ if((servrec = find_server_in_workgroup( work, lp_netbios_name())) == NULL) {
DEBUG(0,("reset_workgroup_state: Error - cannot find server %s \
in workgroup %s on subnet %s\n",
- global_myname(), work->work_group, subrec->subnet_name));
+ lp_netbios_name(), work->work_group, subrec->subnet_name));
work->mst_state = lp_local_master() ? MST_POTENTIAL : MST_NONE;
return;
}
if( DEBUGLVL( 0 ) ) {
dbgtext( "*****\n\n" );
- dbgtext( "Samba name server %s ", global_myname() );
+ dbgtext( "Samba name server %s ", lp_netbios_name() );
dbgtext( "has stopped being a local master browser " );
dbgtext( "for workgroup %s ", relname );
dbgtext( "on subnet %s\n\n*****\n", subrec->subnet_name );
if( DEBUGLVL( 0 ) ) {
dbgtext( "*****\n\n" );
- dbgtext( "Samba name server %s ", global_myname() );
+ dbgtext( "Samba name server %s ", lp_netbios_name() );
dbgtext( "has stopped being a local master browser " );
dbgtext( "for workgroup %s ", failname );
dbgtext( "on subnet %s\n\n*****\n", subrec->subnet_name );
DEBUG(2,("unbecome_local_master_browser: unbecoming local master for workgroup %s \
on subnet %s\n",work->work_group, subrec->subnet_name));
- if(find_server_in_workgroup( work, global_myname()) == NULL) {
+ if(find_server_in_workgroup( work, lp_netbios_name()) == NULL) {
DEBUG(0,("unbecome_local_master_browser: Error - cannot find server %s \
in workgroup %s on subnet %s\n",
- global_myname(), work->work_group, subrec->subnet_name));
+ lp_netbios_name(), work->work_group, subrec->subnet_name));
work->mst_state = lp_local_master() ? MST_POTENTIAL : MST_NONE;
return;
}
return;
}
- if((servrec = find_server_in_workgroup( work, global_myname())) == NULL) {
+ if((servrec = find_server_in_workgroup( work, lp_netbios_name())) == NULL) {
DEBUG(0,("become_local_master_stage2: Error - cannot find server %s \
in workgroup %s on subnet %s\n",
- global_myname(), regname, subrec->subnet_name));
+ lp_netbios_name(), regname, subrec->subnet_name));
work->mst_state = lp_local_master() ? MST_POTENTIAL : MST_NONE;
return;
}
subrec->work_changed = True;
/* Add this name to the workgroup as local master browser. */
- set_workgroup_local_master_browser_name( work, global_myname());
+ set_workgroup_local_master_browser_name( work, lp_netbios_name());
/* Count the number of servers we have on our list. If it's
less than 10 (just a heuristic) request the servers
if( DEBUGLVL( 0 ) ) {
dbgtext( "*****\n\n" );
- dbgtext( "Samba name server %s ", global_myname() );
+ dbgtext( "Samba name server %s ", lp_netbios_name() );
dbgtext( "is now a local master browser " );
dbgtext( "for workgroup %s ", work->work_group );
dbgtext( "on subnet %s\n\n*****\n", subrec->subnet_name );
return;
}
- if(find_server_in_workgroup(work, global_myname()) == NULL) {
+ if(find_server_in_workgroup(work, lp_netbios_name()) == NULL) {
DEBUG(0,("become_local_master_fail1: Error - cannot find server %s \
in workgroup %s on subnet %s\n",
- global_myname(), work->work_group, subrec->subnet_name));
+ lp_netbios_name(), work->work_group, subrec->subnet_name));
return;
}
return;
}
- if(find_server_in_workgroup( work, global_myname()) == NULL) {
+ if(find_server_in_workgroup( work, lp_netbios_name()) == NULL) {
DEBUG(0,("become_local_master_browser: Error - cannot find server %s \
in workgroup %s on subnet %s\n",
- global_myname(), work->work_group, subrec->subnet_name));
+ lp_netbios_name(), work->work_group, subrec->subnet_name));
return;
}
SCVAL(p,0,ANN_MasterAnnouncement);
p++;
- unstrcpy(myname, global_myname());
+ unstrcpy(myname, lp_netbios_name());
strupper_m(myname);
myname[15]='\0';
/* The call below does CH_UNIX -> CH_DOS conversion. JRA */
/* Target name for send_mailslot must be in UNIX charset. */
pull_ascii_nstring(dmb_name, sizeof(dmb_name), work->dmb_name.name);
send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
- global_myname(), 0x0, dmb_name, 0x0,
+ lp_netbios_name(), 0x0, dmb_name, 0x0,
work->dmb_addr, FIRST_SUBNET->myip, DGRAM_PORT);
}
p = skip_string(outbuf,sizeof(outbuf),p);
send_mailslot(False, BROWSE_MAILSLOT, outbuf, PTR_DIFF(p,outbuf),
- global_myname(), 0,
+ lp_netbios_name(), 0,
workgroup_name, 0x1e,
subrec->bcast_ip, subrec->myip, DGRAM_PORT);
}
}
send_election_dgram(subrec, work->work_group, work->ElectionCriterion,
- t - StartupTime, global_myname());
+ t - StartupTime, lp_netbios_name());
if (work->ElectionCount++ >= 4) {
/* Won election (4 packets were sent out uncontested. */
version, ELECTION_VERSION,
criterion, mycriterion,
timeup, mytimeup,
- server_name, global_myname()));
+ server_name, lp_netbios_name()));
if (version > ELECTION_VERSION)
return(False);
if (timeup < mytimeup)
return(True);
- if (strcasecmp_m(global_myname(), server_name) > 0)
+ if (strcasecmp_m(lp_netbios_name(), server_name) > 0)
return(False);
return(True);
* to be our primary workgroup name.
*/
- if(strequal(work_name, global_myname()))
+ if(strequal(work_name, lp_netbios_name()))
unstrcpy(work_name,lp_workgroup());
/*
* not needed in the LanMan announce code, but it won't hurt.
*/
- if(strequal(work_name, global_myname()))
+ if(strequal(work_name, lp_netbios_name()))
unstrcpy(work_name,lp_workgroup());
/*
/* We always return at least one name - our own. */
count = 1;
- unstrcpy(myname, global_myname());
+ unstrcpy(myname, lp_netbios_name());
strupper_m(myname);
myname[15]='\0';
push_ascii(p, myname, sizeof(outbuf)-PTR_DIFF(p,outbuf)-1, STR_TERMINATE);
if(count >= (unsigned int)max_number_requested)
break;
- if(strnequal(servrec->serv.name, global_myname(),15))
+ if(strnequal(servrec->serv.name, lp_netbios_name(),15))
continue;
if(!(servrec->serv.type & SV_TYPE_BACKUP_BROWSER))
send_mailslot(True, BROWSE_MAILSLOT,
outbuf,PTR_DIFF(p,outbuf),
- global_myname(), 0,
+ lp_netbios_name(), 0,
send_to_namestr,0,
sendto_ip, subrec->myip, port);
}
;
for (l2=0;l2<15 && n2[l2] && n2[l2] != ' ';l2++)
;
- l3 = strlen(global_myname());
+ l3 = strlen(lp_netbios_name());
- if ((l1==l3) && strncmp(n1,global_myname(),l3) == 0 &&
- (l2!=l3 || strncmp(n2,global_myname(),l3) != 0))
+ if ((l1==l3) && strncmp(n1,lp_netbios_name(),l3) == 0 &&
+ (l2!=l3 || strncmp(n2,lp_netbios_name(),l3) != 0))
return -1;
- if ((l2==l3) && strncmp(n2,global_myname(),l3) == 0 &&
- (l1!=l3 || strncmp(n1,global_myname(),l3) != 0))
+ if ((l2==l3) && strncmp(n2,lp_netbios_name(),l3) == 0 &&
+ (l1!=l3 || strncmp(n1,lp_netbios_name(),l3) != 0))
return 1;
return memcmp(n1,n2,sizeof(name1));
return;
}
- if((servrec = find_server_in_workgroup( work, global_myname())) == NULL) {
+ if((servrec = find_server_in_workgroup( work, lp_netbios_name())) == NULL) {
DEBUG(0,("become_logon_server_fail: Error - cannot find server %s \
in workgroup %s on subnet %s\n",
- global_myname(), failname, subrec->subnet_name));
+ lp_netbios_name(), failname, subrec->subnet_name));
work->log_state = LOGON_NONE;
return;
}
return;
}
- if((servrec = find_server_in_workgroup( work, global_myname())) == NULL) {
+ if((servrec = find_server_in_workgroup( work, lp_netbios_name())) == NULL) {
DEBUG(0,("become_logon_server_success: Error - cannot find server %s \
in workgroup %s on subnet %s\n",
- global_myname(), reg_name, subrec->subnet_name));
+ lp_netbios_name(), reg_name, subrec->subnet_name));
work->log_state = LOGON_NONE;
return;
}
send_mailslot(true, state->remote_mailslot,
(char *)response.data, response.length,
- global_myname(), 0x0,
+ lp_netbios_name(), 0x0,
state->remote_name,
state->remote_name_type,
state->p->ip,
pull_ascii_nstring(source_name, sizeof(source_name), dgram->source_name.name);
- pdc_name = talloc_asprintf(talloc_tos(), "\\\\%s", global_myname());
+ pdc_name = talloc_asprintf(talloc_tos(), "\\\\%s", lp_netbios_name());
if (!pdc_name) {
return;
}
send_mailslot(True, request.req.logon0.mailslot_name,
(char *)blob_out.data,
blob_out.length,
- global_myname(), 0x0,
+ lp_netbios_name(), 0x0,
source_name,
dgram->source_name.name_type,
p->ip, ip, p->port);
"reporting %s domain %s 0x%x ntversion=%x lm_nt token=%x lm_20 token=%x\n",
request.req.pdc.computer_name,
inet_ntoa(p->ip),
- global_myname(),
+ lp_netbios_name(),
lp_workgroup(),
NETLOGON_RESPONSE_FROM_PDC,
request.req.pdc.nt_version,
request.req.pdc.lm20_token));
get_pdc.command = NETLOGON_RESPONSE_FROM_PDC;
- get_pdc.pdc_name = global_myname();
+ get_pdc.pdc_name = lp_netbios_name();
get_pdc._pad = data_blob_null;
- get_pdc.unicode_pdc_name = global_myname();
+ get_pdc.unicode_pdc_name = lp_netbios_name();
get_pdc.domain_name = lp_workgroup();
get_pdc.nt_version = NETLOGON_NT_VERSION_1;
get_pdc.lmnt_token = 0xffff;
send_mailslot(True, request.req.pdc.mailslot_name,
(char *)blob_out.data,
blob_out.length,
- global_myname(), 0x0,
+ lp_netbios_name(), 0x0,
source_name,
dgram->source_name.name_type,
p->ip, ip, p->port);
nt5_ex.dns_domain = domain;
nt5_ex.pdc_dns_name = hostname;
nt5_ex.domain_name = lp_workgroup();
- nt5_ex.pdc_name = global_myname();
+ nt5_ex.pdc_name = lp_netbios_name();
nt5_ex.user_name = request.req.logon.user_name;
nt5_ex.server_site = "Default-First-Site-Name";
nt5_ex.client_site = "Default-First-Site-Name";
send_mailslot(true, request.req.logon.mailslot_name,
(char *)blob_out.data,
blob_out.length,
- global_myname(), 0x0,
+ lp_netbios_name(), 0x0,
source_name,
dgram->source_name.name_type,
p->ip, ip, p->port);
p++;
send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
- global_myname(), 0x0, to_name, to_type, to_ip,
+ lp_netbios_name(), 0x0, to_name, to_type, to_ip,
FIRST_SUBNET->myip, DGRAM_PORT);
}
SCVAL(p,0,work->token); /* (local) Unique workgroup token id. */
p++;
- p += push_string_check(p+1, global_myname(), 15, STR_ASCII|STR_UPPER|STR_TERMINATE);
+ p += push_string_check(p+1, lp_netbios_name(), 15, STR_ASCII|STR_UPPER|STR_TERMINATE);
send_mailslot(False, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
- global_myname(), 0x0, work->work_group,0x1e, subrec->bcast_ip,
+ lp_netbios_name(), 0x0, work->work_group,0x1e, subrec->bcast_ip,
subrec->myip, DGRAM_PORT);
}
uint32 type = servrec->serv.type & ~SV_TYPE_LOCAL_LIST_ONLY;
DEBUG(3,("send_local_master_announcement: type %x for name %s on subnet %s for workgroup %s\n",
- type, global_myname(), subrec->subnet_name, work->work_group));
+ type, lp_netbios_name(), subrec->subnet_name, work->work_group));
send_announcement(subrec, ANN_LocalMasterAnnouncement,
- global_myname(), /* From nbt name. */
+ lp_netbios_name(), /* From nbt name. */
work->work_group, 0x1e, /* To nbt name. */
subrec->bcast_ip, /* To ip. */
work->announce_interval, /* Time until next announce. */
- global_myname(), /* Name to announce. */
+ lp_netbios_name(), /* Name to announce. */
type, /* Type field. */
servrec->serv.comment);
}
subrec->subnet_name, work->work_group));
send_announcement(subrec, ANN_DomainAnnouncement,
- global_myname(), /* From nbt name. */
+ lp_netbios_name(), /* From nbt name. */
MSBROWSE, 0x1, /* To nbt name. */
subrec->bcast_ip, /* To ip. */
work->announce_interval, /* Time until next announce. */
work->work_group, /* Name to announce. */
SV_TYPE_DOMAIN_ENUM|SV_TYPE_NT, /* workgroup announce flags. */
- global_myname()); /* From name as comment. */
+ lp_netbios_name()); /* From name as comment. */
}
/****************************************************************************
/* Only do domain announcements if we are a master and it's
our primary name we're being asked to announce. */
- if (AM_LOCAL_MASTER_BROWSER(work) && strequal(global_myname(),servrec->serv.name)) {
+ if (AM_LOCAL_MASTER_BROWSER(work) && strequal(lp_netbios_name(),servrec->serv.name)) {
send_local_master_announcement(subrec, work, servrec);
send_workgroup_announcement(subrec, work);
} else {
SCVAL(p,0,ANN_MasterAnnouncement);
p++;
- unstrcpy(myname, global_myname());
+ unstrcpy(myname, lp_netbios_name());
strupper_m(myname);
myname[15]='\0';
push_ascii(p, myname, sizeof(outbuf)-PTR_DIFF(p,outbuf)-1, STR_TERMINATE);
addr = interpret_addr2(s2);
DEBUG(5,("announce_remote: Doing remote browse sync announce for server %s to IP %s.\n",
- global_myname(), inet_ntoa(addr) ));
+ lp_netbios_name(), inet_ntoa(addr) ));
send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
- global_myname(), 0x0, "*", 0x0, addr, FIRST_SUBNET->myip, DGRAM_PORT);
+ lp_netbios_name(), 0x0, "*", 0x0, addr, FIRST_SUBNET->myip, DGRAM_PORT);
}
TALLOC_FREE(frame);
}
const char *name = my_netbios_names(i);
int stype = lp_default_server_announce() | (lp_local_master() ? SV_TYPE_POTENTIAL_BROWSER : 0 );
- if(!strequal(global_myname(), name))
+ if(!strequal(lp_netbios_name(), name))
stype &= ~(SV_TYPE_MASTER_BROWSER|SV_TYPE_POTENTIAL_BROWSER|SV_TYPE_DOMAIN_MASTER|SV_TYPE_DOMAIN_MEMBER);
create_server_on_workgroup(work,name,stype|SV_TYPE_LOCAL_LIST_ONLY, PERMANENT_TTL,
/* prototypes for the special type handlers */
static bool handle_include( int snum, const char *pszParmValue, char **ptr);
static bool handle_copy( int snum, const char *pszParmValue, char **ptr);
-static bool handle_netbios_name( int snum, const char *pszParmValue, char **ptr);
static bool handle_idmap_backend(int snum, const char *pszParmValue, char **ptr);
static bool handle_idmap_uid( int snum, const char *pszParmValue, char **ptr);
static bool handle_idmap_gid( int snum, const char *pszParmValue, char **ptr);
.type = P_USTRING,
.p_class = P_GLOBAL,
.ptr = &Globals.szNetbiosName,
- .special = handle_netbios_name,
+ .special = NULL,
.enum_list = NULL,
.flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
},
}
}
+
string_set(&sDefault.fstype, FSTYPE_STRING);
string_set(&sDefault.szPrintjobUsername, "%U");
DEBUG(3, ("Initialising global parameters\n"));
+ /* Must manually force to upper case here, as this does not go via the handler */
+ string_set(&Globals.szNetbiosName, myhostname_upper());
+
string_set(&Globals.szSMBPasswdFile, get_dyn_SMB_PASSWD_FILE());
string_set(&Globals.szPrivateDir, get_dyn_PRIVATE_DIR());
*/
string_set(&Globals.szPasswdChat, DEFAULT_PASSWD_CHAT);
- set_global_myname(myhostname());
- string_set(&Globals.szNetbiosName,global_myname());
-
string_set(&Globals.szWorkgroup, WORKGROUP);
string_set(&Globals.szPasswdProgram, "");
FN_GLOBAL_CONST_STRING(lp_passwordserver, &Globals.szPasswordServer)
FN_GLOBAL_CONST_STRING(lp_name_resolve_order, &Globals.szNameResolveOrder)
FN_GLOBAL_CONST_STRING(lp_workgroup, &Globals.szWorkgroup)
+FN_GLOBAL_CONST_STRING(lp_netbios_name, &Globals.szNetbiosName)
FN_GLOBAL_CONST_STRING(lp_netbios_scope, &Globals.szNetbiosScope)
FN_GLOBAL_CONST_STRING(lp_realm, &Globals.szRealmUpper)
FN_GLOBAL_CONST_STRING(lp_dnsdomain, &Globals.szDnsDomain)
}
-/***************************************************************************
- Run standard_sub_basic on netbios name... needed because global_myname
- is not accessed through any lp_ macro.
- Note: We must *NOT* use string_set() here as ptr points to global_myname.
-***************************************************************************/
-
-static bool handle_netbios_name(int snum, const char *pszParmValue, char **ptr)
-{
- bool ret;
- char *netbios_name = talloc_sub_basic(
- talloc_tos(), get_current_username(), current_user_info.domain,
- pszParmValue);
-
- ret = set_global_myname(netbios_name);
- TALLOC_FREE(netbios_name);
- string_set(&Globals.szNetbiosName,global_myname());
-
- DEBUG(4, ("handle_netbios_name: set global_myname to: %s\n",
- global_myname()));
-
- return ret;
-}
-
/**
* Initialize iconv conversion descriptors.
*
.socket_options = lp_socket_options,
.workgroup = lp_workgroup,
- .netbios_name = global_myname,
+ .netbios_name = lp_netbios_name,
.netbios_scope = lp_netbios_scope,
.lanman_auth = lp_lanman_auth,
}
}
- if (secrets_fetch_domain_sid(global_myname(), sam_sid)) {
+ if (secrets_fetch_domain_sid(lp_netbios_name(), sam_sid)) {
/* We got our sid. If not a pdc/bdc, we're done. */
if ( !IS_DC )
/* Domain name sid doesn't match global sam sid. Re-store domain sid as 'local' sid. */
DEBUG(0,("pdb_generate_sam_sid: Mismatched SIDs as a pdc/bdc.\n"));
- if (!secrets_store_domain_sid(global_myname(), &domain_sid)) {
+ if (!secrets_store_domain_sid(lp_netbios_name(), &domain_sid)) {
DEBUG(0,("pdb_generate_sam_sid: Can't re-store domain SID for local sid as PDC/BDC.\n"));
SAFE_FREE(sam_sid);
return NULL;
if (read_sid_from_file(fname, sam_sid)) {
/* remember it for future reference and unlink the old MACHINE.SID */
- if (!secrets_store_domain_sid(global_myname(), sam_sid)) {
+ if (!secrets_store_domain_sid(lp_netbios_name(), sam_sid)) {
DEBUG(0,("pdb_generate_sam_sid: Failed to store SID from file.\n"));
SAFE_FREE(fname);
SAFE_FREE(sam_sid);
generate one and save it */
generate_random_sid(sam_sid);
- if (!secrets_store_domain_sid(global_myname(), sam_sid)) {
+ if (!secrets_store_domain_sid(lp_netbios_name(), sam_sid)) {
DEBUG(0,("pdb_generate_sam_sid: Failed to store generated machine SID.\n"));
SAFE_FREE(sam_sid);
return NULL;
{
/* Standalone servers can only use the local netbios name */
if ( lp_server_role() == ROLE_STANDALONE )
- return global_myname();
+ return lp_netbios_name();
/* Default to the DOMAIN name when not specified */
return lp_workgroup();
static NTSTATUS samu_set_unix_internal(struct samu *user, const struct passwd *pwd, bool create)
{
const char *guest_account = lp_guestaccount();
- const char *domain = global_myname();
+ const char *domain = lp_netbios_name();
char *fullname;
uint32_t urid;
if (pwd != NULL) {
*ret_pwd = pwd;
if (account_name != NULL) {
- *account_name = global_myname();
+ *account_name = lp_netbios_name();
}
return true;
channel))
{
if (account_name != NULL) {
- *account_name = global_myname();
+ *account_name = lp_netbios_name();
}
return true;
DEBUG(5, ("publishing printer %s\n", printer));
/* figure out where to publish */
- ads_find_machine_acct(ads, &res, global_myname());
+ ads_find_machine_acct(ads, &res, lp_netbios_name());
/* We use ldap_get_dn here as we need the answer
* in utf8 to call ldap_explode_dn(). JRA. */
/* remove the printer from the directory */
ads_rc = ads_find_printer_on_server(ads, &res,
- printer, global_myname());
+ printer, lp_netbios_name());
if (ADS_ERR_OK(ads_rc) && res && ads_count_replies(ads, res)) {
prt_dn = ads_get_dn(ads, talloc_tos(), res);
DEBUG(2, ("Migrating Form: %s\n", key_name));
- srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
+ srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
if (srv_name_slash == NULL) {
return NT_STATUS_NO_MEMORY;
}
DEBUG(2, ("Migrating Printer Driver: %s\n", key_name));
- srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
+ srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
if (srv_name_slash == NULL) {
return NT_STATUS_NO_MEMORY;
}
make_systemtime(&(block->SystemTime), gmtime(&tm));
_reg_perfcount_init_data_block_perf(block, names);
memset(temp, 0, sizeof(temp));
- rpcstr_push((void *)temp, global_myname(), sizeof(temp), STR_TERMINATE);
+ rpcstr_push((void *)temp, lp_netbios_name(), sizeof(temp), STR_TERMINATE);
block->SystemNameLength = (strlen_w(temp) * 2) + 2;
block->data = talloc_zero_array(mem_ctx, uint8, block->SystemNameLength + (8 - (block->SystemNameLength % 8)));
if (block->data == NULL) {
if (workstation) {
fstr_sprintf( clnt_name_slash, "\\\\%s", workstation );
} else {
- fstr_sprintf( clnt_name_slash, "\\\\%s", global_myname() );
+ fstr_sprintf( clnt_name_slash, "\\\\%s", lp_netbios_name() );
}
/* Initialise input parameters */
status = dcerpc_netr_LogonSamLogon(b, mem_ctx,
cli->srv_name_slash,
- global_myname(),
+ lp_netbios_name(),
&clnt_creds,
&ret_creds,
logon_type,
status = dcerpc_netr_LogonSamLogon(b, mem_ctx,
server_name_slash,
- global_myname(),
+ lp_netbios_name(),
&clnt_creds,
&ret_creds,
NetlogonNetworkInformation,
status = dcerpc_netr_LogonSamLogonEx(b, mem_ctx,
server_name_slash,
- global_myname(),
+ lp_netbios_name(),
NetlogonNetworkInformation,
logon,
validation_level,
result = rpccli_netlogon_setup_creds(cli,
cli->desthost, /* server name */
lp_workgroup(), /* domain */
- global_myname(), /* client name */
+ lp_netbios_name(), /* client name */
account_name, /* machine account name */
orig_trust_passwd_hash,
sec_channel_type,
r.Flags = NL_FLAG_OEM_NETBIOS_DOMAIN_NAME |
NL_FLAG_OEM_NETBIOS_COMPUTER_NAME;
r.oem_netbios_domain.a = cli->auth->domain;
- r.oem_netbios_computer.a = global_myname();
+ r.oem_netbios_computer.a = lp_netbios_name();
status = dcerpc_push_schannel_bind(cli, &r, auth_token);
if (!NT_STATUS_IS_OK(status)) {
}
status = auth_ntlmssp_client_start(NULL,
- global_myname(),
+ lp_netbios_name(),
lp_workgroup(),
lp_client_ntlmv2_auth(),
&ntlmssp_ctx);
status = rpccli_netlogon_setup_creds(netlogon_pipe,
cli->desthost, /* server name */
domain, /* domain */
- global_myname(), /* client name */
+ lp_netbios_name(), /* client name */
machine_account, /* machine account name */
machine_pwd,
sec_chan_type,
ZERO_STRUCT(devmode_ctr);
level1.size = 28;
- level1.client = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
+ level1.client = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
W_ERROR_HAVE_NO_MEMORY(level1.client);
level1.user = cli->auth->user_name;
level1.build = 1381;
level1.major = 2;
level1.minor = 0;
level1.processor = 0;
- level1.client = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
+ level1.client = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
W_ERROR_HAVE_NO_MEMORY(level1.client);
level1.user = cli->auth->user_name;
static bool init_reply_dfs_info_1(TALLOC_CTX *mem_ctx, struct junction_map* j,struct dfs_Info1* dfs1)
{
dfs1->path = talloc_asprintf(mem_ctx,
- "\\\\%s\\%s\\%s", global_myname(),
+ "\\\\%s\\%s\\%s", lp_netbios_name(),
j->service_name, j->volume_name);
if (dfs1->path == NULL)
return False;
static bool init_reply_dfs_info_2(TALLOC_CTX *mem_ctx, struct junction_map* j, struct dfs_Info2* dfs2)
{
dfs2->path = talloc_asprintf(mem_ctx,
- "\\\\%s\\%s\\%s", global_myname(), j->service_name, j->volume_name);
+ "\\\\%s\\%s\\%s", lp_netbios_name(), j->service_name, j->volume_name);
if (dfs2->path == NULL)
return False;
dfs2->comment = talloc_strdup(mem_ctx, j->comment);
int ii;
if (j->volume_name[0] == '\0')
dfs3->path = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
- global_myname(), j->service_name);
+ lp_netbios_name(), j->service_name);
else
- dfs3->path = talloc_asprintf(mem_ctx, "\\\\%s\\%s\\%s", global_myname(),
+ dfs3->path = talloc_asprintf(mem_ctx, "\\\\%s\\%s\\%s", lp_netbios_name(),
j->service_name, j->volume_name);
if (dfs3->path == NULL)
uint32_t rid;
status = dcerpc_samr_Connect2(b, mem_ctx,
- global_myname(),
+ lp_netbios_name(),
SAMR_ACCESS_CONNECT_TO_SERVER |
SAMR_ACCESS_ENUM_DOMAINS |
SAMR_ACCESS_LOOKUP_DOMAIN,
r->oem_information.string = lp_serverstring();
r->domain_name.string = lp_workgroup();
- r->primary.string = global_myname();
+ r->primary.string = lp_netbios_name();
r->sequence_num = seq_num;
r->domain_server_state = DOMAIN_SERVER_ENABLED;
r->role = (enum samr_Role) samr_get_server_role();
/* NT returns its own name when a PDC. win2k and later
* only the name of the PDC if itself is a BDC (samba4
* idl) */
- r->primary.string = global_myname();
+ r->primary.string = lp_netbios_name();
return NT_STATUS_OK;
}
/* make sure the name doesn't already exist as a user
or local group */
- fstr_sprintf( group_name, "%s\\%s", global_myname(), info.acct_name );
+ fstr_sprintf( group_name, "%s\\%s", lp_netbios_name(), info.acct_name );
status = can_create( p->mem_ctx, group_name );
if ( !NT_STATUS_IS_OK( status ) )
return status;
}
/* setup the connection */
- ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
+ ret = cli_full_connection( &the_cli, lp_netbios_name(), remote_machine,
&rm_addr, 0, "IPC$", "IPC",
"", /* username */
"", /* domain */
info2->location));
/* we force some elements to "correct" values */
- info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
+ info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
if (info2->servername == NULL) {
return false;
}
/* check to see if we allow printername != sharename */
if (lp_force_printername(snum)) {
info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
- global_myname(), info2->sharename);
+ lp_netbios_name(), info2->sharename);
} else {
/* make sure printername is in \\server\printername format */
fstrcpy(printername, info2->printername);
}
info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
- global_myname(), p);
+ lp_netbios_name(), p);
}
if (info2->printername == NULL) {
return false;
buffer.length);
}
- push_reg_sz(mem_ctx, &buffer, global_myname());
+ push_reg_sz(mem_ctx, &buffer, lp_netbios_name());
winreg_set_printer_dataex(mem_ctx,
session_info,
msg_ctx,
if (dnsdomname != NULL && dnsdomname[0] != '\0') {
longname = talloc_strdup(mem_ctx, dnsdomname);
} else {
- longname = talloc_strdup(mem_ctx, global_myname());
+ longname = talloc_strdup(mem_ctx, lp_netbios_name());
}
if (longname == NULL) {
result = WERR_NOMEM;
buffer.length);
uncname = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
- global_myname(), printer->sharename);
+ lp_netbios_name(), printer->sharename);
push_reg_sz(mem_ctx, &buffer, uncname);
winreg_set_printer_dataex(mem_ctx,
session_info,
winreg_handle,
&key_hnd,
SPOOL_REG_SHORTSERVERNAME,
- global_myname(),
+ lp_netbios_name(),
&result);
if (!NT_STATUS_IS_OK(status)) {
result = ntstatus_to_werror(status);
*/
dnssuffix = get_mydnsdomname(tmp_ctx);
if (dnssuffix != NULL && dnssuffix[0] != '\0') {
- longname = talloc_asprintf(tmp_ctx, "%s.%s", global_myname(), dnssuffix);
+ longname = talloc_asprintf(tmp_ctx, "%s.%s", lp_netbios_name(), dnssuffix);
} else {
- longname = talloc_strdup(tmp_ctx, global_myname());
+ longname = talloc_strdup(tmp_ctx, lp_netbios_name());
}
if (longname == NULL) {
result = WERR_NOMEM;
}
info102->platform_id = PLATFORM_ID_NT;
- info102->server_name = global_myname();
+ info102->server_name = lp_netbios_name();
info102->version_major = lp_major_announce_version();
info102->version_minor = lp_minor_announce_version();
info102->server_type = lp_default_server_announce();
}
info101->platform_id = PLATFORM_ID_NT;
- info101->server_name = global_myname();
+ info101->server_name = lp_netbios_name();
info101->version_major = lp_major_announce_version();
info101->version_minor = lp_minor_announce_version();
info101->server_type = lp_default_server_announce();
}
info100->platform_id = PLATFORM_ID_NT;
- info100->server_name = global_myname();
+ info100->server_name = lp_netbios_name();
r->out.info->info100 = info100;
DEBUG(10, ("talloc_asprintf failed\n"));
continue;
}
- if (strcmp(machine_name, global_myname()) == 0) {
+ if (strcmp(machine_name, lp_netbios_name()) == 0) {
p = session_list[i].username;
nm = strstr(p, sep);
if (nm) {
info100->version_minor = lp_minor_announce_version();
info100->server_name = talloc_asprintf_strupper_m(
- info100, "%s", global_myname());
+ info100, "%s", lp_netbios_name());
info100->domain_name = talloc_asprintf_strupper_m(
info100, "%s", lp_workgroup());
info101->version_minor = lp_minor_announce_version();
info101->server_name = talloc_asprintf_strupper_m(
- info101, "%s", global_myname());
+ info101, "%s", lp_netbios_name());
info101->domain_name = talloc_asprintf_strupper_m(
info101, "%s", lp_workgroup());
info101->lan_root = "";
info102->version_minor = lp_minor_announce_version();
info102->server_name = talloc_asprintf_strupper_m(
- info102, "%s", global_myname());
+ info102, "%s", lp_netbios_name());
info102->domain_name = talloc_asprintf_strupper_m(
info102, "%s", lp_workgroup());
info102->lan_root = "";
/* For a local user the domain name and logon server are
* both returned as the local machine's NetBIOS name */
ctr1->user1[i].logon_domain = ctr1->user1[i].logon_server =
- talloc_asprintf_strupper_m(ctr1->user1, "%s", global_myname());
+ talloc_asprintf_strupper_m(ctr1->user1, "%s", lp_netbios_name());
ctr1->user1[i].other_domains = NULL; /* Maybe in future? */
}
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
NTSTATUS status;
const char *logon_server = cli->desthost;
- const char *computername = global_myname();
+ const char *computername = lp_netbios_name();
struct netr_Authenticator credential;
struct netr_Authenticator return_authenticator;
enum netr_SamDatabaseID database_id = SAM_DATABASE_DOMAIN;
NTSTATUS status;
uint32_t tmp;
const char *logon_server = cli->desthost;
- const char *computername = global_myname();
+ const char *computername = lp_netbios_name();
struct netr_Authenticator credential;
struct netr_Authenticator return_authenticator;
enum netr_SamDatabaseID database_id = SAM_DATABASE_DOMAIN;
status = rpccli_netlogon_setup_creds(cli,
server_name, /* server name */
lp_workgroup(), /* domain */
- global_myname(), /* client name */
- global_myname(), /* machine account name */
+ lp_netbios_name(), /* client name */
+ lp_netbios_name(), /* machine account name */
trust_passwd_hash,
sec_channel_type,
&neg_flags);
status = dcerpc_netr_DatabaseRedo(b, mem_ctx,
server_name,
- global_myname(),
+ lp_netbios_name(),
&clnt_creds,
&srv_cred,
e,
status = dcerpc_netr_LogonGetCapabilities(b, mem_ctx,
cli->desthost,
- global_myname(),
+ lp_netbios_name(),
&credential,
&return_authenticator,
level,
}
option.types[1].fields[0].field = JOB_NOTIFY_FIELD_PRINTER_NAME;
- clientname = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
+ clientname = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
if (!clientname) {
result = WERR_NOMEM;
goto done;
/* first get the connection to the remote server */
- nt_status = cli_full_connection(&cli_server2, global_myname(), argv[2],
+ nt_status = cli_full_connection(&cli_server2, lp_netbios_name(), argv[2],
NULL, 0,
"IPC$", "IPC",
get_cmdline_auth_info_username(rpcclient_auth_info),
ntresult = rpccli_netlogon_setup_creds(cmd_entry->rpc_pipe,
cli->desthost, /* server name */
get_cmdline_auth_info_domain(auth_info), /* domain */
- global_myname(), /* client name */
+ lp_netbios_name(), /* client name */
machine_account, /* machine account name */
trust_password,
sec_channel_type,
}
- nt_status = cli_full_connection(&cli, global_myname(), binding->host,
+ nt_status = cli_full_connection(&cli, lp_netbios_name(), binding->host,
opt_ipaddr ? &server_ss : NULL, opt_port,
"IPC$", "IPC",
get_cmdline_auth_info_username(rpcclient_auth_info),
}
if (avahi_entry_group_add_service(
state->entry_group, AVAHI_IF_UNSPEC,
- AVAHI_PROTO_UNSPEC, 0, global_myname(),
+ AVAHI_PROTO_UNSPEC, 0, lp_netbios_name(),
"_smb._tcp", NULL, NULL, state->port, NULL) < 0) {
error = avahi_client_errno(c);
DEBUG(10, ("avahi_entry_group_add_service failed: "
b = samr_pipe->binding_handle;
- status = dcerpc_samr_Connect2(b, talloc_tos(), global_myname(),
+ status = dcerpc_samr_Connect2(b, talloc_tos(), lp_netbios_name(),
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle,
&result);
if (!NT_STATUS_IS_OK(status)) {
b = samr_pipe->binding_handle;
- status = dcerpc_samr_Connect2(b, talloc_tos(), global_myname(),
+ status = dcerpc_samr_Connect2(b, talloc_tos(), lp_netbios_name(),
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle,
&result);
if (!NT_STATUS_IS_OK(status)) {
b = samr_pipe->binding_handle;
- status = dcerpc_samr_Connect2(b, talloc_tos(), global_myname(),
+ status = dcerpc_samr_Connect2(b, talloc_tos(), lp_netbios_name(),
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle,
&result);
if (!NT_STATUS_IS_OK(status)) {
b = cli->binding_handle;
status = dcerpc_samr_Connect2(b, mem_ctx,
- global_myname(),
+ lp_netbios_name(),
SAMR_ACCESS_CONNECT_TO_SERVER |
SAMR_ACCESS_ENUM_DOMAINS |
SAMR_ACCESS_LOOKUP_DOMAIN,
b = cli->binding_handle;
- init_lsa_AsciiString(&server, global_myname());
+ init_lsa_AsciiString(&server, lp_netbios_name());
init_lsa_AsciiString(&account, user);
status = dcerpc_samr_OemChangePasswordUser2(b, mem_ctx,
b = cli->binding_handle;
status = dcerpc_samr_Connect2(b, mem_ctx,
- global_myname(),
+ lp_netbios_name(),
SAMR_ACCESS_CONNECT_TO_SERVER |
SAMR_ACCESS_ENUM_DOMAINS |
SAMR_ACCESS_LOOKUP_DOMAIN,
} else {
fstring myname;
char *host_princ_s = NULL;
- name_to_fqdn(myname, global_myname());
+ name_to_fqdn(myname, lp_netbios_name());
strlower_m(myname);
if (asprintf(&host_princ_s, "cifs/%s@%s", myname, lp_realm())
== -1) {
memset(blob_out.data, '\0', 16);
- checked_strlcpy(unix_name, global_myname(), sizeof(unix_name));
+ checked_strlcpy(unix_name, lp_netbios_name(), sizeof(unix_name));
strlower_m(unix_name);
push_ascii_nstring(dos_name, unix_name);
strlcpy((char *)blob_out.data, dos_name, 17);
SSVAL(p, 0, 0);
}
srvstr_push((char *)req->outbuf, req->flags2, p+2,
- global_myname(), 15,
+ lp_netbios_name(), 15,
STR_TERMINATE|STR_ASCII);
if (conn) {
srvstr_push((char *)req->outbuf, req->flags2,
gss_cred_id_t srv_cred;
fstring fqdn;
- name_to_fqdn(fqdn, global_myname());
+ name_to_fqdn(fqdn, lp_netbios_name());
strlower_m(fqdn);
status = get_srv_gss_creds("cifs", fqdn, GSS_C_ACCEPT, &srv_cred);
return False;
}
/* Create server principal. */
- asprintf(&host_princ_s, "%s$@%s", global_myname(), lp_realm());
+ asprintf(&host_princ_s, "%s$@%s", lp_netbios_name(), lp_realm());
if (!host_princ_s) {
goto out;
}
SSVAL(pdata, 0, 0);
}
srvstr_push(pdata, req->flags2, pdata + 2,
- global_myname(), 15,
+ lp_netbios_name(), 15,
STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
srvstr_push(pdata, req->flags2, pdata+18,
lp_servicename(SNUM(conn)), 13,
NTSTATUS status;
printf("starting chain2 test\n");
- status = cli_start_connection(&cli1, global_myname(), host, NULL,
+ status = cli_start_connection(&cli1, lp_netbios_name(), host, NULL,
port_to_use, Undefined, 0);
if (!NT_STATUS_IS_OK(status)) {
return False;
name = argv[0];
}
else {
- name = global_myname();
+ name = lp_netbios_name();
}
if(!initialize_password_db(false, NULL)) {
return 1;
}
- if (!secrets_store_domain_sid(global_myname(), &sid)) {
+ if (!secrets_store_domain_sid(lp_netbios_name(), &sid)) {
DEBUG(0,("Can't store domain SID as a pdc/bdc.\n"));
return 1;
}
/* Generate one, if it doesn't exist */
get_global_sam_sid();
- if (!secrets_fetch_domain_sid(global_myname(), &domain_sid)) {
+ if (!secrets_fetch_domain_sid(lp_netbios_name(), &domain_sid)) {
d_fprintf(stderr, _("Could not fetch local SID\n"));
return 1;
}
sid_to_fstring(sid_str, &domain_sid);
d_printf(_("SID for local machine %s is: %s\n"),
- global_myname(), sid_str);
+ lp_netbios_name(), sid_str);
if (!secrets_fetch_domain_sid(c->opt_workgroup, &domain_sid)) {
d_fprintf(stderr, _("Could not fetch domain SID\n"));
}
if (c->opt_requester_name) {
- set_global_myname(c->opt_requester_name);
+ lp_set_cmdline("netbios name", c->opt_requester_name);
}
if (!c->opt_user_name && getenv("LOGNAME")) {
return -1;
}
- rc = ads_find_machine_acct(ads, &res, global_myname());
+ rc = ads_find_machine_acct(ads, &res, lp_netbios_name());
if (!ADS_ERR_OK(rc)) {
d_fprintf(stderr, _("ads_find_machine_acct: %s\n"), ads_errstr(rc));
ads_destroy(&ads);
}
if (ads_count_replies(ads, res) == 0) {
- d_fprintf(stderr, _("No machine account for '%s' found\n"), global_myname());
+ d_fprintf(stderr, _("No machine account for '%s' found\n"), lp_netbios_name());
ads_destroy(&ads);
return -1;
}
return WERR_INVALID_DOMAIN_ROLE;
}
- if (strlen(global_myname()) > 15) {
+ if (strlen(lp_netbios_name()) > 15) {
d_printf(_("Our netbios name can be at most 15 chars long, "
- "\"%s\" is %u chars long\n"), global_myname(),
- (unsigned int)strlen(global_myname()));
+ "\"%s\" is %u chars long\n"), lp_netbios_name(),
+ (unsigned int)strlen(lp_netbios_name()));
return WERR_INVALID_COMPUTERNAME;
}
if (hostname) {
fstrcpy(machine_name, hostname);
} else {
- name_to_fqdn( machine_name, global_myname() );
+ name_to_fqdn( machine_name, lp_netbios_name() );
}
strlower_m( machine_name );
/* kinit with the machine password */
use_in_memory_ccache();
- if (asprintf( &ads_dns->auth.user_name, "%s$", global_myname()) == -1) {
+ if (asprintf( &ads_dns->auth.user_name, "%s$", lp_netbios_name()) == -1) {
goto fail;
}
ads_dns->auth.password = secrets_fetch_machine_password(
if (argc > 1) {
servername = argv[1];
} else {
- servername = global_myname();
+ servername = lp_netbios_name();
}
rc = ads_find_printer_on_server(ads, &res, printername, servername);
if (argc == 2) {
servername = argv[1];
} else {
- servername = global_myname();
+ servername = lp_netbios_name();
}
/* Get printer data from SPOOLSS */
resolve_name(servername, &server_ss, 0x20, false);
- nt_status = cli_full_connection(&cli, global_myname(), servername,
+ nt_status = cli_full_connection(&cli, lp_netbios_name(), servername,
&server_ss, 0,
"IPC$", "IPC",
c->opt_user_name, c->opt_workgroup,
if (argc > 1) {
servername = argv[1];
} else {
- servername = global_myname();
+ servername = lp_netbios_name();
}
rc = ads_find_printer_on_server(ads, &res, argv[0], servername);
return -1;
}
- fstrcpy(my_name, global_myname());
+ fstrcpy(my_name, lp_netbios_name());
strlower_m(my_name);
if (asprintf(&host_principal, "%s$@%s", my_name, ads->config.realm) == -1) {
ads_destroy(&ads);
sec_channel_type = get_sec_channel_type(NULL);
}
- fstrcpy(trust_passwd, global_myname());
+ fstrcpy(trust_passwd, lp_netbios_name());
strlower_m(trust_passwd);
/*
E_md4hash(trust_passwd, orig_trust_passwd_hash);
result = trust_pw_change_and_store_it(pipe_hnd, mem_ctx, c->opt_target_workgroup,
- global_myname(),
+ lp_netbios_name(),
orig_trust_passwd_hash,
sec_channel_type);
return -1;
}
- if (strlen(global_myname()) > 15) {
+ if (strlen(lp_netbios_name()) > 15) {
d_printf(_("Our netbios name can be at most 15 chars long, "
"\"%s\" is %u chars long\n"),
- global_myname(), (unsigned int)strlen(global_myname()));
+ lp_netbios_name(), (unsigned int)strlen(lp_netbios_name()));
return -1;
}
domain_name = c->opt_workgroup;
c->opt_target_workgroup = c->opt_workgroup;
} else {
- fstrcpy(pdc_name, global_myname());
+ fstrcpy(pdc_name, lp_netbios_name());
domain_name = talloc_strdup(mem_ctx, lp_workgroup());
c->opt_target_workgroup = domain_name;
};
domain_name = c->opt_workgroup;
c->opt_target_workgroup = c->opt_workgroup;
} else {
- fstrcpy(pdc_name, global_myname());
+ fstrcpy(pdc_name, lp_netbios_name());
domain_name = talloc_strdup(mem_ctx, lp_workgroup());
c->opt_target_workgroup = domain_name;
};
return false;
status = cli_connect_nb(server_name, &server_ss, 0, 0x20,
- global_myname(), Undefined, &cli);
+ lp_netbios_name(), Undefined, &cli);
if (!NT_STATUS_IS_OK(status)) {
return false;
}
"could not open domain");
/* Create domain user */
- if ((acct_name = talloc_asprintf(mem_ctx, "%s$", global_myname())) == NULL) {
+ if ((acct_name = talloc_asprintf(mem_ctx, "%s$", lp_netbios_name())) == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
}
status = rpccli_netlogon_setup_creds(pipe_hnd,
cli->desthost, /* server name */
domain, /* domain */
- global_myname(), /* client name */
- global_myname(), /* machine account name */
+ lp_netbios_name(), /* client name */
+ lp_netbios_name(), /* machine account name */
md4_trust_password,
sec_channel_type,
&neg_flags);
d_fprintf(stderr, _("Please make sure that no computer "
"account\nnamed like this machine "
"(%s) exists in the domain\n"),
- global_myname());
+ lp_netbios_name());
}
goto done;
"computer account\nnamed "
"like this machine (%s) "
"exists in the domain\n"),
- global_myname());
+ lp_netbios_name());
}
goto done;
if (strequal(info[j].value_name, SPOOL_REG_SHORTSERVERNAME)) {
- push_reg_sz(mem_ctx, &blob, global_myname());
+ push_reg_sz(mem_ctx, &blob, lp_netbios_name());
}
value = regval_compose(talloc_tos(),
struct cli_state *cli = NULL;
NTSTATUS status;
- status = cli_connect_nb(host, pss, 0, 0x20, global_myname(),
+ status = cli_connect_nb(host, pss, 0, 0x20, lp_netbios_name(),
Undefined, &cli);
if (!NT_STATUS_IS_OK(status)) {
fprintf(stderr, _("Can't contact server %s. Error %s\n"),
c->opt_password = secrets_fetch_machine_password(
c->opt_target_workgroup, NULL, NULL);
- if (asprintf(&user_name, "%s$@%s", global_myname(), lp_realm()) == -1) {
+ if (asprintf(&user_name, "%s$@%s", lp_netbios_name(), lp_realm()) == -1) {
return -1;
}
c->opt_user_name = user_name;
c->opt_password = secrets_fetch_machine_password(
c->opt_target_workgroup, NULL, NULL);
- if (asprintf(&user_name, "%s$", global_myname()) == -1) {
+ if (asprintf(&user_name, "%s$", lp_netbios_name()) == -1) {
return -1;
}
c->opt_user_name = user_name;
}
#endif
- nt_status = cli_full_connection(&cs->cli, global_myname(), global_myname(),
+ nt_status = cli_full_connection(&cs->cli, lp_netbios_name(), lp_netbios_name(),
&loopback_ss, 0,
"IPC$", "IPC",
#if 0
if (winbindd_request_response(WINBINDD_NETBIOS_NAME, NULL, &response) !=
NSS_STATUS_SUCCESS) {
DEBUG(0, ("could not obtain winbind netbios name!\n"));
- return global_myname();
+ return lp_netbios_name();
}
fstrcpy(winbind_netbios_name, response.data.netbios_name);
}
status = ntlmssp_client_start(NULL,
- global_myname(),
+ lp_netbios_name(),
lp_workgroup(),
lp_client_ntlmv2_auth(),
client_ntlmssp_state);
bool is_standalone = false;
if (opt_password) {
- netbios_name = global_myname();
+ netbios_name = lp_netbios_name();
netbios_domain = lp_workgroup();
} else {
netbios_name = get_winbind_netbios_name();
ZERO_STRUCT(spnego);
- myname_lower = talloc_strdup(ctx, global_myname());
+ myname_lower = talloc_strdup(ctx, lp_netbios_name());
if (!myname_lower) {
return;
}
if (!NT_STATUS_IS_OK(
contact_winbind_auth_crap(username,
domain,
- global_myname(),
+ lp_netbios_name(),
&challenge,
&lm_response,
&nt_response,
set_cmdline_auth_info_getpass(auth_info);
- nt_status = cli_full_connection(&c, global_myname(), server,
+ nt_status = cli_full_connection(&c, lp_netbios_name(), server,
&ss, 0,
share, "?????",
get_cmdline_auth_info_username(auth_info),
set_cmdline_auth_info_getpass(smbcquotas_auth_info);
- nt_status = cli_full_connection(&c, global_myname(), server,
+ nt_status = cli_full_connection(&c, lp_netbios_name(), server,
&ss, 0,
share, "?????",
get_cmdline_auth_info_username(smbcquotas_auth_info),
ret = 1;
}
- if (strequal(lp_workgroup(), global_myname())) {
+ if (strequal(lp_workgroup(), lp_netbios_name())) {
fprintf(stderr, "WARNING: 'workgroup' and 'netbios name' " \
"must differ.\n");
ret = 1;
loopback_ip.s_addr = htonl(INADDR_LOOPBACK);
in_addr_to_sockaddr_storage(&ss, loopback_ip);
- status = cli_connect_nb("localhost", &ss, 0, 0x20, global_myname(),
+ status = cli_connect_nb("localhost", &ss, 0, 0x20, lp_netbios_name(),
Undefined, &cli);
if (!NT_STATUS_IS_OK(status)) {
return false;
DATA_BLOB dummy_msg, reply;
status = ntlmssp_client_start(NULL,
- global_myname(),
+ lp_netbios_name(),
lp_workgroup(),
lp_client_ntlmv2_auth(),
&ntlmssp_state);
(*cli)->use_kerberos = True;
DEBUG(5, ("connecting to %s from %s with kerberos principal "
- "[%s] and realm [%s]\n", controller, global_myname(),
+ "[%s] and realm [%s]\n", controller, lp_netbios_name(),
machine_krb5_principal, domain->alt_name));
winbindd_set_locator_kdc_envs(domain);
(*cli)->use_kerberos = False;
DEBUG(5, ("connecting to %s from %s with username "
- "[%s]\\[%s]\n", controller, global_myname(),
+ "[%s]\\[%s]\n", controller, lp_netbios_name(),
lp_workgroup(), machine_account));
ads_status = cli_session_setup_spnego(*cli,
/* Only try authenticated if we have a username */
DEBUG(5, ("connecting to %s from %s with username "
- "[%s]\\[%s]\n", controller, global_myname(),
+ "[%s]\\[%s]\n", controller, lp_netbios_name(),
ipc_domain, ipc_username));
if (NT_STATUS_IS_OK(cli_session_setup(
netlogon_pipe,
domain->dcname, /* server name. */
domain->name, /* domain name */
- global_myname(), /* client name */
+ lp_netbios_name(), /* client name */
account_name, /* machine account */
mach_pwd, /* machine password */
sec_chan_type, /* from get_trust_pw */
DEBUG(3, ("[%5lu]: request netbios name\n",
(unsigned long)state->pid));
- fstrcpy(state->response->data.netbios_name, global_myname());
+ fstrcpy(state->response->data.netbios_name, lp_netbios_name());
request_ok(state);
}
NTSTATUS status;
status = make_user_info(&user_info, user, user, domain, domain,
- global_myname(), lm_resp, nt_resp, NULL, NULL,
+ lp_netbios_name(), lm_resp, nt_resp, NULL, NULL,
NULL, AUTH_PASSWORD_RESPONSE);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(10, ("make_user_info failed: %s\n", nt_errstr(status)));
'workstation' passed to the actual SamLogon call.
*/
names_blob = NTLMv2_generate_names_blob(
- mem_ctx, global_myname(), lp_workgroup());
+ mem_ctx, lp_netbios_name(), lp_workgroup());
if (!SMBNTLMv2encrypt(mem_ctx, name_user, name_domain,
pass,
domain->dcname,
name_user,
name_domain,
- global_myname(),
+ lp_netbios_name(),
chal,
lm_resp,
nt_resp,
}
if (request->data.auth_crap.workstation[0] == '\0') {
- fstrcpy(request->data.auth_crap.workstation, global_myname());
+ fstrcpy(request->data.auth_crap.workstation, lp_netbios_name());
}
subreq = wb_domain_request_send(state, winbind_event_context(), domain,
git.samba.org / bbaumbach / samba-autobuild / .git / commitdiff