HANDLE ComicBookRAR::openRar(RAROpenArchiveDataEx *flags, RARHeaderDataEx *header, wxUint8 mode)
{
HANDLE rarFile;
memset(flags, 0, sizeof(*flags));
#ifdef wxUSE_UNICODE
#ifdef __WXOSX__
const char *filenameData = filename.fn_str().data();
flags->ArcName = new char[strlen(filenameData) + 1];
strcpy(flags->ArcName, filenameData);
#else
flags->ArcNameW = new wchar_t[filename.Length() + 1];
wcscpy(flags->ArcNameW, filename.c_str());
#endif
#else // ASCII
flags->ArcName = new char[filename.Length() + 1];
strcpy(flags->ArcName, filename.c_str());
#endif
flags->CmtBuf = NULL;
flags->OpenMode = mode;
rarFile = RAROpenArchiveEx(flags);
if (flags->OpenResult != 0) {
closeRar(rarFile, flags);
throw ArchiveException(filename, OpenArchiveError(flags->OpenResult));
}
header->CmtBuf = NULL;
return rarFile;
}
JNIEXPORT jint JNICALL Java_com_ssb_droidsound_utils_UnRar_N_1extractAll(JNIEnv *env, jobject obj, jstring archive, jstring target) {
const char *targetDir = env->GetStringUTFChars(target, NULL);
const char *rarName = env->GetStringUTFChars(archive, NULL);
RAROpenArchiveDataEx archiveInfo;
memset(&archiveInfo, 0, sizeof(archiveInfo));
archiveInfo.CmtBuf = NULL;
//archiveInfo.OpenMode = RAR_OM_LIST;
archiveInfo.OpenMode = RAR_OM_EXTRACT;
archiveInfo.ArcName = (char*)rarName;
HANDLE rarFile = RAROpenArchiveEx(&archiveInfo);
RARHeaderDataEx fileInfo;
while(true) {
int RHCode = RARReadHeaderEx(rarFile, &fileInfo);
if(RHCode != 0) break;
__android_log_print(ANDROID_LOG_VERBOSE, "UnRar", "Extracting %s (%d => %d)", fileInfo.FileName, fileInfo.PackSize, fileInfo.UnpSize);
//RARSetCallback(rarFile, CallbackProc, NULL);
int PFCode = RARProcessFile(rarFile, RAR_EXTRACT, (char*)targetDir, NULL);
}
env->ReleaseStringUTFChars(archive, rarName);
env->ReleaseStringUTFChars(target, targetDir);
return 0;
}
}
HANDLE ImgBookRAR::openRar(string file, RAROpenArchiveDataEx *flags, RARHeaderDataEx *header, int mode)
{
HANDLE rarFile;
memset(flags, 0, sizeof(*flags));
flags->ArcName = new char[file.length() + 1];
strcpy(flags->ArcName, file.c_str());
flags->CmtBuf = NULL;
flags->OpenMode = mode;
rarFile = RAROpenArchiveEx(flags);
if (flags->OpenResult != 0)
{
closeRar(rarFile, flags);
string aux = openArchiveError(flags->OpenResult);
PV_LOGPRINTF("%s", aux.c_str());
return NULL;
// throw ArchiveException(filename, OpenArchiveError(flags->OpenResult));
}
header->CmtBuf = NULL;
int ExtractFile(char* filename)
{
char* outputFolder = "temp\\";
HANDLE hData;
INT RHCode;
INT PFCode;
RARHeaderData HeaderData;
RAROpenArchiveDataEx OpenArchiveData = { 0 };
{
OpenArchiveData.ArcName = filename;
//OpenArchiveData.CmtBuf = NULL;
//OpenArchiveData.CmtBufSize = 0;
OpenArchiveData.OpenMode = RAR_OM_EXTRACT;
}
hData = RAROpenArchiveEx(&OpenArchiveData);
if(OpenArchiveData.OpenResult != 0)
{
char buf[128];
memset(buf, 0, sizeof(buf));
sprintf_s(buf, "Error opening <%s>", filename);
MessageBox(NULL, "Error!", buf, MB_OK|MB_ICONERROR);
return -1;
}
RARSetPassword(hData, "8863da099df8adc830836744e19293ef");
while((RHCode = RARReadHeader(hData, &HeaderData)) == 0)
{
PFCode = RARProcessFile(hData, RAR_EXTRACT, outputFolder, NULL);
if(PFCode != 0)
{
char buf[128];
memset(buf, 0, sizeof(buf));
sprintf_s(buf, "Error extracting <%s>", filename);
MessageBox(NULL, "Error!", buf, MB_OK|MB_ICONERROR);
return -1;
}
struct stat st;
std::string file = outputFolder;
file += HeaderData.FileName;
stat(file.c_str(), &st);
if(st.st_mode & S_IFREG)
{
vfs->patchfiles.push_back(file);
}
}
if(RHCode == ERAR_BAD_DATA)
{
char buf[128];
memset(buf, 0, sizeof(buf));
sprintf_s(buf, "Error <%s> is corrupt", filename);
MessageBox(NULL, "Error!", buf, MB_OK|MB_ICONERROR);
return -1;
}
RARCloseArchive(hData);
DeleteFile(filename);
return 0;
}
void YKZip::Extra(const YKString& srcFile, const YKString& desPath, const YK_CHAR* passWord /* = "" */)
{
#if YK_OS == YK_OS_WINDOWS_NT
setlocale(LC_ALL, NULL);
HANDLE hArcData;
int RHCode,PFCode;
char CmtBuf[16384];
struct RARHeaderDataEx HeaderData;
struct RAROpenArchiveDataEx OpenArchiveData;
memset(&HeaderData,0,sizeof(HeaderData));
memset(&OpenArchiveData,0,sizeof(OpenArchiveData));
YKBuffer<YK_WCHAR> buffSrc(srcFile.size()+1);
std::wcscpy(buffSrc.Begin(), srcFile.c_str());
YKBuffer<YK_WCHAR> buffDes(desPath.size()+1);
std::wcscpy(buffDes.Begin(), desPath.c_str());
OpenArchiveData.ArcNameW = buffSrc.Begin();
OpenArchiveData.CmtBuf=CmtBuf;
OpenArchiveData.CmtBufSize=sizeof(CmtBuf);
OpenArchiveData.OpenMode=RAR_OM_EXTRACT;
OpenArchiveData.Callback=YK_NULL;
OpenArchiveData.UserData=0;
hArcData = RAROpenArchiveEx(&OpenArchiveData);
if (OpenArchiveData.OpenResult!=0)
return;
RARSetPassword(hArcData, const_cast<YK_CHAR*>(passWord));
while ((RHCode=RARReadHeaderEx(hArcData,&HeaderData))==0)
{
PFCode = RARProcessFileW(hArcData,RAR_EXTRACT,
buffDes.Begin(), NULL);
}
RARCloseArchive(hArcData);
#endif
// YKString strExtra = g_Application.GetCurModulePath();
// strExtra.Append(L"HaoZip\\HaoZipC.exe x ").Append(srcFile).Append(L" -ao -y -o").Append(desPath);
// strExtra.Append(L" -p").Append(L"42F7AA9A-67E0-4CC7-9526-B2E8B358F179");
// system(strExtra.ToString().c_str());
// return;
// HZIP hz = OpenZip(srcFile.c_str(), passWord);
// ZIPENTRY ze;
// GetZipItem(hz,-1,&ze);
// int num = ze.index;
// for (int i = 0; i < num; ++i)
// {
// GetZipItem(hz, i, &ze);
// UnzipItem(hz,i, (desPath + ze.name).c_str());
// }
//
// CloseZip(hz);
}
bool QtRAR::open(OpenMode mode, const QString &password)
{
RAROpenArchiveDataEx arcData;
wchar_t arcNameW[MAX_ARC_NAME_SIZE];
int arcNameLen = m_p->m_arcName
.left(MAX_ARC_NAME_SIZE - 1)
.toWCharArray(arcNameW);
arcNameW[arcNameLen] = '\0';
arcData.ArcNameW = arcNameW;
arcData.ArcName = 0;
arcData.CmtBufW = new wchar[MAX_COMMENT_SIZE];
arcData.CmtBufSize = MAX_COMMENT_SIZE;
arcData.Callback = 0;
arcData.UserData = 0;
if (mode == OpenModeList) {
arcData.OpenMode = RAR_OM_LIST;
} else {
arcData.OpenMode = RAR_OM_EXTRACT;
}
m_p->m_hArc = RAROpenArchiveEx(&arcData);
m_p->m_error = arcData.OpenResult;
m_p->m_curIndex = 0;
m_p->m_comment.clear();
bool isSuccess = (m_p->m_error == ERAR_SUCCESS);
if (isSuccess) {
m_p->m_mode = mode;
if (arcData.CmtSize > 0) {
// Comment buffer ends with '\0'
std::wstring cstr(arcData.CmtBufW, arcData.CmtSize - 1);
m_p->m_comment = QString::fromStdWString(cstr);
}
m_p->m_isHeadersEncrypted = (arcData.Flags & 0x0080);
if (!password.isEmpty()) {
m_p->m_password = password;
std::wstring passwordW = m_p->m_password.toStdWString();
RARSetPasswordW(m_p->m_hArc, const_cast<wchar *>(passwordW.data()));
}
m_p->scanFileInfo();
} else {
m_p->m_mode = OpenModeNotOpen;
}
delete arcData.CmtBufW;
return isSuccess;
}
HANDLE PASCAL RAROpenArchive(vector<string> *pvRarFiles, string sParfileName, struct RAROpenArchiveData *r)
{
RAROpenArchiveDataEx rx;
memset(&rx,0,sizeof(rx));
rx.ArcName=r->ArcName;
rx.OpenMode=r->OpenMode;
rx.CmtBuf=r->CmtBuf;
rx.CmtBufSize=r->CmtBufSize;
HANDLE hArc=RAROpenArchiveEx(pvRarFiles, sParfileName, &rx);
r->OpenResult=rx.OpenResult;
r->CmtSize=rx.CmtSize;
r->CmtState=rx.CmtState;
return(hArc);
}
HANDLE PASCAL RAROpenArchive(struct RAROpenArchiveData *r)
{
RAROpenArchiveDataEx rx;
memset(&rx,0,sizeof(rx));
rx.ArcName=r->ArcName;
rx.OpenMode=r->OpenMode;
rx.CmtBuf=r->CmtBuf;
rx.CmtBufSize=r->CmtBufSize;
HANDLE hArc=RAROpenArchiveEx(&rx);
r->OpenResult=rx.OpenResult;
r->CmtSize=rx.CmtSize;
r->CmtState=rx.CmtState;
return(hArc);
}
int CSVPRarLib::ListRar(CString fnRarPath , CStringArray* szaFiles)
{
szaFiles->RemoveAll();
struct RAROpenArchiveDataEx ArchiveDataEx;
memset(&ArchiveDataEx, 0, sizeof(ArchiveDataEx));
ArchiveDataEx.ArcNameW = (LPTSTR)(LPCTSTR)fnRarPath;
char fnA[MAX_PATH];
if(wcstombs(fnA, fnRarPath, fnRarPath.GetLength()+1) == -1) fnA[0] = 0;
ArchiveDataEx.ArcName = fnA;
ArchiveDataEx.OpenMode = RAR_OM_EXTRACT;
ArchiveDataEx.CmtBuf = 0;
try{
HANDLE hrar = RAROpenArchiveEx(&ArchiveDataEx);
if(hrar)
{
struct RARHeaderDataEx HeaderDataEx;
HeaderDataEx.CmtBuf = NULL;
while(RARReadHeaderEx(hrar, &HeaderDataEx) == 0)
{
if (HeaderDataEx.Method == 0x30)
{
CString subfn(HeaderDataEx.FileNameW);
BOOL bAlreadyHaveTheSame = false;
for(int i = 0; i < szaFiles->GetCount(); i++){
if(szaFiles->GetAt(i) == subfn){
bAlreadyHaveTheSame = true;
break;
}
}
if(!bAlreadyHaveTheSame)
szaFiles->Add(subfn);
}
RARProcessFile(hrar, RAR_SKIP, NULL, NULL);
}
RARCloseArchive(hrar);
}
}catch (...) {
return 0;
}
return szaFiles->GetCount();
}
HANDLE ComicBookRAR::openRar(RAROpenArchiveDataEx *flags, RARHeaderDataEx *header, wxUint8 mode)
{
HANDLE rarFile;
memset(flags, 0, sizeof(*flags));
flags->ArcNameW = const_cast<wchar_t*>(filename.wc_str());
flags->CmtBuf = NULL;
flags->OpenMode = mode;
rarFile = RAROpenArchiveEx(flags);
if (flags->OpenResult != 0) {
closeRar(rarFile, flags);
throw ArchiveException(filename, OpenArchiveError(flags->OpenResult));
}
header->CmtBuf = NULL;
return rarFile;
}
void UnPackIntoSubdirActionTask::process(const volatile Flags &aborted, QString &error)
{
QByteArray fileName;
IFileContainer::Holder destination;
Tryier tryier(this, &UnPackIntoSubdirActionTask::askForSkipIfNotCopy, aborted);
int res;
void *archive;
struct RARHeaderDataEx fileInfo;
struct RAROpenArchiveDataEx archiveData;
m_aborted = &aborted;
for (AsyncAction::FilesList::size_type i = 0, size = files().size(); i < size && !aborted; ++i)
if (tryier.tryTo(CreateDestination(m_container, m_file = files().at(i).second, destination)))
{
fileName = m_container->location(m_file);
memset(&archiveData, 0, sizeof(struct RAROpenArchiveDataEx));
archiveData.ArcName = fileName.data();
archiveData.OpenMode = RAR_OM_EXTRACT;
if (archive = RAROpenArchiveEx(&archiveData))
{
RARSetCallback(archive, callbackProc, (long)this);
while ((res = RARReadHeaderEx(archive, &fileInfo)) == 0 && !aborted)
{
if ((res = RARProcessFile(archive, RAR_EXTRACT, const_cast<char *>(destination->location().as<QByteArray>().data()), NULL)) != 0)
break;
}
if (!aborted && res != ERAR_END_ARCHIVE)
error = Scanner::errorDescription(res);
RARCloseArchive(archive);
}
}
}
JNIEXPORT jint JNICALL Java_com_ssb_droidsound_utils_UnRar_N_1open(JNIEnv *env, jobject obj, jstring archive)
{
const char *rarName = env->GetStringUTFChars(archive, NULL);
RAROpenArchiveDataEx archiveInfo;
memset(&archiveInfo, 0, sizeof(archiveInfo));
archiveInfo.CmtBuf = NULL;
archiveInfo.OpenMode = RAR_OM_EXTRACT;
archiveInfo.ArcName = (char*)rarName;
HANDLE rarFile = RAROpenArchiveEx(&archiveInfo);
//int RHCode = RARReadHeaderEx(rarFile, &fileInfo);
env->ReleaseStringUTFChars(archive, rarName);
jclass cl = env->GetObjectClass(obj);
refField = env->GetFieldID(cl, "rarRef", "J");
env->SetLongField(obj, refField, (jlong)rarFile);
}
wxRarInputStream::wxRarInputStream(const wxChar* szFile)
{
RAROpenArchiveDataEx rx;
memset(&rx,0,sizeof(rx));
#if wxUSE_UNICODE
rx.ArcNameW =((wxChar*) szFile);
#else /* !wxUSE_UNICODE */
rx.ArcName =((wxChar*) szFile);
#endif
rx.OpenMode=RAR_OM_EXTRACT;
rx.CmtBuf=m_Info.szComment=new char[2000];
rx.CmtBufSize=2000;
m_hRar = RAROpenArchiveEx(&rx);
if (!m_hRar)
{
wxLogSysError(wxString::Format(_("Couldn't open rar file %s"), szFile));
delete m_Info.szComment;
}
RARSetPassword(m_hRar,"");
}
void Scanner::scan(const ScanArguments &arguments, QString &error) const
{
struct RAROpenArchiveDataEx archiveData;
memset(&archiveData, 0, sizeof(struct RAROpenArchiveDataEx));
archiveData.ArcName = const_cast<char *>(m_filePath.data());
archiveData.OpenMode = RAR_OM_LIST;
if (void *archive = RAROpenArchiveEx(&archiveData))
{
QMap<QString, SnapshotItem *> parents;
IFileContainer::Holder container;
struct RARHeaderDataEx fileInfo;
SnapshotItem *parent;
SnapshotItem *entry;
QString fileName;
Location fileNameLocation;
const wchar_t *path;
wchar_t *sep;
int res;
while ((res = RARReadHeaderEx(archive, &fileInfo)) == 0 && !arguments.aborted)
{
path = fileInfo.FileNameW;
if ((sep = wcschr(const_cast<wchar_t *>(path), L'/')) != NULL)
{
(*sep) = 0;
SnapshotItem *&p = parents[fileName = QString::fromWCharArray(path)];
(*sep) = L'/';
if (p == NULL)
{
fileNameLocation = Info::location(fileName);
arguments.snapshot.insert(fileNameLocation, p = parent = new SnapshotItem(m_container, fileNameLocation, fileInfo, NULL));
}
else
parent = p;
path = (++sep);
while ((sep = wcschr(const_cast<wchar_t *>(path), L'/')) != NULL)
{
(*sep) = 0;
if (entry = parent->find(fileName = QString::fromWCharArray(path)))
parent = entry;
else
{
parent->insert(fileName, entry = new SnapshotItem(m_container, Info::location(fileName), fileInfo, parent));
parent = entry;
}
(*sep) = L'/';
path = (++sep);
}
if (!(fileName = QString::fromWCharArray(path)).isEmpty() &&
parent->find(fileName) == NULL)
{
parent->insert(fileName, new SnapshotItem(m_container, Info::location(fileName), fileInfo, parent));
}
}
else
{
SnapshotItem *&p = parents[fileName = QString::fromWCharArray(path)];
if (p == NULL)
{
fileNameLocation = Info::location(fileName);
arguments.snapshot.insert(fileNameLocation, p = new SnapshotItem(m_container, fileNameLocation, fileInfo, NULL));
}
}
RARProcessFile(archive, RAR_SKIP, NULL, NULL);
}
if (!arguments.aborted)
if (res == ERAR_END_ARCHIVE)
for (Snapshot::const_iterator i = arguments.snapshot.begin(), end = arguments.snapshot.end(); i != end; ++i)
static_cast<SnapshotItem *>((*i).second)->populateInfo();
else
error = errorDescription(res);
RARCloseArchive(archive);
}
}
JNIEXPORT jint JNICALL Java_com_aroma_unrartool_Unrar_RarOpenArchive
(JNIEnv *env, jobject obj, jstring param2, jstring param3)
{
//const char *filename = env->GetStringUTFChars(param2, NULL);
char outbuf[255],extrPath[255];
jstring jstr;
int retresult=0;
jclass cls = env->GetObjectClass(obj);
jmethodID mid = env->GetMethodID(cls, "relayMessage", "(ILjava/lang/String;)V");
if(mid == NULL)
LOGE("Error retrieving methodID for %s \n", "relayMessage()");
int len = env->GetStringLength( param2);
env->GetStringUTFRegion( param2, 0, len, outbuf);
len = env->GetStringLength( param3);
env->GetStringUTFRegion( param3, 0, len, extrPath);
LOGI("openning Archive: %s \n", outbuf);
LOGI("==========================\n");
LOGI("Extracting to :%s\n",extrPath);
LOGI("==========================\n");
RAROpenArchiveDataEx data;
memset(&data, 0, sizeof(RAROpenArchiveDataEx));
memset(&environment, 0, sizeof(Environment));
data.ArcName = (char*)outbuf;//filename;
data.OpenMode = RAR_OM_EXTRACT;
HANDLE handle = RAROpenArchiveEx(&data);
if (handle && !data.OpenResult)
{
environment.env=env;
environment.obj=obj;
RARSetCallback(handle,UnRarCallBack,(LPARAM)&environment);
bool firstcheck=true;
RARHeaderDataEx header;
memset(&header, 0, sizeof(RARHeaderDataEx));
int headererror=0 ;
while ((headererror=RARReadHeaderEx(handle, &header)) == 0)
{
if(mid != NULL)
{
jstr = env->NewStringUTF(header.FileName);
if (jstr != NULL) {
env->CallVoidMethod(obj, mid,0,jstr);
env->DeleteLocalRef(jstr);
}
else
LOGE("Unable to Create JString ,outofmemory error");/* out of memory */
}
int result = RARProcessFile(handle, RAR_EXTRACT, extrPath/*"/mnt/sdcard/unrartestfile"*/, NULL);
if(firstcheck && (data.Flags & MHD_VOLUME))
{
LOGI("Archive is a Volume");
if(header.UnpVer >=29 && (data.Flags & MHD_FIRSTVOLUME)==0)
{
LOGE("unrar from the wrong Volume");
if(archivefirstVolume)
env->SetBooleanField(obj, archivefirstVolume , false);
}
firstcheck=false;
}
if (result)
{
LOGE("Unable to process %s, error: %d", header.FileName, result);
retresult=result;
if(mid != NULL)
{
jstr = env->NewStringUTF(header.FileName);
if (jstr != NULL) {
env->CallVoidMethod(obj, mid,result,jstr);
env->DeleteLocalRef(jstr);
}
else
LOGE("Unable to Create JString ,outofmemory error");/* out of memory */
}
switch(result)
{
case ERAR_BAD_DATA :
break;
case ERAR_BAD_ARCHIVE:
break;
case ERAR_UNKNOWN_FORMAT:
break;
case ERAR_EOPEN:
break;
case ERAR_ECREATE:
break;
case ERAR_ECLOSE:
break;
case ERAR_EREAD:
break;
case ERAR_EWRITE:
break;
}
}
else
{
//LOGI("Processing file: %s \n", header.FileName);
/*if(mid != NULL)
{
jstr = env->NewStringUTF(header.FileName);
if (jstr != NULL) {
env->CallVoidMethod(obj, mid,0,jstr);
env->DeleteLocalRef(jstr);
}
else
LOGE("Unable to Create JString ,outofmemory error");
}*/
}
}
if(headererror==ERAR_BAD_DATA)
{
LOGI("RARReadHeaderEx returned ERAR_BAD_DATA");
retresult= headererror;
}
if(headererror==ERAR_END_ARCHIVE)
LOGI("RARReadHeaderEx returned ERAR_END_ARCHIVE");
LOGI("RARReadHeaderEx returned %d",headererror);
RARCloseArchive(handle);
}
else
{
printf("Error Code:%d \n",data.OpenResult);
return displayError(data.OpenResult, outbuf);
//return -1;
}
//env->ReleaseStringUTFChars(param2, filename);
LOGI("end of RarOpenArchive()");
return retresult;
}
int _tmain(int argc, _TCHAR* argv[])
{
HANDLE rar_handle = NULL;
//std::wstring fn_rar = L"E:\\-=eMule=-\\1140746814_39741.rar";
//std::wstring fn_rar = L"E:\\-=eMule=-\\Bride.Flight.2008.Bluray.720p.AC3.x264-CHD_ÐÂÄﺽ°à\\B2_ÐÂÄﺽ°à.part1.rar";
//std::wstring fn_rar = L"D:\\xxxx.part1.rar";
std::wstring fn_rar = L"E:\\-=eMule=-\\Overheard.2009.REPACK.CN.DVDRip.Xvid-XTM\\sample\\xtm-overheard.repack-sample_stored.rar";
//std::wstring fn_rar = L"E:\\-=eMule=-\\Overheard.2009.REPACK.CN.DVDRip.Xvid-XTM\\sample\\xtm-overheard.repack-sample_s.part1.rar";
std::wstring tmp_dir = L"C:\\Temp\\";
struct RAROpenArchiveDataEx ArchiveDataEx;
memset(&ArchiveDataEx, 0, sizeof(ArchiveDataEx));
ArchiveDataEx.ArcNameW = (wchar_t*)fn_rar.c_str();
//ArchiveDataEx.ArcName = "E:\\-=eMule=-\\1140746814_39741.rar";
ArchiveDataEx.OpenMode = RAR_OM_EXTRACT;
ArchiveDataEx.CmtBuf = 0;
rar_handle = RAROpenArchiveEx(&ArchiveDataEx);
const long buffsize = 1000;
char testbuff[buffsize];
if (rar_handle)
{
wprintf(L"RAROpenArchiveEx open successed\n");
struct RARHeaderDataEx HeaderDataEx;
HeaderDataEx.CmtBuf = NULL;
while (RARReadHeaderEx(rar_handle, &HeaderDataEx) == 0)
{
// Õý³£½âѹ¸ÃÎļþ
unsigned long long filesize = ((unsigned long long)HeaderDataEx.UnpSizeHigh << 32) + HeaderDataEx.UnpSize;
int err = 0;
std::wstring unp_tmpfile = tmp_dir + HeaderDataEx.FileNameW;
err = RARProcessFileW(rar_handle, RAR_EXTRACT, (wchar_t*)tmp_dir.c_str(), HeaderDataEx.FileNameW);
wprintf(L"RARProcessFileW to %s return %d size %lld %x %x\n", unp_tmpfile.c_str(), err, filesize, HeaderDataEx.UnpVer, HeaderDataEx.Method);
}
RARCloseArchive(rar_handle);
}
rar_handle = RAROpenArchiveEx(&ArchiveDataEx);
if (rar_handle)
{
wprintf(L"RAROpenArchiveEx open successed\n");
struct RARHeaderDataEx HeaderDataEx;
HeaderDataEx.CmtBuf = NULL;
while (RARReadHeaderEx(rar_handle, &HeaderDataEx) == 0)
{
unsigned long long filesize = ((unsigned long long)HeaderDataEx.UnpSizeHigh << 32) + HeaderDataEx.UnpSize;
int err = 0;
std::wstring unp_tmpfile = tmp_dir + HeaderDataEx.FileNameW;
err = RARExtractChunkInit(rar_handle, HeaderDataEx.FileName);
if (err != 0)
{
wprintf(L"RARExtractChunkInit return error %d\n", err);
continue;
}
FILE* unp_filehandle = NULL;
err = _wfopen_s(&unp_filehandle, unp_tmpfile.c_str(), L"rb");
if (err)
{
wprintf(L"open extracted file fail %d %d\n", err, unp_filehandle);
continue;
}
// ˳Ðò²âÊÔ
int iExtractRet = 0;
unsigned long long fpos = 0;
do
{
iExtractRet = RARExtractChunk(rar_handle, (char*)testbuff, buffsize);
// Compare
if (compare_filebinary(unp_filehandle, fpos, testbuff, iExtractRet, 0))
{
wprintf(L"Sequence compare difference found at %lld for %d\n", fpos, buffsize);
break;
}
//else
// wprintf(L"Sequence compare is same %lld %d\n", fpos, iExtractRet);
fpos += iExtractRet;
} while(iExtractRet > 0);
// Ëæ»ú²âÊÔ
for (int i = 0; i < 100; i++)
{
unsigned long long ll_pos = rand() * filesize/RAND_MAX;
RARExtractChunkSeek(rar_handle, ll_pos, SEEK_SET);
RARExtractChunk(rar_handle, (char*)testbuff, buffsize);
// Compare
if (compare_filebinary(unp_filehandle, ll_pos, testbuff, iExtractRet, 0))
{
wprintf(L"Random compare difference found at %lld\n", ll_pos);
break;
}
//else
// wprintf(L"Random compare is same %lld\n", ll_pos);
}
wprintf(L"RARExtractChunk test for %s finished\n", unp_tmpfile.c_str());
}
RARCloseArchive(rar_handle);
}
wprintf(L"Test finished\n");
scanf_s("%d");
return 0;
}
JNIEXPORT jint JNICALL Java_com_aroma_unrartool_Unrar_RarGetArchiveItems
(JNIEnv *env, jobject obj, jstring fname)
{
char outbuf[255];
char *cmtBuff =NULL;
jstring jstr;
int len = env->GetStringLength( fname);
env->GetStringUTFRegion( fname, 0, len, outbuf);
LOGI("openning Archive: %s for listing\n", outbuf);
LOGI("==========================\n");
RAROpenArchiveDataEx data;
memset(&data, 0, sizeof(RAROpenArchiveDataEx));
cmtBuff=(char*)malloc(MAX_COMMENT_SIZE);
//memset(&environment, 0, sizeof(Environment));
data.ArcName = (char*)outbuf;//filename;
if(cmtBuff)
{
data.CmtBuf=cmtBuff;
data.CmtBufSize=MAX_COMMENT_SIZE;
}
data.OpenMode = RAR_OM_LIST;
HANDLE handle = RAROpenArchiveEx(&data);
int itemscount=0;
if (handle && !data.OpenResult)
{
/*environment.env=env;
environment.obj=obj;
RARSetCallback(handle,UnRarCallBack,(LPARAM)&environment);*/
/* Create a new string and overwrite the instance field */
if(data.Flags & MHD_SOLID)
{
LOGI("Archive is Solid");
if(archivesolid)
env->SetBooleanField(obj, archivesolid , true);
}
if(data.Flags & MHD_LOCK)
{
LOGI("Archive is LOCKED");
if(archivelocked)
env->SetBooleanField(obj, archivelocked , true);
}
if(data.Flags & MHD_AV)
{
LOGI("Archive is Signed");
if(archivesigned)
env->SetBooleanField(obj, archivesigned , true);
}
if(data.Flags & MHD_PROTECT)
{
LOGI("recovery Record is present");
if(archiverecoveryRecord)
env->SetBooleanField(obj, archiverecoveryRecord , true);
}
if(data.Flags & MHD_VOLUME)
{
LOGI("Archive is a Volume");
if(archivevolume)
env->SetBooleanField(obj, archivevolume , true);
}
if(data.CmtState == 1)
{
LOGI("Archive Comment read completely");
jstring jstr = env->NewStringUTF( data.CmtBuf );
if (jstr == NULL)
{
LOGE("Unable to instanciate a new UTF String, may be an out of memory"); /* out of memory */
}
if(archiveCmtfid)
env->SetObjectField(obj, archiveCmtfid , jstr);
if(archivecommentPresent)
env->SetBooleanField(obj, archivecommentPresent , true);
}
else
{
switch(data.CmtState)
{
case 0:
LOGI("Archive Comments not present");
if(archivecommentPresent)
env->SetBooleanField(obj, archivecommentPresent , false);
break;
case ERAR_NO_MEMORY :
LOGI("No enough memory to extract Archive Comments");
break;
case ERAR_BAD_DATA :
LOGI("Broken Archive Comments");
break;
case ERAR_UNKNOWN_FORMAT:
LOGI("Unknown Archive comment format");
break;
case ERAR_SMALL_BUF:
LOGI("Buffer too small,Archive comments not completely read");
break;
}
}
RARHeaderDataEx header;
memset(&header, 0, sizeof(RARHeaderDataEx));
int headererror=0 ;
while (headererror=RARReadHeaderEx(handle, &header) == 0)
{
//RARSetPassword(handle,"mahm1985");
int result = RARProcessFile(handle, RAR_OM_LIST, NULL/*"/mnt/sdcard/unrartestfile"*/, NULL);
if (result)
{
LOGE("Unable to process %s, error: %d", header.FileName, result);
}
else
{
//LOGI("Processing file: %s \n", header.FileName);
}
itemscount++;
}
if(headererror==ERAR_BAD_DATA)
LOGI("RARReadHeaderEx returned ERAR_BAD_DATA");
if(headererror==ERAR_END_ARCHIVE)
LOGI("RARReadHeaderEx returned ERAR_END_ARCHIVE");
RARCloseArchive(handle);
}
else
{
printf("Error Code:%d \n",data.OpenResult);
displayError(data.OpenResult, outbuf);
return -1;
}
//env->ReleaseStringUTFChars(param2, filename);
LOGI("end of RarOpenArchive()");
if(cmtBuff)
free(cmtBuff);
return itemscount;
}
/*
---------------------------------------
读取文件数据
---------------------------------------
*/
static bool_t
iPAK_RAR_getFileData (
__CR_IN__ iPACKAGE* that,
__CR_OT__ sBUFFER* buff,
__CR_IN__ int64u index,
__CR_IN__ bool_t hash
)
{
sint_t rett;
int64u size;
void_t* data;
iPAK_RAR* real;
sPAK_RAR_FILE* item;
RARHeaderDataEx info;
RAROpenArchiveDataEx open;
/* 定位文件索引 */
CR_NOUSE(hash);
real = (iPAK_RAR*)that;
if (index >= real->m_cnt)
return (FALSE);
item = (sPAK_RAR_FILE*)real->pack.__filelst__;
item += (leng_t)index;
/* 获取文件数据 (0大小文件分配1个字节) */
size = item->base.size;
if (size == 0) {
data = mem_malloc(1);
if (data == NULL)
return (FALSE);
size = 1;
*(byte_t*)data = 0x00;
}
else {
real->m_temp = data = mem_malloc64(size);
if (data == NULL)
return (FALSE);
/* RAR 只能顺序读取文件 */
if (real->m_rar == NULL || item->id < real->m_cur)
{
/* 需要重新打开封包 */
if (real->m_rar != NULL) {
RARCloseArchive(real->m_rar);
real->m_rar = NULL;
}
struct_zero(&open, RAROpenArchiveDataEx);
if (real->m_ansi != NULL)
open.ArcName = real->m_ansi;
else
open.ArcNameW = real->m_wide;
open.OpenMode = RAR_OM_EXTRACT;
open.Callback = rar_mem_copy;
open.UserData = (LPARAM)(&real->m_temp);
real->m_rar = RAROpenArchiveEx(&open);
if (real->m_rar == NULL)
goto _failure1;
if (real->m_pass != NULL)
RARSetPassword(real->m_rar, real->m_pass);
real->m_cur = 0;
}
/* 定位到指定文件 */
struct_zero(&info, RARHeaderDataEx);
while (real->m_cur != item->id) {
rett = RARReadHeaderEx(real->m_rar, &info);
if (rett != ERAR_SUCCESS)
goto _failure2;
rett = RARProcessFile(real->m_rar, RAR_SKIP, NULL, NULL);
if (rett != ERAR_SUCCESS && rett != ERAR_BAD_DATA)
goto _failure2;
real->m_cur += 1;
}
/* 测试目标文件就不会有磁盘操作了 */
rett = RARReadHeaderEx(real->m_rar, &info);
if (rett != ERAR_SUCCESS)
goto _failure2;
rett = RARProcessFile(real->m_rar, RAR_TEST, NULL, NULL);
if (rett != ERAR_SUCCESS)
goto _failure2;
real->m_cur += 1;
}
/* 返回文件数据 */
return (buffer_init(buff, data, (leng_t)size, TRUE));
_failure2:
RARCloseArchive(real->m_rar);
real->m_rar = NULL;
_failure1:
real->m_cur = (leng_t)-1;
mem_free(data);
return (FALSE);
}
/*
=======================================
RAR 文件读取
=======================================
*/
CR_API sFMT_PRT*
load_rar (
__CR_IO__ iDATIN* datin,
__CR_IN__ const sLOADER* param
)
{
HANDLE rar;
sARRAY list;
int32u attr;
sint_t retc;
leng_t fpos;
iPAK_RAR* port;
sFMT_PRT* rett;
sPAK_RAR_FILE temp;
RARHeaderDataEx info;
RAROpenArchiveDataEx open;
/* 只支持磁盘文件 */
if (param->type != CR_LDR_ANSI &&
param->type != CR_LDR_WIDE)
return (NULL);
/* 列表模式打开 RAR 文件 */
struct_zero(&open, RAROpenArchiveDataEx);
if (param->type == CR_LDR_ANSI)
open.ArcName = (ansi_t*)param->name.ansi;
else
open.ArcNameW = (wide_t*)param->name.wide;
open.OpenMode = RAR_OM_LIST;
rar = RAROpenArchiveEx(&open);
if (rar == NULL)
return (NULL);
if (param->aprm != NULL &&
*(byte_t*)param->aprm != 0x00) {
RARSetPassword(rar, (ansi_t*)param->aprm);
attr = PAK_FILE_ENC;
}
else {
attr = 0;
}
/* 开始逐个文件读取信息并定位 */
array_initT(&list, sPAK_RAR_FILE);
list.free = rar_free;
struct_zero(&info, RARHeaderDataEx);
for (fpos = 0; ; fpos++)
{
/* 读取一个文件记录头 */
retc = RARReadHeaderEx(rar, &info);
if (retc == ERAR_END_ARCHIVE)
break;
if (retc != ERAR_SUCCESS)
goto _failure1;
/* 目录文件不加入列表 */
if (info.Flags & RHDF_DIRECTORY) {
retc = RARProcessFile(rar, RAR_SKIP, NULL, NULL);
if (retc != ERAR_SUCCESS)
goto _failure1;
continue;
}
/* 文件名统一使用 UTF-8 编码 */
struct_zero(&temp, sPAK_RAR_FILE);
temp.base.name = local_to_utf8(param->page, info.FileName);
if (temp.base.name == NULL)
goto _failure1;
/* 设置公用文件属性 (偏移没有实际用处) */
temp.base.skip = sizeof(sPAK_RAR_FILE);
temp.base.attr = attr;
temp.base.offs = 0;
temp.base.pack = mk_size(info.PackSizeHigh, info.PackSize);
temp.base.size = mk_size(info.UnpSizeHigh, info.UnpSize);
if (info.Method != 0x30)
temp.base.attr |= PAK_FILE_CMP;
if (info.Flags & RHDF_ENCRYPTED)
temp.base.attr |= PAK_FILE_ENC;
else
temp.base.attr &= ~PAK_FILE_ENC;
switch (info.Method)
{
case 0x30: temp.base.memo = "Storing"; break;
case 0x31: temp.base.memo = "Fastest compression"; break;
case 0x32: temp.base.memo = "Fast compression"; break;
case 0x33: temp.base.memo = "Normal compression"; break;
case 0x34: temp.base.memo = "Good compression"; break;
case 0x35: temp.base.memo = "Best compression"; break;
default: temp.base.memo = "Unknown compression"; break;
}
/* 设置私有文件属性 */
temp.id = fpos;
temp.crc32 = (int32u)(info.FileCRC);
temp.fattr = (int32u)(info.FileAttr);
temp.ftime = (int16u)(info.FileTime & 0xFFFF);
temp.fdate = (int16u)(info.FileTime >> 16);
temp.htype = (int32u)(info.HashType);
mem_cpy(temp.hash, info.Hash, sizeof(temp.hash));
/* 文件信息压入列表 */
if (array_push_growT(&list, sPAK_RAR_FILE, &temp) == NULL) {
mem_free(temp.base.name);
goto _failure1;
}
/* 跳过当前已读文件 */
retc = RARProcessFile(rar, RAR_SKIP, NULL, NULL);
if (retc != ERAR_SUCCESS && retc != ERAR_BAD_DATA)
goto _failure1;
}
/* 固定一下列表大小 */
if (!array_no_growT(&list, sPAK_RAR_FILE))
goto _failure1;
/* 生成读包接口对象 */
port = struct_new(iPAK_RAR);
if (port == NULL)
goto _failure1;
/* 保存需要用到的参数 */
port->m_temp = NULL;
if (attr == 0) {
port->m_pass = NULL;
}
else {
port->m_pass = str_dupA((ansi_t*)param->aprm);
if (port->m_pass == NULL)
goto _failure2;
}
if (param->type == CR_LDR_ANSI) {
port->m_wide = NULL;
port->m_ansi = str_dupA(param->name.ansi);
if (port->m_ansi == NULL)
goto _failure3;
}
else {
port->m_ansi = NULL;
port->m_wide = str_dupW(param->name.wide);
if (port->m_wide == NULL)
goto _failure3;
}
port->m_rar = NULL;
port->m_cur = (leng_t)-1;
port->m_cnt = array_get_sizeT(&list, sPAK_RAR_FILE);
port->pack.__filelst__ = array_get_dataT(&list, sPAK_FILE);
port->pack.__vptr__ = &s_pack_vtbl;
if (!pack_init_list((iPACKAGE*)port, TRUE))
goto _failure4;
RARCloseArchive(rar);
/* 返回读取的文件数据 */
rett = struct_new(sFMT_PRT);
if (rett == NULL) {
iPAK_RAR_release((iPACKAGE*)port);
return (NULL);
}
CR_NOUSE(datin);
rett->type = CR_FMTZ_PRT;
rett->port = (iPORT*)port;
rett->more = "iPACKAGE";
rett->infor = "Roshal ARchive (RAR)";
return (rett);
_failure4:
TRY_FREE(port->m_ansi);
TRY_FREE(port->m_wide);
_failure3:
TRY_FREE(port->m_pass);
_failure2:
mem_free(port);
_failure1:
array_freeT(&list, sPAK_RAR_FILE);
RARCloseArchive(rar);
return (NULL);
}
