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