?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add mount.cifs as a wrapper for mount.cifs.
[Samba.git] / source / client / smbmount.c
blobee4b180a89f93bac7997a7719a6742cf7b8d431f
1 /*
2 Unix SMB/CIFS implementation.
3 SMBFS mount program
4 Copyright (C) Andrew Tridgell 1999
5
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.
10
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.
15
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/>.
18 */
19
20 #include "includes.h"
21
22 #include <mntent.h>
23 #include <asm/types.h>
24 #include <linux/smb_fs.h>
25
26 extern bool in_client;
27 extern char *optarg;
28 extern int optind;
29
30 static char *credentials;
31 static fstring my_netbios_name;
32 static char *password;
33 static char *username;
34 static fstring workgroup;
35 static char *mpoint;
36 static char *service;
37 static char *options;
38
39 static struct sockaddr_storage dest_ip;
40 static bool have_ip;
41 static int smb_port = 0;
42 static bool got_user;
43 static bool got_pass;
44 static uid_t mount_uid;
45 static gid_t mount_gid;
46 static int mount_ro;
47 static unsigned mount_fmask;
48 static unsigned mount_dmask;
49 static bool use_kerberos;
50 /* TODO: Add code to detect smbfs version in kernel */
51 static bool status32_smbfs = False;
52 static bool smbfs_has_unicode = False;
53 static bool smbfs_has_lfs = False;
54
55 static void usage(void);
56
57 static void exit_parent(int sig)
58 {
59 /* parent simply exits when child says go... */
60 exit(0);
61 }
62
63 static void daemonize(void)
64 {
65 int j, status;
66 pid_t child_pid;
67
68 signal( SIGTERM, exit_parent );
69
70 if ((child_pid = sys_fork()) < 0) {
71 DEBUG(0,("could not fork\n"));
72 }
73
74 if (child_pid > 0) {
75 while( 1 ) {
76 j = waitpid( child_pid, &status, 0 );
77 if( j < 0 ) {
78 if( EINTR == errno ) {
79 continue;
80 }
81 status = errno;
82 }
83 break;
84 }
85
86 /* If we get here - the child exited with some error status */
87 if (WIFSIGNALED(status))
88 exit(128 + WTERMSIG(status));
89 else
90 exit(WEXITSTATUS(status));
91 }
92
93 signal( SIGTERM, SIG_DFL );
94 chdir("/");
95 }
96
97 static void close_our_files(int client_fd)
98 {
99 int i;
100 struct rlimit limits;
101
102 getrlimit(RLIMIT_NOFILE,&limits);
103 for (i = 0; i< limits.rlim_max; i++) {
104 if (i == client_fd)
105 continue;
106 close(i);
107 }
108 }
109
110 static void usr1_handler(int x)
111 {
112 return;
113 }
114
115
116 /*****************************************************
117 return a connection to a server
118 *******************************************************/
119 static struct cli_state *do_connection(char *the_service)
120 {
121 struct cli_state *c;
122 struct nmb_name called, calling;
123 char *server_n;
124 struct sockaddr_storage ip;
125 char *server;
126 char *share;
127 const char *c_username;
128 const char *c_password;
129 TALLOC_CTX *ctx = talloc_tos();
130
131 if (the_service[0] != '\\' || the_service[1] != '\\') {
132 usage();
133 exit(1);
134 }
135
136 server = talloc_strdup(ctx, the_service+2);
137 if (!server) {
138 fprintf(stderr,"Out of memory\n");
139 exit(ENOMEM);
140 }
141 share = strchr_m(server,'\\');
142 if (!share) {
143 usage();
144 exit(1);
145 }
146 *share = 0;
147 share++;
148
149 server_n = server;
150
151 make_nmb_name(&calling, my_netbios_name, 0x0);
152 make_nmb_name(&called , server, 0x20);
153
154 again:
155 zero_addr(&ip);
156 if (have_ip) ip = dest_ip;
157
158 /* have to open a new connection */
159 if (!(c=cli_initialise()) || (cli_set_port(c, smb_port) != smb_port) ||
160 !NT_STATUS_IS_OK(cli_connect(c, server_n, &ip))) {
161 DEBUG(0,("%d: Connection to %s failed\n", sys_getpid(), server_n));
162 if (c) {
163 cli_shutdown(c);
164 }
165 return NULL;
166 }
167
168 /* SPNEGO doesn't work till we get NTSTATUS error support */
169 /* But it is REQUIRED for kerberos authentication */
170 if(!use_kerberos) c->use_spnego = False;
171
172 /* The kernel doesn't yet know how to sign it's packets */
173 c->sign_info.allow_smb_signing = False;
174
175 /* Use kerberos authentication if specified */
176 c->use_kerberos = use_kerberos;
177
178 if (!cli_session_request(c, &calling, &called)) {
179 char *p;
180 DEBUG(0,("%d: session request to %s failed (%s)\n",
181 sys_getpid(), called.name, cli_errstr(c)));
182 cli_shutdown(c);
183 if ((p=strchr_m(called.name, '.'))) {
184 *p = 0;
185 goto again;
186 }
187 if (strcmp(called.name, "*SMBSERVER")) {
188 make_nmb_name(&called , "*SMBSERVER", 0x20);
189 goto again;
190 }
191 return NULL;
192 }
193
194 DEBUG(4,("%d: session request ok\n", sys_getpid()));
195
196 if (!cli_negprot(c)) {
197 DEBUG(0,("%d: protocol negotiation failed\n", sys_getpid()));
198 cli_shutdown(c);
199 return NULL;
200 }
201
202 if (!got_pass) {
203 char *pass = getpass("Password: ");
204 if (pass) {
205 password = talloc_strdup(talloc_tos(), pass);
206 if (!password) {
207 return NULL;
208 }
209 }
210 }
211
212 /* This should be right for current smbfs. Future versions will support
213 large files as well as unicode and oplocks. */
214 c->capabilities &= ~(CAP_NT_SMBS | CAP_NT_FIND | CAP_LEVEL_II_OPLOCKS);
215 if (!smbfs_has_lfs)
216 c->capabilities &= ~CAP_LARGE_FILES;
217 if (!smbfs_has_unicode)
218 c->capabilities &= ~CAP_UNICODE;
219 if (!status32_smbfs) {
220 c->capabilities &= ~CAP_STATUS32;
221 c->force_dos_errors = True;
222 }
223
224 c_password = password ? password : "";
225 c_username = username ? username : "";
226
227 if (!NT_STATUS_IS_OK(cli_session_setup(c,
228 c_username,
229 c_password, strlen(c_password),
230 c_password, strlen(c_password),
231 workgroup))) {
232 /* if a password was not supplied then try again with a
233 null username */
234 if (c_password[0] || !c_username[0] ||
235 !NT_STATUS_IS_OK(cli_session_setup(c, "", "", 0, "", 0, workgroup))) {
236 DEBUG(0,("%d: session setup failed: %s\n",
237 sys_getpid(), cli_errstr(c)));
238 cli_shutdown(c);
239 return NULL;
240 }
241 DEBUG(0,("Anonymous login successful\n"));
242 }
243
244 DEBUG(4,("%d: session setup ok\n", sys_getpid()));
245
246 if (!cli_send_tconX(c, share, "?????",
247 c_password, strlen(c_password)+1)) {
248 DEBUG(0,("%d: tree connect failed: %s\n",
249 sys_getpid(), cli_errstr(c)));
250 cli_shutdown(c);
251 return NULL;
252 }
253
254 DEBUG(4,("%d: tconx ok\n", sys_getpid()));
255
256 got_pass = True;
257
258 return c;
259 }
260
261 /****************************************************************************
262 unmount smbfs (this is a bailout routine to clean up if a reconnect fails)
263 Code blatently stolen from smbumount.c
264 -mhw-
265 ****************************************************************************/
266 static void smb_umount(char *mount_point)
267 {
268 int fd;
269 struct mntent *mnt;
270 FILE* mtab;
271 FILE* new_mtab;
272
273 /* Programmers Note:
274 This routine only gets called to the scene of a disaster
275 to shoot the survivors... A connection that was working
276 has now apparently failed. We have an active mount point
277 (presumably) that we need to dump. If we get errors along
278 the way - make some noise, but we are already turning out
279 the lights to exit anyways...
280 */
281 if (umount(mount_point) != 0) {
282 DEBUG(0,("%d: Could not umount %s: %s\n",
283 sys_getpid(), mount_point, strerror(errno)));
284 return;
285 }
286
287 if ((fd = open(MOUNTED"~", O_RDWR|O_CREAT|O_EXCL, 0600)) == -1) {
288 DEBUG(0,("%d: Can't get "MOUNTED"~ lock file", sys_getpid()));
289 return;
290 }
291
292 close(fd);
293
294 if ((mtab = setmntent(MOUNTED, "r")) == NULL) {
295 DEBUG(0,("%d: Can't open " MOUNTED ": %s\n",
296 sys_getpid(), strerror(errno)));
297 return;
298 }
299
300 #define MOUNTED_TMP MOUNTED".tmp"
301
302 if ((new_mtab = setmntent(MOUNTED_TMP, "w")) == NULL) {
303 DEBUG(0,("%d: Can't open " MOUNTED_TMP ": %s\n",
304 sys_getpid(), strerror(errno)));
305 endmntent(mtab);
306 return;
307 }
308
309 while ((mnt = getmntent(mtab)) != NULL) {
310 if (strcmp(mnt->mnt_dir, mount_point) != 0) {
311 addmntent(new_mtab, mnt);
312 }
313 }
314
315 endmntent(mtab);
316
317 if (fchmod (fileno (new_mtab), S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) < 0) {
318 DEBUG(0,("%d: Error changing mode of %s: %s\n",
319 sys_getpid(), MOUNTED_TMP, strerror(errno)));
320 return;
321 }
322
323 endmntent(new_mtab);
324
325 if (rename(MOUNTED_TMP, MOUNTED) < 0) {
326 DEBUG(0,("%d: Cannot rename %s to %s: %s\n",
327 sys_getpid(), MOUNTED, MOUNTED_TMP, strerror(errno)));
328 return;
329 }
330
331 if (unlink(MOUNTED"~") == -1) {
332 DEBUG(0,("%d: Can't remove "MOUNTED"~", sys_getpid()));
333 return;
334 }
335 }
336
337
338 /*
339 * Call the smbfs ioctl to install a connection socket,
340 * then wait for a signal to reconnect. Note that we do
341 * not exit after open_sockets() or send_login() errors,
342 * as the smbfs mount would then have no way to recover.
343 */
344 static void send_fs_socket(char *the_service, char *mount_point, struct cli_state *c)
345 {
346 int fd, closed = 0, res = 1;
347 pid_t parentpid = getppid();
348 struct smb_conn_opt conn_options;
349
350 memset(&conn_options, 0, sizeof(conn_options));
351
352 while (1) {
353 if ((fd = open(mount_point, O_RDONLY)) < 0) {
354 DEBUG(0,("mount.smbfs[%d]: can't open %s\n",
355 sys_getpid(), mount_point));
356 break;
357 }
358
359 conn_options.fd = c->fd;
360 conn_options.protocol = c->protocol;
361 conn_options.case_handling = SMB_CASE_DEFAULT;
362 conn_options.max_xmit = c->max_xmit;
363 conn_options.server_uid = c->vuid;
364 conn_options.tid = c->cnum;
365 conn_options.secmode = c->sec_mode;
366 conn_options.rawmode = 0;
367 conn_options.sesskey = c->sesskey;
368 conn_options.maxraw = 0;
369 conn_options.capabilities = c->capabilities;
370 conn_options.serverzone = c->serverzone/60;
371
372 res = ioctl(fd, SMB_IOC_NEWCONN, &conn_options);
373 if (res != 0) {
374 DEBUG(0,("mount.smbfs[%d]: ioctl failed, res=%d\n",
375 sys_getpid(), res));
376 close(fd);
377 break;
378 }
379
380 if (parentpid) {
381 /* Ok... We are going to kill the parent. Now
382 is the time to break the process group... */
383 setsid();
384 /* Send a signal to the parent to terminate */
385 kill(parentpid, SIGTERM);
386 parentpid = 0;
387 }
388
389 close(fd);
390
391 /* This looks wierd but we are only closing the userspace
392 side, the connection has already been passed to smbfs and
393 it has increased the usage count on the socket.
394
395 If we don't do this we will "leak" sockets and memory on
396 each reconnection we have to make. */
397 c->smb_rw_error = SMB_DO_NOT_DO_TDIS;
398 cli_shutdown(c);
399 c = NULL;
400
401 if (!closed) {
402 /* close the name cache so that close_our_files() doesn't steal its FD */
403 namecache_shutdown();
404
405 /* redirect stdout & stderr since we can't know that
406 the library functions we use are using DEBUG. */
407 if ( (fd = open("/dev/null", O_WRONLY)) < 0)
408 DEBUG(2,("mount.smbfs: can't open /dev/null\n"));
409 close_our_files(fd);
410 if (fd >= 0) {
411 dup2(fd, STDOUT_FILENO);
412 dup2(fd, STDERR_FILENO);
413 close(fd);
414 }
415
416 /* here we are no longer interactive */
417 set_remote_machine_name("smbmount", False); /* sneaky ... */
418 setup_logging("mount.smbfs", False);
419 reopen_logs();
420 DEBUG(0, ("mount.smbfs: entering daemon mode for service %s, pid=%d\n", the_service, sys_getpid()));
421
422 closed = 1;
423 }
424
425 /* Wait for a signal from smbfs ... but don't continue
426 until we actually get a new connection. */
427 while (!c) {
428 CatchSignal(SIGUSR1, &usr1_handler);
429 pause();
430 DEBUG(2,("mount.smbfs[%d]: got signal, getting new socket\n", sys_getpid()));
431 c = do_connection(the_service);
432 }
433 }
434
435 smb_umount(mount_point);
436 DEBUG(2,("mount.smbfs[%d]: exit\n", sys_getpid()));
437 exit(1);
438 }
439
440
441 /**
442 * Mount a smbfs
443 **/
444
445 #define NUM_ARGS 20
446
447 static void init_mount(void)
448 {
449 char mount_point[PATH_MAX+1];
450 TALLOC_CTX *ctx = talloc_tos();
451 char *svc2;
452 struct cli_state *c;
453 const char *args[NUM_ARGS];
454 int i, status;
455
456 if (realpath(mpoint, mount_point) == NULL) {
457 fprintf(stderr, "Could not resolve mount point %s\n", mpoint);
458 return;
459 }
460
461
462 c = do_connection(service);
463 if (!c) {
464 fprintf(stderr,"SMB connection failed\n");
465 exit(1);
466 }
467
468 /*
469 Set up to return as a daemon child and wait in the parent
470 until the child say it's ready...
471 */
472 daemonize();
473
474 svc2 = talloc_strdup(ctx, service);
475 if (!svc2) {
476 fprintf(stderr, "Out of memory.\n");
477 exit(ENOMEM);
478 }
479 string_replace(svc2, '\\','/');
480 string_replace(svc2, ' ','_');
481
482 memset(args, 0, sizeof(args[0])*NUM_ARGS);
483
484 i=0;
485 args[i++] = "smbmnt";
486
487 args[i++] = mount_point;
488 args[i++] = "-s";
489 args[i++] = svc2;
490
491 if (mount_ro && i < NUM_ARGS-2) {
492 args[i++] = "-r";
493 }
494 if (mount_uid && i < NUM_ARGS-3) {
495 args[i++] = "-u";
496 args[i] = talloc_asprintf(ctx, "%d", mount_uid);
497 if (!args[i]) {
498 fprintf(stderr, "Out of memory.\n");
499 exit(ENOMEM);
500 }
501 i++;
502 }
503 if (mount_gid && i < NUM_ARGS-3) {
504 args[i++] = "-g";
505 args[i] = talloc_asprintf(ctx, "%d", mount_gid);
506 if (!args[i]) {
507 fprintf(stderr, "Out of memory.\n");
508 exit(ENOMEM);
509 }
510 i++;
511 }
512 if (mount_fmask && i < NUM_ARGS-3) {
513 args[i++] = "-f";
514 args[i] = talloc_asprintf(ctx, "0%o", mount_fmask);
515 if (!args[i]) {
516 fprintf(stderr, "Out of memory.\n");
517 exit(ENOMEM);
518 }
519 i++;
520 }
521 if (mount_dmask && i < NUM_ARGS-3) {
522 args[i++] = "-d";
523 args[i] = talloc_asprintf(ctx, "0%o", mount_dmask);
524 if (!args[i]) {
525 fprintf(stderr, "Out of memory.\n");
526 exit(ENOMEM);
527 }
528 i++;
529 }
530 if (options && i < NUM_ARGS-3) {
531 args[i++] = "-o";
532 args[i++] = options;
533 }
534
535 if (sys_fork() == 0) {
536 char *smbmnt_path;
537
538 asprintf(&smbmnt_path, "%s/smbmnt", get_dyn_BINDIR());
539
540 if (file_exist(smbmnt_path, NULL)) {
541 execv(smbmnt_path, (char * const *)args);
542 fprintf(stderr,
543 "smbfs/init_mount: execv of %s failed. Error was %s.",
544 smbmnt_path, strerror(errno));
545 } else {
546 execvp("smbmnt", (char * const *)args);
547 fprintf(stderr,
548 "smbfs/init_mount: execv of %s failed. Error was %s.",
549 "smbmnt", strerror(errno));
550 }
551 free(smbmnt_path);
552 exit(1);
553 }
554
555 if (waitpid(-1, &status, 0) == -1) {
556 fprintf(stderr,"waitpid failed: Error was %s", strerror(errno) );
557 /* FIXME: do some proper error handling */
558 exit(1);
559 }
560
561 if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
562 fprintf(stderr,"smbmnt failed: %d\n", WEXITSTATUS(status));
563 /* FIXME: do some proper error handling */
564 exit(1);
565 } else if (WIFSIGNALED(status)) {
566 fprintf(stderr, "smbmnt killed by signal %d\n", WTERMSIG(status));
567 exit(1);
568 }
569
570 /* Ok... This is the rubicon for that mount point... At any point
571 after this, if the connections fail and can not be reconstructed
572 for any reason, we will have to unmount the mount point. There
573 is no exit from the next call...
574 */
575 send_fs_socket(service, mount_point, c);
576 }
577
578
579 /****************************************************************************
580 get a password from a a file or file descriptor
581 exit on failure (from smbclient, move to libsmb or shared .c file?)
582 ****************************************************************************/
583
584 static void get_password_file(void)
585 {
586 int fd = -1;
587 char *p;
588 bool close_it = False;
589 char *spec = NULL;
590 TALLOC_CTX *ctx = talloc_tos();
591 char pass[128];
592
593 if ((p = getenv("PASSWD_FD")) != NULL) {
594 spec = talloc_asprintf(ctx,
595 "descriptor %s",
596 p);
597 if (!spec) {
598 fprintf(stderr, "Out of memory.\n");
599 exit(ENOMEM);
600 }
601 fd = atoi(p);
602 close_it = False;
603 } else if ((p = getenv("PASSWD_FILE")) != NULL) {
604 fd = sys_open(p, O_RDONLY, 0);
605 spec = talloc_strdup(ctx, p);
606 if (!spec) {
607 fprintf(stderr, "Out of memory.\n");
608 exit(ENOMEM);
609 }
610 if (fd < 0) {
611 fprintf(stderr, "Error opening PASSWD_FILE %s: %s\n",
612 spec, strerror(errno));
613 exit(1);
614 }
615 close_it = True;
616 }
617
618 for(p = pass, *p = '\0'; /* ensure that pass is null-terminated */
619 p && p - pass < sizeof(pass);) {
620 switch (read(fd, p, 1)) {
621 case 1:
622 if (*p != '\n' && *p != '\0') {
623 *++p = '\0'; /* advance p, and null-terminate pass */
624 break;
625 }
626 case 0:
627 if (p - pass) {
628 *p = '\0'; /* null-terminate it, just in case... */
629 p = NULL; /* then force the loop condition to become false */
630 break;
631 } else {
632 fprintf(stderr, "Error reading password from file %s: %s\n",
633 spec, "empty password\n");
634 exit(1);
635 }
636
637 default:
638 fprintf(stderr, "Error reading password from file %s: %s\n",
639 spec, strerror(errno));
640 exit(1);
641 }
642 }
643 password = talloc_strdup(ctx, pass);
644 if (close_it)
645 close(fd);
646 }
647
648 /****************************************************************************
649 get username and password from a credentials file
650 exit on failure (from smbclient, move to libsmb or shared .c file?)
651 ****************************************************************************/
652
653 static void read_credentials_file(const char *filename)
654 {
655 FILE *auth;
656 fstring buf;
657 uint16 len = 0;
658 char *ptr, *val, *param;
659
660 if ((auth=sys_fopen(filename, "r")) == NULL)
661 {
662 /* fail if we can't open the credentials file */
663 DEBUG(0,("ERROR: Unable to open credentials file!\n"));
664 exit (-1);
665 }
666
667 while (!feof(auth))
668 {
669 /* get a line from the file */
670 if (!fgets (buf, sizeof(buf), auth))
671 continue;
672 len = strlen(buf);
673
674 if ((len) && (buf[len-1]=='\n'))
675 {
676 buf[len-1] = '\0';
677 len--;
678 }
679 if (len == 0)
680 continue;
681
682 /* break up the line into parameter & value.
683 will need to eat a little whitespace possibly */
684 param = buf;
685 if (!(ptr = strchr (buf, '=')))
686 continue;
687 val = ptr+1;
688 *ptr = '\0';
689
690 /* eat leading white space */
691 while ((*val!='\0') && ((*val==' ') || (*val=='\t')))
692 val++;
693
694 if (strwicmp("password", param) == 0)
695 {
696 password = talloc_strdup(talloc_tos(),val);
697 got_pass = True;
698 }
699 else if (strwicmp("username", param) == 0) {
700 username = talloc_strdup(talloc_tos(), val);
701 }
702
703 memset(buf, 0, sizeof(buf));
704 }
705 fclose(auth);
706 }
707
708
709 /****************************************************************************
710 usage on the program
711 ****************************************************************************/
712 static void usage(void)
713 {
714 printf("Usage: mount.smbfs service mountpoint [-o options,...]\n");
715
716 printf("Version %s\n\n",SAMBA_VERSION_STRING);
717
718 printf("Please be aware that smbfs is deprecated in favor of "
719 "cifs\n\n");
720
721 printf(
722 "Options:\n\
723 username=<arg> SMB username\n\
724 password=<arg> SMB password\n\
725 credentials=<filename> file with username/password\n\
726 krb use kerberos (active directory)\n\
727 netbiosname=<arg> source NetBIOS name\n\
728 uid=<arg> mount uid or username\n\
729 gid=<arg> mount gid or groupname\n\
730 port=<arg> remote SMB port number\n\
731 fmask=<arg> file umask\n\
732 dmask=<arg> directory umask\n\
733 debug=<arg> debug level\n\
734 ip=<arg> destination host or IP address\n\
735 workgroup=<arg> workgroup on destination\n\
736 sockopt=<arg> TCP socket options\n\
737 scope=<arg> NetBIOS scope\n\
738 iocharset=<arg> Linux charset (iso8859-1, utf8)\n\
739 codepage=<arg> server codepage (cp850)\n\
740 unicode use unicode when communicating with server\n\
741 lfs large file system support\n\
742 ttl=<arg> dircache time to live\n\
743 guest don't prompt for a password\n\
744 ro mount read-only\n\
745 rw mount read-write\n\
746 \n\
747 This command is designed to be run from within /bin/mount by giving\n\
748 the option '-t smbfs'. For example:\n\
749 mount -t smbfs -o username=tridge,password=foobar //fjall/test /data/test\n\
750 ");
751 }
752
753
754 /****************************************************************************
755 Argument parsing for mount.smbfs interface
756 mount will call us like this:
757 mount.smbfs device mountpoint -o <options>
758
759 <options> is never empty, containing at least rw or ro
760 ****************************************************************************/
761 static void parse_mount_smb(int argc, char **argv)
762 {
763 int opt;
764 char *opts;
765 char *opteq;
766 int val;
767 char *saveptr = NULL;
768 TALLOC_CTX *ctx = talloc_tos();
769
770 /* FIXME: This function can silently fail if the arguments are
771 * not in the expected order.
772
773 > The arguments syntax of smbmount 2.2.3a (smbfs of Debian stable)
774 > requires that one gives "-o" before further options like username=...
775 > . Without -o, the username=.. setting is *silently* ignored. I've
776 > spent about an hour trying to find out why I couldn't log in now..
777
778 */
779
780
781 if (argc < 2 || argv[1][0] == '-') {
782 usage();
783 exit(1);
784 }
785
786 service = talloc_strdup(ctx, argv[1]);
787 if (!service) {
788 fprintf(stderr,"Out of memory\n");
789 exit(ENOMEM);
790 }
791 mpoint = talloc_strdup(ctx, argv[2]);
792 if (!mpoint) {
793 fprintf(stderr,"Out of memory\n");
794 exit(ENOMEM);
795 }
796
797 /* Convert any '/' characters in the service name to
798 '\' characters */
799 string_replace(service, '/','\\');
800 argc -= 2;
801 argv += 2;
802
803 opt = getopt(argc, argv, "o:");
804 if(opt != 'o') {
805 return;
806 }
807
808 options = talloc_strdup(ctx, "");
809 if (!options) {
810 fprintf(stderr,"Out of memory\n");
811 exit(ENOMEM);
812 }
813
814 /*
815 * option parsing from nfsmount.c (util-linux-2.9u)
816 */
817 for (opts = strtok_r(optarg, ",", &saveptr); opts;
818 opts = strtok_r(NULL, ",", &saveptr)) {
819 DEBUG(3, ("opts: %s\n", opts));
820 if ((opteq = strchr_m(opts, '='))) {
821 val = atoi(opteq + 1);
822 *opteq = '\0';
823
824 if (!strcmp(opts, "username") ||
825 !strcmp(opts, "logon")) {
826 char *lp;
827 got_user = True;
828 username = talloc_strdup(ctx, opteq+1);
829 if (!username) {
830 fprintf(stderr,"Out of memory\n");
831 exit(ENOMEM);
832 }
833 if ((lp=strchr_m(username,'%'))) {
834 *lp = 0;
835 password = talloc_strdup(ctx, lp+1);
836 if (!password) {
837 fprintf(stderr,"Out of memory\n");
838 exit(ENOMEM);
839 }
840 got_pass = True;
841 memset(strchr_m(opteq+1,'%')+1,'X',strlen(password));
842 }
843 if ((lp=strchr_m(username,'/'))) {
844 *lp = 0;
845 fstrcpy(workgroup,lp+1);
846 }
847 } else if(!strcmp(opts, "passwd") ||
848 !strcmp(opts, "password")) {
849 password = talloc_strdup(ctx,opteq+1);
850 if (!password) {
851 fprintf(stderr,"Out of memory\n");
852 exit(ENOMEM);
853 }
854 got_pass = True;
855 memset(opteq+1,'X',strlen(password));
856 } else if(!strcmp(opts, "credentials")) {
857 credentials = talloc_strdup(ctx,opteq+1);
858 if (!credentials) {
859 fprintf(stderr,"Out of memory\n");
860 exit(ENOMEM);
861 }
862 } else if(!strcmp(opts, "netbiosname")) {
863 fstrcpy(my_netbios_name,opteq+1);
864 } else if(!strcmp(opts, "uid")) {
865 mount_uid = nametouid(opteq+1);
866 } else if(!strcmp(opts, "gid")) {
867 mount_gid = nametogid(opteq+1);
868 } else if(!strcmp(opts, "port")) {
869 smb_port = val;
870 } else if(!strcmp(opts, "fmask")) {
871 mount_fmask = strtol(opteq+1, NULL, 8);
872 } else if(!strcmp(opts, "dmask")) {
873 mount_dmask = strtol(opteq+1, NULL, 8);
874 } else if(!strcmp(opts, "debug")) {
875 DEBUGLEVEL = val;
876 } else if(!strcmp(opts, "ip")) {
877 if (!interpret_string_addr(&dest_ip, opteq+1,
878 0)) {
879 fprintf(stderr,"Can't resolve address %s\n", opteq+1);
880 exit(1);
881 }
882 have_ip = True;
883 } else if(!strcmp(opts, "workgroup")) {
884 fstrcpy(workgroup,opteq+1);
885 } else if(!strcmp(opts, "sockopt")) {
886 lp_do_parameter(-1, "socket options", opteq+1);
887 } else if(!strcmp(opts, "scope")) {
888 set_global_scope(opteq+1);
889 } else {
890 options = talloc_asprintf_append(options,
891 "%s=%s,",
892 opts, opteq+1);
893 if (!options) {
894 fprintf(stderr,"Out of memory\n");
895 exit(ENOMEM);
896 }
897 }
898 } else {
899 val = 1;
900 if(!strcmp(opts, "nocaps")) {
901 fprintf(stderr, "Unhandled option: %s\n", opteq+1);
902 exit(1);
903 } else if(!strcmp(opts, "guest")) {
904 password = talloc_strdup(talloc_tos(), "");
905 if (!password) {
906 fprintf(stderr,"Out of memory\n");
907 exit(ENOMEM);
908 }
909 got_pass = True;
910 } else if(!strcmp(opts, "krb")) {
911 #ifdef HAVE_KRB5
912
913 use_kerberos = True;
914 if(!status32_smbfs)
915 fprintf(stderr, "Warning: kerberos support will only work for samba servers\n");
916 #else
917 fprintf(stderr,"No kerberos support compiled in\n");
918 exit(1);
919 #endif
920 } else if(!strcmp(opts, "rw")) {
921 mount_ro = 0;
922 } else if(!strcmp(opts, "ro")) {
923 mount_ro = 1;
924 } else if(!strcmp(opts, "unicode")) {
925 smbfs_has_unicode = True;
926 } else if(!strcmp(opts, "lfs")) {
927 smbfs_has_lfs = True;
928 } else {
929 options = talloc_asprintf_append(options,
930 "%s,",
931 opts);
932 if (!options) {
933 fprintf(stderr,"Out of memory\n");
934 exit(ENOMEM);
935 }
936 }
937 }
938 }
939
940 if (!service || !*service) {
941 usage();
942 exit(1);
943 }
944
945 if (options && *options && options[strlen(options)-1] == ',') {
946 options[strlen(options)-1] = '\0'; /* remove trailing , */
947 DEBUG(3,("passthrough options '%s'\n", options));
948 }
949 }
950
951 /****************************************************************************
952 main program
953 ****************************************************************************/
954 int main(int argc,char *argv[])
955 {
956 TALLOC_CTX *frame = talloc_stackframe();
957 char *p;
958
959 DEBUGLEVEL = 1;
960
961 load_case_tables();
962
963 /* here we are interactive, even if run from autofs */
964 setup_logging("mount.smbfs",True);
965
966 #if 0 /* JRA - Urban says not needed ? */
967 /* CLI_FORCE_ASCII=false makes smbmount negotiate unicode. The default
968 is to not announce any unicode capabilities as current smbfs does
969 not support it. */
970 p = getenv("CLI_FORCE_ASCII");
971 if (p && !strcmp(p, "false"))
972 unsetenv("CLI_FORCE_ASCII");
973 else
974 setenv("CLI_FORCE_ASCII", "true", 1);
975 #endif
976
977 in_client = True; /* Make sure that we tell lp_load we are */
978
979 if (getenv("USER")) {
980 username = talloc_strdup(frame, getenv("USER"));
981 if (!username) {
982 exit(ENOMEM);
983 }
984
985 if ((p=strchr_m(username,'%'))) {
986 *p = 0;
987 password = talloc_strdup(frame, p+1);
988 if (!password) {
989 exit(ENOMEM);
990 }
991 got_pass = True;
992 memset(strchr_m(getenv("USER"),'%')+1,'X',strlen(password));
993 }
994 strupper_m(username);
995 }
996
997 if (getenv("PASSWD")) {
998 password = talloc_strdup(frame, getenv("PASSWD"));
999 if (!password) {
1000 exit(ENOMEM);
1001 }
1002 got_pass = True;
1003 }
1004
1005 if (getenv("PASSWD_FD") || getenv("PASSWD_FILE")) {
1006 get_password_file();
1007 got_pass = True;
1008 }
1009
1010 if ((!username || *username == 0) && getenv("LOGNAME")) {
1011 username = talloc_strdup(frame, getenv("LOGNAME"));
1012 if (!username) {
1013 exit(ENOMEM);
1014 }
1015 }
1016
1017 if (!lp_load(get_dyn_CONFIGFILE(),True,False,False,True)) {
1018 fprintf(stderr, "Can't load %s - run testparm to debug it\n",
1019 get_dyn_CONFIGFILE());
1020 }
1021
1022 parse_mount_smb(argc, argv);
1023
1024 if (use_kerberos && !got_user) {
1025 got_pass = True;
1026 }
1027
1028 if (credentials && *credentials != 0) {
1029 read_credentials_file(credentials);
1030 }
1031
1032 DEBUG(3,("mount.smbfs started (version %s)\n", SAMBA_VERSION_STRING));
1033
1034 if (*workgroup == 0) {
1035 fstrcpy(workgroup,lp_workgroup());
1036 }
1037
1038 load_interfaces();
1039 if (!*my_netbios_name) {
1040 fstrcpy(my_netbios_name, myhostname());
1041 }
1042 strupper_m(my_netbios_name);
1043
1044 init_mount();
1045 TALLOC_FREE(frame);
1046 return 0;
1047 }
Samba GIT mirror