name string | code string | asm string | file string |
|---|---|---|---|
cmValue cmTargetPropertyComputer::GetProperty<cmGeneratorTarget>(cmGeneratorTarget const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmMakefile const&) | static cmValue GetProperty(Target const* tgt, const std::string& prop,
cmMakefile const& mf)
{
if (cmValue loc = GetLocation(tgt, prop, mf)) {
return loc;
}
if (cmSystemTools::GetFatalErrorOccurred()) {
return nullptr;
}
if (prop == "SOURCES") {
retur... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3caa4c
testq %rax, %rax
jne 0x3c250c
leaq 0x4a128a(%rip), %rax # 0x863773
cmpb $0x0, (%rax)
jne 0x3c250a
callq 0x1e3b2e
testb %al, %al
jne 0x3c250a
leaq 0x2c7c4b(%rip), %rsi # 0x68a149
movq %r14, %rdi
callq 0x411b0
testl %eax, %eax
je 0x3c25... | /JKorbelRA[P]CMake/Source/cmTargetPropertyComputer.h |
TargetPropertyEntryFileSet::GetBacktrace() const | cmListFileBacktrace GetBacktrace() const override
{
return this->EntryCge->GetBacktrace();
} | movq %rdi, %rax
movq 0x30(%rsi), %rcx
movq (%rcx), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x3c8cb8
movq 0x4952ad(%rip), %rdx # 0x85df58
cmpb $0x0, (%rdx)
je 0x3c8cb4
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
nop
| /JKorbelRA[P]CMake/Source/cmGeneratorTarget.cxx |
cmGlobalUnixMakefileGenerator3::CountProgressMarksInAll(cmLocalGenerator const&) | size_t cmGlobalUnixMakefileGenerator3::CountProgressMarksInAll(
const cmLocalGenerator& lg)
{
size_t count = 0;
std::set<cmGeneratorTarget const*> emitted;
for (cmGeneratorTarget const* target :
this->DirectoryTargetsMap[lg.GetStateSnapshot()]) {
count += this->CountProgressMarksInTarget(target, emit... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x8(%rsp), %rdi
callq 0x17966a
leaq 0x7b0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3... | /JKorbelRA[P]CMake/Source/cmGlobalUnixMakefileGenerator3.cxx |
cmGlobalUnixMakefileGenerator3::AddCXXCompileCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::_... | void cmGlobalUnixMakefileGenerator3::AddCXXCompileCommand(
const std::string& sourceFile, const std::string& workingDirectory,
const std::string& compileCommand, const std::string& objPath)
{
if (!this->CommandDatabase) {
std::string commandDatabaseName =
this->GetCMakeInstance()->GetHomeOutputDirectory... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movq 0x7a8(%rdi), %rdi
testq %rdi, %rdi
je 0x3d533a
leaq 0x2b5ee3(%rip), %rsi # 0x68b20e
movl $0x2, %edx
callq 0x41490
jmp 0x3d53e0
movq 0x78(%r13), %rdi
c... | /JKorbelRA[P]CMake/Source/cmGlobalUnixMakefileGenerator3.cxx |
cmGlobalUnixMakefileGenerator3::WriteMainCMakefileLanguageRules(cmGeneratedFileStream&, std::vector<std::unique_ptr<cmLocalGenerator, std::default_delete<cmLocalGenerator>>, std::allocator<std::unique_ptr<cmLocalGenerator, std::default_delete<cmLocalGenerator>>>>&) | void cmGlobalUnixMakefileGenerator3::WriteMainCMakefileLanguageRules(
cmGeneratedFileStream& cmakefileStream,
std::vector<std::unique_ptr<cmLocalGenerator>>& lGenerators)
{
// now list all the target info files
cmakefileStream << "# Dependency information for all targets:\n";
cmakefileStream << "set(CMAKE_DEP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x2b8788(%rip), %rsi # 0x68f57b
movl $0x2a, %edx
movq %rbx, %rdi
callq 0x41490
leaq 0x2b879f(%rip), %rsi # 0x68f5a6
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x41490
movq (%r14), %r12
movq 0x8(%r14... | /JKorbelRA[P]CMake/Source/cmGlobalUnixMakefileGenerator3.cxx |
cmGlobalUnixMakefileGenerator3::GetName[abi:cxx11]() const | std::string GetName() const override
{
return cmGlobalUnixMakefileGenerator3::GetActualName();
} | movq %rdi, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movabsq $0x6b614d2078696e55, %rcx # imm = 0x6B614D2078696E55
movq %rcx, 0x10(%rdi)
movabsq $0x73656c6966656b61, %rcx # imm = 0x73656C6966656B61
movq %rcx, 0x16(%rdi)
movq $0xe, 0x8(%rdi)
movb $0x0, 0x1e(%rdi)
retq
nop
| /JKorbelRA[P]CMake/Source/cmGlobalUnixMakefileGenerator3.h |
cmGraphVizWriter::FindAllConnections(std::map<cmLinkItem, std::vector<cmGraphVizWriter::Connection, std::allocator<cmGraphVizWriter::Connection>>, std::less<cmLinkItem>, std::allocator<std::pair<cmLinkItem const, std::vector<cmGraphVizWriter::Connection, std::allocator<cmGraphVizWriter::Connection>>>>> const&, cmLinkIt... | void cmGraphVizWriter::FindAllConnections(const ConnectionsMap& connectionMap,
const cmLinkItem& rootItem,
Connections& extendedCons,
std::set<cmLinkItem>& visitedItems)
{
// some "targets" ar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3deefc
movq %r15, 0x8(%rsp)
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x3dd89f
movq 0x8(%rsp), %rdi
movq %r13, %rs... | /JKorbelRA[P]CMake/Source/cmGraphVizWriter.cxx |
cmInstallGenerator::cmInstallGenerator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::... | cmInstallGenerator::cmInstallGenerator(
std::string destination, std::vector<std::string> const& configurations,
std::string component, MessageLevel message, bool exclude_from_all,
bool all_components, cmListFileBacktrace backtrace)
: cmScriptGenerator("CMAKE_INSTALL_CONFIG_NAME", configurations)
, Destinatio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %r14d
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2b0ce0(%rip), %rsi # 0x69019a
leaq 0x2b0cf2(%rip), %rdx # 0x6901b3
leaq 0x10(... | /JKorbelRA[P]CMake/Source/cmInstallGenerator.cxx |
cmInstallExportGenerator::GetTempDir[abi:cxx11]() const | std::string cmInstallExportGenerator::GetTempDir() const
{
if (this->TempDir.empty()) {
return this->TempDirCalculate();
}
return this->TempDir;
} | pushq %rbx
movq %rdi, %rbx
movq 0x168(%rsi), %rdx
testq %rdx, %rdx
je 0x3e256b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x160(%rsi), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x777d0
jmp 0x3e2573
movq %rbx, %rdi
callq 0x3e2404
movq %rbx, %rax
popq %rbx
retq
| /JKorbelRA[P]CMake/Source/cmInstallExportGenerator.cxx |
cmInstalledFile::GetProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const | bool cmInstalledFile::GetProperty(const std::string& prop,
std::string& value) const
{
auto i = this->Properties.find(prop);
if (i == this->Properties.end()) {
return false;
}
Property const& property = i->second;
std::string output;
std::string separator;
for (con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x3e4c08
movq %rax, %r14
addq $0x30, %rbx
cmpq %rbx, %rax
je 0x3e445b
movq %r15, 0x50(%rsp)
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %a... | /JKorbelRA[P]CMake/Source/cmInstalledFile.cxx |
cmInstallFilesGenerator::cmInstallFilesGenerator(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<cha... | cmInstallFilesGenerator::cmInstallFilesGenerator(
std::vector<std::string> const& files, std::string const& dest,
bool programs, std::string file_permissions,
std::vector<std::string> const& configurations, std::string const& component,
MessageLevel message, bool exclude_from_all, std::string rename,
bool opt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r15
movq %r8, %r12
movl %ecx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa0(%rsp), %r13
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x777... | /JKorbelRA[P]CMake/Source/cmInstallFilesGenerator.cxx |
cmInstallImportedRuntimeArtifactsGenerator::cmInstallImportedRuntimeArtifactsGenerator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | cmInstallImportedRuntimeArtifactsGenerator::
cmInstallImportedRuntimeArtifactsGenerator(
std::string targetName, std::string const& dest,
std::string file_permissions,
std::vector<std::string> const& configurations,
std::string const& component, MessageLevel message, bool exclude_from_all,
bool op... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x777d0
leaq 0x30(%rsp), %rbp
movq %r... | /JKorbelRA[P]CMake/Source/cmInstallImportedRuntimeArtifactsGenerator.cxx |
cmInstallImportedRuntimeArtifactsGenerator::GetDestination(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmInstallImportedRuntimeArtifactsGenerator::GetDestination(
std::string const& config) const
{
return cmGeneratorExpression::Evaluate(
this->Destination, this->Target->GetLocalGenerator(), config);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x70(%rsi), %rsi
movq 0x78(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x777d0
movq 0xe8(%r15), %rdi
callq 0x3972ae
leaq 0x38(%rsp), %r15
movq %r15, -... | /JKorbelRA[P]CMake/Source/cmInstallImportedRuntimeArtifactsGenerator.cxx |
cmInstallImportedRuntimeArtifactsGenerator::~cmInstallImportedRuntimeArtifactsGenerator() | ~cmInstallImportedRuntimeArtifactsGenerator() override = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x46c46d(%rip), %rax # 0x853158
movq %rax, (%rdi)
movq 0xf0(%rdi), %rdi
leaq 0x100(%rbx), %rax
cmpq %rax, %rdi
je 0x3e6d0c
movq (%rax), %rsi
incq %rsi
callq 0x3f310
movq 0xc8(%rbx), %rdi
leaq 0xd8(%rbx), %rax
cmpq %rax, %rdi
je 0x3e6d2a
movq (%rax), %rsi
incq %rsi
callq 0x3f310
movq %... | /JKorbelRA[P]CMake/Source/cmInstallImportedRuntimeArtifactsGenerator.h |
cmInstallSubdirectoryGenerator::cmInstallSubdirectoryGenerator(cmMakefile*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmListFileBacktrace) | cmInstallSubdirectoryGenerator::cmInstallSubdirectoryGenerator(
cmMakefile* makefile, std::string binaryDirectory,
cmListFileBacktrace backtrace)
: cmInstallGenerator("", std::vector<std::string>(), "", MessageDefault,
false, false, std::move(backtrace))
, Makefile(makefile)
, BinaryDir... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2d520b(%rip), %r13 # 0x6bf049
movq %rsp, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x5c768
leaq 0x30(%rsp), %rbp
xorp... | /JKorbelRA[P]CMake/Source/cmInstallSubdirectoryGenerator.cxx |
cmInstallTargetGenerator::GetDestination(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string cmInstallTargetGenerator::GetDestination(
std::string const& config) const
{
return cmGeneratorExpression::Evaluate(
this->Destination, this->Target->GetLocalGenerator(), config);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x70(%rsi), %rsi
movq 0x78(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x777d0
movq 0xe8(%r15), %rdi
callq 0x3972ae
leaq 0x38(%rsp), %r15
movq %r15, -... | /JKorbelRA[P]CMake/Source/cmInstallTargetGenerator.cxx |
cmLocalUnixMakefileGenerator3::GetIndividualFileTargets(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets(
std::vector<std::string>& targets)
{
std::map<std::string, LocalObjectInfo> localObjectFiles;
this->GetLocalObjectFiles(localObjectFiles);
for (auto const& localObjectFile : localObjectFiles) {
targets.push_back(localObjectFile.first);
std::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
leaq 0x50(%rsp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
leaq 0x48(%rsp), %rsi
callq 0x3f2850
movq 0x60(%rsp), %r14
cmpq %r15, %r14
je ... | /JKorbelRA[P]CMake/Source/cmLocalUnixMakefileGenerator3.cxx |
cmLocalUnixMakefileGenerator3::AppendCustomDepends(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<cmCustomCommand, std::allocator<cmCustomCommand>> const&) | void cmLocalUnixMakefileGenerator3::AppendCustomDepends(
std::vector<std::string>& depends, const std::vector<cmCustomCommand>& ccs)
{
for (cmCustomCommand const& cc : ccs) {
cmCustomCommandGenerator ccg(cc, this->GetConfigName(), this);
this->AppendCustomDepend(depends, ccg);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rsi, 0x38(%rsp)
movq (%rdx), %r15
movq 0x8(%rdx), %rbx
cmpq %rbx, %r15
je 0x3f79bb
movq %rdi, %r14
leaq 0x40(%rsp), %r12
leaq 0x60(%rsp), %r13
leaq 0x88(%rsp), %rbp
movq %r12, %rdi
movq %r14, %rsi
callq 0x... | /JKorbelRA[P]CMake/Source/cmLocalUnixMakefileGenerator3.cxx |
cmLocalUnixMakefileGenerator3::AppendCleanCommand(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator... | void cmLocalUnixMakefileGenerator3::AppendCleanCommand(
std::vector<std::string>& commands, const std::set<std::string>& files,
cmGeneratorTarget* target, const char* filename)
{
std::string currentBinDir = this->GetCurrentBinaryDirectory();
std::string cleanfile = cmStrCat(
currentBinDir, '/', this->GetTar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %r8, 0x58(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, 0xb0(%rsp)
movq %rdi, %rbp
callq 0x183b4e
leaq 0xc8(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq ... | /JKorbelRA[P]CMake/Source/cmLocalUnixMakefileGenerator3.cxx |
cmMakefileTargetGenerator::GetTargetLinkFlags(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmMakefileTargetGenerator::GetTargetLinkFlags(
std::string& flags, const std::string& linkLanguage)
{
this->LocalGenerator->AppendFlags(
flags, this->GeneratorTarget->GetSafeProperty("LINK_FLAGS"));
std::string linkFlagsConfig =
cmStrCat("LINK_FLAGS_", cmSystemTools::UpperCase(this->GetConfigName())... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r13
movq 0x78(%rdi), %r12
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x281bba(%rip), %rsi # 0x6823d6
leaq 0x281bbd(%rip), %rdx # 0x6823e0
movq %rsp, %rdi
callq... | /JKorbelRA[P]CMake/Source/cmMakefileTargetGenerator.cxx |
cmMakefileTargetGenerator::WriteObjectDependRules(cmSourceFile const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | void cmMakefileTargetGenerator::WriteObjectDependRules(
cmSourceFile const& source, std::vector<std::string>& depends)
{
// Create the list of dependencies known at cmake time. These are
// shared between the object file and dependency scanning rule.
depends.push_back(source.GetFullPath());
if (cmValue objec... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x1ceb6a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7488c
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x27063e(%rip), %rsi # 0x67c0a1
leaq 0x270645(%rip), %rdx # 0x67c0af
leaq 0x8(%rsp), %r15
movq... | /JKorbelRA[P]CMake/Source/cmMakefileTargetGenerator.cxx |
curl_easy_upkeep | CURLcode curl_easy_upkeep(struct Curl_easy *data)
{
/* Verify that we got an easy handle we can work with. */
if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT;
if(data->multi_easy) {
/* Use the common function to keep connections alive. */
return upkeep(&data->multi_easy->conn_cache, da... | pushq %rbx
movl $0x2b, %ebx
testq %rdi, %rdi
je 0x495671
cmpl $0xc0dedbad, (%rdi) # imm = 0xC0DEDBAD
jne 0x495671
movq 0xc0(%rdi), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x495671
addq $0xe8, %rsi
leaq 0xc(%rip), %rcx # 0x495675
movq %rdi, %rdx
callq 0x4b4794
movl %ebx, %eax
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/easy.c |
h2_session_send | static int h2_session_send(struct Curl_easy *data,
nghttp2_session *h2)
{
struct HTTP *stream = data->req.p.http;
struct http_conn *httpc = &data->conn->proto.httpc;
set_transfer(httpc, data);
if((data->set.stream_weight != data->state.stream_weight) ||
(data->set.stream_depends_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x18(%rdi), %rax
movq 0x198(%rdi), %r15
movq %rdi, 0x4a0(%rax)
movl 0xa40(%rdi), %eax
cmpl 0x1190(%rdi), %eax
jne 0x496932
movq 0xa92(%rdi), %rax
shrq $0x2d, %rax
movl 0x1300(%rdi), %ecx
shrl $0xc, %ecx
xorl %eax, %ecx
testb $0x1, %cl
jne 0x496932
m... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http2.c |
curl_mime_type | CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
Curl_safefree(part->mimetype);
part->mimetype = NULL;
if(mimetype) {
part->mimetype = strdup(mimetype);
if(!part->mimetype)
return CURLE_OUT_OF_MEMORY;
}
return CURLE_OK;
} | testq %rdi, %rdi
je 0x49936c
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3c7350(%rip), %rax # 0x860690
movq 0x60(%rdi), %rdi
callq *(%rax)
movq $0x0, 0x60(%rbx)
testq %r14, %r14
je 0x499368
leaq 0x3c7346(%rip), %rax # 0x8606a0
movq %r14, %rdi
callq *(%rax)
movq %rax, 0x60(%rbx)
testq %... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
readback_part | static size_t readback_part(curl_mimepart *part,
char *buffer, size_t bufsize, bool *hasread)
{
size_t cursize = 0;
/* Readback from part. */
while(bufsize) {
size_t sz = 0;
struct curl_slist *hdr = (struct curl_slist *) part->state.ptr;
switch(part->state.state) {
ca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x20(%rsp)
testq %rdx, %rdx
je 0x499bd7
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
leaq 0x88(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0xb8(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0xa0(%rdi), %rax
movq %rax, 0x30(%rsp)
xorl %e... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
Curl_mime_add_header | CURLcode Curl_mime_add_header(struct curl_slist **slp, const char *fmt, ...)
{
struct curl_slist *hdr = NULL;
char *s = NULL;
va_list ap;
va_start(ap, fmt);
s = curl_mvaprintf(fmt, ap);
va_end(ap);
if(s) {
hdr = Curl_slist_append_nodup(*slp, s);
if(hdr)
*slp = hdr;
else
free(s);
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x499deb
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
mov... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mime.c |
curl_msnprintf | int curl_msnprintf(char *buffer, size_t maxlength, const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = curl_mvsnprintf(buffer, maxlength, format, ap_save);
va_end(ap_save);
return retcode;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x49c007
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mprintf.c |
Curl_dyn_vprintf | int Curl_dyn_vprintf(struct dynbuf *dyn, const char *format, va_list ap_save)
{
struct asprintf info;
info.b = dyn;
info.fail = 0;
(void)dprintf_formatf(&info, alloc_addbyter, format, ap_save);
if(info.fail) {
Curl_dyn_free(info.b);
return 1;
}
return 0;
} | pushq %rbx
subq $0x10, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rsp, %rbx
movq %rdi, (%rbx)
movb $0x0, 0x8(%rbx)
leaq 0x24(%rip), %rsi # 0x49c074
movq %rbx, %rdi
callq 0x49ad22
xorl %eax, %eax
cmpb $0x1, 0x8(%rbx)
jne 0x49c06e
movq (%rsp), %rdi
callq 0x4b92db
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mprintf.c |
alloc_addbyter | static int alloc_addbyter(int output, FILE *data)
{
struct asprintf *infop = (struct asprintf *)data;
unsigned char outc = (unsigned char)output;
if(Curl_dyn_addn(infop->b, &outc, 1)) {
infop->fail = 1;
return -1; /* fail */
}
return outc; /* fputc() returns like this on success */
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0xf(%rsp), %rsi
movb %dil, (%rsi)
movq (%rbx), %rdi
movl $0x1, %edx
callq 0x4b9370
testl %eax, %eax
je 0x49c0a0
movb $0x1, 0x8(%rbx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x49c0a5
movzbl 0xf(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/mprintf.c |
Curl_expire | void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id id)
{
struct Curl_multi *multi = data->multi;
struct curltime *nowp = &data->state.expiretime;
struct curltime set;
/* this is only interesting while there is still an associated multi struct
remaining! */
if(!multi)
return;
DEB... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xb8(%rdi), %rbp
testq %rbp, %rbp
je 0x49c9d1
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4a8120
movq %rax, %rcx
movl %edx, %esi
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
movq %r14, %rax
imulq %rdx
mo... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/multi.c |
Curl_pgrsLimitWaitTime | timediff_t Curl_pgrsLimitWaitTime(curl_off_t cursize,
curl_off_t startsize,
curl_off_t limit,
struct curltime start,
struct curltime now)
{
curl_off_t size = cursize - startsize;
t... | movq %rdx, %r9
testq %rdx, %rdx
sete %al
subq %rsi, %rdi
sete %dl
orb %al, %dl
jne 0x4a0f40
pushq %rbx
leaq 0x10(%rsp), %rsi
movabsq $0x20c49ba5e353f7, %r10 # imm = 0x20C49BA5E353F7
cmpq %r10, %rdi
jge 0x4a0f43
imulq $0x3e8, %rdi, %rax # imm = 0x3E8
cqto
idivq %r9
movq %rax, %rbx
jmp 0x4a0f63
xorl %eax, %eax
retq
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/progress.c |
Curl_slist_duplicate | struct curl_slist *Curl_slist_duplicate(struct curl_slist *inlist)
{
struct curl_slist *outlist = NULL;
struct curl_slist *tmp;
while(inlist) {
tmp = curl_slist_append(outlist, inlist->data);
if(!tmp) {
curl_slist_free_all(outlist);
return NULL;
}
outlist = tmp;
inlist = inlist-... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4a68d8
movq %rdi, %r15
xorl %r14d, %r14d
movq (%r15), %rsi
movq %r14, %rdi
callq 0x4a6804
testq %rax, %rax
je 0x4a68a9
movq %rax, %rbx
movq 0x8(%r15), %r15
movq %rax, %r14
testq %r15, %r15
jne 0x4a6888
jmp 0x4a68da
testq %r14, %r14
je 0x4a68d8... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/slist.c |
Curl_strcasecompare | int Curl_strcasecompare(const char *first, const char *second)
{
while(*first && *second) {
if(Curl_raw_toupper(*first) != Curl_raw_toupper(*second))
/* get out of the loop as soon as they don't match */
return 0;
first++;
second++;
}
/* If we're here either the strings are the same or the... | movb (%rdi), %dl
testb %dl, %dl
je 0x4a7e00
incq %rdi
leaq 0x1fc036(%rip), %rcx # 0x6a3e10
movzbl (%rsi), %r8d
testq %r8, %r8
setne %al
je 0x4a7e02
movzbl %dl, %edx
movb (%rdx,%rcx), %dl
cmpb (%r8,%rcx), %dl
jne 0x4a7e0e
incq %rsi
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x4a7dda
jmp 0x4a7e02
movb $0x1, %al
cmp... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/strcase.c |
trailers_read | static size_t trailers_read(char *buffer, size_t size, size_t nitems,
void *raw)
{
struct Curl_easy *data = (struct Curl_easy *)raw;
struct dynbuf *trailers_buf = &data->state.trailers_buf;
size_t bytes_left = Curl_dyn_len(trailers_buf) -
data->state.trailers_bytes_sent;
size_t t... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1210(%rcx), %r12
movq %r12, %rdi
callq 0x4b94fe
subq 0x1208(%r14), %rax
imulq %r13, %rbx
cmpq %rax, %rbx
cmovaeq %rax, %rbx
testq %rbx, %rbx
je 0x4a86d0
movq %r12, %rdi
callq 0x4b94f6
addq 0x120... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/transfer.c |
Curl_meets_timecondition | bool Curl_meets_timecondition(struct Curl_easy *data, time_t timeofdoc)
{
if((timeofdoc == 0) || (data->set.timevalue == 0))
return TRUE;
switch(data->set.timecondition) {
case CURL_TIMECOND_IFMODSINCE:
default:
if(timeofdoc <= data->set.timevalue) {
infof(data,
"The requested documen... | pushq %rbp
pushq %rbx
pushq %rax
movb $0x1, %bpl
testq %rsi, %rsi
je 0x4a88ac
movq %rdi, %rbx
movq 0x530(%rdi), %rax
testq %rax, %rax
je 0x4a88ac
cmpb $0x2, 0x538(%rbx)
jne 0x4a888d
cmpq %rsi, %rax
jg 0x4a88ac
leaq 0x1fcc42(%rip), %rsi # 0x6a54cd
jmp 0x4a8899
cmpq %rsi, %rax
jl 0x4a88ac
leaq 0x1fcc0b(%rip), %rsi ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/transfer.c |
Curl_single_getsock | int Curl_single_getsock(struct Curl_easy *data,
struct connectdata *conn,
curl_socket_t *sock)
{
int bitmap = GETSOCK_BLANK;
unsigned sockindex = 0;
if(conn->handler->perform_getsock)
return conn->handler->perform_getsock(data, conn, sock);
/* don't include ... | movq 0x398(%rsi), %rax
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x4a975f
jmpq *%rax
movl 0x144(%rdi), %r8d
movl %r8d, %ecx
andl $0x15, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x4a9787
movl 0x3b8(%rsi), %eax
movl %eax, (%rdx)
movl 0x144(%rdi), %r8d
movl $0x1, %eax
andl $0x2a, %r8d
cmpl $0x2, %r8d
jne 0x4a97be
movl 0x3... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/transfer.c |
Curl_builtin_scheme | const struct Curl_handler *Curl_builtin_scheme(const char *scheme,
size_t schemelen)
{
const struct Curl_handler * const *pp;
const struct Curl_handler *p;
/* Scan protocol handler table and match against 'scheme'. The handler may
be changed later when the proto... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $-0x1, %rsi
jne 0x4aaec1
movq %rbx, %rdi
callq 0x3fd60
movq %rax, %r14
leaq 0x3ad278(%rip), %r15 # 0x858140
leaq 0x3acd49(%rip), %r12 # 0x857c18
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4a7e2e
testl %eax, ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/url.c |
reuse_conn | static void reuse_conn(struct Curl_easy *data,
struct connectdata *old_conn,
struct connectdata *conn)
{
/* 'local_ip' and 'local_port' get filled with local's numerical
ip address and port number whenever an outgoing connection is
**established** from the prima... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x2e(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp) # imm = 0xFFFFFFFF
cmpq $0x0, 0x188(%rsi)
je 0x4adf35
leaq 0x188(%... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/url.c |
free_urlhandle | static void free_urlhandle(struct Curl_URL *u)
{
free(u->scheme);
free(u->user);
free(u->password);
free(u->options);
free(u->host);
free(u->zoneid);
free(u->port);
free(u->path);
free(u->query);
free(u->fragment);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3b1c1a(%rip), %r14 # 0x860690
movq (%rdi), %rdi
callq *(%r14)
movq 0x8(%rbx), %rdi
callq *(%r14)
movq 0x10(%rbx), %rdi
callq *(%r14)
movq 0x18(%rbx), %rdi
callq *(%r14)
movq 0x20(%rbx), %rdi
callq *(%r14)
movq 0x28(%rbx), %rdi
callq *(%r14)
movq 0x30(%rbx), %rd... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/urlapi.c |
Curl_auth_digest_get_pair | bool Curl_auth_digest_get_pair(const char *str, char *value, char *content,
const char **endptr)
{
int c;
bool starts_with_quote = FALSE;
bool escape = FALSE;
for(c = DIGEST_MAX_VALUE_LENGTH - 1; (*str && (*str != '=') && c--);)
*value++ = *str++;
*value = 0;
if('=' != *... | xorl %r8d, %r8d
xorl %eax, %eax
movzbl (%rdi,%r8), %r9d
testl %r9d, %r9d
je 0x4b1142
cmpl $0x3d, %r9d
je 0x4b1142
cmpl $0xff, %r8d
je 0x4b1142
movb %r9b, (%rsi,%r8)
decq %rax
incq %r8
jmp 0x4b111d
movb $0x0, (%rsi,%r8)
cmpb $0x3d, (%rdi,%r8)
jne 0x4b11f7
leaq 0x1(%rdi), %r9
movb 0x1(%rdi,%r8), %sil
addq $0x2, %rdi
cmpb... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vauth/digest.c |
Curl_auth_decode_digest_http_message | CURLcode Curl_auth_decode_digest_http_message(const char *chlg,
struct digestdata *digest)
{
bool before = FALSE; /* got a nonce before */
bool foundAuth = FALSE;
bool foundAuthInt = FALSE;
char *token = NULL;
char *tmp = NULL;
/* If we already have received a ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp # imm = 0x538
movq %rsi, %rbx
movq %rdi, %rbp
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movq (%rsi), %rax
movq %rax, 0x28(%rsp)
movq %rsi, %rdi
callq 0x4b1ca0
movq $0x0, 0x10(%rsp)
leaq 0x30(%rsp), %r15
leaq 0x130(%rsp), %r12
le... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vauth/digest.c |
trynextip | static CURLcode trynextip(struct Curl_easy *data,
struct connectdata *conn,
int sockindex,
int tempindex)
{
CURLcode result = CURLE_COULDNT_CONNECT;
/* First clean up after the failed socket.
Don't close it yet to ensure that the ne... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %ecx, %eax
movl 0x1e8(%rsi,%rax,4), %ebp
movl $0xffffffff, 0x1e8(%rsi,%rax,4) # imm = 0xFFFFFFFF
movl $0x7, %r12d
testl %edx, %edx
je 0x4b57bb
cmpl $-0x1, %ebp
je 0x4b57a9
movq %r14, %rdi
movq %rbx, %rsi
mo... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/connect.c |
Curl_closesocket | int Curl_closesocket(struct Curl_easy *data, struct connectdata *conn,
curl_socket_t sock)
{
if(conn && conn->fclosesocket) {
if((sock == conn->sock[SECONDARYSOCKET]) && conn->bits.sock_accepted)
/* if this socket matches the second socket, and that was created with
accept, the... | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
testq %rsi, %rsi
je 0x4b590d
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x50(%rsi)
je 0x4b5903
cmpl %ebx, 0x1e4(%r15)
jne 0x4b58c6
movl 0x374(%r15), %eax
btl $0x1d, %eax
jb 0x4b58f7
movq %r14, %rdi
movl %ebx, %esi
callq 0x49f4b1
movq %r14, %rdi
movl $0x1, %esi
callq 0x49... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/connect.c |
process_zlib_error | static CURLcode
process_zlib_error(struct Curl_easy *data, z_stream *z)
{
if(z->msg)
failf(data, "Error while processing content unencoding: %s",
z->msg);
else
failf(data, "Error while processing content unencoding: "
"Unknown failure within decompression software.");
return CURLE_BAD... | testq %rsi, %rsi
je 0x4b6c8f
movq %rsi, %rdx
leaq 0x1efdf5(%rip), %rsi # 0x6a6a7d
xorl %eax, %eax
jmp 0x4a16c7
leaq 0x1efe15(%rip), %rsi # 0x6a6aab
xorl %eax, %eax
jmp 0x4a16c7
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/content_encoding.c |
ftp_disconnect | static CURLcode ftp_disconnect(struct Curl_easy *data,
struct connectdata *conn,
bool dead_connection)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
/* We cannot send quit unconditionally. If this connection is stale or... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x4bb08d
movb $0x0, 0x4ed(%rbx)
jmp 0x4bb12f
testb $0x1, 0x4ed(%rbx)
je 0x4bb12f
leaq 0x448(%rbx), %r15
leaq 0x1ebd5a(%rip), %rdx # 0x6a6e02
leaq 0x18eafa(%rip), %rcx # 0x649ba9
movq %r14, %rdi
movq %r15, %r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
Curl_GetFTPResponse | CURLcode Curl_GetFTPResponse(struct Curl_easy *data,
ssize_t *nreadp, /* return number of bytes read */
int *ftpcode) /* return the ftp-code */
{
/*
* We cannot read just one byte per read() and then go back to select() as
* the OpenSSL read() doesn't gr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
movl 0x1e0(%rax), %ebp
movl $0x0, 0x14(%rsp)
testq %rdx, %rdx
je 0x4bb1f1
movq %rdx, %r12
movl $0x0, (%rdx)
jmp 0x4bb1f6
leaq 0x14(%rsp), %r12
movq 0x8(%rsp... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_readresp | static CURLcode ftp_readresp(struct Curl_easy *data,
curl_socket_t sockfd,
struct pingpong *pp,
int *ftpcode, /* return the ftp-code if done */
size_t *size) /* size of the response */
{
int code;
CUR... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
movq %r15, %rcx
callq 0x4c9f99
movl (%r15), %ecx
movl %ecx, 0x1358(%rbx)
testq %r14, %r14
je 0x4bb359
movl %ecx, (%r14)
cmpl $0x1a5, %ecx # imm = 0x1A5
jne 0x4bb385
leaq 0x1ebdb8(%rip), %rsi # 0x6a7120
m... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_size | static CURLcode ftp_state_size(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = data->req.p.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer == PPTRANSFER_INFO) && ftpc->file) {
/* if a "head"-like request is b... | pushq %rbx
movq %rdi, %rbx
movq 0x198(%rdi), %rax
cmpl $0x1, 0x10(%rax)
jne 0x4bd6d9
movq 0x4d8(%rsi), %rcx
testq %rcx, %rcx
je 0x4bd6d9
addq $0x448, %rsi # imm = 0x448
leaq 0x1e9c74(%rip), %rdx # 0x6a732d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c9f19
testl %eax, %eax
jne 0x4bd6d7
movq 0x18(%rbx), %rax
m... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_prepare_transfer | static CURLcode ftp_state_prepare_transfer(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = data->req.p.ftp;
struct connectdata *conn = data->conn;
if(ftp->transfer != PPTRANSFER_BODY) {
/* doesn't transfer any data */
/* still possibly do PRE QUOTE jobs */
state(data, FTP_R... | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
movq 0x198(%rdi), %rax
cmpl $0x0, 0x10(%rax)
je 0x4bd762
movl $0xd, 0x518(%rsi)
movq %rbx, %rdi
movl $0x1, %esi
movl $0xd, %edx
popq %rbx
jmp 0x4bbe89
movq 0xa92(%rbx), %rax
btl $0xa, %eax
jb 0x4bd77e
btl $0xd, %eax
jb 0x4bd786
movq %rbx, %rdi
popq %rbx
jmp 0x4bc7ce
movq... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_epsv_disable | static CURLcode ftp_epsv_disable(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
if(conn->bits.ipv6
#ifndef CURL_DISABLE_PROXY
&& !(conn->bits.tunnel_proxy || conn->bits.socksproxy)
#endif
) {
/* We can't disable EPSV when doing IPv6, so... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x100a, %eax # imm = 0x100A
andl 0x374(%rsi), %eax
cmpl $0x1000, %eax # imm = 0x1000
jne 0x4bdfc2
leaq 0x1e9868(%rip), %rsi # 0x6a7819
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a16c7
movl $0x8, %eax
jmp 0x4be01f
movq %rsi, %r14
leaq 0x1e986a(%... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_dophase_done | static CURLcode ftp_dophase_done(struct Curl_easy *data, bool connected)
{
struct connectdata *conn = data->conn;
struct FTP *ftp = data->req.p.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(connected) {
int completed;
CURLcode result = ftp_do_more(data, &completed);
if(result) {
close_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq 0x198(%rdi), %r15
testl %esi, %esi
je 0x4be083
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4bab9c
testl %eax, %eax
je 0x4be093
movl %eax, %ebp
movl 0x1e4(%rbx), %edx
cmpl $-0x1, %edx
je 0x4be073
movq %r14, %rdi
movq %rbx,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_pl_get_permission | static int ftp_pl_get_permission(const char *str)
{
int permissions = 0;
/* USER */
if(str[0] == 'r')
permissions |= 1 << 8;
else if(str[0] != '-')
permissions |= FTP_LP_MALFORMATED_PERM;
if(str[1] == 'w')
permissions |= 1 << 7;
else if(str[1] != '-')
permissions |= FTP_LP_MALFORMATED_PERM;
... | movb (%rdi), %al
xorl %ecx, %ecx
cmpb $0x2d, %al
setne %cl
shll $0x18, %ecx
cmpb $0x72, %al
movl $0x100, %eax # imm = 0x100
cmovnel %ecx, %eax
movzbl 0x1(%rdi), %ecx
cmpl $0x2d, %ecx
je 0x4bf632
cmpl $0x77, %ecx
jne 0x4bf62d
orl $0x80, %eax
jmp 0x4bf632
orl $0x1000000, %eax # imm = 0x1000000
movzbl 0x... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftplistparser.c |
Curl_hash_pick | void *
Curl_hash_pick(struct Curl_hash *h, void *key, size_t key_len)
{
struct Curl_llist_element *le;
struct Curl_llist *l;
DEBUGASSERT(h);
if(h->table) {
DEBUGASSERT(h->slots);
l = FETCH_LIST(h, key, key_len);
for(le = l->head; le; le = le->next) {
struct Curl_hash_element *he = le->ptr;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
testq %r12, %r12
je 0x4c00b0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq 0x20(%rdi), %rdx
movq %rsi, %rdi
movq %rbx, %rsi
callq *0x8(%r15)
shlq $0x5, %rax
movq (%r12,%rax), %r13
testq %r13, %r13
je 0x4c00b0
xorl %r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hash.c |
Curl_hash_destroy | void
Curl_hash_destroy(struct Curl_hash *h)
{
if(h->table) {
int i;
for(i = 0; i < h->slots; ++i) {
Curl_llist_destroy(&h->table[i], (void *) h);
}
Curl_safefree(h->table);
}
h->size = 0;
h->slots = 0;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4c0118
cmpl $0x0, 0x20(%rbx)
jle 0x4c0108
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
addq %r14, %rdi
movq %rbx, %rsi
callq 0x4c9024
incq %r15
movslq 0x20(%rbx), %rax
addq $0x20, %r14
cmpq %rax, %r15
jl 0x4c00e7
movq (%rb... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hash.c |
curl_easy_nextheader | struct curl_header *curl_easy_nextheader(CURL *easy,
unsigned int type,
int request,
struct curl_header *prev)
{
struct Curl_easy *data = easy;
struct Curl_llist_element *pick;
struct Curl_ll... | movl 0xd40(%rdi), %r8d
cmpl %edx, %r8d
jge 0x4c04a5
xorl %eax, %eax
retq
cmpl $-0x1, %edx
cmovnel %edx, %r8d
testq %rcx, %rcx
je 0x4c04c0
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x4c04a2
addq $0x10, %rax
jmp 0x4c04c7
leaq 0x1230(%rdi), %rax
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/headers.c |
Curl_headers_push | CURLcode Curl_headers_push(struct Curl_easy *data, const char *header,
unsigned char type)
{
char *value = NULL;
char *name = NULL;
char *end;
size_t hlen; /* length of the incoming header */
struct Curl_header_store *hs;
CURLcode result = CURLE_OUT_OF_MEMORY;
if((header[0] == ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movzbl (%rsi), %r13d
xorl %r14d, %r14d
cmpl $0xa, %r13d
je 0x4c07c5
cmpl $0xd, %r13d
je 0x4c07c5
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, 0x10(%rsp)
movq %rsi, %rdi
movl $0xd, %esi
callq 0x40250
testq %rax, %rax
jne 0x4c0610
movq %r15,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/headers.c |
Curl_printable_address | void Curl_printable_address(const struct Curl_addrinfo *ai, char *buf,
size_t bufsize)
{
DEBUGASSERT(bufsize);
buf[0] = 0;
switch(ai->ai_family) {
case AF_INET: {
const struct sockaddr_in *sa4 = (const void *)ai->ai_addr;
const struct in_addr *ipaddr4 = &sa4->sin_addr;
(... | movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rax
movb $0x0, (%rsi)
movl 0x4(%rdi), %edi
cmpl $0x2, %edi
je 0x4c0908
cmpl $0xa, %edi
jne 0x4c0916
movl $0x8, %esi
jmp 0x4c090d
movl $0x4, %esi
addq 0x20(%rax), %rsi
jmp 0x3f6f0
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hostip.c |
Curl_hostcache_prune | void Curl_hostcache_prune(struct Curl_easy *data)
{
time_t now;
if((data->set.dns_cache_timeout == -1) || !data->dns.hostcache)
/* cache forever means never prune, and NULL hostcache means
we can't do it */
return;
if(data->share)
Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SIN... | cmpl $-0x1, 0x6c8(%rdi)
je 0x4c09a6
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0x0, 0xa8(%rdi)
je 0x4c099f
cmpq $0x0, 0xc8(%rbx)
je 0x4c0954
movq %rbx, %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x4a674d
movq %rsp, %r14
movq %r14, %rdi
callq 0x40a80
movq 0xa8(%rbx), %rdi
movslq 0x6c8(%rbx), %rax
movq ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hostip.c |
fetch_addr | static struct Curl_dns_entry *fetch_addr(struct Curl_easy *data,
const char *hostname,
int port)
{
struct Curl_dns_entry *dns = NULL;
size_t entry_len;
char entry_id[MAX_HOSTCACHE_LEN];
/* Create an entry id, based upon the hostn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %rsi, %rdi
movl %edx, %esi
movq %r14, %rdx
callq 0x4c0d7b
movq %r14, %rdi
callq 0x3fd60
movq %rax, %r15
movq 0xa8(%rbx), %rdi
leaq 0x1(%rax), %rdx
movq %r14, %rsi
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hostip.c |
create_hostcache_id | static void
create_hostcache_id(const char *name, int port, char *ptr, size_t buflen)
{
size_t len = strlen(name);
if(len > (buflen - 7))
len = buflen - 7;
/* store and lower case the name */
while(len--)
*ptr++ = Curl_raw_tolower(*name++);
msnprintf(ptr, 7, ":%u", port);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0x3fd60
testq %rax, %rax
je 0x4c0dbf
movl $0xff, %r12d
cmpq %r12, %rax
cmovbq %rax, %r12
xorl %r13d, %r13d
movsbl (%r15,%r13), %edi
callq 0x4a7dbb
movb %al, (%r14,%r13)
incq %r13
cmpq %r13, %r12
jne 0x4c0da6
add... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hostip.c |
Curl_resolv_check | CURLcode Curl_resolv_check(struct Curl_easy *data,
struct Curl_dns_entry **dns)
{
#if defined(CURL_DISABLE_DOH) && !defined(CURLRES_ASYNCH)
(void)data;
(void)dns;
#endif
#ifndef CURL_DISABLE_DOH
if(data->conn->bits.doh)
return Curl_doh_is_resolved(data, dns);
#endif
return Curl_re... | movq 0x18(%rdi), %rax
testb $0x8, 0x377(%rax)
jne 0x4d268e
movl $0x6, %eax
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/hostip.c |
http_setup_conn | static CURLcode http_setup_conn(struct Curl_easy *data,
struct connectdata *conn)
{
/* allocate the HTTP-specific struct for the Curl_easy, only to survive
during this request */
struct HTTP *http;
DEBUGASSERT(data->req.p.http == NULL);
http = calloc(1, sizeof(struct HTTP))... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x39e9f2(%rip), %rax # 0x8606a8
movl $0x1, %edi
movl $0x2e8, %esi # imm = 0x2E8
callq *(%rax)
testq %rax, %rax
je 0x4c1d11
movq %rax, %r15
movq %rax, %rdi
addq $0x20, %rdi
movq %rbx, %rsi
callq 0x498c6f
movq %r15, 0x198(%rbx)
cmpb $0x1e... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_http | CURLcode Curl_http(struct Curl_easy *data, bool *done)
{
struct connectdata *conn = data->conn;
CURLcode result = CURLE_OK;
struct HTTP *http;
Curl_HttpReq httpreq;
const char *te = ""; /* transfer-encoding */
const char *request;
const char *httpstring;
struct dynbuf req;
char *altused = NULL;
cons... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x1fd2e6(%rip), %rax # 0x6bf049
movq %rax, 0x48(%rsp)
movb $0x1, (%rsi)
cmpb $0x5, 0x57d(%r14)
je 0x4c1de1
cmpb $0x13, 0x57f(%r14)
ja 0x4c1da7
movzbl 0x57c(%r14), %eax
cmpl $0x2, %eax
je 0x4c... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_http_done | CURLcode Curl_http_done(struct Curl_easy *data,
CURLcode status, bool premature)
{
struct connectdata *conn = data->conn;
struct HTTP *http = data->req.p.http;
/* Clear multipass flag. If authentication isn't done yet, then it will get
* a chance to be set back to true when we output t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq 0x198(%rdi), %r15
andb $-0x3, 0xdd8(%rdi)
movl %esi, %ebp
andb $-0x3, 0xdf8(%rdi)
callq 0x4b691c
movq 0x218(%r14), %rax
movq %rax, 0x3e0(%rbx)
movq 0x2b0(%r14), %rax
movq %rax, 0x3e8(%rbx)
testq %r15, %r15... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
readmoredata | static size_t readmoredata(char *buffer,
size_t size,
size_t nitems,
void *userp)
{
struct Curl_easy *data = (struct Curl_easy *)userp;
struct HTTP *http = data->req.p.http;
size_t fullsize = size * nitems;
if(!http->postsize)
... | pushq %r15
pushq %r14
pushq %rbx
movq 0x198(%rcx), %r15
cmpq $0x0, 0x8(%r15)
je 0x4c36f6
movq %rcx, %rbx
imulq %rsi, %rdx
xorl %eax, %eax
cmpl $0x1, 0x200(%r15)
sete %al
movzwl 0x1a9(%rcx), %ecx
shll $0x9, %eax
andl $0xfffffdff, %ecx # imm = 0xFFFFFDFF
orl %eax, %ecx
movw %cx, 0x1a9(%rbx)
movq 0x300(%rbx), %r14
t... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_http_firstwrite | CURLcode Curl_http_firstwrite(struct Curl_easy *data,
struct connectdata *conn,
bool *done)
{
struct SingleRequest *k = &data->req;
if(data->req.newurl) {
if(conn->bits.close) {
/* Abort after the headers if "follow Location" is set
and... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x180(%rdi)
je 0x4c52ad
testb $0x40, 0x374(%r14)
jne 0x4c5365
orb $0x8, 0x1a9(%rbx)
leaq 0x1e3337(%rip), %rsi # 0x6a85da
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a1537
movq 0x1160(%rbx), %rax
testq %rax,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_transferencode | CURLcode Curl_transferencode(struct Curl_easy *data)
{
if(!Curl_checkheaders(data, STRCONST("TE")) &&
data->set.http_transfer_encoding) {
/* When we are to insert a TE: header in the request, we must also insert
TE in a Connection: header, so we need to merge the custom provided
Connection: hea... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1e0f1a(%rip), %rsi # 0x6a62c0
movl $0x2, %edx
callq 0x4a820c
testq %rax, %rax
jne 0x4c545a
testb $0x10, 0xa94(%rbx)
je 0x4c545a
leaq 0x1e337b(%rip), %rsi # 0x6a8748
movl $0xa, %edx
movq %rbx, %rdi
callq 0x4a820c
movq %rax, %r14
leaq 0x39b2ac(%rip), %r15 #... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_http_statusline | CURLcode Curl_http_statusline(struct Curl_easy *data,
struct connectdata *conn)
{
struct SingleRequest *k = &data->req;
data->info.httpcode = k->httpcode;
data->info.httpversion = conn->httpversion;
if(!data->state.httpversion ||
data->state.httpversion > conn->httpversion)
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x140(%rdi), %eax
movl %eax, 0x1358(%rdi)
movb 0x57f(%rsi), %cl
movzbl %cl, %edx
movl %edx, 0x1360(%rdi)
movb 0x1149(%rdi), %sil
decb %sil
cmpb %dl, %sil
jb 0x4c5b60
movb %cl, 0x1149(%rbx)
cmpq $0x0, 0x1160(%rbx)
je 0x4c5b94
cmpb $0x0, 0x11e0(%rbx)
s... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_http_size | CURLcode Curl_http_size(struct Curl_easy *data)
{
struct SingleRequest *k = &data->req;
if(data->req.ignore_cl || k->chunk) {
k->size = k->maxdownload = -1;
}
else if(k->size != -1) {
if(data->set.max_filesize &&
k->size > data->set.max_filesize) {
failf(data, "Maximum file size exceeded");... | pushq %r14
pushq %rbx
pushq %rax
leaq 0xd0(%rdi), %rax
testb $0x60, 0x1a9(%rdi)
je 0x4c5c70
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, (%rax)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rax), %rsi
xorl %ebx, %ebx
cmpq $-0x1, %rsi
je 0x4c5c66
movq %rdi, %r14
movq 0x6f0(%rdi), %rax
testq %rax,... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_http_readwrite_headers | CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
struct connectdata *conn,
ssize_t *nread,
bool *stop_reading)
{
CURLcode result;
struct SingleRequest *k = &data->req;
ssize_t onread = *nread... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x48(%rsp)
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xd0(%rdi), %rax
movq %rax, 0x28(%rsp)
movq (%rdx), %rax
movq %rax, 0x40(%rsp)
movq 0x130(%rdi), %r15
leaq 0xc50(%rdi), %r13
leaq 0x140(%rdi), %rax
movq %rax, 0x1... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
checkhttpprefix | static statusline
checkhttpprefix(struct Curl_easy *data,
const char *s, size_t len)
{
struct curl_slist *head = data->set.http200aliases;
statusline rc = STATUS_BAD;
statusline onmatch = len >= 5? STATUS_DONE : STATUS_UNKNOWN;
while(head) {
if(checkprefixmax(head->data, s, len)) {
rc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
xorl %ebp, %ebp
cmpq $0x5, %rdx
setae %cl
movq 0x6e0(%rdi), %r13
movl $0x2, %r12d
testq %r13, %r13
je 0x4c67a1
movb %cl, 0x7(%rsp)
movq (%r13), %r15
movq %r15, %rdi
callq 0x3fd60
cmpq %r14, %rax
cmovaeq %r14, %r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http.c |
Curl_httpchunk_read | CHUNKcode Curl_httpchunk_read(struct Curl_easy *data,
char *datap,
ssize_t datalen,
ssize_t *wrote,
CURLcode *extrap)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbp
movq 0x18(%rdi), %r15
movq %rcx, 0x28(%rsp)
movq $0x0, (%rcx)
testb $0x4, 0xa96(%rdi)
je 0x4c6857
testb $0x8, 0x1a9(%rbp)
jne 0x4c6857
movq %rbp, %rdi
movl $0x1, %esi
movq %r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http_chunks.c |
Curl_chunked_strerror | const char *Curl_chunked_strerror(CHUNKcode code)
{
switch(code) {
default:
return "OK";
case CHUNKE_TOO_LONG_HEX:
return "Too long hexadecimal number";
case CHUNKE_ILLEGAL_HEX:
return "Illegal or missing hexadecimal sequence";
case CHUNKE_BAD_CHUNK:
return "Malformed encoding found";
case C... | decl %edi
cmpl $0x5, %edi
ja 0x4c6bca
movl %edi, %eax
leaq 0x1e210e(%rip), %rcx # 0x6a8cd0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x1ddb8f(%rip), %rax # 0x6a4760
retq
nop
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http_chunks.c |
Curl_input_ntlm | CURLcode Curl_input_ntlm(struct Curl_easy *data,
bool proxy, /* if proxy or not */
const char *header) /* rest of the www-authenticate:
header */
{
/* point to the correct struct with this */
struct ntlmdata *n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbp
movl %esi, %ebx
movq %rdi, 0x8(%rsp)
movq 0x18(%rdi), %r14
leaq 0x3f8(%r14), %r12
leaq 0x410(%r14), %r15
testl %esi, %esi
movq %r12, %r13
cmovneq %r15, %r13
leaq 0x1e15db(%rip), %rsi # 0x6a81e9
movl $0x4, %edx
movq %rb... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http_ntlm.c |
Curl_proxy_connect | CURLcode Curl_proxy_connect(struct Curl_easy *data, int sockindex)
{
struct connectdata *conn = data->conn;
if(conn->http_proxy.proxytype == CURLPROXY_HTTPS) {
const CURLcode result = https_proxy_connect(data, sockindex);
if(result)
return result;
if(!conn->bits.proxy_ssl_connected[sockindex])
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
cmpb $0x2, 0x140(%r14)
jne 0x4c7099
movslq %ebp, %rcx
cmpb $0x0, 0x372(%r14,%rcx)
je 0x4c70c4
movl 0x374(%r14), %eax
movl %eax, %ecx
notl %ecx
xorl %r15d, %r15d
testb $0x9, %cl
jne 0x4c716a
btl $0x9, %eax
jb 0x4... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http_proxy.c |
Curl_proxyCONNECT | CURLcode Curl_proxyCONNECT(struct Curl_easy *data,
int sockindex,
const char *hostname,
int remote_port)
{
CURLcode result;
struct connectdata *conn = data->conn;
if(!conn->connect_state) {
result = connect_init(data, FALSE);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, 0x4c(%rsp)
movl %esi, %r12d
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x540(%r14), %rbp
testq %rbp, %rbp
movq %rdx, 0x78(%rsp)
je 0x4c71f6
movl $0x0, 0x54(%rsp)
movl %r12d, 0x14(%rsp)
movslq %r12d, %rax
leaq (%r14,%rax,4), %r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http_proxy.c |
Curl_output_aws_sigv4 | CURLcode Curl_output_aws_sigv4(struct Curl_easy *data, bool proxy)
{
CURLcode ret = CURLE_OUT_OF_MEMORY;
struct connectdata *conn = data->conn;
size_t len;
const char *arg;
char provider0[MAX_SIGV4_LEN + 1]="";
char provider1[MAX_SIGV4_LEN + 1]="";
char region[MAX_SIGV4_LEN + 1]="";
char service[MAX_SIG... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movq %rdi, %rbx
movq 0x18(%rdi), %r12
xorl %ebp, %ebp
movb %bpl, 0x190(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x180(%rsp)
movaps %xmm0, 0x170(%rsp)
movaps %xmm0, 0x160(%rsp)
movaps %xmm0, 0x150(%rsp)
movb %bpl, ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/http_aws_sigv4.c |
Curl_ipv6_scope | unsigned int Curl_ipv6_scope(const struct sockaddr *sa)
{
if(sa->sa_family == AF_INET6) {
const struct sockaddr_in6 * sa6 = (const struct sockaddr_in6 *)(void *) sa;
const unsigned char *b = sa6->sin6_addr.s6_addr;
unsigned short w = (unsigned short) ((b[0] << 8) | b[1]);
if((b[0] & 0xFE) == 0xFC) /*... | xorl %eax, %eax
cmpw $0xa, (%rdi)
jne 0x4c8db4
movzbl 0x8(%rdi), %edx
movl %edx, %esi
andl $-0x2, %esi
movl $0x3, %ecx
cmpl $0xfc, %esi
jne 0x4c8db5
movl %ecx, %eax
retq
movzbl 0x9(%rdi), %ecx
shll $0x8, %edx
movl %ecx, %esi
andl $-0x40, %esi
orl %edx, %esi
je 0x4c8de3
cmpl $0xfe80, %esi # imm = 0xFE80
je 0x4... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/if2ip.c |
session_predicate_push_response_headers_send | static int
session_predicate_push_response_headers_send(nghttp2_session *session,
nghttp2_stream *stream) {
int rv;
/* TODO Should disallow HEADERS if GOAWAY has already been issued? */
rv = session_predicate_for_stream_send(session, stream);
if (rv != 0) {
retur... | testq %rsi, %rsi
je 0x4ddcb5
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4d7035
movl %eax, %ecx
movl $0xfffffdee, %eax # imm = 0xFFFFFDEE
testl %ecx, %ecx
jne 0x4ddcad
movl $0xfffffe00, %eax # imm = 0xFFFFFE00
testb $0x2, 0xd9(%r14)
jne 0x4ddcad
movl $0xfffffe07, %eax # im... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
lz4_reader_init | static int
lz4_reader_init(struct archive_read_filter *self)
{
int r;
r = __archive_read_program(self, "lz4 -d -q");
/* Note: We set the format here even if __archive_read_program()
* above fails. We do, after all, know what the format is
* even if we weren't able to read it. */
self->code = ARCHIVE_FILTER_LZ... | pushq %rbx
movq %rdi, %rbx
leaq 0x1a36f8(%rip), %rsi # 0x6ba656
callq 0x51711d
movl $0xd, 0x38(%rbx)
leaq 0x1a36c6(%rip), %rcx # 0x6ba637
movq %rcx, 0x30(%rbx)
popq %rbx
retq
nop
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_lz4.c |
lzop_bidder_bid | static int
lzop_bidder_bid(struct archive_read_filter_bidder *self,
struct archive_read_filter *filter)
{
const unsigned char *p;
ssize_t avail;
(void)self; /* UNUSED */
p = __archive_read_filter_ahead(filter, LZOP_HEADER_MAGIC_LEN, &avail);
if (p == NULL || avail == 0)
return (0);
if (memcmp(p, LZOP_HEA... | pushq %rax
movq %rsi, %rdi
movq %rsp, %rdx
movl $0x9, %esi
callq 0x511b04
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x516ff8
cmpq $0x0, (%rsp)
je 0x516ff8
movabsq $0x1a0a0d004f5a4c89, %rax # imm = 0x1A0A0D004F5A4C89
xorq (%rcx), %rax
movzbl 0x8(%rcx), %ecx
xorq $0xa, %rcx
xorl %edx, %edx
orq %rax, %rcx
movl $... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_lzop.c |
child_stop | static int
child_stop(struct archive_read_filter *self, struct program_filter *state)
{
/* Close our side of the I/O with the child. */
if (state->child_stdin != -1) {
close(state->child_stdin);
state->child_stdin = -1;
}
if (state->child_stdout != -1) {
close(state->child_stdout);
state->child_stdout = -1;... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x24(%rsi), %edi
cmpl $-0x1, %edi
je 0x51755e
callq 0x3f770
movl $0xffffffff, 0x24(%r14) # imm = 0xFFFFFFFF
movl 0x28(%r14), %edi
cmpl $-0x1, %edi
je 0x517574
callq 0x3f770
movl $0xffffffff, 0x28(%r14) # imm = 0xFFFFFFFF
cmpl $0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_program.c |
uudecode_bidder_init | static int
uudecode_bidder_init(struct archive_read_filter *self)
{
struct uudecode *uudecode;
void *out_buff;
void *in_buff;
self->code = ARCHIVE_FILTER_UU;
self->name = "uu";
uudecode = (struct uudecode *)calloc(sizeof(*uudecode), 1);
out_buff = malloc(OUT_BUFF_SIZE);
in_buff = malloc(IN_BUFF_SIZE);
if (... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x7, 0x38(%rdi)
leaq 0x1a2a4e(%rip), %rax # 0x6ba7b5
movq %rax, 0x30(%rdi)
movl $0x30, %edi
movl $0x1, %esi
callq 0x41eb8
movq %rax, %rbx
movl $0x10000, %edi # imm = 0x10000
callq 0x41ec0
movq %rax, %r15
movl $0x400, %edi ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_uu.c |
get_line | static ssize_t
get_line(const unsigned char *b, ssize_t avail, ssize_t *nlsize)
{
ssize_t len;
len = 0;
while (len < avail) {
switch (ascii[*b]) {
case 0: /* Non-ascii character or control character. */
if (nlsize != NULL)
*nlsize = 0;
return (-1);
case '\r':
if (avail-len > 1 && b[1] == '\n') {
... | movq %rsi, %rax
testq %rsi, %rsi
jle 0x517fac
xorl %ecx, %ecx
leaq 0x1a28d2(%rip), %rsi # 0x6ba840
movzbl (%rdi), %r8d
movzbl (%r8,%rsi), %r8d
cmpl $0x9, %r8d
jg 0x517f8b
cmpl $0x1, %r8d
jne 0x517f99
incq %rdi
incq %rcx
jmp 0x517f9e
cmpl $0xa, %r8d
je 0x517fda
cmpl $0xd, %r8d
jne 0x517f9e
jmp 0x517fb9
testl %r8d, %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_uu.c |
uudecode_filter_close | static int
uudecode_filter_close(struct archive_read_filter *self)
{
struct uudecode *uudecode;
uudecode = (struct uudecode *)self->data;
free(uudecode->in_buff);
free(uudecode->out_buff);
free(uudecode);
return (ARCHIVE_OK);
} | pushq %rbx
movq 0x28(%rdi), %rbx
movq 0x8(%rbx), %rdi
callq 0x41e70
movq 0x20(%rbx), %rdi
callq 0x41e70
movq %rbx, %rdi
callq 0x41e70
xorl %eax, %eax
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_uu.c |
archive_read_support_filter_xz | int
archive_read_support_filter_xz(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
if (__archive_read_register_bidder(a, NULL, "xz",
&xz_bidder_vtable) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
#if HAVE_LZMA_H && HAVE_LIBLZMA
return (ARCHIVE_OK);
#else
archive_set_error(_a, ARCHIVE_ER... | pushq %rax
leaq 0x1ad9af(%rip), %rdx # 0x6c6259
leaq 0x343007(%rip), %rcx # 0x85b8b8
xorl %esi, %esi
callq 0x511a51
testl %eax, %eax
movl $0xffffffe2, %ecx # imm = 0xFFFFFFE2
cmovnel %ecx, %eax
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_xz.c |
xz_filter_close | static int
xz_filter_close(struct archive_read_filter *self)
{
struct private_data *state;
state = (struct private_data *)self->data;
lzma_end(&(state->stream));
free(state->out_block);
free(state);
return (ARCHIVE_OK);
} | pushq %rbx
movq 0x28(%rdi), %rbx
movq %rbx, %rdi
callq 0x57912d
movq 0x88(%rbx), %rdi
callq 0x41e70
movq %rbx, %rdi
callq 0x41e70
xorl %eax, %eax
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_xz.c |
zstd_bidder_bid | static int
zstd_bidder_bid(struct archive_read_filter_bidder *self,
struct archive_read_filter *filter)
{
const unsigned char *buffer;
ssize_t avail;
unsigned prefix;
/* Zstd frame magic values */
const unsigned zstd_magic = 0xFD2FB528U;
const unsigned zstd_magic_skippable_start = 0x184D2A50U;
const unsigne... | pushq %rax
movq %rsi, %rdi
movq %rsp, %rdx
movl $0x4, %esi
callq 0x511b04
testq %rax, %rax
je 0x5190fa
movl (%rax), %ecx
movl $0x20, %eax
cmpl $0xfd2fb528, %ecx # imm = 0xFD2FB528
je 0x5190fc
andl $-0x10, %ecx
xorl %eax, %eax
cmpl $0x184d2a50, %ecx # imm = 0x184D2A50
sete %al
shll $0x5, %eax
jmp 0x5190fc
xo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_zstd.c |
archive_read_support_format_cab | int
archive_read_support_format_cab(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
struct cab *cab;
int r;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_cab");
cab = (struct cab *)calloc(1, sizeof(*cab));
if (cab == NULL) {
archive_... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x1a157a(%rip), %rcx # 0x6bb320
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x519e6c
movl $0x1, %edi
movl $0x1c0, %esi # imm = 0x1C0
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cab.c |
cab_minimum_consume_cfdata | static int64_t
cab_minimum_consume_cfdata(struct archive_read *a, int64_t consumed_bytes)
{
struct cab *cab = (struct cab *)(a->format->data);
struct cfdata *cfdata;
int64_t cbytes, rbytes;
int err;
cfdata = cab->entry_cfdata;
rbytes = consumed_bytes;
if (cab->entry_cffolder->comptype == COMPTYPE_NONE) {
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x818(%rdi), %rax
movq (%rax), %r13
movq 0x28(%r13), %rax
movq 0x38(%r13), %rbp
cmpw $0x0, 0x6(%rax)
je 0x51b449
movzwl 0xc(%rbp), %eax
movzwl 0xe(%rbp), %ecx
subq %rcx, %rax
jle 0x51b432
cmpq %rbx, %rax
cm... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cab.c |
archive_read_format_lha_bid | static int
archive_read_format_lha_bid(struct archive_read *a, int best_bid)
{
const char *p;
const void *buff;
ssize_t bytes_avail, offset, window;
size_t next;
/* If there's already a better bid than we can ever
make, don't bother testing. */
if (best_bid > 30)
return (-1);
if ((p = __archive_read_ahea... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x1e, %esi
jg 0x522832
movq %rdi, %rbx
movl $0x16, %esi
xorl %edx, %edx
callq 0x511af8
testq %rax, %rax
je 0x522832
movq %rax, %r14
movq %rax, %rdi
callq 0x524a6b
testq %rax, %rax
je 0x5228... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
archive_read_format_lha_options | static int
archive_read_format_lha_options(struct archive_read *a,
const char *key, const char *val)
{
struct lha *lha;
int ret = ARCHIVE_FAILED;
lha = (struct lha *)(a->format->data);
if (strcmp(key, "hdrcharset") == 0) {
if (val == NULL || val[0] == 0)
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq 0x818(%rdi), %rcx
movq (%rcx), %r15
leaq 0x198af4(%rip), %rsi # 0x6bb358
movq %rax, %rdi
callq 0x40ea0
movl %eax, %ecx
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
testl %ecx, %ecx
jne 0x5228c0
testq %r14, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_check_header_format | static size_t
lha_check_header_format(const void *h)
{
const unsigned char *p = h;
size_t next_skip_bytes;
switch (p[H_METHOD_OFFSET+3]) {
/*
* "-lh0-" ... "-lh7-" "-lhd-"
* "-lzs-" "-lz5-"
*/
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
case 'd':
case 's':
next_skip_... | movzbl 0x5(%rdi), %ecx
cmpl $0x63, %ecx
jg 0x524abf
leal -0x30(%rcx), %eax
cmpl $0x8, %eax
jae 0x524ae5
movl $0x4, %eax
cmpb $0x0, (%rdi)
je 0x524ae4
cmpb $0x2d, 0x2(%rdi)
jne 0x524ae4
cmpb $0x6c, 0x3(%rdi)
jne 0x524ae4
cmpb $0x2d, 0x6(%rdi)
jne 0x524ae4
movzbl 0x4(%rdi), %edx
cmpl $0x7a, %edx
je 0x524afc
cmpl $0x68, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_parse_linkname | static int
lha_parse_linkname(struct archive_wstring *linkname,
struct archive_wstring *pathname)
{
wchar_t * linkptr;
size_t symlen;
linkptr = wcschr(pathname->s, L'|');
if (linkptr != NULL) {
symlen = wcslen(linkptr + 1);
archive_wstrncpy(linkname, linkptr+1, symlen);
*linkptr = 0;
pathname->length... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movl $0x7c, %esi
callq 0x40fc0
testq %rax, %rax
je 0x524b7f
movq %rax, %r15
movq %rax, %r12
addq $0x4, %r12
movq %r12, %rdi
callq 0x40820
movq $0x0, 0x8(%r14)
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_huffman_init | static int
lzh_huffman_init(struct huffman *hf, size_t len_size, int tbl_bits)
{
int bits;
if (hf->bitlen == NULL) {
hf->bitlen = malloc(len_size * sizeof(hf->bitlen[0]));
if (hf->bitlen == NULL)
return (ARCHIVE_FATAL);
}
if (hf->tbl == NULL) {
if (tbl_bits < HTBL_BITS)
bits = tbl_bits;
else
bits ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x525673
movq %r14, %rdi
callq 0x41ec0
movq %rax, 0x50(%rbx)
testq %rax, %rax
je 0x5256bc
cmpq $0x0, 0x70(%rbx)
jne 0x52568d
movl $0x800, %edi # imm = 0x800
callq 0x41ec0
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x525... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_read_pt_bitlen | static int
lzh_read_pt_bitlen(struct lzh_stream *strm, int start, int end)
{
struct lzh_dec *ds = strm->ds;
struct lzh_br *br = &(ds->br);
int c, i;
for (i = start; i < end; ) {
/*
* bit pattern the number we need
* 000 -> 0
* 001 -> 1
* 010 -> 2
*... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpl %edx, %esi
jge 0x525920
movl %edx, %ebp
movq %rdi, %r14
movq 0x30(%rdi), %r12
leaq 0x28(%r12), %r15
movslq %ebx, %rbx
movl $0x3ff, %r13d # imm = 0x3FF
movl 0x30(%r12), %eax
cmpl $0x2, %eax
jg 0x525896
movq %r14, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
read_header | static int
read_header(struct archive_read *a, struct archive_entry *entry)
{
struct mtree *mtree;
char *p;
int r, use_next;
mtree = (struct mtree *)(a->format->data);
if (mtree->fd >= 0) {
close(mtree->fd);
mtree->fd = -1;
}
if (mtree->entries == NULL) {
mtree->resolver = archive_entry_linkresolver_new... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x818(%rdi), %rax
movq (%rax), %rbx
movl 0x30(%rbx), %edi
testl %edi, %edi
js 0x525e55
callq 0x3f770
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
cmpq $0x0, 0x40(%rbx)
movq %r14, (%rsp)
je 0x52622e... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
archive_read_format_rar_read_data | static int
archive_read_format_rar_read_data(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct rar *rar = (struct rar *)(a->format->data);
int ret;
if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
rar->has_encrypte... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
movq 0x818(%rdi), %rax
movq (%rax), %rbp
cmpl $-0x1, 0x4f50(%rbp)
jne 0x528bc6
movl $0x0, 0x4f50(%rbp)
movq 0xa0(%rbp), %rsi
testq %rsi, %rsi
jle 0x528be5
movq %r13, %rdi
ca... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
archive_read_format_rar_read_data_skip | static int
archive_read_format_rar_read_data_skip(struct archive_read *a)
{
struct rar *rar;
int64_t bytes_skipped;
int ret;
rar = (struct rar *)(a->format->data);
if (rar->bytes_unconsumed > 0) {
/* Consume as much as the decompressor actually used. */
__archive_read_consume(a, rar->bytes_uncon... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x818(%rbx), %rax
movq (%rax), %r14
movq 0xa0(%r14), %rsi
testq %rsi, %rsi
jle 0x529729
movq %rbx, %rdi
callq 0x511e26
movq $0x0, 0xa0(%r14)
movq 0xa8(%r14), %rsi
testq %rsi, %rsi
jle 0x529742
movq %rbx, %rdi
callq 0x511e26
testq %rax, %rax
js 0x52977a
xorl %eax, %e... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
archive_read_format_rar_seek_data | static int64_t
archive_read_format_rar_seek_data(struct archive_read *a, int64_t offset,
int whence)
{
int64_t client_offset, ret;
unsigned int i;
struct rar *rar = (struct rar *)(a->format->data);
if (rar->compression_method == COMPRESS_METHOD_STORE)
{
/* Modify the offset for use with SEEK_SET */
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r15
cmpb $0x30, 0x17(%r15)
jne 0x5297b1
cmpl $0x1, %edx
je 0x5297d3
cmpl $0x2, %edx
jne 0x5297de
movl $0x28, %eax
jmp 0x5297d8
leaq 0x193b65(%rip), %rdx # 0x6bd31d
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xor... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.