Unix SMB/CIFS implementation.
string substitution functions
Copyright (C) Andrew Tridgell 1992-2000
+ Copyright (C) Gerald Carter 2006
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
-fstring local_machine="";
-fstring remote_arch="UNKNOWN";
+extern struct current_user current_user;
+
userdom_struct current_user_info;
fstring remote_proto="UNKNOWN";
-fstring remote_machine="";
-extern pstring global_myname;
+
+/**
+ * Set the 'local' machine name
+ * @param local_name the name we are being called
+ * @param if this is the 'final' name for us, not be be changed again
+ */
+
+static char *local_machine;
+
+void free_local_machine_name(void)
+{
+ SAFE_FREE(local_machine);
+}
+
+bool set_local_machine_name(const char *local_name, bool perm)
+{
+ static bool already_perm = false;
+ char *tmp_local_machine = NULL;
+ char addr[INET6_ADDRSTRLEN];
+ size_t len;
+
+ tmp_local_machine = SMB_STRDUP(local_name);
+ if (!tmp_local_machine) {
+ return false;
+ }
+ trim_char(tmp_local_machine,' ',' ');
+
+ /*
+ * Windows NT/2k uses "*SMBSERVER" and XP uses "*SMBSERV"
+ * arrggg!!!
+ */
+
+ if (strequal(tmp_local_machine, "*SMBSERVER") ||
+ strequal(tmp_local_machine, "*SMBSERV") ) {
+ SAFE_FREE(local_machine);
+ local_machine = SMB_STRDUP(client_socket_addr(get_client_fd(),
+ addr, sizeof(addr)) );
+ SAFE_FREE(tmp_local_machine);
+ return local_machine ? true : false;
+ }
+
+ if (already_perm) {
+ return true;
+ }
+
+ SAFE_FREE(local_machine);
+ len = strlen(tmp_local_machine);
+ local_machine = SMB_CALLOC_ARRAY(char, len+1);
+ if (!local_machine) {
+ SAFE_FREE(tmp_local_machine);
+ return false;
+ }
+ /* alpha_strcpy includes the space for the terminating nul. */
+ alpha_strcpy(local_machine,tmp_local_machine,
+ SAFE_NETBIOS_CHARS,len+1);
+ strlower_m(local_machine);
+ SAFE_FREE(tmp_local_machine);
+
+ already_perm = perm;
+
+ return true;
+}
+
+const char *get_local_machine_name(void)
+{
+ if (!local_machine || !*local_machine) {
+ return global_myname();
+ }
+
+ return local_machine;
+}
+
+/**
+ * Set the 'remote' machine name
+ * @param remote_name the name our client wants to be called by
+ * @param if this is the 'final' name for them, not be be changed again
+ */
+
+static char *remote_machine;
+
+bool set_remote_machine_name(const char *remote_name, bool perm)
+{
+ static bool already_perm = False;
+ char *tmp_remote_machine;
+ size_t len;
+
+ if (already_perm) {
+ return true;
+ }
+
+ tmp_remote_machine = SMB_STRDUP(remote_name);
+ if (!tmp_remote_machine) {
+ return false;
+ }
+ trim_char(tmp_remote_machine,' ',' ');
+
+ SAFE_FREE(remote_machine);
+ len = strlen(tmp_remote_machine);
+ remote_machine = SMB_CALLOC_ARRAY(char, len+1);
+ if (!remote_machine) {
+ SAFE_FREE(tmp_remote_machine);
+ return false;
+ }
+
+ /* alpha_strcpy includes the space for the terminating nul. */
+ alpha_strcpy(remote_machine,tmp_remote_machine,
+ SAFE_NETBIOS_CHARS,len+1);
+ strlower_m(remote_machine);
+ SAFE_FREE(tmp_remote_machine);
+
+ already_perm = perm;
+
+ return true;
+}
+
+const char *get_remote_machine_name(void)
+{
+ return remote_machine ? remote_machine : "";
+}
/*******************************************************************
- Given a pointer to a %$(NAME) expand it as an environment variable.
- Return the number of characters by which the pointer should be advanced.
+ Setup the string used by %U substitution.
+********************************************************************/
+
+static char *smb_user_name;
+
+void sub_set_smb_name(const char *name)
+{
+ char *tmp;
+ size_t len;
+ bool is_machine_account = false;
+
+ /* don't let anonymous logins override the name */
+ if (!name || !*name) {
+ return;
+ }
+
+ tmp = SMB_STRDUP(name);
+ if (!tmp) {
+ return;
+ }
+ trim_char(tmp, ' ', ' ');
+ strlower_m(tmp);
+
+ len = strlen(tmp);
+
+ if (len == 0) {
+ SAFE_FREE(tmp);
+ return;
+ }
+
+ /* long story but here goes....we have to allow usernames
+ ending in '$' as they are valid machine account names.
+ So check for a machine account and re-add the '$'
+ at the end after the call to alpha_strcpy(). --jerry */
+
+ if (tmp[len-1] == '$') {
+ is_machine_account = True;
+ }
+
+ SAFE_FREE(smb_user_name);
+ smb_user_name = SMB_CALLOC_ARRAY(char, len+1);
+ if (!smb_user_name) {
+ SAFE_FREE(tmp);
+ return;
+ }
+
+ /* alpha_strcpy includes the space for the terminating nul. */
+ alpha_strcpy(smb_user_name, tmp,
+ SAFE_NETBIOS_CHARS,
+ len+1);
+
+ SAFE_FREE(tmp);
+
+ if (is_machine_account) {
+ len = strlen(smb_user_name);
+ smb_user_name[len-1] = '$';
+ }
+}
+
+static const char *get_smb_user_name(void)
+{
+ return smb_user_name ? smb_user_name : "";
+}
+
+/*******************************************************************
+ Setup the strings used by substitutions. Called per packet. Ensure
+ %U name is set correctly also.
+
+ smb_name must be sanitized by alpha_strcpy
+********************************************************************/
+
+void set_current_user_info(const char *smb_name, const char *unix_name,
+ const char *full_name, const char *domain)
+{
+ fstrcpy(current_user_info.smb_name, smb_name);
+ fstrcpy(current_user_info.unix_name, unix_name);
+ fstrcpy(current_user_info.full_name, full_name);
+ fstrcpy(current_user_info.domain, domain);
+
+ /* The following is safe as current_user_info.smb_name
+ * has already been sanitised in register_existing_vuid. */
+
+ sub_set_smb_name(current_user_info.smb_name);
+}
+
+/*******************************************************************
+ Return the current active user name.
+*******************************************************************/
+
+const char *get_current_username(void)
+{
+ if (current_user_info.smb_name[0] == '\0' ) {
+ return get_smb_user_name();
+ }
+
+ return current_user_info.smb_name;
+}
+
+/*******************************************************************
+ Given a pointer to a %$(NAME) in p and the whole string in str
+ expand it as an environment variable.
+ Return a new allocated and expanded string.
Based on code by Branko Cibej <branko.cibej@hermes.si>
When this is called p points at the '%' character.
+ May substitute multiple occurrencies of the same env var.
********************************************************************/
-static size_t expand_env_var(char *p, int len)
+static char * realloc_expand_env_var(char *str, char *p)
{
- fstring envname;
+ char *envname;
char *envval;
char *q, *r;
int copylen;
- if (p[1] != '$')
- return 1;
-
- if (p[2] != '(')
- return 2;
+ if (p[0] != '%' || p[1] != '$' || p[2] != '(') {
+ return str;
+ }
/*
* Look for the terminating ')'.
if ((q = strchr_m(p,')')) == NULL) {
DEBUG(0,("expand_env_var: Unterminated environment variable [%s]\n", p));
- return 2;
+ return str;
}
/*
* Extract the name from within the %$(NAME) string.
*/
- r = p+3;
- copylen = MIN((q-r),(sizeof(envname)-1));
+ r = p + 3;
+ copylen = q - r;
+
+ /* reserve space for use later add %$() chars */
+ if ( (envname = (char *)SMB_MALLOC(copylen + 1 + 4)) == NULL ) {
+ return NULL;
+ }
+
strncpy(envname,r,copylen);
envname[copylen] = '\0';
if ((envval = getenv(envname)) == NULL) {
DEBUG(0,("expand_env_var: Environment variable [%s] not set\n", envname));
- return 2;
+ SAFE_FREE(envname);
+ return str;
}
/*
* can be replaced.
*/
- copylen = MIN((q+1-p),(sizeof(envname)-1));
+ copylen = q + 1 - p;
strncpy(envname,p,copylen);
envname[copylen] = '\0';
- string_sub(p,envname,envval,len);
- return 0; /* Allow the environment contents to be parsed. */
+ r = realloc_string_sub(str, envname, envval);
+ SAFE_FREE(envname);
+
+ return r;
+}
+
+/*******************************************************************
+*******************************************************************/
+
+static char *longvar_domainsid( void )
+{
+ DOM_SID sid;
+ fstring tmp;
+ char *sid_string;
+
+ if ( !secrets_fetch_domain_sid( lp_workgroup(), &sid ) ) {
+ return NULL;
+ }
+
+ sid_string = SMB_STRDUP( sid_to_fstring( tmp, &sid ) );
+
+ if ( !sid_string ) {
+ DEBUG(0,("longvar_domainsid: failed to dup SID string!\n"));
+ }
+
+ return sid_string;
+}
+
+/*******************************************************************
+*******************************************************************/
+
+struct api_longvar {
+ const char *name;
+ char* (*fn)( void );
+};
+
+static struct api_longvar longvar_table[] = {
+ { "DomainSID", longvar_domainsid },
+ { NULL, NULL }
+};
+
+static char *get_longvar_val( const char *varname )
+{
+ int i;
+
+ DEBUG(7,("get_longvar_val: expanding variable [%s]\n", varname));
+
+ for ( i=0; longvar_table[i].name; i++ ) {
+ if ( strequal( longvar_table[i].name, varname ) ) {
+ return longvar_table[i].fn();
+ }
+ }
+
+ return NULL;
+}
+
+/*******************************************************************
+ Expand the long smb.conf variable names given a pointer to a %(NAME).
+ Return the number of characters by which the pointer should be advanced.
+ When this is called p points at the '%' character.
+********************************************************************/
+
+static char *realloc_expand_longvar(char *str, char *p)
+{
+ fstring varname;
+ char *value;
+ char *q, *r;
+ int copylen;
+
+ if ( p[0] != '%' || p[1] != '(' ) {
+ return str;
+ }
+
+ /* Look for the terminating ')'.*/
+
+ if ((q = strchr_m(p,')')) == NULL) {
+ DEBUG(0,("realloc_expand_longvar: Unterminated environment variable [%s]\n", p));
+ return str;
+ }
+
+ /* Extract the name from within the %(NAME) string.*/
+
+ r = p+2;
+ copylen = MIN( (q-r), (sizeof(varname)-1) );
+ strncpy(varname, r, copylen);
+ varname[copylen] = '\0';
+
+ if ((value = get_longvar_val(varname)) == NULL) {
+ DEBUG(0,("realloc_expand_longvar: Variable [%s] not set. Skipping\n", varname));
+ return str;
+ }
+
+ /* Copy the full %(NAME) into envname so it can be replaced.*/
+
+ copylen = MIN( (q+1-p),(sizeof(varname)-1) );
+ strncpy( varname, p, copylen );
+ varname[copylen] = '\0';
+ r = realloc_string_sub(str, varname, value);
+ SAFE_FREE( value );
+
+ /* skip over the %(varname) */
+
+ return r;
}
/*******************************************************************
Added this to implement %p (NIS auto-map version of %H)
*******************************************************************/
-static char *automount_path(const char *user_name)
+static const char *automount_path(const char *user_name)
{
- static pstring server_path;
+ TALLOC_CTX *ctx = talloc_tos();
+ const char *server_path;
/* use the passwd entry as the default */
/* this will be the default if WITH_AUTOMOUNT is not used or fails */
- pstrcpy(server_path, get_user_home_dir(user_name));
+ server_path = talloc_strdup(ctx, get_user_home_dir(ctx, user_name));
+ if (!server_path) {
+ return "";
+ }
#if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
if (lp_nis_home_map()) {
- char *home_path_start;
- char *automount_value = automount_lookup(user_name);
+ const char *home_path_start;
+ char *automount_value = automount_lookup(ctx, user_name);
- if(strlen(automount_value) > 0) {
+ if(automount_value && strlen(automount_value) > 0) {
home_path_start = strchr_m(automount_value,':');
if (home_path_start != NULL) {
- DEBUG(5, ("NIS lookup succeeded. Home path is: %s\n",
- home_path_start?(home_path_start+1):""));
- pstrcpy(server_path, home_path_start+1);
+ DEBUG(5, ("NIS lookup succeeded. "
+ "Home path is: %s\n",
+ home_path_start ?
+ (home_path_start+1):""));
+ server_path = talloc_strdup(ctx,
+ home_path_start+1);
+ if (!server_path) {
+ server_path = "";
+ }
}
} else {
- /* NIS key lookup failed: default to user home directory from password file */
- DEBUG(5, ("NIS lookup failed. Using Home path from passwd file. Home path is: %s\n", server_path ));
+ /* NIS key lookup failed: default to
+ * user home directory from password file */
+ DEBUG(5, ("NIS lookup failed. Using Home path from "
+ "passwd file. Home path is: %s\n", server_path ));
}
}
#endif
DEBUG(4,("Home server path: %s\n", server_path));
-
return server_path;
}
moved out to a separate function.
*******************************************************************/
-static char *automount_server(const char *user_name)
+static const char *automount_server(const char *user_name)
{
- static pstring server_name;
+ TALLOC_CTX *ctx = talloc_tos();
+ const char *server_name;
+ const char *local_machine_name = get_local_machine_name();
/* use the local machine name as the default */
/* this will be the default if WITH_AUTOMOUNT is not used or fails */
- if (*local_machine)
- pstrcpy(server_name, local_machine);
- else
- pstrcpy(server_name, global_myname);
-
-#if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
+ if (local_machine_name && *local_machine_name) {
+ server_name = talloc_strdup(ctx, local_machine_name);
+ } else {
+ server_name = talloc_strdup(ctx, global_myname());
+ }
+ if (!server_name) {
+ return "";
+ }
+
+#if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
if (lp_nis_home_map()) {
- int home_server_len;
- char *automount_value = automount_lookup(user_name);
- home_server_len = strcspn(automount_value,":");
- DEBUG(5, ("NIS lookup succeeded. Home server length: %d\n",home_server_len));
- if (home_server_len > sizeof(pstring))
- home_server_len = sizeof(pstring);
- strncpy(server_name, automount_value, home_server_len);
- server_name[home_server_len] = '\0';
+ char *p;
+ char *srv;
+ char *automount_value = automount_lookup(ctx, user_name);
+ if (!automount_value) {
+ return "";
+ }
+ srv = talloc_strdup(ctx, automount_value);
+ if (!srv) {
+ return "";
+ }
+ p = strchr_m(srv, ':');
+ if (!p) {
+ return "";
+ }
+ *p = '\0';
+ server_name = srv;
+ DEBUG(5, ("NIS lookup succeeded. Home server %s\n",
+ server_name));
}
#endif
DEBUG(4,("Home server: %s\n", server_name));
-
return server_name;
}
/****************************************************************************
Do some standard substitutions in a string.
+ len is the length in bytes of the space allowed in string str. If zero means
+ don't allow expansions.
****************************************************************************/
-void standard_sub_basic(const char *smb_name, char *str)
+void standard_sub_basic(const char *smb_name, const char *domain_name,
+ char *str, size_t len)
{
- char *p, *s;
- fstring pidstr;
- struct passwd *pass;
+ char *s;
+
+ if ( (s = alloc_sub_basic( smb_name, domain_name, str )) != NULL ) {
+ strncpy( str, s, len );
+ }
+
+ SAFE_FREE( s );
+
+}
- for (s=str; (p=strchr_m(s, '%'));s=p) {
- fstring tmp_str;
+/****************************************************************************
+ Do some standard substitutions in a string.
+ This function will return an allocated string that have to be freed.
+****************************************************************************/
+
+char *talloc_sub_basic(TALLOC_CTX *mem_ctx, const char *smb_name,
+ const char *domain_name, const char *str)
+{
+ char *a, *t;
+
+ if ( (a = alloc_sub_basic(smb_name, domain_name, str)) == NULL ) {
+ return NULL;
+ }
+ t = talloc_strdup(mem_ctx, a);
+ SAFE_FREE(a);
+ return t;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+char *alloc_sub_basic(const char *smb_name, const char *domain_name,
+ const char *str)
+{
+ char *b, *p, *s, *r, *a_string;
+ fstring pidstr, vnnstr;
+ char addr[INET6_ADDRSTRLEN];
+ const char *local_machine_name = get_local_machine_name();
+ TALLOC_CTX *tmp_ctx = NULL;
+
+ /* workaround to prevent a crash while looking at bug #687 */
+
+ if (!str) {
+ DEBUG(0,("alloc_sub_basic: NULL source string! This should not happen\n"));
+ return NULL;
+ }
+
+ a_string = SMB_STRDUP(str);
+ if (a_string == NULL) {
+ DEBUG(0, ("alloc_sub_basic: Out of memory!\n"));
+ return NULL;
+ }
+
+ tmp_ctx = talloc_stackframe();
+
+ for (b = s = a_string; (p = strchr_m(s, '%')); s = a_string + (p - b)) {
+
+ r = NULL;
+ b = a_string;
- int l = sizeof(pstring) - (int)(p-str);
-
switch (*(p+1)) {
case 'U' :
- fstrcpy(tmp_str, smb_name);
- strlower(tmp_str);
- string_sub(p,"%U",tmp_str,l);
+ r = strdup_lower(smb_name);
+ if (r == NULL) {
+ goto error;
+ }
+ a_string = realloc_string_sub(a_string, "%U", r);
break;
- case 'G' :
- fstrcpy(tmp_str, smb_name);
- if ((pass = Get_Pwnam(tmp_str))!=NULL) {
- string_sub(p,"%G",gidtoname(pass->pw_gid),l);
- } else {
- p += 2;
+ case 'G' : {
+ struct passwd *pass;
+ r = SMB_STRDUP(smb_name);
+ if (r == NULL) {
+ goto error;
+ }
+ pass = Get_Pwnam_alloc(tmp_ctx, r);
+ if (pass != NULL) {
+ a_string = realloc_string_sub(
+ a_string, "%G",
+ gidtoname(pass->pw_gid));
}
+ TALLOC_FREE(pass);
break;
+ }
case 'D' :
- fstrcpy(tmp_str, current_user_info.domain);
- strupper(tmp_str);
- string_sub(p,"%D", tmp_str,l);
+ r = strdup_upper(domain_name);
+ if (r == NULL) {
+ goto error;
+ }
+ a_string = realloc_string_sub(a_string, "%D", r);
+ break;
+ case 'I' : {
+ int offset = 0;
+ client_addr(get_client_fd(), addr, sizeof(addr));
+ if (strnequal(addr,"::ffff:",7)) {
+ offset = 7;
+ }
+ a_string = realloc_string_sub(a_string, "%I",
+ addr + offset);
+ break;
+ }
+ case 'i':
+ a_string = realloc_string_sub( a_string, "%i",
+ client_socket_addr(get_client_fd(), addr, sizeof(addr)) );
break;
- case 'I' : string_sub(p,"%I", client_addr(),l); break;
case 'L' :
- if (*local_machine) {
- string_sub(p,"%L", local_machine,l);
+ if ( StrnCaseCmp(p, "%LOGONSERVER%", strlen("%LOGONSERVER%")) == 0 ) {
+ break;
+ }
+ if (local_machine_name && *local_machine_name) {
+ a_string = realloc_string_sub(a_string, "%L", local_machine_name);
} else {
- string_sub(p,"%L", global_myname,l);
+ a_string = realloc_string_sub(a_string, "%L", global_myname());
}
break;
- case 'M' : string_sub(p,"%M", client_name(),l); break;
- case 'R' : string_sub(p,"%R", remote_proto,l); break;
- case 'T' : string_sub(p,"%T", timestring(False),l); break;
- case 'a' : string_sub(p,"%a", remote_arch,l); break;
+ case 'N':
+ a_string = realloc_string_sub(a_string, "%N", automount_server(smb_name));
+ break;
+ case 'M' :
+ a_string = realloc_string_sub(a_string, "%M", client_name(get_client_fd()));
+ break;
+ case 'R' :
+ a_string = realloc_string_sub(a_string, "%R", remote_proto);
+ break;
+ case 'T' :
+ a_string = realloc_string_sub(a_string, "%T", current_timestring(tmp_ctx, False));
+ break;
+ case 'a' :
+ a_string = realloc_string_sub(a_string, "%a",
+ get_remote_arch_str());
+ break;
case 'd' :
slprintf(pidstr,sizeof(pidstr)-1, "%d",(int)sys_getpid());
- string_sub(p,"%d", pidstr,l);
- break;
- case 'h' : string_sub(p,"%h", myhostname(),l); break;
- case 'm' : string_sub(p,"%m", remote_machine,l); break;
- case 'v' : string_sub(p,"%v", VERSION,l); break;
- case '$' : p += expand_env_var(p,l); break; /* Expand environment variables */
- case '\0':
- p++;
- break; /* don't run off the end of the string */
-
- default: p+=2;
+ a_string = realloc_string_sub(a_string, "%d", pidstr);
+ break;
+ case 'h' :
+ a_string = realloc_string_sub(a_string, "%h", myhostname());
+ break;
+ case 'm' :
+ a_string = realloc_string_sub(a_string, "%m",
+ remote_machine
+ ? remote_machine
+ : "");
+ break;
+ case 'v' :
+ a_string = realloc_string_sub(a_string, "%v", SAMBA_VERSION_STRING);
+ break;
+ case 'w' :
+ a_string = realloc_string_sub(a_string, "%w", lp_winbind_separator());
+ break;
+ case '$' :
+ a_string = realloc_expand_env_var(a_string, p); /* Expand environment variables */
+ break;
+ case '(':
+ a_string = realloc_expand_longvar( a_string, p );
+ break;
+ case 'V' :
+ slprintf(vnnstr,sizeof(vnnstr)-1, "%u", get_my_vnn());
+ a_string = realloc_string_sub(a_string, "%V", vnnstr);
+ break;
+ default:
break;
}
+
+ p++;
+ SAFE_FREE(r);
+
+ if (a_string == NULL) {
+ goto done;
+ }
}
+
+ goto done;
+
+error:
+ SAFE_FREE(a_string);
+
+done:
+ TALLOC_FREE(tmp_ctx);
+ return a_string;
}
/****************************************************************************
- Do some standard substitutions in a string.
+ Do some specific substitutions in a string.
+ This function will return an allocated string that have to be freed.
****************************************************************************/
-static void standard_sub_advanced(int snum, const char *user,
- const char *connectpath, gid_t gid,
- const char *smb_name, char *str)
+char *talloc_sub_specified(TALLOC_CTX *mem_ctx,
+ const char *input_string,
+ const char *username,
+ const char *domain,
+ uid_t uid,
+ gid_t gid)
{
- char *p, *s, *home;
+ char *a_string;
+ char *ret_string = NULL;
+ char *b, *p, *s;
+ TALLOC_CTX *tmp_ctx;
+
+ if (!(tmp_ctx = talloc_new(mem_ctx))) {
+ DEBUG(0, ("talloc_new failed\n"));
+ return NULL;
+ }
- for (s=str; (p=strchr_m(s, '%'));s=p) {
- int l = sizeof(pstring) - (int)(p-str);
+ a_string = talloc_strdup(tmp_ctx, input_string);
+ if (a_string == NULL) {
+ DEBUG(0, ("talloc_sub_specified: Out of memory!\n"));
+ goto done;
+ }
+
+ for (b = s = a_string; (p = strchr_m(s, '%')); s = a_string + (p - b)) {
+
+ b = a_string;
switch (*(p+1)) {
- case 'N' : string_sub(p,"%N", automount_server(user),l); break;
- case 'H':
- if ((home = get_user_home_dir(user))) {
- string_sub(p,"%H",home, l);
+ case 'U' :
+ a_string = talloc_string_sub(
+ tmp_ctx, a_string, "%U", username);
+ break;
+ case 'u' :
+ a_string = talloc_string_sub(
+ tmp_ctx, a_string, "%u", username);
+ break;
+ case 'G' :
+ if (gid != -1) {
+ a_string = talloc_string_sub(
+ tmp_ctx, a_string, "%G",
+ gidtoname(gid));
+ } else {
+ a_string = talloc_string_sub(
+ tmp_ctx, a_string,
+ "%G", "NO_GROUP");
+ }
+ break;
+ case 'g' :
+ if (gid != -1) {
+ a_string = talloc_string_sub(
+ tmp_ctx, a_string, "%g",
+ gidtoname(gid));
} else {
- p += 2;
+ a_string = talloc_string_sub(
+ tmp_ctx, a_string, "%g", "NO_GROUP");
}
break;
+ case 'D' :
+ a_string = talloc_string_sub(tmp_ctx, a_string,
+ "%D", domain);
+ break;
+ case 'N' :
+ a_string = talloc_string_sub(
+ tmp_ctx, a_string, "%N",
+ automount_server(username));
+ break;
+ default:
+ break;
+ }
+
+ p++;
+ if (a_string == NULL) {
+ goto done;
+ }
+ }
+
+ /* Watch out, using "mem_ctx" here, so all intermediate stuff goes
+ * away with the TALLOC_FREE(tmp_ctx) further down. */
+
+ ret_string = talloc_sub_basic(mem_ctx, username, domain, a_string);
+
+ done:
+ TALLOC_FREE(tmp_ctx);
+ return ret_string;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static char *alloc_sub_advanced(const char *servicename, const char *user,
+ const char *connectpath, gid_t gid,
+ const char *smb_name, const char *domain_name,
+ const char *str)
+{
+ char *a_string, *ret_string;
+ char *b, *p, *s;
+
+ a_string = SMB_STRDUP(str);
+ if (a_string == NULL) {
+ DEBUG(0, ("alloc_sub_advanced: Out of memory!\n"));
+ return NULL;
+ }
+
+ for (b = s = a_string; (p = strchr_m(s, '%')); s = a_string + (p - b)) {
+
+ b = a_string;
+
+ switch (*(p+1)) {
+ case 'N' :
+ a_string = realloc_string_sub(a_string, "%N", automount_server(user));
+ break;
+ case 'H': {
+ char *h;
+ if ((h = get_user_home_dir(talloc_tos(), user)))
+ a_string = realloc_string_sub(a_string, "%H", h);
+ TALLOC_FREE(h);
+ break;
+ }
case 'P':
- string_sub(p,"%P", connectpath, l);
+ a_string = realloc_string_sub(a_string, "%P", connectpath);
break;
-
case 'S':
- string_sub(p,"%S", lp_servicename(snum), l);
+ a_string = realloc_string_sub(a_string, "%S", servicename);
break;
-
case 'g':
- string_sub(p,"%g", gidtoname(gid), l);
+ a_string = realloc_string_sub(a_string, "%g", gidtoname(gid));
break;
case 'u':
- string_sub(p,"%u", user, l);
+ a_string = realloc_string_sub(a_string, "%u", user);
break;
/* Patch from jkf@soton.ac.uk Left the %N (NIS
* "path =" string in [homes] and so needs the
* service name, not the username. */
case 'p':
- string_sub(p,"%p", automount_path(lp_servicename(snum)), l);
+ a_string = realloc_string_sub(a_string, "%p",
+ automount_path(servicename));
break;
- case '\0':
- p++;
- break; /* don't run off the end of the string */
- default: p+=2;
+ default:
break;
}
+
+ p++;
+ if (a_string == NULL) {
+ return NULL;
+ }
}
- standard_sub_basic(smb_name, str);
+ ret_string = alloc_sub_basic(smb_name, domain_name, a_string);
+ SAFE_FREE(a_string);
+ return ret_string;
}
-const char *standard_sub_specified(TALLOC_CTX *mem_ctx, const char *input_string,
- const char *username,
- const char *domain,
- uid_t uid,
- gid_t gid)
-{
- pstring input_pstring;
- char *p, *s;
+/*
+ * This obviously is inefficient and needs to be merged into
+ * alloc_sub_advanced...
+ */
- pstrcpy(input_pstring, input_string);
-
- for (s=input_pstring; (p=strchr_m(s, '%')); s=p) {
+char *talloc_sub_advanced(TALLOC_CTX *mem_ctx,
+ const char *servicename, const char *user,
+ const char *connectpath, gid_t gid,
+ const char *smb_name, const char *domain_name,
+ const char *str)
+{
+ char *a, *t;
- int l = sizeof(pstring) - (int)(p-input_pstring);
-
- switch (*(p+1)) {
- case 'U' :
- string_sub(p,"%U",username,l);
- break;
- case 'u' :
- string_sub(p,"%u",username,l);
- break;
- case 'G' :
- case 'g' :
- if (gid != -1) {
- string_sub(p,"%G",gidtoname(gid),l);
- string_sub(p,"%g",gidtoname(gid),l);
- } else {
- string_sub(p,"%G","NO_GROUP",l);
- string_sub(p,"%g","NO_GROUP",l);
- }
- break;
- case 'D' :
- string_sub(p,"%D", domain,l);
- break;
- case 'N' :
- string_sub(p,"%N", automount_server(username),l);
- break;
- case '\0':
- p++;
- break; /* don't run off the end of the string */
-
- default: p+=2;
- break;
- }
+ if (!(a = alloc_sub_advanced(servicename, user, connectpath, gid,
+ smb_name, domain_name, str))) {
+ return NULL;
}
-
- standard_sub_basic(username, input_pstring);
-
- return talloc_strdup(mem_ctx, input_pstring);
+ t = talloc_strdup(mem_ctx, a);
+ SAFE_FREE(a);
+ return t;
}
-/****************************************************************************
- Do some standard substitutions in a string.
-****************************************************************************/
-void standard_sub_conn(connection_struct *conn, char *str)
+void standard_sub_advanced(const char *servicename, const char *user,
+ const char *connectpath, gid_t gid,
+ const char *smb_name, const char *domain_name,
+ char *str, size_t len)
{
- standard_sub_advanced(SNUM(conn), conn->user, conn->connectpath, conn->gid, current_user_info.smb_name, str);
+ char *s;
+
+ s = alloc_sub_advanced(servicename, user, connectpath,
+ gid, smb_name, domain_name, str);
+
+ if ( s ) {
+ strncpy( str, s, len );
+ SAFE_FREE( s );
+ }
}
/****************************************************************************
- Like standard_sub but by snum.
+ Do some standard substitutions in a string.
****************************************************************************/
-void standard_sub_snum(int snum, char *str)
+char *standard_sub_conn(TALLOC_CTX *ctx, connection_struct *conn, const char *str)
{
- extern struct current_user current_user;
- static uid_t cached_uid = -1;
- static fstring cached_user;
- /* calling uidtoname() on every substitute would be too expensive, so
- we cache the result here as nearly every call is for the same uid */
-
- if (cached_uid != current_user.uid) {
- fstrcpy(cached_user, uidtoname(current_user.uid));
- cached_uid = current_user.uid;
- }
-
- standard_sub_advanced(snum, cached_user, "", -1, current_user_info.smb_name, str);
+ return talloc_sub_advanced(ctx,
+ lp_servicename(SNUM(conn)),
+ conn->server_info->unix_name,
+ conn->connectpath,
+ conn->server_info->utok.gid,
+ get_smb_user_name(),
+ "",
+ str);
}
-
git.samba.org / kai / samba.git / blobdiff