?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Allow IPv6 address entry in tools>ping - Loosens valid character check
[tomato/davidwu.git] / release / src / router / ntfs-3g / libntfs-3g / reparse.c
blobdc44bcd07718b1eccd7dfee78634d65b35e4a7d5
1 /**
2 * reparse.c - Processing of reparse points
3 *
4 * This module is part of ntfs-3g library
5 *
6 * Copyright (c) 2008-2012 Jean-Pierre Andre
7 *
8 * This program/include file is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as published
10 * by the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program/include file is distributed in the hope that it will be
14 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program (in the main directory of the NTFS-3G
20 * distribution in the file COPYING); if not, write to the Free Software
21 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #ifdef HAVE_STDLIB_H
29 #include <stdlib.h>
30 #endif
31 #ifdef HAVE_ERRNO_H
32 #include <errno.h>
33 #endif
34 #ifdef HAVE_STRING_H
35 #include <string.h>
36 #endif
37 #ifdef HAVE_SYS_STAT_H
38 #include <sys/stat.h>
39 #endif
40
41 #ifdef HAVE_SETXATTR
42 #include <sys/xattr.h>
43 #endif
44
45 #ifdef HAVE_SYS_SYSMACROS_H
46 #include <sys/sysmacros.h>
47 #endif
48
49 #include "compat.h"
50 #include "types.h"
51 #include "debug.h"
52 #include "layout.h"
53 #include "attrib.h"
54 #include "inode.h"
55 #include "dir.h"
56 #include "volume.h"
57 #include "mft.h"
58 #include "index.h"
59 #include "lcnalloc.h"
60 #include "logging.h"
61 #include "misc.h"
62 #include "reparse.h"
63
64 struct MOUNT_POINT_REPARSE_DATA { /* reparse data for junctions */
65 le16 subst_name_offset;
66 le16 subst_name_length;
67 le16 print_name_offset;
68 le16 print_name_length;
69 char path_buffer[0]; /* above data assume this is char array */
70 } ;
71
72 struct SYMLINK_REPARSE_DATA { /* reparse data for symlinks */
73 le16 subst_name_offset;
74 le16 subst_name_length;
75 le16 print_name_offset;
76 le16 print_name_length;
77 le32 flags; /* 1 for full target, otherwise 0 */
78 char path_buffer[0]; /* above data assume this is char array */
79 } ;
80
81 struct REPARSE_INDEX { /* index entry in $Extend/$Reparse */
82 INDEX_ENTRY_HEADER header;
83 REPARSE_INDEX_KEY key;
84 le32 filling;
85 } ;
86
87 static const ntfschar dir_junction_head[] = {
88 const_cpu_to_le16('\\'),
89 const_cpu_to_le16('?'),
90 const_cpu_to_le16('?'),
91 const_cpu_to_le16('\\')
92 } ;
93
94 static const ntfschar vol_junction_head[] = {
95 const_cpu_to_le16('\\'),
96 const_cpu_to_le16('?'),
97 const_cpu_to_le16('?'),
98 const_cpu_to_le16('\\'),
99 const_cpu_to_le16('V'),
100 const_cpu_to_le16('o'),
101 const_cpu_to_le16('l'),
102 const_cpu_to_le16('u'),
103 const_cpu_to_le16('m'),
104 const_cpu_to_le16('e'),
105 const_cpu_to_le16('{'),
106 } ;
107
108 static ntfschar reparse_index_name[] = { const_cpu_to_le16('$'),
109 const_cpu_to_le16('R') };
110
111 static const char mappingdir[] = ".NTFS-3G/";
112
113 /*
114 * Fix a file name with doubtful case in some directory index
115 * and return the name with the casing used in directory.
116 *
117 * Should only be used to translate paths stored with case insensitivity
118 * (such as directory junctions) when no case conflict is expected.
119 * If there some ambiguity, the name which collates first is returned.
120 *
121 * The name is converted to upper case and searched the usual way.
122 * The collation rules for file names are such that we should get the
123 * first candidate if any.
124 */
125
126 static u64 ntfs_fix_file_name(ntfs_inode *dir_ni, ntfschar *uname,
127 int uname_len)
128 {
129 ntfs_volume *vol = dir_ni->vol;
130 ntfs_index_context *icx;
131 u64 mref;
132 le64 lemref;
133 int lkup;
134 int olderrno;
135 int i;
136 u32 cpuchar;
137 INDEX_ENTRY *entry;
138 FILE_NAME_ATTR *found;
139 struct {
140 FILE_NAME_ATTR attr;
141 ntfschar file_name[NTFS_MAX_NAME_LEN + 1];
142 } find;
143
144 mref = (u64)-1; /* default return (not found) */
145 icx = ntfs_index_ctx_get(dir_ni, NTFS_INDEX_I30, 4);
146 if (icx) {
147 if (uname_len > NTFS_MAX_NAME_LEN)
148 uname_len = NTFS_MAX_NAME_LEN;
149 find.attr.file_name_length = uname_len;
150 for (i=0; i<uname_len; i++) {
151 cpuchar = le16_to_cpu(uname[i]);
152 /*
153 * We need upper or lower value, whichever is smaller,
154 * but we can only convert to upper case, so we
155 * will fail when searching for an upper case char
156 * whose lower case is smaller (such as umlauted Y)
157 */
158 if ((cpuchar < vol->upcase_len)
159 && (le16_to_cpu(vol->upcase[cpuchar]) < cpuchar))
160 find.attr.file_name[i] = vol->upcase[cpuchar];
161 else
162 find.attr.file_name[i] = uname[i];
163 }
164 olderrno = errno;
165 lkup = ntfs_index_lookup((char*)&find, uname_len, icx);
166 if (errno == ENOENT)
167 errno = olderrno;
168 /*
169 * We generally only get the first matching candidate,
170 * so we still have to check whether this is a real match
171 */
172 if (icx->entry && (icx->entry->ie_flags & INDEX_ENTRY_END))
173 /* get next entry if reaching end of block */
174 entry = ntfs_index_next(icx->entry, icx);
175 else
176 entry = icx->entry;
177 if (entry) {
178 found = &entry->key.file_name;
179 if (lkup
180 && ntfs_names_are_equal(find.attr.file_name,
181 find.attr.file_name_length,
182 found->file_name, found->file_name_length,
183 IGNORE_CASE,
184 vol->upcase, vol->upcase_len))
185 lkup = 0;
186 if (!lkup) {
187 /*
188 * name found :
189 * fix original name and return inode
190 */
191 lemref = entry->indexed_file;
192 mref = le64_to_cpu(lemref);
193 if (NVolCaseSensitive(vol) || !vol->locase) {
194 for (i=0; i<found->file_name_length; i++)
195 uname[i] = found->file_name[i];
196 } else {
197 for (i=0; i<found->file_name_length; i++)
198 uname[i] = vol->locase[found->file_name[i]];
199 }
200 }
201 }
202 ntfs_index_ctx_put(icx);
203 }
204 return (mref);
205 }
206
207 /*
208 * Search for a directory junction or a symbolic link
209 * along the target path, with target defined as a full absolute path
210 *
211 * Returns the path translated to a Linux path
212 * or NULL if the path is not valid
213 */
214
215 static char *search_absolute(ntfs_volume *vol, ntfschar *path,
216 int count, BOOL isdir)
217 {
218 ntfs_inode *ni;
219 u64 inum;
220 char *target;
221 int start;
222 int len;
223
224 target = (char*)NULL; /* default return */
225 ni = ntfs_inode_open(vol, (MFT_REF)FILE_root);
226 if (ni) {
227 start = 0;
228 /*
229 * Examine and translate the path, until we reach either
230 * - the end,
231 * - an unknown item
232 * - a non-directory
233 * - another reparse point,
234 * A reparse point is not dereferenced, it will be
235 * examined later when the translated path is dereferenced,
236 * however the final part of the path will not be adjusted
237 * to correct case.
238 */
239 do {
240 len = 0;
241 while (((start + len) < count)
242 && (path[start + len] != const_cpu_to_le16('\\')))
243 len++;
244 inum = ntfs_fix_file_name(ni, &path[start], len);
245 ntfs_inode_close(ni);
246 ni = (ntfs_inode*)NULL;
247 if (inum != (u64)-1) {
248 inum = MREF(inum);
249 ni = ntfs_inode_open(vol, inum);
250 start += len;
251 if (start < count)
252 path[start++] = const_cpu_to_le16('/');
253 }
254 } while (ni
255 && (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
256 && !(ni->flags & FILE_ATTR_REPARSE_POINT)
257 && (start < count));
258 if (ni
259 && ((ni->mrec->flags & MFT_RECORD_IS_DIRECTORY ? isdir : !isdir)
260 || (ni->flags & FILE_ATTR_REPARSE_POINT)))
261 if (ntfs_ucstombs(path, count, &target, 0) < 0) {
262 if (target) {
263 free(target);
264 target = (char*)NULL;
265 }
266 }
267 if (ni)
268 ntfs_inode_close(ni);
269 }
270 return (target);
271 }
272
273 /*
274 * Search for a symbolic link along the target path,
275 * with the target defined as a relative path
276 *
277 * Note : the path used to access the current inode, may be
278 * different from the one implied in the target definition,
279 * when an inode has names in several directories.
280 *
281 * Returns the path translated to a Linux path
282 * or NULL if the path is not valid
283 */
284
285 static char *search_relative(ntfs_inode *ni, ntfschar *path, int count)
286 {
287 char *target = (char*)NULL;
288 ntfs_inode *curni;
289 ntfs_inode *newni;
290 u64 inum;
291 int pos;
292 int lth;
293 BOOL ok;
294 BOOL morelinks;
295 int max = 32; /* safety */
296
297 pos = 0;
298 ok = TRUE;
299 morelinks = FALSE;
300 curni = ntfs_dir_parent_inode(ni);
301 /*
302 * Examine and translate the path, until we reach either
303 * - the end,
304 * - an unknown item
305 * - a non-directory
306 * - another reparse point,
307 * A reparse point is not dereferenced, it will be
308 * examined later when the translated path is dereferenced,
309 * however the final part of the path will not be adjusted
310 * to correct case.
311 */
312 while (curni && ok && !morelinks && (pos < (count - 1)) && --max) {
313 if ((count >= (pos + 2))
314 && (path[pos] == const_cpu_to_le16('.'))
315 && (path[pos+1] == const_cpu_to_le16('\\'))) {
316 path[1] = const_cpu_to_le16('/');
317 pos += 2;
318 } else {
319 if ((count >= (pos + 3))
320 && (path[pos] == const_cpu_to_le16('.'))
321 &&(path[pos+1] == const_cpu_to_le16('.'))
322 && (path[pos+2] == const_cpu_to_le16('\\'))) {
323 path[2] = const_cpu_to_le16('/');
324 pos += 3;
325 newni = ntfs_dir_parent_inode(curni);
326 if (curni != ni)
327 ntfs_inode_close(curni);
328 curni = newni;
329 if (!curni)
330 ok = FALSE;
331 } else {
332 lth = 0;
333 while (((pos + lth) < count)
334 && (path[pos + lth] != const_cpu_to_le16('\\')))
335 lth++;
336 if (lth > 0)
337 inum = ntfs_fix_file_name(curni,&path[pos],lth);
338 else
339 inum = (u64)-1;
340 if (!lth
341 || ((curni != ni)
342 && ntfs_inode_close(curni))
343 || (inum == (u64)-1))
344 ok = FALSE;
345 else {
346 curni = ntfs_inode_open(ni->vol, MREF(inum));
347 if (!curni)
348 ok = FALSE;
349 else {
350 if (curni->flags & FILE_ATTR_REPARSE_POINT)
351 morelinks = TRUE;
352 if (ok && ((pos + lth) < count)) {
353 path[pos + lth] = const_cpu_to_le16('/');
354 pos += lth + 1;
355 if (morelinks
356 && ntfs_inode_close(curni))
357 ok = FALSE;
358 } else {
359 pos += lth;
360 if (!morelinks
361 && (ni->mrec->flags ^ curni->mrec->flags)
362 & MFT_RECORD_IS_DIRECTORY)
363 ok = FALSE;
364 if (ntfs_inode_close(curni))
365 ok = FALSE;
366 }
367 }
368 }
369 }
370 }
371 }
372
373 if (ok && (ntfs_ucstombs(path, count, &target, 0) < 0)) {
374 free(target); // needed ?
375 target = (char*)NULL;
376 }
377 return (target);
378 }
379
380 /*
381 * Check whether a drive letter has been defined in .NTFS-3G
382 *
383 * Returns 1 if found,
384 * 0 if not found,
385 * -1 if there was an error (described by errno)
386 */
387
388 static int ntfs_drive_letter(ntfs_volume *vol, ntfschar letter)
389 {
390 char defines[NTFS_MAX_NAME_LEN + 5];
391 char *drive;
392 int ret;
393 int sz;
394 int olderrno;
395 ntfs_inode *ni;
396
397 ret = -1;
398 drive = (char*)NULL;
399 sz = ntfs_ucstombs(&letter, 1, &drive, 0);
400 if (sz > 0) {
401 strcpy(defines,mappingdir);
402 if ((*drive >= 'a') && (*drive <= 'z'))
403 *drive += 'A' - 'a';
404 strcat(defines,drive);
405 strcat(defines,":");
406 olderrno = errno;
407 ni = ntfs_pathname_to_inode(vol, NULL, defines);
408 if (ni && !ntfs_inode_close(ni))
409 ret = 1;
410 else
411 if (errno == ENOENT) {
412 ret = 0;
413 /* avoid errno pollution */
414 errno = olderrno;
415 }
416 }
417 if (drive)
418 free(drive);
419 return (ret);
420 }
421
422 /*
423 * Do some sanity checks on reparse data
424 *
425 * The only general check is about the size (at least the tag must
426 * be present)
427 * If the reparse data looks like a junction point or symbolic
428 * link, more checks can be done.
429 *
430 */
431
432 static BOOL valid_reparse_data(ntfs_inode *ni,
433 const REPARSE_POINT *reparse_attr, size_t size)
434 {
435 BOOL ok;
436 unsigned int offs;
437 unsigned int lth;
438 const struct MOUNT_POINT_REPARSE_DATA *mount_point_data;
439 const struct SYMLINK_REPARSE_DATA *symlink_data;
440
441 ok = ni && reparse_attr
442 && (size >= sizeof(REPARSE_POINT))
443 && (((size_t)le16_to_cpu(reparse_attr->reparse_data_length)
444 + sizeof(REPARSE_POINT)) == size);
445 if (ok) {
446 switch (reparse_attr->reparse_tag) {
447 case IO_REPARSE_TAG_MOUNT_POINT :
448 mount_point_data = (const struct MOUNT_POINT_REPARSE_DATA*)
449 reparse_attr->reparse_data;
450 offs = le16_to_cpu(mount_point_data->subst_name_offset);
451 lth = le16_to_cpu(mount_point_data->subst_name_length);
452 /* consistency checks */
453 if (!(ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
454 || ((size_t)((sizeof(REPARSE_POINT)
455 + sizeof(struct MOUNT_POINT_REPARSE_DATA)
456 + offs + lth)) > size))
457 ok = FALSE;
458 break;
459 case IO_REPARSE_TAG_SYMLINK :
460 symlink_data = (const struct SYMLINK_REPARSE_DATA*)
461 reparse_attr->reparse_data;
462 offs = le16_to_cpu(symlink_data->subst_name_offset);
463 lth = le16_to_cpu(symlink_data->subst_name_length);
464 if ((size_t)((sizeof(REPARSE_POINT)
465 + sizeof(struct SYMLINK_REPARSE_DATA)
466 + offs + lth)) > size)
467 ok = FALSE;
468 break;
469 default :
470 break;
471 }
472 }
473 if (!ok)
474 errno = EINVAL;
475 return (ok);
476 }
477
478 /*
479 * Check and translate the target of a junction point or
480 * a full absolute symbolic link.
481 *
482 * A full target definition begins with "\??\" or "\\?\"
483 *
484 * The fully defined target is redefined as a relative link,
485 * - either to the target if found on the same device.
486 * - or into the /.NTFS-3G directory for the user to define
487 * In the first situation, the target is translated to case-sensitive path.
488 *
489 * returns the target converted to a relative symlink
490 * or NULL if there were some problem, as described by errno
491 */
492
493 static char *ntfs_get_fulllink(ntfs_volume *vol, ntfschar *junction,
494 int count, const char *mnt_point, BOOL isdir)
495 {
496 char *target;
497 char *fulltarget;
498 int sz;
499 char *q;
500 enum { DIR_JUNCTION, VOL_JUNCTION, NO_JUNCTION } kind;
501
502 target = (char*)NULL;
503 fulltarget = (char*)NULL;
504 /*
505 * For a valid directory junction we want \??\x:\
506 * where \ is an individual char and x a non-null char
507 */
508 if ((count >= 7)
509 && !memcmp(junction,dir_junction_head,8)
510 && junction[4]
511 && (junction[5] == const_cpu_to_le16(':'))
512 && (junction[6] == const_cpu_to_le16('\\')))
513 kind = DIR_JUNCTION;
514 else
515 /*
516 * For a valid volume junction we want \\?\Volume{
517 * and a final \ (where \ is an individual char)
518 */
519 if ((count >= 12)
520 && !memcmp(junction,vol_junction_head,22)
521 && (junction[count-1] == const_cpu_to_le16('\\')))
522 kind = VOL_JUNCTION;
523 else
524 kind = NO_JUNCTION;
525 /*
526 * Directory junction with an explicit path and
527 * no specific definition for the drive letter :
528 * try to interpret as a target on the same volume
529 */
530 if ((kind == DIR_JUNCTION)
531 && (count >= 7)
532 && junction[7]
533 && !ntfs_drive_letter(vol, junction[4])) {
534 target = search_absolute(vol,&junction[7],count - 7, isdir);
535 if (target) {
536 fulltarget = (char*)ntfs_malloc(strlen(mnt_point)
537 + strlen(target) + 2);
538 if (fulltarget) {
539 strcpy(fulltarget,mnt_point);
540 strcat(fulltarget,"/");
541 strcat(fulltarget,target);
542 }
543 free(target);
544 }
545 }
546 /*
547 * Volume junctions or directory junctions with
548 * target not found on current volume :
549 * link to /.NTFS-3G/target which the user can
550 * define as a symbolic link to the real target
551 */
552 if (((kind == DIR_JUNCTION) && !fulltarget)
553 || (kind == VOL_JUNCTION)) {
554 sz = ntfs_ucstombs(&junction[4],
555 (kind == VOL_JUNCTION ? count - 5 : count - 4),
556 &target, 0);
557 if ((sz > 0) && target) {
558 /* reverse slashes */
559 for (q=target; *q; q++)
560 if (*q == '\\')
561 *q = '/';
562 /* force uppercase drive letter */
563 if ((target[1] == ':')
564 && (target[0] >= 'a')
565 && (target[0] <= 'z'))
566 target[0] += 'A' - 'a';
567 fulltarget = (char*)ntfs_malloc(strlen(mnt_point)
568 + sizeof(mappingdir) + strlen(target) + 1);
569 if (fulltarget) {
570 strcpy(fulltarget,mnt_point);
571 strcat(fulltarget,"/");
572 strcat(fulltarget,mappingdir);
573 strcat(fulltarget,target);
574 }
575 }
576 if (target)
577 free(target);
578 }
579 return (fulltarget);
580 }
581
582 /*
583 * Check and translate the target of an absolute symbolic link.
584 *
585 * An absolute target definition begins with "\" or "x:\"
586 *
587 * The absolute target is redefined as a relative link,
588 * - either to the target if found on the same device.
589 * - or into the /.NTFS-3G directory for the user to define
590 * In the first situation, the target is translated to case-sensitive path.
591 *
592 * returns the target converted to a relative symlink
593 * or NULL if there were some problem, as described by errno
594 */
595
596 static char *ntfs_get_abslink(ntfs_volume *vol, ntfschar *junction,
597 int count, const char *mnt_point, BOOL isdir)
598 {
599 char *target;
600 char *fulltarget;
601 int sz;
602 char *q;
603 enum { FULL_PATH, ABS_PATH, REJECTED_PATH } kind;
604
605 target = (char*)NULL;
606 fulltarget = (char*)NULL;
607 /*
608 * For a full valid path we want x:\
609 * where \ is an individual char and x a non-null char
610 */
611 if ((count >= 3)
612 && junction[0]
613 && (junction[1] == const_cpu_to_le16(':'))
614 && (junction[2] == const_cpu_to_le16('\\')))
615 kind = FULL_PATH;
616 else
617 /*
618 * For an absolute path we want an initial \
619 */
620 if ((count >= 0)
621 && (junction[0] == const_cpu_to_le16('\\')))
622 kind = ABS_PATH;
623 else
624 kind = REJECTED_PATH;
625 /*
626 * Full path, with a drive letter and
627 * no specific definition for the drive letter :
628 * try to interpret as a target on the same volume.
629 * Do the same for an abs path with no drive letter.
630 */
631 if (((kind == FULL_PATH)
632 && (count >= 3)
633 && junction[3]
634 && !ntfs_drive_letter(vol, junction[0]))
635 || (kind == ABS_PATH)) {
636 if (kind == ABS_PATH)
637 target = search_absolute(vol, &junction[1],
638 count - 1, isdir);
639 else
640 target = search_absolute(vol, &junction[3],
641 count - 3, isdir);
642 if (target) {
643 fulltarget = (char*)ntfs_malloc(strlen(mnt_point)
644 + strlen(target) + 2);
645 if (fulltarget) {
646 strcpy(fulltarget,mnt_point);
647 strcat(fulltarget,"/");
648 strcat(fulltarget,target);
649 }
650 free(target);
651 }
652 }
653 /*
654 * full path with target not found on current volume :
655 * link to /.NTFS-3G/target which the user can
656 * define as a symbolic link to the real target
657 */
658 if ((kind == FULL_PATH) && !fulltarget) {
659 sz = ntfs_ucstombs(&junction[0],
660 count,&target, 0);
661 if ((sz > 0) && target) {
662 /* reverse slashes */
663 for (q=target; *q; q++)
664 if (*q == '\\')
665 *q = '/';
666 /* force uppercase drive letter */
667 if ((target[1] == ':')
668 && (target[0] >= 'a')
669 && (target[0] <= 'z'))
670 target[0] += 'A' - 'a';
671 fulltarget = (char*)ntfs_malloc(strlen(mnt_point)
672 + sizeof(mappingdir) + strlen(target) + 1);
673 if (fulltarget) {
674 strcpy(fulltarget,mnt_point);
675 strcat(fulltarget,"/");
676 strcat(fulltarget,mappingdir);
677 strcat(fulltarget,target);
678 }
679 }
680 if (target)
681 free(target);
682 }
683 return (fulltarget);
684 }
685
686 /*
687 * Check and translate the target of a relative symbolic link.
688 *
689 * A relative target definition does not begin with "\"
690 *
691 * The original definition of relative target is kept, it is just
692 * translated to a case-sensitive path.
693 *
694 * returns the target converted to a relative symlink
695 * or NULL if there were some problem, as described by errno
696 */
697
698 static char *ntfs_get_rellink(ntfs_inode *ni, ntfschar *junction, int count)
699 {
700 char *target;
701
702 target = search_relative(ni,junction,count);
703 return (target);
704 }
705
706 /*
707 * Get the target for a junction point or symbolic link
708 * Should only be called for files or directories with reparse data
709 *
710 * returns the target converted to a relative path, or NULL
711 * if some error occurred, as described by errno
712 * errno is EOPNOTSUPP if the reparse point is not a valid
713 * symbolic link or directory junction
714 */
715
716 char *ntfs_make_symlink(ntfs_inode *ni, const char *mnt_point,
717 int *pattr_size)
718 {
719 s64 attr_size = 0;
720 char *target;
721 unsigned int offs;
722 unsigned int lth;
723 ntfs_volume *vol;
724 REPARSE_POINT *reparse_attr;
725 struct MOUNT_POINT_REPARSE_DATA *mount_point_data;
726 struct SYMLINK_REPARSE_DATA *symlink_data;
727 enum { FULL_TARGET, ABS_TARGET, REL_TARGET } kind;
728 ntfschar *p;
729 BOOL bad;
730 BOOL isdir;
731
732 target = (char*)NULL;
733 bad = TRUE;
734 isdir = (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
735 != const_cpu_to_le16(0);
736 vol = ni->vol;
737 reparse_attr = (REPARSE_POINT*)ntfs_attr_readall(ni,
738 AT_REPARSE_POINT,(ntfschar*)NULL, 0, &attr_size);
739 if (reparse_attr && attr_size
740 && valid_reparse_data(ni, reparse_attr, attr_size)) {
741 switch (reparse_attr->reparse_tag) {
742 case IO_REPARSE_TAG_MOUNT_POINT :
743 mount_point_data = (struct MOUNT_POINT_REPARSE_DATA*)
744 reparse_attr->reparse_data;
745 offs = le16_to_cpu(mount_point_data->subst_name_offset);
746 lth = le16_to_cpu(mount_point_data->subst_name_length);
747 /* reparse data consistency has been checked */
748 target = ntfs_get_fulllink(vol,
749 (ntfschar*)&mount_point_data->path_buffer[offs],
750 lth/2, mnt_point, isdir);
751 if (target)
752 bad = FALSE;
753 break;
754 case IO_REPARSE_TAG_SYMLINK :
755 symlink_data = (struct SYMLINK_REPARSE_DATA*)
756 reparse_attr->reparse_data;
757 offs = le16_to_cpu(symlink_data->subst_name_offset);
758 lth = le16_to_cpu(symlink_data->subst_name_length);
759 p = (ntfschar*)&symlink_data->path_buffer[offs];
760 /*
761 * Predetermine the kind of target,
762 * the called function has to make a full check
763 */
764 if (*p++ == const_cpu_to_le16('\\')) {
765 if ((*p == const_cpu_to_le16('?'))
766 || (*p == const_cpu_to_le16('\\')))
767 kind = FULL_TARGET;
768 else
769 kind = ABS_TARGET;
770 } else
771 if (*p == const_cpu_to_le16(':'))
772 kind = ABS_TARGET;
773 else
774 kind = REL_TARGET;
775 p--;
776 /* reparse data consistency has been checked */
777 switch (kind) {
778 case FULL_TARGET :
779 if (!(symlink_data->flags
780 & const_cpu_to_le32(1))) {
781 target = ntfs_get_fulllink(vol,
782 p, lth/2,
783 mnt_point, isdir);
784 if (target)
785 bad = FALSE;
786 }
787 break;
788 case ABS_TARGET :
789 if (symlink_data->flags
790 & const_cpu_to_le32(1)) {
791 target = ntfs_get_abslink(vol,
792 p, lth/2,
793 mnt_point, isdir);
794 if (target)
795 bad = FALSE;
796 }
797 break;
798 case REL_TARGET :
799 if (symlink_data->flags
800 & const_cpu_to_le32(1)) {
801 target = ntfs_get_rellink(ni,
802 p, lth/2);
803 if (target)
804 bad = FALSE;
805 }
806 break;
807 }
808 break;
809 }
810 free(reparse_attr);
811 }
812 *pattr_size = attr_size;
813 if (bad)
814 errno = EOPNOTSUPP;
815 return (target);
816 }
817
818 /*
819 * Check whether a reparse point looks like a junction point
820 * or a symbolic link.
821 * Should only be called for files or directories with reparse data
822 *
823 * The validity of the target is not checked.
824 */
825
826 BOOL ntfs_possible_symlink(ntfs_inode *ni)
827 {
828 s64 attr_size = 0;
829 REPARSE_POINT *reparse_attr;
830 BOOL possible;
831
832 possible = FALSE;
833 reparse_attr = (REPARSE_POINT*)ntfs_attr_readall(ni,
834 AT_REPARSE_POINT,(ntfschar*)NULL, 0, &attr_size);
835 if (reparse_attr && attr_size) {
836 switch (reparse_attr->reparse_tag) {
837 case IO_REPARSE_TAG_MOUNT_POINT :
838 case IO_REPARSE_TAG_SYMLINK :
839 possible = TRUE;
840 default : ;
841 }
842 free(reparse_attr);
843 }
844 return (possible);
845 }
846
847 #ifdef HAVE_SETXATTR /* extended attributes interface required */
848
849 /*
850 * Set the index for new reparse data
851 *
852 * Returns 0 if success
853 * -1 if failure, explained by errno
854 */
855
856 static int set_reparse_index(ntfs_inode *ni, ntfs_index_context *xr,
857 le32 reparse_tag)
858 {
859 struct REPARSE_INDEX indx;
860 u64 file_id_cpu;
861 le64 file_id;
862 le16 seqn;
863
864 seqn = ni->mrec->sequence_number;
865 file_id_cpu = MK_MREF(ni->mft_no,le16_to_cpu(seqn));
866 file_id = cpu_to_le64(file_id_cpu);
867 indx.header.data_offset = const_cpu_to_le16(
868 sizeof(INDEX_ENTRY_HEADER)
869 + sizeof(REPARSE_INDEX_KEY));
870 indx.header.data_length = const_cpu_to_le16(0);
871 indx.header.reservedV = const_cpu_to_le32(0);
872 indx.header.length = const_cpu_to_le16(
873 sizeof(struct REPARSE_INDEX));
874 indx.header.key_length = const_cpu_to_le16(
875 sizeof(REPARSE_INDEX_KEY));
876 indx.header.flags = const_cpu_to_le16(0);
877 indx.header.reserved = const_cpu_to_le16(0);
878 indx.key.reparse_tag = reparse_tag;
879 /* danger on processors which require proper alignment ! */
880 memcpy(&indx.key.file_id, &file_id, 8);
881 indx.filling = const_cpu_to_le32(0);
882 ntfs_index_ctx_reinit(xr);
883 return (ntfs_ie_add(xr,(INDEX_ENTRY*)&indx));
884 }
885
886 #endif /* HAVE_SETXATTR */
887
888 /*
889 * Remove a reparse data index entry if attribute present
890 *
891 * Returns the size of existing reparse data
892 * (the existing reparse tag is returned)
893 * -1 if failure, explained by errno
894 */
895
896 static int remove_reparse_index(ntfs_attr *na, ntfs_index_context *xr,
897 le32 *preparse_tag)
898 {
899 REPARSE_INDEX_KEY key;
900 u64 file_id_cpu;
901 le64 file_id;
902 s64 size;
903 le16 seqn;
904 int ret;
905
906 ret = na->data_size;
907 if (ret) {
908 /* read the existing reparse_tag */
909 size = ntfs_attr_pread(na, 0, 4, preparse_tag);
910 if (size == 4) {
911 seqn = na->ni->mrec->sequence_number;
912 file_id_cpu = MK_MREF(na->ni->mft_no,le16_to_cpu(seqn));
913 file_id = cpu_to_le64(file_id_cpu);
914 key.reparse_tag = *preparse_tag;
915 /* danger on processors which require proper alignment ! */
916 memcpy(&key.file_id, &file_id, 8);
917 if (!ntfs_index_lookup(&key, sizeof(REPARSE_INDEX_KEY), xr)
918 && ntfs_index_rm(xr))
919 ret = -1;
920 } else {
921 ret = -1;
922 errno = ENODATA;
923 }
924 }
925 return (ret);
926 }
927
928 /*
929 * Open the $Extend/$Reparse file and its index
930 *
931 * Return the index context if opened
932 * or NULL if an error occurred (errno tells why)
933 *
934 * The index has to be freed and inode closed when not needed any more.
935 */
936
937 static ntfs_index_context *open_reparse_index(ntfs_volume *vol)
938 {
939 u64 inum;
940 ntfs_inode *ni;
941 ntfs_inode *dir_ni;
942 ntfs_index_context *xr;
943
944 /* do not use path_name_to inode - could reopen root */
945 dir_ni = ntfs_inode_open(vol, FILE_Extend);
946 ni = (ntfs_inode*)NULL;
947 if (dir_ni) {
948 inum = ntfs_inode_lookup_by_mbsname(dir_ni,"$Reparse");
949 if (inum != (u64)-1)
950 ni = ntfs_inode_open(vol, inum);
951 ntfs_inode_close(dir_ni);
952 }
953 if (ni) {
954 xr = ntfs_index_ctx_get(ni, reparse_index_name, 2);
955 if (!xr) {
956 ntfs_inode_close(ni);
957 }
958 } else
959 xr = (ntfs_index_context*)NULL;
960 return (xr);
961 }
962
963 #ifdef HAVE_SETXATTR /* extended attributes interface required */
964
965 /*
966 * Update the reparse data and index
967 *
968 * The reparse data attribute should have been created, and
969 * an existing index is expected if there is an existing value.
970 *
971 * Returns 0 if success
972 * -1 if failure, explained by errno
973 * If could not remove the existing index, nothing is done,
974 * If could not write the new data, no index entry is inserted
975 * If failed to insert the index, data is removed
976 */
977
978 static int update_reparse_data(ntfs_inode *ni, ntfs_index_context *xr,
979 const char *value, size_t size)
980 {
981 int res;
982 int written;
983 int oldsize;
984 ntfs_attr *na;
985 le32 reparse_tag;
986
987 res = 0;
988 na = ntfs_attr_open(ni, AT_REPARSE_POINT, AT_UNNAMED, 0);
989 if (na) {
990 /* remove the existing reparse data */
991 oldsize = remove_reparse_index(na,xr,&reparse_tag);
992 if (oldsize < 0)
993 res = -1;
994 else {
995 /* resize attribute */
996 res = ntfs_attr_truncate(na, (s64)size);
997 /* overwrite value if any */
998 if (!res && value) {
999 written = (int)ntfs_attr_pwrite(na,
1000 (s64)0, (s64)size, value);
1001 if (written != (s64)size) {
1002 ntfs_log_error("Failed to update "
1003 "reparse data\n");
1004 errno = EIO;
1005 res = -1;
1006 }
1007 }
1008 if (!res
1009 && set_reparse_index(ni,xr,
1010 ((const REPARSE_POINT*)value)->reparse_tag)
1011 && (oldsize > 0)) {
1012 /*
1013 * If cannot index, try to remove the reparse
1014 * data and log the error. There will be an
1015 * inconsistency if removal fails.
1016 */
1017 ntfs_attr_rm(na);
1018 ntfs_log_error("Failed to index reparse data."
1019 " Possible corruption.\n");
1020 }
1021 }
1022 ntfs_attr_close(na);
1023 NInoSetDirty(ni);
1024 } else
1025 res = -1;
1026 return (res);
1027 }
1028
1029 #endif /* HAVE_SETXATTR */
1030
1031 /*
1032 * Delete a reparse index entry
1033 *
1034 * Returns 0 if success
1035 * -1 if failure, explained by errno
1036 */
1037
1038 int ntfs_delete_reparse_index(ntfs_inode *ni)
1039 {
1040 ntfs_index_context *xr;
1041 ntfs_inode *xrni;
1042 ntfs_attr *na;
1043 le32 reparse_tag;
1044 int res;
1045
1046 res = 0;
1047 na = ntfs_attr_open(ni, AT_REPARSE_POINT, AT_UNNAMED, 0);
1048 if (na) {
1049 /*
1050 * read the existing reparse data (the tag is enough)
1051 * and un-index it
1052 */
1053 xr = open_reparse_index(ni->vol);
1054 if (xr) {
1055 if (remove_reparse_index(na,xr,&reparse_tag) < 0)
1056 res = -1;
1057 xrni = xr->ni;
1058 ntfs_index_entry_mark_dirty(xr);
1059 NInoSetDirty(xrni);
1060 ntfs_index_ctx_put(xr);
1061 ntfs_inode_close(xrni);
1062 }
1063 ntfs_attr_close(na);
1064 }
1065 return (res);
1066 }
1067
1068 #ifdef HAVE_SETXATTR /* extended attributes interface required */
1069
1070 /*
1071 * Get the ntfs reparse data into an extended attribute
1072 *
1073 * Returns the reparse data size
1074 * and the buffer is updated if it is long enough
1075 */
1076
1077 int ntfs_get_ntfs_reparse_data(ntfs_inode *ni, char *value, size_t size)
1078 {
1079 REPARSE_POINT *reparse_attr;
1080 s64 attr_size;
1081
1082 attr_size = 0; /* default to no data and no error */
1083 if (ni) {
1084 if (ni->flags & FILE_ATTR_REPARSE_POINT) {
1085 reparse_attr = (REPARSE_POINT*)ntfs_attr_readall(ni,
1086 AT_REPARSE_POINT,(ntfschar*)NULL, 0, &attr_size);
1087 if (reparse_attr) {
1088 if (attr_size <= (s64)size) {
1089 if (value)
1090 memcpy(value,reparse_attr,
1091 attr_size);
1092 else
1093 errno = EINVAL;
1094 }
1095 free(reparse_attr);
1096 }
1097 } else
1098 errno = ENODATA;
1099 }
1100 return (attr_size ? (int)attr_size : -errno);
1101 }
1102
1103 /*
1104 * Set the reparse data from an extended attribute
1105 *
1106 * Warning : the new data is not checked
1107 *
1108 * Returns 0, or -1 if there is a problem
1109 */
1110
1111 int ntfs_set_ntfs_reparse_data(ntfs_inode *ni,
1112 const char *value, size_t size, int flags)
1113 {
1114 int res;
1115 u8 dummy;
1116 ntfs_inode *xrni;
1117 ntfs_index_context *xr;
1118
1119 res = 0;
1120 if (ni && valid_reparse_data(ni, (const REPARSE_POINT*)value, size)) {
1121 xr = open_reparse_index(ni->vol);
1122 if (xr) {
1123 if (!ntfs_attr_exist(ni,AT_REPARSE_POINT,
1124 AT_UNNAMED,0)) {
1125 if (!(flags & XATTR_REPLACE)) {
1126 /*
1127 * no reparse data attribute : add one,
1128 * apparently, this does not feed the new value in
1129 * Note : NTFS version must be >= 3
1130 */
1131 if (ni->vol->major_ver >= 3) {
1132 res = ntfs_attr_add(ni,
1133 AT_REPARSE_POINT,
1134 AT_UNNAMED,0,&dummy,
1135 (s64)0);
1136 if (!res) {
1137 ni->flags |=
1138 FILE_ATTR_REPARSE_POINT;
1139 NInoFileNameSetDirty(ni);
1140 }
1141 NInoSetDirty(ni);
1142 } else {
1143 errno = EOPNOTSUPP;
1144 res = -1;
1145 }
1146 } else {
1147 errno = ENODATA;
1148 res = -1;
1149 }
1150 } else {
1151 if (flags & XATTR_CREATE) {
1152 errno = EEXIST;
1153 res = -1;
1154 }
1155 }
1156 if (!res) {
1157 /* update value and index */
1158 res = update_reparse_data(ni,xr,value,size);
1159 }
1160 xrni = xr->ni;
1161 ntfs_index_entry_mark_dirty(xr);
1162 NInoSetDirty(xrni);
1163 ntfs_index_ctx_put(xr);
1164 ntfs_inode_close(xrni);
1165 } else {
1166 res = -1;
1167 }
1168 } else {
1169 errno = EINVAL;
1170 res = -1;
1171 }
1172 return (res ? -1 : 0);
1173 }
1174
1175 /*
1176 * Remove the reparse data
1177 *
1178 * Returns 0, or -1 if there is a problem
1179 */
1180
1181 int ntfs_remove_ntfs_reparse_data(ntfs_inode *ni)
1182 {
1183 int res;
1184 int olderrno;
1185 ntfs_attr *na;
1186 ntfs_inode *xrni;
1187 ntfs_index_context *xr;
1188 le32 reparse_tag;
1189
1190 res = 0;
1191 if (ni) {
1192 /*
1193 * open and delete the reparse data
1194 */
1195 na = ntfs_attr_open(ni, AT_REPARSE_POINT,
1196 AT_UNNAMED,0);
1197 if (na) {
1198 /* first remove index (reparse data needed) */
1199 xr = open_reparse_index(ni->vol);
1200 if (xr) {
1201 if (remove_reparse_index(na,xr,
1202 &reparse_tag) < 0) {
1203 res = -1;
1204 } else {
1205 /* now remove attribute */
1206 res = ntfs_attr_rm(na);
1207 if (!res) {
1208 ni->flags &=
1209 ~FILE_ATTR_REPARSE_POINT;
1210 NInoFileNameSetDirty(ni);
1211 } else {
1212 /*
1213 * If we could not remove the
1214 * attribute, try to restore the
1215 * index and log the error. There
1216 * will be an inconsistency if
1217 * the reindexing fails.
1218 */
1219 set_reparse_index(ni, xr,
1220 reparse_tag);
1221 ntfs_log_error(
1222 "Failed to remove reparse data."
1223 " Possible corruption.\n");
1224 }
1225 }
1226 xrni = xr->ni;
1227 ntfs_index_entry_mark_dirty(xr);
1228 NInoSetDirty(xrni);
1229 ntfs_index_ctx_put(xr);
1230 ntfs_inode_close(xrni);
1231 }
1232 olderrno = errno;
1233 ntfs_attr_close(na);
1234 /* avoid errno pollution */
1235 if (errno == ENOENT)
1236 errno = olderrno;
1237 } else {
1238 errno = ENODATA;
1239 res = -1;
1240 }
1241 NInoSetDirty(ni);
1242 } else {
1243 errno = EINVAL;
1244 res = -1;
1245 }
1246 return (res ? -1 : 0);
1247 }
1248
1249 #endif /* HAVE_SETXATTR */