remove useless xorg macros patch
[openwrt/svn-archive/archive.git] / utils / cifsmount / mount.cifs.c
1 /*
2 Mount helper utility for Linux CIFS VFS (virtual filesystem) client
3 Copyright (C) 2003 Steve French (sfrench@us.ibm.com)
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
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 <sys/types.h>
28 #include <sys/mount.h>
29 #include <sys/stat.h>
30 #include <sys/utsname.h>
31 #include <sys/socket.h>
32 #include <arpa/inet.h>
33 #include <getopt.h>
34 #include <errno.h>
35 #include <netdb.h>
36 #include <string.h>
37 #include <mntent.h>
38 #include <fcntl.h>
39
40 #define MOUNT_CIFS_VERSION_MAJOR "1"
41 #define MOUNT_CIFS_VERSION_MINOR "5"
42
43 #ifndef MOUNT_CIFS_VENDOR_SUFFIX
44 #define MOUNT_CIFS_VENDOR_SUFFIX ""
45 #endif
46
47 #ifndef MS_MOVE
48 #define MS_MOVE 8192
49 #endif
50
51 char * thisprogram;
52 int verboseflag = 0;
53 static int got_password = 0;
54 static int got_user = 0;
55 static int got_domain = 0;
56 static int got_ip = 0;
57 static int got_unc = 0;
58 static int got_uid = 0;
59 static int got_gid = 0;
60 static int free_share_name = 0;
61 static char * user_name = NULL;
62 char * mountpassword = NULL;
63
64
65 /* BB finish BB
66
67 cifs_umount
68 open nofollow - avoid symlink exposure?
69 get owner of dir see if matches self or if root
70 call system(umount argv) etc.
71
72 BB end finish BB */
73
74 static void mount_cifs_usage(void)
75 {
76 printf("\nUsage: %s <remotetarget> <dir> -o <options>\n", thisprogram);
77 printf("\nMount the remote target, specified as a UNC name,");
78 printf(" to a local directory.\n\nOptions:\n");
79 printf("\tuser=<arg>\n\tpass=<arg>\n\tdom=<arg>\n");
80 printf("\nLess commonly used options:");
81 printf("\n\tcredentials=<filename>,guest,perm,noperm,setuids,nosetuids,\n\trw,ro,sep=<char>,iocharset=<codepage>,suid,nosuid,exec,noexec");
82 printf("\n\nOptions not needed for servers supporting CIFS Unix extensions (e.g. most Samba versions):");
83 printf("\n\tuid=<uid>,gid=<gid>,dir_mode=<mode>,file_mode=<mode>");
84 printf("\n\nRarely used options:");
85 printf("\n\tport=<tcpport>,rsize=<size>,wsize=<size>,unc=<unc_name>,ip=<ip_address>,dev,nodev");
86 printf("\n\nOptions are described in more detail in the manual page");
87 printf("\n\tman 8 mount.cifs\n");
88 printf("\nTo display the version number of the mount helper:");
89 printf("\n\t%s -V\n",thisprogram);
90
91 if(mountpassword) {
92 memset(mountpassword,0,64);
93 free(mountpassword);
94 }
95 exit(1);
96 }
97
98 /* caller frees username if necessary */
99 static char * getusername(void) {
100 char *username = NULL;
101 struct passwd *password = getpwuid(getuid());
102
103 if (password) {
104 username = password->pw_name;
105 }
106 return username;
107 }
108
109 char * parse_cifs_url(char * unc_name)
110 {
111 printf("\nMounting cifs URL not implemented yet. Attempt to mount %s\n",unc_name);
112 return NULL;
113 }
114
115 static int open_cred_file(char * file_name)
116 {
117 char * line_buf;
118 char * temp_val;
119 FILE * fs;
120 int i, length;
121 fs = fopen(file_name,"r");
122 if(fs == NULL)
123 return errno;
124 line_buf = malloc(4096);
125 if(line_buf == NULL)
126 return -ENOMEM;
127
128 while(fgets(line_buf,4096,fs)) {
129 /* parse line from credential file */
130
131 /* eat leading white space */
132 for(i=0;i<4086;i++) {
133 if((line_buf[i] != ' ') && (line_buf[i] != '\t'))
134 break;
135 /* if whitespace - skip past it */
136 }
137 if (strncasecmp("username",line_buf+i,8) == 0) {
138 temp_val = strchr(line_buf + i,'=');
139 if(temp_val) {
140 /* go past equals sign */
141 temp_val++;
142 for(length = 0;length<4087;length++) {
143 if(temp_val[length] == '\n')
144 break;
145 }
146 if(length > 4086) {
147 printf("mount.cifs failed due to malformed username in credentials file");
148 memset(line_buf,0,4096);
149 if(mountpassword) {
150 memset(mountpassword,0,64);
151 }
152 exit(1);
153 } else {
154 got_user = 1;
155 user_name = calloc(1 + length,1);
156 /* BB adding free of user_name string before exit,
157 not really necessary but would be cleaner */
158 strncpy(user_name,temp_val, length);
159 }
160 }
161 } else if (strncasecmp("password",line_buf+i,8) == 0) {
162 temp_val = strchr(line_buf+i,'=');
163 if(temp_val) {
164 /* go past equals sign */
165 temp_val++;
166 for(length = 0;length<65;length++) {
167 if(temp_val[length] == '\n')
168 break;
169 }
170 if(length > 64) {
171 printf("mount.cifs failed: password in credentials file too long\n");
172 memset(line_buf,0, 4096);
173 if(mountpassword) {
174 memset(mountpassword,0,64);
175 }
176 exit(1);
177 } else {
178 if(mountpassword == NULL) {
179 mountpassword = calloc(65,1);
180 } else
181 memset(mountpassword,0,64);
182 if(mountpassword) {
183 /* BB add handling for commas in password here */
184 strncpy(mountpassword,temp_val,length);
185 got_password = 1;
186 }
187 }
188 }
189 }
190 }
191 fclose(fs);
192 if(line_buf) {
193 memset(line_buf,0,4096);
194 free(line_buf);
195 }
196 return 0;
197 }
198
199 static int get_password_from_file(int file_descript, char * filename)
200 {
201 int rc = 0;
202 int i;
203 char c;
204
205 if(mountpassword == NULL)
206 mountpassword = calloc(65,1);
207 else
208 memset(mountpassword, 0, 64);
209
210 if(filename != NULL) {
211 file_descript = open(filename, O_RDONLY);
212 if(file_descript < 0) {
213 printf("mount.cifs failed. %s attempting to open password file %s\n",
214 strerror(errno),filename);
215 exit(1);
216 }
217 }
218 /* else file already open and fd provided */
219
220 for(i=0;i<64;i++) {
221 rc = read(file_descript,&c,1);
222 if(rc < 0) {
223 printf("mount.cifs failed. Error %s reading password file\n",strerror(errno));
224 memset(mountpassword,0,64);
225 if(filename != NULL)
226 close(file_descript);
227 exit(1);
228 } else if(rc == 0) {
229 if(mountpassword[0] == 0) {
230 if(verboseflag)
231 printf("\nWarning: null password used since cifs password file empty");
232 }
233 break;
234 } else /* read valid character */ {
235 if((c == 0) || (c == '\n')) {
236 break;
237 } else
238 mountpassword[i] = c;
239 }
240 }
241 if((i == 64) && (verboseflag)) {
242 printf("\nWarning: password longer than 64 characters specified in cifs password file");
243 }
244 got_password = 1;
245 if(filename != NULL) {
246 close(file_descript);
247 }
248
249 return rc;
250 }
251
252 static int parse_options(char * options, int * filesys_flags)
253 {
254 char * data;
255 char * percent_char = NULL;
256 char * value = NULL;
257 char * next_keyword = NULL;
258 int rc = 0;
259
260 if (!options)
261 return 1;
262 else
263 data = options;
264
265 if(verboseflag)
266 printf("\n parsing options: %s", options);
267
268 /* while ((data = strsep(&options, ",")) != NULL) { */
269 while(data != NULL) {
270 /* check if ends with trailing comma */
271 if(*data == 0)
272 break;
273
274 /* format is keyword=value,keyword2=value2,keyword3=value3 etc.) */
275 /* data = next keyword */
276 /* value = next value ie stuff after equal sign */
277
278 next_keyword = strchr(data,',');
279
280 /* temporarily null terminate end of keyword=value pair */
281 if(next_keyword)
282 *next_keyword = 0;
283
284 /* if (!*data)
285 continue; */
286
287 /* temporarily null terminate keyword to make keyword and value distinct */
288 if ((value = strchr(data, '=')) != NULL) {
289 *value = '\0';
290 value++;
291 }
292
293 if (strncmp(data, "user", 4) == 0) {
294 if (!value || !*value) {
295 if(data[4] == '\0') {
296 if(verboseflag)
297 printf("\nskipping empty user mount parameter\n");
298 /* remove the parm since it would otherwise be confusing
299 to the kernel code which would think it was a real username */
300 data[0] = ',';
301 data[1] = ',';
302 data[2] = ',';
303 data[3] = ',';
304 /* BB remove it from mount line so as not to confuse kernel code */
305 } else {
306 printf("username specified with no parameter\n");
307 return 1; /* needs_arg; */
308 }
309 } else {
310 if (strnlen(value, 260) < 260) {
311 got_user=1;
312 percent_char = strchr(value,'%');
313 if(percent_char) {
314 *percent_char = ',';
315 if(mountpassword == NULL)
316 mountpassword = calloc(65,1);
317 if(mountpassword) {
318 if(got_password)
319 printf("\nmount.cifs warning - password specified twice\n");
320 got_password = 1;
321 percent_char++;
322 strncpy(mountpassword, percent_char,64);
323 /* remove password from username */
324 while(*percent_char != 0) {
325 *percent_char = ',';
326 percent_char++;
327 }
328 }
329 }
330 } else {
331 printf("username too long\n");
332 return 1;
333 }
334 }
335 } else if (strncmp(data, "pass", 4) == 0) {
336 if (!value || !*value) {
337 if(got_password) {
338 printf("\npassword specified twice, ignoring second\n");
339 } else
340 got_password = 1;
341 } else if (strnlen(value, 17) < 17) {
342 if(got_password)
343 printf("\nmount.cifs warning - password specified twice\n");
344 got_password = 1;
345 } else {
346 printf("password too long\n");
347 return 1;
348 }
349 } else if (strncmp(data, "ip", 2) == 0) {
350 if (!value || !*value) {
351 printf("target ip address argument missing");
352 } else if (strnlen(value, 35) < 35) {
353 if(verboseflag)
354 printf("ip address %s override specified\n",value);
355 got_ip = 1;
356 } else {
357 printf("ip address too long\n");
358 return 1;
359 }
360 } else if ((strncmp(data, "unc", 3) == 0)
361 || (strncmp(data, "target", 6) == 0)
362 || (strncmp(data, "path", 4) == 0)) {
363 if (!value || !*value) {
364 printf("invalid path to network resource\n");
365 return 1; /* needs_arg; */
366 } else if(strnlen(value,5) < 5) {
367 printf("UNC name too short");
368 }
369
370 if (strnlen(value, 300) < 300) {
371 got_unc = 1;
372 if (strncmp(value, "//", 2) == 0) {
373 if(got_unc)
374 printf("unc name specified twice, ignoring second\n");
375 else
376 got_unc = 1;
377 } else if (strncmp(value, "\\\\", 2) != 0) {
378 printf("UNC Path does not begin with // or \\\\ \n");
379 return 1;
380 } else {
381 if(got_unc)
382 printf("unc name specified twice, ignoring second\n");
383 else
384 got_unc = 1;
385 }
386 } else {
387 printf("CIFS: UNC name too long\n");
388 return 1;
389 }
390 } else if ((strncmp(data, "domain", 3) == 0)
391 || (strncmp(data, "workgroup", 5) == 0)) {
392 if (!value || !*value) {
393 printf("CIFS: invalid domain name\n");
394 return 1; /* needs_arg; */
395 }
396 if (strnlen(value, 65) < 65) {
397 got_domain = 1;
398 } else {
399 printf("domain name too long\n");
400 return 1;
401 }
402 } else if (strncmp(data, "cred", 4) == 0) {
403 if (value && *value) {
404 rc = open_cred_file(value);
405 if(rc) {
406 printf("error %d opening credential file %s\n",rc, value);
407 return 1;
408 }
409 } else {
410 printf("invalid credential file name specified\n");
411 return 1;
412 }
413 } else if (strncmp(data, "uid", 3) == 0) {
414 if (value && *value) {
415 got_uid = 1;
416 }
417 } else if (strncmp(data, "gid", 3) == 0) {
418 if (value && *value) {
419 got_gid = 1;
420 }
421 /* fmask and dmask synonyms for people used to smbfs syntax */
422 } else if (strcmp(data, "file_mode") == 0 || strcmp(data, "fmask")==0) {
423 if (!value || !*value) {
424 printf ("Option '%s' requires a numerical argument\n", data);
425 return 1;
426 }
427
428 if (value[0] != '0') {
429 printf ("WARNING: '%s' not expressed in octal.\n", data);
430 }
431
432 if (strcmp (data, "fmask") == 0) {
433 printf ("WARNING: CIFS mount option 'fmask' is deprecated. Use 'file_mode' instead.\n");
434 data = "file_mode"; /* BB fix this */
435 }
436 } else if (strcmp(data, "dir_mode") == 0 || strcmp(data, "dmask")==0) {
437 if (!value || !*value) {
438 printf ("Option '%s' requires a numerical argument\n", data);
439 return 1;
440 }
441
442 if (value[0] != '0') {
443 printf ("WARNING: '%s' not expressed in octal.\n", data);
444 }
445
446 if (strcmp (data, "dmask") == 0) {
447 printf ("WARNING: CIFS mount option 'dmask' is deprecated. Use 'dir_mode' instead.\n");
448 data = "dir_mode";
449 }
450 /* the following eight mount options should be
451 stripped out from what is passed into the kernel
452 since these eight options are best passed as the
453 mount flags rather than redundantly to the kernel
454 and could generate spurious warnings depending on the
455 level of the corresponding cifs vfs kernel code */
456 } else if (strncmp(data, "nosuid", 6) == 0) {
457 *filesys_flags |= MS_NOSUID;
458 } else if (strncmp(data, "suid", 4) == 0) {
459 *filesys_flags &= ~MS_NOSUID;
460 } else if (strncmp(data, "nodev", 5) == 0) {
461 *filesys_flags |= MS_NODEV;
462 } else if (strncmp(data, "dev", 3) == 0) {
463 *filesys_flags &= ~MS_NODEV;
464 } else if (strncmp(data, "noexec", 6) == 0) {
465 *filesys_flags |= MS_NOEXEC;
466 } else if (strncmp(data, "exec", 4) == 0) {
467 *filesys_flags &= ~MS_NOEXEC;
468 } else if (strncmp(data, "guest", 5) == 0) {
469 got_password=1;
470 } else if (strncmp(data, "ro", 2) == 0) {
471 *filesys_flags |= MS_RDONLY;
472 } else if (strncmp(data, "rw", 2) == 0) {
473 *filesys_flags &= ~MS_RDONLY;
474 } /* else if (strnicmp(data, "port", 4) == 0) {
475 if (value && *value) {
476 vol->port =
477 simple_strtoul(value, &value, 0);
478 }
479 } else if (strnicmp(data, "rsize", 5) == 0) {
480 if (value && *value) {
481 vol->rsize =
482 simple_strtoul(value, &value, 0);
483 }
484 } else if (strnicmp(data, "wsize", 5) == 0) {
485 if (value && *value) {
486 vol->wsize =
487 simple_strtoul(value, &value, 0);
488 }
489 } else if (strnicmp(data, "version", 3) == 0) {
490 } else {
491 printf("CIFS: Unknown mount option %s\n",data);
492 } */ /* nothing to do on those four mount options above.
493 Just pass to kernel and ignore them here */
494
495 /* move to next option */
496 data = next_keyword+1;
497
498 /* put overwritten equals sign back */
499 if(value) {
500 value--;
501 *value = '=';
502 }
503
504 /* put previous overwritten comma back */
505 if(next_keyword)
506 *next_keyword = ',';
507 else
508 data = NULL;
509 }
510 return 0;
511 }
512
513 /* Note that caller frees the returned buffer if necessary */
514 char * parse_server(char ** punc_name)
515 {
516 char * unc_name = *punc_name;
517 int length = strnlen(unc_name,1024);
518 char * share;
519 char * ipaddress_string = NULL;
520 struct hostent * host_entry;
521 struct in_addr server_ipaddr;
522 int rc;
523
524 if(length > 1023) {
525 printf("mount error: UNC name too long");
526 return NULL;
527 }
528 if (strncasecmp("cifs://",unc_name,7) == 0)
529 return parse_cifs_url(unc_name+7);
530 if (strncasecmp("smb://",unc_name,6) == 0) {
531 return parse_cifs_url(unc_name+6);
532 }
533
534 if(length < 3) {
535 /* BB add code to find DFS root here */
536 printf("\nMounting the DFS root for domain not implemented yet");
537 return NULL;
538 } else {
539 if(strncmp(unc_name,"//",2) && strncmp(unc_name,"\\\\",2)) {
540 /* check for nfs syntax ie server:share */
541 share = strchr(unc_name,':');
542 if(share) {
543 free_share_name = 1;
544 *punc_name = malloc(length+3);
545 *share = '/';
546 strncpy((*punc_name)+2,unc_name,length);
547 unc_name = *punc_name;
548 unc_name[length+2] = 0;
549 goto continue_unc_parsing;
550 } else {
551 printf("mount error: improperly formatted UNC name.");
552 printf(" %s does not begin with \\\\ or //\n",unc_name);
553 return NULL;
554 }
555 } else {
556 continue_unc_parsing:
557 unc_name[0] = '/';
558 unc_name[1] = '/';
559 unc_name += 2;
560 if ((share = strchr(unc_name, '/')) ||
561 (share = strchr(unc_name,'\\'))) {
562 *share = 0; /* temporarily terminate the string */
563 share += 1;
564 if(got_ip == 0) {
565 host_entry = gethostbyname(unc_name);
566 }
567 *(share - 1) = '/'; /* put the slash back */
568 if(got_ip) {
569 if(verboseflag)
570 printf("ip address specified explicitly\n");
571 return NULL;
572 }
573 if(host_entry == NULL) {
574 printf("mount error: could not find target server. TCP name %s not found ", unc_name);
575 printf(" rc = %d\n",rc);
576 return NULL;
577 } else {
578 /* BB should we pass an alternate version of the share name as Unicode */
579 /* BB what about ipv6? BB */
580 /* BB add retries with alternate servers in list */
581
582 memcpy(&server_ipaddr.s_addr, host_entry->h_addr, 4);
583
584 ipaddress_string = inet_ntoa(server_ipaddr);
585 if(ipaddress_string == NULL) {
586 printf("mount error: could not get valid ip address for target server\n");
587 return NULL;
588 }
589 return ipaddress_string;
590 }
591 } else {
592 /* BB add code to find DFS root (send null path on get DFS Referral to specified server here */
593 printf("Mounting the DFS root for a particular server not implemented yet\n");
594 return NULL;
595 }
596 }
597 }
598 }
599
600 static struct option longopts[] = {
601 { "all", 0, NULL, 'a' },
602 { "help",0, NULL, 'h' },
603 { "move",0, NULL, 'm' },
604 { "bind",0, NULL, 'b' },
605 { "read-only", 0, NULL, 'r' },
606 { "ro", 0, NULL, 'r' },
607 { "verbose", 0, NULL, 'v' },
608 { "version", 0, NULL, 'V' },
609 { "read-write", 0, NULL, 'w' },
610 { "rw", 0, NULL, 'w' },
611 { "options", 1, NULL, 'o' },
612 { "type", 1, NULL, 't' },
613 { "rsize",1, NULL, 'R' },
614 { "wsize",1, NULL, 'W' },
615 { "uid", 1, NULL, '1'},
616 { "gid", 1, NULL, '2'},
617 { "user",1,NULL,'u'},
618 { "username",1,NULL,'u'},
619 { "dom",1,NULL,'d'},
620 { "domain",1,NULL,'d'},
621 { "password",1,NULL,'p'},
622 { "pass",1,NULL,'p'},
623 { "credentials",1,NULL,'c'},
624 { "port",1,NULL,'P'},
625 /* { "uuid",1,NULL,'U'}, */ /* BB unimplemented */
626 { NULL, 0, NULL, 0 }
627 };
628
629 int main(int argc, char ** argv)
630 {
631 int c;
632 int flags = MS_MANDLOCK; /* no need to set legacy MS_MGC_VAL */
633 char * orgoptions = NULL;
634 char * share_name = NULL;
635 char * domain_name = NULL;
636 char * ipaddr = NULL;
637 char * uuid = NULL;
638 char * mountpoint;
639 char * options;
640 char * resolved_path;
641 char * temp;
642 int rc;
643 int rsize = 0;
644 int wsize = 0;
645 int nomtab = 0;
646 int uid = 0;
647 int gid = 0;
648 int optlen = 0;
649 int orgoptlen = 0;
650 struct stat statbuf;
651 struct utsname sysinfo;
652 struct mntent mountent;
653 FILE * pmntfile;
654
655 /* setlocale(LC_ALL, "");
656 bindtextdomain(PACKAGE, LOCALEDIR);
657 textdomain(PACKAGE); */
658
659 if(argc && argv) {
660 thisprogram = argv[0];
661 }
662 if(thisprogram == NULL)
663 thisprogram = "mount.cifs";
664
665 uname(&sysinfo);
666 /* BB add workstation name and domain and pass down */
667
668 /* #ifdef _GNU_SOURCE
669 printf(" node: %s machine: %s sysname %s domain %s\n", sysinfo.nodename,sysinfo.machine,sysinfo.sysname,sysinfo.domainname);
670 #endif */
671
672 share_name = argv[1];
673 mountpoint = argv[2];
674
675 /* add sharename in opts string as unc= parm */
676
677 while ((c = getopt_long (argc, argv, "afFhilL:no:O:rsSU:vVwt:",
678 longopts, NULL)) != -1) {
679 switch (c) {
680 /* No code to do the following options yet */
681 /* case 'l':
682 list_with_volumelabel = 1;
683 break;
684 case 'L':
685 volumelabel = optarg;
686 break; */
687 /* case 'a':
688 ++mount_all;
689 break; */
690
691 case '?':
692 case 'h': /* help */
693 mount_cifs_usage ();
694 exit(1);
695 case 'n':
696 ++nomtab;
697 break;
698 case 'b':
699 flags |= MS_BIND;
700 break;
701 case 'm':
702 flags |= MS_MOVE;
703 break;
704 case 'o':
705 orgoptions = strdup(optarg);
706 break;
707 case 'r': /* mount readonly */
708 flags |= MS_RDONLY;
709 break;
710 case 'U':
711 uuid = optarg;
712 break;
713 case 'v':
714 ++verboseflag;
715 break;
716 case 'V':
717 printf ("mount.cifs version: %s.%s%s\n",
718 MOUNT_CIFS_VERSION_MAJOR,
719 MOUNT_CIFS_VERSION_MINOR,
720 MOUNT_CIFS_VENDOR_SUFFIX);
721 if(mountpassword) {
722 memset(mountpassword,0,64);
723 }
724 exit (0);
725 case 'w':
726 flags &= ~MS_RDONLY;
727 break;
728 case 'R':
729 rsize = atoi(optarg) ;
730 break;
731 case 'W':
732 wsize = atoi(optarg);
733 break;
734 case '1':
735 uid = atoi(optarg);
736 break;
737 case '2':
738 gid = atoi(optarg);
739 break;
740 case 'u':
741 got_user = 1;
742 user_name = optarg;
743 break;
744 case 'd':
745 domain_name = optarg;
746 break;
747 case 'p':
748 if(mountpassword == NULL)
749 mountpassword = calloc(65,1);
750 if(mountpassword) {
751 got_password = 1;
752 strncpy(mountpassword,optarg,64);
753 }
754 break;
755 case 'S':
756 get_password_from_file(0 /* stdin */,NULL);
757 break;
758 case 't':
759 break;
760 default:
761 printf("unknown mount option %c\n",c);
762 mount_cifs_usage();
763 exit(1);
764 }
765 }
766
767 if(argc < 3)
768 mount_cifs_usage();
769
770 if (getenv("PASSWD")) {
771 if(mountpassword == NULL)
772 mountpassword = calloc(65,1);
773 if(mountpassword) {
774 strncpy(mountpassword,getenv("PASSWD"),64);
775 got_password = 1;
776 }
777 } else if (getenv("PASSWD_FD")) {
778 get_password_from_file(atoi(getenv("PASSWD_FD")),NULL);
779 } else if (getenv("PASSWD_FILE")) {
780 get_password_from_file(0, getenv("PASSWD_FILE"));
781 }
782
783 if (orgoptions && parse_options(orgoptions, &flags))
784 return -1;
785
786 ipaddr = parse_server(&share_name);
787 if((ipaddr == NULL) && (got_ip == 0)) {
788 printf("No ip address specified and hostname not found\n");
789 return -1;
790 }
791
792
793 /* BB save off path and pop after mount returns? */
794 resolved_path = malloc(PATH_MAX+1);
795 if(resolved_path) {
796 /* Note that if we can not canonicalize the name, we get
797 another chance to see if it is valid when we chdir to it */
798 if (realpath(mountpoint, resolved_path)) {
799 mountpoint = resolved_path;
800 }
801 }
802 if(chdir(mountpoint)) {
803 printf("mount error: can not change directory into mount target %s\n",mountpoint);
804 return -1;
805 }
806
807 if(stat (".", &statbuf)) {
808 printf("mount error: mount point %s does not exist\n",mountpoint);
809 return -1;
810 }
811
812 if (S_ISDIR(statbuf.st_mode) == 0) {
813 printf("mount error: mount point %s is not a directory\n",mountpoint);
814 return -1;
815 }
816
817 if((getuid() != 0) && (geteuid() == 0)) {
818 if((statbuf.st_uid == getuid()) && (S_IRWXU == (statbuf.st_mode & S_IRWXU))) {
819 #ifndef CIFS_ALLOW_USR_SUID
820 /* Do not allow user mounts to control suid flag
821 for mount unless explicitly built that way */
822 flags |= MS_NOSUID | MS_NODEV;
823 #endif
824 } else {
825 printf("mount error: permission denied or not superuser and mount.cifs not installed SUID\n");
826 return -1;
827 }
828 }
829
830 if(got_user == 0)
831 user_name = getusername();
832
833 if(got_password == 0) {
834 mountpassword = getpass("Password: "); /* BB obsolete */
835 got_password = 1;
836 }
837 /* FIXME launch daemon (handles dfs name resolution and credential change)
838 remember to clear parms and overwrite password field before launching */
839 if(orgoptions) {
840 optlen = strlen(orgoptions);
841 orgoptlen = optlen;
842 } else
843 optlen = 0;
844 if(share_name)
845 optlen += strlen(share_name) + 4;
846 if(user_name)
847 optlen += strlen(user_name) + 6;
848 if(ipaddr)
849 optlen += strlen(ipaddr) + 4;
850 if(mountpassword)
851 optlen += strlen(mountpassword) + 6;
852 options = malloc(optlen + 10);
853
854 if(options == NULL) {
855 printf("Could not allocate memory for mount options\n");
856 return -1;
857 }
858
859
860 options[0] = 0;
861 strncat(options,"unc=",4);
862 strcat(options,share_name);
863 /* scan backwards and reverse direction of slash */
864 temp = strrchr(options, '/');
865 if(temp > options + 6)
866 *temp = '\\';
867 if(ipaddr) {
868 strncat(options,",ip=",4);
869 strcat(options,ipaddr);
870 }
871 if(user_name) {
872 strncat(options,",user=",6);
873 strcat(options,user_name);
874 }
875 if(mountpassword) {
876 strncat(options,",pass=",6);
877 strcat(options,mountpassword);
878 }
879 strncat(options,",ver=",5);
880 strcat(options,MOUNT_CIFS_VERSION_MAJOR);
881
882 if(orgoptions) {
883 strcat(options,",");
884 strcat(options,orgoptions);
885 }
886 if(verboseflag)
887 printf("\nmount.cifs kernel mount options %s \n",options);
888 if(mount(share_name, mountpoint, "cifs", flags, options)) {
889 /* remember to kill daemon on error */
890 switch (errno) {
891 case 0:
892 printf("mount failed but no error number set\n");
893 break;
894 case ENODEV:
895 printf("mount error: cifs filesystem not supported by the system\n");
896 break;
897 default:
898 printf("mount error %d = %s\n",errno,strerror(errno));
899 }
900 printf("Refer to the mount.cifs(8) manual page (e.g.man mount.cifs)\n");
901 if(mountpassword) {
902 memset(mountpassword,0,64);
903 }
904 return -1;
905 } else {
906 pmntfile = setmntent(MOUNTED, "a+");
907 if(pmntfile) {
908 mountent.mnt_fsname = share_name;
909 mountent.mnt_dir = mountpoint;
910 mountent.mnt_type = "cifs";
911 mountent.mnt_opts = malloc(220);
912 if(mountent.mnt_opts) {
913 char * mount_user = getusername();
914 memset(mountent.mnt_opts,0,200);
915 if(flags & MS_RDONLY)
916 strcat(mountent.mnt_opts,"ro");
917 else
918 strcat(mountent.mnt_opts,"rw");
919 if(flags & MS_MANDLOCK)
920 strcat(mountent.mnt_opts,",mand");
921 else
922 strcat(mountent.mnt_opts,",nomand");
923 if(flags & MS_NOEXEC)
924 strcat(mountent.mnt_opts,",noexec");
925 if(flags & MS_NOSUID)
926 strcat(mountent.mnt_opts,",nosuid");
927 if(flags & MS_NODEV)
928 strcat(mountent.mnt_opts,",nodev");
929 if(flags & MS_SYNCHRONOUS)
930 strcat(mountent.mnt_opts,",synch");
931 if(mount_user) {
932 if(getuid() != 0) {
933 strcat(mountent.mnt_opts,",user=");
934 strcat(mountent.mnt_opts,mount_user);
935 }
936 free(mount_user);
937 }
938 }
939 mountent.mnt_freq = 0;
940 mountent.mnt_passno = 0;
941 rc = addmntent(pmntfile,&mountent);
942 endmntent(pmntfile);
943 if(mountent.mnt_opts)
944 free(mountent.mnt_opts);
945 } else {
946 printf("could not update mount table\n");
947 }
948 }
949 if(mountpassword) {
950 memset(mountpassword,0,64);
951 free(mountpassword);
952 }
953
954 if(options) {
955 memset(options,0,optlen);
956 free(options);
957 }
958
959 if(orgoptions) {
960 memset(orgoptions,0,orgoptlen);
961 free(orgoptions);
962 }
963 if(resolved_path) {
964 free(resolved_path);
965 }
966
967 if(free_share_name) {
968 free(share_name);
969 }
970 return 0;
971 }
972