int main(int argc, char* argv[]) {
for (int i = 0; i < RSN_ENTRIES; i++) {
rsnEntries[i] = NULL;
rsnSize[i] = 0;
}
rsnInfo = NULL;
resetRsnEntries();
printf("\nUnrar Into Memory Learn 1.0\n\n");
rarFileData.ArcName = "test.rar";
rarFileData.OpenMode = RAR_OM_EXTRACT;
rarHandle = RAROpenArchive(&rarFileData);
printf("Opening test.rar: %d\n", rarFileData.OpenResult);
if (rarFileData.OpenResult == ERAR_SUCCESS) {
printf("-->Success\n");
int res = RARReadHeader(rarHandle, &rarFileHeader);
while(res == ERAR_SUCCESS) {
printf("Header '%s' -> %d -> %d Bytes\n", rarFileHeader.FileName, res, rarFileHeader.UnpSize);
if (strfind(rarFileHeader.FileName, ".spc") != NULL && rsnCount < RSN_ENTRIES && rarFileHeader.UnpSize > 66000 && rarFileHeader.UnpSize < 67000) {
printf("--> SPC File, going to extract\n");
rsnEntries[rsnCount] = (char*)malloc(rarFileHeader.UnpSize);
if (rsnEntries[rsnCount] != NULL) {
printf("--> Pointer to memory: %p\n", rsnEntries[rsnCount]);
RARSetCallback(rarHandle, rarExtractSpcBytes, (long)rsnEntries[rsnCount]);
RARProcessFile(rarHandle, RAR_EXTRACT, NULL, NULL);
rsnSize[rsnCount] = rarFileHeader.UnpSize;
rsnCount++;
}
} else if (strfind(rarFileHeader.FileName, ".txt") != NULL && rsnInfo == NULL && rarFileHeader.UnpSize < 10000) {
printf("--> TXT File, going to extract\n");
rsnInfo = (char*)calloc(rarFileHeader.UnpSize + 1, 1);
if (rsnInfo != NULL) {
RARSetCallback(rarHandle, rarExtractInfoBytes, (long)rsnInfo);
RARProcessFile(rarHandle, RAR_EXTRACT, NULL, NULL);
}
} else {
printf("--> Skip\n");
RARProcessFile(rarHandle, RAR_SKIP, NULL, NULL);
}
res = RARReadHeader(rarHandle, &rarFileHeader);
}
printf("Result: %d\n", res);
}
RARCloseArchive(rarHandle);
printf("Tracks: %d\n", rsnCount);
printf("Info: %d\n\n%s\n", rsnInfo == NULL ? 0 : strlen(rsnInfo), rsnInfo == NULL ? "<?>" : rsnInfo);
return 0;
}
int PASCAL RARReadHeader(HANDLE hArcData,struct RARHeaderData *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(RARReadHeader(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))
{
int Code=RARProcessFile(hArcData,RAR_SKIP,NULL,NULL);
if (Code==0)
return(RARReadHeader(hArcData,D));
else
return(Code);
}
strncpyz(D->ArcName,Data->Arc.FileName,ASIZE(D->ArcName));
strncpyz(D->FileName,Data->Arc.NewLhd.FileName,ASIZE(D->FileName));
D->Flags=Data->Arc.NewLhd.Flags;
D->PackSize=Data->Arc.NewLhd.PackSize;
D->UnpSize=Data->Arc.NewLhd.UnpSize;
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 (int ErrCode)
{
return(RarErrorToDll(ErrCode));
}
return(0);
}
jint Java_de_illogical_modo_SpcDecoder_spcLoadRSN(JNIEnv* env, jclass clazz, jstring path)
{
char cpath[1024];
memset(cpath, 0, 1024);
int clen = (*env)->GetStringLength(env, path);
(*env)->GetStringUTFRegion(env, path, 0, clen, cpath);
rarFileData.ArcName = cpath;
rarFileData.OpenMode = RAR_OM_EXTRACT;
rarHandle = RAROpenArchive(&rarFileData);
if (rarFileData.OpenResult == ERAR_SUCCESS)
{
int res = RARReadHeader(rarHandle, &rarFileHeader);
while(res == ERAR_SUCCESS)
{
if (strfind(rarFileHeader.FileName, ".spc") != NULL && rsnCount < RSN_ENTRIES && rarFileHeader.UnpSize > 66000 && rarFileHeader.UnpSize < 67000)
{
rsnEntries[rsnCount] = (char*)malloc(rarFileHeader.UnpSize);
if (rsnEntries[rsnCount] != NULL) {
rarExtractSpcBytes(0xFFFF, 0, 0, 0);
RARSetCallback(rarHandle, rarExtractSpcBytes, (long)rsnEntries[rsnCount]);
RARProcessFile(rarHandle, RAR_EXTRACT, NULL, NULL);
rsnSize[rsnCount] = rarFileHeader.UnpSize;
rsnCount++;
}
} else if (strfind(rarFileHeader.FileName, ".txt") != NULL && rsnInfo == NULL && rarFileHeader.UnpSize < 10000)
{
rsnInfo = (char*)calloc(rarFileHeader.UnpSize + 1, 1);
if (rsnInfo != NULL) {
rarExtractInfoBytes(0xFFFF, 0, 0, 0);
RARSetCallback(rarHandle, rarExtractInfoBytes, (long)rsnInfo);
RARProcessFile(rarHandle, RAR_EXTRACT, NULL, NULL);
}
} else
{
RARProcessFile(rarHandle, RAR_SKIP, NULL, NULL);
}
res = RARReadHeader(rarHandle, &rarFileHeader);
}
}
RARCloseArchive(rarHandle);
return rsnCount;
}
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;
}
/* XXX a return value indicate the status */
static void extract_rar_file_into_loader(GdkPixbufLoader * loader,
const char *archname,
const char *archpath)
{
struct RAROpenArchiveData arcdata;
int code = 0;
int ret;
HANDLE hrar;
arcdata.ArcName = (char *)archname;
arcdata.OpenMode = RAR_OM_EXTRACT;
arcdata.CmtBuf = NULL;
arcdata.CmtBufSize = 0;
hrar = RAROpenArchive(&arcdata);
if (hrar == NULL && loader == NULL)
return;
RARSetCallback(hrar, rarcbpixbuf, (LONG) loader);
do {
struct RARHeaderData header;
if ((ret = RARReadHeader(hrar, &header)) != 0) {
if (ret != ERAR_UNKNOWN && ret != ERAR_BAD_DATA)
break;
RARCloseArchive(hrar);
//test_rar_file_password(buf, archname, archpath);
return;
}
if (strcasecmp(header.FileName, archpath) == 0) {
code = RARProcessFile(hrar, RAR_TEST, NULL, NULL);
break;
}
} while (RARProcessFile(hrar, RAR_SKIP, NULL, NULL) == 0);
RARCloseArchive(hrar);
if (code == 22) {
//test_rar_file_password(buf, archname, archpath);
return;
}
if (code != 0) {
g_object_unref(loader);
}
}
//////////////////////////////////////////////////////////
//
// ExtractFiles
//
// Extract files from supplied archive filename
//
//////////////////////////////////////////////////////////
bool ExtractFiles ( const SString& strFile )
{
// Open archive
RAROpenArchiveData archiveData;
memset ( &archiveData, 0, sizeof ( archiveData ) );
archiveData.ArcName = (char*)*strFile;
archiveData.OpenMode = RAR_OM_EXTRACT;
HANDLE hArcData = RAROpenArchive ( &archiveData );
if ( !hArcData )
return false;
char* szPassword = "******";
RARSetPassword ( hArcData, szPassword );
bool bOk = false;
// Do each file
while ( true )
{
// Read file header
RARHeaderData headerData;
memset ( &headerData, 0, sizeof ( headerData ) );
int iStatus = RARReadHeader ( hArcData, &headerData );
if ( iStatus != 0 )
{
if ( iStatus == ERAR_END_ARCHIVE )
bOk = true;
break;
}
// Read file data
iStatus = RARProcessFile ( hArcData, RAR_EXTRACT, NULL, NULL );
if ( iStatus != 0 )
break;
}
RARCloseArchive ( hArcData );
return bOk;
}
int
unrar_test_password(const char * file, const char * pwd)
{
void * unrar;
struct RARHeaderData headerdata;
struct RAROpenArchiveData archivedata;
int password_incorrect;
password_incorrect = 0;
memset(&headerdata, 0, sizeof(headerdata));
memset(&archivedata, 0, sizeof(archivedata));
archivedata.ArcName = (char *) file;
archivedata.OpenMode = RAR_OM_EXTRACT;
unrar = RAROpenArchive(&archivedata);
if (!unrar || archivedata.OpenResult)
return -2;
RARSetPassword(unrar, (char *) pwd);
RARSetCallback(unrar, _unrar_test_password_callback, (long) &password_incorrect);
if (RARReadHeader(unrar, &headerdata) != 0)
goto error;
if (RARProcessFile(unrar, RAR_TEST, NULL, NULL) != 0)
goto error;
if (password_incorrect)
goto error;
RARCloseArchive(unrar);
return 0;
error:
RARCloseArchive(unrar);
return -1;
}
bool wxRarInputStream::OpenNextFile()
{
RARHeaderData hd;
int nError;
if ((nError = RARReadHeader(m_hRar, &hd)) != 0)
{
//wxMessageBox(wxString::Format(_T("AHH %ld"), nError));
if (nError != ERAR_END_ARCHIVE) {
wxLogSysError(wxString::Format(_("Error : %ld"), nError));
}
return false;
}
m_Info.szName = wxStringFromBBString(bbStringFromCString(hd.FileName));
m_Info.szComment = hd.CmtBuf;
m_Info.dwUncompressedSize = hd.UnpSize;
m_Info.dwCompressedSize = hd.PackSize;
m_Info.dwTime = hd.FileTime;
return true;
}
/* all filelist->data should be g_free()
* if filter == NULL, all files will be in the list
*/
GList *get_filelist_from_rar(const char *archname, GtkFileFilter * filter)
{
GList *filelist = NULL;
gchar *filename = NULL;
struct RAROpenArchiveData arcdata;
int ret;
HANDLE hrar;
arcdata.ArcName = (char *)archname;
arcdata.OpenMode = RAR_OM_EXTRACT;
arcdata.CmtBuf = NULL;
arcdata.CmtBufSize = 0;
hrar = RAROpenArchive(&arcdata);
if (hrar == NULL)
return NULL;
do {
struct RARHeaderData header;
if ((ret = RARReadHeader(hrar, &header)) != 0) {
if (ret != ERAR_UNKNOWN && ret != ERAR_BAD_DATA)
break;
RARCloseArchive(hrar);
//test_rar_file_password(buf, archname, archpath);
return NULL;
}
filename = g_strdup(header.FileName);
if ((filter != NULL && gtk_filename_filter(filename, filter))
|| filter == NULL)
filelist = g_list_append(filelist, filename);
} while (RARProcessFile(hrar, RAR_SKIP, NULL, NULL) == 0);
RARCloseArchive(hrar);
return filelist;
}
JNIEXPORT jbyteArray JNICALL Java_net_kervala_comicsreader_RarFile_nativeGetData(JNIEnv *env, jclass, jstring jFilename, jstring jEntry)
{
jbyteArray ret = NULL;
const char *filename = env->GetStringUTFChars(jFilename, NULL);
const char *entry = env->GetStringUTFChars(jEntry, NULL);
RAROpenArchiveData data;
memset(&data, 0, sizeof(RAROpenArchiveData));
data.ArcName = (char*)filename;
data.OpenMode = RAR_OM_EXTRACT;
HANDLE handle = RAROpenArchive(&data);
if (handle && !data.OpenResult)
{
RARHeaderData header;
memset(&header, 0, sizeof(RARHeaderData));
// process each entry
while (RARReadHeader(handle, &header) == 0)
{
// check if we must process this entry
if (strcmp(header.FileName, entry) == 0)
{
// set buffer related variables
Buffer buffer(header.UnpSize);
RARSetCallback(handle, callbackData, (LPARAM)&buffer);
// don't use RAR_EXTRACT because files will be extracted in current directory
int result = RARProcessFile(handle, RAR_TEST, NULL, NULL);
if (result)
{
LOGE("Unable to process %s, error: %d", header.FileName, result);
}
else
{
// allocates a new Java buffer
ret = env->NewByteArray(buffer.getSize());
// copy C++ buffer data to Java buffer
env->SetByteArrayRegion(ret, 0, buffer.getSize(), (jbyte *)buffer.getAddress());
// exit if file was correctly extracted
break;
}
}
else
{
// skip this entry
int result = RARProcessFile(handle, RAR_SKIP, NULL, NULL);
if (result)
{
LOGE("Unable to skip %s, error: %d", header.FileName, result);
}
}
}
RARCloseArchive(handle);
}
else
{
displayError(data.OpenResult, filename);
}
// release UTF-8 strings
env->ReleaseStringUTFChars(jEntry, entry);
env->ReleaseStringUTFChars(jFilename, filename);
return ret;
}
JNIEXPORT jobjectArray JNICALL Java_net_kervala_comicsreader_RarFile_nativeGetEntries(JNIEnv *env, jclass, jstring jFilename)
{
jobjectArray ret = NULL;
const char *filename = env->GetStringUTFChars(jFilename, NULL);
RAROpenArchiveData data;
memset(&data, 0, sizeof(RAROpenArchiveData));
data.ArcName = (char*)filename;
data.OpenMode = RAR_OM_LIST;
HANDLE handle = RAROpenArchive(&data);
if (handle && !data.OpenResult)
{
RARHeaderData header;
memset(&header, 0, sizeof(RARHeaderData));
Strings list;
// read all entries
while (RARReadHeader(handle, &header) == 0)
{
// add file to list only if not a directory
if ((header.Flags & LHD_DIRECTORY) != LHD_DIRECTORY) list.addString(header.FileName);
// skip entry content
int result = RARProcessFile(handle, RAR_SKIP, NULL, NULL);
if (result)
{
LOGE("Unable to process %s, error: %d", header.FileName, result);
}
}
RARCloseArchive(handle);
size_t count = list.size();
if (count > 0)
{
ret = (jobjectArray)env->NewObjectArray(count, env->FindClass("java/lang/String"), NULL);
Strings *tmp = &list;
int i = 0;
while(tmp)
{
env->SetObjectArrayElement(ret, i++, env->NewStringUTF(tmp->getString()));
tmp = tmp->getNext();
}
}
}
else
{
displayError(data.OpenResult, filename);
}
env->ReleaseStringUTFChars(jFilename, filename);
return ret;
}
void extract(const std::string & archive_name, const std::string & dest_dir, const std::string & password)
{
bool already_extracted;
#ifdef WINDOWS
already_extracted = contains(extracted_files, archive_name, false);
#else
already_extracted = contains(extracted_files, archive_name, true);
#endif
if (already_extracted)
return;
fprintf(stdout, "Extracting %s to %s\n", archive_name.c_str(), dest_dir.c_str());
HANDLE archive;
struct RAROpenArchiveData data;
struct RARHeaderData header;
if (!fileExists(archive_name))
return;
if (!createDir(dest_dir))
return;
data.ArcName = (char *)archive_name.c_str();
data.OpenMode = RAR_OM_EXTRACT;
data.CmtBuf = NULL;
data.CmtBufSize = 0;
//fprintf(stdout, "Opening %s\n", argv[1]);
archive = RAROpenArchive(&data);
if (!archive || data.OpenResult != 0)
{
fprintf(stderr, "Couldn't open %s\n", archive_name.c_str());
return;
}
header.CmtBuf = NULL;
//fprintf(stdout, "Clearing password\n");
RARSetPassword(archive, (char*)password.c_str());
MultipartInfo info;
//fprintf(stdout, "Setting callback\n");
RARSetCallback(archive, &missing_file, (ssize_t)&info);
//fprintf(stdout, "Starting to process file\n");
// the complete path to the file to be extracted
std::string dest_path;
start_timer();
while (!RARReadHeader(archive, &header))
{
dest_path = dest_dir + PATH_SEP + header.FileName;
if (pathExists(dest_path))
{
fprintf(stderr, "Skpping %s\n", header.FileName);
continue;
}
if (RARProcessFile(archive, RAR_EXTRACT, (char *)dest_dir.c_str(), NULL))
{
/*if (!pathExists(dest_path))
{
fprintf(stderr, "Couldn't create %s\n", dest_path.c_str());
break;
}*/
if (elapsed(five_seconds))
{
info.bytes_processed = 0;
start_timer();
}
}
else
{
break;
}
// (bytes / (1024 * 1024) = MBytes
// ms / 1000 = s
// (bytes / (1024 * 1024) / (ms / 1000) = 0.00095367431640625 * bytes/ms
//fprintf(stdout, "%d MB/s", (int)(0.00095367431640625 * (info.bytes_processed / calc_elapsed())));
}
//fprintf(stdout, "Closing file\n");
RARCloseArchive(archive);
extracted_files.push_back(archive_name);
}
