1 files changed, 6 insertions, 6 deletions
diff --git a/src/Driver/Fuse/FuseService.cpp b/src/Driver/Fuse/FuseService.cpp
index bc3d1023..5b12ba4d 100644
--- a/src/Driver/Fuse/FuseService.cpp
+++ b/src/Driver/Fuse/FuseService.cpp
@@ -196,140 +196,140 @@ namespace VeraCrypt
 	static int fuse_service_read (const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi)
 	{
 		try
 		{
 			if (!FuseService::CheckAccessRights())
 				return -EACCES;
 
 			if (strcmp (path, FuseService::GetVolumeImagePath()) == 0)
 			{
 				try
 				{
 					// Test for read beyond the end of the volume
 					if ((uint64) offset + size > FuseService::GetVolumeSize())
 						size = FuseService::GetVolumeSize() - offset;
 
 					size_t sectorSize = FuseService::GetVolumeSectorSize();
 					if (size % sectorSize != 0 || offset % sectorSize != 0)
 					{
 						// Support for non-sector-aligned read operations is required by some loop device tools
 						// which may analyze the volume image before attaching it as a device
 
 						uint64 alignedOffset = offset - (offset % sectorSize);
 						uint64 alignedSize = size + (offset % sectorSize);
 
 						if (alignedSize % sectorSize != 0)
 							alignedSize += sectorSize - (alignedSize % sectorSize);
 
 						SecureBuffer alignedBuffer (alignedSize);
 
 						FuseService::ReadVolumeSectors (alignedBuffer, alignedOffset);
-						BufferPtr ((byte *) buf, size).CopyFrom (alignedBuffer.GetRange (offset % sectorSize, size));
+						BufferPtr ((uint8 *) buf, size).CopyFrom (alignedBuffer.GetRange (offset % sectorSize, size));
 					}
 					else
 					{
-						FuseService::ReadVolumeSectors (BufferPtr ((byte *) buf, size), offset);
+						FuseService::ReadVolumeSectors (BufferPtr ((uint8 *) buf, size), offset);
 					}
 				}
 				catch (MissingVolumeData&)
 				{
 					return 0;
 				}
 
 				return size;
 			}
 
 			if (strcmp (path, FuseService::GetControlPath()) == 0)
 			{
 				shared_ptr <Buffer> infoBuf = FuseService::GetVolumeInfo();
-				BufferPtr outBuf ((byte *)buf, size);
+				BufferPtr outBuf ((uint8 *)buf, size);
 
 				if (offset >= (off_t) infoBuf->Size())
 					return 0;
 
 				if (offset + size > infoBuf->Size())
 					size = infoBuf->Size () - offset;
 
 				outBuf.CopyFrom (infoBuf->GetRange (offset, size));
 				return size;
 			}
 		}
 		catch (...)
 		{
 			return FuseService::ExceptionToErrorCode();
 		}
 
 		return -ENOENT;
 	}
 
 	static int fuse_service_readdir (const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi)
 	{
 		try
 		{
 			if (!FuseService::CheckAccessRights())
 				return -EACCES;
 
 			if (strcmp (path, "/") != 0)
 				return -ENOENT;
 
 			filler (buf, ".", NULL, 0);
 			filler (buf, "..", NULL, 0);
 			filler (buf, FuseService::GetVolumeImagePath() + 1, NULL, 0);
 			filler (buf, FuseService::GetControlPath() + 1, NULL, 0);
 		}
 		catch (...)
 		{
 			return FuseService::ExceptionToErrorCode();
 		}
 
 		return 0;
 	}
 
 	static int fuse_service_write (const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi)
 	{
 		try
 		{
 			if (!FuseService::CheckAccessRights())
 				return -EACCES;
 
 			if (strcmp (path, FuseService::GetVolumeImagePath()) == 0)
 			{
-				FuseService::WriteVolumeSectors (BufferPtr ((byte *) buf, size), offset);
+				FuseService::WriteVolumeSectors (BufferPtr ((uint8 *) buf, size), offset);
 				return size;
 			}
 
 			if (strcmp (path, FuseService::GetControlPath()) == 0)
 			{
 				if (FuseService::AuxDeviceInfoReceived())
 					return -EACCES;
 
-				FuseService::ReceiveAuxDeviceInfo (ConstBufferPtr ((const byte *)buf, size));
+				FuseService::ReceiveAuxDeviceInfo (ConstBufferPtr ((const uint8 *)buf, size));
 				return size;
 			}
 		}
 #ifdef TC_FREEBSD
 		// FreeBSD apparently retries failed write operations forever, which may lead to a system crash.
 		catch (VolumeReadOnly&)
 		{
 			return size;
 		}
 		catch (VolumeProtected&)
 		{
 			return size;
 		}
 #endif
 		catch (...)
 		{
 			return FuseService::ExceptionToErrorCode();
 		}
 
 		return -ENOENT;
 	}
 
 	bool FuseService::CheckAccessRights ()
 	{
 		return fuse_get_context()->uid == 0 || fuse_get_context()->uid == UserId;
 	}
 
 	void FuseService::CloseMountedVolume ()
 	{
 		if (MountedVolume)
@@ -557,53 +557,53 @@ namespace VeraCrypt
 		fuse_service_oper.getattr = fuse_service_getattr;
 		fuse_service_oper.init = fuse_service_init;
 		fuse_service_oper.open = fuse_service_open;
 		fuse_service_oper.opendir = fuse_service_opendir;
 		fuse_service_oper.read = fuse_service_read;
 		fuse_service_oper.readdir = fuse_service_readdir;
 		fuse_service_oper.write = fuse_service_write;
 
 		// Create a new session
 		setsid ();
 
 		// Fork handler of termination signals
 		SignalHandlerPipe.reset (new Pipe);
 
 		int forkedPid = fork();
 		throw_sys_if (forkedPid == -1);
 
 		if (forkedPid == 0)
 		{
 			CloseMountedVolume();
 
 			struct sigaction action;
 			Memory::Zero (&action, sizeof (action));
 			action.sa_handler = OnSignal;
 
 			sigaction (SIGINT, &action, nullptr);
 			sigaction (SIGQUIT, &action, nullptr);
 			sigaction (SIGTERM, &action, nullptr);
 
 			// Wait for the exit of the main service
-			byte buf[1];
+			uint8 buf[1];
 			if (read (SignalHandlerPipe->GetReadFD(), buf, sizeof (buf))) { } // Errors ignored
 
 			_exit (0);
 		}
 
 		SignalHandlerPipe->GetWriteFD();
 
 #ifdef TC_OPENBSD
 		_exit (fuse_main (argc, argv, &fuse_service_oper, NULL));
 #else
 		_exit (fuse_main (argc, argv, &fuse_service_oper));
 #endif
 	}
 
 	VolumeInfo FuseService::OpenVolumeInfo;
 	Mutex FuseService::OpenVolumeInfoMutex;
 	shared_ptr <Volume> FuseService::MountedVolume;
 	VolumeSlotNumber FuseService::SlotNumber;
 	uid_t FuseService::UserId;
 	gid_t FuseService::GroupId;
 	unique_ptr <Pipe> FuseService::SignalHandlerPipe;
 }