path: root/libntfs-3g/volume.c (plain)
blob: ecacb1813643320d97b0a60a3a055d26215dfe59

1	/**
2	* volume.c - NTFS volume handling code. Originated from the Linux-NTFS project.
3	*
4	* Copyright (c) 2000-2006 Anton Altaparmakov
5	* Copyright (c) 2002-2009 Szabolcs Szakacsits
6	* Copyright (c) 2004-2005 Richard Russon
7	* Copyright (c) 2010 Jean-Pierre Andre
8	*
9	* This program/include file is free software; you can redistribute it and/or
10	* modify it under the terms of the GNU General Public License as published
11	* by the Free Software Foundation; either version 2 of the License, or
12	* (at your option) any later version.
13	*
14	* This program/include file is distributed in the hope that it will be
15	* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
16	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with this program (in the main directory of the NTFS-3G
21	* distribution in the file COPYING); if not, write to the Free Software
22	* Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23	*/
24
25	#ifdef HAVE_CONFIG_H
26	#include "config.h"
27	#endif
28
29	#ifdef HAVE_STDLIB_H
30	#include <stdlib.h>
31	#endif
32	#ifdef HAVE_STDIO_H
33	#include <stdio.h>
34	#endif
35	#ifdef HAVE_STRING_H
36	#include <string.h>
37	#endif
38	#ifdef HAVE_FCNTL_H
39	#include <fcntl.h>
40	#endif
41	#ifdef HAVE_UNISTD_H
42	#include <unistd.h>
43	#endif
44	#ifdef HAVE_ERRNO_H
45	#include <errno.h>
46	#endif
47	#ifdef HAVE_SYS_STAT_H
48	#include <sys/stat.h>
49	#endif
50	#ifdef HAVE_LIMITS_H
51	#include <limits.h>
52	#endif
53	#ifdef HAVE_LOCALE_H
54	#include <locale.h>
55	#endif
56
57	#include "compat.h"
58	#include "volume.h"
59	#include "attrib.h"
60	#include "mft.h"
61	#include "bootsect.h"
62	#include "device.h"
63	#include "debug.h"
64	#include "inode.h"
65	#include "runlist.h"
66	#include "logfile.h"
67	#include "dir.h"
68	#include "logging.h"
69	#include "cache.h"
70	#include "misc.h"
71
72	const char *ntfs_home =
73	"Ntfs-3g news, support and information: http://ntfs-3g.org\n";
74
75	static const char *invalid_ntfs_msg =
76	"The device '%s' doesn't seem to have a valid NTFS.\n"
77	"Maybe the wrong device is used? Or the whole disk instead of a\n"
78	"partition (e.g. /dev/sda, not /dev/sda1)? Or the other way around?\n";
79
80	static const char *corrupt_volume_msg =
81	"NTFS is either inconsistent, or there is a hardware fault, or it's a\n"
82	"SoftRAID/FakeRAID hardware. In the first case run chkdsk /f on Windows\n"
83	"then reboot into Windows twice. The usage of the /f parameter is very\n"
84	"important! If the device is a SoftRAID/FakeRAID then first activate\n"
85	"it and mount a different device under the /dev/mapper/ directory, (e.g.\n"
86	"/dev/mapper/nvidia_eahaabcc1). Please see the 'dmraid' documentation\n"
87	"for more details.\n";
88
89	static const char *hibernated_volume_msg =
90	"The NTFS partition is hibernated. Please resume and shutdown Windows\n"
91	"properly, or mount the volume read-only with the 'ro' mount option, or\n"
92	"mount the volume read-write with the 'remove_hiberfile' mount option.\n"
93	"For example type on the command line:\n"
94	"\n"
95	" mount -t ntfs-3g -o remove_hiberfile %s %s\n"
96	"\n";
97
98	static const char *unclean_journal_msg =
99	"Write access is denied because the disk wasn't safely powered\n"
100	"off and the 'norecover' mount option was specified.\n";
101
102	static const char *opened_volume_msg =
103	"Mount is denied because the NTFS volume is already exclusively opened.\n"
104	"The volume may be already mounted, or another software may use it which\n"
105	"could be identified for example by the help of the 'fuser' command.\n";
106
107	static const char *fakeraid_msg =
108	"Either the device is missing or it's powered down, or you have\n"
109	"SoftRAID hardware and must use an activated, different device under\n"
110	"/dev/mapper/, (e.g. /dev/mapper/nvidia_eahaabcc1) to mount NTFS.\n"
111	"Please see the 'dmraid' documentation for help.\n";
112
113	static const char *access_denied_msg =
114	"Please check '%s' and the ntfs-3g binary permissions,\n"
115	"and the mounting user ID. More explanation is provided at\n"
116	"http://ntfs-3g.org/support.html#unprivileged\n";
117
118	/**
119	* ntfs_volume_alloc - Create an NTFS volume object and initialise it
120	*
121	* Description...
122	*
123	* Returns:
124	*/
125	ntfs_volume *ntfs_volume_alloc(void)
126	{
127	return ntfs_calloc(sizeof(ntfs_volume));
128	}
129
130	static void ntfs_attr_free(ntfs_attr **na)
131	{
132	if (na && *na) {
133	ntfs_attr_close(*na);
134	*na = NULL;
135	}
136	}
137
138	static int ntfs_inode_free(ntfs_inode **ni)
139	{
140	int ret = -1;
141
142	if (ni && *ni) {
143	ret = ntfs_inode_close(*ni);
144	*ni = NULL;
145	}
146
147	return ret;
148	}
149
150	static void ntfs_error_set(int *err)
151	{
152	if (!*err)
153	*err = errno;
154	}
155
156	/**
157	* __ntfs_volume_release - Destroy an NTFS volume object
158	* @v:
159	*
160	* Description...
161	*
162	* Returns:
163	*/
164	static int __ntfs_volume_release(ntfs_volume *v)
165	{
166	int err = 0;
167
168	if (ntfs_inode_free(&v->vol_ni))
169	ntfs_error_set(&err);
170	/*
171	* FIXME: Inodes must be synced before closing
172	* attributes, otherwise unmount could fail.
173	*/
174	if (v->lcnbmp_ni && NInoDirty(v->lcnbmp_ni))
175	ntfs_inode_sync(v->lcnbmp_ni);
176	ntfs_attr_free(&v->lcnbmp_na);
177	if (ntfs_inode_free(&v->lcnbmp_ni))
178	ntfs_error_set(&err);
179
180	if (v->mft_ni && NInoDirty(v->mft_ni))
181	ntfs_inode_sync(v->mft_ni);
182	ntfs_attr_free(&v->mftbmp_na);
183	ntfs_attr_free(&v->mft_na);
184	if (ntfs_inode_free(&v->mft_ni))
185	ntfs_error_set(&err);
186
187	if (v->mftmirr_ni && NInoDirty(v->mftmirr_ni))
188	ntfs_inode_sync(v->mftmirr_ni);
189	ntfs_attr_free(&v->mftmirr_na);
190	if (ntfs_inode_free(&v->mftmirr_ni))
191	ntfs_error_set(&err);
192
193	if (v->dev) {
194	struct ntfs_device *dev = v->dev;
195
196	if (dev->d_ops->sync(dev))
197	ntfs_error_set(&err);
198	if (dev->d_ops->close(dev))
199	ntfs_error_set(&err);
200	}
201
202	ntfs_free_lru_caches(v);
203	free(v->vol_name);
204	free(v->upcase);
205	free(v->attrdef);
206	free(v);
207
208	errno = err;
209	return errno ? -1 : 0;
210	}
211
212	static void ntfs_attr_setup_flag(ntfs_inode *ni)
213	{
214	STANDARD_INFORMATION *si;
215
216	si = ntfs_attr_readall(ni, AT_STANDARD_INFORMATION, AT_UNNAMED, 0, NULL);
217	if (si) {
218	ni->flags = si->file_attributes;
219	free(si);
220	}
221	}
222
223	/**
224	* ntfs_mft_load - load the $MFT and setup the ntfs volume with it
225	* @vol: ntfs volume whose $MFT to load
226	*
227	* Load $MFT from @vol and setup @vol with it. After calling this function the
228	* volume @vol is ready for use by all read access functions provided by the
229	* ntfs library.
230	*
231	* Return 0 on success and -1 on error with errno set to the error code.
232	*/
233	static int ntfs_mft_load(ntfs_volume *vol)
234	{
235	VCN next_vcn, last_vcn, highest_vcn;
236	s64 l;
237	MFT_RECORD *mb = NULL;
238	ntfs_attr_search_ctx *ctx = NULL;
239	ATTR_RECORD *a;
240	int eo;
241
242	/* Manually setup an ntfs_inode. */
243	vol->mft_ni = ntfs_inode_allocate(vol);
244	mb = ntfs_malloc(vol->mft_record_size);
245	if (!vol->mft_ni || !mb) {
246	ntfs_log_perror("Error allocating memory for $MFT");
247	goto error_exit;
248	}
249	vol->mft_ni->mft_no = 0;
250	vol->mft_ni->mrec = mb;
251	/* Can't use any of the higher level functions yet! */
252	l = ntfs_mst_pread(vol->dev, vol->mft_lcn << vol->cluster_size_bits, 1,
253	vol->mft_record_size, mb);
254	if (l != 1) {
255	if (l != -1)
256	errno = EIO;
257	ntfs_log_perror("Error reading $MFT");
258	goto error_exit;
259	}
260
261	if (ntfs_mft_record_check(vol, 0, mb))
262	goto error_exit;
263
264	ctx = ntfs_attr_get_search_ctx(vol->mft_ni, NULL);
265	if (!ctx)
266	goto error_exit;
267
268	/* Find the $ATTRIBUTE_LIST attribute in $MFT if present. */
269	if (ntfs_attr_lookup(AT_ATTRIBUTE_LIST, AT_UNNAMED, 0, 0, 0, NULL, 0,
270	ctx)) {
271	if (errno != ENOENT) {
272	ntfs_log_error("$MFT has corrupt attribute list.\n");
273	goto io_error_exit;
274	}
275	goto mft_has_no_attr_list;
276	}
277	NInoSetAttrList(vol->mft_ni);
278	l = ntfs_get_attribute_value_length(ctx->attr);
279	if (l <= 0 || l > 0x40000) {
280	ntfs_log_error("$MFT/$ATTR_LIST invalid length (%lld).\n",
281	(long long)l);
282	goto io_error_exit;
283	}
284	vol->mft_ni->attr_list_size = l;
285	vol->mft_ni->attr_list = ntfs_malloc(l);
286	if (!vol->mft_ni->attr_list)
287	goto error_exit;
288
289	l = ntfs_get_attribute_value(vol, ctx->attr, vol->mft_ni->attr_list);
290	if (!l) {
291	ntfs_log_error("Failed to get value of $MFT/$ATTR_LIST.\n");
292	goto io_error_exit;
293	}
294	if (l != vol->mft_ni->attr_list_size) {
295	ntfs_log_error("Partial read of $MFT/$ATTR_LIST (%lld != "
296	"%u).\n", (long long)l,
297	vol->mft_ni->attr_list_size);
298	goto io_error_exit;
299	}
300
301	mft_has_no_attr_list:
302
303	ntfs_attr_setup_flag(vol->mft_ni);
304
305	/* We now have a fully setup ntfs inode for $MFT in vol->mft_ni. */
306
307	/* Get an ntfs attribute for $MFT/$DATA and set it up, too. */
308	vol->mft_na = ntfs_attr_open(vol->mft_ni, AT_DATA, AT_UNNAMED, 0);
309	if (!vol->mft_na) {
310	ntfs_log_perror("Failed to open ntfs attribute");
311	goto error_exit;
312	}
313	/* Read all extents from the $DATA attribute in $MFT. */
314	ntfs_attr_reinit_search_ctx(ctx);
315	last_vcn = vol->mft_na->allocated_size >> vol->cluster_size_bits;
316	highest_vcn = next_vcn = 0;
317	a = NULL;
318	while (!ntfs_attr_lookup(AT_DATA, AT_UNNAMED, 0, 0, next_vcn, NULL, 0,
319	ctx)) {
320	runlist_element *nrl;
321
322	a = ctx->attr;
323	/* $MFT must be non-resident. */
324	if (!a->non_resident) {
325	ntfs_log_error("$MFT must be non-resident.\n");
326	goto io_error_exit;
327	}
328	/* $MFT must be uncompressed and unencrypted. */
329	if (a->flags & ATTR_COMPRESSION_MASK ||
330	a->flags & ATTR_IS_ENCRYPTED) {
331	ntfs_log_error("$MFT must be uncompressed and "
332	"unencrypted.\n");
333	goto io_error_exit;
334	}
335	/*
336	* Decompress the mapping pairs array of this extent and merge
337	* the result into the existing runlist. No need for locking
338	* as we have exclusive access to the inode at this time and we
339	* are a mount in progress task, too.
340	*/
341	nrl = ntfs_mapping_pairs_decompress(vol, a, vol->mft_na->rl);
342	if (!nrl) {
343	ntfs_log_perror("ntfs_mapping_pairs_decompress() failed");
344	goto error_exit;
345	}
346	vol->mft_na->rl = nrl;
347
348	/* Get the lowest vcn for the next extent. */
349	highest_vcn = sle64_to_cpu(a->highest_vcn);
350	next_vcn = highest_vcn + 1;
351
352	/* Only one extent or error, which we catch below. */
353	if (next_vcn <= 0)
354	break;
355
356	/* Avoid endless loops due to corruption. */
357	if (next_vcn < sle64_to_cpu(a->lowest_vcn)) {
358	ntfs_log_error("$MFT has corrupt attribute list.\n");
359	goto io_error_exit;
360	}
361	}
362	if (!a) {
363	ntfs_log_error("$MFT/$DATA attribute not found.\n");
364	goto io_error_exit;
365	}
366	if (highest_vcn && highest_vcn != last_vcn - 1) {
367	ntfs_log_error("Failed to load runlist for $MFT/$DATA.\n");
368	ntfs_log_error("highest_vcn = 0x%llx, last_vcn - 1 = 0x%llx\n",
369	(long long)highest_vcn, (long long)last_vcn - 1);
370	goto io_error_exit;
371	}
372	/* Done with the $Mft mft record. */
373	ntfs_attr_put_search_ctx(ctx);
374	ctx = NULL;
375	/*
376	* The volume is now setup so we can use all read access functions.
377	*/
378	vol->mftbmp_na = ntfs_attr_open(vol->mft_ni, AT_BITMAP, AT_UNNAMED, 0);
379	if (!vol->mftbmp_na) {
380	ntfs_log_perror("Failed to open $MFT/$BITMAP");
381	goto error_exit;
382	}
383	return 0;
384	io_error_exit:
385	errno = EIO;
386	error_exit:
387	eo = errno;
388	if (ctx)
389	ntfs_attr_put_search_ctx(ctx);
390	if (vol->mft_na) {
391	ntfs_attr_close(vol->mft_na);
392	vol->mft_na = NULL;
393	}
394	if (vol->mft_ni) {
395	ntfs_inode_close(vol->mft_ni);
396	vol->mft_ni = NULL;
397	}
398	errno = eo;
399	return -1;
400	}
401
402	/**
403	* ntfs_mftmirr_load - load the $MFTMirr and setup the ntfs volume with it
404	* @vol: ntfs volume whose $MFTMirr to load
405	*
406	* Load $MFTMirr from @vol and setup @vol with it. After calling this function
407	* the volume @vol is ready for use by all write access functions provided by
408	* the ntfs library (assuming ntfs_mft_load() has been called successfully
409	* beforehand).
410	*
411	* Return 0 on success and -1 on error with errno set to the error code.
412	*/
413	static int ntfs_mftmirr_load(ntfs_volume *vol)
414	{
415	int err;
416
417	vol->mftmirr_ni = ntfs_inode_open(vol, FILE_MFTMirr);
418	if (!vol->mftmirr_ni) {
419	ntfs_log_perror("Failed to open inode $MFTMirr");
420	return -1;
421	}
422
423	vol->mftmirr_na = ntfs_attr_open(vol->mftmirr_ni, AT_DATA, AT_UNNAMED, 0);
424	if (!vol->mftmirr_na) {
425	ntfs_log_perror("Failed to open $MFTMirr/$DATA");
426	goto error_exit;
427	}
428
429	if (ntfs_attr_map_runlist(vol->mftmirr_na, 0) < 0) {
430	ntfs_log_perror("Failed to map runlist of $MFTMirr/$DATA");
431	goto error_exit;
432	}
433
434	return 0;
435
436	error_exit:
437	err = errno;
438	if (vol->mftmirr_na) {
439	ntfs_attr_close(vol->mftmirr_na);
440	vol->mftmirr_na = NULL;
441	}
442	ntfs_inode_close(vol->mftmirr_ni);
443	vol->mftmirr_ni = NULL;
444	errno = err;
445	return -1;
446	}
447
448	/**
449	* ntfs_volume_startup - allocate and setup an ntfs volume
450	* @dev: device to open
451	* @flags: optional mount flags
452	*
453	* Load, verify, and parse bootsector; load and setup $MFT and $MFTMirr. After
454	* calling this function, the volume is setup sufficiently to call all read
455	* and write access functions provided by the library.
456	*
457	* Return the allocated volume structure on success and NULL on error with
458	* errno set to the error code.
459	*/
460	ntfs_volume *ntfs_volume_startup(struct ntfs_device *dev, unsigned long flags)
461	{
462	LCN mft_zone_size, mft_lcn;
463	s64 br;
464	ntfs_volume *vol;
465	NTFS_BOOT_SECTOR *bs;
466	int eo;
467
468	if (!dev || !dev->d_ops || !dev->d_name) {
469	errno = EINVAL;
470	ntfs_log_perror("%s: dev = %p", __FUNCTION__, dev);
471	return NULL;
472	}
473
474	bs = ntfs_malloc(sizeof(NTFS_BOOT_SECTOR));
475	if (!bs)
476	return NULL;
477
478	/* Allocate the volume structure. */
479	vol = ntfs_volume_alloc();
480	if (!vol)
481	goto error_exit;
482
483	/* Create the default upcase table. */
484	vol->upcase_len = 65536;
485	vol->upcase = ntfs_malloc(vol->upcase_len * sizeof(ntfschar));
486	if (!vol->upcase)
487	goto error_exit;
488
489	ntfs_upcase_table_build(vol->upcase,
490	vol->upcase_len * sizeof(ntfschar));
491
492	if (flags & MS_RDONLY)
493	NVolSetReadOnly(vol);
494
495	/* ...->open needs bracketing to compile with glibc 2.7 */
496	if ((dev->d_ops->open)(dev, NVolReadOnly(vol) ? O_RDONLY: O_RDWR)) {
497	ntfs_log_perror("Error opening '%s'", dev->d_name);
498	goto error_exit;
499	}
500	/* Attach the device to the volume. */
501	vol->dev = dev;
502
503	/* Now read the bootsector. */
504	br = ntfs_pread(dev, 0, sizeof(NTFS_BOOT_SECTOR), bs);
505	if (br != sizeof(NTFS_BOOT_SECTOR)) {
506	if (br != -1)
507	errno = EINVAL;
508	if (!br)
509	ntfs_log_error("Failed to read bootsector (size=0)\n");
510	else
511	ntfs_log_perror("Error reading bootsector");
512	goto error_exit;
513	}
514	if (!ntfs_boot_sector_is_ntfs(bs)) {
515	errno = EINVAL;
516	goto error_exit;
517	}
518	if (ntfs_boot_sector_parse(vol, bs) < 0)
519	goto error_exit;
520
521	free(bs);
522	bs = NULL;
523	/* Now set the device block size to the sector size. */
524	if (ntfs_device_block_size_set(vol->dev, vol->sector_size))
525	ntfs_log_debug("Failed to set the device block size to the "
526	"sector size. This may affect performance "
527	"but should be harmless otherwise. Error: "
528	"%s\n", strerror(errno));
529
530	/* We now initialize the cluster allocator. */
531	vol->full_zones = 0;
532	mft_zone_size = vol->nr_clusters >> 3; /* 12.5% */
533
534	/* Setup the mft zone. */
535	vol->mft_zone_start = vol->mft_zone_pos = vol->mft_lcn;
536	ntfs_log_debug("mft_zone_pos = 0x%llx\n", (long long)vol->mft_zone_pos);
537
538	/*
539	* Calculate the mft_lcn for an unmodified NTFS volume (see mkntfs
540	* source) and if the actual mft_lcn is in the expected place or even
541	* further to the front of the volume, extend the mft_zone to cover the
542	* beginning of the volume as well. This is in order to protect the
543	* area reserved for the mft bitmap as well within the mft_zone itself.
544	* On non-standard volumes we don't protect it as the overhead would be
545	* higher than the speed increase we would get by doing it.
546	*/
547	mft_lcn = (8192 + 2 * vol->cluster_size - 1) / vol->cluster_size;
548	if (mft_lcn * vol->cluster_size < 16 * 1024)
549	mft_lcn = (16 * 1024 + vol->cluster_size - 1) /
550	vol->cluster_size;
551	if (vol->mft_zone_start <= mft_lcn)
552	vol->mft_zone_start = 0;
553	ntfs_log_debug("mft_zone_start = 0x%llx\n", (long long)vol->mft_zone_start);
554
555	/*
556	* Need to cap the mft zone on non-standard volumes so that it does
557	* not point outside the boundaries of the volume. We do this by
558	* halving the zone size until we are inside the volume.
559	*/
560	vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
561	while (vol->mft_zone_end >= vol->nr_clusters) {
562	mft_zone_size >>= 1;
563	vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
564	}
565	ntfs_log_debug("mft_zone_end = 0x%llx\n", (long long)vol->mft_zone_end);
566
567	/*
568	* Set the current position within each data zone to the start of the
569	* respective zone.
570	*/
571	vol->data1_zone_pos = vol->mft_zone_end;
572	ntfs_log_debug("data1_zone_pos = %lld\n", (long long)vol->data1_zone_pos);
573	vol->data2_zone_pos = 0;
574	ntfs_log_debug("data2_zone_pos = %lld\n", (long long)vol->data2_zone_pos);
575
576	/* Set the mft data allocation position to mft record 24. */
577	vol->mft_data_pos = 24;
578
579	/*
580	* The cluster allocator is now fully operational.
581	*/
582
583	/* Need to setup $MFT so we can use the library read functions. */
584	if (ntfs_mft_load(vol) < 0) {
585	ntfs_log_perror("Failed to load $MFT");
586	goto error_exit;
587	}
588
589	/* Need to setup $MFTMirr so we can use the write functions, too. */
590	if (ntfs_mftmirr_load(vol) < 0) {
591	ntfs_log_perror("Failed to load $MFTMirr");
592	goto error_exit;
593	}
594	return vol;
595	error_exit:
596	eo = errno;
597	free(bs);
598	if (vol)
599	__ntfs_volume_release(vol);
600	errno = eo;
601	return NULL;
602	}
603
604	/**
605	* ntfs_volume_check_logfile - check logfile on target volume
606	* @vol: volume on which to check logfile
607	*
608	* Return 0 on success and -1 on error with errno set error code.
609	*/
610	static int ntfs_volume_check_logfile(ntfs_volume *vol)
611	{
612	ntfs_inode *ni;
613	ntfs_attr *na = NULL;
614	RESTART_PAGE_HEADER *rp = NULL;
615	int err = 0;
616
617	ni = ntfs_inode_open(vol, FILE_LogFile);
618	if (!ni) {
619	ntfs_log_perror("Failed to open inode FILE_LogFile");
620	errno = EIO;
621	return -1;
622	}
623
624	na = ntfs_attr_open(ni, AT_DATA, AT_UNNAMED, 0);
625	if (!na) {
626	ntfs_log_perror("Failed to open $FILE_LogFile/$DATA");
627	err = EIO;
628	goto out;
629	}
630
631	if (!ntfs_check_logfile(na, &rp) || !ntfs_is_logfile_clean(na, rp))
632	err = EOPNOTSUPP;
633	free(rp);
634	ntfs_attr_close(na);
635	out:
636	if (ntfs_inode_close(ni))
637	ntfs_error_set(&err);
638	if (err) {
639	errno = err;
640	return -1;
641	}
642	return 0;
643	}
644
645	/**
646	* ntfs_hiberfile_open - Find and open '/hiberfil.sys'
647	* @vol: An ntfs volume obtained from ntfs_mount
648	*
649	* Return: inode Success, hiberfil.sys is valid
650	* NULL hiberfil.sys doesn't exist or some other error occurred
651	*/
652	static ntfs_inode *ntfs_hiberfile_open(ntfs_volume *vol)
653	{
654	u64 inode;
655	ntfs_inode *ni_root;
656	ntfs_inode *ni_hibr = NULL;
657	ntfschar *unicode = NULL;
658	int unicode_len;
659	const char *hiberfile = "hiberfil.sys";
660
661	if (!vol) {
662	errno = EINVAL;
663	return NULL;
664	}
665
666	ni_root = ntfs_inode_open(vol, FILE_root);
667	if (!ni_root) {
668	ntfs_log_debug("Couldn't open the root directory.\n");
669	return NULL;
670	}
671
672	unicode_len = ntfs_mbstoucs(hiberfile, &unicode);
673	if (unicode_len < 0) {
674	ntfs_log_perror("Couldn't convert 'hiberfil.sys' to Unicode");
675	goto out;
676	}
677
678	inode = ntfs_inode_lookup_by_name(ni_root, unicode, unicode_len);
679	if (inode == (u64)-1) {
680	ntfs_log_debug("Couldn't find file '%s'.\n", hiberfile);
681	goto out;
682	}
683
684	inode = MREF(inode);
685	ni_hibr = ntfs_inode_open(vol, inode);
686	if (!ni_hibr) {
687	ntfs_log_debug("Couldn't open inode %lld.\n", (long long)inode);
688	goto out;
689	}
690	out:
691	if (ntfs_inode_close(ni_root)) {
692	ntfs_inode_close(ni_hibr);
693	ni_hibr = NULL;
694	}
695	free(unicode);
696	return ni_hibr;
697	}
698
699
700	#define NTFS_HIBERFILE_HEADER_SIZE 4096
701
702	/**
703	* ntfs_volume_check_hiberfile - check hiberfil.sys whether Windows is
704	* hibernated on the target volume
705	* @vol: volume on which to check hiberfil.sys
706	*
707	* Return: 0 if Windows isn't hibernated for sure
708	* -1 otherwise and errno is set to the appropriate value
709	*/
710	int ntfs_volume_check_hiberfile(ntfs_volume *vol, int verbose)
711	{
712	ntfs_inode *ni;
713	ntfs_attr *na = NULL;
714	int bytes_read, err;
715	char *buf = NULL;
716
717	ni = ntfs_hiberfile_open(vol);
718	if (!ni) {
719	if (errno == ENOENT)
720	return 0;
721	return -1;
722	}
723
724	buf = ntfs_malloc(NTFS_HIBERFILE_HEADER_SIZE);
725	if (!buf)
726	goto out;
727
728	na = ntfs_attr_open(ni, AT_DATA, AT_UNNAMED, 0);
729	if (!na) {
730	ntfs_log_perror("Failed to open hiberfil.sys data attribute");
731	goto out;
732	}
733
734	bytes_read = ntfs_attr_pread(na, 0, NTFS_HIBERFILE_HEADER_SIZE, buf);
735	if (bytes_read == -1) {
736	ntfs_log_perror("Failed to read hiberfil.sys");
737	goto out;
738	}
739	if (bytes_read < NTFS_HIBERFILE_HEADER_SIZE) {
740	if (verbose)
741	ntfs_log_error("Hibernated non-system partition, "
742	"refused to mount.\n");
743	errno = EPERM;
744	goto out;
745	}
746	if (memcmp(buf, "hibr", 4) == 0) {
747	if (verbose)
748	ntfs_log_error("Windows is hibernated, refused to mount.\n");
749	errno = EPERM;
750	goto out;
751	}
752	/* All right, all header bytes are zero */
753	errno = 0;
754	out:
755	if (na)
756	ntfs_attr_close(na);
757	free(buf);
758	err = errno;
759	if (ntfs_inode_close(ni))
760	ntfs_error_set(&err);
761	errno = err;
762	return errno ? -1 : 0;
763	}
764
765	/*
766	* Make sure a LOGGED_UTILITY_STREAM attribute named "$TXF_DATA"
767	* on the root directory is resident.
768	* When it is non-resident, the partition cannot be mounted on Vista
769	* (see http://support.microsoft.com/kb/974729)
770	*
771	* We take care to avoid this situation, however this can be a
772	* consequence of having used an older version (including older
773	* Windows version), so we had better fix it.
774	*
775	* Returns 0 if unneeded or successful
776	* -1 if there was an error, explained by errno
777	*/
778
779	static int fix_txf_data(ntfs_volume *vol)
780	{
781	void *txf_data;
782	s64 txf_data_size;
783	ntfs_inode *ni;
784	ntfs_attr *na;
785	int res;
786
787	res = 0;
788	ntfs_log_debug("Loading root directory\n");
789	ni = ntfs_inode_open(vol, FILE_root);
790	if (!ni) {
791	ntfs_log_perror("Failed to open root directory");
792	res = -1;
793	} else {
794	/* Get the $TXF_DATA attribute */
795	na = ntfs_attr_open(ni, AT_LOGGED_UTILITY_STREAM, TXF_DATA, 9);
796	if (na) {
797	if (NAttrNonResident(na)) {
798	/*
799	* Fix the attribute by truncating, then
800	* rewriting it.
801	*/
802	ntfs_log_debug("Making $TXF_DATA resident\n");
803	txf_data = ntfs_attr_readall(ni,
804	AT_LOGGED_UTILITY_STREAM,
805	TXF_DATA, 9, &txf_data_size);
806	if (txf_data) {
807	if (ntfs_attr_truncate(na, 0)
808	|| (ntfs_attr_pwrite(na, 0,
809	txf_data_size, txf_data)
810	!= txf_data_size))
811	res = -1;
812	free(txf_data);
813	}
814	if (res)
815	ntfs_log_error("Failed to make $TXF_DATA resident\n");
816	else
817	ntfs_log_error("$TXF_DATA made resident\n");
818	}
819	ntfs_attr_close(na);
820	}
821	if (ntfs_inode_close(ni)) {
822	ntfs_log_perror("Failed to close root");
823	res = -1;
824	}
825	}
826	return (res);
827	}
828
829	/**
830	* ntfs_device_mount - open ntfs volume
831	* @dev: device to open
832	* @flags: optional mount flags
833	*
834	* This function mounts an ntfs volume. @dev should describe the device which
835	* to mount as the ntfs volume.
836	*
837	* @flags is an optional second parameter. The same flags are used as for
838	* the mount system call (man 2 mount). Currently only the following flag
839	* is implemented:
840	* MS_RDONLY - mount volume read-only
841	*
842	* The function opens the device @dev and verifies that it contains a valid
843	* bootsector. Then, it allocates an ntfs_volume structure and initializes
844	* some of the values inside the structure from the information stored in the
845	* bootsector. It proceeds to load the necessary system files and completes
846	* setting up the structure.
847	*
848	* Return the allocated volume structure on success and NULL on error with
849	* errno set to the error code.
850	*/
851	ntfs_volume *ntfs_device_mount(struct ntfs_device *dev, unsigned long flags)
852	{
853	s64 l;
854	ntfs_volume *vol;
855	u8 *m = NULL, *m2 = NULL;
856	ntfs_attr_search_ctx *ctx = NULL;
857	ntfs_inode *ni;
858	ntfs_attr *na;
859	ATTR_RECORD *a;
860	VOLUME_INFORMATION *vinf;
861	ntfschar *vname;
862	int i, j, eo;
863	u32 u;
864
865	vol = ntfs_volume_startup(dev, flags);
866	if (!vol)
867	return NULL;
868
869	/* Load data from $MFT and $MFTMirr and compare the contents. */
870	m = ntfs_malloc(vol->mftmirr_size << vol->mft_record_size_bits);
871	m2 = ntfs_malloc(vol->mftmirr_size << vol->mft_record_size_bits);
872	if (!m || !m2)
873	goto error_exit;
874
875	l = ntfs_attr_mst_pread(vol->mft_na, 0, vol->mftmirr_size,
876	vol->mft_record_size, m);
877	if (l != vol->mftmirr_size) {
878	if (l == -1)
879	ntfs_log_perror("Failed to read $MFT");
880	else {
881	ntfs_log_error("Failed to read $MFT, unexpected length "
882	"(%lld != %d).\n", (long long)l,
883	vol->mftmirr_size);
884	errno = EIO;
885	}
886	goto error_exit;
887	}
888	l = ntfs_attr_mst_pread(vol->mftmirr_na, 0, vol->mftmirr_size,
889	vol->mft_record_size, m2);
890	if (l != vol->mftmirr_size) {
891	if (l == -1) {
892	ntfs_log_perror("Failed to read $MFTMirr");
893	goto error_exit;
894	}
895	vol->mftmirr_size = l;
896	}
897	ntfs_log_debug("Comparing $MFTMirr to $MFT...\n");
898	for (i = 0; i < vol->mftmirr_size; ++i) {
899	MFT_RECORD *mrec, *mrec2;
900	const char *ESTR[12] = { "$MFT", "$MFTMirr", "$LogFile",
901	"$Volume", "$AttrDef", "root directory", "$Bitmap",
902	"$Boot", "$BadClus", "$Secure", "$UpCase", "$Extend" };
903	const char *s;
904
905	if (i < 12)
906	s = ESTR[i];
907	else if (i < 16)
908	s = "system file";
909	else
910	s = "mft record";
911
912	mrec = (MFT_RECORD*)(m + i * vol->mft_record_size);
913	if (mrec->flags & MFT_RECORD_IN_USE) {
914	if (ntfs_is_baad_recordp(mrec)) {
915	ntfs_log_error("$MFT error: Incomplete multi "
916	"sector transfer detected in "
917	"'%s'.\n", s);
918	goto io_error_exit;
919	}
920	if (!ntfs_is_mft_recordp(mrec)) {
921	ntfs_log_error("$MFT error: Invalid mft "
922	"record for '%s'.\n", s);
923	goto io_error_exit;
924	}
925	}
926	mrec2 = (MFT_RECORD*)(m2 + i * vol->mft_record_size);
927	if (mrec2->flags & MFT_RECORD_IN_USE) {
928	if (ntfs_is_baad_recordp(mrec2)) {
929	ntfs_log_error("$MFTMirr error: Incomplete "
930	"multi sector transfer "
931	"detected in '%s'.\n", s);
932	goto io_error_exit;
933	}
934	if (!ntfs_is_mft_recordp(mrec2)) {
935	ntfs_log_error("$MFTMirr error: Invalid mft "
936	"record for '%s'.\n", s);
937	goto io_error_exit;
938	}
939	}
940	if (memcmp(mrec, mrec2, ntfs_mft_record_get_data_size(mrec))) {
941	ntfs_log_error("$MFTMirr does not match $MFT (record "
942	"%d).\n", i);
943	goto io_error_exit;
944	}
945	}
946
947	free(m2);
948	free(m);
949	m = m2 = NULL;
950
951	/* Now load the bitmap from $Bitmap. */
952	ntfs_log_debug("Loading $Bitmap...\n");
953	vol->lcnbmp_ni = ntfs_inode_open(vol, FILE_Bitmap);
954	if (!vol->lcnbmp_ni) {
955	ntfs_log_perror("Failed to open inode FILE_Bitmap");
956	goto error_exit;
957	}
958
959	vol->lcnbmp_na = ntfs_attr_open(vol->lcnbmp_ni, AT_DATA, AT_UNNAMED, 0);
960	if (!vol->lcnbmp_na) {
961	ntfs_log_perror("Failed to open ntfs attribute");
962	goto error_exit;
963	}
964
965	if (vol->lcnbmp_na->data_size > vol->lcnbmp_na->allocated_size) {
966	ntfs_log_error("Corrupt cluster map size (%lld > %lld)\n",
967	(long long)vol->lcnbmp_na->data_size,
968	(long long)vol->lcnbmp_na->allocated_size);
969	goto io_error_exit;
970	}
971
972	/* Now load the upcase table from $UpCase. */
973	ntfs_log_debug("Loading $UpCase...\n");
974	ni = ntfs_inode_open(vol, FILE_UpCase);
975	if (!ni) {
976	ntfs_log_perror("Failed to open inode FILE_UpCase");
977	goto error_exit;
978	}
979	/* Get an ntfs attribute for $UpCase/$DATA. */
980	na = ntfs_attr_open(ni, AT_DATA, AT_UNNAMED, 0);
981	if (!na) {
982	ntfs_log_perror("Failed to open ntfs attribute");
983	goto error_exit;
984	}
985	/*
986	* Note: Normally, the upcase table has a length equal to 65536
987	* 2-byte Unicode characters but allow for different cases, so no
988	* checks done. Just check we don't overflow 32-bits worth of Unicode
989	* characters.
990	*/
991	if (na->data_size & ~0x1ffffffffULL) {
992	ntfs_log_error("Error: Upcase table is too big (max 32-bit "
993	"allowed).\n");
994	errno = EINVAL;
995	goto error_exit;
996	}
997	if (vol->upcase_len != na->data_size >> 1) {
998	vol->upcase_len = na->data_size >> 1;
999	/* Throw away default table. */
1000	free(vol->upcase);
1001	vol->upcase = ntfs_malloc(na->data_size);
1002	if (!vol->upcase)
1003	goto error_exit;
1004	}
1005	/* Read in the $DATA attribute value into the buffer. */
1006	l = ntfs_attr_pread(na, 0, na->data_size, vol->upcase);
1007	if (l != na->data_size) {
1008	ntfs_log_error("Failed to read $UpCase, unexpected length "
1009	"(%lld != %lld).\n", (long long)l,
1010	(long long)na->data_size);
1011	errno = EIO;
1012	goto error_exit;
1013	}
1014	/* Done with the $UpCase mft record. */
1015	ntfs_attr_close(na);
1016	if (ntfs_inode_close(ni)) {
1017	ntfs_log_perror("Failed to close $UpCase");
1018	goto error_exit;
1019	}
1020
1021	/*
1022	* Now load $Volume and set the version information and flags in the
1023	* vol structure accordingly.
1024	*/
1025	ntfs_log_debug("Loading $Volume...\n");
1026	vol->vol_ni = ntfs_inode_open(vol, FILE_Volume);
1027	if (!vol->vol_ni) {
1028	ntfs_log_perror("Failed to open inode FILE_Volume");
1029	goto error_exit;
1030	}
1031	/* Get a search context for the $Volume/$VOLUME_INFORMATION lookup. */
1032	ctx = ntfs_attr_get_search_ctx(vol->vol_ni, NULL);
1033	if (!ctx)
1034	goto error_exit;
1035
1036	/* Find the $VOLUME_INFORMATION attribute. */
1037	if (ntfs_attr_lookup(AT_VOLUME_INFORMATION, AT_UNNAMED, 0, 0, 0, NULL,
1038	0, ctx)) {
1039	ntfs_log_perror("$VOLUME_INFORMATION attribute not found in "
1040	"$Volume");
1041	goto error_exit;
1042	}
1043	a = ctx->attr;
1044	/* Has to be resident. */
1045	if (a->non_resident) {
1046	ntfs_log_error("Attribute $VOLUME_INFORMATION must be "
1047	"resident but it isn't.\n");
1048	errno = EIO;
1049	goto error_exit;
1050	}
1051	/* Get a pointer to the value of the attribute. */
1052	vinf = (VOLUME_INFORMATION*)(le16_to_cpu(a->value_offset) + (char*)a);
1053	/* Sanity checks. */
1054	if ((char*)vinf + le32_to_cpu(a->value_length) > (char*)ctx->mrec +
1055	le32_to_cpu(ctx->mrec->bytes_in_use) ||
1056	le16_to_cpu(a->value_offset) + le32_to_cpu(
1057	a->value_length) > le32_to_cpu(a->length)) {
1058	ntfs_log_error("$VOLUME_INFORMATION in $Volume is corrupt.\n");
1059	errno = EIO;
1060	goto error_exit;
1061	}
1062	/* Setup vol from the volume information attribute value. */
1063	vol->major_ver = vinf->major_ver;
1064	vol->minor_ver = vinf->minor_ver;
1065	/* Do not use le16_to_cpu() macro here as our VOLUME_FLAGS are
1066	defined using cpu_to_le16() macro and hence are consistent. */
1067	vol->flags = vinf->flags;
1068	/*
1069	* Reinitialize the search context for the $Volume/$VOLUME_NAME lookup.
1070	*/
1071	ntfs_attr_reinit_search_ctx(ctx);
1072	if (ntfs_attr_lookup(AT_VOLUME_NAME, AT_UNNAMED, 0, 0, 0, NULL, 0,
1073	ctx)) {
1074	if (errno != ENOENT) {
1075	ntfs_log_perror("Failed to lookup of $VOLUME_NAME in "
1076	"$Volume failed");
1077	goto error_exit;
1078	}
1079	/*
1080	* Attribute not present. This has been seen in the field.
1081	* Treat this the same way as if the attribute was present but
1082	* had zero length.
1083	*/
1084	vol->vol_name = ntfs_malloc(1);
1085	if (!vol->vol_name)
1086	goto error_exit;
1087	vol->vol_name[0] = '\0';
1088	} else {
1089	a = ctx->attr;
1090	/* Has to be resident. */
1091	if (a->non_resident) {
1092	ntfs_log_error("$VOLUME_NAME must be resident.\n");
1093	errno = EIO;
1094	goto error_exit;
1095	}
1096	/* Get a pointer to the value of the attribute. */
1097	vname = (ntfschar*)(le16_to_cpu(a->value_offset) + (char*)a);
1098	u = le32_to_cpu(a->value_length) / 2;
1099	/*
1100	* Convert Unicode volume name to current locale multibyte
1101	* format.
1102	*/
1103	vol->vol_name = NULL;
1104	if (ntfs_ucstombs(vname, u, &vol->vol_name, 0) == -1) {
1105	ntfs_log_perror("Volume name could not be converted "
1106	"to current locale");
1107	ntfs_log_debug("Forcing name into ASCII by replacing "
1108	"non-ASCII characters with underscores.\n");
1109	vol->vol_name = ntfs_malloc(u + 1);
1110	if (!vol->vol_name)
1111	goto error_exit;
1112
1113	for (j = 0; j < (s32)u; j++) {
1114	u16 uc = le16_to_cpu(vname[j]);
1115	if (uc > 0xff)
1116	uc = (u16)'_';
1117	vol->vol_name[j] = (char)uc;
1118	}
1119	vol->vol_name[u] = '\0';
1120	}
1121	}
1122	ntfs_attr_put_search_ctx(ctx);
1123	ctx = NULL;
1124	/* Now load the attribute definitions from $AttrDef. */
1125	ntfs_log_debug("Loading $AttrDef...\n");
1126	ni = ntfs_inode_open(vol, FILE_AttrDef);
1127	if (!ni) {
1128	ntfs_log_perror("Failed to open $AttrDef");
1129	goto error_exit;
1130	}
1131	/* Get an ntfs attribute for $AttrDef/$DATA. */
1132	na = ntfs_attr_open(ni, AT_DATA, AT_UNNAMED, 0);
1133	if (!na) {
1134	ntfs_log_perror("Failed to open ntfs attribute");
1135	goto error_exit;
1136	}
1137	/* Check we don't overflow 32-bits. */
1138	if (na->data_size > 0xffffffffLL) {
1139	ntfs_log_error("Attribute definition table is too big (max "
1140	"32-bit allowed).\n");
1141	errno = EINVAL;
1142	goto error_exit;
1143	}
1144	vol->attrdef_len = na->data_size;
1145	vol->attrdef = ntfs_malloc(na->data_size);
1146	if (!vol->attrdef)
1147	goto error_exit;
1148	/* Read in the $DATA attribute value into the buffer. */
1149	l = ntfs_attr_pread(na, 0, na->data_size, vol->attrdef);
1150	if (l != na->data_size) {
1151	ntfs_log_error("Failed to read $AttrDef, unexpected length "
1152	"(%lld != %lld).\n", (long long)l,
1153	(long long)na->data_size);
1154	errno = EIO;
1155	goto error_exit;
1156	}
1157	/* Done with the $AttrDef mft record. */
1158	ntfs_attr_close(na);
1159	if (ntfs_inode_close(ni)) {
1160	ntfs_log_perror("Failed to close $AttrDef");
1161	goto error_exit;
1162	}
1163	/*
1164	* Check for dirty logfile and hibernated Windows.
1165	* We care only about read-write mounts.
1166	*/
1167	if (!(flags & MS_RDONLY)) {
1168	if (!(flags & MS_IGNORE_HIBERFILE) &&
1169	ntfs_volume_check_hiberfile(vol, 1) < 0)
1170	goto error_exit;
1171	if (ntfs_volume_check_logfile(vol) < 0) {
1172	if (!(flags & MS_RECOVER))
1173	goto error_exit;
1174	ntfs_log_info("The file system wasn't safely "
1175	"closed on Windows. Fixing.\n");
1176	if (ntfs_logfile_reset(vol))
1177	goto error_exit;
1178	}
1179	}
1180	/* make $TXF_DATA resident if present on the root directory */
1181	if (!NVolReadOnly(vol) && fix_txf_data(vol))
1182	goto error_exit;
1183
1184	return vol;
1185	io_error_exit:
1186	errno = EIO;
1187	error_exit:
1188	eo = errno;
1189	if (ctx)
1190	ntfs_attr_put_search_ctx(ctx);
1191	free(m);
1192	free(m2);
1193	__ntfs_volume_release(vol);
1194	errno = eo;
1195	return NULL;
1196	}
1197
1198	/**
1199	* ntfs_mount - open ntfs volume
1200	* @name: name of device/file to open
1201	* @flags: optional mount flags
1202	*
1203	* This function mounts an ntfs volume. @name should contain the name of the
1204	* device/file to mount as the ntfs volume.
1205	*
1206	* @flags is an optional second parameter. The same flags are used as for
1207	* the mount system call (man 2 mount). Currently only the following flags
1208	* is implemented:
1209	* MS_RDONLY - mount volume read-only
1210	*
1211	* The function opens the device or file @name and verifies that it contains a
1212	* valid bootsector. Then, it allocates an ntfs_volume structure and initializes
1213	* some of the values inside the structure from the information stored in the
1214	* bootsector. It proceeds to load the necessary system files and completes
1215	* setting up the structure.
1216	*
1217	* Return the allocated volume structure on success and NULL on error with
1218	* errno set to the error code.
1219	*
1220	* Note, that a copy is made of @name, and hence it can be discarded as
1221	* soon as the function returns.
1222	*/
1223	ntfs_volume *ntfs_mount(const char *name __attribute__((unused)),
1224	unsigned long flags __attribute__((unused)))
1225	{
1226	#ifndef NO_NTFS_DEVICE_DEFAULT_IO_OPS
1227	struct ntfs_device *dev;
1228	ntfs_volume *vol;
1229
1230	/* Allocate an ntfs_device structure. */
1231	dev = ntfs_device_alloc(name, 0, &ntfs_device_default_io_ops, NULL);
1232	if (!dev)
1233	return NULL;
1234	/* Call ntfs_device_mount() to do the actual mount. */
1235	vol = ntfs_device_mount(dev, flags);
1236	if (!vol) {
1237	int eo = errno;
1238	ntfs_device_free(dev);
1239	errno = eo;
1240	} else
1241	ntfs_create_lru_caches(vol);
1242	return vol;
1243	#else
1244	/*
1245	* ntfs_mount() makes no sense if NO_NTFS_DEVICE_DEFAULT_IO_OPS is
1246	* defined as there are no device operations available in libntfs in
1247	* this case.
1248	*/
1249	errno = EOPNOTSUPP;
1250	return NULL;
1251	#endif
1252	}
1253
1254	/**
1255	* ntfs_umount - close ntfs volume
1256	* @vol: address of ntfs_volume structure of volume to close
1257	* @force: if true force close the volume even if it is busy
1258	*
1259	* Deallocate all structures (including @vol itself) associated with the ntfs
1260	* volume @vol.
1261	*
1262	* Return 0 on success. On error return -1 with errno set appropriately
1263	* (most likely to one of EAGAIN, EBUSY or EINVAL). The EAGAIN error means that
1264	* an operation is in progress and if you try the close later the operation
1265	* might be completed and the close succeed.
1266	*
1267	* If @force is true (i.e. not zero) this function will close the volume even
1268	* if this means that data might be lost.
1269	*
1270	* @vol must have previously been returned by a call to ntfs_mount().
1271	*
1272	* @vol itself is deallocated and should no longer be dereferenced after this
1273	* function returns success. If it returns an error then nothing has been done
1274	* so it is safe to continue using @vol.
1275	*/
1276	int ntfs_umount(ntfs_volume *vol, const BOOL force __attribute__((unused)))
1277	{
1278	struct ntfs_device *dev;
1279	int ret;
1280
1281	if (!vol) {
1282	errno = EINVAL;
1283	return -1;
1284	}
1285	dev = vol->dev;
1286	ret = __ntfs_volume_release(vol);
1287	ntfs_device_free(dev);
1288	return ret;
1289	}
1290
1291	#ifdef HAVE_MNTENT_H
1292
1293	#ifndef HAVE_REALPATH
1294	/**
1295	* realpath - If there is no realpath on the system
1296	*/
1297	static char *realpath(const char *path, char *resolved_path)
1298	{
1299	strncpy(resolved_path, path, PATH_MAX);
1300	resolved_path[PATH_MAX] = '\0';
1301	return resolved_path;
1302	}
1303	#endif
1304
1305	/**
1306	* ntfs_mntent_check - desc
1307	*
1308	* If you are wanting to use this, you actually wanted to use
1309	* ntfs_check_if_mounted(), you just didn't realize. (-:
1310	*
1311	* See description of ntfs_check_if_mounted(), below.
1312	*/
1313	static int ntfs_mntent_check(const char *file, unsigned long *mnt_flags)
1314	{
1315	struct mntent *mnt;
1316	char *real_file = NULL, *real_fsname = NULL;
1317	FILE *f;
1318	int err = 0;
1319
1320	real_file = ntfs_malloc(PATH_MAX + 1);
1321	if (!real_file)
1322	return -1;
1323	real_fsname = ntfs_malloc(PATH_MAX + 1);
1324	if (!real_fsname) {
1325	err = errno;
1326	goto exit;
1327	}
1328	if (!realpath(file, real_file)) {
1329	err = errno;
1330	goto exit;
1331	}
1332	if (!(f = setmntent(MOUNTED, "r"))) {
1333	err = errno;
1334	goto exit;
1335	}
1336	while ((mnt = getmntent(f))) {
1337	if (!realpath(mnt->mnt_fsname, real_fsname))
1338	continue;
1339	if (!strcmp(real_file, real_fsname))
1340	break;
1341	}
1342	endmntent(f);
1343	if (!mnt)
1344	goto exit;
1345	*mnt_flags = NTFS_MF_MOUNTED;
1346	if (!strcmp(mnt->mnt_dir, "/"))
1347	*mnt_flags |= NTFS_MF_ISROOT;
1348	#ifdef HAVE_HASMNTOPT
1349	if (hasmntopt(mnt, "ro") && !hasmntopt(mnt, "rw"))
1350	*mnt_flags |= NTFS_MF_READONLY;
1351	#endif
1352	exit:
1353	free(real_file);
1354	free(real_fsname);
1355	if (err) {
1356	errno = err;
1357	return -1;
1358	}
1359	return 0;
1360	}
1361	#endif /* HAVE_MNTENT_H */
1362
1363	/**
1364	* ntfs_check_if_mounted - check if an ntfs volume is currently mounted
1365	* @file: device file to check
1366	* @mnt_flags: pointer into which to return the ntfs mount flags (see volume.h)
1367	*
1368	* If the running system does not support the {set,get,end}mntent() calls,
1369	* just return 0 and set *@mnt_flags to zero.
1370	*
1371	* When the system does support the calls, ntfs_check_if_mounted() first tries
1372	* to find the device @file in /etc/mtab (or wherever this is kept on the
1373	* running system). If it is not found, assume the device is not mounted and
1374	* return 0 and set *@mnt_flags to zero.
1375	*
1376	* If the device @file is found, set the NTFS_MF_MOUNTED flags in *@mnt_flags.
1377	*
1378	* Further if @file is mounted as the file system root ("/"), set the flag
1379	* NTFS_MF_ISROOT in *@mnt_flags.
1380	*
1381	* Finally, check if the file system is mounted read-only, and if so set the
1382	* NTFS_MF_READONLY flag in *@mnt_flags.
1383	*
1384	* On success return 0 with *@mnt_flags set to the ntfs mount flags.
1385	*
1386	* On error return -1 with errno set to the error code.
1387	*/
1388	int ntfs_check_if_mounted(const char *file __attribute__((unused)),
1389	unsigned long *mnt_flags)
1390	{
1391	*mnt_flags = 0;
1392	#ifdef HAVE_MNTENT_H
1393	return ntfs_mntent_check(file, mnt_flags);
1394	#else
1395	return 0;
1396	#endif
1397	}
1398
1399	/**
1400	* ntfs_version_is_supported - check if NTFS version is supported.
1401	* @vol: ntfs volume whose version we're interested in.
1402	*
1403	* The function checks if the NTFS volume version is known or not.
1404	* Version 1.1 and 1.2 are used by Windows NT3.x and NT4.
1405	* Version 2.x is used by Windows 2000 Betas.
1406	* Version 3.0 is used by Windows 2000.
1407	* Version 3.1 is used by Windows XP, Windows Server 2003 and Longhorn.
1408	*
1409	* Return 0 if NTFS version is supported otherwise -1 with errno set.
1410	*
1411	* The following error codes are defined:
1412	* EOPNOTSUPP - Unknown NTFS version
1413	* EINVAL - Invalid argument
1414	*/
1415	int ntfs_version_is_supported(ntfs_volume *vol)
1416	{
1417	u8 major, minor;
1418
1419	if (!vol) {
1420	errno = EINVAL;
1421	return -1;
1422	}
1423
1424	major = vol->major_ver;
1425	minor = vol->minor_ver;
1426
1427	if (NTFS_V1_1(major, minor) || NTFS_V1_2(major, minor))
1428	return 0;
1429
1430	if (NTFS_V2_X(major, minor))
1431	return 0;
1432
1433	if (NTFS_V3_0(major, minor) || NTFS_V3_1(major, minor))
1434	return 0;
1435
1436	errno = EOPNOTSUPP;
1437	return -1;
1438	}
1439
1440	/**
1441	* ntfs_logfile_reset - "empty" $LogFile data attribute value
1442	* @vol: ntfs volume whose $LogFile we intend to reset.
1443	*
1444	* Fill the value of the $LogFile data attribute, i.e. the contents of
1445	* the file, with 0xff's, thus marking the journal as empty.
1446	*
1447	* FIXME(?): We might need to zero the LSN field of every single mft
1448	* record as well. (But, first try without doing that and see what
1449	* happens, since chkdsk might pickup the pieces and do it for us...)
1450	*
1451	* On success return 0.
1452	*
1453	* On error return -1 with errno set to the error code.
1454	*/
1455	int ntfs_logfile_reset(ntfs_volume *vol)
1456	{
1457	ntfs_inode *ni;
1458	ntfs_attr *na;
1459	int eo;
1460
1461	if (!vol) {
1462	errno = EINVAL;
1463	return -1;
1464	}
1465
1466	ni = ntfs_inode_open(vol, FILE_LogFile);
1467	if (!ni) {
1468	ntfs_log_perror("Failed to open inode FILE_LogFile");
1469	return -1;
1470	}
1471
1472	na = ntfs_attr_open(ni, AT_DATA, AT_UNNAMED, 0);
1473	if (!na) {
1474	eo = errno;
1475	ntfs_log_perror("Failed to open $FILE_LogFile/$DATA");
1476	goto error_exit;
1477	}
1478
1479	if (ntfs_empty_logfile(na)) {
1480	eo = errno;
1481	ntfs_attr_close(na);
1482	goto error_exit;
1483	}
1484
1485	ntfs_attr_close(na);
1486	return ntfs_inode_close(ni);
1487
1488	error_exit:
1489	ntfs_inode_close(ni);
1490	errno = eo;
1491	return -1;
1492	}
1493
1494	/**
1495	* ntfs_volume_write_flags - set the flags of an ntfs volume
1496	* @vol: ntfs volume where we set the volume flags
1497	* @flags: new flags
1498	*
1499	* Set the on-disk volume flags in the mft record of $Volume and
1500	* on volume @vol to @flags.
1501	*
1502	* Return 0 if successful and -1 if not with errno set to the error code.
1503	*/
1504	int ntfs_volume_write_flags(ntfs_volume *vol, const le16 flags)
1505	{
1506	ATTR_RECORD *a;
1507	VOLUME_INFORMATION *c;
1508	ntfs_attr_search_ctx *ctx;
1509	int ret = -1; /* failure */
1510
1511	if (!vol || !vol->vol_ni) {
1512	errno = EINVAL;
1513	return -1;
1514	}
1515	/* Get a pointer to the volume information attribute. */
1516	ctx = ntfs_attr_get_search_ctx(vol->vol_ni, NULL);
1517	if (!ctx)
1518	return -1;
1519
1520	if (ntfs_attr_lookup(AT_VOLUME_INFORMATION, AT_UNNAMED, 0, 0, 0, NULL,
1521	0, ctx)) {
1522	ntfs_log_error("Attribute $VOLUME_INFORMATION was not found "
1523	"in $Volume!\n");
1524	goto err_out;
1525	}
1526	a = ctx->attr;
1527	/* Sanity check. */
1528	if (a->non_resident) {
1529	ntfs_log_error("Attribute $VOLUME_INFORMATION must be resident "
1530	"but it isn't.\n");
1531	errno = EIO;
1532	goto err_out;
1533	}
1534	/* Get a pointer to the value of the attribute. */
1535	c = (VOLUME_INFORMATION*)(le16_to_cpu(a->value_offset) + (char*)a);
1536	/* Sanity checks. */
1537	if ((char*)c + le32_to_cpu(a->value_length) > (char*)ctx->mrec +
1538	le32_to_cpu(ctx->mrec->bytes_in_use) ||
1539	le16_to_cpu(a->value_offset) +
1540	le32_to_cpu(a->value_length) > le32_to_cpu(a->length)) {
1541	ntfs_log_error("Attribute $VOLUME_INFORMATION in $Volume is "
1542	"corrupt!\n");
1543	errno = EIO;
1544	goto err_out;
1545	}
1546	/* Set the volume flags. */
1547	vol->flags = c->flags = flags & VOLUME_FLAGS_MASK;
1548	/* Write them to disk. */
1549	ntfs_inode_mark_dirty(vol->vol_ni);
1550	if (ntfs_inode_sync(vol->vol_ni))
1551	goto err_out;
1552
1553	ret = 0; /* success */
1554	err_out:
1555	ntfs_attr_put_search_ctx(ctx);
1556	return ret;
1557	}
1558
1559	int ntfs_volume_error(int err)
1560	{
1561	int ret;
1562
1563	switch (err) {
1564	case 0:
1565	ret = NTFS_VOLUME_OK;
1566	break;
1567	case EINVAL:
1568	ret = NTFS_VOLUME_NOT_NTFS;
1569	break;
1570	case EIO:
1571	ret = NTFS_VOLUME_CORRUPT;
1572	break;
1573	case EPERM:
1574	ret = NTFS_VOLUME_HIBERNATED;
1575	break;
1576	case EOPNOTSUPP:
1577	ret = NTFS_VOLUME_UNCLEAN_UNMOUNT;
1578	break;
1579	case EBUSY:
1580	ret = NTFS_VOLUME_LOCKED;
1581	break;
1582	case ENXIO:
1583	ret = NTFS_VOLUME_RAID;
1584	break;
1585	case EACCES:
1586	ret = NTFS_VOLUME_NO_PRIVILEGE;
1587	break;
1588	default:
1589	ret = NTFS_VOLUME_UNKNOWN_REASON;
1590	break;
1591	}
1592	return ret;
1593	}
1594
1595
1596	void ntfs_mount_error(const char *volume, const char *mntpoint, int err)
1597	{
1598	switch (err) {
1599	case NTFS_VOLUME_NOT_NTFS:
1600	ntfs_log_error(invalid_ntfs_msg, volume);
1601	break;
1602	case NTFS_VOLUME_CORRUPT:
1603	ntfs_log_error("%s", corrupt_volume_msg);
1604	break;
1605	case NTFS_VOLUME_HIBERNATED:
1606	ntfs_log_error(hibernated_volume_msg, volume, mntpoint);
1607	break;
1608	case NTFS_VOLUME_UNCLEAN_UNMOUNT:
1609	ntfs_log_error("%s", unclean_journal_msg);
1610	break;
1611	case NTFS_VOLUME_LOCKED:
1612	ntfs_log_error("%s", opened_volume_msg);
1613	break;
1614	case NTFS_VOLUME_RAID:
1615	ntfs_log_error("%s", fakeraid_msg);
1616	break;
1617	case NTFS_VOLUME_NO_PRIVILEGE:
1618	ntfs_log_error(access_denied_msg, volume);
1619	break;
1620	}
1621	}
1622
1623	int ntfs_set_locale(void)
1624	{
1625	const char *locale;
1626
1627	locale = setlocale(LC_ALL, "");
1628	if (!locale) {
1629	locale = setlocale(LC_ALL, NULL);
1630	ntfs_log_error("Couldn't set local environment, using default "
1631	"'%s'.\n", locale);
1632	return 1;
1633	}
1634	return 0;
1635	}
1636
1637	/*
1638	* Feed the counts of free clusters and free mft records
1639	*/
1640
1641	int ntfs_volume_get_free_space(ntfs_volume *vol)
1642	{
1643	ntfs_attr *na;
1644	int ret;
1645
1646	ret = -1; /* default return */
1647	vol->free_clusters = ntfs_attr_get_free_bits(vol->lcnbmp_na);
1648	if (vol->free_clusters < 0) {
1649	ntfs_log_perror("Failed to read NTFS $Bitmap");
1650	} else {
1651	na = vol->mftbmp_na;
1652	vol->free_mft_records = ntfs_attr_get_free_bits(na);
1653
1654	if (vol->free_mft_records >= 0)
1655	vol->free_mft_records += (na->allocated_size - na->data_size) << 3;
1656
1657	if (vol->free_mft_records < 0)
1658	ntfs_log_perror("Failed to calculate free MFT records");
1659	else
1660	ret = 0;
1661	}
1662	return (ret);
1663	}
1664