0bc61ae38f720954716543a35a17bb3e3b8923a3
[ira/wip.git] / source3 / client / mount.cifs.c
1 /* 
2    Mount helper utility for Linux CIFS VFS (virtual filesystem) client
3    Copyright (C) 2003,2008 Steve French  (sfrench@us.ibm.com)
4    Copyright (C) 2008 Jeremy Allison (jra@samba.org)
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 #ifndef _GNU_SOURCE
20 #define _GNU_SOURCE
21 #endif
22
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <unistd.h>
26 #include <pwd.h>
27 #include <grp.h>
28 #include <ctype.h>
29 #include <sys/types.h>
30 #include <sys/mount.h>
31 #include <sys/stat.h>
32 #include <sys/utsname.h>
33 #include <sys/socket.h>
34 #include <arpa/inet.h>
35 #include <getopt.h>
36 #include <errno.h>
37 #include <netdb.h>
38 #include <string.h>
39 #include <mntent.h>
40 #include <fcntl.h>
41 #include <limits.h>
42 #include "mount.h"
43
44 #define MOUNT_CIFS_VERSION_MAJOR "1"
45 #define MOUNT_CIFS_VERSION_MINOR "12"
46
47 #ifndef MOUNT_CIFS_VENDOR_SUFFIX
48  #ifdef _SAMBA_BUILD_
49   #include "include/version.h"
50   #ifdef SAMBA_VERSION_VENDOR_SUFFIX
51    #define MOUNT_CIFS_VENDOR_SUFFIX "-"SAMBA_VERSION_OFFICIAL_STRING"-"SAMBA_VERSION_VENDOR_SUFFIX
52   #else
53    #define MOUNT_CIFS_VENDOR_SUFFIX "-"SAMBA_VERSION_OFFICIAL_STRING
54   #endif /* SAMBA_VERSION_OFFICIAL_STRING and SAMBA_VERSION_VENDOR_SUFFIX */
55  #else
56    #define MOUNT_CIFS_VENDOR_SUFFIX ""
57  #endif /* _SAMBA_BUILD_ */
58 #endif /* MOUNT_CIFS_VENDOR_SUFFIX */
59
60 #ifdef _SAMBA_BUILD_
61 #include "include/config.h"
62 #endif
63
64 #ifndef MS_MOVE 
65 #define MS_MOVE 8192 
66 #endif 
67
68 #ifndef MS_BIND
69 #define MS_BIND 4096
70 #endif
71
72 #define MAX_UNC_LEN 1024
73
74 #define CONST_DISCARD(type, ptr)      ((type) ((void *) (ptr)))
75
76 #ifndef SAFE_FREE
77 #define SAFE_FREE(x) do { if ((x) != NULL) {free(x); x=NULL;} } while(0)
78 #endif
79
80 #define MOUNT_PASSWD_SIZE 64
81 #define DOMAIN_SIZE 64
82
83 const char *thisprogram;
84 int verboseflag = 0;
85 static int got_password = 0;
86 static int got_user = 0;
87 static int got_domain = 0;
88 static int got_ip = 0;
89 static int got_unc = 0;
90 static int got_uid = 0;
91 static int got_gid = 0;
92 static char * user_name = NULL;
93 static char * mountpassword = NULL;
94 char * domain_name = NULL;
95 char * prefixpath = NULL;
96
97 /* glibc doesn't have strlcpy, strlcat. Ensure we do. JRA. We
98  * don't link to libreplace so need them here. */
99
100 /* like strncpy but does not 0 fill the buffer and always null
101  *    terminates. bufsize is the size of the destination buffer */
102
103 #ifndef HAVE_STRLCPY
104 static size_t strlcpy(char *d, const char *s, size_t bufsize)
105 {
106         size_t len = strlen(s);
107         size_t ret = len;
108         if (bufsize <= 0) return 0;
109         if (len >= bufsize) len = bufsize-1;
110         memcpy(d, s, len);
111         d[len] = 0;
112         return ret;
113 }
114 #endif
115
116 /* like strncat but does not 0 fill the buffer and always null
117  *    terminates. bufsize is the length of the buffer, which should
118  *       be one more than the maximum resulting string length */
119
120 #ifndef HAVE_STRLCAT
121 static size_t strlcat(char *d, const char *s, size_t bufsize)
122 {
123         size_t len1 = strlen(d);
124         size_t len2 = strlen(s);
125         size_t ret = len1 + len2;
126
127         if (len1+len2 >= bufsize) {
128                 if (bufsize < (len1+1)) {
129                         return ret;
130                 }
131                 len2 = bufsize - (len1+1);
132         }
133         if (len2 > 0) {
134                 memcpy(d+len1, s, len2);
135                 d[len1+len2] = 0;
136         }
137         return ret;
138 }
139 #endif
140
141 /* BB finish BB
142
143         cifs_umount
144         open nofollow - avoid symlink exposure? 
145         get owner of dir see if matches self or if root
146         call system(umount argv) etc.
147                 
148 BB end finish BB */
149
150 static char * check_for_domain(char **);
151
152
153 static void mount_cifs_usage(void)
154 {
155         printf("\nUsage:  %s <remotetarget> <dir> -o <options>\n", thisprogram);
156         printf("\nMount the remote target, specified as a UNC name,");
157         printf(" to a local directory.\n\nOptions:\n");
158         printf("\tuser=<arg>\n\tpass=<arg>\n\tdom=<arg>\n");
159         printf("\nLess commonly used options:");
160         printf("\n\tcredentials=<filename>,guest,perm,noperm,setuids,nosetuids,rw,ro,");
161         printf("\n\tsep=<char>,iocharset=<codepage>,suid,nosuid,exec,noexec,serverino,");
162         printf("\n\tmapchars,nomapchars,nolock,servernetbiosname=<SRV_RFC1001NAME>");
163         printf("\n\tdirectio,nounix,cifsacl,sec=<authentication mechanism>,sign");
164         printf("\n\nOptions not needed for servers supporting CIFS Unix extensions");
165         printf("\n\t(e.g. unneeded for mounts to most Samba versions):");
166         printf("\n\tuid=<uid>,gid=<gid>,dir_mode=<mode>,file_mode=<mode>,sfu");
167         printf("\n\nRarely used options:");
168         printf("\n\tport=<tcpport>,rsize=<size>,wsize=<size>,unc=<unc_name>,ip=<ip_address>,");
169         printf("\n\tdev,nodev,nouser_xattr,netbiosname=<OUR_RFC1001NAME>,hard,soft,intr,");
170         printf("\n\tnointr,ignorecase,noposixpaths,noacl,prefixpath=<path>,nobrl");
171         printf("\n\tin6_addr");
172         printf("\n\nOptions are described in more detail in the manual page");
173         printf("\n\tman 8 mount.cifs\n");
174         printf("\nTo display the version number of the mount helper:");
175         printf("\n\t%s -V\n",thisprogram);
176
177         SAFE_FREE(mountpassword);
178         exit(EX_USAGE);
179 }
180
181 /* caller frees username if necessary */
182 static char * getusername(void) {
183         char *username = NULL;
184         struct passwd *password = getpwuid(getuid());
185
186         if (password) {
187                 username = password->pw_name;
188         }
189         return username;
190 }
191
192 static char * parse_cifs_url(char * unc_name)
193 {
194         printf("\nMounting cifs URL not implemented yet. Attempt to mount %s\n",unc_name);
195         return NULL;
196 }
197
198 static int open_cred_file(char * file_name)
199 {
200         char * line_buf;
201         char * temp_val;
202         FILE * fs;
203         int i, length;
204         fs = fopen(file_name,"r");
205         if(fs == NULL)
206                 return errno;
207         line_buf = (char *)malloc(4096);
208         if(line_buf == NULL) {
209                 fclose(fs);
210                 return ENOMEM;
211         }
212
213         while(fgets(line_buf,4096,fs)) {
214                 /* parse line from credential file */
215
216                 /* eat leading white space */
217                 for(i=0;i<4086;i++) {
218                         if((line_buf[i] != ' ') && (line_buf[i] != '\t'))
219                                 break;
220                         /* if whitespace - skip past it */
221                 }
222                 if (strncasecmp("username",line_buf+i,8) == 0) {
223                         temp_val = strchr(line_buf + i,'=');
224                         if(temp_val) {
225                                 /* go past equals sign */
226                                 temp_val++;
227                                 for(length = 0;length<4087;length++) {
228                                         if ((temp_val[length] == '\n')
229                                             || (temp_val[length] == '\0')) {
230                                                 temp_val[length] = '\0';
231                                                 break;
232                                         }
233                                 }
234                                 if(length > 4086) {
235                                         printf("mount.cifs failed due to malformed username in credentials file");
236                                         memset(line_buf,0,4096);
237                                         exit(EX_USAGE);
238                                 } else {
239                                         got_user = 1;
240                                         user_name = (char *)calloc(1 + length,1);
241                                         /* BB adding free of user_name string before exit,
242                                                 not really necessary but would be cleaner */
243                                         strlcpy(user_name,temp_val, length+1);
244                                 }
245                         }
246                 } else if (strncasecmp("password",line_buf+i,8) == 0) {
247                         temp_val = strchr(line_buf+i,'=');
248                         if(temp_val) {
249                                 /* go past equals sign */
250                                 temp_val++;
251                                 for(length = 0;length<MOUNT_PASSWD_SIZE+1;length++) {
252                                         if ((temp_val[length] == '\n')
253                                             || (temp_val[length] == '\0')) {
254                                                 temp_val[length] = '\0';
255                                                 break;
256                                         }
257                                 }
258                                 if(length > MOUNT_PASSWD_SIZE) {
259                                         printf("mount.cifs failed: password in credentials file too long\n");
260                                         memset(line_buf,0, 4096);
261                                         exit(EX_USAGE);
262                                 } else {
263                                         if(mountpassword == NULL) {
264                                                 mountpassword = (char *)calloc(MOUNT_PASSWD_SIZE+1,1);
265                                         } else
266                                                 memset(mountpassword,0,MOUNT_PASSWD_SIZE);
267                                         if(mountpassword) {
268                                                 strlcpy(mountpassword,temp_val,MOUNT_PASSWD_SIZE+1);
269                                                 got_password = 1;
270                                         }
271                                 }
272                         }
273                 } else if (strncasecmp("domain",line_buf+i,6) == 0) {
274                         temp_val = strchr(line_buf+i,'=');
275                         if(temp_val) {
276                                 /* go past equals sign */
277                                 temp_val++;
278                                 if(verboseflag)
279                                         printf("\nDomain %s\n",temp_val);
280                                 for(length = 0;length<DOMAIN_SIZE+1;length++) {
281                                         if ((temp_val[length] == '\n')
282                                             || (temp_val[length] == '\0')) {
283                                                 temp_val[length] = '\0';
284                                                 break;
285                                         }
286                                 }
287                                 if(length > DOMAIN_SIZE) {
288                                         printf("mount.cifs failed: domain in credentials file too long\n");
289                                         exit(EX_USAGE);
290                                 } else {
291                                         if(domain_name == NULL) {
292                                                 domain_name = (char *)calloc(DOMAIN_SIZE+1,1);
293                                         } else
294                                                 memset(domain_name,0,DOMAIN_SIZE);
295                                         if(domain_name) {
296                                                 strlcpy(domain_name,temp_val,DOMAIN_SIZE+1);
297                                                 got_domain = 1;
298                                         }
299                                 }
300                         }
301                 }
302
303         }
304         fclose(fs);
305         SAFE_FREE(line_buf);
306         return 0;
307 }
308
309 static int get_password_from_file(int file_descript, char * filename)
310 {
311         int rc = 0;
312         int i;
313         char c;
314
315         if(mountpassword == NULL)
316                 mountpassword = (char *)calloc(MOUNT_PASSWD_SIZE+1,1);
317         else 
318                 memset(mountpassword, 0, MOUNT_PASSWD_SIZE);
319
320         if (mountpassword == NULL) {
321                 printf("malloc failed\n");
322                 exit(EX_SYSERR);
323         }
324
325         if(filename != NULL) {
326                 file_descript = open(filename, O_RDONLY);
327                 if(file_descript < 0) {
328                         printf("mount.cifs failed. %s attempting to open password file %s\n",
329                                    strerror(errno),filename);
330                         exit(EX_SYSERR);
331                 }
332         }
333         /* else file already open and fd provided */
334
335         for(i=0;i<MOUNT_PASSWD_SIZE;i++) {
336                 rc = read(file_descript,&c,1);
337                 if(rc < 0) {
338                         printf("mount.cifs failed. Error %s reading password file\n",strerror(errno));
339                         if(filename != NULL)
340                                 close(file_descript);
341                         exit(EX_SYSERR);
342                 } else if(rc == 0) {
343                         if(mountpassword[0] == 0) {
344                                 if(verboseflag)
345                                         printf("\nWarning: null password used since cifs password file empty");
346                         }
347                         break;
348                 } else /* read valid character */ {
349                         if((c == 0) || (c == '\n')) {
350                                 mountpassword[i] = '\0';
351                                 break;
352                         } else 
353                                 mountpassword[i] = c;
354                 }
355         }
356         if((i == MOUNT_PASSWD_SIZE) && (verboseflag)) {
357                 printf("\nWarning: password longer than %d characters specified in cifs password file",
358                         MOUNT_PASSWD_SIZE);
359         }
360         got_password = 1;
361         if(filename != NULL) {
362                 close(file_descript);
363         }
364
365         return rc;
366 }
367
368 static int parse_options(char ** optionsp, int * filesys_flags)
369 {
370         const char * data;
371         char * percent_char = NULL;
372         char * value = NULL;
373         char * next_keyword = NULL;
374         char * out = NULL;
375         int out_len = 0;
376         int word_len;
377         int rc = 0;
378         char user[32];
379         char group[32];
380
381         if (!optionsp || !*optionsp)
382                 return 1;
383         data = *optionsp;
384
385         if(verboseflag)
386                 printf("parsing options: %s\n", data);
387
388         /* BB fixme check for separator override BB */
389
390         if (getuid()) {
391                 got_uid = 1;
392                 snprintf(user,sizeof(user),"%u",getuid());
393                 got_gid = 1;
394                 snprintf(group,sizeof(group),"%u",getgid());
395         }
396
397 /* while ((data = strsep(&options, ",")) != NULL) { */
398         while(data != NULL) {
399                 /*  check if ends with trailing comma */
400                 if(*data == 0)
401                         break;
402
403                 /* format is keyword=value,keyword2=value2,keyword3=value3 etc.) */
404                 /* data  = next keyword */
405                 /* value = next value ie stuff after equal sign */
406
407                 next_keyword = strchr(data,','); /* BB handle sep= */
408         
409                 /* temporarily null terminate end of keyword=value pair */
410                 if(next_keyword)
411                         *next_keyword++ = 0;
412
413                 /* temporarily null terminate keyword to make keyword and value distinct */
414                 if ((value = strchr(data, '=')) != NULL) {
415                         *value = '\0';
416                         value++;
417                 }
418
419                 if (strncmp(data, "users",5) == 0) {
420                         if(!value || !*value) {
421                                 goto nocopy;
422                         }
423                 } else if (strncmp(data, "user_xattr",10) == 0) {
424                    /* do nothing - need to skip so not parsed as user name */
425                 } else if (strncmp(data, "user", 4) == 0) {
426
427                         if (!value || !*value) {
428                                 if(data[4] == '\0') {
429                                         if(verboseflag)
430                                                 printf("\nskipping empty user mount parameter\n");
431                                         /* remove the parm since it would otherwise be confusing
432                                         to the kernel code which would think it was a real username */
433                                         goto nocopy;
434                                 } else {
435                                         printf("username specified with no parameter\n");
436                                         SAFE_FREE(out);
437                                         return 1;       /* needs_arg; */
438                                 }
439                         } else {
440                                 if (strnlen(value, 260) < 260) {
441                                         got_user=1;
442                                         percent_char = strchr(value,'%');
443                                         if(percent_char) {
444                                                 *percent_char = ',';
445                                                 if(mountpassword == NULL)
446                                                         mountpassword = (char *)calloc(MOUNT_PASSWD_SIZE+1,1);
447                                                 if(mountpassword) {
448                                                         if(got_password)
449                                                                 printf("\nmount.cifs warning - password specified twice\n");
450                                                         got_password = 1;
451                                                         percent_char++;
452                                                         strlcpy(mountpassword, percent_char,MOUNT_PASSWD_SIZE+1);
453                                                 /*  remove password from username */
454                                                         while(*percent_char != 0) {
455                                                                 *percent_char = ',';
456                                                                 percent_char++;
457                                                         }
458                                                 }
459                                         }
460                                         /* this is only case in which the user
461                                         name buf is not malloc - so we have to
462                                         check for domain name embedded within
463                                         the user name here since the later
464                                         call to check_for_domain will not be
465                                         invoked */
466                                         domain_name = check_for_domain(&value);
467                                 } else {
468                                         printf("username too long\n");
469                                         SAFE_FREE(out);
470                                         return 1;
471                                 }
472                         }
473                 } else if (strncmp(data, "pass", 4) == 0) {
474                         if (!value || !*value) {
475                                 if(got_password) {
476                                         printf("\npassword specified twice, ignoring second\n");
477                                 } else
478                                         got_password = 1;
479                         } else if (strnlen(value, 17) < 17) {
480                                 if(got_password)
481                                         printf("\nmount.cifs warning - password specified twice\n");
482                                 got_password = 1;
483                         } else {
484                                 printf("password too long\n");
485                                 SAFE_FREE(out);
486                                 return 1;
487                         }
488                 } else if (strncmp(data, "sec", 3) == 0) {
489                         if (value) {
490                                 if (!strncmp(value, "none", 4) ||
491                                     !strncmp(value, "krb5", 4))
492                                         got_password = 1;
493                         }
494                 } else if (strncmp(data, "ip", 2) == 0) {
495                         if (!value || !*value) {
496                                 printf("target ip address argument missing");
497                         } else if (strnlen(value, 35) < 35) {
498                                 if(verboseflag)
499                                         printf("ip address %s override specified\n",value);
500                                 got_ip = 1;
501                         } else {
502                                 printf("ip address too long\n");
503                                 SAFE_FREE(out);
504                                 return 1;
505                         }
506                 } else if ((strncmp(data, "unc", 3) == 0)
507                    || (strncmp(data, "target", 6) == 0)
508                    || (strncmp(data, "path", 4) == 0)) {
509                         if (!value || !*value) {
510                                 printf("invalid path to network resource\n");
511                                 SAFE_FREE(out);
512                                 return 1;  /* needs_arg; */
513                         } else if(strnlen(value,5) < 5) {
514                                 printf("UNC name too short");
515                         }
516
517                         if (strnlen(value, 300) < 300) {
518                                 got_unc = 1;
519                                 if (strncmp(value, "//", 2) == 0) {
520                                         if(got_unc)
521                                                 printf("unc name specified twice, ignoring second\n");
522                                         else
523                                                 got_unc = 1;
524                                 } else if (strncmp(value, "\\\\", 2) != 0) {                       
525                                         printf("UNC Path does not begin with // or \\\\ \n");
526                                         SAFE_FREE(out);
527                                         return 1;
528                                 } else {
529                                         if(got_unc)
530                                                 printf("unc name specified twice, ignoring second\n");
531                                         else
532                                                 got_unc = 1;
533                                 }
534                         } else {
535                                 printf("CIFS: UNC name too long\n");
536                                 SAFE_FREE(out);
537                                 return 1;
538                         }
539                 } else if ((strncmp(data, "dom" /* domain */, 3) == 0)
540                            || (strncmp(data, "workg", 5) == 0)) {
541                         /* note this allows for synonyms of "domain"
542                            such as "DOM" and "dom" and "workgroup"
543                            and "WORKGRP" etc. */
544                         if (!value || !*value) {
545                                 printf("CIFS: invalid domain name\n");
546                                 SAFE_FREE(out);
547                                 return 1;       /* needs_arg; */
548                         }
549                         if (strnlen(value, DOMAIN_SIZE+1) < DOMAIN_SIZE+1) {
550                                 got_domain = 1;
551                         } else {
552                                 printf("domain name too long\n");
553                                 SAFE_FREE(out);
554                                 return 1;
555                         }
556                 } else if (strncmp(data, "cred", 4) == 0) {
557                         if (value && *value) {
558                                 rc = open_cred_file(value);
559                                 if(rc) {
560                                         printf("error %d (%s) opening credential file %s\n",
561                                                 rc, strerror(rc), value);
562                                         SAFE_FREE(out);
563                                         return 1;
564                                 }
565                         } else {
566                                 printf("invalid credential file name specified\n");
567                                 SAFE_FREE(out);
568                                 return 1;
569                         }
570                 } else if (strncmp(data, "uid", 3) == 0) {
571                         if (value && *value) {
572                                 got_uid = 1;
573                                 if (!isdigit(*value)) {
574                                         struct passwd *pw;
575
576                                         if (!(pw = getpwnam(value))) {
577                                                 printf("bad user name \"%s\"\n", value);
578                                                 exit(EX_USAGE);
579                                         }
580                                         snprintf(user, sizeof(user), "%u", pw->pw_uid);
581                                 } else {
582                                         strlcpy(user,value,sizeof(user));
583                                 }
584                         }
585                         goto nocopy;
586                 } else if (strncmp(data, "gid", 3) == 0) {
587                         if (value && *value) {
588                                 got_gid = 1;
589                                 if (!isdigit(*value)) {
590                                         struct group *gr;
591
592                                         if (!(gr = getgrnam(value))) {
593                                                 printf("bad group name \"%s\"\n", value);
594                                                 exit(EX_USAGE);
595                                         }
596                                         snprintf(group, sizeof(group), "%u", gr->gr_gid);
597                                 } else {
598                                         strlcpy(group,value,sizeof(group));
599                                 }
600                         }
601                         goto nocopy;
602        /* fmask and dmask synonyms for people used to smbfs syntax */
603                 } else if (strcmp(data, "file_mode") == 0 || strcmp(data, "fmask")==0) {
604                         if (!value || !*value) {
605                                 printf ("Option '%s' requires a numerical argument\n", data);
606                                 SAFE_FREE(out);
607                                 return 1;
608                         }
609
610                         if (value[0] != '0') {
611                                 printf ("WARNING: '%s' not expressed in octal.\n", data);
612                         }
613
614                         if (strcmp (data, "fmask") == 0) {
615                                 printf ("WARNING: CIFS mount option 'fmask' is deprecated. Use 'file_mode' instead.\n");
616                                 data = "file_mode"; /* BB fix this */
617                         }
618                 } else if (strcmp(data, "dir_mode") == 0 || strcmp(data, "dmask")==0) {
619                         if (!value || !*value) {
620                                 printf ("Option '%s' requires a numerical argument\n", data);
621                                 SAFE_FREE(out);
622                                 return 1;
623                         }
624
625                         if (value[0] != '0') {
626                                 printf ("WARNING: '%s' not expressed in octal.\n", data);
627                         }
628
629                         if (strcmp (data, "dmask") == 0) {
630                                 printf ("WARNING: CIFS mount option 'dmask' is deprecated. Use 'dir_mode' instead.\n");
631                                 data = "dir_mode";
632                         }
633                         /* the following eight mount options should be
634                         stripped out from what is passed into the kernel
635                         since these eight options are best passed as the
636                         mount flags rather than redundantly to the kernel 
637                         and could generate spurious warnings depending on the
638                         level of the corresponding cifs vfs kernel code */
639                 } else if (strncmp(data, "nosuid", 6) == 0) {
640                         *filesys_flags |= MS_NOSUID;
641                 } else if (strncmp(data, "suid", 4) == 0) {
642                         *filesys_flags &= ~MS_NOSUID;
643                 } else if (strncmp(data, "nodev", 5) == 0) {
644                         *filesys_flags |= MS_NODEV;
645                 } else if ((strncmp(data, "nobrl", 5) == 0) || 
646                            (strncmp(data, "nolock", 6) == 0)) {
647                         *filesys_flags &= ~MS_MANDLOCK;
648                 } else if (strncmp(data, "dev", 3) == 0) {
649                         *filesys_flags &= ~MS_NODEV;
650                 } else if (strncmp(data, "noexec", 6) == 0) {
651                         *filesys_flags |= MS_NOEXEC;
652                 } else if (strncmp(data, "exec", 4) == 0) {
653                         *filesys_flags &= ~MS_NOEXEC;
654                 } else if (strncmp(data, "guest", 5) == 0) {
655                         got_password=1;
656                 } else if (strncmp(data, "ro", 2) == 0) {
657                         *filesys_flags |= MS_RDONLY;
658                 } else if (strncmp(data, "rw", 2) == 0) {
659                         *filesys_flags &= ~MS_RDONLY;
660                 } else if (strncmp(data, "remount", 7) == 0) {
661                         *filesys_flags |= MS_REMOUNT;
662                 } /* else if (strnicmp(data, "port", 4) == 0) {
663                         if (value && *value) {
664                                 vol->port =
665                                         simple_strtoul(value, &value, 0);
666                         }
667                 } else if (strnicmp(data, "rsize", 5) == 0) {
668                         if (value && *value) {
669                                 vol->rsize =
670                                         simple_strtoul(value, &value, 0);
671                         }
672                 } else if (strnicmp(data, "wsize", 5) == 0) {
673                         if (value && *value) {
674                                 vol->wsize =
675                                         simple_strtoul(value, &value, 0);
676                         }
677                 } else if (strnicmp(data, "version", 3) == 0) {
678                 } else {
679                         printf("CIFS: Unknown mount option %s\n",data);
680                 } */ /* nothing to do on those four mount options above.
681                         Just pass to kernel and ignore them here */
682
683                 /* Copy (possibly modified) option to out */
684                 word_len = strlen(data);
685                 if (value)
686                         word_len += 1 + strlen(value);
687
688                 out = (char *)realloc(out, out_len + word_len + 2);
689                 if (out == NULL) {
690                         perror("malloc");
691                         exit(EX_SYSERR);
692                 }
693
694                 if (out_len) {
695                         strlcat(out, ",", out_len + word_len + 2);
696                         out_len++;
697                 }
698
699                 if (value)
700                         snprintf(out + out_len, word_len + 1, "%s=%s", data, value);
701                 else
702                         snprintf(out + out_len, word_len + 1, "%s", data);
703                 out_len = strlen(out);
704
705 nocopy:
706                 data = next_keyword;
707         }
708
709         /* special-case the uid and gid */
710         if (got_uid) {
711                 word_len = strlen(user);
712
713                 out = (char *)realloc(out, out_len + word_len + 6);
714                 if (out == NULL) {
715                         perror("malloc");
716                         exit(EX_SYSERR);
717                 }
718
719                 if (out_len) {
720                         strlcat(out, ",", out_len + word_len + 6);
721                         out_len++;
722                 }
723                 snprintf(out + out_len, word_len + 5, "uid=%s", user);
724                 out_len = strlen(out);
725         }
726         if (got_gid) {
727                 word_len = strlen(group);
728
729                 out = (char *)realloc(out, out_len + 1 + word_len + 6);
730                 if (out == NULL) {
731                 perror("malloc");
732                         exit(EX_SYSERR);
733                 }
734
735                 if (out_len) {
736                         strlcat(out, ",", out_len + word_len + 6);
737                         out_len++;
738                 }
739                 snprintf(out + out_len, word_len + 5, "gid=%s", group);
740                 out_len = strlen(out);
741         }
742
743         SAFE_FREE(*optionsp);
744         *optionsp = out;
745         return 0;
746 }
747
748 /* replace all (one or more) commas with double commas */
749 static void check_for_comma(char ** ppasswrd)
750 {
751         char *new_pass_buf;
752         char *pass;
753         int i,j;
754         int number_of_commas = 0;
755         int len;
756
757         if(ppasswrd == NULL)
758                 return;
759         else 
760                 (pass = *ppasswrd);
761
762         len = strlen(pass);
763
764         for(i=0;i<len;i++)  {
765                 if(pass[i] == ',')
766                         number_of_commas++;
767         }
768
769         if(number_of_commas == 0)
770                 return;
771         if(number_of_commas > MOUNT_PASSWD_SIZE) {
772                 /* would otherwise overflow the mount options buffer */
773                 printf("\nInvalid password. Password contains too many commas.\n");
774                 return;
775         }
776
777         new_pass_buf = (char *)malloc(len+number_of_commas+1);
778         if(new_pass_buf == NULL)
779                 return;
780
781         for(i=0,j=0;i<len;i++,j++) {
782                 new_pass_buf[j] = pass[i];
783                 if(pass[i] == ',') {
784                         j++;
785                         new_pass_buf[j] = pass[i];
786                 }
787         }
788         new_pass_buf[len+number_of_commas] = 0;
789
790         SAFE_FREE(*ppasswrd);
791         *ppasswrd = new_pass_buf;
792         
793         return;
794 }
795
796 /* Usernames can not have backslash in them and we use
797    [BB check if usernames can have forward slash in them BB] 
798    backslash as domain\user separator character
799 */
800 static char * check_for_domain(char **ppuser)
801 {
802         char * original_string;
803         char * usernm;
804         char * domainnm;
805         int    original_len;
806         int    len;
807         int    i;
808
809         if(ppuser == NULL)
810                 return NULL;
811
812         original_string = *ppuser;
813
814         if (original_string == NULL)
815                 return NULL;
816         
817         original_len = strlen(original_string);
818
819         usernm = strchr(*ppuser,'/');
820         if (usernm == NULL) {
821                 usernm = strchr(*ppuser,'\\');
822                 if (usernm == NULL)
823                         return NULL;
824         }
825
826         if(got_domain) {
827                 printf("Domain name specified twice. Username probably malformed\n");
828                 return NULL;
829         }
830
831         usernm[0] = 0;
832         domainnm = *ppuser;
833         if (domainnm[0] != 0) {
834                 got_domain = 1;
835         } else {
836                 printf("null domain\n");
837         }
838         len = strlen(domainnm);
839         /* reset domainm to new buffer, and copy
840         domain name into it */
841         domainnm = (char *)malloc(len+1);
842         if(domainnm == NULL)
843                 return NULL;
844
845         strlcpy(domainnm,*ppuser,len+1);
846
847 /*      move_string(*ppuser, usernm+1) */
848         len = strlen(usernm+1);
849
850         if(len >= original_len) {
851                 /* should not happen */
852                 return domainnm;
853         }
854
855         for(i=0;i<original_len;i++) {
856                 if(i<len)
857                         original_string[i] = usernm[i+1];
858                 else /* stuff with commas to remove last parm */
859                         original_string[i] = ',';
860         }
861
862         /* BB add check for more than one slash? 
863           strchr(*ppuser,'/');
864           strchr(*ppuser,'\\') 
865         */
866         
867         return domainnm;
868 }
869
870 /* replace all occurances of "from" in a string with "to" */
871 static void replace_char(char *string, char from, char to, int maxlen)
872 {
873         char *lastchar = string + maxlen;
874         while (string) {
875                 string = strchr(string, from);
876                 if (string) {
877                         *string = to;
878                         if (string >= lastchar)
879                                 return;
880                 }
881         }
882 }
883
884 /* Note that caller frees the returned buffer if necessary */
885 static char * parse_server(char ** punc_name)
886 {
887         char * unc_name = *punc_name;
888         int length = strnlen(unc_name, MAX_UNC_LEN);
889         char * share;
890         char * ipaddress_string = NULL;
891         struct hostent * host_entry = NULL;
892         struct in_addr server_ipaddr;
893
894         if(length > (MAX_UNC_LEN - 1)) {
895                 printf("mount error: UNC name too long");
896                 return NULL;
897         }
898         if (strncasecmp("cifs://",unc_name,7) == 0)
899                 return parse_cifs_url(unc_name+7);
900         if (strncasecmp("smb://",unc_name,6) == 0) {
901                 return parse_cifs_url(unc_name+6);
902         }
903
904         if(length < 3) {
905                 /* BB add code to find DFS root here */
906                 printf("\nMounting the DFS root for domain not implemented yet\n");
907                 return NULL;
908         } else {
909                 if(strncmp(unc_name,"//",2) && strncmp(unc_name,"\\\\",2)) {
910                         /* check for nfs syntax ie server:share */
911                         share = strchr(unc_name,':');
912                         if(share) {
913                                 *punc_name = (char *)malloc(length+3);
914                                 if(*punc_name == NULL) {
915                                         /* put the original string back  if 
916                                            no memory left */
917                                         *punc_name = unc_name;
918                                         return NULL;
919                                 }
920                                 *share = '/';
921                                 strlcpy((*punc_name)+2,unc_name,length+1);
922                                 SAFE_FREE(unc_name);
923                                 unc_name = *punc_name;
924                                 unc_name[length+2] = 0;
925                                 goto continue_unc_parsing;
926                         } else {
927                                 printf("mount error: improperly formatted UNC name.");
928                                 printf(" %s does not begin with \\\\ or //\n",unc_name);
929                                 return NULL;
930                         }
931                 } else {
932 continue_unc_parsing:
933                         unc_name[0] = '/';
934                         unc_name[1] = '/';
935                         unc_name += 2;
936
937                         /* allow for either delimiter between host and sharename */
938                         if ((share = strpbrk(unc_name, "/\\"))) {
939                                 *share = 0;  /* temporarily terminate the string */
940                                 share += 1;
941                                 if(got_ip == 0) {
942                                         host_entry = gethostbyname(unc_name);
943                                 }
944                                 *(share - 1) = '/'; /* put delimiter back */
945
946                                 /* we don't convert the prefixpath delimiters since '\\' is a valid char in posix paths */
947                                 if ((prefixpath = strpbrk(share, "/\\"))) {
948                                         *prefixpath = 0;  /* permanently terminate the string */
949                                         if (!strlen(++prefixpath))
950                                                 prefixpath = NULL; /* this needs to be done explicitly */
951                                 }
952                                 if(got_ip) {
953                                         if(verboseflag)
954                                                 printf("ip address specified explicitly\n");
955                                         return NULL;
956                                 }
957                                 if(host_entry == NULL) {
958                                         printf("mount error: could not find target server. TCP name %s not found\n", unc_name);
959                                         return NULL;
960                                 } else {
961                                         /* BB should we pass an alternate version of the share name as Unicode */
962                                         /* BB what about ipv6? BB */
963                                         /* BB add retries with alternate servers in list */
964
965                                         memcpy(&server_ipaddr.s_addr, host_entry->h_addr, 4);
966
967                                         ipaddress_string = inet_ntoa(server_ipaddr);                                                                                     
968                                         if(ipaddress_string == NULL) {
969                                                 printf("mount error: could not get valid ip address for target server\n");
970                                                 return NULL;
971                                         }
972                                         return ipaddress_string; 
973                                 }
974                         } else {
975                                 /* BB add code to find DFS root (send null path on get DFS Referral to specified server here */
976                                 printf("Mounting the DFS root for a particular server not implemented yet\n");
977                                 return NULL;
978                         }
979                 }
980         }
981 }
982
983 static struct option longopts[] = {
984         { "all", 0, NULL, 'a' },
985         { "help",0, NULL, 'h' },
986         { "move",0, NULL, 'm' },
987         { "bind",0, NULL, 'b' },
988         { "read-only", 0, NULL, 'r' },
989         { "ro", 0, NULL, 'r' },
990         { "verbose", 0, NULL, 'v' },
991         { "version", 0, NULL, 'V' },
992         { "read-write", 0, NULL, 'w' },
993         { "rw", 0, NULL, 'w' },
994         { "options", 1, NULL, 'o' },
995         { "type", 1, NULL, 't' },
996         { "rsize",1, NULL, 'R' },
997         { "wsize",1, NULL, 'W' },
998         { "uid", 1, NULL, '1'},
999         { "gid", 1, NULL, '2'},
1000         { "user",1,NULL,'u'},
1001         { "username",1,NULL,'u'},
1002         { "dom",1,NULL,'d'},
1003         { "domain",1,NULL,'d'},
1004         { "password",1,NULL,'p'},
1005         { "pass",1,NULL,'p'},
1006         { "credentials",1,NULL,'c'},
1007         { "port",1,NULL,'P'},
1008         /* { "uuid",1,NULL,'U'}, */ /* BB unimplemented */
1009         { NULL, 0, NULL, 0 }
1010 };
1011
1012 /* convert a string to uppercase. return false if the string
1013  * wasn't ASCII. Return success on a NULL ptr */
1014 static int
1015 uppercase_string(char *string)
1016 {
1017         if (!string)
1018                 return 1;
1019
1020         while (*string) {
1021                 /* check for unicode */
1022                 if ((unsigned char) string[0] & 0x80)
1023                         return 0;
1024                 *string = toupper((unsigned char) *string);
1025                 string++;
1026         }
1027
1028         return 1;
1029 }
1030
1031 int main(int argc, char ** argv)
1032 {
1033         int c;
1034         int flags = MS_MANDLOCK; /* no need to set legacy MS_MGC_VAL */
1035         char * orgoptions = NULL;
1036         char * share_name = NULL;
1037         char * ipaddr = NULL;
1038         char * uuid = NULL;
1039         char * mountpoint = NULL;
1040         char * options = NULL;
1041         char * resolved_path = NULL;
1042         char * temp;
1043         char * dev_name;
1044         int rc;
1045         int rsize = 0;
1046         int wsize = 0;
1047         int nomtab = 0;
1048         int uid = 0;
1049         int gid = 0;
1050         int optlen = 0;
1051         int orgoptlen = 0;
1052         size_t options_size = 0;
1053         int retry = 0; /* set when we have to retry mount with uppercase */
1054         struct stat statbuf;
1055         struct utsname sysinfo;
1056         struct mntent mountent;
1057         FILE * pmntfile;
1058
1059         /* setlocale(LC_ALL, "");
1060         bindtextdomain(PACKAGE, LOCALEDIR);
1061         textdomain(PACKAGE); */
1062
1063         if(argc && argv) {
1064                 thisprogram = argv[0];
1065         } else {
1066                 mount_cifs_usage();
1067                 exit(EX_USAGE);
1068         }
1069
1070         if(thisprogram == NULL)
1071                 thisprogram = "mount.cifs";
1072
1073         uname(&sysinfo);
1074         /* BB add workstation name and domain and pass down */
1075
1076 /* #ifdef _GNU_SOURCE
1077         printf(" node: %s machine: %s sysname %s domain %s\n", sysinfo.nodename,sysinfo.machine,sysinfo.sysname,sysinfo.domainname);
1078 #endif */
1079         if(argc > 2) {
1080                 dev_name = argv[1];
1081                 share_name = strndup(argv[1], MAX_UNC_LEN);
1082                 if (share_name == NULL) {
1083                         fprintf(stderr, "%s: %s", argv[0], strerror(ENOMEM));
1084                         exit(EX_SYSERR);
1085                 }
1086                 mountpoint = argv[2];
1087         } else {
1088                 mount_cifs_usage();
1089                 exit(EX_USAGE);
1090         }
1091
1092         /* add sharename in opts string as unc= parm */
1093
1094         while ((c = getopt_long (argc, argv, "afFhilL:no:O:rsSU:vVwt:",
1095                          longopts, NULL)) != -1) {
1096                 switch (c) {
1097 /* No code to do the following  options yet */
1098 /*      case 'l':
1099                 list_with_volumelabel = 1;
1100                 break;
1101         case 'L':
1102                 volumelabel = optarg;
1103                 break; */
1104 /*      case 'a':              
1105                 ++mount_all;
1106                 break; */
1107
1108                 case '?':
1109                 case 'h':        /* help */
1110                         mount_cifs_usage ();
1111                         exit(EX_USAGE);
1112                 case 'n':
1113                     ++nomtab;
1114                     break;
1115                 case 'b':
1116 #ifdef MS_BIND
1117                         flags |= MS_BIND;
1118 #else
1119                         fprintf(stderr,
1120                                 "option 'b' (MS_BIND) not supported\n");
1121 #endif
1122                         break;
1123                 case 'm':
1124 #ifdef MS_MOVE                
1125                         flags |= MS_MOVE;
1126 #else
1127                         fprintf(stderr,
1128                                 "option 'm' (MS_MOVE) not supported\n");
1129 #endif
1130                         break;
1131                 case 'o':
1132                         orgoptions = strdup(optarg);
1133                     break;
1134                 case 'r':  /* mount readonly */
1135                         flags |= MS_RDONLY;
1136                         break;
1137                 case 'U':
1138                         uuid = optarg;
1139                         break;
1140                 case 'v':
1141                         ++verboseflag;
1142                         break;
1143                 case 'V':          
1144                         printf ("mount.cifs version: %s.%s%s\n",
1145                         MOUNT_CIFS_VERSION_MAJOR,
1146                         MOUNT_CIFS_VERSION_MINOR,
1147                         MOUNT_CIFS_VENDOR_SUFFIX);
1148                         exit (0);
1149                 case 'w':
1150                         flags &= ~MS_RDONLY;
1151                         break;
1152                 case 'R':
1153                         rsize = atoi(optarg) ;
1154                         break;
1155                 case 'W':
1156                         wsize = atoi(optarg);
1157                         break;
1158                 case '1':
1159                         if (isdigit(*optarg)) {
1160                                 char *ep;
1161
1162                                 uid = strtoul(optarg, &ep, 10);
1163                                 if (*ep) {
1164                                         printf("bad uid value \"%s\"\n", optarg);
1165                                         exit(EX_USAGE);
1166                                 }
1167                         } else {
1168                                 struct passwd *pw;
1169
1170                                 if (!(pw = getpwnam(optarg))) {
1171                                         printf("bad user name \"%s\"\n", optarg);
1172                                         exit(EX_USAGE);
1173                                 }
1174                                 uid = pw->pw_uid;
1175                                 endpwent();
1176                         }
1177                         break;
1178                 case '2':
1179                         if (isdigit(*optarg)) {
1180                                 char *ep;
1181
1182                                 gid = strtoul(optarg, &ep, 10);
1183                                 if (*ep) {
1184                                         printf("bad gid value \"%s\"\n", optarg);
1185                                         exit(EX_USAGE);
1186                                 }
1187                         } else {
1188                                 struct group *gr;
1189
1190                                 if (!(gr = getgrnam(optarg))) {
1191                                         printf("bad user name \"%s\"\n", optarg);
1192                                         exit(EX_USAGE);
1193                                 }
1194                                 gid = gr->gr_gid;
1195                                 endpwent();
1196                         }
1197                         break;
1198                 case 'u':
1199                         got_user = 1;
1200                         user_name = optarg;
1201                         break;
1202                 case 'd':
1203                         domain_name = optarg; /* BB fix this - currently ignored */
1204                         got_domain = 1;
1205                         break;
1206                 case 'p':
1207                         if(mountpassword == NULL)
1208                                 mountpassword = (char *)calloc(MOUNT_PASSWD_SIZE+1,1);
1209                         if(mountpassword) {
1210                                 got_password = 1;
1211                                 strlcpy(mountpassword,optarg,MOUNT_PASSWD_SIZE+1);
1212                         }
1213                         break;
1214                 case 'S':
1215                         get_password_from_file(0 /* stdin */,NULL);
1216                         break;
1217                 case 't':
1218                         break;
1219                 default:
1220                         printf("unknown mount option %c\n",c);
1221                         mount_cifs_usage();
1222                         exit(EX_USAGE);
1223                 }
1224         }
1225
1226         if((argc < 3) || (dev_name == NULL) || (mountpoint == NULL)) {
1227                 mount_cifs_usage();
1228                 exit(EX_USAGE);
1229         }
1230
1231         if (getenv("PASSWD")) {
1232                 if(mountpassword == NULL)
1233                         mountpassword = (char *)calloc(MOUNT_PASSWD_SIZE+1,1);
1234                 if(mountpassword) {
1235                         strlcpy(mountpassword,getenv("PASSWD"),MOUNT_PASSWD_SIZE+1);
1236                         got_password = 1;
1237                 }
1238         } else if (getenv("PASSWD_FD")) {
1239                 get_password_from_file(atoi(getenv("PASSWD_FD")),NULL);
1240         } else if (getenv("PASSWD_FILE")) {
1241                 get_password_from_file(0, getenv("PASSWD_FILE"));
1242         }
1243
1244         if (orgoptions && parse_options(&orgoptions, &flags)) {
1245                 rc = EX_USAGE;
1246                 goto mount_exit;
1247         }
1248         ipaddr = parse_server(&share_name);
1249         if((ipaddr == NULL) && (got_ip == 0)) {
1250                 printf("No ip address specified and hostname not found\n");
1251                 rc = EX_USAGE;
1252                 goto mount_exit;
1253         }
1254         
1255         /* BB save off path and pop after mount returns? */
1256         resolved_path = (char *)malloc(PATH_MAX+1);
1257         if(resolved_path) {
1258                 /* Note that if we can not canonicalize the name, we get
1259                 another chance to see if it is valid when we chdir to it */
1260                 if (realpath(mountpoint, resolved_path)) {
1261                         mountpoint = resolved_path; 
1262                 }
1263         }
1264         if(chdir(mountpoint)) {
1265                 printf("mount error: can not change directory into mount target %s\n",mountpoint);
1266                 rc = EX_USAGE;
1267                 goto mount_exit;
1268         }
1269
1270         if(stat (".", &statbuf)) {
1271                 printf("mount error: mount point %s does not exist\n",mountpoint);
1272                 rc = EX_USAGE;
1273                 goto mount_exit;
1274         }
1275
1276         if (S_ISDIR(statbuf.st_mode) == 0) {
1277                 printf("mount error: mount point %s is not a directory\n",mountpoint);
1278                 rc = EX_USAGE;
1279                 goto mount_exit;
1280         }
1281
1282         if((getuid() != 0) && (geteuid() == 0)) {
1283                 if((statbuf.st_uid == getuid()) && (S_IRWXU == (statbuf.st_mode & S_IRWXU))) {
1284 #ifndef CIFS_ALLOW_USR_SUID
1285                         /* Do not allow user mounts to control suid flag
1286                         for mount unless explicitly built that way */
1287                         flags |= MS_NOSUID | MS_NODEV;
1288 #endif                                          
1289                 } else {
1290                         printf("mount error: permission denied or not superuser and mount.cifs not installed SUID\n"); 
1291                         exit(EX_USAGE);
1292                 }
1293         }
1294
1295         if(got_user == 0) {
1296                 /* Note that the password will not be retrieved from the
1297                    USER env variable (ie user%password form) as there is
1298                    already a PASSWD environment varaible */
1299                 if (getenv("USER"))
1300                         user_name = strdup(getenv("USER"));
1301                 if (user_name == NULL)
1302                         user_name = getusername();
1303                 got_user = 1;
1304         }
1305        
1306         if(got_password == 0) {
1307                 char *tmp_pass = getpass("Password: "); /* BB obsolete sys call but
1308                                                            no good replacement yet. */
1309                 mountpassword = (char *)calloc(MOUNT_PASSWD_SIZE+1,1);
1310                 if (!tmp_pass || !mountpassword) {
1311                         printf("Password not entered, exiting\n");
1312                         exit(EX_USAGE);
1313                 }
1314                 strlcpy(mountpassword, tmp_pass, MOUNT_PASSWD_SIZE+1);
1315                 got_password = 1;
1316         }
1317         /* FIXME launch daemon (handles dfs name resolution and credential change) 
1318            remember to clear parms and overwrite password field before launching */
1319 mount_retry:
1320         if(orgoptions) {
1321                 optlen = strlen(orgoptions);
1322                 orgoptlen = optlen;
1323         } else
1324                 optlen = 0;
1325         if(share_name)
1326                 optlen += strlen(share_name) + 4;
1327         else {
1328                 printf("No server share name specified\n");
1329                 printf("\nMounting the DFS root for server not implemented yet\n");
1330                 exit(EX_USAGE);
1331         }
1332         if(user_name)
1333                 optlen += strlen(user_name) + 6;
1334         if(ipaddr)
1335                 optlen += strlen(ipaddr) + 4;
1336         if(mountpassword)
1337                 optlen += strlen(mountpassword) + 6;
1338         SAFE_FREE(options);
1339         options_size = optlen + 10 + DOMAIN_SIZE;
1340         options = (char *)malloc(options_size /* space for commas in password */ + 8 /* space for domain=  , domain name itself was counted as part of the length username string above */);
1341
1342         if(options == NULL) {
1343                 printf("Could not allocate memory for mount options\n");
1344                 exit(EX_SYSERR);
1345         }
1346
1347         options[0] = 0;
1348         strlcpy(options,"unc=",options_size);
1349         strlcat(options,share_name,options_size);
1350         /* scan backwards and reverse direction of slash */
1351         temp = strrchr(options, '/');
1352         if(temp > options + 6)
1353                 *temp = '\\';
1354         if(ipaddr) {
1355                 strlcat(options,",ip=",options_size);
1356                 strlcat(options,ipaddr,options_size);
1357         }
1358
1359         if(user_name) {
1360                 /* check for syntax like user=domain\user */
1361                 if(got_domain == 0)
1362                         domain_name = check_for_domain(&user_name);
1363                 strlcat(options,",user=",options_size);
1364                 strlcat(options,user_name,options_size);
1365         }
1366         if(retry == 0) {
1367                 if(domain_name) {
1368                         /* extra length accounted for in option string above */
1369                         strlcat(options,",domain=",options_size);
1370                         strlcat(options,domain_name,options_size);
1371                 }
1372         }
1373         if(mountpassword) {
1374                 /* Commas have to be doubled, or else they will
1375                 look like the parameter separator */
1376 /*              if(sep is not set)*/
1377                 if(retry == 0)
1378                         check_for_comma(&mountpassword);
1379                 strlcat(options,",pass=",options_size);
1380                 strlcat(options,mountpassword,options_size);
1381         }
1382
1383         strlcat(options,",ver=",options_size);
1384         strlcat(options,MOUNT_CIFS_VERSION_MAJOR,options_size);
1385
1386         if(orgoptions) {
1387                 strlcat(options,",",options_size);
1388                 strlcat(options,orgoptions,options_size);
1389         }
1390         if(prefixpath) {
1391                 strlcat(options,",prefixpath=",options_size);
1392                 strlcat(options,prefixpath,options_size); /* no need to cat the / */
1393         }
1394         if(verboseflag)
1395                 printf("\nmount.cifs kernel mount options %s \n",options);
1396
1397         /* convert all '\\' to '/' in share portion so that /proc/mounts looks pretty */
1398         replace_char(dev_name, '\\', '/', strlen(share_name));
1399
1400         if(mount(dev_name, mountpoint, "cifs", flags, options)) {
1401         /* remember to kill daemon on error */
1402                 switch (errno) {
1403                 case 0:
1404                         printf("mount failed but no error number set\n");
1405                         break;
1406                 case ENODEV:
1407                         printf("mount error: cifs filesystem not supported by the system\n");
1408                         break;
1409                 case ENXIO:
1410                         if(retry == 0) {
1411                                 retry = 1;
1412                                 if (uppercase_string(dev_name) &&
1413                                     uppercase_string(share_name) &&
1414                                     uppercase_string(prefixpath)) {
1415                                         printf("retrying with upper case share name\n");
1416                                         goto mount_retry;
1417                                 }
1418                         }
1419                 default:
1420                         printf("mount error %d = %s\n",errno,strerror(errno));
1421                 }
1422                 printf("Refer to the mount.cifs(8) manual page (e.g.man mount.cifs)\n");
1423                 rc = EX_FAIL;
1424         } else {
1425                 atexit(unlock_mtab);
1426                 rc = lock_mtab();
1427                 if (rc) {
1428                         printf("cannot lock mtab");
1429                         goto mount_exit;
1430                 }
1431                 pmntfile = setmntent(MOUNTED, "a+");
1432                 if (!pmntfile) {
1433                         printf("could not update mount table\n");
1434                         unlock_mtab();
1435                         rc = EX_FILEIO;
1436                         goto mount_exit;
1437                 }
1438                 mountent.mnt_fsname = dev_name;
1439                 mountent.mnt_dir = mountpoint;
1440                 mountent.mnt_type = CONST_DISCARD(char *,"cifs");
1441                 mountent.mnt_opts = (char *)malloc(220);
1442                 if(mountent.mnt_opts) {
1443                         char * mount_user = getusername();
1444                         memset(mountent.mnt_opts,0,200);
1445                         if(flags & MS_RDONLY)
1446                                 strlcat(mountent.mnt_opts,"ro",220);
1447                         else
1448                                 strlcat(mountent.mnt_opts,"rw",220);
1449                         if(flags & MS_MANDLOCK)
1450                                 strlcat(mountent.mnt_opts,",mand",220);
1451                         if(flags & MS_NOEXEC)
1452                                 strlcat(mountent.mnt_opts,",noexec",220);
1453                         if(flags & MS_NOSUID)
1454                                 strlcat(mountent.mnt_opts,",nosuid",220);
1455                         if(flags & MS_NODEV)
1456                                 strlcat(mountent.mnt_opts,",nodev",220);
1457                         if(flags & MS_SYNCHRONOUS)
1458                                 strlcat(mountent.mnt_opts,",sync",220);
1459                         if(mount_user) {
1460                                 if(getuid() != 0) {
1461                                         strlcat(mountent.mnt_opts,
1462                                                 ",user=", 220);
1463                                         strlcat(mountent.mnt_opts,
1464                                                 mount_user, 220);
1465                                 }
1466                         }
1467                 }
1468                 mountent.mnt_freq = 0;
1469                 mountent.mnt_passno = 0;
1470                 rc = addmntent(pmntfile,&mountent);
1471                 endmntent(pmntfile);
1472                 unlock_mtab();
1473                 SAFE_FREE(mountent.mnt_opts);
1474                 if (rc)
1475                         rc = EX_FILEIO;
1476         }
1477 mount_exit:
1478         if(mountpassword) {
1479                 int len = strlen(mountpassword);
1480                 memset(mountpassword,0,len);
1481                 SAFE_FREE(mountpassword);
1482         }
1483
1484         SAFE_FREE(options);
1485         SAFE_FREE(orgoptions);
1486         SAFE_FREE(resolved_path);
1487         SAFE_FREE(share_name);
1488         exit(rc);
1489 }