King_DuckZ/unalz
1
0
Fork 0
forked from mirror/unalz
Code Issues Pull requests Releases Wiki Activity

Remove trailing whitespaces

Browse source
This commit is contained in:
King_DuckZ 2020-05-05 15:49:10 +02:00
parent 7359ce3931
commit 4afee05a12
2 changed files with 148 additions and 148 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

260
UnAlz.cpp
View file

@ -23,8 +23,8 @@
#endif
// mkdir
#ifdef _WIN32
# include <direct.h>
#ifdef _WIN32
# include <direct.h>
#else
# include <sys/stat.h>
#endif
@ -39,7 +39,7 @@
#if defined(__NetBSD__)
# include <sys/param.h> // __NetBSD_Version__
# include <errno.h> // iconv.h 때문에 필요
# include <errno.h> // iconv.h 때문에 필요
#endif
#ifdef _WIN32 // safe string 처리
@ -86,8 +86,8 @@ static UINT64 le64tobe(UINT64 a){return swapint64(a);}
static time_t dosTime2TimeT(UINT32 dostime) // from INFO-ZIP src
{
struct tm t;
t.tm_isdst = -1;
struct tm t;
t.tm_isdst = -1;
t.tm_sec = (((int)dostime) << 1) & 0x3e;
t.tm_min = (((int)dostime) >> 5) & 0x3f;
t.tm_hour = (((int)dostime) >> 11) & 0x1f;
@ -97,13 +97,13 @@ static time_t dosTime2TimeT(UINT32 dostime) // from INFO-ZIP src
return mktime(&t);
}
static BOOL IsBigEndian(void)
static BOOL IsBigEndian(void)
{
union {
short a;
char b[2];
} endian;
endian.a = 0x0102;
if(endian.b[0] == 0x02) return FALSE;
return TRUE;
@ -142,7 +142,7 @@ static const char* errorstrtable[]=
"error at read header", // ERR_AT_READ_HEADER
"invalid filename length", // ERR_INVALID_FILENAME_LENGTH
"invalid extrafield length", // ERR_INVALID_EXTRAFIELD_LENGTH,
"can't read central directory structure head", // ERR_CANT_READ_CENTRAL_DIRECTORY_STRUCTURE_HEAD,
"can't read central directory structure head", // ERR_CANT_READ_CENTRAL_DIRECTORY_STRUCTURE_HEAD,
"invalid filename size", // ERR_INVALID_FILENAME_SIZE,
"invalid extrafield size", // ERR_INVALID_EXTRAFIELD_SIZE,
"invalid filecomment size", // ERR_INVALID_FILECOMMENT_SIZE,
@ -153,16 +153,16 @@ static const char* errorstrtable[]=
"bzip2 decompress failed", // ERR_BZIP2_FAILED,
"invalid file CRC", // ERR_INVALID_FILE_CRC
"unknown compression method", // ERR_UNKNOWN_COMPRESSION_METHOD
"iconv-can't open iconv", // ERR_ICONV_CANT_OPEN,
"iconv-invalid multisequence of characters", // ERR_ICONV_INVALID_MULTISEQUENCE_OF_CHARACTERS,
"iconv-incomplete multibyte sequence", // ERR_ICONV_INCOMPLETE_MULTIBYTE_SEQUENCE,
"iconv-not enough space of buffer to convert", // ERR_ICONV_NOT_ENOUGH_SPACE_OF_BUFFER_TO_CONVERT,
"iconv-etc", // ERR_ICONV_ETC,
"password was not set", // ERR_PASSWD_NOT_SET,
"invalid password", // ERR_INVALID_PASSWD,
"user aborted",
"user aborted",
};
@ -191,7 +191,7 @@ CUnAlz::CUnAlz()
#ifdef _UNALZ_UTF8
safe_strcpy(m_szToCodepage, "UTF-8",UNALZ_LEN_CODEPAGE) ; // 기본적으로 utf-8
#else
#else
safe_strcpy(m_szToCodepage, "CP949",UNALZ_LEN_CODEPAGE) ; // 기본적으로 CP949
#endif // _UNALZ_UTF8
@ -239,8 +239,8 @@ void CUnAlz::SetCallback(_UnAlzCallback* pFunc, void* param)
#if !defined(__GNUWIN32__) && !defined(__GNUC__)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 파일 열기
/// @param szPathName
/// @return
/// @param szPathName
/// @return
/// @date 2004-03-06 오후 11:03:59
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::Open(LPCWSTR szPathName)
@ -251,8 +251,8 @@ BOOL CUnAlz::Open(LPCWSTR szPathName)
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 대상 파일 세팅하기.
/// @param szFileName
/// @return
/// @param szFileName
/// @return
/// @date 2004-03-06 오후 11:06:20
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::SetCurrentFile(LPCWSTR szFileName)
@ -274,7 +274,7 @@ BOOL CUnAlz::IsFolder(LPCWSTR szPathName)
BOOL CUnAlz::Open(const char* szPathName)
{
if(FOpen(szPathName)==FALSE)
if(FOpen(szPathName)==FALSE)
{
m_nErr = ERR_CANT_OPEN_FILE;
return FALSE;
@ -304,7 +304,7 @@ BOOL CUnAlz::Open(const char* szPathName)
return FALSE; // 깨진 파일..
}
if(sig==SIG_ALZ_FILE_HEADER)
if(sig==SIG_ALZ_FILE_HEADER)
{
ret = ReadAlzFileHeader();
bValidAlzHeader = TRUE; // alz 파일은 맞다.
@ -319,8 +319,8 @@ BOOL CUnAlz::Open(const char* szPathName)
m_nErr = ERR_CORRUPTED_FILE;
return FALSE;
}
if(ret==FALSE)
if(ret==FALSE)
{
return FALSE;
}
@ -333,7 +333,7 @@ BOOL CUnAlz::Open(const char* szPathName)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 파일 닫기..
/// @return
/// @return
/// @date 2004-03-06 오후 11:04:21
////////////////////////////////////////////////////////////////////////////////////////////////////
void CUnAlz::Close()
@ -353,7 +353,7 @@ void CUnAlz::Close()
////////////////////////////////////////////////////////////////////////////////////////////////////
/// FILE 내의 SIGNATURE 읽기
/// @return
/// @return
/// @date 2004-03-06 오후 11:04:47
////////////////////////////////////////////////////////////////////////////////////////////////////
CUnAlz::SIGNATURE CUnAlz::ReadSignature()
@ -372,7 +372,7 @@ CUnAlz::SIGNATURE CUnAlz::ReadSignature()
////////////////////////////////////////////////////////////////////////////////////////////////////
/// ALZ HEADER SIGNATURE 읽기
/// @return
/// @return
/// @date 2004-03-06 오후 11:05:11
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::ReadAlzFileHeader()
@ -389,7 +389,7 @@ BOOL CUnAlz::ReadAlzFileHeader()
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 각각의 파일 헤더 읽기
/// @return
/// @return
/// @date 2004-03-06 오후 11:05:18
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::ReadLocalFileheader()
@ -398,7 +398,7 @@ BOOL CUnAlz::ReadLocalFileheader()
int ret;
ret = FRead(&(zipHeader.head), sizeof(zipHeader.head));
if(ret==FALSE)
if(ret==FALSE)
{
m_nErr = ERR_AT_READ_HEADER;
return FALSE;
@ -411,7 +411,7 @@ BOOL CUnAlz::ReadLocalFileheader()
if( (zipHeader.head.fileDescriptor & (SHORT)8) != 0){
m_bIsDataDescr = TRUE;
}
int byteLen = zipHeader.head.fileDescriptor/0x10;
if(byteLen)
@ -424,11 +424,11 @@ BOOL CUnAlz::ReadLocalFileheader()
FRead(&(zipHeader.uncompressedSize), byteLen); // 압축 사이즈가 없다.
}
// little to system
// little to system
zipHeader.fileCRC = unalz_le32toh(zipHeader.fileCRC);
zipHeader.head.fileNameLength = unalz_le16toh(zipHeader.head.fileNameLength);
zipHeader.compressedSize = unalz_le64toh(zipHeader.compressedSize);
zipHeader.uncompressedSize = unalz_le64toh(zipHeader.uncompressedSize);
zipHeader.uncompressedSize = unalz_le64toh(zipHeader.uncompressedSize);
// FILE NAME
zipHeader.fileName = (char*)malloc(zipHeader.head.fileNameLength+sizeof(char));
@ -448,7 +448,7 @@ BOOL CUnAlz::ReadLocalFileheader()
if(strlen(m_szToCodepage))
{
#define ICONV_BUF_SIZE (260*6) // utf8 은 최대 6byte
#define ICONV_BUF_SIZE (260*6) // utf8 은 최대 6byte
size_t ileft, oleft;
iconv_t cd;
size_t iconv_result;
@ -461,15 +461,15 @@ BOOL CUnAlz::ReadLocalFileheader()
char *inptr = inbuf;
#endif
char *outptr = outbuf;
size = strlen(zipHeader.fileName)+1;
strncpy(inbuf, zipHeader.fileName, size);
ileft = size;
oleft = sizeof(outbuf);
cd = iconv_open(m_szToCodepage, m_szFromCodepage); // 보통 "CP949" 에서 "UTF-8" 로
cd = iconv_open(m_szToCodepage, m_szFromCodepage); // 보통 "CP949" 에서 "UTF-8" 로
iconv(cd, NULL, NULL, NULL, NULL);
if( cd == (iconv_t)(-1))
if( cd == (iconv_t)(-1))
{
m_nErr = ERR_ICONV_CANT_OPEN; // printf("Converting Error : Cannot open iconv");
return FALSE;
@ -477,21 +477,21 @@ BOOL CUnAlz::ReadLocalFileheader()
else
{
iconv_result = iconv(cd, &inptr, &ileft, &outptr, &oleft);
if(iconv_result== (size_t)(-1)) // iconv 실패..
{
if (errno == EILSEQ)
if (errno == EILSEQ)
m_nErr = ERR_ICONV_INVALID_MULTISEQUENCE_OF_CHARACTERS; // printf("Invalid Multibyte Sequence of Characters");
else if (errno == EINVAL)
else if (errno == EINVAL)
m_nErr = ERR_ICONV_INCOMPLETE_MULTIBYTE_SEQUENCE; //printf("Incomplete multibyte sequence");
else if (errno != E2BIG)
else if (errno != E2BIG)
m_nErr = ERR_ICONV_NOT_ENOUGH_SPACE_OF_BUFFER_TO_CONVERT; // printf("Not enough space of buffer to convert");
else
else
m_nErr = ERR_ICONV_ETC;
iconv_close(cd);
return FALSE;
}
else
}
else
{
outbuf[ICONV_BUF_SIZE-oleft] = 0;
if(zipHeader.fileName) free(zipHeader.fileName);
@ -504,7 +504,7 @@ BOOL CUnAlz::ReadLocalFileheader()
}
// printf("\n Converted File Name : %s", outbuf);
}
iconv_close(cd);
}
@ -525,7 +525,7 @@ BOOL CUnAlz::ReadLocalFileheader()
}
*/
if(IsEncryptedFile(zipHeader.head.fileDescriptor))
if(IsEncryptedFile(zipHeader.head.fileDescriptor))
FRead(zipHeader.encChk, ALZ_ENCR_HEADER_LEN); // xf86
// SKIP FILE DATA
@ -542,9 +542,9 @@ BOOL CUnAlz::ReadLocalFileheader()
/*
#ifdef _DEBUG
printf("NAME:%s COMPRESSED SIZE:%d UNCOMPRESSED SIZE:%d COMP METHOD:%d\n",
zipHeader.fileName,
zipHeader.compressedSize,
printf("NAME:%s COMPRESSED SIZE:%d UNCOMPRESSED SIZE:%d COMP METHOD:%d\n",
zipHeader.fileName,
zipHeader.compressedSize,
zipHeader.uncompressedSize,
zipHeader.compressionMethod
);
@ -675,8 +675,8 @@ void CUnAlz::SetCurrentFile(FileList::iterator newPos)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 버퍼에 압축 풀기. 버퍼는 당근 충분한 크기가 준비되어 있어야 한다.
/// @param pDestBuf
/// @return
/// @param pDestBuf
/// @return
/// @date 2004-03-07 오전 12:26:13
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::ExtractCurrentFileToBuf(BYTE* pDestBuf, int nBufSize)
@ -694,7 +694,7 @@ BOOL CUnAlz::ExtractCurrentFileToBuf(BYTE* pDestBuf, int nBufSize)
/// 현재 파일 (SetCurrentFile로 지)을 대상 경로에 대상 파일로 푼다.
/// @param szDestPathName - 대상 경로
/// @param szDestFileName - 대상 파일명, NULL 이면 원래 파일명 사용
/// @return
/// @return
/// @date 2004-03-06 오후 11:06:59
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::ExtractCurrentFile(const char* szDestPathName, const char* szDestFileName)
@ -704,8 +704,8 @@ BOOL CUnAlz::ExtractCurrentFile(const char* szDestPathName, const char* szDestFi
SExtractDest dest;
char szDestPathFileName[MAX_PATH];
if(chkValidPassword() == FALSE)
if(chkValidPassword() == FALSE)
{
return FALSE;
}
@ -718,7 +718,7 @@ BOOL CUnAlz::ExtractCurrentFile(const char* szDestPathName, const char* szDestFi
m_nErr = ERR_GENERAL;
return FALSE;
}
// 경로명
safe_strcpy(szDestPathFileName, szDestPathName, MAX_PATH);
if(szDestPathFileName[strlen(szDestPathFileName)]!=PATHSEPC)
@ -737,9 +737,9 @@ BOOL CUnAlz::ExtractCurrentFile(const char* szDestPathName, const char* szDestFi
return FALSE;
}
#ifndef _WIN32
#ifndef _WIN32
{
char* p = szDestPathFileName; // 경로 delimiter 바꾸기
char* p = szDestPathFileName; // 경로 delimiter 바꾸기
while(*p)
{
if(*p=='\\') *p='/';
@ -768,14 +768,14 @@ BOOL CUnAlz::ExtractCurrentFile(const char* szDestPathName, const char* szDestFi
}
// 파일 열기 실패시 - 경로를 파본다
if(dest.fp==NULL)
if(dest.fp==NULL)
{
DigPath(szDestPathFileName);
dest.fp = fopen(szDestPathFileName, "wb");
}
// 그래도 파일열기 실패시.
if(dest.fp==NULL)
if(dest.fp==NULL)
{
// 대상 파일 열기 실패
m_nErr = ERR_CANT_OPEN_DEST_FILE;
@ -808,8 +808,8 @@ BOOL CUnAlz::ExtractCurrentFile(const char* szDestPathName, const char* szDestFi
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 대상에 압축 풀기..
/// @param dest
/// @return
/// @param dest
/// @return
/// @date 2004-03-07 오전 12:44:36
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::ExtractTo(SExtractDest* dest)
@ -830,11 +830,11 @@ BOOL CUnAlz::ExtractTo(SExtractDest* dest)
}
else // COMP_UNKNOWN
{
// alzip 5.6 부터 추가된 포맷(5.5 에서는 풀지 못한다. 영문 5.51 은 푼다 )
// alzip 5.6 부터 추가된 포맷(5.5 에서는 풀지 못한다. 영문 5.51 은 푼다 )
// 하지만 어떤 버전에서 이 포맷을 만들어 내는지 정확히 알 수 없다.
// 공식으로 릴리즈된 알집은 이 포맷을 만들어내지 않는다. 비공식(베타?)으로 배포된 버전에서만 이 포맷을 만들어낸다.
m_nErr = ERR_UNKNOWN_COMPRESSION_METHOD;
ASSERT(0);
ASSERT(0);
ret = FALSE;
}
return ret;
@ -844,7 +844,7 @@ BOOL CUnAlz::ExtractTo(SExtractDest* dest)
/// DEFLATE 로 풀기 - 테스트용 함수. 모든 파일을 한꺼번에 읽어서 푼다. 실제 사용 안함.
/// @param fp - 대상 파일
/// @param file - 소스 파일 정보
/// @return
/// @return
/// @date 2004-03-06 오후 11:09:17
////////////////////////////////////////////////////////////////////////////////////////////////////
/*
@ -915,7 +915,7 @@ END :
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 대상 폴더에 현재 압축파일을 전부 풀기
/// @param szDestPathName - 대상 경로
/// @return
/// @return
/// @date 2004-03-06 오후 11:09:49
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::ExtractAll(const char* szDestPathName)
@ -926,7 +926,7 @@ BOOL CUnAlz::ExtractAll(const char* szDestPathName)
{
m_posCur = i;
if(ExtractCurrentFile(szDestPathName)==FALSE) return FALSE;
if(m_bHalt)
if(m_bHalt)
break; // 멈추기..
}
@ -935,8 +935,8 @@ BOOL CUnAlz::ExtractAll(const char* szDestPathName)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 대상 경로 파기 - 압축 파일 내에 폴더 정보가 있을 경우, 다중 폴더를 판다(dig)
/// @param szPathName
/// @return
/// @param szPathName
/// @return
/// @date 2004-03-06 오후 11:10:12
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::DigPath(const char* szPathName)
@ -951,7 +951,7 @@ BOOL CUnAlz::DigPath(const char* szPathName)
last = dup + strlen(dup);
while(last!=dup)
{
if(*last=='/' || *last=='\\')
if(*last=='/' || *last=='\\')
{
*last = (char)NULL;
break;
@ -959,7 +959,7 @@ BOOL CUnAlz::DigPath(const char* szPathName)
last --;
}
token = strtok( dup, seps );
while( token != NULL )
{
@ -994,8 +994,8 @@ BOOL CUnAlz::DigPath(const char* szPathName)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 제대로된 폴더 인가?
/// @param szPathName
/// @return
/// @param szPathName
/// @return
/// @date 2004-03-06 오후 11:03:26
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::IsFolder(const CHAR* szPathName)
@ -1073,7 +1073,7 @@ BOOL CUnAlz::ExtractBzip2_bak(FILE* fp, SAlzLocalFileHeader& file)
UINT32 crc = 0xffffffff;
//BYTE temp[100];
memset(&stream, 0, sizeof(stream));
pInBuf = (BYTE*)malloc(nInBufSize + BZIP2_HEADER_SIZE + BZIP2_CRC_SIZE - ALZDLZ_HEADER_SIZE + BZIP2_TAIL_SIZE);
@ -1149,7 +1149,7 @@ END :
/// RAW 로 압축된 파일 풀기
/// @param fp - 대상 파일
/// @param file - 소스 파일
/// @return
/// @return
/// @date 2004-03-06 오후 11:10:53
////////////////////////////////////////////////////////////////////////////////////////////////////
#define BUF_LEN (4096*2)
@ -1196,7 +1196,7 @@ BOOL CUnAlz::ExtractRawfile(SExtractDest* dest, SAlzLocalFileHeader& file)
if(m_pFuncCallBack)
{
m_pFuncCallBack(NULL, nWritten, file.uncompressedSize, m_pCallbackParam, &bHalt);
if(bHalt)
if(bHalt)
{
break;
}
@ -1225,7 +1225,7 @@ BOOL CUnAlz::ExtractRawfile(SExtractDest* dest, SAlzLocalFileHeader& file)
/// BZIP2 압축 풀기..
/// @param fp_w - 대상 파일
/// @param file - 소스 파일 정보
/// @return
/// @return
/// @date 2004-03-01 오전 5:47:36
////////////////////////////////////////////////////////////////////////////////////////////////////
#define BZIP2_EXTRACT_BUF_SIZE 0x2000
@ -1263,7 +1263,7 @@ BOOL CUnAlz::ExtractBzip2(SExtractDest* dest, SAlzLocalFileHeader& file)
if(m_pFuncCallBack)
{
m_pFuncCallBack(NULL, nWritten, file.uncompressedSize, m_pCallbackParam, &bHalt);
if(bHalt)
if(bHalt)
{
break;
}
@ -1292,7 +1292,7 @@ BOOL CUnAlz::ExtractBzip2(SExtractDest* dest, SAlzLocalFileHeader& file)
}
/*
/*
// FILE* 를 사용할경우 사용하던 코드. - 멀티 볼륨 지원 안함..
BZFILE *bzfp = NULL;
int smallMode = 0;
@ -1318,7 +1318,7 @@ BOOL CUnAlz::ExtractBzip2(SExtractDest* dest, SAlzLocalFileHeader& file)
if(m_pFuncCallBack)
{
m_pFuncCallBack(NULL, nWritten, file.uncompressedSize, m_pCallbackParam, &bHalt);
if(bHalt)
if(bHalt)
{
break;
}
@ -1343,9 +1343,9 @@ BOOL CUnAlz::ExtractBzip2(SExtractDest* dest, SAlzLocalFileHeader& file)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// deflate 로 압축 풀기. ExtractDeflate() 와 달리 조금씩 읽어서 푼다.
/// @param fp
/// @param file
/// @return
/// @param fp
/// @param file
/// @return
/// @date 2004-03-06 오후 11:11:36
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::ExtractDeflate2(SExtractDest* dest, SAlzLocalFileHeader& file)
@ -1395,12 +1395,12 @@ BOOL CUnAlz::ExtractDeflate2(SExtractDest* dest, SAlzLocalFileHeader& file)
m_nErr = ERR_CANT_READ_FILE;
goto END;
}
if(bIsEncrypted)
DecryptingData(uReadThis, pInBuf); // xf86
// dwCRC32 = crc32(dwCRC32,pInBuf, (UINT)(uReadThis));
nRestReadCompressed -= uReadThis;
stream.next_in = pInBuf;
stream.avail_in = uReadThis;
@ -1418,13 +1418,13 @@ BOOL CUnAlz::ExtractDeflate2(SExtractDest* dest, SAlzLocalFileHeader& file)
uTotalOutAfter = stream.total_out;
uOutThis = uTotalOutAfter-uTotalOutBefore;
dwCRC32 = crc32(dwCRC32,bufBefore, (UINT)(uOutThis));
rest_read_uncompressed -= uOutThis;
iRead += (UINT)(uTotalOutAfter - uTotalOutBefore);
WriteToDest(dest, pOutBuf, uOutThis);
//fwrite(pOutBuf, uOutThis, 1, fp); // file 에 쓰기.
stream.next_out = pOutBuf;
@ -1436,7 +1436,7 @@ BOOL CUnAlz::ExtractDeflate2(SExtractDest* dest, SAlzLocalFileHeader& file)
if(m_pFuncCallBack)
{
m_pFuncCallBack(NULL, nWritten, file.uncompressedSize, m_pCallbackParam, &bHalt);
if(bHalt)
if(bHalt)
{
m_nErr = ERR_USER_ABORTED;
break;
@ -1446,7 +1446,7 @@ BOOL CUnAlz::ExtractDeflate2(SExtractDest* dest, SAlzLocalFileHeader& file)
if (err==Z_STREAM_END)
break;
//if(iRead==0) break; // UNZ_EOF;
if (err!=Z_OK)
if (err!=Z_OK)
{
m_nErr = ERR_INFLATE_FAILED;
goto END;
@ -1476,8 +1476,8 @@ END :
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 파일 열기
/// @param szPathName
/// @return
/// @param szPathName
/// @return
/// @date 2004-10-02 오후 11:47:14
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::FOpen(const char* szPathName)
@ -1494,7 +1494,7 @@ BOOL CUnAlz::FOpen(const char* szPathName)
m_bIsEOF = FALSE;
for(i=0;i<MAX_FILES;i++) // aa.alz 파일명을 가지고 aa.a00 aa.a01 aa.a02 .. 만들기
{
if(i>0)
if(i>0)
safe_sprintf(temp+nLen-3, 4, "%c%02d", (i-1)/100+'a', (i-1)%100);
#ifdef _WIN32
@ -1505,7 +1505,7 @@ BOOL CUnAlz::FOpen(const char* szPathName)
m_files[i].fp = fopen(temp, "rb");
if(m_files[i].fp==NULL) break;
dwFileSizeHigh=0;
unalz_fseek(m_files[i].fp,0,SEEK_END);
unalz_fseek(m_files[i].fp,0,SEEK_END);
nFileSizeLow=unalz_ftell(m_files[i].fp);
unalz_fseek(m_files[i].fp,0,SEEK_SET);
#endif
@ -1523,7 +1523,7 @@ BOOL CUnAlz::FOpen(const char* szPathName)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 파일 닫기
/// @return
/// @return
/// @date 2004-10-02 오후 11:48:53
////////////////////////////////////////////////////////////////////////////////////////////////////
void CUnAlz::FClose()
@ -1545,7 +1545,7 @@ void CUnAlz::FClose()
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 파일의 끝인가?
/// @return
/// @return
/// @date 2004-10-02 오후 11:48:21
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::FEof()
@ -1561,7 +1561,7 @@ BOOL CUnAlz::FEof()
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 현재 파일 위치
/// @return
/// @return
/// @date 2004-10-02 오후 11:50:50
////////////////////////////////////////////////////////////////////////////////////////////////////
INT64 CUnAlz::FTell()
@ -1571,9 +1571,9 @@ INT64 CUnAlz::FTell()
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 파일 위치 세팅
/// @param offset
/// @param origin
/// @return
/// @param offset
/// @param origin
/// @return
/// @date 2004-10-02 오후 11:51:53
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::FSeek(INT64 offset)
@ -1609,10 +1609,10 @@ BOOL CUnAlz::FSeek(INT64 offset)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 파일 읽기
/// @param buffer
/// @param size
/// @param count
/// @return
/// @param buffer
/// @param size
/// @param count
/// @return
/// @date 2004-10-02 오후 11:44:05
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::FRead(void* buffer, UINT32 nBytesToRead, int* pTotRead )
@ -1635,14 +1635,14 @@ BOOL CUnAlz::FRead(void* buffer, UINT32 nBytesToRead, int* pTotRead )
}
#ifdef _WIN32
ret = ReadFile(m_files[m_nCurFile].fp, ((BYTE*)buffer)+dwTotRead, dwRead, (DWORD*)&nNumOfBytesRead, NULL);
if(ret==FALSE && GetLastError()==ERROR_HANDLE_EOF)
if(ret==FALSE && GetLastError()==ERROR_HANDLE_EOF)
{
m_bIsEOF = TRUE;return FALSE;
}
#else
nNumOfBytesRead = fread(((BYTE*)buffer)+dwTotRead, 1,dwRead ,m_files[m_nCurFile].fp);
if(nNumOfBytesRead<=0)
if(nNumOfBytesRead<=0)
{
m_bIsEOF = TRUE;return FALSE;
}
@ -1685,14 +1685,14 @@ BOOL CUnAlz::FRead(void* buffer, UINT32 nBytesToRead, int* pTotRead )
else
if(m_nCurFilePos>m_files[m_nCurFile].nFileSize-m_files[m_nCurFile].nMultivolTailSize) ASSERT(0);
}
return ret;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// error code 를 스트링으로 바꿔 준다.
/// @param nERR
/// @return
/// @param nERR
/// @return
/// @date 2004-10-24 오후 3:28:39
////////////////////////////////////////////////////////////////////////////////////////////////////
const char* CUnAlz::LastErrToStr(ERR nERR)
@ -1747,7 +1747,7 @@ void CUnAlz::CryptInitKeys()
void CUnAlz::CryptUpdateKeys(CHAR c)
{
m_keys[0] = CryptCRC32(m_keys[0], c);
m_keys[1] += m_keys[0] & 0xff;
m_keys[1] = m_keys[1] * 134775813L + 1;
@ -1760,7 +1760,7 @@ BOOL CUnAlz::CryptCheck(CHAR *buf)
CHAR b = 0;
for (int i = 0; i < ALZ_ENCR_HEADER_LEN; i++)
{
b = buf[i];
b = buf[i];
CryptDecode((CHAR&)b);
}
@ -1791,8 +1791,8 @@ UINT32 CUnAlz::CryptCRC32(UINT32 l, CHAR c)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 암호걸린 파일인지 여부
/// @param fileDescriptor
/// @return
/// @param fileDescriptor
/// @return
/// @date 2004-11-27 오후 11:25:32
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::IsEncryptedFile(BYTE fileDescriptor)
@ -1806,8 +1806,8 @@ BOOL CUnAlz::IsEncryptedFile()
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 암호로 키 초기화
/// @param szPassword
/// @return
/// @param szPassword
/// @return
/// @date 2004-11-27 오후 11:04:01
////////////////////////////////////////////////////////////////////////////////////////////////////
void CUnAlz::InitCryptKeys(const CHAR* szPassword)
@ -1825,8 +1825,8 @@ void CUnAlz::InitCryptKeys(const CHAR* szPassword)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 데이타로 키 업데이트하기
/// @param c
/// @return
/// @param c
/// @return
/// @date 2004-11-27 오후 11:04:09
////////////////////////////////////////////////////////////////////////////////////////////////////
void CUnAlz::UpdateKeys(BYTE c)
@ -1838,9 +1838,9 @@ void CUnAlz::UpdateKeys(BYTE c)
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 암호가 맞는지 헤더 체크하기
/// @param buf
/// @return
/// 암호가 맞는지 헤더 체크하기
/// @param buf
/// @return
/// @date 2004-11-27 오후 11:04:24
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::CryptCheck(const BYTE* buf)
@ -1861,12 +1861,12 @@ BOOL CUnAlz::CryptCheck(const BYTE* buf)
if (IsDataDescr()) // Data descriptor present
return (m_posCur->head.fileTimeDate >> 8) == c;
else
return ( ((m_posCur->fileCRC)>>24) ) == c; // 파일 crc 의 최상위 byte
return ( ((m_posCur->fileCRC)>>24) ) == c; // 파일 crc 의 최상위 byte
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 키에서 데이타 추출
/// @return
/// @return
/// @date 2004-11-27 오후 11:05:36
////////////////////////////////////////////////////////////////////////////////////////////////////
BYTE CUnAlz::DecryptByte()
@ -1878,9 +1878,9 @@ BYTE CUnAlz::DecryptByte()
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 데이타 압축 풀기
/// @param nSize
/// @param data
/// @return
/// @param nSize
/// @param data
/// @return
/// @date 2004-11-27 오후 11:03:30
////////////////////////////////////////////////////////////////////////////////////////////////////
void CUnAlz::DecryptingData(int nSize, BYTE* data)
@ -1900,9 +1900,9 @@ void CUnAlz::DecryptingData(int nSize, BYTE* data)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// CRC 테이블 참조
/// @param l
/// @param c
/// @return
/// @param l
/// @param c
/// @return
/// @date 2004-11-27 오후 11:14:16
////////////////////////////////////////////////////////////////////////////////////////////////////
UINT32 CUnAlz::CRC32(UINT32 l, BYTE c)
@ -1911,16 +1911,16 @@ UINT32 CUnAlz::CRC32(UINT32 l, BYTE c)
return CRC_TABLE[(l ^ c) & 0xff] ^ (l >> 8);
}
void CUnAlz::SetPassword(char *passwd)
{
if(strlen(passwd) == 0) return;
safe_strcpy(m_szPasswd, passwd, UNALZ_LEN_PASSWORD);
void CUnAlz::SetPassword(char *passwd)
{
if(strlen(passwd) == 0) return;
safe_strcpy(m_szPasswd, passwd, UNALZ_LEN_PASSWORD);
}
#ifdef _UNALZ_ICONV
void CUnAlz::SetDestCodepage(const char* szToCodepage)
{
safe_strcpy(m_szToCodepage, szToCodepage, UNALZ_LEN_CODEPAGE);
safe_strcpy(m_szToCodepage, szToCodepage, UNALZ_LEN_CODEPAGE);
}
#endif
@ -1928,9 +1928,9 @@ void CUnAlz::SetDestCodepage(const char* szToCodepage)
////////////////////////////////////////////////////////////////////////////////////////////////////
/// 문자열 처리 함수들
/// @param l
/// @param c
/// @return
/// @param l
/// @param c
/// @return
/// @date 2007-02
////////////////////////////////////////////////////////////////////////////////////////////////////
unsigned int CUnAlz::_strlcpy (char *dest, const char *src, unsigned int size)

36
UnAlzBzip2.cpp
View file

@ -1,12 +1,12 @@
////////////////////////////////////////////////////////////////////////////////////////////////////
///
///
/// bzip2 관련 file i/o 함수들 - 원래 UnAlzbzlib.c (bzlib.c) 에 있던 함수들은 분할 압축 처리를 위해서
/// 약간의 수정을 가한 소스들이다..
/// FILE* handle 관련 부분들이 수정되었다.
///
///
/// @author kippler@gmail.com
/// @date 2004-10-03 오후 3:09:11
///
///
////////////////////////////////////////////////////////////////////////////////////////////////////
//#include "stdafx.h"
@ -32,14 +32,14 @@ MybzFile;
////////////////////////////////////////////////////////////////////////////////////////////////////
/// BZIP2 파일 처리 함수
/// @param bzerror
/// @param f
/// @param verbosity
/// @param _small
/// @param unused
/// @param nUnused
/// @return
/// BZIP2 파일 처리 함수
/// @param bzerror
/// @param f
/// @param verbosity
/// @param _small
/// @param unused
/// @param nUnused
/// @return
/// @date 2004-10-03 오전 3:16:45
////////////////////////////////////////////////////////////////////////////////////////////////////
CUnAlz::MYBZFILE* CUnAlz::BZ2_bzReadOpen(int* bzerror, CUnAlz* f, int verbosity, int _small,void* unused, int nUnused)
@ -49,7 +49,7 @@ CUnAlz::MYBZFILE* CUnAlz::BZ2_bzReadOpen(int* bzerror, CUnAlz* f, int verbosity,
BZ_SETERR(BZ_OK);
if (f == NULL ||
if (f == NULL ||
(_small != 0 && _small != 1) ||
(verbosity < 0 || verbosity > 4) ||
(unused == NULL && nUnused != 0) ||
@ -60,7 +60,7 @@ CUnAlz::MYBZFILE* CUnAlz::BZ2_bzReadOpen(int* bzerror, CUnAlz* f, int verbosity,
// { BZ_SETERR(BZ_IO_ERROR); return NULL; };
bzf = (MybzFile*)malloc ( sizeof(MybzFile) );
if (bzf == NULL)
if (bzf == NULL)
{ BZ_SETERR(BZ_MEM_ERROR); return NULL; };
BZ_SETERR(BZ_OK);
@ -72,7 +72,7 @@ CUnAlz::MYBZFILE* CUnAlz::BZ2_bzReadOpen(int* bzerror, CUnAlz* f, int verbosity,
bzf->strm.bzalloc = NULL;
bzf->strm.bzfree = NULL;
bzf->strm.opaque = NULL;
while (nUnused > 0) {
bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++;
unused = ((void*)( 1 + ((UChar*)(unused)) ));
@ -87,7 +87,7 @@ CUnAlz::MYBZFILE* CUnAlz::BZ2_bzReadOpen(int* bzerror, CUnAlz* f, int verbosity,
bzf->strm.next_in = bzf->buf;
bzf->initialisedOk = True;
return bzf;
return bzf;
}
@ -126,7 +126,7 @@ int CUnAlz::BZ2_bzRead(int* bzerror, MYBZFILE* b, void* buf, int len)
while (True) {
// if (ferror(bzf->handle))
// if (ferror(bzf->handle))
// { BZ_SETERR(BZ_IO_ERROR); return 0; };
if (bzf->strm.avail_in == 0 && !bzf->handle->FEof()) {
@ -147,7 +147,7 @@ int CUnAlz::BZ2_bzRead(int* bzerror, MYBZFILE* b, void* buf, int len)
if (ret != BZ_OK && ret != BZ_STREAM_END)
{ BZ_SETERR(ret); return 0; };
if (ret == BZ_OK && bzf->handle->FEof() &&
if (ret == BZ_OK && bzf->handle->FEof() &&
bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)
{ BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
@ -156,7 +156,7 @@ int CUnAlz::BZ2_bzRead(int* bzerror, MYBZFILE* b, void* buf, int len)
return len - bzf->strm.avail_out; };
if (bzf->strm.avail_out == 0)
{ BZ_SETERR(BZ_OK); return len; };
}
return 0; /*not reached*/