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