Free inspect software for linux

Inspect Context is an extension which provides an open Dom Inspector at this node from Inspect on context menu.

Open Dom Inspector at this node from Inspect on context menu. Dom Inspector must already be installed.

Handy for checking both page for web developers and chrome for extension developers.

Linux From Scratch (LFS) is a project that provides you with the steps necessary to build your own custom Linux system.
There are a lot of reasons why somebody would want to install an LFS system. The question most people raise is "why go through all the hassle of manually installing a Linux system from scratch when you can just download an existing distribution?". That is a valid question which I hope to answer for you.
The most important reason for LFSs existence is teaching people how a Linux system works internally. Building an LFS system teaches you about all that makes Linux tick, how things work together, and depend on each other. And most importantly, how to customize it to your own taste and needs.
One of the key benefits of LFS is that you are in control over your system without having to rely on somebody elses Linux implementation. You are in the drivers seat now and are able to dictate every single thing such as the directory layout and boot script setup. You will also know exactly where, why and how programs are installed.
Another benefit of LFS is that you can create a very compact Linux system. When you install a regular distribution, you end up installing a lot of programs you probably would never use. Theyre just sitting there taking up (precious) disk space. Its not hard to get an LFS system installed under 100 MB. Does that still sound like a lot? A few of us have been working on creating a very small embedded LFS system. We installed a system that was just enough to run the Apache web server; total disk space usage was aproximately 8 MB. With further stripping, that can be brought down to 5 MB or less. Try that with a regular distribution.
If we were to compare a Linux distribution with a hamburger you buy at a supermarket or fast-food restaurant, you would end up eating it without knowing precisely what it is you are eating, whereas LFS gives you the ingredients to make a hamburger. This allows you to carefully inspect it, remove unwanted ingredients, and at the same time allow you to add ingredients to enhance the flavour of your hamburger. When you are satisfied with the ingredients, you go on to the next part of putting it together. You now have the chance to make it just the way you like it: broil it, bake it, deep-fry it, barbeque it, or eat it raw.
Another analogy that we can use is that of comparing LFS with a finished house. LFS will give you the skeleton of a house, but its up to you to install plumbing, electrical outlets, kitchen, bathtub, wallpaper, etc.
Another advantage of a custom built Linux system is added security. You will compile the entire system from source, thus allowing you to audit everything, if you wish to do so, and apply all the security patches you want or need to apply. You dont have to wait for somebody else to provide a new binary package that fixes a security hole. Besides, you have no guarantee that the new package actually fixes the problem (adequately). You never truly know whether a security hole is fixed or not unless you do it yourself.
Enhancements:
- The LFS LiveCD Team is proud to announce the release of the x86-6.2-3 version of LFS LiveCD. This version is built using LFS 6.2 and many Beyond Linux From Scratch packages from the Subversion branch. Source packages for LFS 6.2, and the LFS book itself, are included on the live CD. The CD is also suitable as a host for building x86 and x86_64 Cross LFS systems. Other features and bugfixes: the CD supports hibernation; the CD file system can be written to; the CD contains a visually pleasing and easy-to-use window manager, XFce...

pciutils is a set of programs for listing PCI devices, inspecting their status and setting their configuration registers.
Currently, pciutils work on all versions of Linux and they also have somewhat experimental support for FreeBSD, NetBSD, AIX, GNU Hurd and Solaris/x86. It should be very easy to add support for other systems as well (volunteers wanted; if you want to try that, Ill be very glad to see the patches and include them in the next version).
Enhancements:
- pci.ids: Updated copyright header.
- lib/sysfs.c (sysfs_get_resources): Removed warning about unsupported 64-bit addresses, they are now always supported.
- lspci.c (show_bases): Corrected printing of 64-bit addresses in bus-centric mode.
- lib/configure: Enable 64-bit addresses on all Linux systems.
- lib/types.h: Dont pad 64-bit addresses to 16 xigits, only to 8 if they are shorter.

Streamline is a high-speed networking subsystem for commodity operating systems. It increases performance by moving processing tasks to the fastest location. Streamline supports in-kernel execution, but also dedicated hardware (NICs) and even remote machines. An implementation of Streamline for Linux 2.6.13 and higher is made publicly available.
The goal of Streamline is to make fast network processing viable for common tasks. Many advanced processing schemes so far fail to make it into OSes, because they are difficult to combine with the socket(..) API or only applicable in a few situations. Our goal is to integrate known as well as develop new methods that replace sockets(..). without burdening application developers and end-users. Streamline achieves this by constructing a tailored dataplane for each application at runtime from an extensible set of functions.
Applications request information streams by specifying a series of abstract functions that need to be performed on incoming data (e.g., select tcp packets for port 80, reassemble into a stream, filter out known attacks). At runtime, streamline searches for implementations of these functions. These can be found in the kernel, in the application library, or in dedicated hardware such as programmable network cards or asymmetric multicores. When all functions are found, interconnecting datapaths are setup. Paths may need to cross the PCI bus, userspace/kernelspace barrier or even LANs. Optimisation of these paths is one of the factors that contributes to Streamlines performance.
The base system comes bundled with functions for pattern matching (Aho Corasick, RegEx), accounting, filtering (among others BPF), stream reassembly, rewriting, inspection, and more. Obvious uses are intrusion detection, network address translation, media streaming and realtime (pre)processing of scientific data.
Enhancements:
- This is mostly a stabilization release, which adds support for Linux kernels up to 2.6.22 and Fedora Core installations.
- The only truly new feature is a virtual filesystem interface (like sysfs) to streamline.
- With this "netmonfs" you can inspect live datastreams as if youre reading local files.
- Setting up streams and filters is easily accomplished through mkdir, open, and other well-known tools.
- Note that netmonfs is still beta quality software.

LinCVS XXL is a platform independent graphical interface for the cvs command line client. LinCVS XXL covers the cvs instruction set and allows intuitive and graphical handling of cvs projects. The LinCVS XXL GUI aims towards unexperienced users, yet complies with the requirements of sophisticated and professional users. It plugs into the native look and feel.
In contrast to other cvs clients, LinCVS XXL is a platform independent solution that supports multiple projects at once, allows repository inspection without previous checkout and has fine-grained internal merge/preview features.
Allmost all dialogs are non-modal, so for example inspecting the projects is possible while writing a commit message. File states are continuously monitored, and recognize external cvs actions without user interaction. LinCVS XXL can be fine-tuned to the project requirements, meaning size and performance. An internal ChangeSet viewer is included.
LinCVS supports graphical:
Connect methods:
- local/nfs
- pserver
- ssh
- ssh-agent
- proxy
Special dirview features:
- flatview
- dir-state track keeping
- disable/enable tree/dir
- continuous dir state monitoring
- on-the-fly dir scanning
- open dir browser
- open shell
- expand all
- collaps all
Overall features:
- user/server profiles
- handle multiple projects simultaneously
- handling of subprojects
- ascii/binary file support
- project properties
- per project settings
- can be operated without mouse
- customizable settings for open/view file
- application-wide customizable keyboard shortcuts
- rename file/s
- merge preview
- export from working copy
- extensive dragn drop support
- user definable look and feel
- user definable icons/icon dir
- Application dir installation
- import binary/ascii preview
- browse modules on server, even without modules file
- view files without checkout, from history or log
- branch/tag/project-name/commit-info history
- tabbed view for cvs-controled/cvs-ignored/non-cvs files
- remove files local/in repository/both
- open with (startup option for just opening a specific dir/project)
- create new file/dir
- internal diff viewer with highlighting of in-line differences
- internal conflict resolver dialog
- use of external: editor/browser/shell/diff/remote shell
- ncvs (notification extension) support
CVS features:
- checkout (branch/tag/date)
- import
- import vendor
- export (branch/tag/date)
- release/remove
- status
- query update
- show editors [non-modal]
- show watchers [non-modal]
- watch add/remove
- edit
- unedit
- history [non-modal]
- commit [non-modal]
- tag (add/remove/move/reset)
- branch
- update (to whatever revision)
- reset/update to dir branch
- update (*kx options)
- login/logout
- lock/unlock dir/files
- log (graphical zoomable multi-file revision tree) [non-modal]
- diff (against whatever revision) [non-modal]
- create patch (against whatever revision/tag/date)
- visit file (from log tree or history) [non-modal]
- diff, merge, create patch (from log tree)
- merge diff between rev1,rev2 into rev3(from log tree)
- annotate (with mult. filter functions)
- commit info templates
- .cvsignore support (global/local/environment/per directory)
- add ascii/binary
- readd (resurrect) files

Nasal is a language that I wrote for use in a personal project. Ostensibly it was because I was frustrated with the dearth of small-but-complete embeddable scripting languages, but of course I really wrote it because it was fun.
It is still young and incomplete in a few places, but is under active development and has been integrated as the extension language for the FlightGear simulator.
Documentation is still sparse. There is a design document available, which talks at length about the "whys" behind the design of Nasal and includes documentation for the built-in library functions.
More useful to the experienced programmer is the tutorial-style sample code, which explains and demonstrates all the syntax features of the language.
Like perl, python and javascript, nasal uses vectors (expandable arrays) and hash tables as its native data format. This is a well-understood idiom, and it works very well. I felt no need to rock the boat here.
Like perl, and unlike everything else, nasal combines numbers and strings into a single "scalar" datatype. No conversion needs to happen in user code, which simplifies common string handling tasks.
Like perl, but unlike python, hash keys must by scalars in nasal. Python supports a "tuple" constant type that can be used as well, but there is no equivalent in nasal (you cant use vectors as keys because they might change after the insertion).
Like perl and python, nasal uses a # character to indicate and end-of-line comment. There is no multiline begin/end comment syntax as in Javascript.
Like perl, nasal functions do not have named parameters. They get their arguments in a vector named "arg", and can extract them however they like. Unlike perl, Nasal takes advantage of this feature to do away with function "declaration" entirly; see below.
Like python, there is no hidden local object scope in a function call. The object on which a method was called is available to a function as a local variable named "me" (python calls this "self" by convention, but because nasal has no declared function arguments, there is no opportunity to change it).
Like perl, "objects" in nasal are simply hash tables. Looking an item up by name in a hash table and extracting a symbol for an object are just different syntax for the same operation (but read on for an important exception):
a["b"] = 1 means the same thing as: a.b = 1
The above paragraph is a minor lie. The "dot" syntax is also the clue to the interpreter to "save" the left hand side as the "me" reference if the expression is used as a function/method call. That is, these expressions are not equivalent (one is a plain function call, the other a method invocation on the object "a"):
a["b"](arg1, arg2) isnt the same as: a.b(arg1, arg2)
Like javascript, nasal lacks a specific "class" syntax for OOP programming. Instead, classes are simply objects. Each object supports a "parents" member array; symbol lookup on the object at runtime bounces to the parents (and the parents parents) if the symbol is not found in the hash. The parents field is just like any other object field, you can set it however you like and even change it at runtime if you are feeling especially perverse.
Like lisp, javascript and perl, nasal supports lexical closures. This means that the local symbol namespace available to your function when it is assigned remain constant over time. If you dont know what this means, you dont need to care. It is this feature that allows functions to use variables declared in the outer scope when it is defined (e.g. seeing "module" variables).
Like all other scripting languages, functions are just symbols in a namespace, but unlike all other scripting languages, there is no function "declaration" syntax. A function is always an anonymous object (a "lambda," in the parlance), which you assign to a variable in order to use. Like so:
myfunction = func { arg[0] + 1 }
myfunction(1); # returns 2
One annoyance of this feature is that Nasal functions dont have unique internal "names". So a debugging or exception stack trace can only give you a source line number, and not a function name as reference.
Nasal has a straightforward, readable syntax which is closest to javascript among other scripting languages. Like later versions of javascript, it includes has a hash lookup syntax as well as an object field accessor syntax (that is, you can do both a.b and a["b"]).
Unlike python, nasal has a grammar which is not whitespace-sensitive. This doesnt make python hard to write, and it arguably makes it easier to read. But it is different from the way the rest of the world works, and makes python distinctly unsuitable for "inline" environments (consider PHP, Javascript, ASP or in-configuration-file scripts) where it needs to live as a plain old string inside of another programs code or data file.
Nasal garbage collects runtime storage, so the programmer need not worry about manual allocation, or even circular references. The current implementation is a simple mark/sweep collector, which should be acceptable for most applications. Future enhancements will include a "return early" capability for latency-critical applications. The collector can be instructred to return after a certain maximum delay, and be restarted later. Fancy items like generational collectors fail the "small and simple" criteria and are not likely to be included.
Like python, nasal supports exception handling as a first-class language feature, with built-in runtime-inspectable stack trace. Rather like perl, however, there is no special "try" syntax for exception handling, nor inheritance-based catching semantics. Instead, you call a "try" function on another function, and inspect the return value on your own. Code simply calls die with an argument list, which is returned from the closest enclosing try() invocation. Elaborate exception handling isnt really appropriate for embedded scripting languages. [NOTE: this isnt finished yet]
Nasal tries to be stricter than perl. Operations like converting a non-numeric string value to a number, reading or writing past the end of an array or operating on a nil reference, which are generally legal in perl, throw exceptions in nasal. Perl sometimes bends over backwards to do something "reasonable" with your instructions (e.g. whats the boolean truth value of a hash reference?); nasal doesnt try ("error: non-scalar used in boolean context at line 92")
Nasal is very small, very simple, written in ANSI C, and generally an excellent choice for embedded applications. It uses a simple and transparent syntax interpretable by a simple "bracket matching and operator precedence" parser. It does not depend on any third party libraries other than the standard C library. It does not depend on third party tools like (f)lex and yacc/bison. It builds simply and easily, supports a reasonably simple extension API and cohabitates well with other code.
Nasal makes no use of the processor stack when running recursive code. This is important for embedded languages as it provides the ability to "exit early" from a Nasal context. An outside application may have realtime constraints, and Nasal can be instructed to run for only a certain number of "cycles" before returning. Later calls will automatically pick up the interpreter state where it left off.
Nasal provides "minimal threadsafety". Multithreaded operations on Nasal objects are safe in the sense that they cannot crash or corrupt the interpreter. They are not guaranteed to be atomic. In particular, poorly synchronized insertions into containers can "drop" objects into oblivion (which is OK from an interpreter stability standpoint, since the GC will clean them up normally). Race conditions have to be the programmers problem anyway, this is just another symptom. Garbage collection will block all threads before running. [NOTE: this part is still unimplemented.]
Enhancements:
- This release contains the updates that have been available in SimGear for some time now.
- Important new functionality includes bugfixes, many performance enhancements, a declared function argument syntax, a ternary (?:) operator, indexable and mutable string objects, interpreter thread safety features, and much work to the "standard" library (including stdio, bitfields, Unix system calls, and PCRE regular expressions).

Unicode Error Detector is a product for Plone used to pinpoint errors in your application leading to UnicodeDecodeErrors.

Do not use this product unless you are actively debugging a Unicode Error. Never use this product in production sites.

UnicodeDecodeErrors typically occur when you try to add a Unicode string to a non-ascii string. This product patches StringIO used by page templates to check if the appended string is a Unicode string, and if it is, it replaces the string with an error marker.

As there is some overhead associated with inspecting the strings instead of just appending to the output, this product is meant for debugging purposes only.

Usage

Put the product in your Products directory and restart Zope. Load the template causing the UnicodeDecodeError, and this tool will indicate the location by printing THIS IS WHERE THE ERROR IS in the rendered template.

You can then inspect the template and/or code more closely to figure out where the decode error happens.

soapUI provides a desktop application for inspecting, invoking, implementing and testing of web services over soap/http.

soapUI is a free and open source desktop application for inspecting, invoking, developing and functional/load/compliance testing of web services over HTTP.

It is mainly aimed at developers/testers providing and/or consuming web services (java, .net, etc). Functional and Load-Testing can be done both interactively in soapUI or within an automated build/integration process using the soapUI command-line tools.

IDE-plugins are available for eclipse, IntelliJ IDEA, NetBeans and a specialized eclipse-plugin for JBossWS.