This code appears to perform a file copy operation from...

February 4, 2025 at 03:59 PM

ulonglong FUN_1400022a0(LPCSTR param_1,LPCSTR param_2)

{
  BOOL BVar1;
  undefined8 uVar2;
  HANDLE hFile;
  uint uVar3;
  uint uVar5;
  ulonglong uVar6;
  DWORD local_res18 [4];
  undefined4 local_38;
  undefined4 uStack_34;
  undefined4 uStack_30;
  undefined4 uStack_2c;
  undefined local_28 [16];
  ulonglong uVar4;
  
  local_38 = 0xffffffff;
  uStack_34 = 0xffffffff;
  uStack_30 = 0;
  uStack_2c = 0;
  local_28 = ZEXT816(0);
  uVar2 = FUN_140002070((HANDLE *)&local_38,param_1,0);
  uVar6 = 0;
  if (((int)uVar2 != 0) &&
     (hFile = CreateFileA(param_2,0x40000000,0,(LPSECURITY_ATTRIBUTES)0x0,2,0,(HANDLE)0x0),
     hFile != (HANDLE)0xffffffffffffffff)) {
    uVar5 = local_28._8_4_;
    FUN_140002240((byte *)local_28._0_8_,uVar5,0);
    uVar4 = uVar6;
    do {
      local_res18[0] = 0;
      BVar1 = WriteFile(hFile,(LPCVOID)(uVar4 + local_28._0_8_),uVar5 - (int)uVar4,local_res18,
                        (LPOVERLAPPED)0x0);
      if (BVar1 == 0) {
        CloseHandle(hFile);
        DeleteFileA(param_2);
        goto LAB_1400023b0;
      }
      uVar3 = (int)uVar4 + local_res18[0];
      uVar4 = (ulonglong)uVar3;
    } while (uVar3 < uVar5);
    CloseHandle(hFile);
    uVar6 = 1;
  }
LAB_1400023b0:
  if ((LPCVOID)local_28._0_8_ != (LPCVOID)0x0) {
    UnmapViewOfFile((LPCVOID)local_28._0_8_);
  }
  if ((HANDLE)CONCAT44(uStack_2c,uStack_30) != (HANDLE)0x0) {
    CloseHandle((HANDLE)CONCAT44(uStack_2c,uStack_30));
  }
  if ((HANDLE)CONCAT44(uStack_34,local_38) != (HANDLE)0x0) {
    CloseHandle((HANDLE)CONCAT44(uStack_34,local_38));
  }
  return uVar6;
}

This code appears to perform a file copy operation from a source file (param_1) to a destination file (param_2) using memory-mapped file techniques in a Windows environment. Here's a breakdown of what it does:

Initialization:
- Several variables (like local_38, local_28, etc.) are initialized. In particular, local_38 is used to hold a file handle for the source file, while local_28 assists in memory mapping operations.
Opening and Memory-Mapping the Source File:
- FUN_140002070 is called with the source filename (param_1). This function presumably opens the source file and prepares it for memory mapping, returning some status (uVar2).
- If the source file cannot be opened successfully (uVar2 is 0), the function proceeds to clean up and exit early with a return value of 0.
Creating the Destination File:
- The CreateFileA function is used to create the destination file (param_2) with write access (0x40000000), no sharing, and opening it in CREATE_ALWAYS mode (i.e., always create a new file, even if it already exists).
- If the destination file cannot be created (hFile == INVALID_HANDLE_VALUE), the function proceeds to clean up and exit early with a return value of 0.
Copying Data:
- FUN_140002240 is called to map the source file into memory. Presumably, it populates local_28._0_8_ (the starting address of the mapped memory) and local_28._8_4_ (the size of the mapped file in bytes).
- A do-while loop then writes the contents of the source file to the destination file in chunks using the WriteFile function.
- If any WriteFile operation fails, the function deletes the partially created destination file (DeleteFileA(param_2)), closes the handle to the destination file, and exits with 0.
- The loop continues until all bytes of the source file have been written to the destination file.
Cleaning Up:
- After the copy operation is complete, handles to the files are closed using CloseHandle.
- If the memory-mapped view of the source file is still active (local_28._0_8_), it is unmapped using UnmapViewOfFile.
- The function also ensures all file handles initialized earlier are closed properly.
Return Value:
- The function returns 1 if the copy operation is successful.
- It returns 0 if the operation fails at any point.

In Summary:

This function attempts to copy a file (param_1) to a new file (param_2) using memory-mapped file techniques. It performs error-checking at each step (opening the source file, creating the destination file, writing data) and cleans up used resources appropriately. If successful, the function returns 1; otherwise, it returns 0.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr