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;
}
JNIEXPORT jstring JNICALL Java_com_ssb_droidsound_utils_UnRar_N_1getFileName(JNIEnv *env, jobject obj)
{
HANDLE rarFile = (HANDLE)env->GetLongField(obj, refField);
RARHeaderDataEx fileInfo;
int RHCode = RARReadHeaderEx(rarFile, &fileInfo);
if(RHCode != 0) return NULL;
return env->NewStringUTF(fileInfo.FileName);
}
JNIEXPORT jint JNICALL Java_com_ssb_droidsound_utils_UnRar_N_1getFileSize(JNIEnv *env, jobject obj)
{
HANDLE rarFile = (HANDLE)env->GetLongField(obj, refField);
RARHeaderDataEx fileInfo;
int RHCode = RARReadHeaderEx(rarFile, &fileInfo);
if(RHCode != 0) return -1;
return fileInfo.UnpSize;
}
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);
}
ComicBookRAR::ComicBookRAR(wxString file, wxUint32 cacheLen, COMICAL_ZOOM zoom, long zoomLevel, bool fitOnlyOversize, COMICAL_MODE mode, FREE_IMAGE_FILTER filter, COMICAL_DIRECTION direction, wxInt32 scrollbarThickness) : ComicBook(file, cacheLen, zoom, zoomLevel, fitOnlyOversize, mode, filter, direction, scrollbarThickness)
{
HANDLE rarFile;
int RHCode = 0, PFCode = 0;
struct RARHeaderDataEx header;
struct RAROpenArchiveDataEx flags;
wxString page, new_password;
open_rar:
rarFile = openRar(&flags, &header, RAR_OM_LIST);
if (flags.Flags & 0x0080) { // if the headers are encrypted
new_password = wxGetPasswordFromUser(
wxT("This archive is password-protected. Please enter the password."),
wxT("Enter Password"));
if (new_password.IsEmpty()) { // the dialog was cancelled, and the archive cannot be opened
closeRar(rarFile, &flags);
throw ArchiveException(filename, wxT("Comical could not open this file because it is password-protected."));
}
SetPassword(new_password.ToAscii());
}
if (password)
RARSetPassword(rarFile, password);
while ((RHCode = RARReadHeaderEx(rarFile, &header)) == 0) {
#ifdef wxUSE_UNICODE
page = wxString(header.FileNameW);
#else
page = wxString(header.FileName);
#endif
if(page.Right(5).Upper() == wxT(".JPEG") || page.Right(4).Upper() == wxT(".JPG") ||
page.Right(4).Upper() == wxT(".GIF") ||
page.Right(4).Upper() == wxT(".PNG"))
Filenames->Add(page);
if ((PFCode = RARProcessFile(rarFile, RAR_SKIP, NULL, NULL)) != 0) {
closeRar(rarFile, &flags);
throw ArchiveException(filename, ProcessFileError(PFCode, page));
}
}
closeRar(rarFile, &flags);
// Wrong return code + needs password = wrong password given
if (RHCode != ERAR_END_ARCHIVE && flags.Flags & 0x0080)
goto open_rar;
postCtor();
Create(); // create the wxThread
}
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();
}
bool ComicBookRAR::TestPassword()
{
HANDLE rarFile;
int RHCode = 0, PFCode = 0;
struct RARHeaderDataEx header;
struct RAROpenArchiveDataEx flags;
bool passwordCorrect = true;
if (Pages.size() == 0)
// nothing in the archive to open
return true;
wxString page = Pages.at(0)->Filename; // test using the first page
rarFile = openRar(&flags, &header, RAR_OM_EXTRACT);
if (password)
RARSetPassword(rarFile, password);
while ((RHCode = RARReadHeaderEx(rarFile, &header)) == 0) {
if (page.Cmp(header.FileNameW) == 0) {
break;
} else {
if ((PFCode = RARProcessFile(rarFile, RAR_SKIP, NULL, NULL)) != 0) {
closeRar(rarFile, &flags);
throw ArchiveException(filename, ProcessFileError(PFCode, page));
}
}
}
if (RHCode != 0) {
closeRar(rarFile, &flags);
throw new ArchiveException(filename, OpenArchiveError(RHCode));
}
RARSetCallback(rarFile, TestPasswordCallbackProc, (long) &passwordCorrect);
PFCode = RARProcessFile(rarFile, RAR_TEST, NULL, NULL);
closeRar(rarFile, &flags);
// If the password is wrong, RARProcessFile will return ERAR_BAD_DATA. Of
// course, it will also return ERAR_BAD_DATA when the first file in the archive
// is corrupted. How does one tell the difference?
if (PFCode == ERAR_BAD_DATA)
return false;
return passwordCorrect;
}
void QtRARPrivate::scanFileInfo()
{
if (!m_q->isOpen() || m_hasScaned) {
return;
}
m_fileInfoList.clear();
RARHeaderDataEx hData;
int i = 0;
while (RARReadHeaderEx(m_hArc, &hData) == ERAR_SUCCESS) {
QtRARFileInfo info;
info.fileName = QString::fromWCharArray(hData.FileNameW);
info.arcName = m_arcName;
info.flags = hData.Flags;
info.packSize = hData.PackSize;
info.unpSize = hData.UnpSize;
info.hostOS = hData.HostOS;
info.fileCRC = hData.FileCRC;
info.fileTime = hData.FileTime;
info.unpVer = hData.UnpVer;
info.method = hData.Method;
info.fileAttr = hData.FileAttr;
info.comment = m_q->comment();
m_fileInfoList << info;
m_fileNameToIndexSensitive.insert(info.fileName, i);
m_fileNameToIndexInsensitive.insert(info.fileName.toLower(), i);
i++;
if (info.flags & 0x04) {
m_isFilesEncrypted = true;
}
if (RARProcessFile(m_hArc, RAR_SKIP, NULL, NULL) != ERAR_SUCCESS) {
break;
}
};
m_hasScaned = true;
// Reopen to reset cursor
reopen();
}
bool QtRAR::setCurrentFile(const QString &fileName, Qt::CaseSensitivity cs)
{
if (!isOpen()) {
return false;
}
// Move unrar cursor to this index
if (!m_p->reopen()) {
qWarning() << "QtRAR::setCurrentFile: fail to reopen to reset cursor";
return false;
}
QHash<QString, int>::const_iterator it;
if (cs == Qt::CaseSensitive) {
it = m_p->m_fileNameToIndexSensitive.find(fileName);
if (it == m_p->m_fileNameToIndexSensitive.end()) {
return false;
}
} else {
it = m_p->m_fileNameToIndexInsensitive.find(fileName.toLower());
if (it == m_p->m_fileNameToIndexInsensitive.end()) {
return false;
}
}
m_p->m_curIndex = it.value();
for (int i = 0; i < m_p->m_curIndex; ++i) {
RARHeaderDataEx hData;
if (RARReadHeaderEx(m_p->m_hArc, &hData) == ERAR_SUCCESS) {
if (RARProcessFile(m_p->m_hArc, RAR_SKIP, 0, 0) == ERAR_SUCCESS) {
continue;
} else {
qWarning() << "QtRAR::setCurrentFile: fail to skip file at index"
<< i;
}
} else {
qWarning() << "QtRAR:setCurrentFile: fail to read head at index"
<< i;
return false;
}
}
return true;
}
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);
}
}
}
int PASCAL RARReadHeader(HANDLE hArcData,struct RARHeaderData *D)
{
struct RARHeaderDataEx X;
memset(&X,0,sizeof(X));
int Code=RARReadHeaderEx(hArcData,&X);
strncpyz(D->ArcName,X.ArcName,ASIZE(D->ArcName));
strncpyz(D->FileName,X.FileName,ASIZE(D->FileName));
D->Flags=X.Flags;
D->PackSize=X.PackSize;
D->UnpSize=X.UnpSize;
D->HostOS=X.HostOS;
D->FileCRC=X.FileCRC;
D->FileTime=X.FileTime;
D->UnpVer=X.UnpVer;
D->Method=X.Method;
D->FileAttr=X.FileAttr;
D->CmtSize=0;
D->CmtState=0;
return Code;
}
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;
}
/*
=======================================
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);
}
/*
---------------------------------------
读取文件数据
---------------------------------------
*/
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);
}
ImgBookRAR::ImgBookRAR(string file) : ImgBook(file)
{
HANDLE rarFile;
int RHCode = 0, PFCode = 0;
struct RARHeaderDataEx header;
struct RAROpenArchiveDataEx flags;
string page, new_password;
PV_LOGPRINTF("full Name %s", file.c_str());
string nom = getFileName(file);
PV_LOGPRINTF("fileName %s", nom.c_str());
string nouNom;
nouNom.assign(file);
nouNom.append("/");
nouNom.append(nom);
if (existFile(nouNom) == true)
file.assign(nouNom);
PV_LOGPRINTF("file name prepared %s", nouNom.c_str());
PV_LOGPRINTF("full Name %s", file.c_str());
filename = file;
open_rar:
rarFile = openRar(file, &flags, &header, RAR_OM_LIST);
if (rarFile == NULL)
{
PV_LOGPRINTF("error open RarFile");
return;
}
PV_LOGPRINTF("rarFile opened");
if (flags.Flags & 0x0080)
{
// if the headers are encrypted
PV_LOGPRINTF("rarFile encrypted");
return;
}
PV_LOGPRINTF("reading file name");
while ((RHCode = RARReadHeaderEx(rarFile, &header)) == 0)
{
PV_LOGPRINTF("while");
page = string(header.FileName);
if (testFile (page) == TRUE)
{
PV_LOGPRINTF("imageAdded %s", header.FileName);
imagenes->addEnd(page);
}
if ((PFCode = RARProcessFile(rarFile, RAR_SKIP, NULL, NULL)) != 0)
{
closeRar(rarFile, &flags);
perror("error al abrir fichero\n");
return;
}
}
PV_LOGPRINTF("close rar");
closeRar(rarFile, &flags);
PV_LOGPRINTF("rar closed");
// Wrong return code + needs password = wrong password given
if (RHCode != ERAR_END_ARCHIVE && flags.Flags & 0x0080)
goto open_rar;
currentPage = 1;
PV_LOGPRINTF("currentPage %d", currentPage);
pageCount = imagenes->getCount();
wxInputStream * ComicBookRAR::ExtractStream(wxUint32 pageindex)
{
HANDLE rarFile;
int RHCode = 0, PFCode = 0;
struct RARHeaderDataEx header;
struct RAROpenArchiveDataEx flags;
wxString page = Filenames->Item(pageindex);
size_t length = 0;
rarFile = openRar(&flags, &header, RAR_OM_EXTRACT);
if (password)
RARSetPassword(rarFile, password);
while ((RHCode = RARReadHeaderEx(rarFile, &header)) == 0) {
#ifdef wxUSE_UNICODE
if (page.IsSameAs(wxString(header.FileNameW))) {
#else // ASCII
if (page.IsSameAs(header.FileName)) {
#endif
length = header.UnpSize;
break;
} else {
if ((PFCode = RARProcessFile(rarFile, RAR_SKIP, NULL, NULL)) != 0) {
closeRar(rarFile, &flags);
throw ArchiveException(filename, ProcessFileError(PFCode, page));
}
}
}
if (length == 0) { // archived file not found
closeRar(rarFile, &flags);
throw new ArchiveException(filename, page + wxT(" not found in this archive."));
}
if (RHCode) {
closeRar(rarFile, &flags);
throw new ArchiveException(filename, OpenArchiveError(PFCode));
}
wxUint8 *buffer = new wxUint8[length];
wxUint8 *callBackBuffer = buffer;
RARSetCallback(rarFile, CallbackProc, (long) &callBackBuffer);
PFCode = RARProcessFile(rarFile, RAR_TEST, NULL, NULL);
closeRar(rarFile, &flags);
if (PFCode != 0)
throw new ArchiveException(filename, ProcessFileError(PFCode, page));
return new wxMemoryInputStream(buffer, length);
}
bool ComicBookRAR::TestPassword()
{
HANDLE rarFile;
int RHCode = 0, PFCode = 0;
struct RARHeaderDataEx header;
struct RAROpenArchiveDataEx flags;
bool passwordCorrect = true;
wxString page = Filenames->Item(0); // test using the first page
rarFile = openRar(&flags, &header, RAR_OM_EXTRACT);
if (password)
RARSetPassword(rarFile, password);
while ((RHCode = RARReadHeaderEx(rarFile, &header)) == 0) {
#ifdef wxUSE_UNICODE
if (page.IsSameAs(wxString(header.FileNameW))) {
#else // ASCII
if (page.IsSameAs(header.FileName)) {
#endif
break;
} else {
if ((PFCode = RARProcessFile(rarFile, RAR_SKIP, NULL, NULL)) != 0) {
closeRar(rarFile, &flags);
throw ArchiveException(filename, ProcessFileError(PFCode, page));
}
}
}
if (RHCode != 0) {
closeRar(rarFile, &flags);
throw new ArchiveException(filename, OpenArchiveError(RHCode));
}
RARSetCallback(rarFile, TestPasswordCallbackProc, (long) &passwordCorrect);
PFCode = RARProcessFile(rarFile, RAR_TEST, NULL, NULL);
closeRar(rarFile, &flags);
// If the password is wrong, RARProcessFile will return ERAR_BAD_DATA. Of
// course, it will also return ERAR_BAD_DATA when the first file in the archive
// is corrupted. How does one tell the difference?
if (PFCode == ERAR_BAD_DATA)
return false;
return passwordCorrect;
}
wxString ComicBookRAR::OpenArchiveError(int Error)
{
wxString prefix = wxT("Could not open ") + filename;
switch(Error) {
case ERAR_NO_MEMORY:
return wxString(prefix + wxT(": out of memory"));
case ERAR_EOPEN:
return prefix;
case ERAR_BAD_ARCHIVE:
return wxString(prefix + wxT(": it is not a valid RAR archive"));
case ERAR_BAD_DATA:
return wxString(prefix + wxT(": archive header broken"));
case ERAR_UNKNOWN:
return wxString(prefix + wxT(": unknown error"));
default:
return prefix;
}
}
ComicBookRAR::ComicBookRAR(wxString file, wxUint32 cacheLen, COMICAL_ZOOM zoom, long zoomLevel, bool fitOnlyOversize, COMICAL_MODE mode, FREE_IMAGE_FILTER filter, COMICAL_DIRECTION direction, wxInt32 scrollbarThickness) : ComicBook(file, cacheLen, zoom, zoomLevel, fitOnlyOversize, mode, filter, direction, scrollbarThickness)
{
HANDLE rarFile;
int RHCode = 0, PFCode = 0;
struct RARHeaderDataEx header;
struct RAROpenArchiveDataEx flags;
wxString path, new_password;
wxInputStream *stream;
ComicPage *page;
int numEntries, progress=0;
open_rar:
rarFile = openRar(&flags, &header, RAR_OM_LIST);
if (flags.Flags & 0x0080) { // if the headers are encrypted
new_password = wxGetPasswordFromUser(
wxT("This archive is password-protected. Please enter the password."),
wxT("Enter Password"));
if (new_password.IsEmpty()) { // the dialog was cancelled, and the archive cannot be opened
closeRar(rarFile, &flags);
throw ArchiveException(filename, wxT("Comical could not open this file because it is password-protected."));
}
SetPassword(new_password.ToAscii());
}
if (password)
RARSetPassword(rarFile, password);
// skip through the entire archive to count the number of entries
for (numEntries = 0; RARReadHeaderEx(rarFile, &header) == 0; numEntries++) {
if ((PFCode = RARProcessFile(rarFile, RAR_SKIP, NULL, NULL)) != 0) {
closeRar(rarFile, &flags);
throw ArchiveException(filename, ProcessFileError(PFCode, header.FileNameW));
}
}
wxProgressDialog progressDlg(wxString(wxT("Opening ")) + file, wxString(), numEntries);
progressDlg.SetMinSize(wxSize(400, -1));
// close and re-open the archive to restart at the first header
closeRar(rarFile, &flags);
rarFile = openRar(&flags, &header, RAR_OM_LIST);
while ((RHCode = RARReadHeaderEx(rarFile, &header)) == 0) {
path = header.FileNameW;
progressDlg.Update(progress, wxString(wxT("Scanning: ")) + path);
progressDlg.CentreOnParent(wxHORIZONTAL);
stream = ExtractStream(path);
page = new ComicPage(path, stream);
if (page->GetBitmapType() == wxBITMAP_TYPE_INVALID)
delete page;
else
Pages.push_back(page);
wxDELETE(stream);
if ((PFCode = RARProcessFileW(rarFile, RAR_SKIP, NULL, NULL)) != 0) {
closeRar(rarFile, &flags);
throw ArchiveException(filename, ProcessFileError(PFCode, path));
}
progressDlg.Update(++progress);
}
closeRar(rarFile, &flags);
// Wrong return code + needs password = wrong password given
if (RHCode != ERAR_END_ARCHIVE && flags.Flags & 0x0080)
goto open_rar;
postCtor();
Create(); // create the wxThread
}
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);
}
}
//Img *ImgBookRAR::ExtractStream(int pageindex, int aWidth, int aHeight)
GrPixbuf *ImgBookRAR::ExtractStream(int pageindex, int aWidth, int aHeight)
{
HANDLE rarFile;
int RHCode = 0, PFCode = 0;
struct RARHeaderDataEx header;
struct RAROpenArchiveDataEx flags;
imagenes->setPos(pageindex);
string page = imagenes->get();
size_t length = 0;
rarFile = openRar(filename, &flags, &header, RAR_OM_EXTRACT);
while ((RHCode = RARReadHeaderEx(rarFile, &header)) == 0)
{
if (page.compare(header.FileName) == 0)
{
length = header.UnpSize;
break;
}
else
{
if ((PFCode = RARProcessFile(rarFile, RAR_SKIP, NULL, NULL)) != 0)
{
closeRar(rarFile, &flags);
string msg = ProcessFileError(PFCode, page);
return NULL;
}
}
}
if (length == 0)
{ // archived file not found
closeRar(rarFile, &flags);
return NULL;
}
if (RHCode)
{
closeRar(rarFile, &flags);
return NULL;
}
unsigned char *buffer;
unsigned char *callBackBuffer;
buffer = new unsigned char[length];
callBackBuffer = buffer;
RARSetCallback(rarFile, CallbackProc, (long) &callBackBuffer);
PFCode = RARProcessFile(rarFile, RAR_TEST, NULL, NULL);
closeRar(rarFile, &flags);
if (PFCode != 0)
{
return NULL;
}
// Img *pageImg = getPixbuf((const guchar*)buffer, length, page);
GrPixbuf *pageImg = getPixbuf((const guchar*)buffer, length, page, aWidth, aHeight);
delete[] buffer;
int PASCAL RARReadHeaderEx(HANDLE hArcData,struct RARHeaderDataEx *D)
{
DataSet *Data=(DataSet *)hArcData;
try
{
if ((Data->HeaderSize=(int)Data->Arc.SearchBlock(HEAD_FILE))<=0)
{
if (Data->Arc.Volume && Data->Arc.GetHeaderType()==HEAD_ENDARC &&
Data->Arc.EndArcHead.NextVolume)
if (MergeArchive(Data->Arc,NULL,false,'L'))
{
Data->Arc.Seek(Data->Arc.CurBlockPos,SEEK_SET);
return RARReadHeaderEx(hArcData,D);
}
else
return ERAR_EOPEN;
if (Data->Arc.BrokenHeader)
return ERAR_BAD_DATA;
// Might be necessary if RARSetPassword is still called instead of
// open callback for RAR5 archives and if password is invalid.
if (Data->Arc.FailedHeaderDecryption)
return ERAR_BAD_PASSWORD;
return ERAR_END_ARCHIVE;
}
FileHeader *hd=&Data->Arc.FileHead;
if (Data->OpenMode==RAR_OM_LIST && hd->SplitBefore)
{
int Code=RARProcessFile(hArcData,RAR_SKIP,NULL,NULL);
if (Code==0)
return RARReadHeaderEx(hArcData,D);
else
return Code;
}
wcsncpy(D->ArcNameW,Data->Arc.FileName,ASIZE(D->ArcNameW));
WideToChar(D->ArcNameW,D->ArcName,ASIZE(D->ArcName));
wcsncpy(D->FileNameW,hd->FileName,ASIZE(D->FileNameW));
WideToChar(D->FileNameW,D->FileName,ASIZE(D->FileName));
#ifdef _WIN_ALL
CharToOemA(D->FileName,D->FileName);
#endif
D->Flags=0;
if (hd->SplitBefore)
D->Flags|=RHDF_SPLITBEFORE;
if (hd->SplitAfter)
D->Flags|=RHDF_SPLITAFTER;
if (hd->Encrypted)
D->Flags|=RHDF_ENCRYPTED;
if (hd->Solid)
D->Flags|=RHDF_SOLID;
if (hd->Dir)
D->Flags|=RHDF_DIRECTORY;
D->PackSize=uint(hd->PackSize & 0xffffffff);
D->PackSizeHigh=uint(hd->PackSize>>32);
D->UnpSize=uint(hd->UnpSize & 0xffffffff);
D->UnpSizeHigh=uint(hd->UnpSize>>32);
D->HostOS=hd->HSType==HSYS_WINDOWS ? HOST_WIN32:HOST_UNIX;
if (Data->Arc.Format==RARFMT50)
D->UnpVer=Data->Arc.FileHead.UnpVer==0 ? 50 : 200; // If it is not 0, just set it to something big.
else
D->UnpVer=Data->Arc.FileHead.UnpVer;
D->FileCRC=hd->FileHash.CRC32;
D->FileTime=hd->mtime.GetDos();
D->Method=hd->Method+0x30;
D->FileAttr=hd->FileAttr;
D->CmtSize=0;
D->CmtState=0;
D->DictSize=uint(hd->WinSize/1024);
switch (hd->FileHash.Type)
{
case HASH_RAR14:
case HASH_CRC32:
D->HashType=RAR_HASH_CRC32;
break;
case HASH_BLAKE2:
D->HashType=RAR_HASH_BLAKE2;
memcpy(D->Hash,hd->FileHash.Digest,BLAKE2_DIGEST_SIZE);
break;
default:
D->HashType=RAR_HASH_NONE;
break;
}
}
catch (RAR_EXIT ErrCode)
{
return Data->Cmd.DllError!=0 ? Data->Cmd.DllError : RarErrorToDll(ErrCode);
}
return ERAR_SUCCESS;
}
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;
}
int PASCAL RARReadHeaderEx(HANDLE hArcData,struct RARHeaderDataEx *D)
{
DataSet *Data=(DataSet *)hArcData;
try
{
if ((Data->HeaderSize=(int)Data->Arc.SearchBlock(FILE_HEAD))<=0)
{
if (Data->Arc.Volume && Data->Arc.GetHeaderType()==ENDARC_HEAD &&
(Data->Arc.EndArcHead.Flags & EARC_NEXT_VOLUME))
if (MergeArchive(Data->Arc,NULL,false,'L'))
{
Data->Extract.SignatureFound=false;
Data->Arc.Seek(Data->Arc.CurBlockPos,SEEK_SET);
return(RARReadHeaderEx(hArcData,D));
}
else
return(ERAR_EOPEN);
return(Data->Arc.BrokenFileHeader ? ERAR_BAD_DATA:ERAR_END_ARCHIVE);
}
if (Data->OpenMode==RAR_OM_LIST && (Data->Arc.NewLhd.Flags & LHD_SPLIT_BEFORE)!=0)
{
int Code=RARProcessFile(hArcData,RAR_SKIP,NULL,NULL);
if (Code==0)
return(RARReadHeaderEx(hArcData,D));
else
return(Code);
}
strncpyz(D->ArcName,Data->Arc.FileName,ASIZE(D->ArcName));
if (*Data->Arc.FileNameW)
wcsncpy(D->ArcNameW,Data->Arc.FileNameW,ASIZE(D->ArcNameW));
else
CharToWide(Data->Arc.FileName,D->ArcNameW);
strncpyz(D->FileName,Data->Arc.NewLhd.FileName,ASIZE(D->FileName));
if (*Data->Arc.NewLhd.FileNameW)
wcsncpy(D->FileNameW,Data->Arc.NewLhd.FileNameW,ASIZE(D->FileNameW));
else
{
#ifdef _WIN_ALL
char AnsiName[NM];
OemToCharA(Data->Arc.NewLhd.FileName,AnsiName);
if (!CharToWide(AnsiName,D->FileNameW,ASIZE(D->FileNameW)))
*D->FileNameW=0;
#else
if (!CharToWide(Data->Arc.NewLhd.FileName,D->FileNameW,ASIZE(D->FileNameW)))
*D->FileNameW=0;
#endif
}
D->Flags=Data->Arc.NewLhd.Flags;
D->PackSize=Data->Arc.NewLhd.PackSize;
D->PackSizeHigh=Data->Arc.NewLhd.HighPackSize;
D->UnpSize=Data->Arc.NewLhd.UnpSize;
D->UnpSizeHigh=Data->Arc.NewLhd.HighUnpSize;
D->HostOS=Data->Arc.NewLhd.HostOS;
D->FileCRC=Data->Arc.NewLhd.FileCRC;
D->FileTime=Data->Arc.NewLhd.FileTime;
D->UnpVer=Data->Arc.NewLhd.UnpVer;
D->Method=Data->Arc.NewLhd.Method;
D->FileAttr=Data->Arc.NewLhd.FileAttr;
D->CmtSize=0;
D->CmtState=0;
}
catch (RAR_EXIT ErrCode)
{
return(Data->Cmd.DllError!=0 ? Data->Cmd.DllError:RarErrorToDll(ErrCode));
}
return(0);
}
extern u32 fs_rar_to_menu(const char *rarfile, u32 icolor, u32 selicolor, u32 selrcolor, u32 selbcolor)
{
int fid;
struct RAROpenArchiveData arcdata;
struct RARHeaderDataEx header;
int ret;
HANDLE hrar;
t_fs_filetype ft;
t_win_menuitem item;
if (menu_renew(&g_menu) == NULL) {
return 0;
}
fid = freq_enter_hotzone();
arcdata.ArcName = (char *) rarfile;
arcdata.OpenMode = RAR_OM_LIST;
arcdata.CmtBuf = NULL;
arcdata.CmtBufSize = 0;
hrar = RAROpenArchive(&arcdata);
if (hrar == 0) {
freq_leave(fid);
return 0;
}
add_parent_to_menu(g_menu, icolor, selicolor, selrcolor, selbcolor);
do {
char t[20];
if ((ret = RARReadHeaderEx(hrar, &header)) != 0) {
if (ret != ERAR_UNKNOWN)
break;
RARCloseArchive(hrar);
if ((hrar = reopen_rar_with_passwords(&arcdata)) == 0)
break;
if (RARReadHeaderEx(hrar, &header) != 0)
break;
}
if (header.UnpSize == 0)
continue;
ft = fs_file_get_type(header.FileName);
if (ft == fs_filetype_chm || ft == fs_filetype_zip || ft == fs_filetype_rar)
continue;
win_menuitem_new(&item);
item.data = (void *) ft;
if (header.Flags & 0x200) {
char str[1024];
const u8 *uni;
memset(str, 0, 1024);
uni = (u8 *) header.FileNameW;
charsets_utf32_conv(uni, sizeof(header.FileNameW), (u8 *) str, sizeof(str));
buffer_copy_string_len(item.compname, header.FileName, 256);
filename_to_itemname(&item, str);
} else {
buffer_copy_string_len(item.compname, header.FileName, 256);
filename_to_itemname(&item, header.FileName);
}
SPRINTF_S(t, "%u", (unsigned int) header.UnpSize);
buffer_copy_string(item.shortname, t);
item.selected = false;
item.icolor = icolor;
item.selicolor = selicolor;
item.selrcolor = selrcolor;
item.selbcolor = selbcolor;
item.data3 = header.UnpSize;
win_menu_add(g_menu, &item);
} while (RARProcessFile(hrar, RAR_SKIP, NULL, NULL) == 0);
RARCloseArchive(hrar);
freq_leave(fid);
return g_menu->size;
}
