source: branches/samba-3.3.x/source/client/mount.cifs.c@ 342

Last change on this file since 342 was 342, checked in by Herwig Bauernfeind, 16 years ago

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