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