VeraCrypt

Documentation >> Troubleshooting

Troubleshooting

This section presents possible solutions to common problems that you may run into when using VeraCrypt.
Note: If your problem is not listed here, it might be listed in one of the following sections:
Make sure you use the latest stable version of VeraCrypt. If the problem is caused by a bug in an old version of VeraCrypt, it may have already been fixed. Note: Select Help > About to find out which version you use.

 

Problem:
Writing/reading to/from volume is very slow even though, according to the benchmark, the speed of the cipher that I'm using is higher than the speed of the hard drive.
Probable Cause:
This is probably caused by an interfering application.
Possible Solution:
First, make sure that your VeraCrypt container does not have a file extension that is reserved for executable files (for example, .exe, .sys, or .dll). If it does, Windows and antivirus software may interfere with the container and adversely affect the performance of the volume.
Second, disable or uninstall any application that might be interfering, which usually is antivirus software or automatic disk defragmentation tool, etc. In case of antivirus software, it often helps to turn off real-time (on-access) scanning in the preferences of the antivirus software. If it does not help, try temporarily disabling the virus protection software. If this does not help either, try uninstalling it completely and restarting your computer subsequently.
Problem:
VeraCrypt volume cannot be mounted; VeraCrypt reports "Incorrect password or not a VeraCrypt volume".
Possible Cause:
The volume header may have been damaged by a third-party application or malfunctioning hardware component.
Possible Solutions:
Problem:
After successfully mounting a volume, Windows reports "This device does not contain a valid file system" or a similar error.
Probable Cause:
The file system on the VeraCrypt volume may be corrupted (or the volume is unformatted).
Possible Solution:
You can use filesystem repair tools supplied with your operating system to attempt to repair the filesystem on the VeraCrypt volume. In Windows, it is the 'chkdsk' tool. VeraCrypt provides an easy way to use this tool on a VeraCrypt volume: First, make a backup copy of the VeraCrypt volume (because the 'chkdsk' tool might damage the filesystem even more) and then mount it. Right-click the mounted volume in the main VeraCrypt window (in the drive list) and from the context menu select 'Repair Filesystem'.
Problem:
When trying to create a hidden volume, its maximum possible size is unexpectedly small (there is much more free space than this on the outer volume).
Probable Causes:
  1. The outer volume has been formatted as NTFS
  2. Fragmentation
  3. Too small cluster size + too many files/folders in the root directory of the outer volume.
Possible Solutions:
Solution Related to Cause 1:
Unlike the FAT filesystem, the NTFS filesystem always stores internal data exactly in the middle of the volume. Therefore, the hidden volume can reside only in the second half of the outer volume. If this constraint is unacceptable, do one of the following:
Solution Related to Cause 2:
Create a new outer volume (defragmentation is not a solution, because it would adversely affect plausible deniability – see section Defragmenting).
Solution Related to Cause 3:
Note: The following solution applies only to hidden volumes created within FAT volumes.
Defragment the outer volume (mount it, right-click its drive letter in the 'Computer' or 'My Computer' window, click Properties, select the Tools tab, and click 'Defragment Now'). After the volume is defragmented, exit Disk Defragmenter and try to create the hidden volume again.

If this does not help, delete all files and folders on the outer volume by pressing Shift+Delete, not by formatting, (do not forget to disable the Recycle Bin and System Restore for this drive beforehand) and try creating the hidden volume on this completely empty outer volume again (for testing purposes only). If the maximum possible size of the hidden volume does not change even now, the cause of the problem is very likely an extended root directory. If you did not use the 'Default' cluster size (the last step in the Wizard), reformat the outer volume and this time leave the cluster size at 'Default'.
If it does not help, reformat the outer volume again and copy less files/folders to its root folder than you did last time. If it does not help, keep reformatting and decreasing the number of files/folders in the root folder. If this is unacceptable or if it does not help, reformat the outer volume and select a larger cluster size. If it does not help, keep reformatting and increasing the cluster size, until the problem is solved. Alternatively, try creating a hidden volume within an NTFS volume.
Problem:
One of the following problems occurs:
In addition, the following error may be reported: "The process cannot access the file because it is being used by another process."
Probable Cause:
This is probably caused by an interfering application. Note that this is not a bug in VeraCrypt. The operating system reports to VeraCrypt that the device is locked for an exclusive access by an application (so VeraCrypt is not allowed to access it).
Possible Solution:
It usually helps to disable or uninstall the interfering application, which is usually an anti-virus utility, a disk management application, etc.
Problem:
In the VeraCrypt Boot Loader screen, I'm trying to type my password and/or pressing other keys but the VeraCrypt boot loader is not responding.
Probable Cause:
You have a USB keyboard (not a PS/2 keyboard) and pre-boot support for USB keyboards is disabled in your BIOS settings.
Possible Solution:
You need to enable pre-boot support for USB keyboards in your BIOS settings. To do so, follow the below steps:
Restart your computer, press F2 or Delete (as soon as you see a BIOS start-up screen), and wait until a BIOS configuration screen appears. If no BIOS configuration screen appears, restart (reset) the computer again and start pressing F2 or Delete repeatedly as soon as you restart (reset) the computer. When a BIOS configuration screen appears, enable pre-boot support for USB keyboards. This can typically be done by selecting: Advanced > 'USB Configuration' > 'Legacy USB Support' (or 'USB Legacy') > Enabled. (Note that the word 'legacy' is in fact misleading, because pre-boot components of modern versions of MS Windows require this option to be enabled to allow user interaction/control.) Then save the BIOS settings (typically by pressing F10) and restart your computer. For more information, please refer to the documentation for your BIOS/motherboard or contact your computer vendor's technical support team for assistance.
Problem:
After the system partition/drive is encrypted, the computer cannot boot after it is restarted (it is also impossible to enter the BIOS configuration screen).
Probable Cause:
A bug in the BIOS of your computer.
Possible Solutions:

Follow these steps:

  1. Disconnect the encrypted drive.
  2. Connect an unencrypted drive with an installed operating system (or install it on the drive).
  3. Upgrade the BIOS.
  4. If it does not help, please report this bug to the manufacturer or vendor of the computer.

OR

Problem:
One of the following problems occurs:
Probable Cause:
A bug in the BIOS of your computer or an issue with Windows bootloader.
Possible Solution:
Problem:
When trying to encrypt the system partition/drive, during the pretest, the VeraCrypt Boot Loader always reports that the pre-boot authentication password I entered is incorrect (even though I'm sure it is correct).
Possible Causes:
Possible Solution:
  1. When you set a pre-boot authentication password, remember whether the Num Lock and Caps Lock keys are on or off (depending on the manufacturer, the keys may have different labels, such as Num LK). Note: You can change the state of each of the keys as desired before you set the password, but you need to remember the states.
  2. When you enter the password in the VeraCrypt Boot Loader screen, make sure the state of each of the keys is the same as when you set the password.
Note: For other possible solutions to this problem, see the other sections of this chapter.
Problem:
When the system partition/drive is encrypted, the operating system 'freezes' for approx. 10-60 seconds every 5-60 minutes (100% CPU usage may co-occur).
Probable Cause:
A CPU and/or motherboard issue.
Possible Solutions:
Problem:
When mounting or dismounting a VeraCrypt volume, the system crashes (a 'blue screen' error screen appears or the computer abruptly restarts).
OR
Since I installed VeraCrypt, the operating system has been crashing frequently.
Possible Causes:
Possible Solutions:
Problem:
On Windows 7/Vista (and possibly later versions), the Microsoft Windows Backup tool cannot be used to backup data to a non-system VeraCrypt Volume.
Cause:
A bug in the Windows Backup tool.
Possible Solution:
  1. Mount the VeraCrypt volume to which you want to back up data.
  2. Right-click a folder located on the volume (or right-click its drive letter in the 'Computer' list) and select an item from the 'Share with' submenu (on Windows Vista, select 'Share').
  3. Follow the instructions to share the folder with your user account.
  4. In the Windows Backup tool, select the shared folder (the network location/path) as the destination.
  5. Start the backup process.
Note: The above solution does not apply to the Starter and Home editions of Windows 7 (and possibly later versions).
Problem:
The label of a filesystem in a VeraCrypt volume cannot be changed from within the 'Computer' window under Windows Vista or a later version of Windows.
Cause:
A Windows issue causes the label to be written only to the Windows registry file, instead of being written to the filesystem.
Possible Solutions:
Problem:
I cannot encrypt a partition/device because VeraCrypt Volume Creation Wizard says it is in use.
Possible Solution:
Close, disable, or uninstall all programs that might be using the partition/device in any way (for example an anti-virus utility). If it does not help, right-click the 'Computer' (or 'My Computer') icon on your desktop and select Manage -> Storage -> Disk Management. Then right-click the partition that you want to encrypt, and click Change Drive Letter and Paths. Then click Remove and OK. Restart the operating system.
Problem:
When creating a hidden volume, the Wizard reports that the outer volume cannot be locked.
Probable Cause:
The outer volume contains files being used by one or more applications.
Possible Solution:
Close all applications that are using files on the outer volume. If it does not help, try disabling or uninstalling any anti-virus utility you use and restarting the system subsequently.
Problem:
When accessing a file-hosted container shared over a network, you receive one or both of the following error messages:
"Not enough server storage is available to process this command." and/or,
"Not enough memory to complete transaction."
Probable Cause:
IRPStackSize in the Windows registry may have been set to a too small value.
Possible Solution:
Locate the IRPStackSize key in the Windows registry and set it to a higher value. Then restart the system. If the key does not exist in the Windows registry, create it at HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters and set its value to 16 or higher. Then restart the system. For more information, see: https://support.microsoft.com/kb/285089/ and https://support.microsoft.com/kb/177078/





  See also: Known Issues & Limitations,  Incompatibilities

>ZIP_SOURCE_TELL_WRITE, /* get write position */ ZIP_SOURCE_SUPPORTS, /* check whether source supports command */ ZIP_SOURCE_REMOVE, /* remove file */ ZIP_SOURCE_RESERVED_1, /* previously used internally */ ZIP_SOURCE_BEGIN_WRITE_CLONING, /* like ZIP_SOURCE_BEGIN_WRITE, but keep part of original file */ ZIP_SOURCE_ACCEPT_EMPTY, /* whether empty files are valid archives */ ZIP_SOURCE_GET_FILE_ATTRIBUTES /* get additional file attributes */ }; typedef enum zip_source_cmd zip_source_cmd_t; #define ZIP_SOURCE_MAKE_COMMAND_BITMASK(cmd) (((zip_int64_t)1) << (cmd)) /* clang-format off */ #define ZIP_SOURCE_SUPPORTS_READABLE (ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_OPEN) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_READ) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_CLOSE) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_STAT) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_ERROR) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_FREE)) #define ZIP_SOURCE_SUPPORTS_SEEKABLE (ZIP_SOURCE_SUPPORTS_READABLE \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SEEK) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_TELL) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SUPPORTS)) #define ZIP_SOURCE_SUPPORTS_WRITABLE (ZIP_SOURCE_SUPPORTS_SEEKABLE \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_COMMIT_WRITE) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_ROLLBACK_WRITE) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_WRITE) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SEEK_WRITE) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_TELL_WRITE) \ | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_REMOVE)) /* clang-format on */ /* for use by sources */ struct zip_source_args_seek { zip_int64_t offset; int whence; }; typedef struct zip_source_args_seek zip_source_args_seek_t; #define ZIP_SOURCE_GET_ARGS(type, data, len, error) ((len) < sizeof(type) ? zip_error_set((error), ZIP_ER_INVAL, 0), (type *)NULL : (type *)(data)) /* error information */ /* use zip_error_*() to access */ struct zip_error { int zip_err; /* libzip error code (ZIP_ER_*) */ int sys_err; /* copy of errno (E*) or zlib error code */ char *_Nullable str; /* string representation or NULL */ }; #define ZIP_STAT_NAME 0x0001u #define ZIP_STAT_INDEX 0x0002u #define ZIP_STAT_SIZE 0x0004u #define ZIP_STAT_COMP_SIZE 0x0008u #define ZIP_STAT_MTIME 0x0010u #define ZIP_STAT_CRC 0x0020u #define ZIP_STAT_COMP_METHOD 0x0040u #define ZIP_STAT_ENCRYPTION_METHOD 0x0080u #define ZIP_STAT_FLAGS 0x0100u struct zip_stat { zip_uint64_t valid; /* which fields have valid values */ const char *_Nullable name; /* name of the file */ zip_uint64_t index; /* index within archive */ zip_uint64_t size; /* size of file (uncompressed) */ zip_uint64_t comp_size; /* size of file (compressed) */ time_t mtime; /* modification time */ zip_uint32_t crc; /* crc of file data */ zip_uint16_t comp_method; /* compression method used */ zip_uint16_t encryption_method; /* encryption method used */ zip_uint32_t flags; /* reserved for future use */ }; struct zip_buffer_fragment { zip_uint8_t *_Nonnull data; zip_uint64_t length; }; struct zip_file_attributes { zip_uint64_t valid; /* which fields have valid values */ zip_uint8_t version; /* version of this struct, currently 1 */ zip_uint8_t host_system; /* host system on which file was created */ zip_uint8_t ascii; /* flag whether file is ASCII text */ zip_uint8_t version_needed; /* minimum version needed to extract file */ zip_uint32_t external_file_attributes; /* external file attributes (host-system specific) */ zip_uint16_t general_purpose_bit_flags; /* general purpose big flags, only some bits are honored */ zip_uint16_t general_purpose_bit_mask; /* which bits in general_purpose_bit_flags are valid */ }; #define ZIP_FILE_ATTRIBUTES_HOST_SYSTEM 0x0001u #define ZIP_FILE_ATTRIBUTES_ASCII 0x0002u #define ZIP_FILE_ATTRIBUTES_VERSION_NEEDED 0x0004u #define ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES 0x0008u #define ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS 0x0010u struct zip; struct zip_file; struct zip_source; typedef struct zip zip_t; typedef struct zip_error zip_error_t; typedef struct zip_file zip_file_t; typedef struct zip_file_attributes zip_file_attributes_t; typedef struct zip_source zip_source_t; typedef struct zip_stat zip_stat_t; typedef struct zip_buffer_fragment zip_buffer_fragment_t; typedef zip_uint32_t zip_flags_t; typedef zip_int64_t (*zip_source_callback)(void *_Nullable, void *_Nullable, zip_uint64_t, zip_source_cmd_t); typedef void (*zip_progress_callback)(zip_t *_Nonnull, double, void *_Nullable); typedef int (*zip_cancel_callback)(zip_t *_Nonnull, void *_Nullable); #ifndef ZIP_DISABLE_DEPRECATED typedef void (*zip_progress_callback_t)(double); ZIP_EXTERN void zip_register_progress_callback(zip_t *_Nonnull, zip_progress_callback_t _Nullable); /* use zip_register_progress_callback_with_state */ ZIP_EXTERN zip_int64_t zip_add(zip_t *_Nonnull, const char *_Nonnull, zip_source_t *_Nonnull); /* use zip_file_add */ ZIP_EXTERN zip_int64_t zip_add_dir(zip_t *_Nonnull, const char *_Nonnull); /* use zip_dir_add */ ZIP_EXTERN const char *_Nullable zip_get_file_comment(zip_t *_Nonnull, zip_uint64_t, int *_Nullable, int); /* use zip_file_get_comment */ ZIP_EXTERN int zip_get_num_files(zip_t *_Nonnull); /* use zip_get_num_entries instead */ ZIP_EXTERN int zip_rename(zip_t *_Nonnull, zip_uint64_t, const char *_Nonnull); /* use zip_file_rename */ ZIP_EXTERN int zip_replace(zip_t *_Nonnull, zip_uint64_t, zip_source_t *_Nonnull); /* use zip_file_replace */ ZIP_EXTERN int zip_set_file_comment(zip_t *_Nonnull, zip_uint64_t, const char *_Nullable, int); /* use zip_file_set_comment */ ZIP_EXTERN int zip_error_get_sys_type(int); /* use zip_error_system_type */ ZIP_EXTERN void zip_error_get(zip_t *_Nonnull, int *_Nullable, int *_Nullable); /* use zip_get_error, zip_error_code_zip / zip_error_code_system */ ZIP_EXTERN int zip_error_to_str(char *_Nonnull, zip_uint64_t, int, int); /* use zip_error_init_with_code / zip_error_strerror */ ZIP_EXTERN void zip_file_error_get(zip_file_t *_Nonnull, int *_Nullable, int *_Nullable); /* use zip_file_get_error, zip_error_code_zip / zip_error_code_system */ #endif ZIP_EXTERN int zip_close(zip_t *_Nonnull); ZIP_EXTERN int zip_delete(zip_t *_Nonnull, zip_uint64_t); ZIP_EXTERN zip_int64_t zip_dir_add(zip_t *_Nonnull, const char *_Nonnull, zip_flags_t); ZIP_EXTERN void zip_discard(zip_t *_Nonnull); ZIP_EXTERN zip_error_t *_Nonnull zip_get_error(zip_t *_Nonnull); ZIP_EXTERN void zip_error_clear(zip_t *_Nonnull); ZIP_EXTERN int zip_error_code_zip(const zip_error_t *_Nonnull); ZIP_EXTERN int zip_error_code_system(const zip_error_t *_Nonnull); ZIP_EXTERN void zip_error_fini(zip_error_t *_Nonnull); ZIP_EXTERN void zip_error_init(zip_error_t *_Nonnull); ZIP_EXTERN void zip_error_init_with_code(zip_error_t *_Nonnull, int); ZIP_EXTERN void zip_error_set(zip_error_t *_Nullable, int, int); ZIP_EXTERN const char *_Nonnull zip_error_strerror(zip_error_t *_Nonnull); ZIP_EXTERN int zip_error_system_type(const zip_error_t *_Nonnull); ZIP_EXTERN zip_int64_t zip_error_to_data(const zip_error_t *_Nonnull, void *_Nonnull, zip_uint64_t); ZIP_EXTERN int zip_fclose(zip_file_t *_Nonnull); ZIP_EXTERN zip_t *_Nullable zip_fdopen(int, int, int *_Nullable); ZIP_EXTERN zip_int64_t zip_file_add(zip_t *_Nonnull, const char *_Nonnull, zip_source_t *_Nonnull, zip_flags_t); ZIP_EXTERN void zip_file_attributes_init(zip_file_attributes_t *_Nonnull); ZIP_EXTERN void zip_file_error_clear(zip_file_t *_Nonnull); ZIP_EXTERN int zip_file_extra_field_delete(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_flags_t); ZIP_EXTERN int zip_file_extra_field_delete_by_id(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_uint16_t, zip_flags_t); ZIP_EXTERN int zip_file_extra_field_set(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_uint16_t, const zip_uint8_t *_Nullable, zip_uint16_t, zip_flags_t); ZIP_EXTERN zip_int16_t zip_file_extra_fields_count(zip_t *_Nonnull, zip_uint64_t, zip_flags_t); ZIP_EXTERN zip_int16_t zip_file_extra_fields_count_by_id(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_flags_t); ZIP_EXTERN const zip_uint8_t *_Nullable zip_file_extra_field_get(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_uint16_t *_Nullable, zip_uint16_t *_Nullable, zip_flags_t); ZIP_EXTERN const zip_uint8_t *_Nullable zip_file_extra_field_get_by_id(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_uint16_t, zip_uint16_t *_Nullable, zip_flags_t); ZIP_EXTERN const char *_Nullable zip_file_get_comment(zip_t *_Nonnull, zip_uint64_t, zip_uint32_t *_Nullable, zip_flags_t); ZIP_EXTERN zip_error_t *_Nonnull zip_file_get_error(zip_file_t *_Nonnull); ZIP_EXTERN int zip_file_get_external_attributes(zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_uint8_t *_Nullable, zip_uint32_t *_Nullable); ZIP_EXTERN int zip_file_rename(zip_t *_Nonnull, zip_uint64_t, const char *_Nonnull, zip_flags_t); ZIP_EXTERN int zip_file_replace(zip_t *_Nonnull, zip_uint64_t, zip_source_t *_Nonnull, zip_flags_t); ZIP_EXTERN int zip_file_set_comment(zip_t *_Nonnull, zip_uint64_t, const char *_Nullable, zip_uint16_t, zip_flags_t); ZIP_EXTERN int zip_file_set_dostime(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_uint16_t, zip_flags_t); ZIP_EXTERN int zip_file_set_encryption(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, const char *_Nullable); ZIP_EXTERN int zip_file_set_external_attributes(zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_uint8_t, zip_uint32_t); ZIP_EXTERN int zip_file_set_mtime(zip_t *_Nonnull, zip_uint64_t, time_t, zip_flags_t); ZIP_EXTERN const char *_Nonnull zip_file_strerror(zip_file_t *_Nonnull); ZIP_EXTERN zip_file_t *_Nullable zip_fopen(zip_t *_Nonnull, const char *_Nonnull, zip_flags_t); ZIP_EXTERN zip_file_t *_Nullable zip_fopen_encrypted(zip_t *_Nonnull, const char *_Nonnull, zip_flags_t, const char *_Nullable); ZIP_EXTERN zip_file_t *_Nullable zip_fopen_index(zip_t *_Nonnull, zip_uint64_t, zip_flags_t); ZIP_EXTERN zip_file_t *_Nullable zip_fopen_index_encrypted(zip_t *_Nonnull, zip_uint64_t, zip_flags_t, const char *_Nullable); ZIP_EXTERN zip_int64_t zip_fread(zip_file_t *_Nonnull, void *_Nonnull, zip_uint64_t); ZIP_EXTERN zip_int8_t zip_fseek(zip_file_t *_Nonnull, zip_int64_t, int); ZIP_EXTERN zip_int64_t zip_ftell(zip_file_t *_Nonnull); ZIP_EXTERN const char *_Nullable zip_get_archive_comment(zip_t *_Nonnull, int *_Nullable, zip_flags_t); ZIP_EXTERN int zip_get_archive_flag(zip_t *_Nonnull, zip_flags_t, zip_flags_t); ZIP_EXTERN const char *_Nullable zip_get_name(zip_t *_Nonnull, zip_uint64_t, zip_flags_t); ZIP_EXTERN zip_int64_t zip_get_num_entries(zip_t *_Nonnull, zip_flags_t); ZIP_EXTERN const char *_Nonnull zip_libzip_version(void); ZIP_EXTERN zip_int64_t zip_name_locate(zip_t *_Nonnull, const char *_Nonnull, zip_flags_t); ZIP_EXTERN zip_t *_Nullable zip_open(const char *_Nonnull, int, int *_Nullable); ZIP_EXTERN zip_t *_Nullable zip_open_from_source(zip_source_t *_Nonnull, int, zip_error_t *_Nullable); ZIP_EXTERN int zip_register_progress_callback_with_state(zip_t *_Nonnull, double, zip_progress_callback _Nullable, void (*_Nullable)(void *_Nullable), void *_Nullable); ZIP_EXTERN int zip_register_cancel_callback_with_state(zip_t *_Nonnull, zip_cancel_callback _Nullable, void (*_Nullable)(void *_Nullable), void *_Nullable); ZIP_EXTERN int zip_set_archive_comment(zip_t *_Nonnull, const char *_Nullable, zip_uint16_t); ZIP_EXTERN int zip_set_archive_flag(zip_t *_Nonnull, zip_flags_t, int); ZIP_EXTERN int zip_set_default_password(zip_t *_Nonnull, const char *_Nullable); ZIP_EXTERN int zip_set_file_compression(zip_t *_Nonnull, zip_uint64_t, zip_int32_t, zip_uint32_t); ZIP_EXTERN int zip_source_begin_write(zip_source_t *_Nonnull); ZIP_EXTERN int zip_source_begin_write_cloning(zip_source_t *_Nonnull, zip_uint64_t); ZIP_EXTERN zip_source_t *_Nullable zip_source_buffer(zip_t *_Nonnull, const void *_Nullable, zip_uint64_t, int); ZIP_EXTERN zip_source_t *_Nullable zip_source_buffer_create(const void *_Nullable, zip_uint64_t, int, zip_error_t *_Nullable); ZIP_EXTERN zip_source_t *_Nullable zip_source_buffer_fragment(zip_t *_Nonnull, const zip_buffer_fragment_t *_Nonnull, zip_uint64_t, int); ZIP_EXTERN zip_source_t *_Nullable zip_source_buffer_fragment_create(const zip_buffer_fragment_t *_Nullable, zip_uint64_t, int, zip_error_t *_Nullable); ZIP_EXTERN int zip_source_close(zip_source_t *_Nonnull); ZIP_EXTERN int zip_source_commit_write(zip_source_t *_Nonnull); ZIP_EXTERN zip_error_t *_Nonnull zip_source_error(zip_source_t *_Nonnull); ZIP_EXTERN zip_source_t *_Nullable zip_source_file(zip_t *_Nonnull, const char *_Nonnull, zip_uint64_t, zip_int64_t); ZIP_EXTERN zip_source_t *_Nullable zip_source_file_create(const char *_Nonnull, zip_uint64_t, zip_int64_t, zip_error_t *_Nullable); ZIP_EXTERN zip_source_t *_Nullable zip_source_filep(zip_t *_Nonnull, FILE *_Nonnull, zip_uint64_t, zip_int64_t); ZIP_EXTERN zip_source_t *_Nullable zip_source_filep_create(FILE *_Nonnull, zip_uint64_t, zip_int64_t, zip_error_t *_Nullable); ZIP_EXTERN void zip_source_free(zip_source_t *_Nullable); ZIP_EXTERN zip_source_t *_Nullable zip_source_function(zip_t *_Nonnull, zip_source_callback _Nonnull, void *_Nullable); ZIP_EXTERN zip_source_t *_Nullable zip_source_function_create(zip_source_callback _Nonnull, void *_Nullable, zip_error_t *_Nullable); ZIP_EXTERN int zip_source_get_file_attributes(zip_source_t *_Nonnull, zip_file_attributes_t *_Nonnull); ZIP_EXTERN int zip_source_is_deleted(zip_source_t *_Nonnull); ZIP_EXTERN void zip_source_keep(zip_source_t *_Nonnull); ZIP_EXTERN zip_int64_t zip_source_make_command_bitmap(zip_source_cmd_t, ...); ZIP_EXTERN int zip_source_open(zip_source_t *_Nonnull); ZIP_EXTERN zip_int64_t zip_source_read(zip_source_t *_Nonnull, void *_Nonnull, zip_uint64_t); ZIP_EXTERN void zip_source_rollback_write(zip_source_t *_Nonnull); ZIP_EXTERN int zip_source_seek(zip_source_t *_Nonnull, zip_int64_t, int); ZIP_EXTERN zip_int64_t zip_source_seek_compute_offset(zip_uint64_t, zip_uint64_t, void *_Nonnull, zip_uint64_t, zip_error_t *_Nullable); ZIP_EXTERN int zip_source_seek_write(zip_source_t *_Nonnull, zip_int64_t, int); ZIP_EXTERN int zip_source_stat(zip_source_t *_Nonnull, zip_stat_t *_Nonnull); ZIP_EXTERN zip_int64_t zip_source_tell(zip_source_t *_Nonnull); ZIP_EXTERN zip_int64_t zip_source_tell_write(zip_source_t *_Nonnull); #ifdef _WIN32 ZIP_EXTERN zip_source_t *zip_source_win32a(zip_t *, const char *, zip_uint64_t, zip_int64_t); ZIP_EXTERN zip_source_t *zip_source_win32a_create(const char *, zip_uint64_t, zip_int64_t, zip_error_t *); ZIP_EXTERN zip_source_t *zip_source_win32handle(zip_t *, void *, zip_uint64_t, zip_int64_t); ZIP_EXTERN zip_source_t *zip_source_win32handle_create(void *, zip_uint64_t, zip_int64_t, zip_error_t *); ZIP_EXTERN zip_source_t *zip_source_win32w(zip_t *, const wchar_t *, zip_uint64_t, zip_int64_t); ZIP_EXTERN zip_source_t *zip_source_win32w_create(const wchar_t *, zip_uint64_t, zip_int64_t, zip_error_t *); #endif ZIP_EXTERN zip_int64_t zip_source_write(zip_source_t *_Nonnull, const void *_Nullable, zip_uint64_t); ZIP_EXTERN zip_source_t *_Nullable zip_source_zip(zip_t *_Nonnull, zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_int64_t); ZIP_EXTERN int zip_stat(zip_t *_Nonnull, const char *_Nonnull, zip_flags_t, zip_stat_t *_Nonnull); ZIP_EXTERN int zip_stat_index(zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_stat_t *_Nonnull); ZIP_EXTERN void zip_stat_init(zip_stat_t *_Nonnull); ZIP_EXTERN const char *_Nonnull zip_strerror(zip_t *_Nonnull); ZIP_EXTERN int zip_unchange(zip_t *_Nonnull, zip_uint64_t); ZIP_EXTERN int zip_unchange_all(zip_t *_Nonnull); ZIP_EXTERN int zip_unchange_archive(zip_t *_Nonnull); ZIP_EXTERN int zip_compression_method_supported(zip_int32_t method, int compress); ZIP_EXTERN int zip_encryption_method_supported(zip_uint16_t method, int encode); #ifdef __cplusplus } #endif #endif /* _HAD_ZIP_H */