2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1999
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include "system/passwd.h"
24 #include <asm/types.h>
25 #include <linux/smb_fs.h>
27 #define pstrcpy(d,s) safe_strcpy((d),(s),sizeof(pstring)-1)
28 #define pstrcat(d,s) safe_strcat((d),(s),sizeof(pstring)-1)
30 static pstring credentials
;
31 static pstring my_netbios_name
;
32 static pstring password
;
33 static pstring username
;
34 static pstring workgroup
;
35 static pstring mpoint
;
36 static pstring service
;
37 static pstring options
;
39 static struct in_addr dest_ip
;
41 static int smb_port
= 0;
44 static uid_t mount_uid
;
45 static gid_t mount_gid
;
47 static uint_t mount_fmask
;
48 static uint_t mount_dmask
;
49 static bool use_kerberos
;
50 /* TODO: Add code to detect smbfs version in kernel */
51 static bool status32_smbfs
= false;
53 static void usage(void);
55 static void exit_parent(int sig
)
57 /* parent simply exits when child says go... */
61 static void daemonize(void)
66 signal( SIGTERM
, exit_parent
);
68 if ((child_pid
= sys_fork()) < 0) {
69 DEBUG(0,("could not fork\n"));
74 j
= waitpid( child_pid
, &status
, 0 );
76 if( EINTR
== errno
) {
84 /* If we get here - the child exited with some error status */
85 if (WIFSIGNALED(status
))
86 exit(128 + WTERMSIG(status
));
88 exit(WEXITSTATUS(status
));
91 signal( SIGTERM
, SIG_DFL
);
95 static void close_our_files(int client_fd
)
100 getrlimit(RLIMIT_NOFILE
,&limits
);
101 for (i
= 0; i
< limits
.rlim_max
; i
++) {
108 static void usr1_handler(int x
)
114 /*****************************************************
115 return a connection to a server
116 *******************************************************/
117 static struct smbcli_state
*do_connection(const char *the_service
, bool unicode
, int maxprotocol
,
118 struct smbcli_session_options session_options
)
120 struct smbcli_state
*c
;
121 struct nmb_name called
, calling
;
127 if (the_service
[0] != '\\' || the_service
[1] != '\\') {
132 pstrcpy(server
, the_service
+2);
133 share
= strchr_m(server
,'\\');
143 make_nmb_name(&calling
, my_netbios_name
, 0x0);
144 choose_called_name(&called
, server
, 0x20);
148 if (have_ip
) ip
= dest_ip
;
150 /* have to open a new connection */
151 if (!(c
=smbcli_initialise(NULL
)) || (smbcli_set_port(c
, smb_port
) != smb_port
) ||
152 !smbcli_connect(c
, server_n
, &ip
)) {
153 DEBUG(0,("%d: Connection to %s failed\n", sys_getpid(), server_n
));
160 /* SPNEGO doesn't work till we get NTSTATUS error support */
161 /* But it is REQUIRED for kerberos authentication */
162 if(!use_kerberos
) c
->use_spnego
= false;
164 /* The kernel doesn't yet know how to sign it's packets */
165 c
->sign_info
.allow_smb_signing
= false;
167 /* Use kerberos authentication if specified */
168 c
->use_kerberos
= use_kerberos
;
170 if (!smbcli_session_request(c
, &calling
, &called
)) {
172 DEBUG(0,("%d: session request to %s failed (%s)\n",
173 sys_getpid(), called
.name
, smbcli_errstr(c
)));
175 if ((p
=strchr_m(called
.name
, '.'))) {
179 if (strcmp(called
.name
, "*SMBSERVER")) {
180 make_nmb_name(&called
, "*SMBSERVER", 0x20);
186 DEBUG(4,("%d: session request ok\n", sys_getpid()));
188 if (!smbcli_negprot(c
, unicode
, maxprotocol
)) {
189 DEBUG(0,("%d: protocol negotiation failed\n", sys_getpid()));
195 char *pass
= getpass("Password: ");
197 pstrcpy(password
, pass
);
201 /* This should be right for current smbfs. Future versions will support
202 large files as well as unicode and oplocks. */
203 if (status32_smbfs
) {
204 c
->capabilities
&= ~(CAP_UNICODE
| CAP_LARGE_FILES
| CAP_NT_SMBS
|
205 CAP_NT_FIND
| CAP_LEVEL_II_OPLOCKS
);
208 c
->capabilities
&= ~(CAP_UNICODE
| CAP_LARGE_FILES
| CAP_NT_SMBS
|
209 CAP_NT_FIND
| CAP_STATUS32
|
210 CAP_LEVEL_II_OPLOCKS
);
211 c
->force_dos_errors
= true;
214 if (!smbcli_session_setup(c
, username
,
215 password
, strlen(password
),
216 password
, strlen(password
),
217 workgroup
, session_options
)) {
218 /* if a password was not supplied then try again with a
220 if (password
[0] || !username
[0] ||
221 !smbcli_session_setup(c
, "", "", 0, "", 0, workgroup
,
223 DEBUG(0,("%d: session setup failed: %s\n",
224 sys_getpid(), smbcli_errstr(c
)));
228 DEBUG(0,("Anonymous login successful\n"));
231 DEBUG(4,("%d: session setup ok\n", sys_getpid()));
233 if (!smbcli_tconX(c
, share
, "?????", password
, strlen(password
)+1)) {
234 DEBUG(0,("%d: tree connect failed: %s\n",
235 sys_getpid(), smbcli_errstr(c
)));
240 DEBUG(4,("%d: tconx ok\n", sys_getpid()));
248 /****************************************************************************
249 unmount smbfs (this is a bailout routine to clean up if a reconnect fails)
250 Code blatently stolen from smbumount.c
252 ****************************************************************************/
253 static void smb_umount(const char *mount_point
)
261 This routine only gets called to the scene of a disaster
262 to shoot the survivors... A connection that was working
263 has now apparently failed. We have an active mount point
264 (presumably) that we need to dump. If we get errors along
265 the way - make some noise, but we are already turning out
266 the lights to exit anyways...
268 if (umount(mount_point
) != 0) {
269 DEBUG(0,("%d: Could not umount %s: %s\n",
270 sys_getpid(), mount_point
, strerror(errno
)));
274 if ((fd
= open(MOUNTED
"~", O_RDWR
|O_CREAT
|O_EXCL
, 0600)) == -1) {
275 DEBUG(0,("%d: Can't get "MOUNTED
"~ lock file", sys_getpid()));
281 if ((mtab
= setmntent(MOUNTED
, "r")) == NULL
) {
282 DEBUG(0,("%d: Can't open " MOUNTED
": %s\n",
283 sys_getpid(), strerror(errno
)));
287 #define MOUNTED_TMP MOUNTED".tmp"
289 if ((new_mtab
= setmntent(MOUNTED_TMP
, "w")) == NULL
) {
290 DEBUG(0,("%d: Can't open " MOUNTED_TMP
": %s\n",
291 sys_getpid(), strerror(errno
)));
296 while ((mnt
= getmntent(mtab
)) != NULL
) {
297 if (strcmp(mnt
->mnt_dir
, mount_point
) != 0) {
298 addmntent(new_mtab
, mnt
);
304 if (fchmod (fileno (new_mtab
), S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IROTH
) < 0) {
305 DEBUG(0,("%d: Error changing mode of %s: %s\n",
306 sys_getpid(), MOUNTED_TMP
, strerror(errno
)));
312 if (rename(MOUNTED_TMP
, MOUNTED
) < 0) {
313 DEBUG(0,("%d: Cannot rename %s to %s: %s\n",
314 sys_getpid(), MOUNTED
, MOUNTED_TMP
, strerror(errno
)));
318 if (unlink(MOUNTED
"~") == -1) {
319 DEBUG(0,("%d: Can't remove "MOUNTED
"~", sys_getpid()));
326 * Call the smbfs ioctl to install a connection socket,
327 * then wait for a signal to reconnect. Note that we do
328 * not exit after open_sockets() or send_login() errors,
329 * as the smbfs mount would then have no way to recover.
331 static void send_fs_socket(struct loadparm_context
*lp_ctx
,
332 const char *the_service
, const char *mount_point
, struct smbcli_state
*c
)
334 int fd
, closed
= 0, res
= 1;
335 pid_t parentpid
= getppid();
336 struct smb_conn_opt conn_options
;
337 struct smbcli_session_options session_options
;
339 lp_smbcli_session_options(lp_ctx
, &session_options
);
341 memset(&conn_options
, 0, sizeof(conn_options
));
344 if ((fd
= open(mount_point
, O_RDONLY
)) < 0) {
345 DEBUG(0,("mount.smbfs[%d]: can't open %s\n",
346 sys_getpid(), mount_point
));
350 conn_options
.fd
= c
->fd
;
351 conn_options
.protocol
= c
->protocol
;
352 conn_options
.case_handling
= SMB_CASE_DEFAULT
;
353 conn_options
.max_xmit
= c
->max_xmit
;
354 conn_options
.server_uid
= c
->vuid
;
355 conn_options
.tid
= c
->cnum
;
356 conn_options
.secmode
= c
->sec_mode
;
357 conn_options
.rawmode
= 0;
358 conn_options
.sesskey
= c
->sesskey
;
359 conn_options
.maxraw
= 0;
360 conn_options
.capabilities
= c
->capabilities
;
361 conn_options
.serverzone
= c
->serverzone
/60;
363 res
= ioctl(fd
, SMB_IOC_NEWCONN
, &conn_options
);
365 DEBUG(0,("mount.smbfs[%d]: ioctl failed, res=%d\n",
372 /* Ok... We are going to kill the parent. Now
373 is the time to break the process group... */
375 /* Send a signal to the parent to terminate */
376 kill(parentpid
, SIGTERM
);
382 /* This looks wierd but we are only closing the userspace
383 side, the connection has already been passed to smbfs and
384 it has increased the usage count on the socket.
386 If we don't do this we will "leak" sockets and memory on
387 each reconnection we have to make. */
392 /* redirect stdout & stderr since we can't know that
393 the library functions we use are using DEBUG. */
394 if ( (fd
= open("/dev/null", O_WRONLY
)) < 0)
395 DEBUG(2,("mount.smbfs: can't open /dev/null\n"));
398 dup2(fd
, STDOUT_FILENO
);
399 dup2(fd
, STDERR_FILENO
);
403 /* here we are no longer interactive */
404 set_remote_machine_name("smbmount"); /* sneaky ... */
405 setup_logging("mount.smbfs", DEBUG_STDERR
);
407 DEBUG(0, ("mount.smbfs: entering daemon mode for service %s, pid=%d\n", the_service
, sys_getpid()));
412 /* Wait for a signal from smbfs ... but don't continue
413 until we actually get a new connection. */
415 CatchSignal(SIGUSR1
, &usr1_handler
);
417 DEBUG(2,("mount.smbfs[%d]: got signal, getting new socket\n", sys_getpid()));
418 c
= do_connection(the_service
,
420 lp_cli_maxprotocol(lp_ctx
),
425 smb_umount(mount_point
);
426 DEBUG(2,("mount.smbfs[%d]: exit\n", sys_getpid()));
434 static void init_mount(struct loadparm_context
*lp_ctx
)
436 char mount_point
[MAXPATHLEN
+1];
439 struct smbcli_state
*c
;
442 struct smbcli_session_options session_options
;
444 if (realpath(mpoint
, mount_point
) == NULL
) {
445 fprintf(stderr
, "Could not resolve mount point %s\n", mpoint
);
449 lp_smbcli_session_options(lp_ctx
, &session_options
);
451 c
= do_connection(service
, lp_unicode(lp_ctx
), lp_cli_maxprotocol(lp_ctx
),
454 fprintf(stderr
,"SMB connection failed\n");
459 Set up to return as a daemon child and wait in the parent
460 until the child say it's ready...
464 pstrcpy(svc2
, service
);
465 string_replace(svc2
, '\\','/');
466 string_replace(svc2
, ' ','_');
468 memset(args
, 0, sizeof(args
[0])*20);
471 args
[i
++] = "smbmnt";
473 args
[i
++] = mount_point
;
481 slprintf(tmp
, sizeof(tmp
)-1, "%d", mount_uid
);
483 args
[i
++] = smb_xstrdup(tmp
);
486 slprintf(tmp
, sizeof(tmp
)-1, "%d", mount_gid
);
488 args
[i
++] = smb_xstrdup(tmp
);
491 slprintf(tmp
, sizeof(tmp
)-1, "0%o", mount_fmask
);
493 args
[i
++] = smb_xstrdup(tmp
);
496 slprintf(tmp
, sizeof(tmp
)-1, "0%o", mount_dmask
);
498 args
[i
++] = smb_xstrdup(tmp
);
505 if (sys_fork() == 0) {
508 asprintf(&smbmnt_path
, "%s/smbmnt", dyn_BINDIR
);
510 if (file_exist(smbmnt_path
)) {
511 execv(smbmnt_path
, args
);
513 "smbfs/init_mount: execv of %s failed. Error was %s.",
514 smbmnt_path
, strerror(errno
));
516 execvp("smbmnt", args
);
518 "smbfs/init_mount: execv of %s failed. Error was %s.",
519 "smbmnt", strerror(errno
));
525 if (waitpid(-1, &status
, 0) == -1) {
526 fprintf(stderr
,"waitpid failed: Error was %s", strerror(errno
) );
527 /* FIXME: do some proper error handling */
531 if (WIFEXITED(status
) && WEXITSTATUS(status
) != 0) {
532 fprintf(stderr
,"smbmnt failed: %d\n", WEXITSTATUS(status
));
533 /* FIXME: do some proper error handling */
535 } else if (WIFSIGNALED(status
)) {
536 fprintf(stderr
, "smbmnt killed by signal %d\n", WTERMSIG(status
));
540 /* Ok... This is the rubicon for that mount point... At any point
541 after this, if the connections fail and can not be reconstructed
542 for any reason, we will have to unmount the mount point. There
543 is no exit from the next call...
545 send_fs_socket(lp_ctx
, service
, mount_point
, c
);
549 /****************************************************************************
550 get a password from a a file or file descriptor
551 exit on failure (from smbclient, move to libsmb or shared .c file?)
552 ****************************************************************************/
553 static void get_password_file(void)
557 bool close_it
= false;
561 if ((p
= getenv("PASSWD_FD")) != NULL
) {
562 pstrcpy(spec
, "descriptor ");
564 sscanf(p
, "%d", &fd
);
566 } else if ((p
= getenv("PASSWD_FILE")) != NULL
) {
567 fd
= open(p
, O_RDONLY
, 0);
570 fprintf(stderr
, "Error opening PASSWD_FILE %s: %s\n",
571 spec
, strerror(errno
));
577 for(p
= pass
, *p
= '\0'; /* ensure that pass is null-terminated */
578 p
&& p
- pass
< sizeof(pass
);) {
579 switch (read(fd
, p
, 1)) {
581 if (*p
!= '\n' && *p
!= '\0') {
582 *++p
= '\0'; /* advance p, and null-terminate pass */
587 *p
= '\0'; /* null-terminate it, just in case... */
588 p
= NULL
; /* then force the loop condition to become false */
591 fprintf(stderr
, "Error reading password from file %s: %s\n",
592 spec
, "empty password\n");
597 fprintf(stderr
, "Error reading password from file %s: %s\n",
598 spec
, strerror(errno
));
602 pstrcpy(password
, pass
);
607 /****************************************************************************
608 get username and password from a credentials file
609 exit on failure (from smbclient, move to libsmb or shared .c file?)
610 ****************************************************************************/
611 static void read_credentials_file(char *filename
)
616 char *ptr
, *val
, *param
;
618 if ((auth
=sys_fopen(filename
, "r")) == NULL
)
620 /* fail if we can't open the credentials file */
621 DEBUG(0,("ERROR: Unable to open credentials file!\n"));
627 /* get a line from the file */
628 if (!fgets (buf
, sizeof(buf
), auth
))
632 if ((len
) && (buf
[len
-1]=='\n'))
640 /* break up the line into parameter & value.
641 will need to eat a little whitespace possibly */
643 if (!(ptr
= strchr (buf
, '=')))
648 /* eat leading white space */
649 while ((*val
!='\0') && ((*val
==' ') || (*val
=='\t')))
652 if (strwicmp("password", param
) == 0)
654 pstrcpy(password
, val
);
657 else if (strwicmp("username", param
) == 0) {
658 pstrcpy(username
, val
);
661 memset(buf
, 0, sizeof(buf
));
667 /****************************************************************************
669 ****************************************************************************/
670 static void usage(void)
672 printf("Usage: mount.smbfs service mountpoint [-o options,...]\n");
674 printf("Version %s\n\n",VERSION
);
678 username=<arg> SMB username\n\
679 password=<arg> SMB password\n\
680 credentials=<filename> file with username/password\n\
681 krb use kerberos (active directory)\n\
682 netbiosname=<arg> source NetBIOS name\n\
683 uid=<arg> mount uid or username\n\
684 gid=<arg> mount gid or groupname\n\
685 port=<arg> remote SMB port number\n\
686 fmask=<arg> file umask\n\
687 dmask=<arg> directory umask\n\
688 debug=<arg> debug level\n\
689 ip=<arg> destination host or IP address\n\
690 workgroup=<arg> workgroup on destination\n\
691 sockopt=<arg> TCP socket options\n\
692 scope=<arg> NetBIOS scope\n\
693 iocharset=<arg> Linux charset (iso8859-1, utf8)\n\
694 codepage=<arg> server codepage (cp850)\n\
695 ttl=<arg> dircache time to live\n\
696 guest don't prompt for a password\n\
697 ro mount read-only\n\
698 rw mount read-write\n\
700 This command is designed to be run from within /bin/mount by giving\n\
701 the option '-t smbfs'. For example:\n\
702 mount -t smbfs -o username=tridge,password=foobar //fjall/test /data/test\n\
707 /****************************************************************************
708 Argument parsing for mount.smbfs interface
709 mount will call us like this:
710 mount.smbfs device mountpoint -o <options>
712 <options> is never empty, containing at least rw or ro
713 ****************************************************************************/
714 static void parse_mount_smb(int argc
, char **argv
)
723 /* FIXME: This function can silently fail if the arguments are
724 * not in the expected order.
726 > The arguments syntax of smbmount 2.2.3a (smbfs of Debian stable)
727 > requires that one gives "-o" before further options like username=...
728 > . Without -o, the username=.. setting is *silently* ignored. I've
729 > spent about an hour trying to find out why I couldn't log in now..
734 if (argc
< 2 || argv
[1][0] == '-') {
739 pstrcpy(service
, argv
[1]);
740 pstrcpy(mpoint
, argv
[2]);
742 /* Convert any '/' characters in the service name to
744 string_replace(service
, '/','\\');
748 opt
= getopt(argc
, argv
, "o:");
757 * option parsing from nfsmount.c (util-linux-2.9u)
759 for (opts
= strtok(optarg
, ","); opts
; opts
= strtok(NULL
, ",")) {
760 DEBUG(3, ("opts: %s\n", opts
));
761 if ((opteq
= strchr_m(opts
, '='))) {
762 val
= atoi(opteq
+ 1);
765 if (!strcmp(opts
, "username") ||
766 !strcmp(opts
, "logon")) {
769 pstrcpy(username
,opteq
+1);
770 if ((lp
=strchr_m(username
,'%'))) {
772 pstrcpy(password
,lp
+1);
774 memset(strchr_m(opteq
+1,'%')+1,'X',strlen(password
));
776 if ((lp
=strchr_m(username
,'/'))) {
778 pstrcpy(workgroup
,lp
+1);
780 } else if(!strcmp(opts
, "passwd") ||
781 !strcmp(opts
, "password")) {
782 pstrcpy(password
,opteq
+1);
784 memset(opteq
+1,'X',strlen(password
));
785 } else if(!strcmp(opts
, "credentials")) {
786 pstrcpy(credentials
,opteq
+1);
787 } else if(!strcmp(opts
, "netbiosname")) {
788 pstrcpy(my_netbios_name
,opteq
+1);
789 } else if(!strcmp(opts
, "uid")) {
790 mount_uid
= nametouid(opteq
+1);
791 } else if(!strcmp(opts
, "gid")) {
792 mount_gid
= nametogid(opteq
+1);
793 } else if(!strcmp(opts
, "port")) {
795 } else if(!strcmp(opts
, "fmask")) {
796 mount_fmask
= strtol(opteq
+1, NULL
, 8);
797 } else if(!strcmp(opts
, "dmask")) {
798 mount_dmask
= strtol(opteq
+1, NULL
, 8);
799 } else if(!strcmp(opts
, "debug")) {
801 } else if(!strcmp(opts
, "ip")) {
802 dest_ip
= interpret_addr2(opteq
+1);
803 if (is_zero_ip_v4(dest_ip
)) {
804 fprintf(stderr
,"Can't resolve address %s\n", opteq
+1);
808 } else if(!strcmp(opts
, "workgroup")) {
809 pstrcpy(workgroup
,opteq
+1);
810 } else if(!strcmp(opts
, "sockopt")) {
811 lp_set_cmdline("socket options", opteq
+1);
812 } else if(!strcmp(opts
, "scope")) {
813 lp_set_cmdline("netbios scope", opteq
+1);
815 slprintf(p
, sizeof(pstring
) - (p
- options
) - 1, "%s=%s,", opts
, opteq
+1);
820 if(!strcmp(opts
, "nocaps")) {
821 fprintf(stderr
, "Unhandled option: %s\n", opteq
+1);
823 } else if(!strcmp(opts
, "guest")) {
826 } else if(!strcmp(opts
, "krb")) {
831 fprintf(stderr
, "Warning: kerberos support will only work for samba servers\n");
833 fprintf(stderr
,"No kerberos support compiled in\n");
836 } else if(!strcmp(opts
, "rw")) {
838 } else if(!strcmp(opts
, "ro")) {
841 strncpy(p
, opts
, sizeof(pstring
) - (p
- options
) - 1);
855 *(p
-1) = 0; /* remove trailing , */
856 DEBUG(3,("passthrough options '%s'\n", options
));
860 /****************************************************************************
862 ****************************************************************************/
863 int main(int argc
,char *argv
[])
868 struct loadparm_context
*lp_ctx
;
872 /* here we are interactive, even if run from autofs */
873 setup_logging("mount.smbfs",DEBUG_STDERR
);
875 #if 0 /* JRA - Urban says not needed ? */
876 /* CLI_FORCE_ASCII=false makes smbmount negotiate unicode. The default
877 is to not announce any unicode capabilities as current smbfs does
879 p
= getenv("CLI_FORCE_ASCII");
880 if (p
&& !strcmp(p
, "false"))
881 unsetenv("CLI_FORCE_ASCII");
883 setenv("CLI_FORCE_ASCII", "true", 1);
886 if (getenv("USER")) {
887 pstrcpy(username
,getenv("USER"));
889 if ((p
=strchr_m(username
,'%'))) {
891 pstrcpy(password
,p
+1);
893 memset(strchr_m(getenv("USER"),'%')+1,'X',strlen(password
));
898 if (getenv("PASSWD")) {
899 pstrcpy(password
, getenv("PASSWD"));
903 if (getenv("PASSWD_FD") || getenv("PASSWD_FILE")) {
908 if (*username
== 0 && getenv("LOGNAME")) {
909 pstrcpy(username
,getenv("LOGNAME"));
912 lp_ctx
= loadparm_init(talloc_autofree_context());
914 if (!lp_load(lp_ctx
, dyn_CONFIGFILE
)) {
915 fprintf(stderr
, "Can't load %s - run testparm to debug it\n",
919 parse_mount_smb(argc
, argv
);
921 if (use_kerberos
&& !got_user
) {
925 if (*credentials
!= 0) {
926 read_credentials_file(credentials
);
929 DEBUG(3,("mount.smbfs started (version %s)\n", VERSION
));
931 if (*workgroup
== 0) {
932 pstrcpy(workgroup
, lp_workgroup());
935 if (!*my_netbios_name
) {
936 pstrcpy(my_netbios_name
, myhostname());
938 strupper(my_netbios_name
);