Error system transformation to GErrorv0.6.74

Note that most coreworkers are broken at the moment.

2 files changed, 281 insertions, 274 deletions

diff --git a/vfs/UVFSCore.pas b/vfs/UVFSCore.pas
index cf3e36a..d875b83 100644
--- a/vfs/UVFSCore.pas
+++ b/vfs/UVFSCore.pas
@@ -97,6 +97,8 @@ type
     FBlockSize: Cardinal;
     FArchiveMode: boolean;
     FArchivePath: string;
+    FCopyProgressCallback: PVFSProgressCallback;
+    FCopyCallbackData: Pointer;
     function GetPluginID: string;
     function GetDataItemFromVFSItem(P: PVFSItem): PDataItem;
     function GetArchiveStreamingType: boolean;
@@ -109,10 +111,10 @@ type
     constructor Create(SourcePlugin: TVFSPlugin);
     destructor Destroy; override;
 
-    function GetListing(List: TList; const APath: string; AddDotFiles, FollowSymlinks, AddFullPath: boolean): integer; override;
-    function GetFileInfo(const APath: string; FollowSymlinks, AddFullPath: boolean): PDataItem; override;
+    function GetListing(List: TList; const APath: string; AddDotFiles, FollowSymlinks, AddFullPath: boolean; Error: PPGError): boolean; override;
+    function GetFileInfo(const APath: string; FollowSymlinks, AddFullPath: boolean; Error: PPGError): PDataItem; override;
 
-    function ChangeDir(const NewPath: string): integer; override;
+    function ChangeDir(const NewPath: string; Error: PPGError): boolean; override;
     function GetPath: string; override;
     procedure SetPath(Value: string); override;
 
@@ -124,32 +126,32 @@ type
     function IsOnROMedium(const FileName: string): boolean; override;
     function FileCanRun(const FileName: string): boolean; override;
 
-    function MakeDir(const NewDir: string): integer; override;
-    function Remove(const APath: string): integer; override;
-    function MakeSymLink(const NewFileName, PointTo: string): integer; override;
-    function Chmod(const FileName: string; Mode: cuLong): integer; override;
-    function Chown(const FileName: string; UID, GID: cuLong): integer; override;
-    function RenameFile(const SourceFile, DestFile: string): integer; override;
-    function ChangeTimes(const APath: string; mtime, atime: time_t): integer; override;
+    function MakeDir(const NewDir: string; Error: PPGError): boolean; override;
+    function Remove(const APath: string; Error: PPGError): boolean; override;
+    function MakeSymLink(const NewFileName, PointTo: string; Error: PPGError): boolean; override;
+    function Chmod(const FileName: string; Mode: cuLong; Error: PPGError): boolean; override;
+    function Chown(const FileName: string; UID, GID: cuLong; Error: PPGError): boolean; override;
+    function RenameFile(const SourceFile, DestFile: string; Error: PPGError): boolean; override;
+    function ChangeTimes(const APath: string; mtime, atime: time_t; Error: PPGError): boolean; override;
 
     function GetBlockSize: guint32; override;
     procedure SetBlockSize(Value: guint32); override;
-    function CopyFileIn(Sender: Pointer; const SourceFile, DestFile: string; ProgressFunc: TEngineProgressFunc; ErrorFunc: TEngineErrorFunc; Append: boolean): boolean; override;
-    function CopyFileOut(Sender: Pointer; const SourceFile, DestFile: string; ProgressFunc: TEngineProgressFunc; ErrorFunc: TEngineErrorFunc; Append: boolean): boolean; override;
+    function CopyFileIn(const SourceFile, DestFile: string; Append: boolean; ProgressFunc: TEngineProgressFunc; Sender: Pointer): boolean; override;
+    function CopyFileOut(const SourceFile, DestFile: string; Append: boolean; ProgressFunc: TEngineProgressFunc; Sender: Pointer): boolean; override;
     function IsOnSameFS(const Path1, Path2: string; FollowSymlinks: boolean): boolean; override;
     function TwoSameFiles(const Path1, Path2: string; FollowSymlinks: boolean): boolean; override;
 
-    function OpenFile(const APath: string; Mode: integer; var Error: integer): TEngineFileDes; override;
-    function ReadFile(const FileDescriptor: TEngineFileDes; Buffer: Pointer; ABlockSize: integer; var Error: integer): integer; override;
-    function WriteFile(const FileDescriptor: TEngineFileDes; Buffer: Pointer; BytesCount: integer; var Error: integer): integer; override;
-    function CloseFile(const FileDescriptor: TEngineFileDes): integer; override;
-    function FileSeek(const FileDescriptor: TEngineFileDes; const AbsoluteOffset: Int64; var Error: integer): Int64; override;
+    function OpenFile(const APath: string; Mode: integer; Error: PPGError): TEngineFileDes; override;
+    function ReadFile(const FileDescriptor: TEngineFileDes; Buffer: Pointer; ABlockSize: integer; Error: PPGError): integer; override;
+    function WriteFile(const FileDescriptor: TEngineFileDes; Buffer: Pointer; BytesCount: integer; Error: PPGError): integer; override;
+    function CloseFile(const FileDescriptor: TEngineFileDes; Error: PPGError): boolean; override;
+    function FileSeek(const FileDescriptor: TEngineFileDes; const AbsoluteOffset: Int64; Error: PPGError): Int64; override;
 
     //  VFS additions
-    function VFSOpenURI(const URI: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): boolean;
-    function VFSOpenEx(const OpenFile: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): TVFSResult;
-    function VFSClose: boolean;
-    function ChangeDirEx(const NewPath: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): integer;
+    function VFSOpenURI(const URI: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer; Error: PPGError): boolean;
+    function VFSOpenEx(const OpenFile: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer; Error: PPGError): boolean;
+    function VFSClose(Error: PPGError): boolean;
+    function ChangeDirEx(const NewPath: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer; Error: PPGError): boolean;
 
     function GetPathURI: string;
 
@@ -157,10 +159,10 @@ type
     procedure ResetPassword;
 
     //  callbacks here are used for next volume prompts, password prompts (encrypted archives)
-    function StartCopyOperation(Sender: Pointer; ErrorFunc: TEngineErrorFunc; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): boolean;
-    function StopCopyOperation(Sender: Pointer; ErrorFunc: TEngineErrorFunc): boolean;
-    function CopyFileInEx(Sender: Pointer; const SourceFile, DestFile: string; ErrorFunc: TEngineErrorFunc; Append: boolean): boolean;
-    function CopyFileOutEx(Sender: Pointer; const SourceFile, DestFile: string; ErrorFunc: TEngineErrorFunc; Append: boolean): boolean;
+    function StartCopyOperation(AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): boolean;
+    function StopCopyOperation(ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): boolean;
+    function CopyFileOutEx(const SourceFile, DestFile: string; Append: boolean): boolean;
+    function CopyFileInEx(const SourceFile, DestFile: string; Append: boolean): boolean;
   published
     property PluginID: string read GetPluginID;
     property ArchiveMode: boolean read FArchiveMode;
@@ -176,7 +178,7 @@ var PluginList: TList;
 
 implementation
 
-uses SysUtils, UConfig, ULocale;
+uses SysUtils, UConfig, ULocale, UError;
 
 
 const ConstGlobalModulePath1 = '/usr/lib/tuxcmd';
@@ -359,6 +361,8 @@ begin
   RemoveFileOnClose := '';
   OpenedFromQuickConnect := False;
   CustomPluginIDSave := '';
+  FCopyProgressCallback := nil;
+  FCopyCallbackData := nil;
 
   if @FSourcePlugin.FVFSNew <> nil then FGlobs := FSourcePlugin.FVFSNew(@VFSLogFunc);
 end;
@@ -375,13 +379,13 @@ begin
   end;
 end;
 
-function TVFSEngine.VFSOpenURI(const URI: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): boolean;
+function TVFSEngine.VFSOpenURI(const URI: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer; Error: PPGError): boolean;
 begin
   Result := False;
   if (FGlobs <> nil) and (@FSourcePlugin.FVFSOpenURI <> nil) then begin
     if @FSourcePlugin.FVFSSetCallbacks <> nil then
       FSourcePlugin.FVFSSetCallbacks(FGlobs, AskQuestionCallback, AskPasswordCallback, ProgressCallback, CallbackData);
-    Result := FSourcePlugin.FVFSOpenURI(FGlobs, PChar(URI)) = cVFS_OK;
+    Result := FSourcePlugin.FVFSOpenURI(FGlobs, PChar(URI), Error);
     FArchiveMode := False;
     FArchivePath := '';
     if @FSourcePlugin.FVFSSetCallbacks <> nil then
@@ -389,27 +393,27 @@ begin
   end;
 end;
 
-function TVFSEngine.VFSOpenEx(const OpenFile: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): TVFSResult;
+function TVFSEngine.VFSOpenEx(const OpenFile: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer; Error: PPGError): boolean;
 begin
-  Result := cVFS_OK;
+  Result := False;
   if (FGlobs <> nil) and (@FSourcePlugin.FVFSOpenArchive <> nil) then begin
     if @FSourcePlugin.FVFSSetCallbacks <> nil then
       FSourcePlugin.FVFSSetCallbacks(FGlobs, AskQuestionCallback, AskPasswordCallback, ProgressCallback, CallbackData);
-    Result := FSourcePlugin.FVFSOpenArchive(FGlobs, PChar(OpenFile));
+    Result := FSourcePlugin.FVFSOpenArchive(FGlobs, PChar(OpenFile), Error);
     FArchiveMode := True;
-    if Result = cVFS_OK then FArchivePath := OpenFile
-                        else FArchivePath := '';
+    if Result then FArchivePath := OpenFile
+              else FArchivePath := '';
     if @FSourcePlugin.FVFSSetCallbacks <> nil then
       FSourcePlugin.FVFSSetCallbacks(FGlobs, nil, nil, nil, nil);
   end;
 end;
 
 (********************************************************************************************************************************)
-function TVFSEngine.VFSClose: boolean;
+function TVFSEngine.VFSClose(Error: PPGError): boolean;
 begin
   Result := False;
-  if (FGlobs <> nil) and (@FSourcePlugin.FVFSClose <> nil)
-    then Result := FSourcePlugin.FVFSClose(FGlobs) = cVFS_OK;
+  if (FGlobs <> nil) and (@FSourcePlugin.FVFSClose <> nil) then
+    Result := FSourcePlugin.FVFSClose(FGlobs, Error);
 end;
 
 function TVFSEngine.GetDataItemFromVFSItem(P: PVFSItem): PDataItem;
@@ -444,30 +448,21 @@ begin
   Result := Item;
 end;
 
-function TVFSEngine.GetListing(List: TList; const APath: string; AddDotFiles, FollowSymlinks, AddFullPath: boolean): integer;
+function TVFSEngine.GetListing(List: TList; const APath: string; AddDotFiles, FollowSymlinks, AddFullPath: boolean; Error: PPGError): boolean;
 var P: PVFSItem;
     Item: PDataItem;
-    Res: integer;
+    FError: PGError;
 begin
   DebugMsg(['^^VFS (II): GetListing begin']);
-  Result := 0;
+  Result := False;
   try
-    if @FSourcePlugin.FVFSListFirst = nil then begin
-      Result := ERRNoAccess;
-      Exit;
-    end;
-    P := real_libc_malloc(sizeof(TVFSItem));
-    memset(P, 0, sizeof(TVFSItem));
-    Res := FSourcePlugin.FVFSListFirst(FGlobs, PChar(APath), P, FollowSymlinks, AddFullPath);
-    if Res <> cVFS_OK then begin
-      FSourcePlugin.FVFSListClose(FGlobs);
-      if Res = cVFS_Not_More_Files then Result := 0
-                                   else Result := Res;
-      real_libc_free(P);
+    if (@FSourcePlugin.FVFSListFirst = nil) or (@FSourcePlugin.FVFSListNext = nil) or (@FSourcePlugin.FVFSListClose = nil) then begin
+      g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'File listing not supported by the VFS module.');
       Exit;
     end;
-
-    repeat
+    FError := nil;
+    P := FSourcePlugin.FVFSListFirst(FGlobs, PChar(APath), FollowSymlinks, AddFullPath, @FError);
+    while (P <> nil) and (BreakProcessingType <> 2) do begin
       if (strlen(P^.FName) > 0) and (AddDotFiles or (P^.FName[0] <> '.')) then begin
         Item := GetDataItemFromVFSItem(P);
         List.Add(Item);
@@ -475,14 +470,22 @@ begin
       if P^.FName <> nil then real_libc_free(P^.FName);
       if P^.FDisplayName <> nil then real_libc_free(P^.FDisplayName);
       if P^.sLinkTo <> nil then real_libc_free(P^.sLinkTo);
-      memset(P, 0, sizeof(TVFSItem));
-      Res := FSourcePlugin.FVFSListNext(FGlobs, P);
-    until (Res <> cVFS_OK) or (BreakProcessingType = 2);
-    if BreakProcessingType <> 0 then DebugMsg(['^^VFS (WW): GetListing: stopped by BreakProcessing']);
-
+      real_libc_free(P);
+      P := FSourcePlugin.FVFSListNext(FGlobs, @FError);
+    end;
+    Result := FError = nil;
+    if BreakProcessingType <> 0 then begin
+      DebugMsg(['^^VFS (WW): GetListing: stopped by BreakProcessing']);
+      g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_CANCELLED), '%s', 'The operation has been cancelled.');
+      Result := False;
+    end else begin
+      if (Error <> nil) and (FError <> nil) then
+        Error^ := g_error_copy(FError);
+    end;
+    if FError <> nil then
+      g_error_free(FError);
     real_libc_free(P);
-    FSourcePlugin.FVFSListClose(FGlobs);
-    if Res <> cVFS_Not_More_Files then Result := Res;
+    FSourcePlugin.FVFSListClose(FGlobs, nil);
   except
     on E: Exception do
       DebugMsg(['^^VFS (EE): GetListing: Exception: ', E.Message]);
@@ -491,18 +494,19 @@ begin
   DebugMsg(['^^VFS (II): GetListing end.']);
 end;
 
-function TVFSEngine.GetFileInfo(const APath: string; FollowSymlinks, AddFullPath: boolean): PDataItem;
+function TVFSEngine.GetFileInfo(const APath: string; FollowSymlinks, AddFullPath: boolean; Error: PPGError): PDataItem;
 var P: PVFSItem;
-    Res: integer;
 begin
   DebugMsg(['^^VFS (II): GetFileInfo begin']);
   Result := nil;
-  if @FSourcePlugin.FVFSFileInfo = nil then Exit;
+
+  if @FSourcePlugin.FVFSFileInfo = nil then begin
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Querying file info is not supported by the VFS module.');
+    Exit;
+  end;
   try
-    P := real_libc_malloc(sizeof(TVFSItem));
-    memset(P, 0, sizeof(TVFSItem));
-    Res := FSourcePlugin.FVFSFileInfo(FGlobs, PChar(APath), P, FollowSymlinks, AddFullPath);
-    if Res = cVFS_OK then
+    P := FSourcePlugin.FVFSFileInfo(FGlobs, PChar(APath), FollowSymlinks, AddFullPath, Error);
+    if P <> nil then
       Result := GetDataItemFromVFSItem(P);
     if P^.FName <> nil then real_libc_free(P^.FName);
     if P^.FDisplayName <> nil then real_libc_free(P^.FDisplayName);
@@ -527,13 +531,12 @@ begin
     AFSSize := -1;
     AFSFree := -1;
     AFSName := nil;
-    if FSourcePlugin.FVFSGetFileSystemInfo(FGlobs, PChar(APath), @AFSSize, @AFSFree, @AFSName) = cVFS_OK then begin
-      FSSize := AFSSize;
-      FSFree := AFSFree;
-      if AFSName <> nil then begin
-        FSName := string(AFSName);
-        real_libc_free(AFSName);
-      end;
+    FSourcePlugin.FVFSGetFileSystemInfo(FGlobs, PChar(APath), @AFSSize, @AFSFree, @AFSName);
+    FSSize := AFSSize;
+    FSFree := AFSFree;
+    if AFSName <> nil then begin
+      FSName := string(AFSName);
+      real_libc_free(AFSName);
     end;
   end;
 end;
@@ -546,7 +549,7 @@ end;
 function TVFSEngine.FileCanRun(const FileName: string): boolean;
 var Item: PDataItem;
 begin
-  Item := GetFileInfo(FileName, True, True);
+  Item := GetFileInfo(FileName, True, True, nil);
   Result := (Item <> nil) and Item^.IsExecutable;
   FreeDataItem(Item);
 end;
@@ -577,26 +580,23 @@ begin
   end;
 end;
 
-function TVFSEngine.ChangeDir(const NewPath: string): integer;
+function TVFSEngine.ChangeDir(const NewPath: string; Error: PPGError): boolean;
 begin
-  DebugMsg(['^^VFS (II): ChangeDir begin']);
-  Result := 0;
+  Result := False;
   try
-    Result := FSourcePlugin.FVFSChangeDir(FGlobs, PChar(NewPath));
-//        Sleep(3000);
+    Result := FSourcePlugin.FVFSChangeDir(FGlobs, PChar(NewPath), Error);
   except
     on E: Exception do DebugMsg(['^^VFS (EE): ChangeDir: Exception: ', E.Message]);
   end;
-  DebugMsg(['^^VFS (II): ChangeDir end.']);
 end;
 
-function TVFSEngine.ChangeDirEx(const NewPath: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): integer;
+function TVFSEngine.ChangeDirEx(const NewPath: string; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer; Error: PPGError): boolean;
 begin
-  Result := ERRNoAccess;
+  Result := False;
   if (FGlobs <> nil) and (@FSourcePlugin.FVFSChangeDir <> nil) then begin
     if @FSourcePlugin.FVFSSetCallbacks <> nil then
       FSourcePlugin.FVFSSetCallbacks(FGlobs, AskQuestionCallback, AskPasswordCallback, ProgressCallback, CallbackData);
-    Result := ChangeDir(NewPath);
+    Result := ChangeDir(NewPath, Error);
     if @FSourcePlugin.FVFSSetCallbacks <> nil then
       FSourcePlugin.FVFSSetCallbacks(FGlobs, nil, nil, nil, nil);
   end;
@@ -604,7 +604,7 @@ end;
 
 procedure TVFSEngine.SetPath(Value: string);
 begin
-  ChangeDir(Value);
+  ChangeDir(Value, nil);
 end;
 
 function TVFSEngine.FileExists(const FileName: string; FollowSymlinks: boolean): boolean;
@@ -614,9 +614,8 @@ begin
   if (FGlobs = nil) or (@FSourcePlugin.FVFSFileInfo = nil) then
     Exit;
   try
-    P := real_libc_malloc(sizeof(TVFSItem));
-    memset(P, 0, sizeof(TVFSItem));
-    Result := FSourcePlugin.FVFSFileInfo(FGlobs, PChar(FileName), P, FollowSymlinks, False) = cVFS_OK;
+    P := FSourcePlugin.FVFSFileInfo(FGlobs, PChar(FileName), FollowSymlinks, False, nil);
+    Result := P <> nil;
     real_libc_free(P);
   except
     on E: Exception do
@@ -626,16 +625,13 @@ end;
 
 function TVFSEngine.DirectoryExists(const FileName: string; FollowSymlinks: boolean): boolean;
 var P: PVFSItem;
-    Res: integer;
 begin
   Result := False;
   if (FGlobs = nil) or (@FSourcePlugin.FVFSFileInfo = nil) then
     Exit;
   try
-    P := real_libc_malloc(sizeof(TVFSItem));
-    memset(P, 0, sizeof(TVFSItem));
-    Res := FSourcePlugin.FVFSFileInfo(FGlobs, PChar(FileName), P, FollowSymlinks, False);
-    Result := (Res = cVFS_OK) and (TVFSItemType(P^.ItemType) = vDirectory);
+    P := FSourcePlugin.FVFSFileInfo(FGlobs, PChar(FileName), FollowSymlinks, False, nil);
+    Result := (P <> nil) and (TVFSItemType(P^.ItemType) = vDirectory);
     real_libc_free(P);
   except
     on E: Exception do
@@ -643,46 +639,74 @@ begin
   end;
 end;
 
-function TVFSEngine.MakeDir(const NewDir: string): integer;
+function TVFSEngine.MakeDir(const NewDir: string; Error: PPGError): boolean;
 begin
-  if @FSourcePlugin.FVFSMkDir <> nil then Result := FSourcePlugin.FVFSMkDir(FGlobs, PChar(NewDir))
-                                     else Result := cVFS_Failed;
+  if @FSourcePlugin.FVFSMkDir <> nil then
+    Result := FSourcePlugin.FVFSMkDir(FGlobs, PChar(NewDir), Error)
+  else begin
+    Result := False;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Creating directories is not supported by the VFS module.');
+  end;
 end;
 
-function TVFSEngine.Remove(const APath: string): integer;
+function TVFSEngine.Remove(const APath: string; Error: PPGError): boolean;
 begin
-  if @FSourcePlugin.FVFSRemove <> nil then Result := FSourcePlugin.FVFSRemove(FGlobs, PChar(APath))
-                                      else Result := cVFS_Failed;
+  if @FSourcePlugin.FVFSRemove <> nil then
+    Result := FSourcePlugin.FVFSRemove(FGlobs, PChar(APath), Error)
+  else begin
+    Result := False;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Removing files is not supported by the VFS module.');
+  end;
 end;
 
-function TVFSEngine.RenameFile(const SourceFile, DestFile: string): integer;
+function TVFSEngine.RenameFile(const SourceFile, DestFile: string; Error: PPGError): boolean;
 begin
-  if @FSourcePlugin.FVFSRename <> nil then Result := FSourcePlugin.FVFSRename(FGlobs, PChar(SourceFile), PChar(DestFile))
-                                      else Result := cVFS_Failed;
+  if @FSourcePlugin.FVFSRename <> nil then
+    Result := FSourcePlugin.FVFSRename(FGlobs, PChar(SourceFile), PChar(DestFile), Error)
+  else begin
+    Result := False;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Renaming files is not supported by the VFS module.');
+  end;
 end;
 
-function TVFSEngine.MakeSymLink(const NewFileName, PointTo: string): integer;
+function TVFSEngine.MakeSymLink(const NewFileName, PointTo: string; Error: PPGError): boolean;
 begin
-  if @FSourcePlugin.FVFSMakeSymLink <> nil then Result := FSourcePlugin.FVFSMakeSymLink(FGlobs, PChar(NewFileName), PChar(PointTo))
-                                           else Result := cVFS_Failed;
+  if @FSourcePlugin.FVFSMakeSymLink <> nil then
+    Result := FSourcePlugin.FVFSMakeSymLink(FGlobs, PChar(NewFileName), PChar(PointTo), Error)
+  else begin
+    Result := False;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Creating symbolic links is not supported by the VFS module.');
+  end;
 end;
 
-function TVFSEngine.Chmod(const FileName: string; Mode: cuLong): integer;
+function TVFSEngine.Chmod(const FileName: string; Mode: cuLong; Error: PPGError): boolean;
 begin
-  if @FSourcePlugin.FVFSChmod <> nil then Result := FSourcePlugin.FVFSChmod(FGlobs, PChar(FileName), Mode)
-                                     else Result := cVFS_Failed;
+  if @FSourcePlugin.FVFSChmod <> nil then
+    Result := FSourcePlugin.FVFSChmod(FGlobs, PChar(FileName), Mode, Error)
+  else begin
+    Result := False;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Chmod is not supported by the VFS module.');
+  end;
 end;
 
-function TVFSEngine.Chown(const FileName: string; UID, GID: cuLong): integer;
+function TVFSEngine.Chown(const FileName: string; UID, GID: cuLong; Error: PPGError): boolean;
 begin
-  if @FSourcePlugin.FVFSChown <> nil then Result := FSourcePlugin.FVFSChown(FGlobs, PChar(FileName), UID, GID)
-                                     else Result := cVFS_Failed;
+  if @FSourcePlugin.FVFSChown <> nil then
+    Result := FSourcePlugin.FVFSChown(FGlobs, PChar(FileName), UID, GID, Error)
+  else begin
+    Result := False;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Chown is not supported by the VFS module.');
+  end;
 end;
 
-function TVFSEngine.ChangeTimes(const APath: string; mtime, atime: time_t): integer;
+function TVFSEngine.ChangeTimes(const APath: string; mtime, atime: time_t; Error: PPGError): boolean;
 begin
-  if @FSourcePlugin.FVFSChangeTimes <> nil then Result := FSourcePlugin.FVFSChangeTimes(FGlobs, PChar(APath), mtime, atime)
-                                           else Result := cVFS_Failed;
+  if @FSourcePlugin.FVFSChangeTimes <> nil then
+    Result := FSourcePlugin.FVFSChangeTimes(FGlobs, PChar(APath), mtime, atime, Error)
+  else begin
+    Result := False;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Changing timestamps is not supported by the VFS module.');
+  end;
 end;
 
 function TVFSEngine.GetDirSize(const APath: string): Int64;
@@ -719,46 +743,51 @@ begin
     else Result := True;
 end;
 
-function TVFSEngine.OpenFile(const APath: string; Mode: integer; var Error: integer): TEngineFileDes;
-var i: integer;
+function TVFSEngine.OpenFile(const APath: string; Mode: integer; Error: PPGError): TEngineFileDes;
 begin
-  if @FSourcePlugin.FVFSOpenFile <> nil then begin
-    Result := FSourcePlugin.FVFSOpenFile(FGlobs, PChar(APath), Mode, @i);
-    Error := i;
-  end else Result := nil;
+  if @FSourcePlugin.FVFSOpenFile <> nil then
+    Result := FSourcePlugin.FVFSOpenFile(FGlobs, PChar(APath), Mode, Error)
+  else begin
+    Result := nil;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Manual opening files is not supported by the VFS module.');
+  end;
 end;
 
-function TVFSEngine.ReadFile(const FileDescriptor: TEngineFileDes; Buffer: Pointer; ABlockSize: integer; var Error: integer): integer;
-var i: integer;
+function TVFSEngine.ReadFile(const FileDescriptor: TEngineFileDes; Buffer: Pointer; ABlockSize: integer; Error: PPGError): integer;
 begin
-  if @FSourcePlugin.FVFSReadFile <> nil then begin
-    Result := FSourcePlugin.FVFSReadFile(FGlobs, FileDescriptor, Buffer, ABlockSize, @i);
-    Error := i;
-  end else Result := -1;
+  if @FSourcePlugin.FVFSReadFile <> nil then
+    Result := FSourcePlugin.FVFSReadFile(FGlobs, FileDescriptor, Buffer, ABlockSize, Error)
+  else begin
+    Result := -1;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Manual read is not supported by the VFS module.');
+  end;
 end;
 
-function TVFSEngine.WriteFile(const FileDescriptor: TEngineFileDes; Buffer: Pointer; BytesCount: integer; var Error: integer): integer;
-var i: integer;
+function TVFSEngine.WriteFile(const FileDescriptor: TEngineFileDes; Buffer: Pointer; BytesCount: integer; Error: PPGError): integer;
 begin
-  if @FSourcePlugin.FVFSWriteFile <> nil then begin
-    Result := FSourcePlugin.FVFSWriteFile(FGlobs, FileDescriptor, Buffer, BytesCount, @i);
-    Error := i;
-  end else Result := -1;
+  if @FSourcePlugin.FVFSWriteFile <> nil then
+    Result := FSourcePlugin.FVFSWriteFile(FGlobs, FileDescriptor, Buffer, BytesCount, Error)
+  else begin
+    Result := -1;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Manual write is not supported by the VFS module.');
+  end;
 end;
 
-function TVFSEngine.CloseFile(const FileDescriptor: TEngineFileDes): integer;
+function TVFSEngine.CloseFile(const FileDescriptor: TEngineFileDes; Error: PPGError): boolean;
 begin
-  if @FSourcePlugin.FVFSCloseFile <> nil then Result := FSourcePlugin.FVFSCloseFile(FGlobs, FileDescriptor)
-                                         else Result := 0;
+  if @FSourcePlugin.FVFSCloseFile <> nil then
+    Result := FSourcePlugin.FVFSCloseFile(FGlobs, FileDescriptor, nil)
+  else Result := False;
 end;
 
-function TVFSEngine.FileSeek(const FileDescriptor: TEngineFileDes; const AbsoluteOffset: Int64; var Error: integer): Int64;
-var i: integer;
+function TVFSEngine.FileSeek(const FileDescriptor: TEngineFileDes; const AbsoluteOffset: Int64; Error: PPGError): Int64;
 begin
-  if @FSourcePlugin.FVFSFileSeek <> nil then begin
-    Result := FSourcePlugin.FVFSFileSeek(FGlobs, FileDescriptor, AbsoluteOffset, @i);
-    Error := i;
-  end else Result := -1;
+  if @FSourcePlugin.FVFSFileSeek <> nil then
+    Result := FSourcePlugin.FVFSFileSeek(FGlobs, FileDescriptor, AbsoluteOffset, Error)
+  else begin
+    Result := -1;
+    g_set_error(Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'Manual seek is not supported by the VFS module.');
+  end;
 end;
 
 function TVFSEngine.TwoSameFiles(const Path1, Path2: string; FollowSymlinks: boolean): boolean;
@@ -770,129 +799,123 @@ end;
 
 
 (********************************************************************************************************************************)
-function TVFSEngine.CopyFileIn(Sender: Pointer; const SourceFile, DestFile: string; ProgressFunc: TEngineProgressFunc; ErrorFunc: TEngineErrorFunc; Append: boolean): boolean;
+function TVFSEngine.CopyFileIn(const SourceFile, DestFile: string; Append: boolean; ProgressFunc: TEngineProgressFunc; Sender: Pointer): boolean;
 begin
-  Result := StartCopyOperation(Sender, ErrorFunc, nil, nil, nil, nil);
-  Result := Result and CopyFileInEx(Sender, SourceFile, DestFile, ErrorFunc, Append);
-  Result := Result and StopCopyOperation(Sender, ErrorFunc);
+  DebugMsg(['** (WW): deprecated method CopyFileIn called from a TVFSEngine instance!']);
+  Result := StartCopyOperation(nil, nil, nil, nil);
+  Result := Result and CopyFileInEx(SourceFile, DestFile, Append);
+  Result := Result and StopCopyOperation(nil, nil);
 end;
 
-function TVFSEngine.CopyFileOut(Sender: Pointer; const SourceFile, DestFile: string; ProgressFunc: TEngineProgressFunc; ErrorFunc: TEngineErrorFunc; Append: boolean): boolean;
+function TVFSEngine.CopyFileOut(const SourceFile, DestFile: string; Append: boolean; ProgressFunc: TEngineProgressFunc; Sender: Pointer): boolean;
 begin
-  Result := StartCopyOperation(Sender, ErrorFunc, nil, nil, nil, nil);
-  Result := Result and CopyFileInEx(Sender, SourceFile, DestFile, ErrorFunc, Append);
-  Result := Result and StopCopyOperation(Sender, ErrorFunc);
+  DebugMsg(['** (WW): deprecated method CopyFileOut called from a TVFSEngine instance!']);
+  Result := StartCopyOperation(nil, nil, nil, nil);
+  Result := Result and CopyFileOutEx(SourceFile, DestFile, Append);
+  Result := Result and StopCopyOperation(nil, nil);
 end;
 
-function TVFSEngine.CopyFileOutEx(Sender: Pointer; const SourceFile, DestFile: string; ErrorFunc: TEngineErrorFunc; Append: boolean): boolean;
-var Res: TVFSResult;
+function TVFSEngine.CopyFileOutEx(const SourceFile, DestFile: string; Append: boolean): boolean;
+var Error: PGError;
+    ACopyProgressCallback: TVFSProgressCallback;
 begin
   Result := False;
   try
-    if @FSourcePlugin.FVFSCopyToLocal <> nil then begin
-      try
-        Res := FSourcePlugin.FVFSCopyToLocal(FGlobs, PChar(SourceFile), PChar(DestFile), Append);
-      except
-        on E: Exception do begin
-          DebugMsg(['*** Exception raised in TVFSEngine.CopyFileOut(Sender=', QWord(Sender), ', SourceFile=', SourceFile, ', DestFile=', DestFile, '):  (', E.ClassName, '): ', E.Message]);
-          Res := cVFS_WriteErr;
-        end;
+    Error := nil;
+    if @FSourcePlugin.FVFSCopyToLocal <> nil then
+      Result := FSourcePlugin.FVFSCopyToLocal(FGlobs, PChar(SourceFile), PChar(DestFile), Append, @Error)
+    else
+      g_set_error(@Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'VFSCopyToLocal not supported by the VFS module.');
+    if Error <> nil then begin
+      if FCopyProgressCallback <> nil then begin
+        @ACopyProgressCallback := FCopyProgressCallback;
+        Result := ACopyProgressCallback(0, Error, FCopyCallbackData);
       end;
-      Result := Res = cVFS_OK;
-      // * TODO: Port to GError
-      if (Res <> cVFS_OK) and Assigned(ErrorFunc) then
-        case Res of
-          cVFS_ReadErr: Result := ErrorFunc(Sender, 6, 0, SourceFile);
-          cVFS_WriteErr: Result := ErrorFunc(Sender, 7, 0, DestFile);
-          cVFS_mallocFailed: ErrorFunc(Sender, 1, 0, SourceFile);
-          cVFS_Cancelled: ErrorFunc(Sender, 0, 0, SourceFile);
-         end;
-    end else Result := False;
+      g_error_free(Error);
+    end;
   except
-    on E: Exception do DebugMsg(['*** Exception raised in TVFSEngine.CopyFileOut(Sender=', QWord(Sender), ', SourceFile=', SourceFile, ', DestFile=', DestFile, '):  (', E.ClassName, '): ', E.Message]);
+    on E: Exception do begin
+      DebugMsg(['*** Exception raised in TVFSEngine.CopyFileOutEx(SourceFile=', SourceFile, ', DestFile=', DestFile, ', Append=', Append,'):  (', E.ClassName, '): ', E.Message]);
+      Result := False;
+    end;
   end;
 end;
 
-function TVFSEngine.CopyFileInEx(Sender: Pointer; const SourceFile, DestFile: string; ErrorFunc: TEngineErrorFunc; Append: boolean): boolean;
-var Res: TVFSResult;
+function TVFSEngine.CopyFileInEx(const SourceFile, DestFile: string; Append: boolean): boolean;
+var Error: PGError;
+ACopyProgressCallback: TVFSProgressCallback;
 begin
   Result := False;
   try
-    if @FSourcePlugin.FVFSCopyFromLocal <> nil then begin
-      try
-        Res := FSourcePlugin.FVFSCopyFromLocal(FGlobs, PChar(SourceFile), PChar(DestFile), Append);
-      except
-        on E: Exception do begin
-          DebugMsg(['*** Exception raised in TVFSEngine.CopyFileIn(Sender=', QWord(Sender), ', SourceFile=', SourceFile, ', DestFile=', DestFile, '):  (', E.ClassName, '): ', E.Message]);
-          Res := cVFS_WriteErr;
-        end;
+    Error := nil;
+    if @FSourcePlugin.FVFSCopyFromLocal <> nil then
+      Result := FSourcePlugin.FVFSCopyFromLocal(FGlobs, PChar(SourceFile), PChar(DestFile), Append, @Error)
+    else
+      g_set_error(@Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'VFSCopyFromLocal not supported by the VFS module.');
+    if Error <> nil then begin
+      if FCopyProgressCallback <> nil then begin
+        @ACopyProgressCallback := FCopyProgressCallback;
+        Result := ACopyProgressCallback(0, Error, FCopyCallbackData);
       end;
-      Result := Res = cVFS_OK;
-      // * TODO: Port to GError
-      if (Res <> cVFS_OK) and Assigned(ErrorFunc) then
-        case Res of
-          cVFS_ReadErr: Result := ErrorFunc(Sender, 6, 0, SourceFile);
-          cVFS_WriteErr: Result := ErrorFunc(Sender, 7, 0, DestFile);
-          cVFS_mallocFailed: ErrorFunc(Sender, 1, 0, SourceFile);
-          cVFS_Cancelled: ErrorFunc(Sender, 0, 0, SourceFile);
-        end;
-    end else Result := False;
+      g_error_free(Error);
+    end;
   except
-    on E: Exception do DebugMsg(['*** Exception raised in TVFSEngine.CopyFileIn(Sender=', QWord(Sender), ', SourceFile=', SourceFile, ', DestFile=', DestFile, '):  (', E.ClassName, '): ', E.Message]);
+    on E: Exception do begin
+      DebugMsg(['*** Exception raised in TVFSEngine.CopyFileInEx(SourceFile=', SourceFile, ', DestFile=', DestFile, ', Append=', Append,'):  (', E.ClassName, '): ', E.Message]);
+      Result := False;
+    end;
   end;
 end;
 
-function TVFSEngine.StartCopyOperation(Sender: Pointer; ErrorFunc: TEngineErrorFunc; AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): boolean;
-var Res: TVFSResult;
+function TVFSEngine.StartCopyOperation(AskQuestionCallback: PVFSAskQuestionCallback; AskPasswordCallback: PVFSAskPasswordCallback; ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): boolean;
+var Error: PGError;
 begin
   Result := not ArchiveMode;
   try
     if @FSourcePlugin.FVFSSetCallbacks <> nil then
       FSourcePlugin.FVFSSetCallbacks(FGlobs, AskQuestionCallback, AskPasswordCallback, ProgressCallback, CallbackData);
+    FCopyProgressCallback := ProgressCallback;
+    FCopyCallbackData := CallbackData;
     if ArchiveMode then begin
-      if @FSourcePlugin.FVFSStartCopyOperation <> nil then begin
-        Res := FSourcePlugin.FVFSStartCopyOperation(FGlobs);
-        Result := Res = cVFS_OK;
-        // * TODO: Port to GError
-        if (Res <> cVFS_OK) and Assigned(ErrorFunc) then
-          case Res of
-            cVFS_ReadErr: Result := ErrorFunc(Sender, 6, 0, 'StartCopyOperation');
-            cVFS_WriteErr: Result := ErrorFunc(Sender, 7, 0, 'StartCopyOperation');
-            cVFS_mallocFailed: ErrorFunc(Sender, 1, 0, 'StartCopyOperation');
-            cVFS_Cancelled: ErrorFunc(Sender, 0, 0, 'StartCopyOperation');
-          end;
-      end else
-        ErrorFunc(Sender, 2, 0, 'StartCopyOperation not supported');
+      Error := nil;
+      if @FSourcePlugin.FVFSStartCopyOperation <> nil then
+        Result := FSourcePlugin.FVFSStartCopyOperation(FGlobs, @Error)
+      else
+        g_set_error(@Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'VFSStartCopyOperation not supported by the VFS module.');
+      if Error <> nil then begin
+        if ProgressCallback <> nil then
+          Result := ProgressCallback^(0, Error, CallbackData);
+        g_error_free(Error);
+      end;
     end;
   except
-    on E: Exception do DebugMsg(['*** Exception raised in TVFSEngine.StartCopyOperation(Sender=', QWord(Sender), '):  (', E.ClassName, '): ', E.Message]);
+    on E: Exception do DebugMsg(['*** Exception raised in TVFSEngine.StartCopyOperation(CallbackData=', CallbackData, '):  (', E.ClassName, '): ', E.Message]);
   end;
 end;
 
-function TVFSEngine.StopCopyOperation(Sender: Pointer; ErrorFunc: TEngineErrorFunc): boolean;
-var Res: TVFSResult;
+function TVFSEngine.StopCopyOperation(ProgressCallback: PVFSProgressCallback; CallbackData: Pointer): boolean;
+var Error: PGError;
 begin
   Result := not ArchiveMode;
   try
     if @FSourcePlugin.FVFSSetCallbacks <> nil then
       FSourcePlugin.FVFSSetCallbacks(FGlobs, nil, nil, nil, nil);
     if ArchiveMode then begin
-      if @FSourcePlugin.FVFSStopCopyOperation <> nil then begin
-        Res := FSourcePlugin.FVFSStopCopyOperation(FGlobs);
-        Result := Res = cVFS_OK;
-        // * TODO: Port to GError
-        if (Res <> cVFS_OK) and Assigned(ErrorFunc) then
-          case Res of
-            cVFS_ReadErr: Result := ErrorFunc(Sender, 6, 0, 'StopCopyOperation');
-            cVFS_WriteErr: Result := ErrorFunc(Sender, 7, 0, 'StopCopyOperation');
-            cVFS_mallocFailed: ErrorFunc(Sender, 1, 0, 'StopCopyOperation');
-            cVFS_Cancelled: ErrorFunc(Sender, 0, 0, 'StopCopyOperation');
-          end;
-      end else
-        ErrorFunc(Sender, 5, 0, 'StopCopyOperation not supported');
+      Error := nil;
+      if @FSourcePlugin.FVFSStopCopyOperation <> nil then
+        Result := FSourcePlugin.FVFSStopCopyOperation(FGlobs, @Error)
+      else
+        g_set_error(@Error, G_IO_ERROR, gint(G_IO_ERROR_NOT_SUPPORTED), '%s', 'VFSStopCopyOperation not supported by the VFS module.');
+      if Error <> nil then begin
+        if ProgressCallback <> nil then
+          Result := ProgressCallback^(0, Error, CallbackData);
+        g_error_free(Error);
+      end;
     end;
+    FCopyProgressCallback := nil;
+    FCopyCallbackData := nil;
   except
-    on E: Exception do DebugMsg(['*** Exception raised in TVFSEngine.StopCopyOperation(Sender=', QWord(Sender), '):  (', E.ClassName, '): ', E.Message]);
+    on E: Exception do DebugMsg(['*** Exception raised in TVFSEngine.StopCopyOperation(CallbackData=', CallbackData, '):  (', E.ClassName, '): ', E.Message]);
   end;
 end;
 
diff --git a/vfs/uVFSprototypes.pas b/vfs/uVFSprototypes.pas
index 8beacdd..9ed0844 100644
--- a/vfs/uVFSprototypes.pas
+++ b/vfs/uVFSprototypes.pas
@@ -36,24 +36,7 @@ uses glib2;
 const
       cVFSVersion = 5;    //  current version of the VFS API
 
-      //  Error codes (TVFSResult)
-      cVFS_OK = 0;
-      cVFS_Failed = 1;   // also No such file
-      cVFS_Cancelled = 2;
-      cVFS_Not_Supported = 3;
-      cVFS_Not_More_Files = 4;   // returned while directory listing
-      cVFS_ReadErr = 5;
-      cVFS_WriteErr = 6;   //  also ReadOnlyFileSystem
-      cVFS_LoginFailed = 7;
-      cVFS_PermissionDenied = 8;
-      cVFS_NoSpaceLeft = 9;
-      cVFS_mallocFailed = 10;
-      cVFS_BadPassword = 11;
-      cVFS_MissingVolume = 12;
-      cVFS_CorruptedArchive = 13;
-
-
-      //  Open modes (for VFSOpenFile function) 
+      //  Open modes (for VFSOpenFile function)
       cVFS_OpenRead = 0;
       cVFS_OpenWrite = 1;
       cVFS_OpenAppend = 2;
@@ -76,8 +59,6 @@ const
 
 
 type
-     TVFSResult = longint;
-
      //  Plugin private data for each connection/instance
      TVFSGlobs = Pointer;
 
@@ -94,7 +75,6 @@ type
 
      TVFSItemType = (vRegular=0, vChardev=1, vBlockdev=2, vDirectory=3, vFifo=4, vSock=5, vOther=6);
 
-
      PVFSItem = ^TVFSItem;
      TVFSItem = record
        FName: PChar;
@@ -149,10 +129,14 @@ type
                                         password_save: PVFSPasswordSave;
                                         user_data: Pointer): gboolean; cdecl;
 
-    //  Return False to break the operation
+    //  Progress callback, return False to break the copy process
+    //  If an Error is set, returning True means to ignore error (don't delete broken file if possible)
+    //  If an Error is set, Position may contain random value
+    //  Do not free Error, it belongs to the copy operation
     PVFSProgressCallback = ^TVFSProgressCallback;
+    //  Keep in sync with UCoreWorkers.pas/vfs_progress_callback
     TVFSProgressCallback = function (position: guint64;
-                                     max: guint64;
+                                     error: PGError;
                                      user_data: Pointer): gboolean; cdecl;
 
 type
@@ -192,33 +176,33 @@ type
 
 
     //  Opens specified archive. This will also switch engine into an archiving mode
-    TVFSOpenArchive = function (g:TVFSGlobs; const sName: PChar): TVFSResult; cdecl;
+    TVFSOpenArchive = function (g:TVFSGlobs; const sName: PChar; Error: PPGError): gboolean; cdecl;
     //  Opens specified network location. This will also switch engine into a networking mode
     //  In case of URI, do not supply password encoded in the string; plugin will automatically spawn the TVFSAskPasswordCallback callback when needed
-    TVFSOpenURI = function (g:TVFSGlobs; const sURI: PChar): TVFSResult; cdecl;
+    TVFSOpenURI = function (g:TVFSGlobs; const sURI: PChar; Error: PPGError): gboolean; cdecl;
     //  Closes the file or connection to the server
-    TVFSClose = function (g:TVFSGlobs): TVFSResult; cdecl;
+    TVFSClose = function (g:TVFSGlobs; Error: PPGError): gboolean; cdecl;
 
 
     //  These functions serves for listing contents of a directory
     //  Before calling VFSListFirst, it is recommended to change target directory (VFSChangeDir) to check it really exists
     //  First call the VFSListFirst function and then repeat call of VFSListNext until it returns NULL.
     //  Then call VFSListClose to make cleanup
-    TVFSListFirst = function (g:TVFSGlobs; const sDir: PChar; VFSItem: PVFSItem; FollowSymlinks, AddFullPath: gboolean): TVFSResult; cdecl;
-    TVFSListNext = function (g:TVFSGlobs; VFSItem: PVFSItem): TVFSResult; cdecl;
-    TVFSListClose = function (g:TVFSGlobs): TVFSResult; cdecl;
+    TVFSListFirst = function (g:TVFSGlobs; const sDir: PChar; FollowSymlinks, AddFullPath: gboolean; Error: PPGError): PVFSItem; cdecl;
+    TVFSListNext = function (g:TVFSGlobs; Error: PPGError): PVFSItem; cdecl;
+    TVFSListClose = function (g:TVFSGlobs; Error: PPGError): gboolean; cdecl;
     //  Gets a single info item without need to list a whole directory
-    TVFSFileInfo = function (g:TVFSGlobs; const AFileName: PChar; VFSItem: PVFSItem; FollowSymlinks, AddFullPath: gboolean): TVFSResult; cdecl;
+    TVFSFileInfo = function (g:TVFSGlobs; const AFileName: PChar; FollowSymlinks, AddFullPath: gboolean; Error: PPGError): PVFSItem; cdecl;
 
 
     //  Try to change directory, checks real access
-    TVFSChangeDir = function (g:TVFSGlobs; const NewPath: PChar): TVFSResult; cdecl;
+    TVFSChangeDir = function (g:TVFSGlobs; const NewPath: PChar; Error: PPGError): gboolean; cdecl;
     //  Returns current working path, tuxcmd will take care of memory deallocation
     TVFSGetPath = function (g:TVFSGlobs): PChar; cdecl;
     //  Returns the current working path in the URI form, tuxcmd will take care of memory deallocation
     TVFSGetPathURI = function (g:TVFSGlobs): PChar; cdecl;
     //  Gets filesystem info; tuxcmd will take care of memory deallocation
-    TVFSGetFileSystemInfo = function (g:TVFSGlobs; const APath: PChar; FSSize, FSFree: PInt64; FSLabel: PPChar): TVFSResult; cdecl;
+    TVFSGetFileSystemInfo = procedure (g:TVFSGlobs; const APath: PChar; FSSize, FSFree: PInt64; FSLabel: PPChar); cdecl;
     TVFSIsOnSameFS = function (g:TVFSGlobs; const Path1, Path2: PChar; FollowSymlinks: gboolean): gboolean; cdecl;
     //  Checks if the two files are simmilar (used to test the case-insensitive filesystem - or hardlinks)
     TVFSTwoSameFiles = function (g:TVFSGlobs; const Path1, Path2: PChar; FollowSymlinks: gboolean): gboolean; cdecl;
@@ -228,34 +212,34 @@ type
     TVFSBreakGetDirSize = procedure (g:TVFSGlobs); cdecl;
 
     //  Operations
-    TVFSMkDir = function (g:TVFSGlobs; const sDirName: PChar): TVFSResult; cdecl;
+    TVFSMkDir = function (g:TVFSGlobs; const sDirName: PChar; Error: PPGError): gboolean; cdecl;
     //  Rename/Move, the two files/directories have to be on the same filesystem (do manual copy and delete otherway)
-    TVFSRename = function (g:TVFSGlobs; const sSrcName, sDstName: PChar): TVFSResult; cdecl;
+    TVFSRename = function (g:TVFSGlobs; const sSrcName, sDstName: PChar; Error: PPGError): gboolean; cdecl;
     //  Removes file/directory (empty only!)
-    TVFSRemove = function (g:TVFSGlobs; const APath: PChar): TVFSResult; cdecl;
-    TVFSMakeSymLink = function (g:TVFSGlobs; const NewFileName, PointTo: PChar): TVFSResult; cdecl;
+    TVFSRemove = function (g:TVFSGlobs; const APath: PChar; Error: PPGError): gboolean; cdecl;
+    TVFSMakeSymLink = function (g:TVFSGlobs; const NewFileName, PointTo: PChar; Error: PPGError): gboolean; cdecl;
     //  Mode is classic unix format (glibc) - a bit mask
-    TVFSChmod = function (g:TVFSGlobs; const FileName: PChar; Mode: guint32): TVFSResult; cdecl;
-    TVFSChown = function (g:TVFSGlobs; const FileName: PChar; UID, GID: guint32): TVFSResult; cdecl;
+    TVFSChmod = function (g:TVFSGlobs; const FileName: PChar; Mode: guint32; Error: PPGError): gboolean; cdecl;
+    TVFSChown = function (g:TVFSGlobs; const FileName: PChar; UID, GID: guint32; Error: PPGError): gboolean; cdecl;
     //  Changes times for the file/directory - mtime and atime are __time_t parameters (glibc)
-    TVFSChangeTimes = function (g:TVFSGlobs; const APath: PChar; mtime, atime: guint32): TVFSResult; cdecl;
+    TVFSChangeTimes = function (g:TVFSGlobs; const APath: PChar; mtime, atime: guint32; Error: PPGError): gboolean; cdecl;
 
     
     //  Performs the copy process from inside of module to local filesystem
     //  (thus sSrcName is a path from inside of module and sDstName is path in the local filesystem where the file should be copied)
     //  Note: if you need to transfer a file between two VFS modules, you need to do it manually -
     //        - either first copy to local FS or use the Open, Read, Write functions of the module (NOTE: both VFS modules have to support these functions)
-    TVFSCopyToLocal = function (g:TVFSGlobs; const sSrcName, sDstName: PChar; Append: gboolean): TVFSResult; cdecl;
+    TVFSCopyToLocal = function (g:TVFSGlobs; const sSrcName, sDstName: PChar; Append: gboolean; Error: PPGError): gboolean; cdecl;
     //  Performs the copy process from local filesystem into the module
-    TVFSCopyFromLocal = function (g:TVFSGlobs; const sSrcName, sDstName: PChar; Append: gboolean): TVFSResult; cdecl;
-    //  Start the copy operation - open the archive and prepare internal structures
-    TVFSStartCopyOperation = function (g:TVFSGlobs): TVFSResult; cdecl;
-    //  Stop the copy operation - close the archive and free memory
-    TVFSStopCopyOperation = function (g:TVFSGlobs): TVFSResult; cdecl;
+    TVFSCopyFromLocal = function (g:TVFSGlobs; const sSrcName, sDstName: PChar; Append: gboolean; Error: PPGError): gboolean; cdecl;
+    //  Start the copy operation - open the archive and prepare internal structures (called only in archive mode)
+    TVFSStartCopyOperation = function (g:TVFSGlobs; Error: PPGError): gboolean; cdecl;
+    //  Stop the copy operation - close the archive and free memory (called only in archive mode)
+    TVFSStopCopyOperation = function (g:TVFSGlobs; Error: PPGError): gboolean; cdecl;
 
 
     //  TODO: Prototype function for packing new files into archive
-    TVFSPack = function (g:TVFSGlobs; const sSrcName, sDstName: PChar; CompressionLevel: integer; const Password: PChar): TVFSResult; cdecl;
+    TVFSPack = function (g:TVFSGlobs; const sSrcName, sDstName: PChar; CompressionLevel: integer; const Password: PChar; Error: PPGError): gboolean; cdecl;
 
 
     //  TODO: not implemented at all
@@ -263,14 +247,14 @@ type
     //  There is a TVFSFileDes object which identifies the processed file (filedescriptor)
     //  All these functions needs a pointer to an int variable to store the error code
     //  NOTE: not all modules could support this set of functions due to its design (unable to set a solid block size)
-    TVFSOpenFile = function (g:TVFSGlobs; const APath: PChar; Mode: integer; Error: Pinteger): TVFSFileDes; cdecl;
+    TVFSOpenFile = function (g:TVFSGlobs; const APath: PChar; Mode: integer; Error: PPGError): TVFSFileDes; cdecl;
     //  Opens a file or creates new (the values for the Mode parameter are described above) and returns the assigned filedescriptor
-    TVFSReadFile = function (g:TVFSGlobs; const FileDescriptor: TVFSFileDes; Buffer: Pointer; ABlockSize: integer; Error: Pinteger): integer; cdecl;
+    TVFSReadFile = function (g:TVFSGlobs; const FileDescriptor: TVFSFileDes; Buffer: Pointer; ABlockSize: integer; Error: PPGError): integer; cdecl;
     //  Returns number of bytes read; the buffer needs to be allocated by a blocksize (set it by VFSSetBlockSize function)
-    TVFSWriteFile = function (g:TVFSGlobs; const FileDescriptor: TVFSFileDes; Buffer: Pointer; BytesCount: integer; Error: Pinteger): integer; cdecl;
+    TVFSWriteFile = function (g:TVFSGlobs; const FileDescriptor: TVFSFileDes; Buffer: Pointer; BytesCount: integer; Error: PPGError): integer; cdecl;
     //  Returns number of bytes written
-    TVFSCloseFile = function (g:TVFSGlobs; const FileDescriptor: TVFSFileDes): TVFSResult; cdecl;
-    TVFSFileSeek = function (g:TVFSGlobs; const FileDescriptor: TVFSFileDes; const AbsoluteOffset: Int64; Error: Pinteger): Int64; cdecl;
+    TVFSCloseFile = function (g:TVFSGlobs; const FileDescriptor: TVFSFileDes; Error: PPGError): gboolean; cdecl;
+    TVFSFileSeek = function (g:TVFSGlobs; const FileDescriptor: TVFSFileDes; const AbsoluteOffset: Int64; Error: PPGError): Int64; cdecl;
     //  Sets the position in the file from the start and returns real current position