2 Unix SMB/CIFS implementation.
3 string substitution functions
4 Copyright (C) Andrew Tridgell 1992-2000
5 Copyright (C) Gerald Carter 2006
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "system/passwd.h"
27 static char *alloc_sub_basic(const char *smb_name
, const char *domain_name
,
30 userdom_struct current_user_info
;
31 fstring remote_proto
="UNKNOWN";
34 * Set the 'local' machine name
35 * @param local_name the name we are being called
36 * @param if this is the 'final' name for us, not be be changed again
39 static char *local_machine
;
41 void free_local_machine_name(void)
43 SAFE_FREE(local_machine
);
46 bool set_local_machine_name(const char *local_name
, bool perm
)
48 static bool already_perm
= false;
49 char *tmp_local_machine
= NULL
;
56 tmp_local_machine
= SMB_STRDUP(local_name
);
57 if (!tmp_local_machine
) {
60 trim_char(tmp_local_machine
,' ',' ');
62 SAFE_FREE(local_machine
);
63 len
= strlen(tmp_local_machine
);
64 local_machine
= SMB_CALLOC_ARRAY(char, len
+1);
66 SAFE_FREE(tmp_local_machine
);
69 /* alpha_strcpy includes the space for the terminating nul. */
70 alpha_strcpy(local_machine
,tmp_local_machine
,
71 SAFE_NETBIOS_CHARS
,len
+1);
72 strlower_m(local_machine
);
73 SAFE_FREE(tmp_local_machine
);
80 const char *get_local_machine_name(void)
82 if (!local_machine
|| !*local_machine
) {
83 return global_myname();
90 * Set the 'remote' machine name
91 * @param remote_name the name our client wants to be called by
92 * @param if this is the 'final' name for them, not be be changed again
95 static char *remote_machine
;
97 bool set_remote_machine_name(const char *remote_name
, bool perm
)
99 static bool already_perm
= False
;
100 char *tmp_remote_machine
;
107 tmp_remote_machine
= SMB_STRDUP(remote_name
);
108 if (!tmp_remote_machine
) {
111 trim_char(tmp_remote_machine
,' ',' ');
113 SAFE_FREE(remote_machine
);
114 len
= strlen(tmp_remote_machine
);
115 remote_machine
= SMB_CALLOC_ARRAY(char, len
+1);
116 if (!remote_machine
) {
117 SAFE_FREE(tmp_remote_machine
);
121 /* alpha_strcpy includes the space for the terminating nul. */
122 alpha_strcpy(remote_machine
,tmp_remote_machine
,
123 SAFE_NETBIOS_CHARS
,len
+1);
124 strlower_m(remote_machine
);
125 SAFE_FREE(tmp_remote_machine
);
132 const char *get_remote_machine_name(void)
134 return remote_machine
? remote_machine
: "";
137 /*******************************************************************
138 Setup the string used by %U substitution.
139 ********************************************************************/
141 static char *smb_user_name
;
143 void sub_set_smb_name(const char *name
)
147 bool is_machine_account
= false;
149 /* don't let anonymous logins override the name */
150 if (!name
|| !*name
) {
154 tmp
= SMB_STRDUP(name
);
158 trim_char(tmp
, ' ', ' ');
168 /* long story but here goes....we have to allow usernames
169 ending in '$' as they are valid machine account names.
170 So check for a machine account and re-add the '$'
171 at the end after the call to alpha_strcpy(). --jerry */
173 if (tmp
[len
-1] == '$') {
174 is_machine_account
= True
;
177 SAFE_FREE(smb_user_name
);
178 smb_user_name
= SMB_CALLOC_ARRAY(char, len
+1);
179 if (!smb_user_name
) {
184 /* alpha_strcpy includes the space for the terminating nul. */
185 alpha_strcpy(smb_user_name
, tmp
,
191 if (is_machine_account
) {
192 len
= strlen(smb_user_name
);
193 smb_user_name
[len
-1] = '$';
197 static char sub_peeraddr
[INET6_ADDRSTRLEN
];
198 static const char *sub_peername
= NULL
;
199 static char sub_sockaddr
[INET6_ADDRSTRLEN
];
201 void sub_set_socket_ids(const char *peeraddr
, const char *peername
,
202 const char *sockaddr
)
204 const char *addr
= peeraddr
;
206 if (strnequal(addr
, "::ffff:", 7)) {
209 strlcpy(sub_peeraddr
, addr
, sizeof(sub_peeraddr
));
211 if (sub_peername
!= NULL
&&
212 sub_peername
!= sub_peeraddr
) {
213 free(discard_const_p(char,sub_peername
));
216 sub_peername
= SMB_STRDUP(peername
);
217 if (sub_peername
== NULL
) {
218 sub_peername
= sub_peeraddr
;
222 * Shouldn't we do the ::ffff: cancellation here as well? The
223 * original code in alloc_sub_basic() did not do it, so I'm
224 * leaving it out here as well for compatibility.
226 strlcpy(sub_sockaddr
, sockaddr
, sizeof(sub_sockaddr
));
229 static const char *get_smb_user_name(void)
231 return smb_user_name
? smb_user_name
: "";
234 /*******************************************************************
235 Setup the strings used by substitutions. Called per packet. Ensure
236 %U name is set correctly also.
238 smb_name must be sanitized by alpha_strcpy
239 ********************************************************************/
241 void set_current_user_info(const char *smb_name
, const char *unix_name
,
244 fstrcpy(current_user_info
.smb_name
, smb_name
);
245 fstrcpy(current_user_info
.unix_name
, unix_name
);
246 fstrcpy(current_user_info
.domain
, domain
);
248 /* The following is safe as current_user_info.smb_name
249 * has already been sanitised in register_existing_vuid. */
251 sub_set_smb_name(current_user_info
.smb_name
);
254 /*******************************************************************
255 Return the current active user name.
256 *******************************************************************/
258 const char *get_current_username(void)
260 if (current_user_info
.smb_name
[0] == '\0' ) {
261 return get_smb_user_name();
264 return current_user_info
.smb_name
;
267 /*******************************************************************
268 Given a pointer to a %$(NAME) in p and the whole string in str
269 expand it as an environment variable.
270 Return a new allocated and expanded string.
271 Based on code by Branko Cibej <branko.cibej@hermes.si>
272 When this is called p points at the '%' character.
273 May substitute multiple occurrencies of the same env var.
274 ********************************************************************/
276 static char * realloc_expand_env_var(char *str
, char *p
)
283 if (p
[0] != '%' || p
[1] != '$' || p
[2] != '(') {
288 * Look for the terminating ')'.
291 if ((q
= strchr_m(p
,')')) == NULL
) {
292 DEBUG(0,("expand_env_var: Unterminated environment variable [%s]\n", p
));
297 * Extract the name from within the %$(NAME) string.
303 /* reserve space for use later add %$() chars */
304 if ( (envname
= (char *)SMB_MALLOC(copylen
+ 1 + 4)) == NULL
) {
308 strncpy(envname
,r
,copylen
);
309 envname
[copylen
] = '\0';
311 if ((envval
= getenv(envname
)) == NULL
) {
312 DEBUG(0,("expand_env_var: Environment variable [%s] not set\n", envname
));
318 * Copy the full %$(NAME) into envname so it
323 strncpy(envname
,p
,copylen
);
324 envname
[copylen
] = '\0';
325 r
= realloc_string_sub(str
, envname
, envval
);
331 /*******************************************************************
332 *******************************************************************/
334 static char *longvar_domainsid( void )
340 if ( !secrets_fetch_domain_sid( lp_workgroup(), &sid
) ) {
344 sid_string
= SMB_STRDUP( sid_to_fstring( tmp
, &sid
) );
347 DEBUG(0,("longvar_domainsid: failed to dup SID string!\n"));
353 /*******************************************************************
354 *******************************************************************/
361 static struct api_longvar longvar_table
[] = {
362 { "DomainSID", longvar_domainsid
},
366 static char *get_longvar_val( const char *varname
)
370 DEBUG(7,("get_longvar_val: expanding variable [%s]\n", varname
));
372 for ( i
=0; longvar_table
[i
].name
; i
++ ) {
373 if ( strequal( longvar_table
[i
].name
, varname
) ) {
374 return longvar_table
[i
].fn();
381 /*******************************************************************
382 Expand the long smb.conf variable names given a pointer to a %(NAME).
383 Return the number of characters by which the pointer should be advanced.
384 When this is called p points at the '%' character.
385 ********************************************************************/
387 static char *realloc_expand_longvar(char *str
, char *p
)
394 if ( p
[0] != '%' || p
[1] != '(' ) {
398 /* Look for the terminating ')'.*/
400 if ((q
= strchr_m(p
,')')) == NULL
) {
401 DEBUG(0,("realloc_expand_longvar: Unterminated environment variable [%s]\n", p
));
405 /* Extract the name from within the %(NAME) string.*/
408 copylen
= MIN( (q
-r
), (sizeof(varname
)-1) );
409 strncpy(varname
, r
, copylen
);
410 varname
[copylen
] = '\0';
412 if ((value
= get_longvar_val(varname
)) == NULL
) {
413 DEBUG(0,("realloc_expand_longvar: Variable [%s] not set. Skipping\n", varname
));
417 /* Copy the full %(NAME) into envname so it can be replaced.*/
419 copylen
= MIN( (q
+1-p
),(sizeof(varname
)-1) );
420 strncpy( varname
, p
, copylen
);
421 varname
[copylen
] = '\0';
422 r
= realloc_string_sub(str
, varname
, value
);
425 /* skip over the %(varname) */
430 /*******************************************************************
431 Patch from jkf@soton.ac.uk
432 Added this to implement %p (NIS auto-map version of %H)
433 *******************************************************************/
435 static const char *automount_path(const char *user_name
)
437 TALLOC_CTX
*ctx
= talloc_tos();
438 const char *server_path
;
440 /* use the passwd entry as the default */
441 /* this will be the default if WITH_AUTOMOUNT is not used or fails */
443 server_path
= talloc_strdup(ctx
, get_user_home_dir(ctx
, user_name
));
448 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
450 if (lp_nis_home_map()) {
451 const char *home_path_start
;
452 char *automount_value
= automount_lookup(ctx
, user_name
);
454 if(automount_value
&& strlen(automount_value
) > 0) {
455 home_path_start
= strchr_m(automount_value
,':');
456 if (home_path_start
!= NULL
) {
457 DEBUG(5, ("NIS lookup succeeded. "
458 "Home path is: %s\n",
460 (home_path_start
+1):""));
461 server_path
= talloc_strdup(ctx
,
468 /* NIS key lookup failed: default to
469 * user home directory from password file */
470 DEBUG(5, ("NIS lookup failed. Using Home path from "
471 "passwd file. Home path is: %s\n", server_path
));
476 DEBUG(4,("Home server path: %s\n", server_path
));
480 /*******************************************************************
481 Patch from jkf@soton.ac.uk
482 This is Luke's original function with the NIS lookup code
483 moved out to a separate function.
484 *******************************************************************/
486 static const char *automount_server(const char *user_name
)
488 TALLOC_CTX
*ctx
= talloc_tos();
489 const char *server_name
;
490 const char *local_machine_name
= get_local_machine_name();
492 /* use the local machine name as the default */
493 /* this will be the default if WITH_AUTOMOUNT is not used or fails */
494 if (local_machine_name
&& *local_machine_name
) {
495 server_name
= talloc_strdup(ctx
, local_machine_name
);
497 server_name
= talloc_strdup(ctx
, global_myname());
504 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
505 if (lp_nis_home_map()) {
508 char *automount_value
= automount_lookup(ctx
, user_name
);
509 if (!automount_value
) {
512 srv
= talloc_strdup(ctx
, automount_value
);
516 p
= strchr_m(srv
, ':');
522 DEBUG(5, ("NIS lookup succeeded. Home server %s\n",
527 DEBUG(4,("Home server: %s\n", server_name
));
531 /****************************************************************************
532 Do some standard substitutions in a string.
533 len is the length in bytes of the space allowed in string str. If zero means
534 don't allow expansions.
535 ****************************************************************************/
537 void standard_sub_basic(const char *smb_name
, const char *domain_name
,
538 char *str
, size_t len
)
542 if ( (s
= alloc_sub_basic( smb_name
, domain_name
, str
)) != NULL
) {
543 strncpy( str
, s
, len
);
549 /****************************************************************************
550 Do some standard substitutions in a string.
551 This function will return an allocated string that have to be freed.
552 ****************************************************************************/
554 char *talloc_sub_basic(TALLOC_CTX
*mem_ctx
, const char *smb_name
,
555 const char *domain_name
, const char *str
)
559 if ( (a
= alloc_sub_basic(smb_name
, domain_name
, str
)) == NULL
) {
562 t
= talloc_strdup(mem_ctx
, a
);
567 /****************************************************************************
568 ****************************************************************************/
570 static char *alloc_sub_basic(const char *smb_name
, const char *domain_name
,
573 char *b
, *p
, *s
, *r
, *a_string
;
574 fstring pidstr
, vnnstr
;
575 const char *local_machine_name
= get_local_machine_name();
576 TALLOC_CTX
*tmp_ctx
= NULL
;
578 /* workaround to prevent a crash while looking at bug #687 */
581 DEBUG(0,("alloc_sub_basic: NULL source string! This should not happen\n"));
585 a_string
= SMB_STRDUP(str
);
586 if (a_string
== NULL
) {
587 DEBUG(0, ("alloc_sub_basic: Out of memory!\n"));
591 tmp_ctx
= talloc_stackframe();
593 for (b
= s
= a_string
; (p
= strchr_m(s
, '%')); s
= a_string
+ (p
- b
)) {
600 r
= strlower_talloc(tmp_ctx
, smb_name
);
604 a_string
= realloc_string_sub(a_string
, "%U", r
);
608 r
= talloc_strdup(tmp_ctx
, smb_name
);
612 pass
= Get_Pwnam_alloc(tmp_ctx
, r
);
614 a_string
= realloc_string_sub(
616 gidtoname(pass
->pw_gid
));
622 r
= strupper_talloc(tmp_ctx
, domain_name
);
626 a_string
= realloc_string_sub(a_string
, "%D", r
);
629 a_string
= realloc_string_sub(
631 sub_peeraddr
[0] ? sub_peeraddr
: "0.0.0.0");
635 a_string
= realloc_string_sub(
637 sub_sockaddr
[0] ? sub_sockaddr
: "0.0.0.0");
640 if ( StrnCaseCmp(p
, "%LOGONSERVER%", strlen("%LOGONSERVER%")) == 0 ) {
643 if (local_machine_name
&& *local_machine_name
) {
644 a_string
= realloc_string_sub(a_string
, "%L", local_machine_name
);
646 a_string
= realloc_string_sub(a_string
, "%L", global_myname());
650 a_string
= realloc_string_sub(a_string
, "%N", automount_server(smb_name
));
653 a_string
= realloc_string_sub(a_string
, "%M",
654 sub_peername
? sub_peername
: "");
657 a_string
= realloc_string_sub(a_string
, "%R", remote_proto
);
660 a_string
= realloc_string_sub(a_string
, "%T", current_timestring(tmp_ctx
, False
));
663 a_string
= realloc_string_sub(a_string
, "%a",
664 get_remote_arch_str());
667 slprintf(pidstr
,sizeof(pidstr
)-1, "%d",(int)sys_getpid());
668 a_string
= realloc_string_sub(a_string
, "%d", pidstr
);
671 a_string
= realloc_string_sub(a_string
, "%h", myhostname());
674 a_string
= realloc_string_sub(a_string
, "%m",
680 a_string
= realloc_string_sub(a_string
, "%v", samba_version_string());
683 a_string
= realloc_string_sub(a_string
, "%w", lp_winbind_separator());
686 a_string
= realloc_expand_env_var(a_string
, p
); /* Expand environment variables */
689 a_string
= realloc_expand_longvar( a_string
, p
);
692 slprintf(vnnstr
,sizeof(vnnstr
)-1, "%u", get_my_vnn());
693 a_string
= realloc_string_sub(a_string
, "%V", vnnstr
);
702 if (a_string
== NULL
) {
713 TALLOC_FREE(tmp_ctx
);
717 /****************************************************************************
718 Do some specific substitutions in a string.
719 This function will return an allocated string that have to be freed.
720 ****************************************************************************/
722 char *talloc_sub_specified(TALLOC_CTX
*mem_ctx
,
723 const char *input_string
,
724 const char *username
,
730 char *ret_string
= NULL
;
734 if (!(tmp_ctx
= talloc_new(mem_ctx
))) {
735 DEBUG(0, ("talloc_new failed\n"));
739 a_string
= talloc_strdup(tmp_ctx
, input_string
);
740 if (a_string
== NULL
) {
741 DEBUG(0, ("talloc_sub_specified: Out of memory!\n"));
745 for (b
= s
= a_string
; (p
= strchr_m(s
, '%')); s
= a_string
+ (p
- b
)) {
751 a_string
= talloc_string_sub(
752 tmp_ctx
, a_string
, "%U", username
);
755 a_string
= talloc_string_sub(
756 tmp_ctx
, a_string
, "%u", username
);
760 a_string
= talloc_string_sub(
761 tmp_ctx
, a_string
, "%G",
764 a_string
= talloc_string_sub(
771 a_string
= talloc_string_sub(
772 tmp_ctx
, a_string
, "%g",
775 a_string
= talloc_string_sub(
776 tmp_ctx
, a_string
, "%g", "NO_GROUP");
780 a_string
= talloc_string_sub(tmp_ctx
, a_string
,
784 a_string
= talloc_string_sub(
785 tmp_ctx
, a_string
, "%N",
786 automount_server(username
));
793 if (a_string
== NULL
) {
798 /* Watch out, using "mem_ctx" here, so all intermediate stuff goes
799 * away with the TALLOC_FREE(tmp_ctx) further down. */
801 ret_string
= talloc_sub_basic(mem_ctx
, username
, domain
, a_string
);
804 TALLOC_FREE(tmp_ctx
);
808 /****************************************************************************
809 ****************************************************************************/
811 static char *alloc_sub_advanced(const char *servicename
, const char *user
,
812 const char *connectpath
, gid_t gid
,
813 const char *smb_name
, const char *domain_name
,
816 char *a_string
, *ret_string
;
819 a_string
= SMB_STRDUP(str
);
820 if (a_string
== NULL
) {
821 DEBUG(0, ("alloc_sub_advanced: Out of memory!\n"));
825 for (b
= s
= a_string
; (p
= strchr_m(s
, '%')); s
= a_string
+ (p
- b
)) {
831 a_string
= realloc_string_sub(a_string
, "%N", automount_server(user
));
835 if ((h
= get_user_home_dir(talloc_tos(), user
)))
836 a_string
= realloc_string_sub(a_string
, "%H", h
);
841 a_string
= realloc_string_sub(a_string
, "%P", connectpath
);
844 a_string
= realloc_string_sub(a_string
, "%S", servicename
);
847 a_string
= realloc_string_sub(a_string
, "%g", gidtoname(gid
));
850 a_string
= realloc_string_sub(a_string
, "%u", user
);
853 /* Patch from jkf@soton.ac.uk Left the %N (NIS
854 * server name) in standard_sub_basic as it is
855 * a feature for logon servers, hence uses the
856 * username. The %p (NIS server path) code is
857 * here as it is used instead of the default
858 * "path =" string in [homes] and so needs the
859 * service name, not the username. */
861 a_string
= realloc_string_sub(a_string
, "%p",
862 automount_path(servicename
));
870 if (a_string
== NULL
) {
875 ret_string
= alloc_sub_basic(smb_name
, domain_name
, a_string
);
881 * This obviously is inefficient and needs to be merged into
882 * alloc_sub_advanced...
885 char *talloc_sub_advanced(TALLOC_CTX
*mem_ctx
,
886 const char *servicename
, const char *user
,
887 const char *connectpath
, gid_t gid
,
888 const char *smb_name
, const char *domain_name
,
893 if (!(a
= alloc_sub_advanced(servicename
, user
, connectpath
, gid
,
894 smb_name
, domain_name
, str
))) {
897 t
= talloc_strdup(mem_ctx
, a
);
903 void standard_sub_advanced(const char *servicename
, const char *user
,
904 const char *connectpath
, gid_t gid
,
905 const char *smb_name
, const char *domain_name
,
906 char *str
, size_t len
)
910 s
= alloc_sub_advanced(servicename
, user
, connectpath
,
911 gid
, smb_name
, domain_name
, str
);
914 strncpy( str
, s
, len
);
919 /****************************************************************************
920 Do some standard substitutions in a string.
921 ****************************************************************************/
923 char *standard_sub_conn(TALLOC_CTX
*ctx
, connection_struct
*conn
, const char *str
)
925 return talloc_sub_advanced(ctx
,
926 lp_servicename(SNUM(conn
)),
927 conn
->session_info
->unix_name
,
929 conn
->session_info
->utok
.gid
,