source: branches/samba-3.2.x/source/client/mount.cifs.c@ 232

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

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