int query_windows(){ string arch = lower_case(architecture()); #ifdef __WIN32__ return 1; #else if(grepp(arch,"windows") || grepp(arch,"cygwin")) return 1; #endif return 0; }
bool Abi::isCompatibleWith(const Abi &other) const { bool isCompat = (architecture() == other.architecture() || other.architecture() == Abi::UnknownArchitecture) && (os() == other.os() || other.os() == Abi::UnknownOS) && (osFlavor() == other.osFlavor() || other.osFlavor() == Abi::UnknownFlavor) && (binaryFormat() == other.binaryFormat() || other.binaryFormat() == Abi::UnknownFormat) && ((wordWidth() == other.wordWidth() && wordWidth() != 0) || other.wordWidth() == 0); // *-linux-generic-* is compatible with *-linux-* (both ways): This is for the benefit of // people building Qt themselves using e.g. a meego toolchain. // // We leave it to the specific targets to catch filter out the tool chains that do not // work for them. if (!isCompat && (architecture() == other.architecture() || other.architecture() == Abi::UnknownArchitecture) && ((os() == other.os()) && (os() == LinuxOS)) && (osFlavor() == GenericLinuxFlavor || other.osFlavor() == GenericLinuxFlavor) && (binaryFormat() == other.binaryFormat() || other.binaryFormat() == Abi::UnknownFormat) && ((wordWidth() == other.wordWidth() && wordWidth() != 0) || other.wordWidth() == 0)) isCompat = true; return isCompat; }
string query_os_type(){ string config_file, s1, s2, s3; if(function_exists("architecture",load_object("/secure/sefun/sefun"))){ string arch = lower_case(architecture()); if(grepp(arch,"windows") || grepp(arch,"cygwin")) return "windows"; else return "unix"; } if(!file_exists("/secure/cfg/mudos.cfg")) return "unknown"; config_file = read_matching_line("/secure/cfg/mudos.cfg","mudlib directory :"); if(!config_file) return ""; if(sscanf(config_file,"%s:%s:%s",s1,s2,s3) == 3){ return "windows"; } else return "unix"; }
bool DebFile::check() { // check arch if (architecture().empty()) { m_errorMsg = "No Architecture field in the package"; return false; } std::cout << architecture() << std::endl; if (architecture().compare("all") != 0 && architecture().compare(_config->Find("APT::Architecture")) != 0) { m_errorMsg = "Wrong architecture "; m_errorMsg.append(architecture()); return false; } // if not "Architecture" in self._sections: // self._dbg(1, "ERROR: no architecture field") // self._failure_string = _("No Architecture field in the package") // return False // arch = self._sections["Architecture"] // if arch != "all" and arch != apt_pkg.config.find("APT::Architecture"): // self._dbg(1, "ERROR: Wrong architecture dude!") // self._failure_string = _("Wrong architecture '%s'") % arch // return False // // // check version // if self.compare_to_version_in_cache() == self.VERSION_OUTDATED: // if self._cache[self.pkgname].installed: // // the deb is older than the installed // self._failure_string = _("A later version is already installed") // return False // // // FIXME: this sort of error handling sux // self._failure_string = "" // // // check conflicts // if not self.check_conflicts(): // return False // // // check if installing it would break anything on the // // current system // if not self.check_breaks_existing_packages(): // return False // // // try to satisfy the dependencies // if not self._satisfy_depends(self.depends): // return False // // // check for conflicts again (this time with the packages that are // // makeed for install) // if not self.check_conflicts(): // return False // // if self._cache._depcache.broken_count > 0: // self._failure_string = _("Failed to satisfy all dependencies " // "(broken cache)") // // clean the cache again // self._cache.clear() // return False return true; }
Value *DataflowAnalyzer::computeValue(const Term *term, const MemoryLocation &memoryLocation, const ReachingDefinitions &definitions) { assert(term); assert(term->isRead()); assert(memoryLocation || definitions.empty()); auto value = dataflow().getValue(term); if (definitions.empty()) { return value; } auto byteOrder = architecture()->getByteOrder(memoryLocation.domain()); /* * Merge abstract values. */ auto abstractValue = value->abstractValue(); foreach (const auto &chunk, definitions.chunks()) { assert(memoryLocation.covers(chunk.location())); /* * Mask of bits inside abstractValue which are covered by chunk's location. */ auto mask = bitMask<ConstantValue>(chunk.location().size()); if (byteOrder == ByteOrder::LittleEndian) { mask = bitShift(mask, chunk.location().addr() - memoryLocation.addr()); } else { mask = bitShift(mask, memoryLocation.endAddr() - chunk.location().endAddr()); } foreach (auto definition, chunk.definitions()) { auto definitionLocation = dataflow().getMemoryLocation(definition); assert(definitionLocation.covers(chunk.location())); auto definitionValue = dataflow().getValue(definition); auto definitionAbstractValue = definitionValue->abstractValue(); /* * Shift definition's abstract value to match term's location. */ if (byteOrder == ByteOrder::LittleEndian) { definitionAbstractValue.shift(definitionLocation.addr() - memoryLocation.addr()); } else { definitionAbstractValue.shift(memoryLocation.endAddr() - definitionLocation.endAddr()); } /* Project the value to the defined location. */ definitionAbstractValue.project(mask); /* Update term's value. */ abstractValue.merge(definitionAbstractValue); } } value->setAbstractValue(abstractValue.resize(term->size())); /* * Merge stack offset and product flags. * * Heuristic: merge information only from terms that define lower bits of the term's value. */ const std::vector<const Term *> *lowerBitsDefinitions = nullptr; if (byteOrder == ByteOrder::LittleEndian) { if (definitions.chunks().front().location().addr() == memoryLocation.addr()) { lowerBitsDefinitions = &definitions.chunks().front().definitions(); } } else { if (definitions.chunks().back().location().endAddr() == memoryLocation.endAddr()) { lowerBitsDefinitions = &definitions.chunks().back().definitions(); } } if (lowerBitsDefinitions) { foreach (auto definition, *lowerBitsDefinitions) { auto definitionValue = dataflow().getValue(definition); if (definitionValue->isNotStackOffset()) { value->makeNotStackOffset(); } else if (definitionValue->isStackOffset()) { value->makeStackOffset(definitionValue->stackOffset()); } if (definitionValue->isNotProduct()) { value->makeNotProduct(); } else if (definitionValue->isProduct()) { value->makeProduct(); } } } /* * Merge return address flag. */ if (definitions.chunks().front().location() == memoryLocation) { foreach (auto definition, definitions.chunks().front().definitions()) { auto definitionValue = dataflow().getValue(definition); if (definitionValue->isNotReturnAddress()) { value->makeNotReturnAddress(); } else if (definitionValue->isReturnAddress()) { value->makeReturnAddress(); } } }
bool DataflowAnalyzer::isTracked(const MemoryLocation &memoryLocation) const { return memoryLocation && !architecture()->isGlobalMemory(memoryLocation); }
int main(int argc, char *argv[]) { static const advgetopt::getopt::option options[] = { { '\0', 0, NULL, NULL, "Usage: dep2graph [-<opt>] <package> ...", advgetopt::getopt::help_argument }, { '\0', 0, "admindir", "var/lib/wpkg", "define the administration directory (i.e. wpkg database folder), default is /var/lib/wpkg", advgetopt::getopt::required_argument }, { '\0', 0, "instdir", "", "specify the installation directory, where files get unpacked, by default the root is used", advgetopt::getopt::required_argument }, { '\0', 0, "root", "/", "define the root directory (i.e. where everything is installed), default is /", advgetopt::getopt::required_argument }, { 'o', 0, "output", NULL, "define a filename where the final PNG is saved", advgetopt::getopt::required_argument }, { 'f', 0, "filename", NULL, NULL, // hidden argument in --help screen advgetopt::getopt::default_multiple_argument }, { 'h', 0, "help", NULL, "print this help message", advgetopt::getopt::no_argument }, { '\0', 0, "help-nobr", NULL, NULL, advgetopt::getopt::no_argument }, { '\0', 0, "version", NULL, "show the version of deb2graph", advgetopt::getopt::no_argument }, { 'v', 0, "verbose", NULL, "print additional information as available", advgetopt::getopt::no_argument }, { '\0', 0, "license", NULL, "displays the license of this tool", advgetopt::getopt::no_argument }, { '\0', 0, "licence", // French spelling NULL, NULL, // hidden argument in --help screen advgetopt::getopt::no_argument }, { '\0', 0, NULL, NULL, NULL, advgetopt::getopt::end_of_options } }; std::vector<std::string> configuration_files; advgetopt::getopt opt(argc, argv, options, configuration_files, ""); if(opt.is_defined("help") || opt.is_defined("help-nobr")) { opt.usage(opt.is_defined("help-nobr") ? advgetopt::getopt::no_error_nobr : advgetopt::getopt::no_error, "Usage: deb2graph [-<opt>] <package> ..."); /*NOTREACHED*/ } if(opt.is_defined("version")) { printf("%s\n", debian_packages_version_string()); exit(1); } if(opt.is_defined("license") || opt.is_defined("licence")) { license::license(); exit(1); } bool verbose(opt.is_defined("verbose")); // get the size, if zero it's undefined int max(opt.size("filename")); if(max == 0) { opt.usage(advgetopt::getopt::error, "at least one debian package must be specified on the command line"); /*NOTREACHED*/ } // all these directories have a default if not specified on the command line manager.set_root_path(opt.get_string("root")); manager.set_inst_path(opt.get_string("instdir")); manager.set_database_path(opt.get_string("admindir")); manager.set_control_file_state(std::shared_ptr<wpkg_control::control_file::control_file_state_t>(new wpkg_control::control_file::contents_control_file_state_t)); // start creating the .dot file dot.create(memfile::memory_file::file_format_other); dot.printf("digraph {\nrankdir=BT;\nlabel=\"Debian Package Dependency Graph\";\n"); node_names_t nodes; node_names_t deps; // dependencies not found on the command line // load all the packages dot.printf("/* Explicit Packages */\n"); for(int i = 0; i < max; ++i) { std::string package_filename(opt.get_string("filename", i)); // avoid adding the exact same package more than once if(verbose) { printf("Package \"%s\" loaded.\n", package_filename.c_str()); } manager.load_package(package_filename); std::string package(manager.get_field(package_filename, "Package")); package_info_t info; info.f_package = package; info.f_filename = package_filename; info.f_nodecount = node_count; nodes.push_back(info); std::string version(manager.get_field(package_filename, "Version")); std::string architecture(manager.get_field(package_filename, "Architecture")); dot.printf("n%d [label=\"%s %s\\n%s\",shape=box];\n", node_count, package.c_str(), version.c_str(), architecture.c_str()); ++node_count; } // edges font size to small dot.printf("edge [fontsize=8,fontcolor=\"#990033\",color=\"#cccccc\"];\n"); // use the dependency fields to define all the nodes of the graph dot.printf("edge [style=dashed];\n"); add_nodes(nodes, deps, "Build-Depends"); dot.printf("edge [style=bold,color=\"#8888ff\"];\n"); add_nodes(nodes, deps, "Pre-Depends"); dot.printf("edge [style=solid,color=\"#aaaaaa\"];\n"); add_nodes(nodes, deps, "Depends"); dot.printf("edge [color=\"#ff8888\"];\n"); add_nodes(nodes, deps, "Breaks"); dot.printf("edge [style=bold,arrowhead=tee];\n"); add_nodes(nodes, deps, "Conflicts"); // close the digraph dot.printf("}\n"); dot.write_file("deb2graph.dot"); std::string cmd("dot -Tsvg deb2graph.dot >"); if(opt.is_defined("output")) { cmd += opt.get_string("output"); } else { cmd += "deb2graph.svg"; } const int status = system(cmd.c_str()); if( status == -1 ) { // TODO: Add a message here stating the command could not be launched... return 1; } return status; }