Từ 1 tới 1 trên tổng số 1 kết quả

Đề tài: Cắt xén tập tin nhị phân bằng Window API

  1. #1
    Ngày gia nhập
    02 2014
    Nơi ở
    TP.HCM
    Bài viết
    715

    Mặc định Cắt xén tập tin nhị phân bằng Window API

    Có bạn hỏi riêng tôi cách sử dụng các hàm API như SetFilePointer, SetEndOfFile để cắt một số Bytes ở đầu, cuối, hay từ 1 offset nào đó trong tập tin.
    Bên dưới là 1 demo nhỏ trả lời cho riêng bạn đã hỏi cũng như cho bạn nào cần.
    Visual C++ Code:
    1. #include<windows.h>
    2. #include<shlwapi.h>
    3. #include"resource.h"
    4. #pragma comment(lib, "shlwapi.lib")
    5.  
    6. class CEdit
    7. {
    8. private:
    9.     HWND        m_hEdit;        // Thẻ cửa sổ Edit
    10.     WNDPROC     m_pSubProc;     // Thủ tục cũ
    11.  
    12.     static LRESULT CALLBACK NewProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
    13.     {
    14.         WNDPROC *   pSubProc = reinterpret_cast<WNDPROC*>(static_cast<LONG_PTR>(GetWindowLongPtr(hwnd, GWLP_USERDATA)));
    15.         if (msg == WM_CHAR)
    16.         {
    17.             if (isalnum(wparam) || wparam == 8)
    18.                 return CallWindowProc(*pSubProc, hwnd, msg, wparam, lparam);
    19.             return 0;
    20.         }
    21.         return CallWindowProc(*pSubProc, hwnd, msg, wparam, lparam);
    22.     }
    23. public:
    24.     __declspec(property(get = getHwnd)) HWND Hwnd;
    25.     HWND getHwnd() { return m_hEdit; }
    26.     CEdit(HWND hEdit)
    27.     {
    28.         m_hEdit = hEdit;
    29.         m_pSubProc = (WNDPROC)GetWindowLong(m_hEdit, GWL_WNDPROC);
    30.         SetWindowLong(m_hEdit, GWL_WNDPROC, (LONG_PTR)NewProc);
    31.         SetWindowLong(m_hEdit, GWLP_USERDATA, PtrToUlong(&m_pSubProc));
    32.     }
    33. };
    34. class CMyDialog
    35. {
    36. private:
    37.     HINSTANCE       m_hInstance;    // Thể hiện chương trình
    38.     HWND            m_hDlgMain;     // Thẻ hộp thoại chính
    39.     HWND            m_hedPath;      // Thẻ điều khiển Edit hiển thị đường dẫn đầy đủ của tập tin
    40.     HWND            m_hedOrgSize1;  // Thẻ điều khiển Edit hiển thị kích thước nguyên thủy tập tin theo Decimal
    41.     HWND            m_hedOrgSize2;  // Thẻ điều khiển Edit hiển thị kích thước nguyên thủy tập tin theo HexaDecimal
    42.     CEdit *         m_hedCutSize1;  // Thẻ điều khiển Edit hiển thị số bytes sẽ cắt theo Decimal
    43.     HWND            m_hedCutSize2;  // Thẻ điều khiển Edit hiển thị số bytes sẽ cắt theo HexaDecimal
    44.     CEdit *         m_hedCutOff1;   // Thẻ điều khiển Edit hiển thị Offset cắt theo Decimal
    45.     HWND            m_hedCutOff2;   // Thẻ điều khiển Edit hiển thị Offset cắt theo HexaDecimal
    46.    
    47.     static BOOL CALLBACK DlgProc(HWND hDlg, UINT msg, WPARAM wparam, LPARAM lparam)
    48.     {
    49.         if (msg == WM_INITDIALOG)
    50.         {
    51.             CMyDialog * pDialog = reinterpret_cast<CMyDialog*>(lparam);
    52.             SetWindowLong(hDlg, GWLP_USERDATA, PtrToUlong(pDialog));
    53.             return pDialog->OnInitDialog(hDlg);
    54.         }
    55.         CMyDialog * pDialog = reinterpret_cast<CMyDialog*>(static_cast<LONG_PTR>(GetWindowLongPtr(hDlg, GWLP_USERDATA)));
    56.         switch (msg)
    57.         {
    58.         case WM_COMMAND:    return pDialog->OnCommand(wparam, lparam);
    59.         case WM_CLOSE:      return pDialog->OnClose();
    60.         }
    61.         return FALSE;
    62.     }
    63.     BOOL OnInitDialog(HWND hDlg)
    64.     {
    65.         // Khởi tạo các biến thành viên
    66.         m_hInstance = (HINSTANCE)GetWindowLong(hDlg, GWLP_HINSTANCE);
    67.         m_hDlgMain = hDlg;
    68.         m_hedPath = GetDlgItem(hDlg, IDC_EDIT_PATH);
    69.         m_hedOrgSize1 = GetDlgItem(hDlg, IDC_EDIT_ORGSIZE1);
    70.         m_hedOrgSize2 = GetDlgItem(hDlg, IDC_EDIT_ORGSIZE2);
    71.         m_hedCutSize1 = new CEdit(GetDlgItem(hDlg, IDC_EDIT_CUTSIZE1));
    72.         m_hedCutSize2 = GetDlgItem(hDlg, IDC_EDIT_CUTSIZE2);
    73.         m_hedCutOff1 = new CEdit(GetDlgItem(hDlg, IDC_EDIT_OFFSET1));
    74.         m_hedCutOff2 = GetDlgItem(hDlg, IDC_EDIT_OFFSET2);
    75.         CheckDlgButton(m_hDlgMain, IDC_RADIO_FIRST, BST_CHECKED);
    76.         SetWindowTextW(m_hedPath, L"Press button <Open...>");
    77.         SetFocus(GetDlgItem(hDlg, IDC_BUTTON_OPEN));
    78.         return FALSE;   // Trả về false vì chúng ta có thiết lập focus
    79.     }
    80.     BOOL OnCommand(WPARAM wparam, LPARAM lparam)
    81.     {
    82.         switch (LOWORD(wparam))
    83.         {
    84.         case IDC_BUTTON_OPEN:   return OnOpen();
    85.         case IDC_BUTTON_CUT:    return OnCut();
    86.         case IDCANCEL:          return OnClose();
    87.         case IDC_RADIO_FIRST:   return OnFirst();
    88.         case IDC_RADIO_LAST:    return OnLast();
    89.         case IDC_RADIO_OFFSET:  return OnOffset();
    90.         case IDC_EDIT_CUTSIZE1: return CutSize_Changed(wparam);
    91.         case IDC_EDIT_OFFSET1:  return OffCut_Changed(wparam);
    92.         }
    93.         return FALSE;
    94.     }
    95.     BOOL OnClose()
    96.     {
    97.         EndDialog(m_hDlgMain, 0);
    98.         return TRUE;
    99.     }
    100.     BOOL OnOpen()
    101.     {
    102.         CHAR            szBuf[MAX_PATH];
    103.         OPENFILENAME    ofn;
    104.  
    105.         szBuf[0] = 0;
    106.         ZeroMemory(&ofn, sizeof(OPENFILENAME));
    107.         ofn.hInstance = m_hInstance;
    108.         ofn.hwndOwner = m_hDlgMain;
    109.         ofn.lpstrFile = szBuf;
    110.         ofn.nMaxFile = sizeof(szBuf);
    111.         ofn.lStructSize = sizeof(OPENFILENAME);
    112.         ofn.lpstrFilter = "All files\0*.*\0";
    113.         ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
    114.         if (!GetOpenFileName(&ofn))
    115.             return TRUE;
    116.         HANDLE  hFile = CreateFile(szBuf, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    117.         if (INVALID_HANDLE_VALUE == hFile)
    118.         {
    119.             MessageBoxW(m_hDlgMain, L"Lỗi từ hàm CreateFile", L"Thất bại", 0);
    120.             return TRUE;
    121.         }
    122.         DWORD   dwSize = GetFileSize(hFile, NULL);
    123.         CloseHandle(hFile);
    124.         if (INVALID_FILE_SIZE == dwSize)
    125.         {
    126.             MessageBoxW(m_hDlgMain, L"Lỗi từ hàm GetFileSize", L"Thất bại", 0);
    127.             return TRUE;
    128.         }
    129.         SetWindowText(m_hedPath, szBuf);
    130.         wsprintf(szBuf, "%d", dwSize);
    131.         SetWindowText(m_hedOrgSize1, szBuf);
    132.         wsprintf(szBuf, "%X", dwSize);
    133.         SetWindowText(m_hedOrgSize2, szBuf);
    134.         return TRUE;
    135.     }
    136.     BOOL OnCut()
    137.     {
    138.         WCHAR   szFile[MAX_PATH];
    139.         WCHAR   szBuf[MAX_PATH];
    140.         CHAR    szTemp[MAX_PATH];
    141.         GetWindowTextW(m_hedPath, szFile, MAX_PATH - 1);
    142.         if (!PathFileExistsW(szFile))
    143.         {
    144.             wsprintfW(szBuf, L"Tập tin \"%s\" không có sẵn", szFile);
    145.             MessageBoxW(m_hDlgMain, szBuf, L"Thất bại", 0);
    146.             SetFocus(m_hedPath);
    147.             return TRUE;
    148.         }
    149.         // Phải kiểm tra lại vì có thể tập tin đã thay đổi
    150.         HANDLE  hFile = CreateFileW(szFile, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    151.         if (INVALID_HANDLE_VALUE == hFile)
    152.         {
    153.             MessageBoxW(m_hDlgMain, L"Lỗi từ hàm CreateFile", L"Thất bại", 0);
    154.             return TRUE;
    155.         }
    156.         DWORD   dwSize = GetFileSize(hFile, NULL);
    157.         if (INVALID_FILE_SIZE == dwSize)
    158.         {
    159.             CloseHandle(hFile);
    160.             MessageBoxW(m_hDlgMain, L"Lỗi từ hàm GetFileSize", L"Thất bại", 0);
    161.             return TRUE;
    162.         }
    163.         wsprintfW(szBuf, L"%d", dwSize);
    164.         SetWindowTextW(m_hedOrgSize1, szBuf);
    165.         wsprintfW(szBuf, L"%X", dwSize);
    166.         SetWindowTextW(m_hedOrgSize2, szBuf);
    167.         //
    168.         int     nLen = GetWindowTextLength(m_hedCutSize1->Hwnd);
    169.         if (!nLen)
    170.         {
    171.             CloseHandle(hFile);
    172.             MessageBoxW(m_hDlgMain, L"Kích thước cắt không giá trị", L"Thất bại", 0);
    173.             SetFocus(m_hedCutSize1->Hwnd);
    174.             return TRUE;
    175.         }
    176.         GetWindowText(m_hedCutSize1->Hwnd, szTemp, nLen + 1);
    177.         DWORD   dwCut = atoi(szTemp);
    178.         if (!dwCut)
    179.         {
    180.             CloseHandle(hFile);
    181.             MessageBoxW(m_hDlgMain, L"Kích thước cắt = 0", L"Thất bại", 0);
    182.             SetFocus(m_hedCutSize1->Hwnd);
    183.             return TRUE;
    184.         }
    185.         //
    186.         if (dwCut > dwSize)
    187.         {
    188.             CloseHandle(hFile);
    189.             MessageBoxW(m_hDlgMain, L"Kích thước cắt > Kích thước tập tin", L"Thất bại", 0);
    190.             SetFocus(m_hedCutSize1->Hwnd);
    191.             return TRUE;
    192.         }
    193.         //
    194.         BOOL    bCut;
    195.         if (BST_CHECKED == IsDlgButtonChecked(m_hDlgMain, IDC_RADIO_FIRST))
    196.             bCut = CutFirst(hFile, dwSize, dwCut);
    197.         else if (BST_CHECKED == IsDlgButtonChecked(m_hDlgMain, IDC_RADIO_LAST))
    198.             bCut = CutLast(hFile, dwSize, dwCut);
    199.         else
    200.         {
    201.             nLen = GetWindowTextLength(m_hedCutOff1->Hwnd);
    202.             if (!nLen)
    203.             {
    204.                 CloseHandle(hFile);
    205.                 MessageBoxW(m_hDlgMain, L"Offset cắt không giá trị", L"Thất bại", 0);
    206.                 SetFocus(m_hedCutOff1->Hwnd);
    207.                 return TRUE;
    208.             }
    209.             GetWindowText(m_hedCutOff1->Hwnd, szTemp, nLen + 1);
    210.             DWORD   dwOffset = atoi(szTemp);
    211.             if (dwOffset == 0)
    212.             {
    213.                 bCut = CutFirst(hFile, dwSize, dwCut);
    214.             }
    215.             else
    216.             {
    217.                 if (dwOffset + dwCut > dwSize)
    218.                 {
    219.                     CloseHandle(hFile);
    220.                     MessageBoxW(m_hDlgMain, L"Offset cắt + Kích thước cắt > Kích thước tập tin", L"Thất bại", 0);
    221.                     SetFocus(m_hedCutOff1->Hwnd);
    222.                     return TRUE;
    223.                 }
    224.                 bCut = CutOffset(hFile, dwSize, dwCut, dwOffset);
    225.             }
    226.         }
    227.         CloseHandle(hFile);
    228.         if (bCut)
    229.         {
    230.             wsprintf(szTemp, "%d", dwSize - dwCut);
    231.             SetWindowText(m_hedOrgSize1, szTemp);
    232.             wsprintf(szTemp, "%X", dwSize - dwCut);
    233.             SetWindowText(m_hedOrgSize2, szTemp);
    234.             MessageBoxW(m_hDlgMain, L"Đã cắt thành công", L"Thành công", 0);
    235.         }
    236.         return TRUE;
    237.     }
    238.     BOOL OnFirst()
    239.     {
    240.         if (BST_CHECKED == IsDlgButtonChecked(m_hDlgMain, IDC_RADIO_FIRST))
    241.         {
    242.             EnableWindow(m_hedCutOff1->Hwnd, FALSE);
    243.             EnableWindow(m_hedCutOff2, FALSE);
    244.         }
    245.         return TRUE;
    246.     }
    247.     BOOL OnLast()
    248.     {
    249.         if (BST_CHECKED == IsDlgButtonChecked(m_hDlgMain, IDC_RADIO_LAST))
    250.         {
    251.             EnableWindow(m_hedCutOff1->Hwnd, FALSE);
    252.             EnableWindow(m_hedCutOff2, FALSE);
    253.         }
    254.         return TRUE;
    255.     }
    256.     BOOL OnOffset()
    257.     {
    258.         if (BST_CHECKED == IsDlgButtonChecked(m_hDlgMain, IDC_RADIO_OFFSET))
    259.         {
    260.             EnableWindow(m_hedCutOff1->Hwnd, TRUE);
    261.             EnableWindow(m_hedCutOff2, TRUE);
    262.         }
    263.         return TRUE;
    264.     }
    265.     BOOL CutFirst(HANDLE hFile, DWORD dwSize, DWORD dwCut)
    266.     {
    267.         DWORD   dwMove = dwSize - dwCut;
    268.         PBYTE   pBytes = new BYTE[dwMove];
    269.         if (!pBytes)
    270.         {
    271.             MessageBoxW(m_hDlgMain, L"Lỗi cấp phát bộ nhớ", L"Kết quả", 0);
    272.             return FALSE;
    273.         }
    274.         DWORD   dw;
    275.         SetFilePointer(hFile, dwCut, 0, FILE_BEGIN);
    276.         BOOL bRead = ReadFile(hFile, pBytes, dwMove, &dw, NULL);
    277.         if (!bRead || dw != dwMove)
    278.         {
    279.             MessageBoxW(m_hDlgMain, L"Lỗi từ hàm ReadFile", L"Kết quả", 0);
    280.             return FALSE;
    281.         }
    282.         SetFilePointer(hFile, 0, 0, FILE_BEGIN);
    283.         BOOL bWrite = WriteFile(hFile, pBytes, dwMove, &dw, NULL);
    284.         delete[] pBytes;
    285.         SetFilePointer(hFile, dwMove, 0, FILE_BEGIN);
    286.         SetEndOfFile(hFile);
    287.         if (!bWrite || dw != dwMove)
    288.         {
    289.             MessageBoxW(m_hDlgMain, L"Lỗi từ hàm WriteFile", L"Kết quả", 0);
    290.             return FALSE;
    291.         }
    292.         return TRUE;
    293.     }
    294.     BOOL CutLast(HANDLE hFile, DWORD dwSize, DWORD dwCut)
    295.     {
    296.         SetFilePointer(hFile, dwSize - dwCut, 0, FILE_BEGIN);
    297.         SetEndOfFile(hFile);
    298.         return TRUE;
    299.     }
    300.     BOOL CutOffset(HANDLE hFile, DWORD dwSize, DWORD dwCut, DWORD dwOffset)
    301.     {
    302.         DWORD   dwMove = dwSize - dwOffset - dwCut;
    303.         PBYTE   pBytes = (PBYTE)malloc(dwMove);
    304.         if (!pBytes)
    305.         {
    306.             MessageBoxW(m_hDlgMain, L"Lỗi cấp phát bộ nhớ", L"Kết quả", 0);
    307.             return FALSE;
    308.         }
    309.         DWORD   dw;
    310.         SetFilePointer(hFile, dwOffset + dwCut, 0, FILE_BEGIN);
    311.         BOOL bRead = ReadFile(hFile, pBytes, dwMove, &dw, NULL);
    312.         if (!bRead || dw != dwMove)
    313.         {
    314.             MessageBoxW(m_hDlgMain, L"Lỗi từ hàm ReadFile", L"Kết quả", 0);
    315.             return FALSE;
    316.         }
    317.         SetFilePointer(hFile, dwOffset, 0, FILE_BEGIN);
    318.         BOOL bWrite = WriteFile(hFile, pBytes, dwMove, &dw, NULL);
    319.         delete[] pBytes;
    320.         SetFilePointer(hFile, dwOffset + dwMove, 0, FILE_BEGIN);
    321.         SetEndOfFile(hFile);
    322.         if (!bWrite || dw != dwMove)
    323.         {
    324.             MessageBoxW(m_hDlgMain, L"Lỗi từ hàm WriteFile", L"Kết quả", 0);
    325.             return FALSE;
    326.         }
    327.         return TRUE;
    328.     }
    329.     BOOL CutSize_Changed(WPARAM wparam)
    330.     {
    331.         if (HIWORD(wparam) == EN_CHANGE)
    332.         {
    333.             CHAR    szBuf[MAX_PATH];
    334.             GetWindowText(m_hedCutSize1->Hwnd, szBuf, MAX_PATH - 1);
    335.             wsprintf(szBuf, "%X", atoi(szBuf));
    336.             SetWindowText(m_hedCutSize2, szBuf);
    337.             return TRUE;
    338.         }
    339.         return FALSE;
    340.     }
    341.     BOOL OffCut_Changed(WPARAM wparam)
    342.     {
    343.         if (HIWORD(wparam) == EN_CHANGE)
    344.         {
    345.             CHAR    szBuf[MAX_PATH];
    346.             GetWindowText(m_hedCutOff1->Hwnd, szBuf, MAX_PATH - 1);
    347.             wsprintf(szBuf, "%X", atoi(szBuf));
    348.             SetWindowText(m_hedCutOff2, szBuf);
    349.             return TRUE;
    350.         }
    351.         return FALSE;
    352.     }
    353.    
    354. public:
    355.     CMyDialog()
    356.     {
    357.         m_hInstance = NULL;
    358.         m_hDlgMain = NULL;
    359.         m_hedPath = NULL;
    360.         m_hedOrgSize1 = NULL;
    361.         m_hedOrgSize2 = NULL;
    362.         m_hedCutSize1 = NULL;
    363.         m_hedCutSize2 = NULL;
    364.         m_hedCutOff1 = NULL;
    365.         m_hedCutOff2 = NULL;
    366.     }
    367.     void Show(HINSTANCE hInstance)
    368.     {
    369.         DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, DlgProc, (LPARAM)this);
    370.     }
    371. };
    372. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrev, LPSTR pCmd, int nShow)
    373. {
    374.     CMyDialog   hDlg;
    375.     hDlg.Show(hInstance);
    376.     return 0;
    377. }
    Chương trình viết trên VS2015 từ kiểu dự án trống, không thiết lập Unicode trên dự án nhưng có sử dụng các API thao tác với chuỗi Unicode.
    Attached Files Attached Files
    Yêu mã hơn yêu em !!!

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn