// par1.c // Copyright : 2024-11-30 Yutaka Sawada // License : GPL #ifndef _UNICODE #define _UNICODE #endif #ifndef UNICODE #define UNICODE #endif #ifndef _WIN32_WINNT #define _WIN32_WINNT 0x0601 // Windows 7 or later #endif #include #include #include #include "common1.h" #include "phmd5.h" #include "md5_1.h" #include "ini.h" #include "par1.h" #include "version.h" /* Fast Galois Field Arithmetic Library in C/C++ Copright (C) 2007 James S. Plank */ #include "gf8.h" /* // 行列の表示用関数 void galois_print_matrix(int *matrix, int rows, int cols) { int i, j; printf("\n"); for (i = 0; i < rows; i++) { for (j = 0; j < cols; j++) { printf("%4d", matrix[i*cols+j]); } printf("\n"); } } */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* gflib の行列作成用関数や行列の逆変換用の関数を元にして、 計算のやり方を PAR 1.0 用に修正する。 par-v1.1.tar.gz に含まれる rs.doc Dummies guide to Reed-Solomon coding. を参考にする 解説ではパリティ計算用の行列の要素、掛ける値は F(i,j) = i^(j-1) ・・・ i の (j-1) 乗 ソース・ブロックは i = 1～N で、 パリティ・ブロックは j = 1～M になってる。 実際に計算する関数では ソース・ブロックが i = 0 ～ cols - 1 で、 パリティ・ブロックが j = 0 ～ rows - 1 なので、 理論のF(i,j) = F(i+1, j+1) = (i+1) ^ (j+1-1) = (i+1) ^ j ・・・ (i+1) の j 乗 */ // PAR 1.0 のパリティ作成用の行列 int * make_encode_matrix( int rows, // 横行、パリティのブロック数 int cols, // 縦列、ソースのブロック数 int first) // 最初のパリティ・ブロック番号 { int *mat, i, j; mat = malloc(sizeof(int) * rows * cols); if (mat == NULL){ printf("malloc, %d\n", sizeof(int) * rows * cols); return NULL; } for (j = 0; j < rows; j++){ for (i = 0; i < cols; i++) mat[cols * j + i] = galois_power(i + 1, first + j); } return mat; } /* 失われたソース・ブロックの数 = 利用するパリティ・ブロックの数を縦行とし、 ソース・ブロックの数を横列とする長方形の行列を作る。 例えば、ソース・ブロックを A, B, C, D, E 、 そのパリティ・ブロックを X, Y, Z とする。 その場合の関係式は次のようになる。 1: 1*A xor 1*B xor 1*C xor 1*D xor 1*E = X 2: 1*A xor 2*B xor 3*C xor 4*D xor 5*E = Y 3: 1*A xor 4*B xor 5*C xor 16*D xor 17*E = Z これは PARファイルを作成する際の行列と同じ。 1 1 1 1 1 1 2 3 4 5 1 4 5 16 17 ここで、B, C, D の三ブロックが失われて、それぞれを X, Y, Z で補うなら、 その状態は次のような関係式になる。 1: 1*A xor 1*B xor 1*C xor 1*D xor 1*E = 0*A xor 1*X xor 0*Y xor 0*Z xor 0*E 2: 1*A xor 2*B xor 3*C xor 4*D xor 5*E = 0*A xor 0*X xor 1*Y xor 0*Z xor 0*E 3: 1*A xor 4*B xor 5*C xor 16*D xor 17*E = 0*A xor 0*X xor 0*Y xor 1*Z xor 0*E 左：パリティ・ブロックの係数 1 1 1 1 1 1 2 3 4 5 1 4 5 16 17 右：そのパリティ・ブロックがどのソース・ブロックの位置にくるか 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 ここでまず、存在するソース・ブロックの列を 0にする。 1: 0*A xor 1*B xor 1*C xor 1*D xor 0*E = 1*A xor 1*X xor 0*Y xor 0*Z xor 1*E 2: 0*A xor 2*B xor 3*C xor 4*D xor 0*E = 1*A xor 0*X xor 1*Y xor 0*Z xor 5*E 3: 0*A xor 4*B xor 5*C xor 16*D xor 0*E = 1*A xor 0*X xor 0*Y xor 1*Z xor 17*E 左：ソース・ブロックが存在した所が 0になる 0 1 1 1 0 0 2 3 4 0 0 4 5 16 0 右：逆にこちらではソース・ブロックが存在した所が反転する 1 1 0 0 1 1 0 1 0 5 1 0 0 1 17 Gaussian Elimination (ガウスの消去法) で元の左の行列を右のに変換する 各行で 0でない値を探して、それが 1になるように、何倍かする。 まずは 1行目： 1: 0*A xor 1*B xor 1*C xor 1*D xor 0*E = 1*A xor 1*X xor 0*Y xor 0*Z xor 1*E 1 行目の 2列目は 1なのでそのまま。 他の行の同じ列に 0でない値があれば、それを 0にするために、 行を何倍かしたものを XOR する 2: 0*A xor 2*B xor 3*C xor 4*D xor 0*E = 1*A xor 0*X xor 1*Y xor 0*Z xor 5*E 2 行目の 2列目は 2なので、1行目の各値を 2倍したものを XOR する。 3: 0*A xor 4*B xor 5*C xor 16*D xor 0*E = 1*A xor 0*X xor 0*Y xor 1*Z xor 17*E 3 行目の 2列目は 4なので、1行目の各値を 4倍したものを XOR する。 1: 0*A xor 1*B xor 1*C xor 1*D xor 0*E = 1*A xor 1*X xor 0*Y xor 0*Z xor 1*E 2: 0*A xor 0*B xor 1*C xor 6*D xor 0*E = 3*A xor 2*X xor 1*Y xor 0*Z xor 7*E 3: 0*A xor 0*B xor 1*C xor 20*D xor 0*E = 5*A xor 4*X xor 0*Y xor 1*Z xor 21*E 次は 2行目： 2: 0*A xor 0*B xor 1*C xor 6*D xor 0*E = 3*A xor 2*X xor 1*Y xor 0*Z xor 7*E 2 行目の 3列目は 1なのでそのまま。 1: 0*A xor 1*B xor 1*C xor 1*D xor 0*E = 1*A xor 1*X xor 0*Y xor 0*Z xor 1*E 1 行目の 3列目は 1なので、1行目の各値をそのまま XOR する。 3: 0*A xor 0*B xor 1*C xor 20*D xor 0*E = 5*A xor 4*X xor 0*Y xor 1*Z xor 21*E 3 行目の 3列目は 1なので、1行目の各値をそのまま XOR する。 1: 0*A xor 1*B xor 0*C xor 7*D xor 0*E = 2*A xor 3*X xor 1*Y xor 0*Z xor 6*E 2: 0*A xor 0*B xor 1*C xor 6*D xor 0*E = 3*A xor 2*X xor 1*Y xor 0*Z xor 7*E 3: 0*A xor 0*B xor 0*C xor 18*D xor 0*E = 6*A xor 6*X xor 1*Y xor 1*Z xor 18*E 次は 3行目： 3: 0*A xor 0*B xor 0*C xor 18*D xor 0*E = 6*A xor 6*X xor 1*Y xor 1*Z xor 18*E 3 行目の 4列目は 18なので、18で割る 1: 0*A xor 1*B xor 0*C xor 7*D xor 0*E = 2*A xor 3*X xor 1*Y xor 0*Z xor 6*E 1 行目の 4列目は 7なので、1行目の各値を 7倍したものを XOR する。 2: 0*A xor 0*B xor 1*C xor 6*D xor 0*E = 3*A xor 2*X xor 1*Y xor 0*Z xor 7*E 2 行目の 4列目は 6なので、1行目の各値を 6倍したものを XOR する。 1: 0*A xor 1*B xor 0*C xor 0*D xor 0*E = 3*A xor 2*X xor 123*Y xor 122*Z xor 1*E 2: 0*A xor 0*B xor 1*C xor 0*D xor 0*E = 184*A xor 185*X xor 187*Y xor 186*Z xor 1*E 3: 0*A xor 0*B xor 0*C xor 1*D xor 0*E = 186*A xor 186*X xor 192*Y xor 192*Z xor 1*E 左：元の右の行列と同じになってる 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 右：これが失われたソース・ブロックを復元するための行列となる 3 2 123 122 1 184 185 187 186 1 186 186 192 192 1 */ // 復元用の行列を作る、十分な数のパリティ・ブロックが必要 int * make_decode_matrix( int parity_max, // 本来のパリティ・ブロックの数 int rows, // 横行、行列の縦サイズ、失われたソース・ブロックの数 = 利用するパリティ・ブロック数 int cols, // 縦列、行列の横サイズ、本来のソース・ブロック数 int *exist, // どのブロックが存在するか int *id) // 失われたソース・ブロックをどのパリティ・ブロックで代用したか { int *mat_max, *mat_l, *mat_r; int factor, row_start, row_start2, col_find, i, j, k; // 失われたソース・ブロックをどのパリティ・ブロックで代用するか j = 0; for (i = 0; i < cols; i++){ id[i] = i; if (exist[i] == 0){ // ソース・ブロックが存在しない所 while (j < parity_max){ if (exist[cols + j] != 0){ // その番号のパリティ・ブロックが存在すれば id[i] = cols + j; j++; break; } else { j++; } } if (id[i] < cols){ printf("\nneed more parity volume\n"); return NULL; // パリティ・ブロックの数が足りなければ } } } // 全てのパリティ・ブロックが存在すると仮定した行列を作る mat_max = make_encode_matrix(parity_max, cols, 0); if (mat_max == NULL) return NULL; // 存在して利用するパリティ・ブロックだけの行列を作る mat_l = malloc(sizeof(int) * rows * cols); if (mat_l == NULL) { free(mat_max); printf("malloc, %d\n", sizeof(int) * rows * cols); return NULL; } j = 0; for (i = 0; i < cols; i++){ if (id[i] >= cols){ for (k = 0; k < cols; k++) mat_l[cols * j + k] = mat_max[cols * (id[i] - cols) + k]; j++; } } free(mat_max); //printf("\nLeft :\n"); //galois_print_matrix(mat_l, rows, cols); // 失われたソース・ブロックと代用するパリティ・ブロックの位置を表す行列を作る mat_r = (int *)calloc(rows * cols, sizeof(int)); if (mat_r == NULL){ free(mat_l); printf("calloc, %d\n", sizeof(int) * rows * cols); return NULL; } j = 0; for (i = 0; i < cols; i++){ if (id[i] >= cols){ // j = 行番号 // id[i] = その行を補ったパリティ・ブロックの番号 // i = その行のソース・ブロック番号 mat_r[cols * j + i] = 1; j++; } } //printf("\nRight :\n"); //galois_print_matrix(mat_r, rows, cols); // mat_l の存在するソース・ブロックの列を 0 にするような値で XOR する for (i = 0; i < cols; i++){ if (exist[i] != 0){ // ソース・ブロックが存在する列 for (j = 0; j < rows; j++){ // 行ごとに factor = mat_l[cols * j + i]; // j 行の i 列の値 mat_l[cols * j + i] = 0; // mat_l[cols * j + i] ^= factor; と同じ mat_r[cols * j + i] ^= factor; } } } //printf("\nErase source block :\n"); //galois_print_matrix(mat_l, rows, cols); //printf("\n"); //galois_print_matrix(mat_r, rows, cols); // Gaussian Elimination for (j = 0; j < rows; j++){ row_start = cols * j; // その行の開始位置 // mat_l の各行ごとに最初の 0でない値を探す for (col_find = 0; col_find < cols; col_find++){ if (mat_l[row_start + col_find] != 0) break; } if (col_find == cols){ // 見つからなければ、その行列の逆行列を計算できない printf("\nmatrix is not invertible\n"); k = 0; for (i = 0; i < cols; i++){ if (id[i] >= cols){ if (k == j){ printf(" parity volume %u is useless\n", (1 + id[i] - cols)); break; } k++; } } free(mat_l); free(mat_r); return NULL; } factor = mat_l[row_start + col_find]; // col_find 列に 0 ではない値を発見 if (factor != 1){ // factor が 1でなければ、1にする為に factor で割る for (k = 0; k < cols; k++){ mat_l[row_start + k] = galois_multtable_divide(mat_l[row_start + k], factor); mat_r[row_start + k] = galois_multtable_divide(mat_r[row_start + k], factor); } } // 別の行の同じ col_find 列が 0以外なら、その値を 0にするために、 // j 行を何倍かしたものを XOR する for (i = 0; i < rows; i++){ if (i == j) continue; // 同じ行はとばす row_start2 = cols * i; // その行の開始位置 factor = mat_l[row_start2 + col_find]; // i 行の col_find 列の値 if (factor != 0){ // 0でなければ // 先の計算により、j 行の col_find 列の値は必ず 1なので、この factor が倍率になる if (factor == 1){ // 倍率が 1なら、単純に XOR するだけ for (k = 0; k < cols; k++){ mat_l[row_start2 + k] ^= mat_l[row_start + k]; mat_r[row_start2 + k] ^= mat_r[row_start + k]; } } else { for (k = 0; k < cols; k++){ mat_l[row_start2 + k] ^= galois_multtable_multiply(mat_l[row_start + k], factor); mat_r[row_start2 + k] ^= galois_multtable_multiply(mat_r[row_start + k], factor); } } } } //printf("\nDivide & Eliminate :\n"); //galois_print_matrix(mat_l, rows, cols); //printf("\n"); //galois_print_matrix(mat_r, rows, cols); } free(mat_l); return mat_r; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #define CHUNK_SIZE 65536 typedef struct { HANDLE hFile; // ファイル・ハンドル __int64 size; // ファイルの残りサイズ } file_ctx; // リード・ソロモン符号を使ってエンコードする int rs_encode( int source_num, // ソース・ブロックの数 __int64 block_size, // ブロック・サイズ (最大ファイル・サイズ) int parity_num, // パリティ・ブロックの数 int first_num, // 最初のパリティ・ブロック番号 file_ctx *files, HANDLE *par_hFile, PHMD5 *par_md5) { unsigned char *buffer, *block = NULL; int err = 0, i, j; int *mat = NULL, factor; unsigned int io_size, unit_size, len, rv; unsigned int k, offset, length, chunk_count; unsigned int time_last, prog_num = 0, prog_base; __int64 block_left; //unsigned int time1; // 利用できるメモリー量を調べる io_size = get_mem_size(block_size * (__int64)(source_num + parity_num)); if (io_size > 1048576 * 2) io_size -= (parity_num * source_num) * 4 + 1048576; // 行列に必要なメモリーとスタック用に 1MB if (io_size < 1048576) io_size = 1048576; io_size /= source_num + 1; // 何個分必要か // ブロック・サイズより大きい、またはブロック・サイズ自体が小さい場合は if (((__int64)io_size >= block_size) || (block_size <= 4096)){ io_size = (unsigned int)block_size; // ブロック・サイズと同じにする } else { // ブロック・サイズを 2の乗数サイズの断片に分割する // 断片化する場合でもブロック数が多いと 256 * 4096 = 1MB は使う __int64 fragment_size = 4096; // 最低サイズ while (fragment_size * 2 <= (__int64)io_size) fragment_size *= 2; io_size = (unsigned int)fragment_size; } io_size = (io_size + 3) & 0xFFFFFFFC; // 4の倍数にする unit_size = io_size + HASH_SIZE; // チェックサムの分だけ増やす prog_base = (unsigned int)((block_size + (__int64)io_size - 1) / (__int64)io_size) * parity_num; // 全体の断片の個数 //printf("io_size = %d, prog_base = %d\n", io_size, prog_base); block_left = block_size; if (galois_create_mult_tables() < 0){ printf("galois_create_mult_tables\n"); return 1; } // 作業バッファーを確保する block = malloc(unit_size * (source_num + 1)); if (block == NULL){ printf("malloc, %d\n", unit_size * (source_num + 1)); err = 1; goto error_end; } buffer = block + unit_size; // パリティ計算用の行列演算の準備をする mat = make_encode_matrix(parity_num, source_num, first_num); // 変換行列 if (mat == NULL){ err = 1; goto error_end; } //galois_print_matrix(mat, parity_num, source_num); // chunk がキャッシュに収まるようにすれば速くなる！ (ストリップマイニングという最適化手法) // CPU L2キャッシュ・サイズが 256KB として、1/4 なら 64KB // chunk サイズが 2**16 なので分割数は 1～65536 の範囲になる chunk_count = (unit_size + CHUNK_SIZE - 1) / CHUNK_SIZE; //printf("split count = %d, chunk size = %d\n", chunk_count, CHUNK_SIZE); //time1 = GetTickCount(); // バッファー・サイズごとにパリティ・ブロックを作成する time_last = GetTickCount(); while (block_left > 0){ // バッファーにソース・ファイルの内容を読み込む for (i = 0; i < source_num; i++){ if (files[i].size > 0){ if (files[i].size < io_size){ len = (unsigned int)(files[i].size); } else { len = io_size; } files[i].size -= len; if (!ReadFile(files[i].hFile, buffer + (unit_size * i), len, &rv, NULL) || (len != rv)){ print_win32_err(); printf("ReadFile, data file %d\n", i); err = 1; goto error_end; } if (len < io_size) memset(buffer + (unit_size * i + len), 0, io_size - len); // ソース・ブロックのチェックサムを計算する checksum4(buffer + (unit_size * i), buffer + (unit_size * i + io_size), io_size); } else { // ソース・ブロックの値が全て 0 なら、チェックサムも 0 になる。 memset(buffer + (unit_size * i), 0, unit_size); } } // バッファーに読み込んだサイズ if (block_left < io_size){ len = (unsigned int)block_left; } else { len = io_size; } block_left -= len; // パリティ・ブロックごとに for (i = 0; i < parity_num; i++){ /* without strip mining memset(block, 0, unit_size); // パリティ・ブロックを 0で埋める // ソース・ブロックごとにパリティを追加していく for (j = 0; j < source_num; j++){ factor = mat[i * source_num + j]; if (factor == 1){ galois_region_xor(buffer + (unit_size * j), block, unit_size); } else if (factor != 0){ galois_region_multiply(buffer + (unit_size * j), block, unit_size, factor); } } */ length = CHUNK_SIZE; for (k = 0; k < chunk_count; k++){ // chunk の番号 offset = k * CHUNK_SIZE; if (offset + length >= unit_size){ // 最後の chunk なら length = unit_size - offset; k = chunk_count; } memset(block + offset, 0, length); // パリティ・ブロックを 0で埋める // ソース・ブロックごとにパリティを追加していく for (j = 0; j < source_num; j++){ factor = mat[i * source_num + j]; if (factor == 1){ galois_region_xor(buffer + (unit_size * j + offset), block + offset, length); } else if (factor != 0){ galois_region_multiply(buffer + (unit_size * j + offset), block + offset, length, factor); } } } // 経過表示 prog_num++; if (GetTickCount() - time_last >= UPDATE_TIME){ if (print_progress((prog_num * 1000) / prog_base)){ err = 2; goto error_end; } time_last = GetTickCount(); } // パリティ・ブロックのチェックサムを検証する checksum4(block, (unsigned char *)&rv, io_size); if (memcmp(block + io_size, &rv, HASH_SIZE) != 0){ printf("checksum mismatch, parity volume %d\n", i); err = 1; goto error_end; } Phmd5Process(&(par_md5[i]), block, len); // ハッシュ値を計算する // リカバリ・ファイルへ書き込む if (!WriteFile(par_hFile[i], block, len, &rv, NULL)){ print_win32_err(); printf("WriteFile, parity volume %d\n", first_num + 1 + i); err = 1; goto error_end; } } } print_progress_done(); // 改行して行の先頭に戻しておく //time1 = GetTickCount() - time1; //printf("encode %u.%03u sec\n", time1 / 1000, time1 % 1000); error_end: if (block) free(block); if (mat) free(mat); // gflib のテーブルを解放する galois_free_tables(); return err; } // リード・ソロモン符号を使ってデコードする int rs_decode( int source_num, // 本来のソース・ブロックの数 int block_lost, // 失われたソース・ブロックの数 __int64 block_size, // ブロック・サイズ (最大ファイル・サイズ) int parity_max, // 本来のパリティ・ブロックの数 int *exist, // そのブロックが存在するか file_ctx *files) { unsigned char *buffer, *block = NULL; int err = 0, i, j; int *mat = NULL, *id = NULL, factor; int block_recover; unsigned int io_size, unit_size, len, rv, len2; unsigned int k, offset, length, chunk_count; unsigned int time_last, prog_num = 0, prog_base; __int64 block_left; // 利用できるメモリー量を調べる io_size = get_mem_size(block_size * (__int64)(source_num + block_lost)); io_size -= (block_lost * source_num * 8) + (parity_max * source_num * 4) + (source_num * 4); io_size -= 1048576; // 行列に必要なメモリーとスタック用に 1MB if (io_size < 1048576) io_size = 1048576; io_size /= source_num + 1; // 何個分必要か // ブロック・サイズより大きい、またはブロック・サイズ自体が小さい場合は if (((__int64)io_size >= block_size) || (block_size <= 4096)){ io_size = (unsigned int)block_size; // ブロック・サイズと同じにする } else { // ブロック・サイズを 2の乗数サイズの断片に分割する // 断片化する場合でもブロック数が多いと 256 * 4096 = 1MB は使う __int64 fragment_size = 4096; // 最低サイズ while (fragment_size * 2 <= (__int64)io_size) fragment_size *= 2; io_size = (unsigned int)fragment_size; } io_size = (io_size + 3) & 0xFFFFFFFC; // 4の倍数にする unit_size = io_size + HASH_SIZE; // チェックサムの分だけ増やす prog_base = (unsigned int)((block_size + (__int64)io_size - 1) / (__int64)io_size) * block_lost; // 全体の断片の個数 //printf("io_size = %d\n", io_size); block_left = block_size; if (galois_create_mult_tables() < 0){ printf("galois_create_mult_tables\n"); return 1; } // 作業バッファーを確保する block = malloc(unit_size * (source_num + 1)); if (block == NULL){ printf("malloc, %d\n", unit_size * (source_num + 1)); err = 1; goto error_end; } buffer = block + unit_size; // パリティ計算用の行列演算の準備をする id = malloc(sizeof(int) * source_num); if (id == NULL){ printf("malloc, %d\n", sizeof(int) * source_num); err = 1; goto error_end; } mat = make_decode_matrix(parity_max, block_lost, source_num, exist, id); if (mat == NULL){ err = 1; goto error_end; } //galois_print_matrix(mat, block_lost, source_num); //for (i = 0; i < source_num; i++) // printf("id[%d] = %d\n", i, id[i]); // chunk サイズが 2**16 なので分割数は 1～65536 の範囲になる chunk_count = (unit_size + CHUNK_SIZE - 1) / CHUNK_SIZE; // バッファー・サイズごとにソース・ブロックを復元する time_last = GetTickCount(); while (block_left > 0){ // バッファーにソース・ファイルとリカバリ・ファイルの内容を読み込む for (i = 0; i < source_num; i++){ //printf("%d: id = %d, exist = %d, size = %I64u \n", i, id[i], exist[id[i]], files[id[i]].size); if (files[id[i]].size > 0){ if (files[id[i]].size < io_size){ len = (unsigned int)(files[id[i]].size); } else { len = io_size; } files[id[i]].size -= len; if (!ReadFile(files[id[i]].hFile, buffer + (unit_size * i), len, &rv, NULL)){ print_win32_err(); printf("ReadFile, data file %d\n", id[i]); err = 1; goto error_end; } else if (len != rv){ printf("ReadFile, data file %d, %d, %d\n", id[i], len, rv); err = 1; goto error_end; } if (len < io_size) memset(buffer + (unit_size * i + len), 0, io_size - len); // ソース・ブロックのチェックサムを計算する checksum4(buffer + (unit_size * i), buffer + (unit_size * i + io_size), io_size); } else { // ソース・ブロックの値が全て 0 なら、チェックサムも 0 になる。 memset(buffer + (unit_size * i), 0, unit_size); } } // バッファーに読み込んだサイズ if (block_left < io_size){ len = (unsigned int)block_left; } else { len = io_size; } block_left -= len; // 失われたソース・ブロックごとに block_recover = 0; for (i = 0; i < source_num; i++){ if (id[i] >= source_num){ // パリティ・ブロックで補った部分 /* without strip mining memset(block, 0, unit_size); // ソース・ブロックを 0で埋める // 失われたソース・ブロックを復元していく for (j = 0; j < source_num; j++) { factor = mat[source_num * block_recover + j]; if (factor == 1){ galois_region_xor(buffer + (unit_size * j), block, unit_size); } else if (factor != 0){ galois_region_multiply(buffer + (unit_size * j), block, unit_size, factor); } } */ length = CHUNK_SIZE; for (k = 0; k < chunk_count; k++){ // chunk の番号 offset = k * CHUNK_SIZE; if (offset + length >= unit_size){ // 最後の chunk なら length = unit_size - offset; k = chunk_count; } memset(block + offset, 0, length); // ソース・ブロックを 0で埋める // 失われたソース・ブロックを復元していく for (j = 0; j < source_num; j++) { factor = mat[source_num * block_recover + j]; if (factor == 1){ galois_region_xor(buffer + (unit_size * j + offset), block + offset, length); } else if (factor != 0){ galois_region_multiply(buffer + (unit_size * j + offset), block + offset, length, factor); } } } // 経過表示 prog_num++; if (GetTickCount() - time_last >= UPDATE_TIME){ if (print_progress((prog_num * 1000) / prog_base)){ err = 2; goto error_end; } time_last = GetTickCount(); } // 復元されたソース・ブロックのチェックサムを検証する checksum4(block, (unsigned char *)&rv, io_size); if (memcmp(block + io_size, &rv, HASH_SIZE) != 0){ printf("checksum mismatch, recovered data file %d\n", i); err = 1; goto error_end; } block_recover++; // ソース・ファイルに書き込むサイズ if (files[i].size < len){ len2 = (unsigned int)(files[i].size); } else { len2 = len; } files[i].size -= len2; // ソース・ファイルへ書き込む if (!WriteFile(files[i].hFile, block, len2, &rv, NULL)){ print_win32_err(); printf("WriteFile, data file %d\n", i); err = 1; goto error_end; } } } } print_progress_done(); // 改行して行の先頭に戻しておく error_end: if (block) free(block); if (id) free(id); if (mat) free(mat); // gflib のテーブルを解放する galois_free_tables(); return err; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // PAR 1.0 のヘッダーを作成する int set_header( unsigned char *buf, file_ctx *files, // ソース・ブロックのハンドルとサイズ int source_num, // ソース・ブロックの数 int file_num, // ソース・ファイルの数 wchar_t *list_buf, // ソース・ファイルのリスト int list_len) // ファイル・リストの文字数 { unsigned char hash[16], hash16[16], set_hash[16 * 256]; unsigned char hash0[16] = {0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04, 0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e}; wchar_t file_path[MAX_LEN], *file_name; int i, off, list_off, len, num = 0; __int64 file_size, total_file_size, prog_now; WIN32_FILE_ATTRIBUTE_DATA AttrData; memset(buf, 0, 96); // Identification String buf[0] = 'P'; buf[1] = 'A'; buf[2] = 'R'; // Version Number i = 0x00010000; // PAR 1.0 memcpy(buf + 8, &i, 4); // "program"-"version"-"subversion"-"subsubversion". buf[12] = PRODUCT_VERSION & 0xF; // subsubversion buf[13] = (PRODUCT_VERSION >> 4) & 0xF; // subversion buf[14] = PRODUCT_VERSION >> 8; // version, ちなみに par-cmdline の最終バージョンは 0.9.0 ? buf[15] = 2; // program, 1=Mirror, 2=PAR, 3=SmartPar, 0&4～=Unknown client // control hash の 16バイトは最後に書き込む // set hash の 16バイトは後で書き込む // volume number はパリティ・ブロックごとに変更する // number of files memcpy(buf + 56, &file_num, 4); // start offset of the file list buf[64] = 0x60; // file list size の 8バイトは後で書き込む // start offset of the data の 8バイトは後で書き込む // data size はパリティ・ブロックならブロック・サイズを書き込む // 合計ファイル・サイズを求める total_file_size = 0; prog_now = 0; list_off = 0; while (list_off < list_len){ // ファイル名を取得する file_name = list_buf + list_off; // サブ・ディレクトリを含まないのでそのまま使う list_off += wcslen(file_name) + 1; wcscpy(file_path, base_dir); wcscat(file_path, file_name); if (!GetFileAttributesEx(file_path, GetFileExInfoStandard, &AttrData)){ print_win32_err(); printf_cp("cannot open input file, %s\n", file_name); return 0; } file_size = ((__int64)(AttrData.nFileSizeHigh) << 32) | (__int64)(AttrData.nFileSizeLow); total_file_size += file_size; } // ここから file list off = 0x0060; list_off = 0; while (list_off < list_len){ // ファイル名を取得する file_name = list_buf + list_off; // サブ・ディレクトリを含まないのでそのまま使う len = wcslen(file_name); list_off += (len + 1); len *= 2; // 文字数からバイト数にする // entry size i = 0x38 + len; memcpy(buf + off, &i, 4); memset(buf + off + 4, 0, 4); off += 8; // status field wcscpy(file_path, base_dir); wcscat(file_path, file_name); if (!GetFileAttributesEx(file_path, GetFileExInfoStandard, &AttrData)){ print_win32_err(); printf_cp("cannot open input file, %s\n", file_name); return 0; } file_size = ((__int64)(AttrData.nFileSizeHigh) << 32) | (__int64)(AttrData.nFileSizeLow); if (file_size > 0){ i = 1; } else { i = 0; // 空のファイルはパリティ計算に含めない } memcpy(buf + off, &i, 4); memset(buf + off + 4, 0, 4); off += 8; // size memcpy(buf + off, &file_size, 8); off += 8; // MD5 hash if (file_size > 0){ // パリティ・ブロック計算用に開く files[num].size = file_size; files[num].hFile = CreateFile(file_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (files[num].hFile == INVALID_HANDLE_VALUE){ print_win32_err(); printf_cp("cannot open input file, %s\n", file_name); return 0; } // MD5 を計算する i = file_md5_total(files[num].hFile, file_size, hash, hash16, total_file_size, &prog_now); if (i != 0){ if (i < 0) return i; printf_cp("file_md5_total, %s\n", file_name); return 0; } } else { memcpy(hash, hash0, 16); } memcpy(buf + off, hash, 16); off += 16; if (file_size > 0) memcpy(set_hash + (num * 16), hash, 16); // 16k MD5 hash if (file_size > 16384) memcpy(hash, hash16, 16); memcpy(buf + off, hash, 16); off += 16; // filename memcpy(buf + off, file_name, len); off += len; if (file_size > 0) num++; } // set hash をここで書き込む data_md5(set_hash, source_num * 16, hash); memcpy(buf + 32, hash, 16); // file list size をここで書き込む i = off - 96; memcpy(buf + 72, &i, 4); // start offset of the data をここで書き込む memcpy(buf + 80, &off, 4); // 最後にファイルのハッシュ値を計算する data_md5(buf + 32, off - 32, hash); memcpy(buf + 16, hash, 16); return off; } // インデックス・ファイルを作り直す int recreate_par( wchar_t *file_path, // PAR ファイルのパス unsigned char *pxx_buf, // PXX ファイルのヘッダー unsigned char *buf) // 作業バッファー { unsigned char hash[16]; int data_off, rv; HANDLE hFileWrite; // start offset of the data を読み取る memcpy(&data_off, pxx_buf + 80, 4); memcpy(buf, pxx_buf, data_off); // ヘッダー部分をコピーする // volume number を 0にする memset(buf + 48, 0, 8); // data size を 0にする memset(buf + 88, 0, 8); // control hash を計算しなおす data_md5(buf + 32, data_off - 32, hash); memcpy(buf + 16, hash, 16); // ファイルに書き込む hFileWrite = CreateFile(file_path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hFileWrite == INVALID_HANDLE_VALUE) return 1; if (!WriteFile(hFileWrite, buf, data_off, &rv, NULL)){ CloseHandle(hFileWrite); return 1; } CloseHandle(hFileWrite); return 0; } // PAR 1.0 のヘッダーから値を読み取る int get_header( wchar_t *file_name, HANDLE hFile, unsigned char *buf, int buf_size, unsigned char *set_hash, // NULL でなければ set hash、同じ構成の PXX かどうかを識別するため int *volume_num, // リカバリ・ファイルの番号 int *file_num, // ソース・ファイルの数 int *list_off, // ソース・ファイルのリストの開始位置 int *list_size, // ソース・ファイルのリストのサイズ int *data_off, // ソースの開始位置 __int64 *data_size) // ソースのサイズ { unsigned char hash[16]; int i; unsigned int rv, meta_data[7]; if (buf_size <= 96) return 1; // ファイルの先頭に戻す if (SetFilePointer(hFile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER){ print_win32_err(); return 1; } // ヘッダー部分を読み込む if (!ReadFile(hFile, buf, buf_size, &rv, NULL)){ print_win32_err(); printf("ReadFile, header\n"); return 1; } // Identification String memcpy(&i, buf, 4); if (i != 5390672) // 'P' + 'A' * 256 + 'R' * 65536 return 1; memcpy(&i, buf + 4, 4); if (i != 0) return 1; // Version Number memcpy(&i, buf + 8, 4); if ((i & 0xffff0000) != 0x00010000) // PAR v1.** にだけ対応する return 1; // 完全なリカバリ・ファイルを見つけた後だけ、検査結果を探す if (list_size == NULL){ i = check_ini_state(0x10FF, meta_data, hFile); if (i == -2){ // 記録が無い、または状態が変化してる // control hash if (rv = file_md5_from32(file_name, hFile, hash)) return rv; i = 0; if (memcmp(hash, buf + 16, 16) != 0) i = 1; // 今回の検査結果を書き込む write_ini_state(0x10FF, meta_data, i); } if (i != 0) return 1; } else { // control hash if (rv = file_md5_from32(file_name, hFile, hash)) return rv; if (memcmp(hash, buf + 16, 16) != 0) return 1; } // set hash if (set_hash != NULL) memcpy(set_hash, buf + 32, 16); // volume number if (volume_num != NULL) memcpy(volume_num, buf + 48, 4); // number of files if (file_num != NULL) memcpy(file_num, buf + 56, 4); // start offset of the file list if (list_off != NULL) memcpy(list_off, buf + 64, 4); // file list size if (list_size != NULL) memcpy(list_size, buf + 72, 4); // start offset of the data if (data_off != NULL) memcpy(data_off, buf + 80, 4); // data size if (data_size != NULL) memcpy(data_size, buf + 88, 8); return 0; } // ファイル・リストからブロック数を読み取る int get_source_num( unsigned char *buf, __int64 *block_size) { int i, off, file_num, entry_size, status, source_num = 0; __int64 file_size; // number of files memcpy(&file_num, buf + 56, 4); // start offset of the file list memcpy(&off, buf + 64, 4); for (i = 0; i < file_num; i++){ // entry size memcpy(&entry_size, buf + off, 4); // status field memcpy(&status, buf + (off + 8), 4); if ((status & 1) == 1){ source_num++; // file size memcpy(&file_size, buf + (off + 16), 8); if (file_size > *block_size) *block_size = file_size; } off += entry_size; } printf("%3d \r", source_num); return source_num; } // コメントを読み取る static void read_comment( wchar_t *par_comment, unsigned char *buf, int len) { if (par_comment[0] != 0) return; if (len >= COMMENT_LEN * 2) len = (COMMENT_LEN - 1) * 2; memcpy(par_comment, buf, len); len /= 2; // 文字数にする par_comment[len] = 0; // 末尾を null 文字にする for (len = 0; len < COMMENT_LEN; len++){ // 表示する前に sanitalize する if (par_comment[len] == 0){ break; } else if ((par_comment[len] <= 31) || (par_comment[len] == 127)){ // 制御文字を消す par_comment[len] = ' '; } } } // リカバリ・ファイルを作成する int par1_create( int switch_p, // インデックス・ファイルを作らない int source_num, // ソース・ブロックの数 __int64 block_size, // ブロック・サイズ (最大ファイル・サイズ) int parity_num, // パリティ・ブロックの数 int first_vol, // 最初のリカバリ・ファイル番号 int file_num, // ソース・ファイルの数 wchar_t *list_buf, // ソース・ファイルのリスト int list_len, // ファイル・リストの文字数 wchar_t *par_comment) // コメント { unsigned char *header_buf = NULL; wchar_t recovery_base[MAX_LEN]; int err = 0, i; int int4, buf_size; unsigned int rv; HANDLE *par_hFile = NULL; file_ctx *files = NULL; PHMD5 *par_md5 = NULL; buf_size = 0x0060 + (0x0038 * file_num) + (list_len * 2); // 最大サイズ分確保しておく header_buf = malloc(buf_size); if (header_buf == NULL){ printf("malloc, %d\n", buf_size); err = 1; goto error_end; } files = malloc(sizeof(file_ctx) * source_num); if (files == NULL){ printf("malloc, %d\n", sizeof(file_ctx) * source_num); err = 1; goto error_end; } for (i = 0; i < source_num; i++) files[i].hFile = NULL; int4 = sizeof(HANDLE) * parity_num; if (int4 == 0) int4 = sizeof(HANDLE); par_hFile = malloc(int4); if (par_hFile == NULL){ printf("malloc, %d\n", int4); err = 1; goto error_end; } par_hFile[0] = NULL; for (i = 1; i < parity_num; i++) par_hFile[i] = NULL; if (parity_num > 0){ par_md5 = malloc(sizeof(PHMD5) * parity_num); if (par_md5 == NULL){ printf("malloc, %d\n", sizeof(PHMD5) * parity_num); err = 1; goto error_end; } for (i = 0; i < parity_num; i++) Phmd5Begin(&(par_md5[i])); } printf("\n"); print_progress_text(0, "Computing file hash"); // ヘッダーを作成する buf_size = set_header(header_buf, files, source_num, file_num, list_buf, list_len); if (buf_size <= 0){ if (buf_size < 0){ err = 2; } else { err = 1; } goto error_end; } if (switch_p == 0){ // インデックス・ファイルを作るなら // コメントがあるならヘッダーを修正する if (int4 = wcslen(par_comment) * 2) memcpy(header_buf + 88, &int4, 4); // リカバリ・ファイル (*.PAR) を書き込む par_hFile[0] = CreateFile(recovery_file, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (par_hFile[0] == INVALID_HANDLE_VALUE){ print_win32_err(); printf_cp("cannot create file, %s\n", recovery_file); par_hFile[0] = NULL; err = 1; goto error_end; } if (!WriteFile(par_hFile[0], header_buf, buf_size, &rv, NULL)){ print_win32_err(); printf("WriteFile, index file\n"); err = 1; goto error_end; } // コメントがあるならコメントも書き込む if (int4 = wcslen(par_comment) * 2){ if (!WriteFile(par_hFile[0], par_comment, int4, &int4, NULL)){ print_win32_err(); printf("WriteFile, index file\n"); err = 1; goto error_end; } // MD5を計算しなおす if (err = file_md5_from32(NULL, par_hFile[0], header_buf + 16)){ if (err == 1) printf("file_md5_from32\n"); goto error_end; } if (SetFilePointer(par_hFile[0], 16, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER){ print_win32_err(); err = 1; goto error_end; } if (!WriteFile(par_hFile[0], header_buf + 16, 16, &rv, NULL)){ print_win32_err(); printf("WriteFile, index file\n"); err = 1; goto error_end; } } CloseHandle(par_hFile[0]); par_hFile[0] = NULL; } print_progress_done(); if (parity_num == 0) // パリティ・ブロックを作らない場合はここで終わる goto creation_end; // ソース・ファイルから読み込む準備をする for (i = 0; i < source_num; i++){ if (SetFilePointer(files[i].hFile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER){ print_win32_err(); err = 1; goto error_end; } } // リカバリ・ファイル (*.PXX) の名前の基 wcscpy(recovery_base, recovery_file); int4 = wcslen(recovery_base); recovery_base[int4 - 1] = 0; recovery_base[int4 - 2] = 0; print_progress_text(0, "Creating parity volume"); // リカバリ・ファイル (*.PXX) に書き込む準備をする memcpy(header_buf + 88, &block_size, 8); // ブロック・サイズにする for (i = 0; i < parity_num; i++){ int4 = first_vol + i; // 作成する parity volume の番号にする swprintf(recovery_file, MAX_LEN, L"%s%02d", recovery_base, int4); par_hFile[i] = CreateFile(recovery_file, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (par_hFile[i] == INVALID_HANDLE_VALUE){ print_win32_err(); par_hFile[i] = NULL; printf_cp("cannot create file, %s\n", recovery_file); // これまでに作ったリカバリ・ファイルを削除する if (switch_p == 0){ wcscpy(recovery_file, recovery_base); wcscat(recovery_file, L"ar"); DeleteFile(recovery_file); } for (int4 = 0; int4 < i; int4++){ CloseHandle(par_hFile[int4]); par_hFile[int4] = NULL; swprintf(recovery_file, MAX_LEN, L"%s%02d", recovery_base, first_vol + int4); DeleteFile(recovery_file); // 途中までのリカバリ・ファイルを削除する } err = 1; goto error_end; } // ヘッダーを書き込む memcpy(header_buf + 48, &int4, 2); // volume number にする if (!WriteFile(par_hFile[i], header_buf, buf_size, &rv, NULL)){ print_win32_err(); printf("WriteFile, parity volume %d\n", int4); err = 1; goto error_end; } // ヘッダー部分からのハッシュ値を計算しかけておく Phmd5Process(&(par_md5[i]), header_buf + 32, buf_size - 32); } // パリティ・ブロックを作成する if (err = rs_encode(source_num, block_size, parity_num, first_vol - 1, files, par_hFile, par_md5)){ if (err == 2){ // キャンセルされたのなら、作業中のファイルを削除する if (switch_p == 0){ wcscpy(recovery_file, recovery_base); wcscat(recovery_file, L"ar"); DeleteFile(recovery_file); } for (i = 0; i < parity_num; i++){ CloseHandle(par_hFile[i]); par_hFile[i] = NULL; swprintf(recovery_file, MAX_LEN, L"%s%02d", recovery_base, first_vol + i); DeleteFile(recovery_file); // 途中までのリカバリ・ファイルを削除する } } goto error_end; } // リカバリ・ファイル (*.PXX) の MD5を計算しなおす for (i = 0; i < parity_num; i++){ Phmd5End(&(par_md5[i])); // ハッシュ値の計算終了 memcpy(header_buf + 16, par_md5[i].hash, 16); if (SetFilePointer(par_hFile[i], 16, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER){ print_win32_err(); err = 1; goto error_end; } if (!WriteFile(par_hFile[i], header_buf + 16, 16, &rv, NULL)){ print_win32_err(); printf("WriteFile, parity volume %d\n", i); err = 1; goto error_end; } } creation_end: printf("\nCreated successfully\n"); error_end: if (list_buf) free(list_buf); if (header_buf) free(header_buf); if (par_md5) free(par_md5); if (files){ for (i = 0; i < source_num; i++){ if (files[i].hFile != NULL) CloseHandle(files[i].hFile); } free(files); } if (par_hFile){ for (i = 0; i < parity_num; i++){ if (par_hFile[i] != NULL) CloseHandle(par_hFile[i]); } free(par_hFile); } return err; } // ソース・ファイルの破損や欠損を調べる int par1_verify( int switch_b, // 既存のファイルを別名にしてどかす int switch_p, // インデックス・ファイルを作り直す wchar_t *par_comment) // コメント { char ascii_buf[MAX_LEN * 3], ascii_buf2[MAX_LEN * 3]; unsigned char *header_buf = NULL, *header_buf2 = NULL, hash[16], set_hash[16]; wchar_t file_name[MAX_LEN], file_path[MAX_LEN], find_path[MAX_LEN]; wchar_t par_char[] = L"AR"; int err = 0, i, j, bad_flag, find_flag, parity_flag, par_flag, exist[99]; int len, dir_len, base_len, buf_size, entry_size, entry_size2, blk; int volume_num, volume_max, file_num, list_off, list_size, data_off; int buf_size2, volume_num2, file_num2, list_off2, data_off2; int parity_num, source_num, block_lost = 0, need_repair = 0, recovery_lost = 0; unsigned int rv, meta_data[7]; __int64 file_size, file_size2, data_size, block_size = 0, total_file_size; HANDLE hFile = NULL, hFind; WIN32_FIND_DATA FindData; // リカバリ・ファイルの名前 wcscpy(file_path, recovery_file); len = wcslen(file_path); file_path[len - 2] = 0; // 末尾の2文字を消去する if (file_path[len - 3] == 'p'){ par_char[0] = 'a'; par_char[1] = 'r'; } // ディレクトリの長さ dir_len = len - 3; while (dir_len >= 0){ if ((file_path[dir_len] == '\\') || (file_path[dir_len] == '/')) break; dir_len--; } dir_len++; base_len = wcslen(base_dir); // リカバリ・ファイルの一覧を表示する printf("PAR File list :\n"); printf(" Size : Filename\n"); total_file_size = 0; parity_num = 0; volume_max = 0; for (i = 0; i <= 99; i++){ if (i == 0){ swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char); blk = 0; } else { swprintf(find_path, MAX_LEN, L"%s%02d", file_path, i); blk = 1; } // ファイルを開くことができるか、サイズを取得できるかを確かめる hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile == INVALID_HANDLE_VALUE){ continue; } // ファイルのサイズを取得する if (!GetFileSizeEx(hFile, (PLARGE_INTEGER)&file_size)){ CloseHandle(hFile); continue; } CloseHandle(hFile); total_file_size += file_size; parity_num++; volume_max = i; // リカバリ・ファイルの名前 utf16_to_cp(find_path + dir_len, ascii_buf); printf("%13I64d : \"%s\"\n", file_size, ascii_buf); } hFile = NULL; printf("\nPAR File total size\t: %I64d\n", total_file_size); printf("PAR File possible count\t: %d\n\n", parity_num); // 指定されたリカバリ・ファイルを開く hFile = CreateFile(recovery_file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile == INVALID_HANDLE_VALUE){ print_win32_err(); printf("valid file is not found\n"); err = 1; goto error_end; } // ファイルのサイズを取得する if (!GetFileSizeEx(hFile, (PLARGE_INTEGER)&file_size)){ print_win32_err(); err = 1; goto error_end; } // ヘッダー用のバッファーを確保する buf_size = 0x0060 + ((0x0038 + (260 * 2)) * 256) + (COMMENT_LEN * 2); // 最大サイズ if ((__int64)buf_size > file_size) buf_size = (unsigned int)file_size; header_buf = malloc(buf_size); if (header_buf == NULL){ printf("malloc, %d\n", buf_size); err = 1; goto error_end; } // PAR や PXX ファイルとして正しいかを調べる par_flag = 0; par_comment[0] = 0; for (i = 0; i < 99; i++) exist[i] = -1; if (rv = get_header(NULL, hFile, header_buf, buf_size, set_hash, &volume_num, &file_num, &list_off, &list_size, &data_off, &data_size)){ if (rv == 2){ // キャンセル err = 2; goto error_end; } volume_num = -1; par_flag |= 2; } else { // 各ブロックが存在するかを記録していく j = get_source_num(header_buf, &block_size); check_ini_file(set_hash, j); // 前回の検査結果が存在するかどうか if (volume_num == 0){ par_flag |= 1; rv = (int)data_size; if (buf_size < (int)data_size) rv = buf_size; if (rv > 1) read_comment(par_comment, header_buf + data_off, rv); } } CloseHandle(hFile); hFile = NULL; // 他のリカバリ・ファイルのヘッダー用のバッファーを確保する if (volume_num == -1){ buf_size2 = 0x0060 + ((0x0038 + (260 * 2)) * 256) + (COMMENT_LEN * 2); // 最大サイズ } else { buf_size2 = 0x0060 + ((0x0038 + (260 * 2)) * file_num); } header_buf2 = malloc(buf_size2); if (header_buf2 == NULL){ printf("malloc, %d\n", buf_size2); err = 1; goto error_end; } // 他のリカバリ・ファイルも調べる printf("Loading PAR File:\n"); printf(" Block Status : Filename\n"); fflush(stdout); parity_num = 0; for (i = 0; i <= 99; i++){ if (err = cancel_progress()) // キャンセル処理 goto error_end; if (i == 0){ swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char); blk = 0; } else { swprintf(find_path, MAX_LEN, L"%s%02d", file_path, i); blk = 1; } utf16_to_cp(find_path + dir_len, ascii_buf); // 既にチェック済みなら if ((_wcsicmp(recovery_file + dir_len, find_path + dir_len) == 0) && (volume_num != -1)){ if ((volume_num > 0) && (volume_num <= 99)){ if (exist[volume_num - 1] == -1) // 係数が重複してるのは使えない parity_num++; exist[volume_num - 1] = i; if (volume_max < volume_num) volume_max = volume_num; } if ((par_flag & 2) != 0){ printf(" 0 / %d Damaged : \"%s\"\n", blk, ascii_buf); recovery_lost++; } else if (i == volume_num){ printf(" %d / %d Good : \"%s\"\n", blk, blk, ascii_buf); } else { blk = (volume_num > 0) ? 1 : 0; printf(" %d / %d Misnamed : \"%s\"\n", blk, blk, ascii_buf); recovery_lost++; // リカバリ・ファイルの破損は修復必要とは判定しない } continue; } // ファイルを開く hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile == INVALID_HANDLE_VALUE) continue; // PAR や PXX ファイルとして正しいかを調べる bad_flag = 0; if (volume_num == -1){ if (rv = get_header(find_path + dir_len, hFile, header_buf, buf_size, set_hash, &volume_num, &file_num, &list_off, &list_size, &data_off, &data_size)){ if (rv == 2){ // キャンセル err = 2; goto error_end; } volume_num = -1; bad_flag = 1; } else { j = get_source_num(header_buf, &block_size); check_ini_file(set_hash, j); // 前回の検査結果が存在するかどうか if (volume_num == 0){ par_flag |= 1; rv = (int)data_size; if (buf_size < (int)data_size) rv = buf_size; if (rv > 1) read_comment(par_comment, header_buf + data_off, (int)data_size); } else if (volume_num <= 99){ parity_num++; exist[volume_num - 1] = i; if (volume_max < volume_num) volume_max = volume_num; } if (i != volume_num){ // ブロック番号と拡張子が異なるなら bad_flag = 3; blk = (volume_num > 0) ? 1 : 0; } } } else { if (rv = get_header(find_path + dir_len, hFile, header_buf2, buf_size2, hash, &volume_num2, &file_num2, &list_off2, NULL, &data_off2, &data_size)){ if (rv == 2){ // キャンセル err = 2; goto error_end; } bad_flag = 1; } else { // 同じ構成の PXX かを確認する if (memcmp(hash, set_hash, 16) != 0) bad_flag = 2; if ((file_num2 != file_num) || (list_off2 != list_off) || (data_off2 != data_off)) bad_flag = 2; if ((block_size) && (volume_num2 > 0)){ if (data_size != block_size) bad_flag = 2; } if (!bad_flag){ if (volume_num2 == 0){ par_flag |= 1; rv = (int)data_size; if (buf_size2 < (int)data_size) rv = buf_size2; if (rv > 1) read_comment(par_comment, header_buf2 + data_off2, rv); } else if (volume_num2 <= 99){ if (exist[volume_num2 - 1] == -1) // 係数が重複してるのは使えない parity_num++; exist[volume_num2 - 1] = i; if (volume_max < volume_num2) volume_max = volume_num2; } if (i != volume_num2){ // ブロック番号と拡張子が異なるなら bad_flag = 3; blk = (volume_num2 > 0) ? 1 : 0; } } } } switch (bad_flag){ case 0: printf(" %d / %d Good : \"%s\"\n", blk, blk, ascii_buf); break; case 1: printf(" 0 / %d Damaged : \"%s\"\n", blk, ascii_buf); recovery_lost++; break; case 2: printf(" %d / %d Useless : \"%s\"\n", blk, blk, ascii_buf); recovery_lost++; break; case 3: printf(" %d / %d Misnamed : \"%s\"\n", blk, blk, ascii_buf); recovery_lost++; // リカバリ・ファイルの破損は修復必要とは判定しない break; } CloseHandle(hFile); hFile = NULL; fflush(stdout); } if (volume_num == -1){ // Recovery Set が見つからなければここで終わる printf("valid file is not found\n"); err = 1; goto error_end; } // セット・ハッシュとプログラムのバージョンを表示する printf("\nSet Hash: "); print_hash(set_hash); memcpy(&rv, header_buf + 12, 4); printf("\nCreator : "); switch (rv >> 24){ case 1: // Mirror printf("Mirror"); break; case 2: // PAR printf("PAR"); break; case 3: // SmartPar printf("SmartPar"); break; default: printf("Unknown client %d", rv >> 24); } printf(" version %d.%d.%d\n", (rv >> 16) & 0xFF, (rv >> 8) & 0xFF, rv & 0xFF); if ((par_comment[0] != 0) && (!utf16_to_cp(par_comment, ascii_buf))) printf("Comment : %s\n", ascii_buf); // コメントをユニコードから戻せた場合だけ表示する if (((par_flag & 1) == 0) && (switch_p)){ // PAR ファイルを作り直す swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char); get_temp_name(find_path, file_name); if (recreate_par(file_name, header_buf, header_buf2) == 0){ if (replace_file(find_path, file_name, switch_b) == 0){ // 破損したPARファイルが存在するならどかす utf16_to_cp(find_path + dir_len, ascii_buf); printf("\nRestored file :\n"); printf(" Size : Filename\n"); printf("%13u : \"%s\"\n", data_off, ascii_buf); } else { DeleteFile(file_name); } } } free(header_buf2); header_buf2 = NULL; printf("\nParity Volume count\t: %d\n", volume_max); printf("Parity Volume found\t: %d\n", parity_num); fflush(stdout); // ファイル・リストを表示する printf("\nInput File list : %d\n", file_num); printf(" Size B : Filename\n"); total_file_size = 0; source_num = 0; list_off2 = list_off; for (i = 0; i < file_num; i++){ // entry size memcpy(&entry_size, header_buf + list_off2, 4); // status field memcpy(&parity_flag, header_buf + (list_off2 + 8), 2); parity_flag &= 0x01; // bit 0 = file is saved in the parity volume set if (parity_flag){ source_num++; blk = 1; } else { blk = 0; } // size memcpy(&data_size, header_buf + (list_off2 + 16), 8); total_file_size += data_size; // filename len = (entry_size - 56) / 2; if (len >= MAX_LEN) len = MAX_LEN - 1; memcpy(file_name, header_buf + (list_off2 + 56), len * 2); file_name[len] = 0; utf16_to_cp(file_name, ascii_buf); // ファイル名が有効かどうか確かめる j = sanitize_filename(file_name); if (j != 0){ if (j == 16){ printf("filename is not valied, %s\n", ascii_buf); err = 1; goto error_end; } utf16_to_cp(file_name, ascii_buf); } printf("%13I64u %d : \"%s\"\n", data_size, blk, ascii_buf); list_off2 += entry_size; // 次のエントリー位置にずらす } printf("\nData File count : %d\n", source_num); printf("Max file size\t: %I64d\n", block_size); printf("Total data size : %I64d\n", total_file_size); // ソース・ファイルが存在していて正しいかを調べる printf("\nVerifying Input File :\n"); printf(" Size Status : Filename\n"); fflush(stdout); for (i = 0; i < file_num; i++){ if (err = cancel_progress()) // キャンセル処理 goto error_end; find_flag = bad_flag = parity_flag = 0; // entry size memcpy(&entry_size, header_buf + list_off, 4); // status field memcpy(&parity_flag, header_buf + (list_off + 8), 2); parity_flag &= 0x01; // bit 0 = file is saved in the parity volume set // size memcpy(&data_size, header_buf + (list_off + 16), 8); file_size = 0; // filename len = (entry_size - 56) / 2; if (len >= MAX_LEN) len = MAX_LEN - 1; memcpy(file_name, header_buf + (list_off + 56), len * 2); file_name[len] = 0; utf16_to_cp(file_name, ascii_buf); // ファイル名が有効かどうか確かめる wcscpy(file_path, file_name); j = sanitize_filename(file_path); if (j != 0){ wcscpy(file_name, file_path); utf16_to_cp(file_name, ascii_buf); } // ファイル名を基準ディレクトリに追加してパスにする if (base_len + wcslen(file_name) >= MAX_LEN - ADD_LEN){ printf("filename is too long\n"); err = 1; goto error_end; } wcscpy(file_path, base_dir); wcscpy(file_path + base_len, file_name); // ファイルが存在するか hFile = CreateFile(file_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile != INVALID_HANDLE_VALUE){ // ファイルが存在するなら内容を確認する // 検査結果の記録があるかどうか bad_flag = check_ini_state(i, meta_data, hFile); memcpy(&file_size, meta_data, 8); if (bad_flag == -1){ // ファイル・サイズが不明なら消失扱いにする bad_flag = 1; } else if (bad_flag == -2){ // 検査結果が無かった場合 bad_flag = 0; if (file_size >= data_size){ // 末尾にゴミが付いてないか調べる if (file_size > data_size) bad_flag = 2; if (data_size > 0){ // 16k MD5 hash が一致するか確かめる if (file_md5_16k(hFile, data_size, hash)){ bad_flag = 1; } else if (memcmp(hash, header_buf + (list_off + 40), 16) != 0){ bad_flag = 1; } else if (data_size > 16384){ // MD5 hash が一致するか確かめる if (rv = file_md5(file_name, hFile, data_size, hash)){ if (rv == 2){ err = 2; goto error_end; } bad_flag = 1; } else if (memcmp(hash, header_buf + (list_off + 24), 16) != 0){ bad_flag = 1; } // 16k MD5 hash が一致した時だけ検査結果を記録する write_ini_state(i, meta_data, bad_flag); } } } else if (file_size < data_size){ bad_flag = 1; } } CloseHandle(hFile); hFile = NULL; if (!bad_flag) find_flag = 3; } // ファイルが存在しないか、不完全だった場合は、サイズとハッシュ値で検索する if ((data_size) && ((hFile == INVALID_HANDLE_VALUE) || (bad_flag))){ wcscpy(find_path, base_dir); wcscpy(find_path + base_len, L"*"); hFind = FindFirstFile(find_path, &FindData); if (hFind != INVALID_HANDLE_VALUE){ do { if ((FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0){ // フォルダは無視する find_flag = 1; file_size2 = ((__int64)(FindData.nFileSizeHigh) << 32) | (__int64)(FindData.nFileSizeLow); if (file_size2 != data_size){ // ファイル・サイズが一致しなければ find_flag = 0; } else { // ファイル名がリスト上にあれば除外する memcpy(&list_off2, header_buf + 64, 4); for (j = 0; j < file_num; j++){ // entry size memcpy(&entry_size2, header_buf + list_off2, 4); // filename len = (entry_size2 - 56) / 2; if (len >= MAX_LEN) len = MAX_LEN - 1; memcpy(file_name, header_buf + (list_off2 + 56), len * 2); file_name[len] = 0; sanitize_filename(file_name); if (_wcsicmp(file_name, FindData.cFileName) == 0){ find_flag = 0; break; } list_off2 += entry_size2; // 次のエントリー位置にずらす } } // リスト上に無くてファイル・サイズが一致すれば if ((find_flag != 0) && (base_len + wcslen(FindData.cFileName) < MAX_LEN)){ wcscpy(find_path + base_len, FindData.cFileName); hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile != INVALID_HANDLE_VALUE){ j = check_ini_state(i, meta_data, hFile); if (j == -2){ // 検査結果が無かった場合 if (data_size > 0){ // 16k MD5 hash が一致するか確かめる if (file_md5_16k(hFile, data_size, hash)){ find_flag = 0; } else if (memcmp(hash, header_buf + (list_off + 40), 16) != 0){ find_flag = 0; } else if (data_size > 16384){ // MD5 hash が一致するか確かめる j = 0; if (rv = file_md5(FindData.cFileName, hFile, data_size, hash)){ if (rv == 2){ err = 2; goto error_end; } find_flag = 0; j = 1; } else if (memcmp(hash, header_buf + (list_off + 24), 16) != 0){ find_flag = 0; j = 1; } // 16k MD5 hash が一致した時だけ検査結果を記録する write_ini_state(i, meta_data, j); } } } else if (j != 0){ // 完全以外なら find_flag = 0; } CloseHandle(hFile); hFile = NULL; if (find_flag){ // 異なる名前だが同じ内容のファイルを発見した utf16_to_cp(FindData.cFileName, ascii_buf2); break; } } else { find_flag = 0; } } } } while (FindNextFile(hFind, &FindData)); // 次のファイルを検索する FindClose(hFind); } } if (find_flag == 3){ printf(" = Complete : \"%s\"\n", ascii_buf); } else if (find_flag == 1){ need_repair++; if (bad_flag){ printf("%13I64u Damaged~ : \"%s\"\n", file_size, ascii_buf); } else { printf(" - Missing~ : \"%s\"\n", ascii_buf); } printf("%13I64u Misnamed : \"%s\"\n", data_size, ascii_buf2); } else if (bad_flag == 2){ need_repair++; printf("%13I64u Appended : \"%s\"\n", file_size, ascii_buf); } else if (bad_flag){ if (parity_flag) block_lost++; if (data_size == 0) need_repair++; printf("%13I64u Damaged : \"%s\"\n", file_size, ascii_buf); } else { if (parity_flag) block_lost++; if (data_size == 0) need_repair++; printf(" - Missing : \"%s\"\n", ascii_buf); } fflush(stdout); list_off += entry_size; // 次のエントリー位置にずらす } printf("\nData File lost\t: %d\n\n", block_lost); if ((block_lost == 0) && (need_repair == 0)) printf("All Files Complete\n"); if (recovery_lost > 0){ // 不完全なリカバリ・ファイルがあるなら err = 256; printf("%d PAR File(s) Incomplete\n", recovery_lost); } // 修復する必要があるかどうか if ((block_lost > 0) || (need_repair > 0)){ err |= 4; if (need_repair > 0){ printf("Ready to rename %d file(s)\n", need_repair); err |= 32; } if (block_lost > 0){ if (block_lost > parity_num){ printf("Need %d more volume(s) to repair %d file(s)\n", block_lost - parity_num, block_lost); err |= 8; } else { printf("Ready to repair %d file(s)\n", block_lost); err |= 128; } } } error_end: close_ini_file(); if (hFile != NULL) CloseHandle(hFile); if (header_buf) free(header_buf); if (header_buf2) free(header_buf2); return err; } // ソース・ファイルの破損や欠損を修復する int par1_repair( int switch_b, // 既存のファイルを別名にしてどかす int switch_p, // インデックス・ファイルを作り直す wchar_t *par_comment) // コメント { char ascii_buf[MAX_LEN * 3], ascii_buf2[MAX_LEN * 3]; unsigned char *header_buf = NULL, *header_buf2 = NULL, hash[16], set_hash[16]; wchar_t file_name[MAX_LEN * 2], file_path[MAX_LEN], find_path[MAX_LEN * 2]; wchar_t par_char[] = L"AR"; int err = 0, i, j, bad_flag, find_flag, parity_flag, par_flag, exist[256]; int len, dir_len, base_len, buf_size, entry_size, entry_size2, blk; int volume_num, volume_max, file_num, list_off, list_size, data_off; int buf_size2, volume_num2, file_num2, list_off2, data_off2; int parity_num, source_num, block_lost = 0, need_repair = 0, recovery_lost = 0; int parity_max, block_max; unsigned int rv, meta_data[7]; __int64 file_size, file_size2, data_size, block_size = 0, total_file_size; HANDLE hFile = NULL, hFind; WIN32_FIND_DATA FindData; file_ctx *files = NULL, *tmp_p; // リカバリ・ファイルの名前 wcscpy(file_path, recovery_file); len = wcslen(file_path); file_path[len - 2] = 0; // 末尾の2文字を消去する if (file_path[len - 3] == 'p'){ par_char[0] = 'a'; par_char[1] = 'r'; } // ディレクトリの長さ dir_len = len - 3; while (dir_len >= 0){ if ((file_path[dir_len] == '\\') || (file_path[dir_len] == '/')) break; dir_len--; } dir_len++; base_len = wcslen(base_dir); // リカバリ・ファイルの一覧を表示する printf("PAR File list :\n"); printf(" Size : Filename\n"); total_file_size = 0; parity_num = 0; volume_max = 0; for (i = 0; i <= 99; i++){ if (i == 0){ swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char); blk = 0; } else { swprintf(find_path, MAX_LEN, L"%s%02d", file_path, i); blk = 1; } // ファイルを開くことができるか、サイズを取得できるかを確かめる hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile == INVALID_HANDLE_VALUE){ continue; } // ファイルのサイズを取得する if (!GetFileSizeEx(hFile, (PLARGE_INTEGER)&file_size)){ CloseHandle(hFile); continue; } CloseHandle(hFile); total_file_size += file_size; parity_num++; volume_max = i; // リカバリ・ファイルの名前 utf16_to_cp(find_path + dir_len, ascii_buf); printf("%13I64d : \"%s\"\n", file_size, ascii_buf); } hFile = NULL; printf("\nPAR File total size\t: %I64d\n", total_file_size); printf("PAR File possible count\t: %d\n\n", parity_num); // 指定されたリカバリ・ファイルを開く hFile = CreateFile(recovery_file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile == INVALID_HANDLE_VALUE){ print_win32_err(); printf("valid file is not found\n"); err = 1; goto error_end; } // ファイルのサイズを取得する if (!GetFileSizeEx(hFile, (PLARGE_INTEGER)&file_size)){ print_win32_err(); err = 1; goto error_end; } // ヘッダー用のバッファーを確保する buf_size = 0x0060 + ((0x0038 + (260 * 2)) * 256) + (COMMENT_LEN * 2); // 最大サイズ if ((__int64)buf_size > file_size) buf_size = (unsigned int)file_size; header_buf = malloc(buf_size); if (header_buf == NULL){ printf("malloc, %d\n", buf_size); err = 1; goto error_end; } // PAR や PXX ファイルとして正しいかを調べる parity_max = 0; par_flag = 0; par_comment[0] = 0; for (i = 0; i < 256; i++) exist[i] = -1; if (rv = get_header(NULL, hFile, header_buf, buf_size, set_hash, &volume_num, &file_num, &list_off, &list_size, &data_off, &data_size)){ if (rv == 2){ // キャンセル err = 2; goto error_end; } volume_num = -1; par_flag |= 2; } else { // 各ブロックが存在するかを記録していく block_max = get_source_num(header_buf, &block_size); check_ini_file(set_hash, block_max); // 前回の検査結果が存在するかどうか if (volume_num == 0){ par_flag |= 1; rv = (int)data_size; if (buf_size < (int)data_size) rv = buf_size; if (rv > 1) read_comment(par_comment, header_buf + data_off, rv); } } CloseHandle(hFile); hFile = NULL; // 他のリカバリ・ファイルのヘッダー用のバッファーを確保する if (volume_num == -1){ buf_size2 = 0x0060 + ((0x0038 + (260 * 2)) * 256) + (COMMENT_LEN * 2); // 最大サイズ } else { buf_size2 = 0x0060 + ((0x0038 + (260 * 2)) * file_num); } header_buf2 = malloc(buf_size2); if (header_buf2 == NULL){ printf("malloc, %d\n", buf_size2); err = 1; goto error_end; } // 他のリカバリ・ファイルも調べる printf("Loading PAR File:\n"); printf(" Block Status : Filename\n"); fflush(stdout); parity_num = 0; for (i = 0; i <= 99; i++){ if (err = cancel_progress()) // キャンセル処理 goto error_end; if (i == 0){ swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char); blk = 0; } else { swprintf(find_path, MAX_LEN, L"%s%02d", file_path, i); blk = 1; } utf16_to_cp(find_path + dir_len, ascii_buf); // 既にチェック済みなら if ((_wcsicmp(recovery_file + dir_len, find_path + dir_len) == 0) && (volume_num != -1)){ if ((volume_num > 0) && (volume_num <= 99)){ if (exist[block_max + volume_num - 1] == -1) // 係数が重複してるのは使えない parity_num++; if (parity_max < volume_num) parity_max = volume_num; if (block_max + volume_num <= 256) exist[block_max + volume_num - 1] = i; if (volume_max < volume_num) volume_max = volume_num; } if ((par_flag & 2) != 0){ printf(" 0 / %d Damaged : \"%s\"\n", blk, ascii_buf); recovery_lost++; } else if (i == volume_num){ printf(" %d / %d Good : \"%s\"\n", blk, blk, ascii_buf); } else { blk = (volume_num > 0) ? 1 : 0; printf(" %d / %d Misnamed : \"%s\"\n", blk, blk, ascii_buf); recovery_lost++; // リカバリ・ファイルの破損は修復必要とは判定しない } continue; } // ファイルを開く hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile == INVALID_HANDLE_VALUE) continue; // PAR や PXX ファイルとして正しいかを調べる bad_flag = 0; if (volume_num == -1){ if (rv = get_header(find_path + dir_len, hFile, header_buf, buf_size, set_hash, &volume_num, &file_num, &list_off, &list_size, &data_off, &data_size)){ if (rv == 2){ // キャンセル err = 2; goto error_end; } volume_num = -1; bad_flag = 1; } else { block_max = get_source_num(header_buf, &block_size); check_ini_file(set_hash, block_max); // 前回の検査結果が存在するかどうか if (volume_num == 0){ par_flag |= 1; rv = (int)data_size; if (buf_size < (int)data_size) rv = buf_size; if (rv > 1) read_comment(par_comment, header_buf + data_off, (int)data_size); } else if (volume_num <= 99){ parity_num++; if (parity_max < volume_num) parity_max = volume_num; if (block_max + volume_num <= 256) exist[block_max + volume_num - 1] = i; if (volume_max < volume_num) volume_max = volume_num; } if (i != volume_num){ // ブロック番号と拡張子が異なるなら bad_flag = 3; blk = (volume_num > 0) ? 1 : 0; } } } else { if (rv = get_header(find_path + dir_len, hFile, header_buf2, buf_size2, hash, &volume_num2, &file_num2, &list_off2, NULL, &data_off2, &data_size)){ if (rv == 2){ // キャンセル err = 2; goto error_end; } bad_flag = 1; } else { // 同じ構成の PXX かを確認する if (memcmp(hash, set_hash, 16) != 0) bad_flag = 2; if ((file_num2 != file_num) || (list_off2 != list_off) || (data_off2 != data_off)) bad_flag = 2; if ((block_size) && (volume_num2 > 0)){ if (data_size != block_size) bad_flag = 2; } if (!bad_flag){ if (volume_num2 == 0){ par_flag |= 1; rv = (int)data_size; if (buf_size2 < (int)data_size) rv = buf_size2; if (rv > 1) read_comment(par_comment, header_buf2 + data_off2, rv); } else if (volume_num2 <= 99){ if (exist[block_max + volume_num2 - 1] == -1) // 係数が重複してるのは使えない parity_num++; // 各ブロックが存在するかを記録していく if (parity_max < volume_num2) parity_max = volume_num2; if (block_max + volume_num2 <= 256) exist[block_max + volume_num2 - 1] = i; if (volume_max < volume_num2) volume_max = volume_num2; } if (i != volume_num2){ // ブロック番号と拡張子が異なるなら bad_flag = 3; blk = (volume_num2 > 0) ? 1 : 0; } } } } switch (bad_flag){ case 0: printf(" %d / %d Good : \"%s\"\n", blk, blk, ascii_buf); break; case 1: printf(" 0 / %d Damaged : \"%s\"\n", blk, ascii_buf); recovery_lost++; break; case 2: printf(" %d / %d Useless : \"%s\"\n", blk, blk, ascii_buf); recovery_lost++; break; case 3: printf(" %d / %d Misnamed : \"%s\"\n", blk, blk, ascii_buf); recovery_lost++; // リカバリ・ファイルの破損は修復必要とは判定しない break; } CloseHandle(hFile); hFile = NULL; fflush(stdout); } if (volume_num == -1){ // Recovery Set が見つからなければここで終わる printf("valid file is not found\n"); err = 1; goto error_end; } // セット・ハッシュとプログラムのバージョンを表示する printf("\nSet Hash: "); print_hash(set_hash); memcpy(&rv, header_buf + 12, 4); printf("\nCreator : "); switch (rv >> 24){ case 1: // Mirror printf("Mirror"); break; case 2: // PAR printf("PAR"); break; case 3: // SmartPar printf("SmartPar"); break; default: printf("Unknown client %d", rv >> 24); } printf(" version %d.%d.%d\n", (rv >> 16) & 0xFF, (rv >> 8) & 0xFF, rv & 0xFF); if ((par_comment[0] != 0) && (!utf16_to_cp(par_comment, ascii_buf))) printf("Comment : %s\n", ascii_buf); // コメントをユニコードから戻せた場合だけ表示する if (((par_flag & 1) == 0) && (switch_p)){ // PAR ファイルを作り直す swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char); get_temp_name(find_path, file_name); if (recreate_par(file_name, header_buf, header_buf2) == 0){ if (replace_file(find_path, file_name, switch_b) == 0){ // 破損したPARファイルが存在するならどかす utf16_to_cp(find_path + dir_len, ascii_buf); printf("\nRestored file :\n"); printf(" Size : Filename\n"); printf("%13u : \"%s\"\n", data_off, ascii_buf); } else { DeleteFile(file_name); } } } free(header_buf2); header_buf2 = NULL; printf("\nParity Volume count\t: %d\n", volume_max); printf("Parity Volume found\t: %d\n", parity_num); fflush(stdout); // リカバリ・ファイルを開く len = sizeof(file_ctx) * (block_max + parity_max); files = malloc(len); if (files == NULL){ printf("malloc, %d\n", len); err = 1; goto error_end; } for (i = 0; i < (block_max + parity_max); i++) files[i].hFile = NULL; for (i = block_max; i < (block_max + parity_max); i++){ if (exist[i] != -1){ // リカバリ・ファイルが存在するなら if (exist[i] == 0){ swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char); } else { swprintf(find_path, MAX_LEN, L"%s%02d", file_path, exist[i]); } files[i].hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (files[i].hFile == INVALID_HANDLE_VALUE){ exist[i] = 0; continue; } // ファイル・サイズを取得する if (!GetFileSizeEx(files[i].hFile, (PLARGE_INTEGER)&file_size2)){ exist[i] = 0; continue; } files[i].size = file_size2; files[i].size -= data_off; //printf("%d: off = %d, size = %I64u \n", i, data_off, files[i].size); // 開始位置をリード・ソロモン符号のデータの所にしておく if (SetFilePointer(files[i].hFile, data_off, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER){ exist[i] = 0; continue; } exist[i] = 1; } else { exist[i] = 0; } } for (i = 0; i < block_max; i++) exist[i] = 0; // ファイル・リストを表示する printf("\nInput File list : %d\n", file_num); printf(" Size B : Filename\n"); total_file_size = 0; source_num = 0; list_off2 = list_off; for (i = 0; i < file_num; i++){ // entry size memcpy(&entry_size, header_buf + list_off2, 4); // status field memcpy(&parity_flag, header_buf + (list_off2 + 8), 2); parity_flag &= 0x01; // bit 0 = file is saved in the parity volume set if (parity_flag){ source_num++; blk = 1; } else { blk = 0; } // size memcpy(&data_size, header_buf + (list_off2 + 16), 8); total_file_size += data_size; // filename len = (entry_size - 56) / 2; if (len >= MAX_LEN) len = MAX_LEN - 1; memcpy(file_name, header_buf + (list_off2 + 56), len * 2); file_name[len] = 0; utf16_to_cp(file_name, ascii_buf); // ファイル名が有効かどうか確かめる j = sanitize_filename(file_name); if (j != 0){ if (j == 16){ printf("filename is not valied, %s\n", ascii_buf); err = 1; goto error_end; } utf16_to_cp(file_name, ascii_buf); } printf("%13I64u %d : \"%s\"\n", data_size, blk, ascii_buf); list_off2 += entry_size; // 次のエントリー位置にずらす } printf("\nData File count : %d\n", source_num); printf("Max file size\t: %I64d\n", block_size); printf("Total data size : %I64d\n", total_file_size); // ソース・ファイルが存在していて正しいかを調べる printf("\nVerifying Input File :\n"); printf(" Size Status : Filename\n"); fflush(stdout); source_num = 0; for (i = 0; i < file_num; i++){ if (err = cancel_progress()) // キャンセル処理 goto error_end; find_flag = bad_flag = parity_flag = 0; // entry size memcpy(&entry_size, header_buf + list_off, 4); // status field memcpy(&parity_flag, header_buf + (list_off + 8), 2); parity_flag &= 0x0001; // bit 0 = file is saved in the parity volume set if (parity_flag) source_num++; // size memcpy(&data_size, header_buf + (list_off + 16), 8); file_size = 0; // filename len = (entry_size - 56) / 2; if (len >= MAX_LEN) len = MAX_LEN - 1; memcpy(file_name, header_buf + (list_off + 56), len * 2); file_name[len] = 0; utf16_to_cp(file_name, ascii_buf); // ファイル名が有効かどうか確かめる wcscpy(file_path, file_name); j = sanitize_filename(file_path); if (j != 0){ wcscpy(file_name, file_path); utf16_to_cp(file_name, ascii_buf); } // ファイル名を基準ディレクトリに追加してパスにする if (base_len + wcslen(file_name) >= MAX_LEN - ADD_LEN){ printf("filename is too long\n"); err = 1; goto error_end; } wcscpy(file_path, base_dir); wcscpy(file_path + base_len, file_name); // ファイルが存在するか hFile = CreateFile(file_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile != INVALID_HANDLE_VALUE){ // ファイルが存在するなら内容を確認する // 検査結果の記録があるかどうか bad_flag = check_ini_state(i, meta_data, hFile); memcpy(&file_size, meta_data, 8); if (bad_flag == -1){ // ファイル・サイズが不明なら消失扱いにする bad_flag = 1; } else if (bad_flag == -2){ // 検査結果が無かった場合 bad_flag = 0; if (file_size >= data_size){ // 末尾にゴミが付いてないか調べる if (file_size > data_size) bad_flag = 2; if (data_size > 0){ // 16k MD5 hash が一致するか確かめる if (file_md5_16k(hFile, data_size, hash)){ bad_flag = 1; } else if (memcmp(hash, header_buf + (list_off + 40), 16) != 0){ bad_flag = 1; } else if (data_size > 16384){ // MD5 hash が一致するか確かめる if (rv = file_md5(file_name, hFile, data_size, hash)){ if (rv == 2){ err = 2; goto error_end; } bad_flag = 1; } else if (memcmp(hash, header_buf + (list_off + 24), 16) != 0){ bad_flag = 1; } // 16k MD5 hash が一致した時だけ検査結果を記録する write_ini_state(i, meta_data, bad_flag); } } } else if (file_size < data_size){ bad_flag = 1; } } CloseHandle(hFile); hFile = NULL; if (!bad_flag){ find_flag = 3; if (parity_flag) exist[source_num - 1] = 1; } } // ファイルが存在しないか、不完全だった場合は、サイズとハッシュ値で検索する if ((data_size) && ((hFile == INVALID_HANDLE_VALUE) || (bad_flag))){ wcscpy(find_path, base_dir); wcscpy(find_path + base_len, L"*"); hFind = FindFirstFile(find_path, &FindData); if (hFind != INVALID_HANDLE_VALUE){ do { if ((FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0){ // フォルダは無視する find_flag = 1; file_size2 = ((__int64)(FindData.nFileSizeHigh) << 32) | (__int64)(FindData.nFileSizeLow); if (file_size2 != data_size){ // ファイル・サイズが一致しなければ find_flag = 0; } else { // ファイル名がリスト上にあれば除外する memcpy(&list_off2, header_buf + 64, 4); for (j = 0; j < file_num; j++){ // entry size memcpy(&entry_size2, header_buf + list_off2, 4); // filename len = (entry_size2 - 56) / 2; if (len >= MAX_LEN) len = MAX_LEN - 1; memcpy(file_name, header_buf + (list_off2 + 56), len * 2); file_name[len] = 0; sanitize_filename(file_name); if (_wcsicmp(file_name, FindData.cFileName) == 0){ find_flag = 0; break; } list_off2 += entry_size2; // 次のエントリー位置にずらす } } // リスト上に無くてファイル・サイズが一致すれば if ((find_flag != 0) && (base_len + wcslen(FindData.cFileName) < MAX_LEN)){ wcscpy(find_path + base_len, FindData.cFileName); hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile != INVALID_HANDLE_VALUE){ j = check_ini_state(i, meta_data, hFile); if (j == -2){ // 検査結果が無かった場合 if (data_size > 0){ // 16k MD5 hash が一致するか確かめる if (file_md5_16k(hFile, data_size, hash)){ find_flag = 0; } else if (memcmp(hash, header_buf + (list_off + 40), 16) != 0){ find_flag = 0; } else if (data_size > 16384){ // MD5 hash が一致するか確かめる j = 0; if (rv = file_md5(FindData.cFileName, hFile, data_size, hash)){ if (rv == 2){ err = 2; goto error_end; } find_flag = 0; j = 1; } else if (memcmp(hash, header_buf + (list_off + 24), 16) != 0){ find_flag = 0; j = 1; } // 16k MD5 hash が一致した時だけ検査結果を記録する write_ini_state(i, meta_data, j); } } } else if (j != 0){ // 完全以外なら find_flag = 0; } CloseHandle(hFile); hFile = NULL; if (find_flag){ // 異なる名前だが同じ内容のファイルを発見した utf16_to_cp(FindData.cFileName, ascii_buf2); // ファイル名を修正する if (replace_file(file_path, find_path, switch_b) == 0){ find_flag = 2; // } else { // printf("cannot rename to %s\n", ascii_buf); // err = 1; // goto error_end; } break; } } else { find_flag = 0; } } } } while (FindNextFile(hFind, &FindData)); // 次のファイルを検索する FindClose(hFind); } } if (find_flag == 3){ printf(" = Complete : \"%s\"\n", ascii_buf); } else if (find_flag == 1){ need_repair++; need_repair |= 0x40000000; // 修復失敗の印 if (bad_flag){ printf("%13I64u Failed~ : \"%s\"\n", file_size, ascii_buf); } else { printf(" - Failed : \"%s\"\n", ascii_buf); } printf("%13I64u Misnamed : \"%s\"\n", data_size, ascii_buf2); } else if (find_flag == 2){ need_repair += 0x10001; // 修復できた数を記録する if (parity_flag) exist[source_num - 1] = 1; printf("%13I64u Restored : \"%s\"\n", data_size, ascii_buf); } else if (bad_flag == 2){ if (shorten_file(file_path, data_size, switch_b) != 0) // ファイルを小さくする bad_flag = 1; need_repair++; if (bad_flag == 2){ // 修復 (縮小) できたら need_repair += 0x10000; // 上位 16-bit に修復できた数を記録する if (parity_flag) exist[source_num - 1] = 1; printf("%13I64u Restored : \"%s\"\n", data_size, ascii_buf); } else { // 修復できなかったなら if (parity_flag) block_lost++; printf("%13I64u Appended : \"%s\"\n", file_size, ascii_buf); } } else if (bad_flag){ bad_flag = 1; if (data_size == 0){ // サイズが 0ならすぐに復元できる need_repair++; hFile = CreateFile(file_path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile != INVALID_HANDLE_VALUE){ bad_flag = 0; need_repair += 0x10000; // 上位 16-bit に修復できた数を記録する } CloseHandle(hFile); hFile = NULL; } if (bad_flag){ if (parity_flag) block_lost++; printf("%13I64u Damaged : \"%s\"\n", file_size, ascii_buf); } else { if (parity_flag) exist[source_num - 1] = 1; printf("%13I64u Restored : \"%s\"\n", data_size, ascii_buf); } } else { bad_flag = 1; if (data_size == 0){ // サイズが 0ならすぐに復元できる need_repair++; hFile = CreateFile(file_path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile != INVALID_HANDLE_VALUE){ bad_flag = 0; need_repair += 0x10000; // 上位 16-bit に修復できた数を記録する } CloseHandle(hFile); hFile = NULL; } if (bad_flag){ if (parity_flag) block_lost++; printf(" - Missing : \"%s\"\n", ascii_buf); } else { if (parity_flag) exist[source_num - 1] = 1; printf("%13I64u Restored : \"%s\"\n", data_size, ascii_buf); } } if (parity_flag){ // ソース・ファイルを開く if (exist[source_num - 1]){ // ソース・ブロックが存在するなら files[source_num - 1].hFile = CreateFile(file_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (files[source_num - 1].hFile == INVALID_HANDLE_VALUE){ exist[source_num - 1] = 0; } else { if (!GetFileSizeEx(files[source_num - 1].hFile, (PLARGE_INTEGER)&file_size2)){ exist[source_num - 1] = 0; } else { files[source_num - 1].size = file_size2; } } } else { // 破損してる、または存在しないなら get_temp_name(file_path, find_path); // 修復中のテンポラリ・ファイル files[source_num - 1].hFile = CreateFile(find_path, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (files[source_num - 1].hFile == INVALID_HANDLE_VALUE){ print_win32_err(); printf_cp("cannot create file, %s\n", find_path); err = 1; goto error_end; } files[source_num - 1].size = data_size; } //printf("%d: exist = %d, size = %I64u \n", source_num - 1, exist[source_num - 1], files[source_num - 1].size); } fflush(stdout); list_off += entry_size; // 次のエントリー位置にずらす } printf("\nData File lost\t: %d\n\n", block_lost); // 修復に必要なパリティ・ブロックの数が少なくて済むなら最大値を調節する if (block_lost < parity_num){ volume_num = 0; len = block_max + parity_max; for (i = block_max; i < len; i++){ if (exist[i]){ volume_num++; if (volume_num > block_lost){ volume_num--; exist[i] = 0; CloseHandle(files[i].hFile); files[i].hFile = NULL; } else { parity_max = 1 + i - block_max; } } } len = sizeof(file_ctx) * (block_max + parity_max); tmp_p = (file_ctx *)realloc(files, len); if (tmp_p == NULL){ printf("realloc, %d\n", len); err = 1; goto error_end; } else { files = tmp_p; } } if ((block_lost == 0) && (need_repair == 0)) printf("All Files Complete\n"); if (recovery_lost > 0){ // 不完全なリカバリ・ファイルがあるなら err = 256; printf("%d PAR File(s) Incomplete\n", recovery_lost); } // 修復する必要があるかどうか if (block_lost == 0){ if (need_repair > 0){ need_repair &= 0x3FFFFFFF; printf("Restored file count\t: %d\n\n", need_repair >> 16); need_repair = (need_repair & 0xFFFF) - (need_repair >> 16); if (need_repair == 0){ // 全て修復できたのなら printf("Repaired successfully\n"); err |= 16; } else { printf("Failed to repair %d file(s)\n", need_repair); err |= 16 | 4; } } goto error_end; } else { if (need_repair > 0){ printf("Restored file count\t: %d\n\n", (need_repair >> 16) & 0x3FFF); if (need_repair & 0x40000000){ need_repair = (need_repair & 0xFFFF) - ((need_repair >> 16) & 0x3FFF); printf("Failed to repair %d file(s)\n", block_lost + need_repair); err |= 16 | 4; goto error_end; } need_repair &= 0x3FFFFFFF; need_repair = (need_repair & 0xFFFF) - (need_repair >> 16); } if (block_lost > parity_num){ printf("Need %d more volume(s) to repair %d file(s)\n", block_lost - parity_num, block_lost); err |= 8 | 4; goto error_end; } else { printf("Ready to repair %d file(s)\n", block_lost); } } // 失われたブロックを復元する printf("\n"); print_progress_text(0, "Recovering data"); if (err = rs_decode(block_max, block_lost, block_size, parity_max, exist, files)){ goto error_end; } // 正しく修復できたか確かめる printf("\nVerifying repair: %d\n", block_lost); printf(" Status : Filename\n"); fflush(stdout); wcscpy(file_path, base_dir); find_flag = 0; source_num = 0; memcpy(&list_off, header_buf + 64, 4); for (i = 0; i < file_num; i++){ bad_flag = 0; // entry size memcpy(&entry_size, header_buf + list_off, 4); // status field memcpy(&parity_flag, header_buf + (list_off + 8), 2); parity_flag &= 0x0001; // bit 0 = file is saved in the parity volume set // size memcpy(&data_size, header_buf + (list_off + 16), 8); // filename len = (entry_size - 56) / 2; if (len >= MAX_LEN) len = MAX_LEN - 1; memcpy(file_name, header_buf + (list_off + 56), len * 2); file_name[len] = 0; utf16_to_cp(file_name, ascii_buf); sanitize_filename(file_name); // ファイル名を基準ディレクトリに追加してパスにする wcscpy(file_path + base_len, file_name); //printf("%d : list_off = %d, exist = %d \n", i, list_off, exist[source_num]); // 修復したファイルのハッシュ値を計算する if (parity_flag){ if (exist[source_num] == 0){ if (file_md5(file_name, files[source_num].hFile, data_size, hash)){ bad_flag = 1; } else { for (j = 0; j < 16; j++){ if (hash[j] != header_buf[list_off + 24 + j]){ bad_flag = 1; break; } } } CloseHandle(files[source_num].hFile); files[source_num].hFile = NULL; get_temp_name(file_path, find_path); if (bad_flag){ // 失敗 DeleteFile(find_path); // テンポラリ・ファイルを削除する printf(" Failed : \"%s\"\n", ascii_buf); } else { // 復元成功 if (replace_file(file_path, find_path, switch_b) == 0){ // 修復したファイルを戻す block_lost--; find_flag++; printf(" Repaired : \"%s\"\n", ascii_buf); } else { // ファイルを戻せなかった場合は、テンポラリ・ファイルを残した方がいいかも？ // まあ PAR2 と違ってすぐに修復できるから、削除してもよさそう。 DeleteFile(find_path); // テンポラリ・ファイルを削除する printf(" Locked : \"%s\"\n", ascii_buf); } } fflush(stdout); } source_num++; } list_off += entry_size; // 次のエントリー位置にずらす } printf("\nRepaired file count\t: %d\n\n", find_flag); err = 16; if (block_lost + need_repair == 0){ // 全て修復できたなら printf("Repaired successfully\n"); } else { printf("Failed to repair %d file(s)\n", block_lost + need_repair); err |= 4; } if (recovery_lost > 0) err |= 256; error_end: close_ini_file(); if (files){ // エラーが発生したら、作業中のファイルを削除する source_num = 0; memcpy(&list_off, header_buf + 64, 4); for (i = 0; i < file_num; i++){ // entry size memcpy(&entry_size, header_buf + list_off, 4); // status field memcpy(&parity_flag, header_buf + (list_off + 8), 2); parity_flag &= 0x0001; // bit 0 = file is saved in the parity volume set // filename len = (entry_size - 56) / 2; if (len >= MAX_LEN) len = MAX_LEN - 1; memcpy(file_name, header_buf + (list_off + 56), len * 2); file_name[len] = 0; sanitize_filename(file_name); // ファイル名を基準ディレクトリに追加してパスにする wcscpy(file_path + base_len, file_name); if (parity_flag){ if ((exist[source_num] == 0) && (files[source_num].hFile)){ CloseHandle(files[source_num].hFile); files[source_num].hFile = NULL; get_temp_name(file_path, find_path); DeleteFile(find_path); // テンポラリ・ファイルを削除する } source_num++; } list_off += entry_size; // 次のエントリー位置にずらす } for (i = 0; i < (source_num + parity_max); i++){ if (files[i].hFile != NULL) CloseHandle(files[i].hFile); } free(files); } if (hFile != NULL) CloseHandle(hFile); if (header_buf) free(header_buf); if (header_buf2) free(header_buf2); return err; } // ソース・ファイルの一覧を表示する int par1_list( int switch_h, // ハッシュ値も表示する wchar_t *par_comment) // コメント { char ascii_buf[MAX_LEN * 3]; unsigned char *header_buf = NULL, hash[16]; wchar_t file_name[MAX_LEN]; int err = 0, i, parity_flag; int len, buf_size, entry_size, blk; int volume_num, file_num, list_off, list_size, data_off; int source_num = 0; __int64 file_size, data_size, block_size = 0; HANDLE hFile = NULL; // 指定されたリカバリ・ファイルを開く hFile = CreateFile(recovery_file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile == INVALID_HANDLE_VALUE){ print_win32_err(); printf("cannot open PAR file\n"); err = 1; goto error_end; } // ファイルのサイズを取得する if (!GetFileSizeEx(hFile, (PLARGE_INTEGER)&file_size)){ print_win32_err(); err = 1; goto error_end; } // ヘッダー用のバッファーを確保する buf_size = 0x0060 + ((0x0038 + (260 * 2)) * 256) + (COMMENT_LEN * 2); // 最大サイズ if ((__int64)buf_size > file_size) buf_size = (unsigned int)file_size; header_buf = malloc(buf_size); if (header_buf == NULL){ printf("malloc, %d\n", buf_size); err = 1; goto error_end; } // PAR や PXX ファイルとして正しいかを調べる if (err = get_header(NULL, hFile, header_buf, buf_size, hash, &volume_num, &file_num, &list_off, &list_size, &data_off, &data_size)){ if (err != 2) // キャンセル以外なら printf("valid file is not found\n"); goto error_end; } else { if ((volume_num == 0) && (data_size > 0)){ // コメントがある len = (int)data_size; if (buf_size < (int)data_size) len = buf_size; if (len > 1) read_comment(par_comment, header_buf + data_off, len); if (!utf16_to_cp(par_comment, ascii_buf)) printf("Comment : %s\n", ascii_buf); // コメントをユニコードから戻せた場合だけ表示する } } CloseHandle(hFile); hFile = NULL; printf("Input File list : %d\n", file_num); if (switch_h){ printf(" Size B MD5 Hash : Filename\n"); } else { printf(" Size B : Filename\n"); } // ソース・ファイルの情報を表示する for (i = 0; i < file_num; i++){ // entry size memcpy(&entry_size, header_buf + list_off, 4); // status field memcpy(&parity_flag, header_buf + (list_off + 8), 2); parity_flag &= 0x01; // bit 0 = file is saved in the parity volume set if (parity_flag){ source_num++; blk = 1; } else { blk = 0; } // size memcpy(&file_size, header_buf + (list_off + 16), 8); if (file_size > block_size) block_size = file_size; // hash memcpy(hash, header_buf + (list_off + 40), 16); // filename len = (entry_size - 56) / 2; if (len >= MAX_LEN) len = MAX_LEN - 1; memcpy(file_name, header_buf + (list_off + 56), len * 2); file_name[len] = 0; utf16_to_cp(file_name, ascii_buf); // 項目番号、ソース・ブロックかどうか、ファイル・サイズ、MD5ハッシュ値、ファイル名 if (switch_h){ printf("%13I64u %d ", file_size, blk); print_hash(hash); printf(" : \"%s\"\n", ascii_buf); } else { printf("%13I64u %d : \"%s\"\n", file_size, blk, ascii_buf); } list_off += entry_size; // 次のエントリー位置にずらす } // 調べた結果を表示する printf("\nData File count : %d\n", source_num); printf("Max file size\t: %I64u\n", block_size); printf("\nListed successfully\n"); error_end: if (header_buf) free(header_buf); if (hFile != NULL) CloseHandle(hFile); return err; } // CRC-32 チェックサムを使って自分自身の破損を検出する int par1_checksum(wchar_t *uni_buf) // 作業用 { unsigned int crc, chk, chk2; unsigned int len, tmp, i; unsigned char *pAddr, *p; HANDLE hFile, hMap; // 実行ファイルのパスを取得する tmp = GetModuleFileName(NULL, uni_buf, MAX_LEN); if ((tmp == 0) || (tmp >= MAX_LEN)) return 1; //printf("%S\n", uni_buf); // 実行ファイルの PE checksum と CRC-32 を検証する hFile = CreateFile(uni_buf, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (hFile == INVALID_HANDLE_VALUE){ print_win32_err(); return 1; } len = GetFileSize(hFile, &chk2); if (len == INVALID_FILE_SIZE) return 1; hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, chk2, len, NULL); if (hMap == NULL){ CloseHandle(hFile); return 1; } pAddr = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, len); if (pAddr == NULL){ CloseHandle(hMap); CloseHandle(hFile); return 1; } if (CheckSumMappedFile(pAddr, len, &chk2, &chk) == NULL){ // PE checksum UnmapViewOfFile(pAddr); CloseHandle(hMap); CloseHandle(hFile); return 1; } crc = 0xFFFFFFFF; p = pAddr; while (len--){ tmp = (*p++); for (i = 0; i < 8; i++){ if ((tmp ^ crc) & 1){ crc = (crc >> 1) ^ 0xEDB88320; } else { crc = crc >> 1; } tmp = tmp >> 1; } } crc ^= 0xFFFFFFFF; UnmapViewOfFile(pAddr); CloseHandle(hMap); CloseHandle(hFile); if (chk != chk2) return 2; if (crc != 0x11111111) return 3; return 0; }