|
Announcing V0.5 of netx!
|
An open-source JNLP client
|
|
Quick Links
Documentation
Project Links
Netx-Powered Apps
Volunteer
Logos
If you include netx as part of your application
please use one of these logos:
Under construction. |
Version 0.5 Released!
For more information see the web site at
http://jnlp.sourceforge.net/netx/
About Netx - NETwork eXecute
Netx is a high-quality implementation of the Java
Network Launching Protocol (JNLP). It downloads
code over the network for applications and
applets, caches it, and runs it in a secure
environment.
Netx was designed from the ground-up to be a library for adding JNLP features to other applications. This allows the API to be clean, simple, and easy to use. Netx avoids the bloat and complication from application browsers and other UIs because these are done by other apps such as the Java Start button and OCD/Xito. What is JNLP?
The Java Network Launching Protocol describes
internet applications and applets, what resources
they need, and how to run the code. The basic
idea of JNLP is to let a user click on a link and
have an application or applet run outside the
browser.
The main part of JNLP is the .jnlp file, which is an XML-formatted description of an application or applet. This file specified the code, security requirements, meta-data such as vendor and icons, and other information. Credits
Written by Jon A. Maxwell (JAM)
Contributors: Deane Richan, Graham Heyes, Thomas Singer, Steve Menard, Jan Boesenberg, Karsten Lentzsch, Scott Pennell, and others. |
libnetx-java-0.5.orig/javadoc/ 0000777 0001750 0001750 00000000000 07625173272 014433 5 ustar god god libnetx-java-0.5.orig/LICENSE.TXT 0000666 0001750 0001750 00000063476 07624376206 014530 0 ustar god god GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.
|
|
Announcing V0.5 of netx!
|
An open-source JNLP client
|
|
Quick Links
Documentation
Project Links
Netx-Powered Apps
Volunteer
Logos
If you include netx as part of your application
please use one of these logos:
Under construction. |
In Progress...
Improvements since previous version:
Netx 0.5
Major improvements since previous version:
Netx 0.4.1
Version 0.4.1 fixes a download bug that caused
some applications not to run on some systems.
Improvements since previous version:
Netx 0.3
Main improvement is a cache.
Improvements since previous version:
Netx 0.2
The first stand-alone client.
Improvements since previous version:
Netx 0.1
This version was part of the Object Component Desktop.
|
libnetx-java-0.5.orig/src/ 0000777 0001750 0001750 00000000000 07625173272 013613 5 ustar god god libnetx-java-0.5.orig/src/javax/ 0000777 0001750 0001750 00000000000 07625173272 014724 5 ustar god god libnetx-java-0.5.orig/src/javax/jnlp/ 0000777 0001750 0001750 00000000000 07625173272 015667 5 ustar god god libnetx-java-0.5.orig/src/javax/jnlp/BasicService.java 0000666 0001750 0001750 00000000332 07622737600 021070 0 ustar god god package javax.jnlp; public interface BasicService { public java.net.URL getCodeBase(); public boolean isOffline(); public boolean showDocument(java.net.URL url); public boolean isWebBrowserSupported(); } libnetx-java-0.5.orig/src/javax/jnlp/ClipboardService.java 0000666 0001750 0001750 00000000303 07622737600 021744 0 ustar god god package javax.jnlp; public interface ClipboardService { public java.awt.datatransfer.Transferable getContents(); public void setContents(java.awt.datatransfer.Transferable contents); } libnetx-java-0.5.orig/src/javax/jnlp/DownloadService.java 0000666 0001750 0001750 00000003275 07622737600 021627 0 ustar god god package javax.jnlp; public interface DownloadService { public boolean isResourceCached(java.net.URL ref, java.lang.String version); public boolean isPartCached(java.lang.String part); public boolean isPartCached(java.lang.String[] parts); public boolean isExtensionPartCached(java.net.URL ref, java.lang.String version, java.lang.String part); public boolean isExtensionPartCached(java.net.URL ref, java.lang.String version, java.lang.String[] parts); public void loadResource(java.net.URL ref, java.lang.String version, DownloadServiceListener progress) throws java.io.IOException; public void loadPart(java.lang.String part, DownloadServiceListener progress) throws java.io.IOException; public void loadPart(java.lang.String[] parts, DownloadServiceListener progress) throws java.io.IOException; public void loadExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String part, DownloadServiceListener progress) throws java.io.IOException; public void loadExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String[] parts, DownloadServiceListener progress) throws java.io.IOException; public void removeResource(java.net.URL ref, java.lang.String version) throws java.io.IOException; public void removePart(java.lang.String part) throws java.io.IOException; public void removePart(java.lang.String[] parts) throws java.io.IOException; public void removeExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String part) throws java.io.IOException; public void removeExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String[] parts) throws java.io.IOException; public DownloadServiceListener getDefaultProgressWindow(); } libnetx-java-0.5.orig/src/javax/jnlp/DownloadServiceListener.java 0000666 0001750 0001750 00000000751 07622737600 023331 0 ustar god god package javax.jnlp; public interface DownloadServiceListener { public void progress(java.net.URL url, java.lang.String version, long readSoFar, long total, int overallPercent); public void validating(java.net.URL url, java.lang.String version, long entry, long total, int overallPercent); public void upgradingArchive(java.net.URL url, java.lang.String version, int patchPercent, int overallPercent); public void downloadFailed(java.net.URL url, java.lang.String version); } libnetx-java-0.5.orig/src/javax/jnlp/ExtensionInstallerService.java 0000666 0001750 0001750 00000001342 07622737600 023703 0 ustar god god package javax.jnlp; public interface ExtensionInstallerService { public java.lang.String getInstallPath(); public java.lang.String getExtensionVersion(); public java.net.URL getExtensionLocation(); public void hideProgressBar(); public void hideStatusWindow(); public void setHeading(java.lang.String heading); public void setStatus(java.lang.String status); public void updateProgress(int value); public void installSucceeded(boolean needsReboot); public void installFailed(); public void setJREInfo(java.lang.String platformVersion, java.lang.String jrePath); public void setNativeLibraryInfo(java.lang.String path); public java.lang.String getInstalledJRE(java.net.URL url, java.lang.String version); } libnetx-java-0.5.orig/src/javax/jnlp/FileContents.java 0000666 0001750 0001750 00000001255 07622737600 021130 0 ustar god god package javax.jnlp; public interface FileContents { public java.lang.String getName() throws java.io.IOException; public java.io.InputStream getInputStream() throws java.io.IOException; public java.io.OutputStream getOutputStream(boolean overwrite) throws java.io.IOException; public long getLength() throws java.io.IOException; public boolean canRead() throws java.io.IOException; public boolean canWrite() throws java.io.IOException; public JNLPRandomAccessFile getRandomAccessFile(java.lang.String mode) throws java.io.IOException; public long getMaxLength() throws java.io.IOException; public long setMaxLength(long maxlength) throws java.io.IOException; } libnetx-java-0.5.orig/src/javax/jnlp/FileOpenService.java 0000666 0001750 0001750 00000000474 07622737602 021561 0 ustar god god package javax.jnlp; public interface FileOpenService { public FileContents openFileDialog(java.lang.String pathHint, java.lang.String[] extensions) throws java.io.IOException; public FileContents[] openMultiFileDialog(java.lang.String pathHint, java.lang.String[] extensions) throws java.io.IOException; } libnetx-java-0.5.orig/src/javax/jnlp/FileSaveService.java 0000666 0001750 0001750 00000000601 07622737602 021546 0 ustar god god package javax.jnlp; public interface FileSaveService { public FileContents saveFileDialog(java.lang.String pathHint, java.lang.String[] extensions, java.io.InputStream stream, java.lang.String name) throws java.io.IOException; public FileContents saveAsFileDialog(java.lang.String pathHint, java.lang.String[] extensions, FileContents contents) throws java.io.IOException; } libnetx-java-0.5.orig/src/javax/jnlp/JNLPRandomAccessFile.java 0000666 0001750 0001750 00000004411 07622737602 022360 0 ustar god god package javax.jnlp; public interface JNLPRandomAccessFile { public void close() throws java.io.IOException; public long length() throws java.io.IOException; public long getFilePointer() throws java.io.IOException; public int read() throws java.io.IOException; public int read(byte[] b, int off, int len) throws java.io.IOException; public int read(byte[] b) throws java.io.IOException; public void readFully(byte[] b) throws java.io.IOException; public void readFully(byte[] b, int off, int len) throws java.io.IOException; public int skipBytes(int n) throws java.io.IOException; public boolean readBoolean() throws java.io.IOException; public byte readByte() throws java.io.IOException; public int readUnsignedByte() throws java.io.IOException; public short readShort() throws java.io.IOException; public int readUnsignedShort() throws java.io.IOException; public char readChar() throws java.io.IOException; public int readInt() throws java.io.IOException; public long readLong() throws java.io.IOException; public float readFloat() throws java.io.IOException; public double readDouble() throws java.io.IOException; public java.lang.String readLine() throws java.io.IOException; public java.lang.String readUTF() throws java.io.IOException; public void seek(long pos) throws java.io.IOException; public void setLength(long newLength) throws java.io.IOException; public void write(int b) throws java.io.IOException; public void write(byte[] b) throws java.io.IOException; public void write(byte[] b, int off, int len) throws java.io.IOException; public void writeBoolean(boolean v) throws java.io.IOException; public void writeByte(int v) throws java.io.IOException; public void writeShort(int v) throws java.io.IOException; public void writeChar(int v) throws java.io.IOException; public void writeInt(int v) throws java.io.IOException; public void writeLong(long v) throws java.io.IOException; public void writeFloat(float v) throws java.io.IOException; public void writeDouble(double v) throws java.io.IOException; public void writeBytes(java.lang.String s) throws java.io.IOException; public void writeChars(java.lang.String s) throws java.io.IOException; public void writeUTF(java.lang.String str) throws java.io.IOException; } libnetx-java-0.5.orig/src/javax/jnlp/PersistenceService.java 0000666 0001750 0001750 00000001522 07622737602 022337 0 ustar god god package javax.jnlp; public interface PersistenceService { public static final int CACHED = 0; public static final int TEMPORARY = 1; public static final int DIRTY = 2; public long create(java.net.URL url, long maxsize) throws java.net.MalformedURLException, java.io.IOException; public FileContents get(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException, java.io.FileNotFoundException; public void delete(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException; public java.lang.String[] getNames(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException; public int getTag(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException; public void setTag(java.net.URL url, int tag) throws java.net.MalformedURLException, java.io.IOException; } libnetx-java-0.5.orig/src/javax/jnlp/PrintService.java 0000666 0001750 0001750 00000000476 07622737602 021156 0 ustar god god package javax.jnlp; public interface PrintService { public java.awt.print.PageFormat getDefaultPage(); public java.awt.print.PageFormat showPageFormatDialog(java.awt.print.PageFormat page); public boolean print(java.awt.print.Pageable document); public boolean print(java.awt.print.Printable painter); } libnetx-java-0.5.orig/src/javax/jnlp/ServiceManager.java 0000666 0001750 0001750 00000002276 07622737602 021434 0 ustar god god package javax.jnlp; import java.util.*; public final class ServiceManager { private static ServiceManagerStub stub = null; private static Map lookupTable = new HashMap(); // ensure lookup is idempotent private ServiceManager() { // says it can't be instantiated } public static java.lang.Object lookup(java.lang.String name) throws UnavailableServiceException { if (stub == null) throw new UnavailableServiceException("service stub not set."); synchronized(lookupTable) { Object result = lookupTable.get(name); if (result == null) { result = stub.lookup(name); if (result != null) lookupTable.put(name, result); } if (result == null) throw new UnavailableServiceException("service not available (stub returned null)."); return result; } } public static java.lang.String[] getServiceNames() { // should this return the required ones even though no stub?? if (stub == null) return new String[0]; return stub.getServiceNames(); } public static void setServiceManagerStub(ServiceManagerStub stub) { if (ServiceManager.stub == null) ServiceManager.stub = stub; } } libnetx-java-0.5.orig/src/javax/jnlp/ServiceManagerStub.java 0000666 0001750 0001750 00000000315 07622737602 022262 0 ustar god god package javax.jnlp; public interface ServiceManagerStub { public java.lang.Object lookup(java.lang.String name) throws UnavailableServiceException; public java.lang.String[] getServiceNames(); } libnetx-java-0.5.orig/src/javax/jnlp/UnavailableServiceException.java 0000666 0001750 0001750 00000000355 07622737602 024160 0 ustar god god package javax.jnlp; public class UnavailableServiceException extends Exception { public UnavailableServiceException() { super(); } public UnavailableServiceException(java.lang.String message) { super(message); } } libnetx-java-0.5.orig/src/nanoxml/ 0000777 0001750 0001750 00000000000 07625173272 015267 5 ustar god god libnetx-java-0.5.orig/src/nanoxml/XMLElement.java 0000666 0001750 0001750 00000106513 07622737602 020112 0 ustar god god /* XMLElement.java * * $Revision: 1.2 $ * $Date: 2002/08/03 04:36:34 $ * $Name: $ * * This file is part of NanoXML 2 Lite. * Copyright (C) 2000-2002 Marc De Scheemaecker, All Rights Reserved. * * This software is provided 'as-is', without any express or implied warranty. * In no event will the authors be held liable for any damages arising from the * use of this software. * * Permission is granted to anyone to use this software for any purpose, * including commercial applications, and to alter it and redistribute it * freely, subject to the following restrictions: * * 1. The origin of this software must not be misrepresented; you must not * claim that you wrote the original software. If you use this software in * a product, an acknowledgment in the product documentation would be * appreciated but is not required. * * 2. Altered source versions must be plainly marked as such, and must not be * misrepresented as being the original software. * * 3. This notice may not be removed or altered from any source distribution. *****************************************************************************/ /* JAM: hacked the source to remove unneeded methods and comments. */ package nanoxml; import java.io.*; import java.util.*; /** * XMLElement is a representation of an XML object. The object is able to parse * XML code. *
-
*
- Parsing XML Data *
-
* You can parse XML data using the following code:
*
* XMLElement xml = new XMLElement();
* FileReader reader = new FileReader("filename.xml");
* xml.parseFromReader(reader); *
- Retrieving Attributes *
-
* You can enumerate the attributes of an element using the method
* {@link #enumerateAttributeNames() enumerateAttributeNames}.
* The attribute values can be retrieved using the method
* {@link #getStringAttribute(java.lang.String) getStringAttribute}.
* The following example shows how to list the attributes of an element:
*
* XMLElement element = ...;
* Enumeration enum = element.getAttributeNames();
* while (enum.hasMoreElements()) {
* String key = (String) enum.nextElement();
* String value = element.getStringAttribute(key);
* System.out.println(key + " = " + value);
* } *
- Retrieving Child Elements *
- * You can enumerate the children of an element using * {@link #enumerateChildren() enumerateChildren}. * The number of child elements can be retrieved using * {@link #countChildren() countChildren}. *
- Elements Containing Character Data *
-
* If an elements contains character data, like in the following example:
*
* <title>The Title</title> *
- Subclassing XMLElement *
- * When subclassing XMLElement, you need to override the method * {@link #createAnotherElement() createAnotherElement} * which has to return a new copy of the receiver. *
* * @see nanoxml.XMLParseException * * @author Marc De Scheemaecker * <cyberelf@mac.com> * @version $Name: $, $Revision: 1.2 $ */ public class XMLElement { /** * The attributes given to the element. * *
- Invariants:
-
*
- The field can be empty. *
- The field is never
null. * - The keys and the values are strings. *
- Invariants:
-
*
- The field can be empty. *
- The field is never
null. * - The elements are instances of
XMLElement* or a subclass ofXMLElement. *
- Invariants:
-
*
- The field is
nulliff the element is not * initialized by either parse or setName. * - If the field is not
null, it's not empty. * - If the field is not
null, it contains a valid * XML identifier. *
- The field is
- Invariants:
-
*
- The field is
nulliff the element is not a * #PCDATA element. * - The field can be any string, including the empty string. *
- The field is
- Invariants:
-
*
- The field is never
null. * - The field always contains the following associations: * "lt" => "<", "gt" => ">", * "quot" => "\"", "apos" => "'", * "amp" => "&" *
- The keys are strings *
- The values are char arrays *
- The field is never
- Invariants:
-
*
lineNr >= 0*
true if the case of the element and attribute names
* are case insensitive.
*/
private boolean ignoreCase;
/**
* true if the leading and trailing whitespace of #PCDATA
* sections have to be ignored.
*/
private boolean ignoreWhitespace;
/**
* Character read too much.
* This character provides push-back functionality to the input reader
* without having to use a PushbackReader.
* If there is no such character, this field is '\0'.
*/
private char charReadTooMuch;
/**
* The reader provided by the caller of the parse method.
*
* - Invariants:
-
*
- The field is not
nullwhile the parse method * is running. *
- The field is not
- Invariants:
-
*
- parserLineNr > 0 while the parse method is running. *
new XMLElement(new Hashtable(), false, true)
* - Postconditions:
-
*
- countChildren() => 0 *
- enumerateChildren() => empty enumeration *
- enumeratePropertyNames() => empty enumeration *
- getChildren() => empty vector *
- getContent() => "" *
- getLineNr() => 0 *
- getName() => null *
* This constructor should only be called from
* {@link #createAnotherElement() createAnotherElement}
* to create child elements.
*
* @param entities
* The entity conversion table.
* @param skipLeadingWhitespace
* true if leading and trailing whitespace in PCDATA
* content has to be removed.
* @param fillBasicConversionTable
* true if the basic entities need to be added to
* the entity list (client code calling this constructor).
* @param ignoreCase
* true if the case of element and attribute names have
* to be ignored.
*
*
- Preconditions:
-
*
entities != null*- if
fillBasicConversionTable == false* thenentitiescontains at least the following * entries:amp,lt,gt, *aposandquot*
- Postconditions:
-
*
- countChildren() => 0 *
- enumerateChildren() => empty enumeration *
- enumeratePropertyNames() => empty enumeration *
- getChildren() => empty vector *
- getContent() => "" *
- getLineNr() => 0 *
- getName() => null *
-
*
*/
protected XMLElement(Hashtable entities,
boolean skipLeadingWhitespace,
boolean fillBasicConversionTable,
boolean ignoreCase)
{
this.ignoreWhitespace = skipLeadingWhitespace;
this.ignoreCase = ignoreCase;
this.name = null;
this.contents = "";
this.attributes = new Hashtable();
this.children = new Vector();
this.entities = entities;
this.lineNr = 0;
Enumeration enum = this.entities.keys();
while (enum.hasMoreElements()) {
Object key = enum.nextElement();
Object value = this.entities.get(key);
if (value instanceof String) {
value = ((String) value).toCharArray();
this.entities.put(key, value);
}
}
if (fillBasicConversionTable) {
this.entities.put("amp", new char[] { '&' });
this.entities.put("quot", new char[] { '"' });
this.entities.put("apos", new char[] { '\'' });
this.entities.put("lt", new char[] { '<' });
this.entities.put("gt", new char[] { '>' });
}
}
/**
* Adds a child element.
*
* @param child
* The child element to add.
*
*
- Preconditions:
-
*
child != null*child.getName() != null*childdoes not have a parent element *
- Postconditions:
-
*
- countChildren() => old.countChildren() + 1 *
- enumerateChildren() => old.enumerateChildren() + child *
- getChildren() => old.enumerateChildren() + child *
-
*
*/
public void addChild(XMLElement child)
{
this.children.addElement(child);
}
/**
* Adds or modifies an attribute.
*
* @param name
* The name of the attribute.
* @param value
* The value of the attribute.
*
*
- Preconditions:
-
*
name != null*nameis a valid XML identifier *value != null*
- Postconditions:
-
*
- enumerateAttributeNames() * => old.enumerateAttributeNames() + name *
- getAttribute(name) => value *
-
*
*/
public void setAttribute(String name,
Object value)
{
if (this.ignoreCase) {
name = name.toUpperCase();
}
this.attributes.put(name, value.toString());
}
/**
* Returns the number of child elements of the element.
*
*
- Postconditions:
-
*
result >= 0*
- Postconditions:
-
*
result != null*
- Postconditions:
-
*
result != null*
- Postconditions:
-
*
result >= 0*
null is returned.
*
*/
public String getContent()
{
return this.contents;
}
/**
* Returns the line nr in the source data on which the element is found.
* This method returns 0 there is no associated source data.
*
* null is returned.
*
* @param name The name of the attribute.
*
* - Preconditions:
-
*
name != null*nameis a valid XML identifier *
-
*
*/
public Object getAttribute(String name)
{
if (this.ignoreCase) {
name = name.toUpperCase();
}
Object value = this.attributes.get(name);
return value;
}
/**
* Returns the name of the element.
*
*/
public String getName()
{
return this.name;
}
/**
* Reads one XML element from a java.io.Reader and parses it.
*
* @param reader
* The reader from which to retrieve the XML data.
*
*
- Preconditions:
-
*
reader != null*readeris not closed *
- Postconditions:
-
*
- the state of the receiver is updated to reflect the XML element * parsed from the reader *
- the reader points to the first character following the last * '>' character of the XML element *
-
*
* @throws java.io.IOException
* If an error occured while reading the input.
* @throws nanoxml.XMLParseException
* If an error occured while parsing the read data.
*/
public void parseFromReader(Reader reader)
throws IOException, XMLParseException
{
this.parseFromReader(reader, /*startingLineNr*/ 1);
}
/**
* Reads one XML element from a java.io.Reader and parses it.
*
* @param reader
* The reader from which to retrieve the XML data.
* @param startingLineNr
* The line number of the first line in the data.
*
*
- Preconditions:
-
*
reader != null*readeris not closed *
- Postconditions:
-
*
- the state of the receiver is updated to reflect the XML element * parsed from the reader *
- the reader points to the first character following the last * '>' character of the XML element *
-
*
* @throws java.io.IOException
* If an error occured while reading the input.
* @throws nanoxml.XMLParseException
* If an error occured while parsing the read data.
*/
public void parseFromReader(Reader reader,
int startingLineNr)
throws IOException, XMLParseException
{
this.charReadTooMuch = '\0';
this.reader = reader;
this.parserLineNr = startingLineNr;
for (;;) {
char ch = this.scanWhitespace();
if (ch != '<') {
throw this.expectedInput("<");
}
ch = this.readChar();
if ((ch == '!') || (ch == '?')) {
this.skipSpecialTag(0);
} else {
this.unreadChar(ch);
this.scanElement(this);
return;
}
}
}
/**
* Creates a new similar XML element.
*
* You should override this method when subclassing XMLElement. */ protected XMLElement createAnotherElement() { return new XMLElement(this.entities, this.ignoreWhitespace, false, this.ignoreCase); } /** * Changes the content string. * * @param content * The new content string. */ public void setContent(String content) { this.contents = content; } /** * Changes the name of the element. * * @param name * The new name. * *
- Preconditions:
-
*
name != null*nameis a valid XML identifier *
result.
*
* @param result
* The buffer in which the scanned identifier will be put.
*
* - Preconditions:
-
*
result != null*- The next character read from the reader is a valid first * character of an XML identifier. *
- Postconditions:
-
*
- The next character read from the reader won't be an identifier * character. *
-
*/
protected void scanIdentifier(StringBuffer result)
throws IOException
{
for (;;) {
char ch = this.readChar();
if (((ch < 'A') || (ch > 'Z')) && ((ch < 'a') || (ch > 'z'))
&& ((ch < '0') || (ch > '9')) && (ch != '_') && (ch != '.')
&& (ch != ':') && (ch != '-') && (ch <= '\u007E')) {
this.unreadChar(ch);
return;
}
result.append(ch);
}
}
/**
* This method scans an identifier from the current reader.
*
* @return the next character following the whitespace.
*/
protected char scanWhitespace()
throws IOException
{
for (;;) {
char ch = this.readChar();
switch (ch) {
case ' ':
case '\t':
case '\n':
case '\r':
break;
default:
return ch;
}
}
}
/**
* This method scans an identifier from the current reader.
* The scanned whitespace is appended to
result.
*
* @return the next character following the whitespace.
*
* - Preconditions:
-
*
result != null*
string.
*
* - Preconditions:
-
*
string != null*- the next char read is the string delimiter *
data.
*
* - Preconditions:
-
*
data != null*
buf.
*
* - Preconditions:
-
*
buf != null*- The first < has already been read. *
- Preconditions:
-
*
- The first <!-- has already been read. *
- Preconditions:
-
*
- The first <! has already been read. *
bracketLevel >= 0*
- Preconditions:
-
*
literal != null*
- Preconditions:
-
*
- The first < has already been read. *
elt != null*
buf.
*
* @param buf Where to put the entity value.
*
* - Preconditions:
-
*
- The first & has already been read. *
buf != null*
- Preconditions:
-
*
- The read-back buffer is empty. *
ch != '\0'*
- Preconditions:
-
*
name != null*
- Preconditions:
-
*
name != null*value != null*
- Preconditions:
-
*
context != null*context.length() > 0*
- Preconditions:
-
*
charSet != null*charSet.length() > 0*
- Preconditions:
-
*
name != null*name.length() > 0*
* $Revision: 1.1 $
* $Date: 2002/08/03 04:05:32 $
*
* @see nanoxml.XMLElement
*
* @author Marc De Scheemaecker
* @version $Name: $, $Revision: 1.1 $
*/
public class XMLParseException
extends RuntimeException
{
/**
* Indicates that no line number has been associated with this exception.
*/
public static final int NO_LINE = -1;
/**
* The line number in the source code where the error occurred, or
* NO_LINE if the line number is unknown.
*
*
- Invariants:
-
*
lineNr > 0 || lineNr == NO_LINE*
- Preconditions:
-
*
message != null*
- Postconditions:
-
*
- getLineNr() => NO_LINE *
-
*/
public XMLParseException(String name,
String message)
{
super("XML Parse Exception during parsing of "
+ ((name == null) ? "the XML definition"
: ("a " + name + " element"))
+ ": " + message);
this.lineNr = XMLParseException.NO_LINE;
}
/**
* Creates an exception.
*
* @param name The name of the element where the error is located.
* @param lineNr The number of the line in the input.
* @param message A message describing what went wrong.
*
*
- Preconditions:
-
*
message != null*lineNr > 0*
- Postconditions:
-
*
- getLineNr() => lineNr *
-
*/
public XMLParseException(String name,
int lineNr,
String message)
{
super("XML Parse Exception during parsing of "
+ ((name == null) ? "the XML definition"
: ("a " + name + " element"))
+ " at line " + lineNr + ": " + message);
this.lineNr = lineNr;
}
/**
* Where the error occurred, or
NO_LINE if the line number is
* unknown.
*
* @see nanoxml.XMLParseException#NO_LINE
*/
public int getLineNr()
{
return this.lineNr;
}
}
libnetx-java-0.5.orig/src/netx/ 0000777 0001750 0001750 00000000000 07625173272 014571 5 ustar god god libnetx-java-0.5.orig/src/netx/jnlp/ 0000777 0001750 0001750 00000000000 07625173272 015534 5 ustar god god libnetx-java-0.5.orig/src/netx/jnlp/AppletDesc.java 0000666 0001750 0001750 00000006001 07622737602 020420 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp;
import java.io.*;
import java.net.*;
import java.util.*;
/**
* The applet-desc element.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.8 $
*/
public class AppletDesc {
/** the applet name */
private String name;
/** the main class name and package */
private String mainClass;
/** the document base */
private URL documentBase;
/** the width */
private int width;
/** the height */
private int height;
/** the parameters */
private Map parameters;
/**
* Create an Applet descriptor.
*
* @param name the applet name
* @param mainClass the main class name and package
* @param documentBase the document base
* @param width the width
* @param height the height
* @param parameters the parameters
*/
public AppletDesc(String name, String mainClass, URL documentBase, int width, int height, Map parameters) {
this.name = name;
this.mainClass = mainClass;
this.documentBase = documentBase;
this.width = width;
this.height = height;
this.parameters = new HashMap(parameters);
}
/**
* Returns the applet name
*/
public String getName() {
return name;
}
/**
* Returns the main class name
*/
public String getMainClass() {
return mainClass;
}
/**
* Returns the document base
*/
public URL getDocumentBase() {
return documentBase;
}
/**
* Returns the width
*/
public int getWidth() {
return width;
}
/**
* Returns the height
*/
public int getHeight() {
return height;
}
/**
* Returns the applet parameters
*/
public Map getParameters() {
return new HashMap(parameters);
}
/**
* Adds a parameter to the applet. If the parameter already
* exists then it is overwritten with the new value. Adding a
* parameter will have no effect on already-running applets
* launched from this JNLP file.
*/
public void addParameter(String name, String value) {
parameters.put(name, value);
}
}
libnetx-java-0.5.orig/src/netx/jnlp/ApplicationDesc.java 0000666 0001750 0001750 00000003755 07622737602 021453 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp;
import java.io.*;
import java.net.*;
import java.util.*;
/**
* The application-desc element.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.7 $
*/
public class ApplicationDesc {
/** the main class name and package */
private String mainClass;
/** the arguments */
private String arguments[];
/**
* Create an Application descriptor.
*
* @param mainClass the main class name and package
* @param arguments the arguments
*/
public ApplicationDesc(String mainClass, String arguments[]) {
this.mainClass = mainClass;
this.arguments = arguments;
}
/**
* Returns the main class name
*/
public String getMainClass() {
return mainClass;
}
/**
* Returns the arguments
*/
public String[] getArguments() {
return (String[]) arguments.clone();
}
/**
* Add an argument to the end of the arguments.
*/
public void addArgument(String arg) {
ArrayList l = new ArrayList(Arrays.asList(arguments));
l.add(arg);
arguments = (String[]) l.toArray(arguments);
}
}
libnetx-java-0.5.orig/src/netx/jnlp/cache/ 0000777 0001750 0001750 00000000000 07625173272 016577 5 ustar god god libnetx-java-0.5.orig/src/netx/jnlp/cache/CacheEntry.java 0000666 0001750 0001750 00000012315 07623741316 021467 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.cache;
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.reflect.*;
import java.security.*;
import javax.jnlp.*;
import netx.jnlp.*;
import netx.jnlp.runtime.*;
import netx.jnlp.util.*;
/**
* Describes an entry in the cache.* * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.10 $ */ public class CacheEntry { /** the remote resource location */ private URL location; /** the requested version */ private Version version; /** info about the cached file */ private PropertiesFile properties; /** * Create a CacheEntry for the resources specified as a remote * URL. * * @param location the remote resource location * @param version the version of the resource */ public CacheEntry(URL location, Version version) { this.location = location; this.version = version; File infoFile = CacheUtil.getCacheFile(location, version); infoFile = new File(infoFile.getPath()+".info"); // replace with something that can't be clobbered properties = new PropertiesFile(infoFile, JNLPRuntime.getMessage("CAutoGen")); } /** * Initialize the cache entry data from a connection to the * remote resource (does not store data). */ void initialize(URLConnection connection) { long modified = connection.getLastModified(); long length = connection.getContentLength(); // an int properties.setProperty("content-length", Long.toString(length)); properties.setProperty("last-modified", Long.toString(modified)); } /** * Returns the remote location this entry caches. */ public URL getLocation() { return location; } /** * Returns the time in the local system clock that the file was * most recently checked for an update. */ public long getLastUpdated() { try { return Long.parseLong(properties.getProperty("last-updated")); } catch (Exception ex) { return 0; } } /** * Sets the time in the local system clock that the file was * most recently checked for an update. */ public void setLastUpdated(long updatedTime) { properties.setProperty("last-updated", Long.toString(updatedTime)); } /** * Returns whether there is a version of the URL contents in * the cache and it is up to date. This method may not return * immediately. * * @param connection a connection to the remote URL * @return whether the cache contains the version */ public boolean isCurrent(URLConnection connection) { boolean cached = isCached(); if (!cached) return false; try { long remoteModified = connection.getLastModified(); long cachedModified = Long.parseLong(properties.getProperty("last-modified")); if (remoteModified > 0 && remoteModified <= cachedModified) return true; else return false; } catch (Exception ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); return cached; // if can't connect return whether already in cache } } /** * Returns true if the cache has a local copy of the contents * of the URL matching the specified version string. * * @return true if the resource is in the cache */ public boolean isCached() { File localFile = CacheUtil.getCacheFile(location, version); if (!localFile.exists()) return false; try { long cachedLength = localFile.length(); long remoteLength = Long.parseLong(properties.getProperty("content-length", "-1")); if (remoteLength >= 0 && cachedLength != remoteLength) return false; else return true; } catch (Exception ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); return false; // should throw? } } /** * Save the current information for the cache entry. */ protected void store() { properties.store(); } } libnetx-java-0.5.orig/src/netx/jnlp/cache/CacheUtil.java 0000666 0001750 0001750 00000032574 07623741534 021316 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp.cache; import java.io.*; import java.net.*; import java.util.*; import java.lang.reflect.*; import java.security.*; import javax.jnlp.*; import netx.jnlp.*; import netx.jnlp.runtime.*; /** * Provides static methods to interact with the cache, download * indicator, and other utility methods.
* * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.17 $ */ public class CacheUtil { private static String R(String key, Object param) { return JNLPRuntime.getMessage(key, new Object[] {param}); } /** * Compares a URL using string compare of its protocol, host, * port, path, query, and anchor. This method avoids the host * name lookup that URL.equals does for http: protocol URLs. * It may not return the same value as the URL.equals method * (different hostnames that resolve to the same IP address, * ie sourceforge.net and www.sourceforge.net). */ public static boolean urlEquals(URL u1, URL u2) { if (u1==u2) return true; if (u1==null || u2==null) return false; if (!compare(u1.getProtocol(), u2.getProtocol(), true) || !compare(u1.getHost(), u2.getHost(), true) || //u1.getDefaultPort() != u2.getDefaultPort() || // only in 1.4 !compare(u1.getPath(), u2.getPath(), false) || !compare(u1.getQuery(), u2.getQuery(), false) || !compare(u1.getRef(), u2.getRef(), false)) return false; else return true; } /** * Caches a resource and returns a URL for it in the cache; * blocks until resource is cached. If the resource location is * not cacheable (points to a local file, etc) then the original * URL is returned.
* * @param location location of the resource * @param version the version, or null * @return either the location in the cache or the original location */ public static URL getCachedResource(URL location, Version version, UpdatePolicy policy) { ResourceTracker rt = new ResourceTracker(); rt.addResource(location, version, policy); try { File f = rt.getCacheFile(location); return f.toURL(); } catch (MalformedURLException ex) { return location; } } /** * Compare strings that can be null. */ private static boolean compare(String s1, String s2, boolean ignore) { if (s1==s2) return true; if (s1==null || s2==null) return false; if (ignore) return s1.equalsIgnoreCase(s2); else return s1.equals(s2); } /** * Returns the Permission object necessary to access the * resource, or null if no permission is needed. */ public static Permission getReadPermission(URL location, Version version) { if (CacheUtil.isCacheable(location, version)) { File file = CacheUtil.getCacheFile(location, version); return new FilePermission(file.getPath(), "read"); } else { try { // this is what URLClassLoader does location.openConnection().getPermission(); } catch (java.io.IOException ioe) { // should try to figure out the permission } } return null; } /** * Returns whether there is a version of the URL contents in the * cache and it is up to date. This method may not return * immediately. * * @param source the source URL * @param version the versions to check for * @param connection a connection to the URL, or null * @return whether the cache contains the version * @throws IllegalArgumentException if the source is not cacheable */ public static boolean isCurrent(URL source, Version version, URLConnection connection) { if (!isCacheable(source, version)) throw new IllegalArgumentException(R("CNotCacheable", source)); try { if (connection == null) connection = source.openConnection(); connection.connect(); CacheEntry entry = new CacheEntry(source, version); // could pool this boolean result = entry.isCurrent(connection); if (JNLPRuntime.isDebug()) System.out.println("isCurrent: "+source+" = "+result); return result; } catch (Exception ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); return isCached(source, version); // if can't connect return whether already in cache } } /** * Returns true if the cache has a local copy of the contents of * the URL matching the specified version string. * * @param source the source URL * @param version the versions to check for * @return true if the source is in the cache * @throws IllegalArgumentException if the source is not cacheable */ public static boolean isCached(URL source, Version version) { if (!isCacheable(source, version)) throw new IllegalArgumentException(R("CNotCacheable", source)); CacheEntry entry = new CacheEntry(source, version); // could pool this boolean result = entry.isCached(); if (JNLPRuntime.isDebug()) System.out.println("isCached: "+source+" = "+result); return result; } /** * Returns whether the resource can be cached as a local file; * if not, then URLConnection.openStream can be used to obtain * the contents. */ public static boolean isCacheable(URL source, Version version) { if (source == null) return false; if (source.getProtocol().equals("file")) return false; if (source.getProtocol().equals("jar")) return false; return true; } /** * Returns the file for the locally cached contents of the * source. This method returns the file location only and does * not download the resource. The latest version of the * resource that matches the specified version will be returned. * * @param source the source URL * @param version the version id of the local file * @return the file location in the cache, or null if no versions cached * @throws IllegalArgumentException if the source is not cacheable */ public static File getCacheFile(URL source, Version version) { // ensure that version is an version id not version string if (!isCacheable(source, version)) throw new IllegalArgumentException(R("CNotCacheable", source)); try { File localFile = urlToPath(source, "cache"); localFile.getParentFile().mkdirs(); return localFile; } catch (Exception ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); return null; } } /** * Returns a buffered output stream open for writing to the * cache file. * * @param source the remote location * @param version the file version to write to */ public static OutputStream getOutputStream(URL source, Version version) throws IOException { File localFile = getCacheFile(source, version); OutputStream out = new FileOutputStream(localFile); return new BufferedOutputStream(out); } /** * Copies from an input stream to an output stream. On * completion, both streams will be closed. Streams are * buffered automatically. */ public static void streamCopy(InputStream is, OutputStream os) throws IOException { if (!(is instanceof BufferedInputStream)) is = new BufferedInputStream(is); if (!(os instanceof BufferedOutputStream)) os = new BufferedOutputStream(os); try { byte b[] = new byte[4096]; while (true) { int c = is.read(b, 0, b.length); if (c == -1) break; os.write(b, 0, c); } } finally { is.close(); os.close(); } } /** * Converts a URL into a local path string within the runtime's * base directory. * * @param location the url * @param subdir subdirectory under the base directory * @return the file */ public static File urlToPath(URL location, String subdir) { StringBuffer path = new StringBuffer(); if (subdir != null) { path.append(subdir); path.append(File.separatorChar); } path.append(location.getProtocol()); path.append(File.separatorChar); path.append(location.getHost()); path.append(File.separatorChar); path.append(location.getPath().replace('/', File.separatorChar)); return new File(JNLPRuntime.getBaseDir(), fixPath(path.toString())); } /** * Clean up a string by removing characters that can't appear in * a local file name. */ private static String fixPath(String path) { char badChars[] = { '\\', '/', ':', '*', '?', '"', '<', '>', '|' }; for (int i=0; i < badChars.length; i++) if (badChars[i] != File.separatorChar) if (-1 != path.indexOf(badChars[i])) path = path.replace(badChars[i], 'X'); return path; } /** * Waits until the resources are downloaded, while showing a * progress indicator. * * @param tracker the resource tracker * @param resources the resources to wait for * @param title name of the download */ public static void waitForResources(ApplicationInstance app, ResourceTracker tracker, URL resources[], String title) { DownloadIndicator indicator = JNLPRuntime.getDefaultDownloadIndicator(); DownloadServiceListener listener = null; try { if (indicator == null) { tracker.waitForResources(resources, 0); return; } // see if resources can be downloaded very quickly; avoids // overhead of creating display components for the resources if (tracker.waitForResources(resources, indicator.getInitialDelay())) return; // only resources not starting out downloaded are displayed List urlList = new ArrayList(); for (int i=0; i < resources.length; i++) { if (!tracker.checkResource(resources[i])) urlList.add(resources[i]); } URL undownloaded[] = (URL[]) urlList.toArray( new URL[urlList.size()] ); listener = indicator.getListener(app, title, undownloaded); do { long read = 0; long total = 0; for (int i=0; i < undownloaded.length; i++) { // add in any -1's; they're insignificant total += tracker.getTotalSize(undownloaded[i]); read += tracker.getAmountRead(undownloaded[i]); } int percent = (int)( (100*read)/Math.max(1,total) ); for (int i=0; i < undownloaded.length; i++) listener.progress(undownloaded[i], "version", tracker.getAmountRead(undownloaded[i]), tracker.getTotalSize(undownloaded[i]), percent); } while (!tracker.waitForResources(resources, indicator.getUpdateRate())); // make sure they read 100% until indicator closes for (int i=0; i < undownloaded.length; i++) listener.progress(undownloaded[i], "version", tracker.getTotalSize(undownloaded[i]), tracker.getTotalSize(undownloaded[i]), 100); } catch (InterruptedException ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); } finally { if (listener != null) indicator.disposeListener(listener); } } } libnetx-java-0.5.orig/src/netx/jnlp/cache/DefaultDownloadIndicator.java 0000666 0001750 0001750 00000024061 07623002002 024332 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp.cache; import java.awt.*; import java.awt.event.*; import java.net.*; import java.util.*; import java.util.List; import javax.swing.*; import javax.swing.Timer; import javax.jnlp.*; import netx.jnlp.*; import netx.jnlp.runtime.*; /** * Show the progress of downloads. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.3 $ */ public class DefaultDownloadIndicator implements DownloadIndicator { // todo: rewrite this to cut down on size/complexity; smarter // panels (JList, renderer) understand resources instead of // nested panels and grid-bag mess. // todo: fix bug where user closes download box and it // never(?) reappears. // todo: UI for user to cancel/restart download // todo: this should be synchronized at some point but conflicts // aren't very likely. private static String downloading = JNLPRuntime.getMessage("CDownloading"); private static String complete = JNLPRuntime.getMessage("CComplete"); /** time to wait after completing but before window closes */ private static final int CLOSE_DELAY = 750; /** the display window */ private static JFrame frame; /** shared constraint */ static GridBagConstraints vertical; static GridBagConstraints verticalIndent; static { vertical = new GridBagConstraints(); vertical.gridwidth = GridBagConstraints.REMAINDER; vertical.weightx = 1.0; vertical.fill = GridBagConstraints.HORIZONTAL; vertical.anchor = GridBagConstraints.WEST; verticalIndent = (GridBagConstraints) vertical.clone(); verticalIndent.insets = new Insets(0, 10, 3, 0); } /** * Return the update rate. */ public int getUpdateRate() { return 150; //ms } /** * Return the initial delay before obtaining a listener. */ public int getInitialDelay() { return 300; //ms } /** * Return a download service listener that displays the progress * in a shared download info window. * * @param app the downloading application, or null if N/A * @param downloadName name identifying the download to the user * @param resources initial urls to display (not required) */ public DownloadServiceListener getListener(ApplicationInstance app, String downloadName, URL resources[]) { DownloadPanel result = new DownloadPanel(downloadName); if (frame == null) { frame = new JFrame(downloading+"..."); frame.getContentPane().setLayout(new GridBagLayout()); } if (resources != null) for (int i=0; i < resources.length; i++) result.addProgressPanel(resources[i], null); frame.getContentPane().add(result, vertical); frame.pack(); if (!frame.isVisible()) { Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); frame.setLocation(screen.width/2-frame.getWidth()/2, screen.height/2-frame.getHeight()/2); } frame.show(); return result; } /** * Remove a download service listener that was obtained by * calling the getDownloadListener method from the shared * download info window. */ public void disposeListener(final DownloadServiceListener listener) { if (!(listener instanceof DownloadPanel)) return; ActionListener hider = new ActionListener() { public void actionPerformed(ActionEvent evt) { if (frame.getContentPane().getComponentCount() == 1) frame.hide(); frame.getContentPane().remove((DownloadPanel) listener); frame.pack(); } }; Timer timer = new Timer(CLOSE_DELAY, hider); timer.setRepeats(false); timer.start(); } /** * Groups the url progress in a panel. */ static class DownloadPanel extends JPanel implements DownloadServiceListener { /** the download name */ private String downloadName; /** Downloading part: */ private JLabel header = new JLabel(); /** list of URLs being downloaded */ private List urls = new ArrayList(); /** list of ProgressPanels */ private List panels = new ArrayList(); /** * Create a new download panel for with the specified download * name. */ protected DownloadPanel(String downloadName) { setLayout(new GridBagLayout()); this.downloadName = downloadName; this.add(header, vertical); header.setFont(header.getFont().deriveFont(Font.BOLD)); setOverallPercent(0); } /** * Add a ProgressPanel for a URL. */ protected void addProgressPanel(URL url, String version) { if (!urls.contains(url)) { ProgressPanel panel = new ProgressPanel(url, version); add(panel, verticalIndent); frame.pack(); urls.add(url); panels.add(panel); } } /** * Update the download progress of a url. */ protected void update(final URL url, final String version, final long readSoFar, final long total, final int overallPercent) { Runnable r = new Runnable() { public void run() { if (!urls.contains(url)) addProgressPanel(url, version); setOverallPercent(overallPercent); ProgressPanel panel = (ProgressPanel) panels.get(urls.indexOf(url)); panel.setProgress(readSoFar, total); panel.repaint(); } }; SwingUtilities.invokeLater(r); } /** * Sets the overall percent completed. */ public void setOverallPercent(int percent) { // don't get whole string from resource and sub in // values because it'll be doing a MessageFormat for // each update. header.setText(downloading+" "+downloadName+": "+percent+"% "+complete+"."); } /** * Called when a download failed. */ public void downloadFailed(URL url, String version) { update(url, version, -1, -1, -1); } /** * Called when a download has progressed. */ public void progress(URL url, String version, long readSoFar, long total, int overallPercent) { update(url, version, readSoFar, total, overallPercent); } /** * Called when an archive is patched. */ public void upgradingArchive(URL url, String version, int patchPercent, int overallPercent) { update(url, version, patchPercent, 100, overallPercent); } /** * Called when a download is being validated. */ public void validating(URL url, String version, long entry, long total, int overallPercent) { update(url, version, entry, total, overallPercent); } }; /** * A progress bar with the URL next to it. */ static class ProgressPanel extends JPanel { private JPanel bar = new JPanel(); private long total; private long readSoFar; ProgressPanel(URL url, String version) { JLabel location = new JLabel(" "+url.getHost()+"/"+url.getFile()); bar.setMinimumSize(new Dimension(80,15)); bar.setPreferredSize(new Dimension(80,15)); bar.setOpaque(false); setLayout(new GridBagLayout()); GridBagConstraints gbc = new GridBagConstraints(); gbc.weightx = 0.0; gbc.fill = GridBagConstraints.NONE; gbc.gridwidth = GridBagConstraints.RELATIVE; add(bar, gbc); gbc.insets = new Insets(0, 3, 0, 0); gbc.weightx = 1.0; gbc.fill = GridBagConstraints.HORIZONTAL; gbc.gridwidth = GridBagConstraints.REMAINDER; gbc.anchor = GridBagConstraints.WEST; add(location, gbc); } public void setProgress(long readSoFar, long total) { this.readSoFar = readSoFar; this.total = total; } public void paintComponent(Graphics g) { super.paintComponent(g); int x = bar.getX(); int y = bar.getY(); int h = bar.getHeight(); int w = bar.getWidth(); if (readSoFar <= 0 || total <= 0) { // make barber pole } else { double progress = (double)readSoFar / (double)total; int divide = (int)(w * progress); g.setColor(Color.white); g.fillRect(x, y, w, h); g.setColor(Color.blue); g.fillRect(x+1, y+1, divide-1, h-1); } } }; } libnetx-java-0.5.orig/src/netx/jnlp/cache/DownloadIndicator.java 0000666 0001750 0001750 00000006611 07622737602 023052 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp.cache; import java.awt.*; import java.awt.event.*; import java.net.*; import java.util.*; import java.util.List; import javax.swing.*; import javax.swing.Timer; import javax.jnlp.*; import netx.jnlp.*; import netx.jnlp.runtime.*; /** * A DownloadIndicator creates DownloadServiceListeners that are * notified of resources being transferred and their progress. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.8 $ */ public interface DownloadIndicator { /** * Return a download service listener that displays the progress * of downloading resources. Update messages may be reported * for URLs that are not included initially.
* * Progress messages are sent as if the DownloadServiceListener * were listening to a DownloadService request. The listener * will receive progress messages from time to time during the * download.
* * @param app JNLP application downloading the files, or null if not applicable * @param downloadName name identifying the download to the user * @param resources initial urls to display, empty if none known at start */ public DownloadServiceListener getListener(ApplicationInstance app, String downloadName, URL resources[]); /** * Indicates that a download service listener that was obtained * from the getDownloadListener method will no longer be used. * This method can be used to ensure that progress dialogs are * properly removed once a particular download is finished. * * @param listener the listener that is no longer in use */ public void disposeListener(DownloadServiceListener listener); /** * Return the desired time in milliseconds between updates. * Updates are not guarenteed to occur based on this value; for * example, they may occur based on the download percent or some * other factor. * * @return rate in milliseconds, must be >= 0 */ public int getUpdateRate(); /** * Return a time in milliseconds to wait for a download to * complete before obtaining a listener for the download. This * value can be used to skip lengthy operations, such as * initializing a GUI, for downloads that complete quickly. The * getListener method is not called if the download completes * in less time than the returned delay. * * @return delay in milliseconds, must be >= 0 */ public int getInitialDelay(); } libnetx-java-0.5.orig/src/netx/jnlp/cache/package.html 0000666 0001750 0001750 00000001236 07617774060 021065 0 ustar god god
This package contains the JNLP cache.Package Specification
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see: libnetx-java-0.5.orig/src/netx/jnlp/cache/Resource.java 0000666 0001750 0001750 00000017651 07623442762 021244 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp.cache; import java.io.*; import java.net.*; import java.util.*; import netx.jnlp.*; import netx.jnlp.runtime.*; import netx.jnlp.util.*; /** * Information about a single resource to download. * This class tracks the downloading of various resources of a * JNLP file to local files. It can be used to download icons, * jnlp and extension files, jars, and jardiff files using the * version based protocol or any file using the basic download * protocol.* * Resources can be put into download groups by specifying a part * name for the resource. The resource tracker can also be * configured to prefetch resources, which are downloaded in the * order added to the media tracker.
* * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.9 $ */ public class Resource { // todo: fix resources to handle different versions // todo: IIRC, any resource is checked for being up-to-date // only once, regardless of UpdatePolicy. verify and fix. /** status bits */ public static final int UNINITIALIZED = 0; public static final int CONNECT = 1; public static final int CONNECTING = 2; public static final int CONNECTED = 4; public static final int DOWNLOAD = 8; public static final int DOWNLOADING = 16; public static final int DOWNLOADED = 32; public static final int ERROR = 64; public static final int STARTED = 128; // enqueued or being worked on /** list of weak references of resources currently in use */ private static WeakList resources = new WeakList(); /** weak list of trackers monitoring this resource */ private WeakList trackers = new WeakList(); /** the remote location of the resource */ URL location; /** the local file downloaded to */ File localFile; /** the requested version */ Version requestVersion; /** the version downloaded from server */ Version downloadVersion; /** connection to resource */ URLConnection connection; /** amount in bytes transferred */ long transferred = 0; /** total size of the resource, or -1 if unknown */ long size = -1; /** the status of the resource */ int status = UNINITIALIZED; /** * Create a resource. */ private Resource(URL location, Version requestVersion) { this.location = location; this.requestVersion = requestVersion; } /** * Return a shared Resource object representing the given * location and version. */ public static Resource getResource(URL location, Version requestVersion) { synchronized (resources) { Resource resource = new Resource(location, requestVersion); int index = resources.indexOf(resource); if (index >= 0) { // return existing object Resource result = (Resource) resources.get(index); if (result != null) return result; } resources.add(resource); resources.trimToSize(); return resource; } } /** * Returns the remote location of the resource. */ public URL getLocation() { return location; } /** * Returns the tracker that first created or monitored the * resource, or null if no trackers are monitoring the resource. */ ResourceTracker getTracker() { synchronized (trackers) { List t = trackers.hardList(); if (t.size() > 0) return (ResourceTracker) t.get(0); return null; } } /** * Returns true if any of the specified flags are set. */ public boolean isSet(int flag) { if (flag == UNINITIALIZED) return status == UNINITIALIZED; else return (status & flag) != 0; } /** * Returns a human-readable status string. */ private String getStatusString(int flag) { StringBuffer result = new StringBuffer(); if (flag == 0) result.append("<> "); if ((flag & CONNECT) != 0) result.append("CONNECT "); if ((flag & CONNECTING) != 0) result.append("CONNECTING "); if ((flag & CONNECTED) != 0) result.append("CONNECTED "); if ((flag & DOWNLOAD) != 0) result.append("DOWNLOAD "); if ((flag & DOWNLOADING) != 0) result.append("DOWNLOADING "); if ((flag & DOWNLOADED) != 0) result.append("DOWNLOADED "); if ((flag & ERROR) != 0) result.append("ERROR "); if ((flag & STARTED) != 0) result.append("STARTED "); return result.deleteCharAt(result.length()-1).toString(); } /** * Changes the status by clearing the flags in the first * parameter and setting the flags in the second. This method * is synchronized on this resource. */ public void changeStatus(int clear, int add) { int orig = 0; synchronized(this) { orig = status; this.status &= ~clear; this.status |= add; } if (JNLPRuntime.isDebug()) if (status != orig) { System.out.print("Status: "+getStatusString(status)); if ((status & ~orig) != 0) System.out.print(" +("+getStatusString(status & ~orig)+")"); if ((~status & orig) != 0) System.out.print(" -("+getStatusString(~status & orig)+")"); System.out.println(" @ "+location.getPath()); } } /** * Removes the tracker to the list of trackers monitoring this * resource. */ public void removeTracker(ResourceTracker tracker) { synchronized (trackers) { trackers.remove(tracker); trackers.trimToSize(); } } /** * Adds the tracker to the list of trackers monitoring this * resource. */ public void addTracker(ResourceTracker tracker) { synchronized (trackers) { List t = trackers.hardList(); // prevent GC between contains and add if (!t.contains(tracker)) trackers.add(tracker); trackers.trimToSize(); } } /** * Instructs the trackers monitoring this resource to fire a * download event. */ protected void fireDownloadEvent() { List send; synchronized (trackers) { send = trackers.hardList(); } for (int i=0; i < send.size(); i++) { ResourceTracker rt = (ResourceTracker) send.get(i); rt.fireDownloadEvent(this); } } public boolean equals(Object other) { if (other instanceof Resource) { // this prevents the URL handler from looking up the IP // address and doing name resolution; much faster so less // time spent in synchronized addResource determining if // Resource is already in a tracker, and better for offline // mode on some OS. return CacheUtil.urlEquals(location, ((Resource)other).location); } return false; } public String toString() { return "location="+location.toString() + " state="+getStatusString(status); } } libnetx-java-0.5.orig/src/netx/jnlp/cache/ResourceTracker.java 0000666 0001750 0001750 00000100050 07623741316 022537 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp.cache; import java.io.*; import java.net.*; import java.util.*; import netx.jnlp.*; import netx.jnlp.event.*; import netx.jnlp.runtime.*; import netx.jnlp.util.*; /** * This class tracks the downloading of various resources of a * JNLP file to local files in the cache. It can be used to * download icons, jnlp and extension files, jars, and jardiff * files using the version based protocol or any file using the * basic download protocol (jardiff and version not implemented * yet).
* * The resource tracker can be configured to prefetch resources, * which are downloaded in the order added to the media * tracker.
* * Multiple threads are used to download and cache resources that * are actively being waited for (blocking a caller) or those that * have been started downloading by calling the startDownload * method. Resources that are prefetched are downloaded one at a * time and only if no other trackers have requested downloads. * This allows the tracker to start downloading many items without * using many system resources, but still quickly download items * as needed.
* * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.22 $ */ public class ResourceTracker { // todo: use event listener arrays instead of lists // todo: see if there is a way to set the socket options just // for use by the tracker so checks for updates don't hang for // a long time. // todo: ability to restart/retry a hung download // todo: move resource downloading/processing code into Resource // class, threading stays in ResourceTracker // todo: get status method? and some way to convey error status // to the caller. // todo: might make a tracker be able to download more than one // version of a resource, but probably not very useful. // defines // ResourceTracker.Downloader (download threads) // separately locks on (in order of aquire order, ie, sync on prefetch never syncs on lock): // lock, prefetch, this.resources, each resource, listeners /** notified on initialization or download of a resource */ private static Object lock = new Integer(0); // used to lock static structures // shortcuts private static final int UNINITIALIZED = Resource.UNINITIALIZED; private static final int CONNECT = Resource.CONNECT; private static final int CONNECTING = Resource.CONNECTING; private static final int CONNECTED = Resource.CONNECTED; private static final int DOWNLOAD = Resource.DOWNLOAD; private static final int DOWNLOADING = Resource.DOWNLOADING; private static final int DOWNLOADED = Resource.DOWNLOADED; private static final int ERROR = Resource.ERROR; private static final int STARTED = Resource.STARTED; /** max threads */ private static final int maxThreads = 5; /** running threads */ private static int threads = 0; /** weak list of resource trackers with resources to prefetch */ private static WeakList prefetchTrackers = new WeakList(); /** resources requested to be downloaded */ private static ArrayList queue = new ArrayList(); /** resource trackers threads are working for (used for load balancing across multi-tracker downloads) */ private static ArrayList active = new ArrayList(); // /** the resources known about by this resource tracker */ private List resources = new ArrayList(); /** download listeners for this tracker */ private List listeners = new ArrayList(); /** whether to download parts before requested */ private boolean prefetch; /** * Creates a resource tracker that does not prefetch resources. */ public ResourceTracker() { this(false); } /** * Creates a resource tracker. * * @param prefetch whether to download resources before requested. */ public ResourceTracker(boolean prefetch) { this.prefetch = prefetch; if (prefetch) { synchronized (prefetchTrackers) { prefetchTrackers.add(this); prefetchTrackers.trimToSize(); } } } /** * Add a resource identified by the specified location and * version. The tracker only downloads one version of a given * resource per instance (ie cannot download both versions 1 and * 2 of a resource in the same tracker). * * @param location the location of the resource * @param version the resource version * @param updatePolicy whether to check for updates if already in cache */ public void addResource(URL location, Version version, UpdatePolicy updatePolicy) { if (location == null) throw new IllegalArgumentException("location==null"); Resource resource = Resource.getResource(location, version); boolean downloaded = false; synchronized (resources) { if (resources.contains(resource)) return; resource.addTracker(this); resources.add(resource); } // checkCache may take a while (loads properties file). this // should really be synchronized on resources, but the worst // case should be that the resource will be updated once even // if unnecessary. downloaded = checkCache(resource, updatePolicy); synchronized (lock) { if (!downloaded) if (prefetch && threads == 0) // existing threads do pre-fetch when queue empty startThread(); } } /** * Removes a resource from the tracker. This method is useful * to allow memory to be reclaimed, but calling this method is * not required as resources are reclaimed when the tracker is * collected. * * @throws IllegalArgumentException if the resource is not being tracked */ public void removeResource(URL location) { synchronized (resources) { Resource resource = getResource(location); if (resource != null) { resources.remove(resource); resource.removeTracker(this); } // should remove from queue? probably doesn't matter } } /** * Check the cache for a resource, and initialize the resource * as already downloaded if found.
* * @param updatePolicy whether to check for updates if already in cache * @return whether the resource are already downloaded */ private boolean checkCache(Resource resource, UpdatePolicy updatePolicy) { if (!CacheUtil.isCacheable(resource.location, resource.downloadVersion)) { // pretend that they are already downloaded; essentially // they will just 'pass through' the tracker as if they were // never added (for example, not affecting the total download size). synchronized (resource) { resource.changeStatus(0, DOWNLOADED|CONNECTED|STARTED); } fireDownloadEvent(resource); return true; } if (updatePolicy != UpdatePolicy.ALWAYS) { // save loading entry props file CacheEntry entry = new CacheEntry(resource.location, resource.downloadVersion); if (entry.isCached() && !updatePolicy.shouldUpdate(entry)) { if (JNLPRuntime.isDebug()) System.out.println("not updating: "+resource.location); synchronized (resource) { resource.localFile = CacheUtil.getCacheFile(resource.location, resource.downloadVersion); resource.size = resource.localFile.length(); resource.transferred = resource.localFile.length(); resource.changeStatus(0, DOWNLOADED|CONNECTED|STARTED); } fireDownloadEvent(resource); return true; } } // may or may not be cached, but check update when connection // is open to possibly save network communication time if it // has to be downloaded, and allow this call to return quickly return false; } /** * Adds the listener to the list of objects interested in * receivind DownloadEvents.
* * @param location the resource to add a callback for * @param runnable the runnable to call when resource is completed */ public void addDownloadListener(DownloadListener listener) { synchronized (listeners) { if (!listeners.contains(listener)) listeners.add(listener); } } /** * Removes a download listener. */ public void removeDownloadListener(DownloadListener listener) { synchronized (listeners) { listeners.remove(listener); } } /** * Fires the download event corresponding to the resource's * state. This method is typicall called by the Resource itself * on each tracker that is monitoring the resource. Do not call * this method with any locks because the listeners may call * back to this ResourceTracker. */ protected void fireDownloadEvent(Resource resource) { DownloadListener l[] = null; synchronized (listeners) { l = (DownloadListener[]) listeners.toArray(new DownloadListener[0]); } int status; synchronized (resource) { status = resource.status; } DownloadEvent event = new DownloadEvent(this, resource); for (int i=0; i < l.length; i++) { if (0 != ((ERROR|DOWNLOADED) & status)) l[i].downloadCompleted(event); else if (0 != (DOWNLOADING & status)) l[i].downloadStarted(event); else if (0 != (CONNECTING & status)) l[i].updateStarted(event); } } /** * Returns a URL pointing to the cached location of the * resource, or the resource itself if it is a non-cacheable * resource.
* * If the resource has not downloaded yet, the method will block * until it has been transferred to the cache.
* * @param location the resource location * @return the resource, or null if it could not be downloaded * @throws IllegalArgumentException if the resource is not being tracked * @see CacheUtil#isCacheable */ public URL getCacheURL(URL location) { try { File f = getCacheFile(location); if (f != null) return f.toURL(); } catch (MalformedURLException ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); } return location; } /** * Returns a file containing the downloaded resource. If the * resource is non-cacheable then null is returned unless the * resource is a local file (the original file is returned).
* * If the resource has not downloaded yet, the method will block * until it has been transferred to the cache.
* * @param location the resource location * @return a local file containing the resource, or null * @throws IllegalArgumentException if the resource is not being tracked * @see CacheUtil#isCacheable */ public File getCacheFile(URL location) { try { Resource resource = getResource(location); if (!resource.isSet(DOWNLOADED|ERROR)) waitForResource(location, 0); if (resource.isSet(ERROR)) return null; if (resource.localFile != null) return resource.localFile; if (location.getProtocol().equalsIgnoreCase("file")) { File file = new File(location.getFile()); if (file.exists()) return file; } return null; } catch (InterruptedException ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); return null; // need an error exception to throw } } /** * Returns an input stream that reads the contents of the * resource. For non-cacheable resources, an InputStream that * reads from the source location is returned. Otherwise the * InputStream reads the cached resource.
* * This method will block while the resource is downloaded to * the cache. * * @throws IOException if there was an error opening the stream * @throws IllegalArgumentException if the resource is not being tracked */ public InputStream getInputStream(URL location) throws IOException { try { Resource resource = getResource(location); if (!resource.isSet(DOWNLOADED|ERROR)) waitForResource(location, 0); if (resource.localFile != null) return new FileInputStream(resource.localFile); return resource.location.openStream(); } catch (InterruptedException ex) { throw new IOException("wait was interrupted"); } } /** * Wait for a group of resources to be downloaded and made * available locally. * * @param urls the resources to wait for * @param timeout the time in ms to wait before returning, 0 for no timeout * @return whether the resources downloaded before the timeout * @throws IllegalArgumentException if the resource is not being tracked */ public boolean waitForResources(URL urls[], long timeout) throws InterruptedException { Resource resources[] = new Resource[ urls.length ]; synchronized(resources) { // keep the lock so getResource doesn't have to aquire it each time for (int i=0; i < urls.length; i++) resources[i] = getResource(urls[i]); } if (resources.length > 0) return wait(resources, timeout); return true; } /** * Wait for a particular resource to be downloaded and made * available. * * @param location the resource to wait for * @param timeout the timeout, or 0 to wait until completed * @return whether the resource downloaded before the timeout * @throws InterruptedException if another thread interrupted the wait * @throws IllegalArgumentException if the resource is not being tracked */ public boolean waitForResource(URL location, long timeout) throws InterruptedException { return wait(new Resource[] { getResource(location) }, timeout); } /** * Returns the number of bytes downloaded for a resource. * * @param location the resource location * @return the number of bytes transferred * @throws IllegalArgumentException if the resource is not being tracked */ public long getAmountRead(URL location) { // not atomic b/c transferred is a long, but so what (each // byte atomic? so probably won't affect anything...) return getResource(location).transferred; } /** * Returns whether a resource is available for use (ie, can be * accessed with the getCacheFile method). * * @throws IllegalArgumentException if the resource is not being tracked */ public boolean checkResource(URL location) { return getResource(location).isSet(DOWNLOADED|ERROR); // isSet atomic } /** * Starts loading the resource if it is not already being * downloaded or already cached. Resources started downloading * using this method may download faster than those prefetched * by the tracker because the tracker will only prefetch one * resource at a time to conserve system resources. * * @return true if the resource is already downloaded (or an error occurred) * @throws IllegalArgumentException if the resource is not being tracked */ public boolean startResource(URL location) { Resource resource = getResource(location); return startResource(resource); } /** * Sets the resource status to connect and download, and * enqueues the resource if not already started. * * @return true if the resource is already downloaded (or an error occurred) * @throws IllegalArgumentException if the resource is not being tracked */ private boolean startResource(Resource resource) { boolean enqueue = false; synchronized (resource) { if (resource.isSet(ERROR)) return true; enqueue = !resource.isSet(STARTED); if (!resource.isSet(CONNECTED | CONNECTING)) resource.changeStatus(0, CONNECT|STARTED); if (!resource.isSet(DOWNLOADED | DOWNLOADING)) resource.changeStatus(0, DOWNLOAD|STARTED); if (!resource.isSet(DOWNLOAD|CONNECT)) enqueue = false; } if (enqueue) queueResource(resource); return !enqueue; } /** * Returns the number of total size in bytes of a resource, or * -1 it the size is not known. * * @param location the resource location * @return the number of bytes, or -1 * @throws IllegalArgumentException if the resource is not being tracked */ public long getTotalSize(URL location) { return getResource(location).size; // atomic } /** * Start a new download thread if there are not too many threads * already running.
* * Calls to this method should be synchronized on lock. */ protected void startThread() { if (threads < maxThreads) { threads++; Thread thread = new Thread(new Downloader()); thread.start(); } } /** * A thread is ending, called by the thread itself.
* * Calls to this method should be synchronized. */ private void endThread() { threads--; if (threads < 0) { // this should never happen but try to recover threads = 0; if (queue.size() > 0) // if any on queue make sure a thread is running startThread(); // look into whether this could create a loop throw new RuntimeException("tracker threads < 0"); } if (threads == 0) { synchronized (prefetchTrackers) { queue.trimToSize(); // these only accessed by threads so no sync needed active.clear(); // no threads so no trackers actively downloading active.trimToSize(); prefetchTrackers.trimToSize(); } } } /** * Add a resource to the queue and start a thread to download or * initialize it. */ private void queueResource(Resource resource) { synchronized (lock) { if (!resource.isSet(CONNECT|DOWNLOAD)) throw new IllegalArgumentException("Invalid resource state (resource: "+resource+")"); queue.add(resource); startThread(); } } /** * Process the resource by either downloading it or initializing * it. */ private void processResource(Resource resource) { boolean doConnect = false; boolean doDownload = false; synchronized (resource) { if (resource.isSet(CONNECTING)) doConnect = true; } if (doConnect) initializeResource(resource); synchronized (resource) { // return to queue if we just initalized but it still needs // to download (not cached locally / out of date) if (resource.isSet(DOWNLOAD)) // would be DOWNLOADING if connected before this method queueResource(resource); if (resource.isSet(DOWNLOADING)) doDownload = true; } if (doDownload) downloadResource(resource); } /** * Downloads an resource to a file. */ private void downloadResource(Resource resource) { resource.fireDownloadEvent(); // fire DOWNLOADING try { // create out second in case in does not exist InputStream in = new BufferedInputStream( resource.connection.getInputStream() ); OutputStream out = CacheUtil.getOutputStream(resource.location, resource.downloadVersion); byte buf[] = new byte[1024]; int rlen; while (-1 != (rlen = in.read(buf))) { resource.transferred += rlen; out.write(buf, 0, rlen); } in.close(); out.close(); resource.changeStatus(DOWNLOADING, DOWNLOADED); synchronized(lock) { lock.notifyAll(); // wake up wait's to check for completion } resource.fireDownloadEvent(); // fire DOWNLOADED } catch (Exception ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); resource.changeStatus(0, ERROR); synchronized(lock) { lock.notifyAll(); // wake up wait's to check for completion } resource.fireDownloadEvent(); // fire ERROR } } /** * Open a URL connection and get the content length and other * fields. */ private void initializeResource(Resource resource) { resource.fireDownloadEvent(); // fire CONNECTING try { File localFile = CacheUtil.getCacheFile(resource.location, resource.downloadVersion); // connect URLConnection connection = resource.location.openConnection(); // this won't change so should be okay unsynchronized int size = connection.getContentLength(); boolean current = CacheUtil.isCurrent(resource.location, resource.requestVersion, connection); synchronized(resource) { resource.localFile = localFile; resource.connection = connection; resource.size = size; resource.changeStatus(CONNECT|CONNECTING, CONNECTED); // check if up-to-date; if so set as downloaded if (current) resource.changeStatus(DOWNLOAD|DOWNLOADING, DOWNLOADED); } // update cache entry CacheEntry entry = new CacheEntry(resource.location, resource.requestVersion); if (!current) entry.initialize(connection); entry.setLastUpdated(System.currentTimeMillis()); entry.store(); synchronized(lock) { lock.notifyAll(); // wake up wait's to check for completion } resource.fireDownloadEvent(); // fire CONNECTED } catch (Exception ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); resource.changeStatus(0, ERROR); synchronized(lock) { lock.notifyAll(); // wake up wait's to check for completion } resource.fireDownloadEvent(); // fire ERROR } } /** * Pick the next resource to download or initialize. If there * are no more resources requested then one is taken from a * resource tracker with prefetch enabled.
* * The resource state is advanced before it is returned * (CONNECT->CONNECTING).
* * Calls to this method should be synchronized on lock.
* * @return the resource to initialize or download, or null */ private static Resource selectNextResource() { Resource result; // pick from queue result = selectByFlag(queue, CONNECT, ERROR); // connect but not error if (result == null) result = selectByFlag(queue, DOWNLOAD, ERROR|CONNECT|CONNECTING); // remove from queue if found if (result != null) queue.remove(result); // prefetch if nothing found so far and this is the last thread if (result == null && threads == 1) result = getPrefetch(); if (result == null) return null; synchronized (result) { if (result.isSet(CONNECT)) { result.changeStatus(CONNECT, CONNECTING); } else if (result.isSet(DOWNLOAD)) { // only download if *not* connecting, when done connecting // select next will pick up the download part. This makes // all requested connects happen before any downloads, so // the size is known as early as possible. result.changeStatus(DOWNLOAD, DOWNLOADING); } } return result; } /** * Returns the next resource to be prefetched before * requested.
* * Calls to this method should be synchronized on lock.
*/ private static Resource getPrefetch() { Resource result = null; Resource alternate = null; // first find one to initialize synchronized (prefetchTrackers) { for (int i=0; i < prefetchTrackers.size() && result == null; i++) { ResourceTracker tracker = (ResourceTracker) prefetchTrackers.get(i); if (tracker == null) continue; synchronized (tracker.resources) { result = selectByFlag(tracker.resources, UNINITIALIZED, ERROR); if (result == null && alternate == null) alternate = selectByFlag(tracker.resources, CONNECTED, ERROR|DOWNLOADED|DOWNLOADING|DOWNLOAD); } } } // if none to initialize, switch to download if (result == null) result = alternate; if (result == null) return null; synchronized (result) { ResourceTracker tracker = result.getTracker(); if (tracker == null) return null; // GC of tracker happened between above code and here // prevents startResource from putting it on queue since // we're going to return it. result.changeStatus(0, STARTED); tracker.startResource(result); } return result; } /** * Selects a resource from the source list that has the * specified flag set.
* * Calls to this method should be synchronized on lock and * source list.
*/ private static Resource selectByFlag(List source, int flag, int notflag) { Resource result = null; int score = Integer.MAX_VALUE; for (int i=0; i < source.size(); i++) { Resource resource = (Resource) source.get(i); boolean selectable = false; synchronized (resource) { if (resource.isSet(flag) && !resource.isSet(notflag)) selectable = true; } if (selectable) { int activeCount = 0; for (int j=0; j < active.size(); j++) if ((ResourceTracker)active.get(j) == resource.getTracker()) activeCount++; // try to spread out the downloads so that a slow host // won't monopolize the downloads if (activeCount < score) { result = resource; score = activeCount; } } } return result; } /** * Return the resource matching the specified URL. * * @throws IllegalArgumentException if the resource is not being tracked */ private Resource getResource(URL location) { synchronized (resources) { for (int i=0; i < resources.size(); i++) { Resource resource = (Resource) resources.get(i); if (CacheUtil.urlEquals(resource.location, location)) return resource; } } throw new IllegalArgumentException("Location does not specify a resource being tracked."); } /** * Wait for some resources. * * @param resources the resources to wait for * @param timeout the timeout, or 0 to wait until completed * @returns true if the resources were downloaded or had errors, * false if the timeout was reached * @throws InterruptedException if another thread interrupted the wait */ private boolean wait(Resource resources[], long timeout) throws InterruptedException { long startTime = System.currentTimeMillis(); // start them downloading / connecting in background for (int i=0; i < resources.length; i++) startResource(resources[i]); // wait for completion while (true) { boolean finished = true; synchronized (lock) { // check for completion for (int i=0; i < resources.length; i++) { synchronized (resources[i]) { if (!resources[i].isSet(DOWNLOADED | ERROR)) { finished = false; break; } } } if (finished) return true; // wait long waitTime = 0; if (timeout > 0) { waitTime = timeout - (System.currentTimeMillis()-startTime); if (waitTime <= 0) return false; } lock.wait(waitTime); } } } // inner classes /** * This class downloads and initializes the queued resources. */ class Downloader implements Runnable { Resource resource = null; public void run() { while (true) { synchronized (lock) { // remove from active list, used for load balancing if (resource != null) active.remove(resource.getTracker()); resource = selectNextResource(); if (resource == null) { endThread(); break; } // add to active list, used for load balancing active.add(resource.getTracker()); } try { processResource(resource); } catch (Exception ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); } } // should have a finally in case some exception is thrown by // selectNextResource(); } }; } libnetx-java-0.5.orig/src/netx/jnlp/cache/UpdatePolicy.java 0000666 0001750 0001750 00000005302 07622737602 022044 0 ustar god god // Copyright (C) 2002 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp.cache; import java.io.*; import java.net.*; import java.util.*; import java.lang.reflect.*; import java.security.*; import javax.jnlp.*; import netx.jnlp.*; import netx.jnlp.runtime.*; import netx.jnlp.util.*; /** * A policy that determines when a resource should be checked for * an updated version.
* * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.3 $ */ public class UpdatePolicy { // todo: implement session updating // todo: doesn't seem to work in the same JVM, probably because // Resource is being held by a tracker so it isn't collected; // then next time a tracker adds the resource even if // shouldUpdate==true it's state is already marked // CONNECTED|DOWNLOADED. Let the resource be collected or reset // to UNINITIALIZED. public static UpdatePolicy ALWAYS = new UpdatePolicy(0); public static UpdatePolicy SESSION = new UpdatePolicy(-1); public static UpdatePolicy NEVER = new UpdatePolicy(Long.MAX_VALUE); private long timeDiff = -1; /** * Create a new update policy; this policy always updates the * entry unless the shouldUpdate method is overridden. */ public UpdatePolicy() { } /** * Create an update policy that only checks a file for being * updated if it has not been checked for longer than the * specified time. * * @param timeDiff how long in ms until update needed */ public UpdatePolicy(long timeDiff) { this.timeDiff = timeDiff; } /** * Returns whether the resource should be checked for being * up-to-date. */ public boolean shouldUpdate(CacheEntry entry) { long updated = entry.getLastUpdated(); long current = System.currentTimeMillis(); if (current - updated >= timeDiff) return true; else return false; } } libnetx-java-0.5.orig/src/netx/jnlp/ComponentDesc.java 0000666 0001750 0001750 00000002341 07622737602 021140 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.net.*; import java.util.*; /** * The component-desc element. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.6 $ */ public class ComponentDesc { // this is for completeness and in case of changes to spec for components. /** * Create a component descriptor. */ public ComponentDesc() { } } libnetx-java-0.5.orig/src/netx/jnlp/DefaultLaunchHandler.java 0000666 0001750 0001750 00000007150 07624225570 022415 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import netx.jnlp.runtime.*; import netx.jnlp.util.*; import java.awt.*; import java.util.*; import javax.swing.*; /** * This default implementation shows prints the exception to * stdout and if not in headless mode displays the exception in a * dialog. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.1 $ */ public class DefaultLaunchHandler implements LaunchHandler { /** * Called when the application could not be launched due to a * fatal error, such as the inability to find the main class * or non-parseable XML. */ public void launchError(LaunchException exception) { printMessage(exception); } /** * Called when launching the application can not be launched * due to an error that is not fatal. For example a JNLP file * that is not strictly correct yet does not necessarily * prohibit the system from attempting to launch the * application. * * @return true if the launch should continue, false to abort */ public boolean launchWarning(LaunchException warning) { printMessage(warning); return true; } /** * Called when a security validation error occurs while * launching the application. * * @return true to allow the application to continue, false to stop it. */ public boolean validationError(LaunchException security) { printMessage(security); return true; } /** * Called when an application, applet, or installer has been * launched successfully (the main method or applet start method * returned normally). * * @param application the launched application instance */ public void launchCompleted(ApplicationInstance application) { // } /** * Print a message to stdout. */ protected void printMessage(LaunchException ex) { StringBuffer result = new StringBuffer(); result.append("netx: "); result.append(ex.getCategory()); if (ex.getSummary() != null) { result.append(": "); result.append(ex.getSummary()); } if (JNLPRuntime.isDebug()) { if (ex.getCause() != null) ex.getCause().printStackTrace(); else ex.printStackTrace(); } Throwable causes[] = ex.getCauses(); for (int i=0; i < causes.length; i++) { result.append(" ("); result.append(causes[i].getClass().getName()); result.append(" "); result.append(causes[i].getMessage()); result.append(")"); } System.out.println(result); } } libnetx-java-0.5.orig/src/netx/jnlp/event/ 0000777 0001750 0001750 00000000000 07625173272 016655 5 ustar god god libnetx-java-0.5.orig/src/netx/jnlp/event/ApplicationEvent.java 0000666 0001750 0001750 00000003143 07622737602 022766 0 ustar god god // Copyright (C) 2002 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp.event; import java.util.*; import netx.jnlp.*; import netx.jnlp.runtime.*; /** * This event is sent when an application is terminated. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.5 $ */ public class ApplicationEvent extends EventObject { /** the application instance */ private ApplicationInstance application; /** * Creates a launch event for the specified application * instance. * * @param source the application instance */ public ApplicationEvent(ApplicationInstance source) { super(source); this.application = source; } /** * Returns the application instance. */ public ApplicationInstance getApplication() { return application; } } libnetx-java-0.5.orig/src/netx/jnlp/event/ApplicationListener.java 0000666 0001750 0001750 00000002360 07622737602 023472 0 ustar god god // Copyright (C) 2002 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp.event; import java.util.*; /** * The listener that is notified when an application instance is * terminated. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.5 $ */ public interface ApplicationListener extends EventListener { /** * Invoked when the application is destroyed. */ public void applicationDestroyed(ApplicationEvent applicationEvent); } libnetx-java-0.5.orig/src/netx/jnlp/event/DownloadEvent.java 0000666 0001750 0001750 00000003640 07622737602 022274 0 ustar god god // Copyright (C) 2002 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp.event; import java.net.*; import java.util.*; import netx.jnlp.*; import netx.jnlp.cache.*; import netx.jnlp.runtime.*; /** * This event is sent during the launch of an * application. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.3 $ */ public class DownloadEvent extends EventObject { /** the tracker */ private ResourceTracker tracker; /** the resource */ private Resource resource; /** * Creates a launch event for the specified application * instance. * * @param source the resource tracker * @param resource the resource */ public DownloadEvent(ResourceTracker source, Resource resource) { super(source); this.tracker = source; this.resource = resource; } /** * Returns the tracker that owns the resource. */ public ResourceTracker getTracker() { return tracker; } /** * Returns the location of the resource being downloaded. */ public URL getResourceLocation() { return resource.getLocation(); } } libnetx-java-0.5.orig/src/netx/jnlp/event/DownloadListener.java 0000666 0001750 0001750 00000003301 07622737602 022772 0 ustar god god // Copyright (C) 2002 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp.event; import java.util.*; /** * The listener that is notified of the state of resources being * downloaded by a ResourceTracker. Events may be delivered on a * background thread, and the event methods should complete * quickly so that they do not slow down other downloading in * progress by tying up a thread. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.3 $ */ public interface DownloadListener extends EventListener { /** * Called when a resource is checked for being up-to-date. */ public void updateStarted(DownloadEvent downloadEvent); /** * Called when a download starts. */ public void downloadStarted(DownloadEvent downloadEvent); /** * Called when a download completed or there was an error. */ public void downloadCompleted(DownloadEvent downloadEvent); } libnetx-java-0.5.orig/src/netx/jnlp/event/package.html 0000666 0001750 0001750 00000001237 07617774060 021144 0 ustar god god
This package contains the JNLP events.Package Specification
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see: libnetx-java-0.5.orig/src/netx/jnlp/ExtensionDesc.java 0000666 0001750 0001750 00000010503 07623000774 021143 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.net.*; import java.util.*; import netx.jnlp.runtime.JNLPRuntime; /** * The extension element. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.8 $ */ public class ExtensionDesc { /** the extension name */ private String name; /** the required extension version */ private Version version; /** the location of the extension JNLP file */ private URL location; /** the JNLPFile the extension refers to */ private JNLPFile file; /** map from ext-part to local part */ private Map extToPart = new HashMap(); /** eager ext parts */ private List eagerExtParts = new ArrayList(); /** * Create an extention descriptor. * * @param name the extension name * @param version the required version of the extention JNLPFile * @param location the location of the extention JNLP file */ public ExtensionDesc(String name, Version version, URL location) { this.name = name; this.version = version; this.location = location; } /** * Adds an extension part to be downloaded when the specified * part of the main JNLP file is loaded. The extension part * will be downloaded before the application is launched if the * lazy value is false or the part is empty or null. * * @param extPart the part name in the extension file * @param part the part name in the main file * @param lazy whether to load the part before launching */ protected void addPart(String extPart, String part, boolean lazy) { extToPart.put(extPart, part); if (!lazy || part == null || part.length() == 0) eagerExtParts.add(extPart); } /** * Returns the parts in the extension JNLP file mapped to the * part of the main file. */ public String[] getExtensionParts(String thisPart) { return null; } /** * Returns the name of the extension. */ public String getName() { return name; } /** * Returns the required version of the extension JNLP file. */ public Version getVersion() { return version; } /** * Returns the location of the extension JNLP file. */ public URL getLocation() { return location; } /** * Resolves the extension by creating a JNLPFile from the file * specified by the extension's location property. * * @throws IOException if the extension JNLPFile could not be resolved. * @throws ParseException if the extension JNLPFile could not be * parsed or was not a component or installer descriptor. */ public void resolve() throws ParseException, IOException { if (file == null) { file = new JNLPFile(location); if (JNLPRuntime.isDebug()) System.out.println("Resolve: "+file.getInformation().getTitle()); // check for it being an extension descriptor if (!file.isComponent() && !file.isInstaller()) throw new ParseException(JNLPRuntime.getMessage("JInvalidExtensionDescriptor", new Object[] {name, location} )); } } /** * Returns a JNLPFile for the extension, or null if the JNLP * file has not been resolved. */ public JNLPFile getJNLPFile() { return file; } } libnetx-java-0.5.orig/src/netx/jnlp/IconDesc.java 0000666 0001750 0001750 00000006322 07622737602 020071 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.net.*; import java.util.*; /** * The icon element. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.8 $ */ public class IconDesc { /** default icon */ public static final Object DEFAULT = "default"; /** selected icon */ public static final Object SELECTED = "selected"; /** disabled icon */ public static final Object DISABLED = "disabled"; /** rollover icon */ public static final Object ROLLOVER = "rollover"; /** splash icon */ public static final Object SPLASH = "splash"; /** the location of the icon */ private URL location; /** the type of icon*/ private Object kind; /** the width, or -1 if unknown*/ private int width; /** the height, or -1 if unknown*/ private int height; /** the depth, or -1 if unknown*/ private int depth; /** the size, or -1 if unknown*/ private int size; /** * Creates an icon descriptor with the specified information. * * @param location the location of the icon * @param kind the type of icon * @param width the width, or -1 if unknown * @param height the height, or -1 if unknown * @param depth the depth, or -1 if unknown * @param size the size, or -1 if unknown */ IconDesc(URL location, Object kind, int width, int height, int depth, int size) { this.location = location; this.kind = kind; this.width = width; this.height = height; this.depth = depth; this.size = size; } /** * Returns the location of the icon. */ public URL getLocation() { return location; } /** * Returns the icon type. */ public Object getKind() { return kind; } /** * Returns the icon width or -1 if not specified in the * JNLPFile. */ public int getWidth() { return width; } /** * Returns the icon height or -1 if not specified in the * JNLPFile. */ public int getHeight() { return height; } /** * Returns the icon size or -1 if not specified in the JNLPFile. */ public int getSize() { return size; } /** * Returns the icon depth or -1 if not specified in the * JNLPFile. */ public int getDepth() { return depth; } } libnetx-java-0.5.orig/src/netx/jnlp/InformationDesc.java 0000666 0001750 0001750 00000015420 07622737602 021465 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.awt.Dimension; import java.net.*; import java.util.*; /** * The information element.* * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.9 $ */ public class InformationDesc { // There is an understanding between this class and the parser // that description and icon types are keyed by "icon-"+kind and // "description-"+kind, and that other types are keyed by their // specification name. /** one-line description */ public static final Object ONE_LINE= "oneline"; /** short description */ public static final Object SHORT= "short"; /** tooltip description */ public static final Object TOOLTIP= "tooltip"; /** default description */ public static final Object DEFAULT = "default"; /** the locales for the information */ private Locale locales[]; /** the data as list of key,value pairs */ private List info; /** the JNLPFile this information is for */ private JNLPFile jnlpFile; /** * Create an information element object. * * @param jnlpFile file that the information is for * @param locale the the information is for */ public InformationDesc(JNLPFile jnlpFile, Locale locales[]) { this.jnlpFile = jnlpFile; this.locales = locales; } /** * Returns the application's title. */ public String getTitle() { return (String) getItem("title"); } /** * Returns the application's vendor. */ public String getVendor() { return (String) getItem("vendor"); } /** * Returns the application's homepage. */ public URL getHomepage() { return (URL)getItem("homepage"); } /** * Returns the default description for the application. */ public String getDescription() { String result = getDescription(DEFAULT); // try to find any description if default is null if (result == null) result = getDescription(ONE_LINE); if (result == null) result = getDescription(SHORT); if (result == null) result = getDescription(TOOLTIP); return result; } /** * Returns the application's description of the specified type. * * @param kind one of Information.SHORT, Information.ONE_LINE, * Information.TOOLTIP, Information.DEFAULT */ public String getDescription(Object kind) { String result = (String) getItem("description-"+kind); if (result == null) return (String) getItem("description-"+DEFAULT); else return result; } /** * Returns the icons specified by the JNLP file. * * @param kind one of IconDesc.SELECTED, IconDesc.DISABLED, * IconDesc.ROLLOVER, IconDesc.SPLASH, IconDesc.DEFAULT * @return an array of zero of more IconDescs of the specified icon type */ public IconDesc[] getIcons(Object kind) { List icons = getItems("icon-"+kind); return (IconDesc[]) icons.toArray(new IconDesc[icons.size()]); }; /** * Returns the URL of the icon closest to the specified size and * kind. This method will not return an icon smaller than the * specified width and height unless there are no other icons * available. * * @param kind the kind of icon to get * @param width desired width of icon * @param height desired height of icon * @return the closest icon by size or null if no icons declared */ public URL getIconLocation(Object kind, int width, int height) { IconDesc icons[] = getIcons(kind); if (icons.length == 0) return null; IconDesc best = null; for (int i=0; i < icons.length; i++) { if (icons[i].getWidth() >= width && icons[i].getHeight() >= height) { if (best == null) best = icons[i]; if (icons[i].getWidth() <= best.getWidth() && // Use <= so last specified of icons[i].getHeight() <= best.getHeight()) // equivalent icons is chosen. best = icons[i]; } } if (best == null) best = icons[0]; return best.getLocation(); } /** * Returns the locales for the information. */ public Locale[] getLocales() { return locales; } /** * Returns the JNLPFile the information is for. */ public JNLPFile getJNLPFile() { return jnlpFile; } /** * Returns whether offline execution allowed. */ public boolean isOfflineAllowed() { return null != getItem("offline-allowed"); } /** * Returns whether the resources specified in the JNLP file may * be shared by more than one instance in the same JVM * (JNLP extension). This is an extension to the JNLP spec and * will always return false for standard JNLP files. */ public boolean isSharingAllowed() { return null != getItem("sharing-allowed"); } /** * Returns the last item matching the specified key. */ protected Object getItem(Object key) { List items = getItems(key); if (items.size() == 0) return null; else return items.get( items.size()-1 ); } /** * Returns all items matching the specified key. */ protected List getItems(Object key) { if (info == null) return Collections.EMPTY_LIST; List result = new ArrayList(); for (int i=0; i < info.size(); i+=2) if (info.get(i).equals(key)) result.add( info.get(i+1) ); return result; } /** * Add an information item (description, icon, etc) under a * specified key name. */ protected void addItem(String key, Object value) { if (info == null) info = new ArrayList(); info.add(key); info.add(value); } } libnetx-java-0.5.orig/src/netx/jnlp/InstallerDesc.java 0000666 0001750 0001750 00000002720 07622737602 021134 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.net.*; import java.util.*; /** * The installer-desc element. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.6 $ */ public class InstallerDesc { /** the main class name and package. */ private String mainClass; /** * Creates a installer descriptor. * * @param mainClass main class name and package */ public InstallerDesc(String mainClass) { this.mainClass = mainClass; } /** * Returns the main class name and package. */ public String getMainClass() { return mainClass; } } libnetx-java-0.5.orig/src/netx/jnlp/JARDesc.java 0000666 0001750 0001750 00000006634 07622737602 017623 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.net.*; import java.util.*; /** * The JAR element. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.6 $ */ public class JARDesc { /** the location of the JAR file */ private URL location; /** the required JAR versions, or null */ private Version version; /** the part name */ private String part; /** whether to load the JAR on demand */ private boolean lazy; /** whether the JAR contains the main class */ private boolean main; /** whether the JAR contains native libraries */ private boolean nativeJar; /** * Create a JAR descriptor. * * @param location the location of the JAR file * @param version the required JAR versions, or null * @param part the part name, or null * @param lazy whether to load the JAR on demand * @param main whether the JAR contains the main class * @param nativeJam whether the JAR contains native libraries */ public JARDesc(URL location, Version version, String part, boolean lazy, boolean main, boolean nativeJar) { this.location = location; this.version = version; this.part = part; this.lazy = lazy; this.main = main; this.nativeJar = nativeJar; } /** * Returns the URL of the JAR file. */ public URL getLocation() { return location; } /** * Returns the required version of the JAR file. */ public Version getVersion() { return version; } /** * Returns the part name, or null if not specified in the JNLP * file. */ public String getPart() { return part; } /** * Returns true if the JAR file contains native code * libraries. */ public boolean isNative() { return nativeJar; } // these both are included in case the spec adds a new value, // where !lazy would no longer imply eager. /** * Returns true if the JAR file should be downloaded before * starting the application. */ public boolean isEager() { return !lazy; } /** * Returns true if the JAR file should be downloaded on demand. */ public boolean isLazy() { return lazy; } /** * Returns true if the JNLP file defined this JAR as containing * the main class. If no JARs were defined as the main JAR then * the first JAR should be used to locate the main class. * * @see ResourcesDesc#getMainJAR */ public boolean isMain() { return main; } } libnetx-java-0.5.orig/src/netx/jnlp/JNLPFile.java 0000666 0001750 0001750 00000040512 07623004124 017727 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.net.*; import java.util.*; import netx.jnlp.cache.*; import netx.jnlp.runtime.*; /** * Provides methods to access the information in a Java Network * Launching Protocol (JNLP) file. The Java Network Launching * Protocol specifies in an XML file the information needed to * load, cache, and run Java code over the network and in a secure * environment.
* * This class represents the overall information about a JNLP file * from the jnlp element. Other information is accessed through * objects that represent the elements of a JNLP file * (information, resources, application-desc, etc). References to * these objects are obtained by calling the getInformation, * getResources, getSecurity, etc methods.
* * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.21 $ */ public class JNLPFile { // todo: save the update policy, then if file was not updated // then do not check resources for being updated. // // todo: make getLaunchInfo return a superclass that all the // launch types implement (can get codebase from it). // // todo: currently does not filter resources by jvm version. // private static String R(String key) { return JNLPRuntime.getMessage(key); } /** the location this JNLP file was created from */ private URL sourceLocation = null; /** the network location of this JNLP file */ private URL fileLocation; /** the URL used to resolve relative URLs in the file */ private URL codeBase; /** file version */ private Version fileVersion; /** spec version */ private Version specVersion; /** information */ private List info; /** resources */ private List resources; /** additional resources not in JNLP file (from command line) */ private ResourcesDesc sharedResources = new ResourcesDesc(this, null, null, null); /** the application description */ private Object launchType; /** the security descriptor */ private SecurityDesc security; /** the default OS */ private Locale defaultLocale = null; /** the default arch */ private String defaultOS = null; /** the default jvm */ private String defaultArch = null; { // initialize defaults if security allows try { defaultLocale = Locale.getDefault(); defaultOS = System.getProperty("os.name"); defaultArch = System.getProperty("os.arch"); } catch (SecurityException ex) { // null values will still work, and app can set defaults later } } /** * Create a JNLPFile from a URL. * * @param location the location of the JNLP file * @throws IOException if an IO exception occurred * @throws ParseException if the JNLP file was invalid */ public JNLPFile(URL location) throws IOException, ParseException { this(location, false); // not strict } /** * Create a JNLPFile from a URL checking for updates using the * default policy. * * @param location the location of the JNLP file * @param strict whether to enforce the spec when * @throws IOException if an IO exception occurred * @throws ParseException if the JNLP file was invalid */ public JNLPFile(URL location, boolean strict) throws IOException, ParseException { this(location, strict, JNLPRuntime.getDefaultUpdatePolicy()); } /** * Create a JNLPFile from a URL checking for updates using the * specified policy. * * @param location the location of the JNLP file * @param strict whether to enforce the spec when * @param policy the update policy * @throws IOException if an IO exception occurred * @throws ParseException if the JNLP file was invalid */ public JNLPFile(URL location, boolean strict, UpdatePolicy policy) throws IOException, ParseException { Node root = Parser.getRootNode(openURL(location, policy)); parse(root, strict, location); this.fileLocation = location; } /** * Create a JNLPFile from an input stream. * * @throws IOException if an IO exception occurred * @throws ParseException if the JNLP file was invalid */ public JNLPFile(InputStream input, boolean strict) throws ParseException { parse(Parser.getRootNode(input), strict, null); } /** * Create a JNLPFile from a character stream. * * @param input the stream * @param strict whether to enforce the spec when * @throws IOException if an IO exception occurred * @throws ParseException if the JNLP file was invalid */ private JNLPFile(Reader input, boolean strict) throws ParseException { // todo: now that we are using NanoXML we can use a Reader //parse(Parser.getRootNode(input), strict, null); } /** * Open the jnlp file URL from the cache if there, otherwise * download to the cache. Called from constructor. */ private static InputStream openURL(URL location, UpdatePolicy policy) throws IOException { if (location == null || policy == null) throw new IllegalArgumentException(R("NullParameter")); try { ResourceTracker tracker = new ResourceTracker(false); // no prefetch tracker.addResource(location, null/*version*/, policy); return tracker.getInputStream(location); } catch (Exception ex) { throw new IOException(ex.getMessage()); } } /** * Returns the JNLP specification versions supported. */ public static Version getSupportedVersions() { return Parser.getSupportedVersions(); } /** * Returns the JNLP file's title. This method returns the same * value as InformationDesc.getTitle(). */ public String getTitle() { return getInformation().getTitle(); } /** * Returns the JNLP file's network location as specified in the * JNLP file. */ public URL getSourceLocation() { return sourceLocation; } /** * Returns the location of the file parsed to create the JNLP * file, or null if it was not created from a URL. */ public URL getFileLocation() { return fileLocation; } /** * Returns the JNLP file's version. */ public Version getFileVersion() { return fileVersion; } /** * Returns the specification version required by the file. */ public Version getSpecVersion() { return specVersion; } /** * Returns the codebase URL for the JNLP file. */ public URL getCodeBase() { return codeBase; } /** * Returns the information section of the JNLP file as viewed * through the default locale. */ public InformationDesc getInformation() { return getInformation(defaultLocale); } /** * Returns the information section of the JNLP file as viewed * through the specified locale. */ public InformationDesc getInformation(final Locale locale) { return new InformationDesc(this, new Locale[] {locale}) { protected List getItems(Object key) { List result = new ArrayList(); for (int i=0; i < info.size(); i++) { InformationDesc infoDesc = (InformationDesc) info.get(i); if (localMatches(locale, infoDesc.getLocales())) if (localMatches(locale, infoDesc.getLocales())) result.addAll(infoDesc.getItems(key) ); } return result; } }; } /** * Returns the security section of the JNLP file. */ public SecurityDesc getSecurity() { return security; } /** * Returns the resources section of the JNLP file as viewed * through the default locale and the os.name and os.arch * properties. */ public ResourcesDesc getResources() { return getResources(defaultLocale, defaultOS, defaultArch); } /** * Returns the information section of the JNLP file for the * specified locale, os, and arch. */ public ResourcesDesc getResources(final Locale locale, final String os, final String arch) { return new ResourcesDesc(this, new Locale[] {locale}, new String[] {os}, new String[] {arch}) { public List getResources(Class launchType) { List result = new ArrayList(); for (int i=0; i < resources.size(); i++) { ResourcesDesc rescDesc = (ResourcesDesc) resources.get(i); if (localMatches(locale, rescDesc.getLocales()) && stringMatches(os, rescDesc.getOS()) && stringMatches(arch, rescDesc.getArch())) result.addAll(rescDesc.getResources(launchType) ); } result.addAll(sharedResources.getResources(launchType)); return result; } public void addResource(Object resource) { // todo: honor the current locale, os, arch values sharedResources.addResource(resource); } }; } /** * Returns an object of one of the following types: AppletDesc, * ApplicationDesc, InstallerDesc, and ComponentDesc. */ public Object getLaunchInfo() { return launchType; } /** * Returns the launch information for an applet. * * @throws UnsupportedOperationException if there is no applet information */ public AppletDesc getApplet() { if (!isApplet()) throw new UnsupportedOperationException(R("JNotApplet")); return (AppletDesc) launchType; } /** * Returns the launch information for an application. * * @throws UnsupportedOperationException if there is no application information */ public ApplicationDesc getApplication() { if (!isApplication()) throw new UnsupportedOperationException(R("JNotApplication")); return (ApplicationDesc) launchType; } /** * Returns the launch information for a component. * * @throws UnsupportedOperationException if there is no component information */ public ComponentDesc getComponent() { if (!isComponent()) throw new UnsupportedOperationException(R("JNotComponent")); return (ComponentDesc) launchType; } /** * Returns the launch information for an installer. * * @throws UnsupportedOperationException if there is no installer information */ public InstallerDesc getInstaller() { if (!isInstaller()) throw new UnsupportedOperationException(R("NotInstaller")); return (InstallerDesc) launchType; } /** * Returns whether the lauch descriptor describes an Applet. */ public boolean isApplet() { return launchType instanceof AppletDesc; } /** * Returns whether the lauch descriptor describes an Application. */ public boolean isApplication() { return launchType instanceof ApplicationDesc; } /** * Returns whether the lauch descriptor describes a Component. */ public boolean isComponent() { return launchType instanceof ComponentDesc; } /** * Returns whether the lauch descriptor describes an Installer. */ public boolean isInstaller() { return launchType instanceof InstallerDesc; } /** * Sets the default view of the JNLP file returned by * getInformation, getResources, etc. If unset, the defaults * are the properties os.name, os.arch, and the locale returned * by Locale.getDefault(). */ public void setDefaults(String os, String arch, Locale locale) { defaultOS = os; defaultArch = arch; defaultLocale = locale; } /** * Returns whether a locale is matched by one of more other * locales. Only the non-empty language, country, and variant * codes are compared; for example, a requested locale of * Locale("","","") would always return true. * * @param requested the local * @param available the available locales * @return true if requested matches any of available, or if * available is empty or null. */ private boolean localMatches(Locale requested, Locale available[]) { if (available == null || available.length == 0) return true; for (int i=0; i < available.length; i++) { String language = requested.getLanguage(); // "" but never null String country = requested.getCountry(); String variant = requested.getVariant(); if (!"".equals(language) && !language.equalsIgnoreCase(available[i].getLanguage())) continue; if (!"".equals(country) && !country.equalsIgnoreCase(available[i].getCountry())) continue; if (!"".equals(variant) && !variant.equalsIgnoreCase(available[i].getVariant())) continue; return true; } return false; } /** * Returns whether the string is a prefix for any of the strings * in the specified array. * * @param prefixStr the prefix string * @param available the strings to test * @return true if prefixStr is a prefix of any strings in * available, or if available is empty or null. */ private boolean stringMatches(String prefixStr, String available[]) { if (available == null || available.length == 0) return true; for (int i=0; i < available.length; i++) if (available[i] != null && available[i].startsWith(prefixStr)) return true; return false; } /** * Initialize the JNLPFile fields. Private because it's called * from the constructor. * * @param root the root node * @param strict whether to enforce the spec when * @param location the file location or null */ private void parse(Node root, boolean strict, URL location) throws ParseException { try { //if (location != null) // location = new URL(location, "."); // remove filename Parser parser = new Parser(this, location, root, strict, true); // true == allow extensions // JNLP tag information specVersion = parser.getSpecVersion(); fileVersion = parser.getFileVersion(); codeBase = parser.getCodeBase(); sourceLocation = parser.getFileLocation(); info = parser.getInfo(root); resources = parser.getResources(root, false); // false == not a j2se resources section launchType = parser.getLauncher(root); security = parser.getSecurity(root); } catch (ParseException ex) { throw ex; } catch (Exception ex) { if (JNLPRuntime.isDebug()) ex.printStackTrace(); throw new RuntimeException(ex.toString()); } } } libnetx-java-0.5.orig/src/netx/jnlp/JREDesc.java 0000666 0001750 0001750 00000006610 07622737602 017621 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.net.*; import java.util.*; /** * The J2SE element. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.5 $ */ public class JREDesc { /** the platform version or the product version if location is not null */ private Version version; /** the location of a JRE product or null */ private URL location; /** inital heap size */ private long initialHeapSize; /** maximum head size */ private long maximumHeapSize; /** list of ResourceDesc objects */ private List resources; /** * Create a JRE descriptor. * * @param version the platform version or the product version * if location is not null * @param location the location of a JRE product or null * @param initialHeapSize inital heap size * @param maximumHeadSize maximum head size * @param resources list of ResourceDesc objects */ public JREDesc(Version version, URL location, String initialHeapSize, String maximumHeapSize, List resources) { this.version = version; this.location = location; this.initialHeapSize = heapToLong(initialHeapSize); this.maximumHeapSize = heapToLong(maximumHeapSize); this.resources = resources; } /** * Returns the JRE version. Use isPlatformVersion to * determine if this version corresponds to a platform or * product version. */ public Version getVersion() { return version; } /** * Returns true if the JRE version is a Java platform version * (java.specification.version property) or false if it is a * product version (java.version property). */ public boolean isPlatformVersion() { return getLocation() == null; } /** * Returns the JRE version string. */ public URL getLocation() { return location; } /** * Returns the maximum heap size in bytes. */ public long getMaximumHeapSize() { return maximumHeapSize; } /** * Returns the initial heap size in bytes. */ public long getInitialHeapSize() { return initialHeapSize; } /** * Returns the resources defined for this JRE. */ public List getResourcesDesc() { return resources; } /** * Convert a heap size description string to a long value * indicating the heap min/max size. */ static private long heapToLong(String heapSize) { // need to implement for completeness even though not used in netx return -1; } } libnetx-java-0.5.orig/src/netx/jnlp/Launcher.java 0000666 0001750 0001750 00000045610 07624371066 020146 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.applet.*; import java.io.*; import java.net.*; import java.util.*; import java.security.*; import java.lang.reflect.*; import netx.jnlp.runtime.*; import netx.jnlp.util.*; import netx.jnlp.cache.*; /** * Launches JNLPFiles either in the foreground or background.
* * An optional LaunchHandler can be specified that is notified of * warning and error condition while launching and that indicates * whether a launch may proceed after a warning has occurred. If * specified, the LaunchHandler is notified regardless of whether * the file is launched in the foreground or background.
* * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.22 $ */ public class Launcher { // defines class Launcher.BgRunner, Launcher.TgThread /** shortcut for resources */ private static String R(String key) { return JNLPRuntime.getMessage(key); } /** shared thread group */ private static final ThreadGroup mainGroup = new ThreadGroup(R("LAllThreadGroup")); /** the handler */ private LaunchHandler handler = null; /** the update policy */ private UpdatePolicy updatePolicy = JNLPRuntime.getDefaultUpdatePolicy(); /** whether to create an AppContext (if possible) */ private boolean context = true; /** * Create a launcher with the runtime's default update policy * and launch handler. */ public Launcher() { this(null, null); if (handler == null) handler = JNLPRuntime.getDefaultLaunchHandler(); } /** * Create a launcher with the specified handler and the * runtime's default update policy. * * @param handler the handler to use or null for no handler. */ public Launcher(LaunchHandler handler) { this(handler, null); } /** * Create a launcher with an optional handler using the * specified update policy and launch handler. * * @param handler the handler to use or null for no handler. * @param policy the update policy to use or null for default policy. */ public Launcher(LaunchHandler handler, UpdatePolicy policy) { if (policy == null) policy = JNLPRuntime.getDefaultUpdatePolicy(); this.handler = handler; this.updatePolicy = policy; } /** * Sets the update policy used by launched applications. */ public void setUpdatePolicy(UpdatePolicy policy) { if (policy == null) throw new IllegalArgumentException(R("LNullUpdatePolicy")); this.updatePolicy = policy; } /** * Returns the update policy used when launching applications. */ public UpdatePolicy getUpdatePolicy() { return updatePolicy; } /** * Sets whether to launch the application in a new AppContext * (a separate event queue, look and feel, etc). If the * sun.awt.SunToolkit class is not present then this method * has no effect. The default value is true. */ public void setCreateAppContext(boolean context) { this.context = context; } /** * Returns whether applications are launched in their own * AppContext. */ public boolean isCreateAppContext() { return this.context; } /** * Launches a JNLP file by calling the launch method for the * appropriate file type. * * @param file the JNLP file to launch * @return the application instance * @throws LaunchException if an error occurred while launching (also sent to handler) */ public ApplicationInstance launch(JNLPFile file) throws LaunchException { TgThread tg = new TgThread(file); tg.start(); try { tg.join(); } catch (InterruptedException ex) { throw launchWarning(new LaunchException(file, ex, R("LSMinor"), R("LCSystem"), R("LThreadInterrupted"), R("LThreadInterruptedInfo"))); } if (tg.getException() != null) throw tg.getException(); // passed to handler when first created if (handler != null) handler.launchCompleted(tg.getApplication()); return tg.getApplication(); } /** * Launches a JNLP file by calling the launch method for the * appropriate file type. * * @param location the URL of the JNLP file to launch * @throws LaunchException if there was an exception * @return the application instance */ public ApplicationInstance launch(URL location) throws LaunchException { return launch(toFile(location)); } /** * Launches a JNLP file by calling the launch method for the * appropriate file type in a different thread. * * @param file the JNLP file to launch */ public void launchBackground(JNLPFile file) { BgRunner runner = new BgRunner(file, null); new Thread(runner).start(); } /** * Launches the JNLP file at the specified location in the * background by calling the launch method for its file type. * * @param location the location of the JNLP file */ public void launchBackground(URL location) { BgRunner runner = new BgRunner(null, location); new Thread(runner).start(); } /** * Launches the JNLP file in a new JVM instance. The launched * application's output is sent to the system out and it's * standard input channel is closed. * * @param file the JNLP file to launch * @throws LaunchException if there was an exception */ public void launchExternal(JNLPFile file) throws LaunchException { if (file.getSourceLocation() != null) launchExternal(file.getSourceLocation()); else if (file.getFileLocation() != null) launchExternal(file.getFileLocation()); else launchError(new LaunchException(file, null, R("LSFatal"), R("LCExternalLaunch"), R("LNullLocation"), R("LNullLocationInfo"))); } /** * Launches the JNLP file at the specified location in a new JVM * instance. The launched application's output is sent to the * system out and it's standard input channel is closed. * * @param location the URL of the JNLP file to launch * @throws LaunchException if there was an exception */ public void launchExternal(URL location) throws LaunchException { try { URL cs = Launcher.class.getProtectionDomain().getCodeSource().getLocation(); if (JNLPRuntime.isDebug()) System.out.println("netx.jar path: "+cs.getPath()); File netxFile = new File(cs.getPath()); if (!netxFile.exists()) throw launchError(new LaunchException(null, null, R("LSFatal"), R("LCExternalLaunch"), R("LNetxJarMissing"), R("LNetxJarMissingInfo"))); String command[] = { "javaw", "-jar", netxFile.toString(), "-jnlp", location.toString(), "-verbose", }; Process p = Runtime.getRuntime().exec(command); new StreamEater(p.getErrorStream()).start(); new StreamEater(p.getInputStream()).start(); p.getOutputStream().close(); } catch (NullPointerException ex) { throw launchError(new LaunchException(null, null, R("LSFatal"), R("LCExternalLaunch"), R("LNetxJarMissing"), R("LNetxJarMissingInfo"))); } catch (Exception ex) { throw launchError(new LaunchException(null, ex, R("LSFatal"), R("LCExternalLaunch"), R("LCouldNotLaunch"), R("LCouldNotLaunchInfo"))); } } /** * Returns the JNLPFile for the URL, with error handling. */ private JNLPFile toFile(URL location) throws LaunchException { try { JNLPFile file = null; try { file = new JNLPFile(location, true, updatePolicy); // strict } catch (ParseException ex) { file = new JNLPFile(location, false, updatePolicy); // only here if strict failed but lax did not fail LaunchException lex = launchWarning(new LaunchException(file, ex, R("LSMinor"), R("LCFileFormat"), R("LNotToSpec"), R("LNotToSpecInfo"))); if (lex != null) throw lex; } return file; } catch (Exception ex) { if (ex instanceof LaunchException) throw (LaunchException) ex; // already sent to handler when first thrown else // IO and Parse throw launchError(new LaunchException(null, ex, R("LSFatal"), R("LCReadError"), R("LCantRead"), R("LCantReadInfo"))); } } /** * Launches a JNLP application. This method should be called * from a thread in the application's thread group. */ protected ApplicationInstance launchApplication(JNLPFile file) throws LaunchException { if (!file.isApplication()) throw launchError(new LaunchException(file, null, R("LSFatal"), R("LCClient"), R("LNotApplication"), R("LNotApplicationInfo"))); try { ApplicationInstance app = createApplication(file); app.initialize(); String mainName = file.getApplication().getMainClass(); Class mainClass = app.getClassLoader().loadClass(mainName); Method main = mainClass.getDeclaredMethod("main", new Class[] {String[].class} ); String args[] = file.getApplication().getArguments(); // required to make some apps work right Thread.currentThread().setContextClassLoader(app.getClassLoader()); main.invoke(null, new Object[] { args } ); return app; } catch (LaunchException lex) { throw launchError(lex); } catch (Exception ex) { throw launchError(new LaunchException(file, ex, R("LSFatal"), R("LCLaunching"), R("LCouldNotLaunch"), R("LCouldNotLaunchInfo"))); } } /** * Launches a JNLP applet. This method should be called from a * thread in the application's thread group.
* * The enableCodeBase parameter adds the applet's codebase to * the locations searched for resources and classes. This can * slow down the applet loading but allows browser-style applets * that don't use JAR files exclusively to be run from a applet * JNLP file. If the applet JNLP file does not specify any * resources then the code base will be enabled regardless of * the specified value.
*
* @param file the JNLP file
* @param enableCodeBase whether to add the codebase URL to the classloader
*/
protected ApplicationInstance launchApplet(JNLPFile file, boolean enableCodeBase) throws LaunchException {
if (!file.isApplet())
throw launchError(new LaunchException(file, null, R("LSFatal"), R("LCClient"), R("LNotApplet"), R("LNotAppletInfo")));
try {
AppletInstance applet= createApplet(file, enableCodeBase);
applet.initialize();
applet.getAppletEnvironment().startApplet(); // this should be a direct call to applet instance
return applet;
}
catch (LaunchException lex) {
throw launchError(lex);
}
catch (Exception ex) {
throw launchError(new LaunchException(file, ex, R("LSFatal"), R("LCLaunching"), R("LCouldNotLaunch"), R("LCouldNotLaunchInfo")));
}
}
/**
* Launches a JNLP installer. This method should be called from
* a thread in the application's thread group.
*/
protected ApplicationInstance launchInstaller(JNLPFile file) throws LaunchException {
throw launchError(new LaunchException(file, null, R("LSFatal"), R("LCNotSupported"), R("LNoInstallers"), R("LNoInstallersInfo")));
}
/**
* Create an AppletInstance.
*
* @param enableCodeBase whether to add the code base URL to the classloader
*/
protected AppletInstance createApplet(JNLPFile file, boolean enableCodeBase) throws LaunchException {
try {
JNLPClassLoader loader = JNLPClassLoader.getInstance(file, updatePolicy);
if (enableCodeBase || file.getResources().getJARs().length == 0)
loader.enableCodeBase();
AppThreadGroup group = (AppThreadGroup) Thread.currentThread().getThreadGroup();
String appletName = file.getApplet().getMainClass();
Class appletClass = loader.loadClass(appletName);
Applet applet = (Applet) appletClass.newInstance();
AppletInstance appletInstance = new AppletInstance(file, group, loader, applet);
group.setApplication(appletInstance);
loader.setApplication(appletInstance);
return appletInstance;
}
catch (Exception ex) {
throw launchError(new LaunchException(file, ex, R("LSFatal"), R("CLInit"), R("LInitApplet"), R("LInitAppletInfo")));
}
}
/**
* Creates an Application.
*/
protected ApplicationInstance createApplication(JNLPFile file) throws LaunchException {
try {
JNLPClassLoader loader = JNLPClassLoader.getInstance(file, updatePolicy);
AppThreadGroup group = (AppThreadGroup) Thread.currentThread().getThreadGroup();
ApplicationInstance app = new ApplicationInstance(file, group, loader);
group.setApplication(app);
loader.setApplication(app);
return app;
}
catch (Exception ex) {
throw launchError(new LaunchException(file, ex, R("LSFatal"), R("CLInit"), R("LInitApplet"), R("LInitAppletInfo")));
}
}
/**
* Create a thread group for the JNLP file.
*/
protected AppThreadGroup createThreadGroup(JNLPFile file) {
return new AppThreadGroup(mainGroup, file.getTitle());
}
/**
* Send n launch error to the handler, if set, and also to the
* caller.
*/
private LaunchException launchError(LaunchException ex) {
if (handler != null)
handler.launchError(ex);
return ex;
}
/**
* Send a launch error to the handler, if set, and to the
* caller only if the handler indicated that the launch should
* continue despite the warning.
*
* @return an exception to throw if the launch should be aborted, or null otherwise
*/
private LaunchException launchWarning(LaunchException ex) {
if (handler != null)
if (!handler.launchWarning(ex))
// no need to destroy the app b/c it hasn't started
return ex; // chose to abort
return null; // chose to continue, or no handler
}
/**
* This runnable is used to call the appropriate launch method
* for the application, applet, or installer in its thread group.
*/
private class TgThread extends Thread { // ThreadGroupThread
private JNLPFile file;
private ApplicationInstance application;
private LaunchException exception;
TgThread(JNLPFile file) {
super(createThreadGroup(file), file.getTitle());
this.file = file;
}
public void run() {
try {
if (context)
new Reflect().invokeStatic("sun.awt.SunToolkit", "createNewAppContext");
if (file.isApplication())
application = launchApplication(file);
else if (file.isApplet())
application = launchApplet(file, true); // enable applet code base
else if (file.isInstaller())
application = launchInstaller(file);
else
throw launchError(new LaunchException(file, null, R("LSFatal"), R("LCClient"), R("LNotLaunchable"), R("LNotLaunchableInfo")));
}
catch (LaunchException ex) {
exception = ex;
}
}
public LaunchException getException() {
return exception;
}
public ApplicationInstance getApplication() {
return application;
}
};
/**
* This runnable is used by the launchBackground
* methods to launch a JNLP file from a separate thread.
*/
private class BgRunner implements Runnable {
private JNLPFile file;
private URL location;
BgRunner(JNLPFile file, URL location) {
this.file = file;
this.location = location;
}
public void run() {
try {
if (file != null)
launch(file);
if (location != null)
launch(location);
}
catch (LaunchException ex) {
// launch method communicates error conditions to the
// handler if it exists, otherwise we don't care because
// there's nothing that can be done about the exception.
}
}
};
/**
* This class reads the output from a launched process and
* writes it to stdout.
*/
private static class StreamEater extends Thread {
private InputStream stream;
StreamEater(InputStream stream) {
this.stream = new BufferedInputStream(stream);
}
public void run() {
try {
while (true) {
int c = stream.read();
if (c == -1)
break;
System.out.write(c);
}
}
catch (IOException ex) {
}
}
};
}
libnetx-java-0.5.orig/src/netx/jnlp/LaunchException.java 0000666 0001750 0001750 00000012156 07624371226 021473 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp;
import java.io.*;
import java.util.*;
import netx.jnlp.util.*;
/**
* Thrown when a JNLP application, applet, or installer could not
* be created.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.9 $
*/
public class LaunchException extends Exception {
/** the original exception */
private Throwable cause = null;
/** the file being launched */
private JNLPFile file;
/** the category of the exception */
private String category;
/** summary */
private String summary;
/** description of the action that was taking place */
private String description;
/** severity of the warning/error */
private String severity;
/**
* Creates a LaunchException without detail message.
*/
public LaunchException(JNLPFile file, Exception cause, String severity, String category, String summary, String description) {
super(severity + ": " + category + ": "+ summary);
this.file = file;
this.category = category;
this.summary = summary;
this.description = description;
this.severity = severity;
// replace with setCause when no longer 1.3 compatible
this.cause = cause;
}
/**
* Creates a LaunchException with a cause.
*/
public LaunchException(Throwable cause) {
this(cause.getMessage());
// replace with setCause when no longer 1.3 compatible
this.cause = cause;
}
/**
* Creates a LaunchException with a cause and detail message
*/
public LaunchException(String message, Throwable cause) {
this(message+": "+cause.getMessage());
// replace with setCause when no longer 1.3 compatible
this.cause = cause;
}
/**
* Constructs a LaunchException with the specified detail
* message.
*
* @param message the detail message
*/
public LaunchException(String message) {
super(message);
}
/**
* Returns the JNLPFile being launched.
*/
public JNLPFile getFile() {
return file;
}
/**
* Returns the category string, a short description of the
* exception suitable for displaying in a window title.
*/
public String getCategory() {
return category;
}
/**
* Returns a one-sentence summary of the problem.
*/
public String getSummary() {
return summary;
}
/**
* Return a description of the exception and the action being
* performed when the exception occurred.
*/
public String getDescription() {
return description;
}
/**
* Returns a short description of the severity of the problem.
*/
public String getSeverity() {
return severity;
}
/**
* Return the cause of the launch exception or null if there
* is no cause exception.
*/
public Throwable getCause() {
return cause;
}
/**
* Returns the causes for this exception. This method is
* useful on JRE 1.3 since getCause is not a standard method,
* and will be removed once netx no longer supports 1.3.
*/
public Throwable[] getCauses() {
ArrayList result = new ArrayList();
Reflect r = new Reflect();
Throwable cause = this.cause;
while (cause != null) {
result.add(cause);
cause = (Throwable) r.invoke(cause, "getCause");
}
return (Throwable[]) result.toArray(new Throwable[0]);
}
/**
* Print the stack trace and the cause exception (1.3
* compatible)
*/
public void printStackTrace(PrintStream stream) {
super.printStackTrace(stream);
if (cause != null) {
stream.println("Caused by: ");
cause.printStackTrace(stream);
}
}
/**
* Print the stack trace and the cause exception (1.3
* compatible)
*/
public void printStackTrace(PrintWriter stream) {
super.printStackTrace(stream);
if (cause != null) {
stream.println("Caused by: ");
cause.printStackTrace(stream);
}
}
}
libnetx-java-0.5.orig/src/netx/jnlp/LaunchHandler.java 0000666 0001750 0001750 00000004741 07624371366 021120 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp;
import netx.jnlp.runtime.*;
/**
* This optional interface is used to handle conditions that occur
* while launching JNLP applications, applets, and installers.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.9 $
*/
public interface LaunchHandler {
/**
* Called when the application could not be launched due to a
* fatal error, such as the inability to find the main class or
* non-parseable XML.
*/
public void launchError(LaunchException exception);
/**
* Called when launching the application can not be launched due
* to an error that is not fatal. For example a JNLP file that
* is not strictly correct yet does not necessarily prohibit the
* system from attempting to launch the application.
*
* @return true if the launch should continue, false to abort
*/
public boolean launchWarning(LaunchException warning);
/**
* Called when a security validation error occurs while
* launching the application.
*
* @return true to allow the application to continue, false to stop it.
*/
public boolean validationError(LaunchException security);
// this method will probably be replaced when real security
// controller is in place.
/**
* Called when an application, applet, or installer has been
* launched successfully (the main method or applet start method
* returned normally).
*
* @param application the launched application instance
*/
public void launchCompleted(ApplicationInstance application);
}
libnetx-java-0.5.orig/src/netx/jnlp/package.html 0000666 0001750 0001750 00000001471 07617774060 020023 0 ustar god god
Package Specification
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see: libnetx-java-0.5.orig/src/netx/jnlp/PackageDesc.java 0000666 0001750 0001750 00000005232 07622737602 020533 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.net.*; import java.util.*; /** * The package element. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.6 $ */ public class PackageDesc { /** the package name */ private String name; /** the part required by the package */ private String part; /** whether the package includes subpackages */ private boolean recursive; /** * Create a package descriptor. * * @param name the package name * @param part the part required by the package * @param recursive whether the package includes subpackages */ public PackageDesc(String name, String part, boolean recursive) { this.name = name; this.part = part; this.recursive = recursive; } /** * Returns whether the specified class is part of this package. * * @param className the fully qualified class name */ public boolean matches(String className) { // form 1: exact class if (name.equals(className)) return true; // form 2: package.* if (name.endsWith(".*")) { String pkName = name.substring(0, name.length()-1); if (className.startsWith(pkName)) { String postfix = className.substring(pkName.length()+1); if (recursive || -1 == postfix.indexOf(".")) return true; } } return false; } /** * Returns the package name. */ public String getName() { return name; } /** * Returns the part name. */ public String getPart() { return part; } /** * Returns whether subpackages should be matched by this * package. */ public boolean isRecursive() { return recursive; } } libnetx-java-0.5.orig/src/netx/jnlp/ParseException.java 0000666 0001750 0001750 00000005136 07623000720 021316 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.net.*; import java.util.*; /** * Thrown to indicate that an error has occurred while parsing a * JNLP file. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.7 $ */ public class ParseException extends Exception { // todo: add meaningful information, such as the invalid // element, parse position, etc. /** the original exception */ private Throwable cause = null; /** * Create a parse exception with the specified message. */ public ParseException(String message) { super(message); } /** * Create a parse exception with the specified message and * cause. */ public ParseException(String message, Throwable cause) { super(message); // replace with setCause when no longer 1.3 compatible this.cause = cause; } /** * Return the cause of the launch exception or null if there * is no cause exception. */ public Throwable getCause() { return cause; } /** * Print the stack trace and the cause exception (1.3 * compatible) */ public void printStackTrace(PrintStream stream) { super.printStackTrace(stream); if (cause != null) { stream.println("Caused by: "); cause.printStackTrace(stream); } } /** * Print the stack trace and the cause exception (1.3 * compatible) */ public void printStackTrace(PrintWriter stream) { super.printStackTrace(stream); if (cause != null) { stream.println("Caused by: "); cause.printStackTrace(stream); } } } libnetx-java-0.5.orig/src/netx/jnlp/Parser.java 0000666 0001750 0001750 00000107044 07623000774 017633 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM) // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package netx.jnlp; import java.io.*; import java.net.*; import java.util.*; //import javax.xml.parsers.*; // commented to use right Node //import org.w3c.dom.*; // class for using Tiny XML | NanoXML //import org.xml.sax.*; //import gd.xml.tiny.*; import nanoxml.*; import netx.jnlp.runtime.JNLPRuntime; /** * Contains methods to parse an XML document into a JNLPFile. * Implements JNLP specification version 1.0. * * @author Jon A. Maxwell (JAM) - initial author * @version $Revision: 1.13 $ */ class Parser { private static String R(String key) { return JNLPRuntime.getMessage(key); } private static String R(String key, Object p1) { return R(key, p1, null); } private static String R(String key, Object p1, Object p2) { return R(key, p1, p2, null); } private static String R(String key, Object p1, Object p2, Object p3) { return JNLPRuntime.getMessage(key, new Object[] { p1, p2, p3 }); } // defines netx.jnlp.Node class if using Tiny XML or Nano XML // Currently uses the Nano XML parse. Search for "SAX" or // "TINY" or "NANO" and uncomment those blocks and comment the // active ones (if any) to switch XML parsers. Also // (un)comment appropriate Node class at end of this file and // do a clean build. /** * Ensure consistent error handling. */ /* SAX static ErrorHandler errorHandler = new ErrorHandler() { public void error(SAXParseException exception) throws SAXParseException { //throw exception; } public void fatalError(SAXParseException exception) throws SAXParseException { //throw exception; } public void warning(SAXParseException exception) { System.err.println("XML parse warning:"); exception.printStackTrace(); } }; */ /** the supported JNLP file versions */ private static Version supportedVersions = new Version("1.0"); // fix: some descriptors need to use the jnlp file at a later // date and having file ref lets us pass it to their // constructors // /** the file reference */ private JNLPFile file; // do not use (uninitialized) /** the root node */ private Node root; /** the specification version */ private Version spec; /** the base URL that all hrefs are relative to */ private URL base; /** the codebase URL */ private URL codebase; /** the file URL */ private URL fileLocation; /** whether to throw errors on non-fatal errors. */ private boolean strict; // if strict==true parses a file with no error then strict==false should also /** whether to allow extensions to the JNLP specification */ private boolean allowExtensions; // true if extensions to JNLP spec are ok /** * Create a parser for the JNLP file. If the location * parameters is not null it is used as the default codebase * (does not override value of jnlp element's href * attribute).
*
* The root node may be normalized as a side effect of this
* constructor.
*
* @param file the (uninitialized) file reference
* @param base if codebase is not specified, a default base for relative URLs
* @param root the root node
* @param strict whether to enforce strict compliance with the JNLP spec
* @param allowExtensions whether to allow extensions to the JNLP spec
* @throws ParseException if the JNLP file is invalid
*/
public Parser(JNLPFile file, URL base, Node root, boolean strict, boolean allowExtensions) throws ParseException {
this.file = file;
this.root = root;
this.strict = strict;
this.allowExtensions = allowExtensions;
// ensure it's a JNLP node
if (root == null || !root.getNodeName().equals("jnlp"))
throw new ParseException(R("PInvalidRoot"));
// JNLP tag information
this.spec = getVersion(root, "spec", "1.0+");
this.codebase = addSlash(getURL(root, "codebase", base));
this.base = (codebase!=null) ? codebase : base; // if codebase not specified use default codebase
fileLocation = getURL(root, "href", this.base);
// ensure version is supported
if (!supportedVersions.matchesAny(spec))
throw new ParseException(R("PSpecUnsupported", supportedVersions));
// normalize the text nodes
root.normalize();
}
/**
* Return the JNLP specification versions supported.
*/
public static Version getSupportedVersions() {
return supportedVersions;
}
/**
* Returns the file version.
*/
public Version getFileVersion() {
return getVersion(root, "version", null);
}
/**
* Returns the file location.
*/
public URL getFileLocation() {
return fileLocation;
}
/**
* Returns the codebase.
*/
public URL getCodeBase() {
return codebase;
}
/**
* Returns the specification version.
*/
public Version getSpecVersion() {
return spec;
}
//
// This section loads the resources elements
//
/**
* Returns all of the ResourcesDesc elements under the specified
* node (jnlp or j2se).
*
* @param parent the parent node (either jnlp or j2se)
* @param j2se true if the resources are located under a j2se node
* @throws ParseException if the JNLP file is invalid
*/
public List getResources(Node parent, boolean j2se) throws ParseException {
List result = new ArrayList();
Node resources[] = getChildNodes(parent, "resources");
// ensure that there are at least one information section present
if (resources.length == 0 && !j2se)
throw new ParseException(R("PNoResources"));
// create objects from the resources sections
for (int i=0; i < resources.length; i++)
result.add(getResourcesDesc(resources[i], j2se));
return result;
}
/**
* Returns the ResourcesDesc element at the specified node.
*
* @param node the resources node
* @param j2se true if the resources are located under a j2se node
* @throws ParseException if the JNLP file is invalid
*/
public ResourcesDesc getResourcesDesc(Node node, boolean j2se) throws ParseException {
boolean mainFlag = false; // if found a main tag
// create resources
ResourcesDesc resources =
new ResourcesDesc(file,
getLocales(node),
splitString(getAttribute(node, "os", null)),
splitString(getAttribute(node, "arch", null)));
// step through the elements
Node child = node.getFirstChild();
while (child != null) {
String name = child.getNodeName();
// check for nativelib but no trusted environment
if ("nativelib".equals(name))
if (!isTrustedEnvironment())
throw new ParseException(R("PUntrustedNative"));
if ("j2se".equals(name)) {
if (getChildNode(root, "component-desc") != null)
if (strict)
throw new ParseException(R("PExtensionHasJ2SE"));
if (!j2se)
resources.addResource( getJRE(child) );
else
throw new ParseException(R("PInnerJ2SE"));
}
if ("jar".equals(name) || "nativelib".equals(name)) {
JARDesc jar = getJAR(child);
// check for duplicate main entries
if (jar.isMain()) {
if (mainFlag == true)
if (strict)
throw new ParseException(R("PTwoMains"));
mainFlag = true;
}
resources.addResource(jar);
}
if ("extension".equals(name))
resources.addResource( getExtension(child) );
if ("property".equals(name))
resources.addResource( getProperty(child) );
if ("package".equals(name))
resources.addResource( getPackage(child) );
child = child.getNextSibling();
}
return resources;
}
/**
* Returns the JRE element at the specified node.
*
* @param node the j2se node
* @throws ParseException if the JNLP file is invalid
*/
public JREDesc getJRE(Node node) throws ParseException {
Version version = getVersion(node, "version", null);
URL location = getURL(node, "href", base);
String initialHeap = getAttribute(node, "initial-heap-size", null);
String maxHeap = getAttribute(node, "max-heap-size", null);
List resources = getResources(node, true);
// require version attribute
getRequiredAttribute(node, "version", null);
return new JREDesc(version, location, initialHeap, maxHeap, resources);
}
/**
* Returns the JAR element at the specified node.
*
* @param node the jar or nativelib node
* @throws ParseException if the JNLP file is invalid
*/
public JARDesc getJAR(Node node) throws ParseException {
boolean nativeJar = "nativelib".equals(node.getNodeName());
URL location = getRequiredURL(node, "href", base);
Version version = getVersion(node, "version", null);
String part = getAttribute(node, "part", null);
boolean main = "true".equals(getAttribute(node, "main", "false"));
boolean lazy = "lazy".equals(getAttribute(node, "download", "eager"));
int size = Integer.parseInt(getAttribute(node, "size", "0"));
if (nativeJar && main)
if (strict)
throw new ParseException(R("PNativeHasMain"));
return new JARDesc(location, version, part, lazy, main, nativeJar);
}
/**
* Returns the Extension element at the specified node.
*
* @param node the extension node
* @throws ParseException if the JNLP file is invalid
*/
public ExtensionDesc getExtension(Node node) throws ParseException {
String name = getAttribute(node, "name", null);
Version version = getVersion(node, "version", null);
URL location = getRequiredURL(node, "href", base);
ExtensionDesc ext = new ExtensionDesc(name, version, location);
Node dload[] = getChildNodes(node, "ext-download");
for (int i=0; i < dload.length; i++) {
boolean lazy = "lazy".equals(getAttribute(node, "download", "eager"));
ext.addPart(getRequiredAttribute(node, "ext-part", null),
getAttribute(node, "part", null),
lazy);
}
return ext;
}
/**
* Returns the Property element at the specified node.
*
* @param node the property node
* @throws ParseException if the JNLP file is invalid
*/
public PropertyDesc getProperty(Node node) throws ParseException {
String name = getRequiredAttribute(node, "name", null);
String value = getRequiredAttribute(node, "value", "");
return new PropertyDesc(name, value);
}
/**
* Returns the Package element at the specified node.
*
* @param node the package node
* @throws ParseException if the JNLP file is invalid
*/
public PackageDesc getPackage(Node node) throws ParseException {
String name = getRequiredAttribute(node, "name", null);
String part = getRequiredAttribute(node, "part", "");
boolean recursive = getAttribute(node, "recursive", "false").equals("true");
return new PackageDesc(name, part, recursive);
}
//
// This section loads the information elements
//
/**
* Returns all of the information elements under the specified
* node.
*
* @param parent the parent node (jnlp)
* @throws ParseException if the JNLP file is invalid
*/
public List getInfo(Node parent) throws ParseException {
List result = new ArrayList();
Node info[] = getChildNodes(parent, "information");
// ensure that there are at least one information section present
if (info.length == 0)
throw new ParseException(R("PNoInfoElement"));
// create objects from the info sections
for (int i=0; i < info.length; i++)
result.add(getInformationDesc(info[i]));
return result;
}
/**
* Returns the information element at the specified node.
*
* @param node the information node
* @throws ParseException if the JNLP file is invalid
*/
public InformationDesc getInformationDesc(Node node) throws ParseException {
List descriptionsUsed = new ArrayList();
// locale
Locale locales[] = getLocales(node);
// create information
InformationDesc info = new InformationDesc(file, locales);
// step through the elements
Node child = node.getFirstChild();
while (child != null) {
String name = child.getNodeName();
if ("title".equals(name))
addInfo(info, child, null, getSpanText(child));
if ("vendor".equals(name))
addInfo(info, child, null, getSpanText(child));
if ("description".equals(name)) {
String kind = getAttribute(child, "kind", "default");
if (descriptionsUsed.contains(kind))
if (strict)
throw new ParseException(R("PTwoDescriptions", kind));
descriptionsUsed.add(kind);
addInfo(info, child, kind, getSpanText(child));
}
if ("homepage".equals(name))
addInfo(info, child, null, getRequiredURL(child, "href", base));
if ("icon".equals(name))
addInfo(info, child, getAttribute(child, "kind", "default"), getIcon(child));
if ("offline-allowed".equals(name))
addInfo(info, child, null, Boolean.TRUE);
if ("sharing-allowed".equals(name)) {
if (strict && !allowExtensions)
throw new ParseException(R("PSharing"));
addInfo(info, child, null, Boolean.TRUE);
}
child = child.getNextSibling();
}
return info;
}
/**
* Adds a key,value pair to the information object.
*
* @param info the information object
* @param node node name to be used as the key
* @param mod key name appended with "-"+mod if not null
* @param value the info object to add (icon or string)
*/
protected void addInfo(InformationDesc info, Node node, String mod, Object value) {
String modStr = (mod == null) ? "" : "-"+mod;
if (node == null)
return;
info.addItem(node.getNodeName()+modStr, value);
}
/**
* Returns the icon element at the specified node.
*
* @param node the icon node
* @throws ParseException if the JNLP file is invalid
*/
public IconDesc getIcon(Node node) throws ParseException {
int width = Integer.parseInt(getAttribute(node, "width", "-1"));
int height = Integer.parseInt(getAttribute(node, "height", "-1"));
int size = Integer.parseInt(getAttribute(node, "size", "-1"));
int depth = Integer.parseInt(getAttribute(node, "depth", "-1"));
URL location = getRequiredURL(node, "href", base);
Object kind = getAttribute(node, "kind", "default");
return new IconDesc(location, kind, width, height, depth, size);
}
//
// This section loads the security descriptor element
//
/**
* Returns the security descriptor element. If no security
* element was specified in the JNLP file then a SecurityDesc
* with applet permissions is returned.
*
* @param parent the parent node
* @throws ParseException if the JNLP file is invalid
*/
public SecurityDesc getSecurity(Node parent) throws ParseException {
Node nodes[] = getChildNodes(parent, "security");
// test for too many security elements
if (nodes.length > 1)
if (strict)
throw new ParseException(R("PTwoSecurity"));
Object type = SecurityDesc.SANDBOX_PERMISSIONS;
if (nodes.length == 0)
type = SecurityDesc.SANDBOX_PERMISSIONS;
else if (null != getChildNode(nodes[0], "all-permissions"))
type = SecurityDesc.ALL_PERMISSIONS;
else if (null != getChildNode(nodes[0], "j2ee-application-client-permissions"))
type = SecurityDesc.J2EE_PERMISSIONS;
else if (strict)
throw new ParseException(R("PEmptySecurity"));
if (base != null)
return new SecurityDesc(file, type, base.getHost());
else
return new SecurityDesc(file, type, null);
}
/**
* Returns whether the JNLP file requests a trusted execution
* environment.
*/
protected boolean isTrustedEnvironment() {
Node security = getChildNode(root, "security");
if (security != null)
if (getChildNode(security, "all-permissions") != null
|| getChildNode(security, "j2ee-application-client-permissions") != null)
return true;
return false;
}
//
// This section loads the launch descriptor element
//
/**
* Returns the launch descriptor element, either AppletDesc,
* ApplicationDesc, ComponentDesc, or InstallerDesc.
*
* @param parent the parent node
* @throws ParseException if the JNLP file is invalid
*/
public Object getLauncher(Node parent) throws ParseException {
// check for other than one application type
if (1 != getChildNodes(parent, "applet-desc").length
+ getChildNodes(parent, "application-desc").length
+ getChildNodes(parent, "component-desc").length
+ getChildNodes(parent, "installer-desc").length)
throw new ParseException(R("PTwoDescriptors"));
Node child = parent.getFirstChild();
while (child != null) {
String name = child.getNodeName();
if ("applet-desc".equals(name))
return getApplet(child);
if ("application-desc".equals(name))
return getApplication(child);
if ("component-desc".equals(name))
return getComponent(child);
if ("installer-desc".equals(name))
return getInstaller(child);
child = child.getNextSibling();
}
// not reached
return null;
}
/**
* Returns the applet descriptor.
*
* @throws ParseException if the JNLP file is invalid
*/
public AppletDesc getApplet(Node node) throws ParseException {
String name = getRequiredAttribute(node, "name", R("PUnknownApplet"));
String main = getRequiredAttribute(node, "main-class", null);
URL docbase = getURL(node, "documentbase", base);
Map paramMap = new HashMap();
int width = 0;
int height = 0;
try {
width = Integer.parseInt(getRequiredAttribute(node, "width", "100"));
height = Integer.parseInt(getRequiredAttribute(node, "height", "100"));
}
catch (NumberFormatException nfe) {
if (width <= 0)
throw new ParseException(R("PBadWidth"));
throw new ParseException(R("PBadWidth"));
}
// read params
Node params[] = getChildNodes(node, "param");
for (int i=0; i < params.length; i++) {
paramMap.put(getRequiredAttribute(params[i], "name", null),
getRequiredAttribute(params[i], "value", ""));
}
return new AppletDesc(name, main, docbase, width, height, paramMap);
}
/**
* Returns the application descriptor.
*
* @throws ParseException if the JNLP file is invalid
*/
public ApplicationDesc getApplication(Node node) throws ParseException {
String main = getAttribute(node, "main-class", null);
List argsList = new ArrayList();
// if (main == null)
// only ok if can be found in main jar file (can't check here but make a note)
// read parameters
Node args[] = getChildNodes(node, "argument");
for (int i=0; i < args.length; i++) {
//argsList.add( args[i].getNodeValue() );
//This approach was not finding the argument text
argsList.add( getSpanText(args[i]) );
}
String argStrings[] =
(String[]) argsList.toArray( new String[argsList.size()] );
return new ApplicationDesc(main, argStrings);
}
/**
* Returns the component descriptor.
*/
public ComponentDesc getComponent(Node node) {
return new ComponentDesc();
}
/**
* Returns the installer descriptor.
*/
public InstallerDesc getInstaller(Node node) {
String main = getAttribute(node, "main-class", null);
return new InstallerDesc(main);
}
// other methods
/**
* Returns an array of substrings seperated by spaces (spaces
* escaped with backslash do not separate strings). This method
* splits strings as per the spec except that it does replace
* escaped other characters with their own value.
*/
public String[] splitString(String source) {
if (source == null)
return new String[0];
List result = new ArrayList();
StringTokenizer st = new StringTokenizer(source, " ");
StringBuffer part = new StringBuffer();
while (st.hasMoreTokens()) {
part.setLength(0);
// tack together tokens joined by backslash
while (true) {
part.append(st.nextToken());
if (st.hasMoreTokens() && part.charAt(part.length()-1) == '\\')
part.setCharAt(part.length()-1, ' '); // join with the space
else
break; // bizarre while format gets \ at end of string right (no extra space added at end)
}
// delete \ quote chars
for (int i = part.length(); i-- > 0;) // sweet syntax for reverse loop
if (part.charAt(i) == '\\')
part.deleteCharAt(i--); // and skip previous char so \\ becomes \
result.add( part.toString() );
}
return (String[]) result.toArray(new String[result.size()] );
}
/**
* Returns the Locale object(s) from a node's locale attribute.
*
* @param node the node with a locale attribute
*/
public Locale[] getLocales(Node node) {
List locales = new ArrayList();
String localeParts[] =
splitString(getAttribute(node, "locale", ""));
for (int i=0; i < localeParts.length; i++) {
Locale l = getLocale( localeParts[i] );
if (l != null)
locales.add(l);
}
return (Locale[]) locales.toArray(new Locale[locales.size()] );
}
/**
* Returns a Locale from a single locale.
*
* @param locale the locale string
*/
public Locale getLocale(String localeStr) {
if (localeStr.length() < 2)
return null;
String language = localeStr.substring(0, 2);
String country = (localeStr.length()<5) ? "" : localeStr.substring(3, 5);
String variant = (localeStr.length()<7) ? "" : localeStr.substring(6, 8);
// null is not allowed n locale but "" is
return new Locale(language, country, variant);
}
// XML junk
/**
* Returns the implied text under a node, for example "text" in
* "
*
* @param node the node
* @param name the attribute containing an href
* @param base the base URL
* @throws ParseException if the JNLP file is invalid
*/
public URL getURL(Node node, String name, URL base) throws ParseException {
String href = getAttribute(node, name, null);
if (href == null)
return null; // so that code can throw an exception if attribute was required
try {
if (base == null)
return new URL(href);
else {
try {
return new URL(href);
}
catch (MalformedURLException ex) {
// is relative
}
URL result = new URL(base, href);
// check for going above the codebase
if (! result.toString().startsWith( base.toString()) )
if (strict)
throw new ParseException(R("PUrlNotInCodebase", node.getNodeName(), href, base));
return result;
}
}
catch (MalformedURLException ex) {
if (base == null)
throw new ParseException(R("PBadNonrelativeUrl", node.getNodeName(), href));
else
throw new ParseException(R("PBadRelativeUrl", node.getNodeName(), href, base));
}
}
/**
* Returns a Version from the specified attribute and default
* value.
*
* @param node the node
* @param name the attribute
* @param defaultValue default if no such attribute
* @return a Version, or null if no such attribute and default is null
*/
public Version getVersion(Node node, String name, String defaultValue) {
String version = getAttribute(node, name, defaultValue);
if (version == null)
return null;
else
return new Version(version);
}
/**
* Returns the same result as getAttribute except that if strict
* mode is enabled or the default value is null a parse
* exception is thrown instead of returning the default value.
*
* @param node the node
* @param name the attribute
* @param defaultValue default value
* @throws ParseException if the attribute does not exist or is empty
*/
public String getRequiredAttribute(Node node, String name, String defaultValue) throws ParseException {
String result = getAttribute(node, name, null);
if (result == null || result.length() == 0)
if (strict || defaultValue == null)
throw new ParseException(R("PNeedsAttribute", node.getNodeName(), name));
if (result == null)
return defaultValue;
else
return result;
}
/**
* Retuns an attribute or the specified defaultValue if there is
* no such attribute.
*
* @param node the node
* @param name the attribute
* @param defaultValue default if no such attribute
*/
public String getAttribute(Node node, String name, String defaultValue) {
// SAX
// String result = ((Element) node).getAttribute(name);
String result = node.getAttribute(name);
if (result == null || result.length()==0)
return defaultValue;
return result;
}
/**
* Return the root node from the XML document in the specified
* input stream.
*
* @throws ParseException if the JNLP file is invalid
*/
public static Node getRootNode(InputStream input) throws ParseException {
try {
/* SAX
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
factory.setNamespaceAware(true);
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setErrorHandler(errorHandler);
Document doc = builder.parse(input);
return doc.getDocumentElement();
*/
/* TINY
Node document = new Node(TinyParser.parseXML(input));
Node jnlpNode = getChildNode(document, "jnlp"); // skip comments
*/
/* NANO */
XMLElement xml = new XMLElement();
xml.parseFromReader(new InputStreamReader(input));
Node jnlpNode = new Node(xml);
return jnlpNode;
}
catch(Exception ex) {
throw new ParseException(R("PBadXML"), ex);
}
}
}
// this class makes assumptions on how parser calls methods (such
// as getFirstChild->getNextChild only called by a single loop at
// a time, so no need for an iterator).
/**
* This class converts the NanoXML's XMLElement nodes into the
* regular XML Node interface (for the methods used by Parser).
*/
/* NANO */
class Node {
private XMLElement xml;
private Node next;
private Node children[];
Node(XMLElement xml) {
this.xml = xml;
}
Node getFirstChild() {
if (children == null)
getChildNodes();
if (children.length == 0)
return null;
else
return children[0];
}
Node getNextSibling() {
return next;
}
void normalize() {
}
String getNodeValue() {
return xml.getContent();
}
Node[] getChildNodes() {
if (children == null) {
List list = new ArrayList();
for (Enumeration e = xml.enumerateChildren(); e.hasMoreElements();)
list.add( new Node((XMLElement)e.nextElement()) );
children = (Node[]) list.toArray( new Node[list.size()] );
for (int i=0; i < children.length-1; i++)
children[i].next = children[i+1];
}
return children;
}
String getAttribute(String name) {
return (String)xml.getAttribute(name);
}
String getNodeName() {
if (xml.getName() == null)
return "";
else
return xml.getName();
}
public String toString() {
return getNodeName();
}
}
/**
* This class converts the TinyXML's ParsedXML nodes into the
* regular XML Node interface (for the methods used by Parser).
*/
/* TINY
class Node {
private ParsedXML tinyNode;
private Node next;
private Node children[];
Node(ParsedXML tinyNode) {
this.tinyNode = tinyNode;
}
Node getFirstChild() {
if (children == null)
getChildNodes();
if (children.length == 0)
return null;
else
return children[0];
}
Node getNextSibling() {
return next;
}
void normalize() {
}
String getNodeValue() {
return tinyNode.getContent();
}
Node[] getChildNodes() {
if (children == null) {
List list = new ArrayList();
for (Enumeration e = tinyNode.elements(); e.hasMoreElements();) {
list.add( new Node((ParsedXML)e.nextElement()) );
}
children = (Node[]) list.toArray( new Node[list.size()] );
for (int i=0; i < children.length-1; i++)
children[i].next = children[i+1];
}
return children;
}
String getAttribute(String name) {
return tinyNode.getAttribute(name);
}
String getNodeName() {
if (tinyNode.getName() == null)
return "";
else
return tinyNode.getName();
}
public String toString() {
return getNodeName();
}
}
*/
libnetx-java-0.5.orig/src/netx/jnlp/PropertyDesc.java 0000666 0001750 0001750 00000003127 07622737602 021025 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp;
import java.io.*;
import java.net.*;
import java.util.*;
/**
* The property element.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.6 $
*/
public class PropertyDesc {
/** the key name */
private String key;
/** the value */
private String value;
/**
* Creates a property descriptor.
*
* @param key the key name
* @param value the value
*/
public PropertyDesc(String key, String value) {
this.key = key;
this.value = value;
}
/**
* Returns the property's key
*/
public String getKey() {
return key;
}
/**
* Returns the property's value
*/
public String getValue() {
return value;
}
}
libnetx-java-0.5.orig/src/netx/jnlp/resources/ 0000777 0001750 0001750 00000000000 07625173272 017546 5 ustar god god libnetx-java-0.5.orig/src/netx/jnlp/resources/default.jnlp 0000666 0001750 0001750 00000001132 07624412630 022045 0 ustar god god
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.7 $
*/
public class ResourcesDesc {
/** the locales of these resources */
private Locale locales[];
/** the OS for these resources */
private String os[];
/** the arch for these resources */
private String arch[];
/** the JNLPFile this information is for */
private JNLPFile jnlpFile;
/** list of jars, packages, properties, and extensions */
private List resources = new ArrayList(); // mixed list makes easier for lookup code
/**
* Create a representation of one information section of the
* JNLP File.
*
* @param jnlpFile JNLP file the resources are for
* @param locales the locales of these resources
* @param os the os of these resources
* @param arch the arch of these resources
*/
public ResourcesDesc(JNLPFile jnlpFile, Locale locales[], String os[], String arch[]) {
this.jnlpFile = jnlpFile;
this.locales = locales;
this.os = os;
this.arch = arch;
}
/**
* Returns the JVMs.
*/
public JREDesc[] getJREs() {
List resources = getResources(JREDesc.class);
return (JREDesc[]) resources.toArray( new JREDesc[resources.size()] );
}
/**
* Returns the main JAR for these resources. There first JAR
* is returned if no JARs are specified as the main JAR, and if
* there are no JARs defined then null is returned.
*/
public JARDesc getMainJAR() {
JARDesc jars[] = getJARs();
for (int i=0; i < jars.length; i++)
if (jars[i].isMain())
return jars[i];
if (jars.length > 0)
return jars[0];
else
return null;
}
/**
* Returns all of the JARs.
*/
public JARDesc[] getJARs() {
List resources = getResources(JARDesc.class);
return (JARDesc[]) resources.toArray( new JARDesc[resources.size()] );
}
/**
* Returns the JARs with the specified part name.
*
* @param partName the part name, null and "" equivalent
*/
public JARDesc[] getJARs(String partName) {
List resources = getResources(JARDesc.class);
for (int i = resources.size(); i-- > 0;) {
JARDesc jar = (JARDesc) resources.get(i);
if (!(""+jar.getPart()).equals(""+partName))
resources.remove(i);
}
return (JARDesc[]) resources.toArray( new JARDesc[resources.size()] );
}
/**
* Returns the Extensions.
*/
public ExtensionDesc[] getExtensions() {
List resources = getResources(ExtensionDesc.class);
return (ExtensionDesc[]) resources.toArray( new ExtensionDesc[resources.size()] );
}
/**
* Returns the Packages.
*/
public PackageDesc[] getPackages() {
List resources = getResources(PackageDesc.class);
return (PackageDesc[]) resources.toArray( new PackageDesc[resources.size()] );
}
/**
* Returns the Packages that match the specified class name.
*
* @param className the fully qualified class name
* @return the PackageDesc objects matching the class name
*/
public PackageDesc[] getPackages(String className) {
List resources = getResources(PackageDesc.class);
for (int i = resources.size(); i-- > 0;) {
PackageDesc pk = (PackageDesc) resources.get(i);
if (!pk.matches(className))
resources.remove(i);
}
return (PackageDesc[]) resources.toArray( new PackageDesc[resources.size()] );
}
/**
* Returns the Properties as a list.
*/
public PropertyDesc[] getProperties() {
List resources = getResources(PropertyDesc.class);
return (PropertyDesc[]) resources.toArray( new PropertyDesc[resources.size()] );
}
/**
* Returns the properties as a map.
*/
public Map getPropertiesMap() {
Properties properties = new Properties();
List resources = getResources(PropertyDesc.class);
for (int i=0; i < resources.size(); i++) {
PropertyDesc prop = (PropertyDesc) resources.get(i);
properties.put( prop.getKey(), prop.getValue() );
}
return properties;
}
/**
* Returns the os required by these resources, or null if no
* locale was specified in the JNLP file.
*/
public String[] getOS() {
return os;
}
/**
* Returns the architecture required by these resources, or null
* if no locale was specified in the JNLP file.
*/
public String[] getArch() {
return arch;
}
/**
* Returns the locale required by these resources, or null if no
* locale was specified in the JNLP file.
*/
public Locale[] getLocales() {
return locales;
}
/**
* Returns the JNLPFile the resources are for.
*/
public JNLPFile getJNLPFile() {
return jnlpFile;
}
/**
* Returns all resources of the specified type.
*/
public List getResources(Class type) {
List result = new ArrayList();
for (int i=0; i < resources.size(); i++)
if ( type.isAssignableFrom(resources.get(i).getClass()) )
result.add(resources.get(i));
return result;
}
/**
* Add a resource.
*/
public void addResource(Object resource) {
// if this is going to stay public it should probably take an
// interface instead of an Object
if (resource == null)
throw new IllegalArgumentException("null resource");
resources.add(resource);
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/ 0000777 0001750 0001750 00000000000 07625173272 017217 5 ustar god god libnetx-java-0.5.orig/src/netx/jnlp/runtime/AppletAudioClip.java 0000666 0001750 0001750 00000005414 07622737604 023107 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.net.*;
import java.io.*;
import java.applet.*;
import javax.sound.sampled.*;
// based on Deane Richan's AppletAudioClip
/**
* An applet audio clip using the javax.sound API.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.8 $
*/
public class AppletAudioClip implements AudioClip {
/** the clip */
private Clip clip;
/**
* Creates new AudioClip. If the clip cannot be opened no
* exception is thrown, instead the methods of the AudioClip
* return without performing any operations.
*
* @param location the clip location
*/
public AppletAudioClip(URL location) {
try {
AudioInputStream stream = AudioSystem.getAudioInputStream(location);
clip = (Clip) AudioSystem.getLine(new Line.Info(Clip.class));
clip.open(stream);
}
catch (Exception ex) {
System.err.println("Error loading sound:"+location.toString());
clip = null;
}
}
/**
* Plays the clip in a continuous loop until the stop method is
* called.
*/
public void loop() {
if (clip == null)
return;
clip.loop(Clip.LOOP_CONTINUOUSLY);
}
/**
* Plays the clip from the beginning.
*/
public void play() {
if (clip == null)
return;
// applet audio clip resets to beginning when played again
clip.stop();
clip.setFramePosition(0);
clip.start();
}
/**
* Stops playing the clip.
*/
public void stop() {
if (clip == null)
return;
clip.stop();
}
/**
* Stops playing the clip and disposes it; the clip cannot be
* played after being disposed.
*/
void dispose() {
if (clip != null) {
clip.stop();
clip.flush();
clip.close();
}
clip = null;
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/AppletEnvironment.java 0000666 0001750 0001750 00000020363 07623004234 023525 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.List;
import java.net.*;
import java.io.*;
import javax.swing.*;
import netx.jnlp.*;
import netx.jnlp.util.*;
/**
* The applet environment including stub, context, and frame. The
* default environment puts the applet in a non-resiable frame;
* this can be changed by obtaining the frame and setting it
* resizable.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.12 $
*/
public class AppletEnvironment implements AppletContext, AppletStub {
/** the JNLP file */
private JNLPFile file;
/** the applet instance */
private AppletInstance appletInstance;
/** the applet */
private Applet applet;
/** the parameters */
private Map parameters;
/** the applet frame */
private Frame frame;
/** weak references to the audio clips */
private WeakList weakClips = new WeakList();
/** whether the applet has been started / displayed */
private boolean appletStarted = false;
/** whether the applet has been destroyed */
private boolean destroyed = false;
/**
* Create a new applet environment for the applet specified by
* the JNLP file.
*/
public AppletEnvironment(JNLPFile file, final AppletInstance appletInstance) {
this.file = file;
this.appletInstance = appletInstance;
this.applet = appletInstance.getApplet();
parameters = file.getApplet().getParameters();
frame = new Frame(file.getApplet().getName() + " - Applet");
frame.setResizable(false);
appletInstance.addWindow(frame);
// may not need this once security manager can close windows
// that do not have app code on the stack
WindowListener closer = new WindowAdapter() {
public void windowClosing(WindowEvent event) {
appletInstance.destroy();
System.exit(0);
}
};
frame.addWindowListener(closer);
}
/**
* Checks whether the applet has been destroyed, and throws an
* IllegalStateException if the applet has been destroyed of.
*
* @throws IllegalStateException
*/
private void checkDestroyed() {
if (destroyed)
throw new IllegalStateException("Illegal applet stub/context access: applet destroyed.");
}
/**
* Disposes the applet's resources and disables the applet
* environment from further use; after calling this method the
* applet stub and context methods throw IllegalStateExceptions.
*/
public void destroy() {
destroyed = true;
List clips = weakClips.hardList();
for (int i = 0; i < clips.size(); i++) {
((AppletAudioClip)clips.get(i)).dispose();
}
}
/**
* Returns the frame that contains the applet. Disposing this
* frame will destroy the applet.
*/
public Frame getAppletFrame() {
return frame;
}
/**
* Initialize, start, and show the applet.
*/
public void startApplet() {
checkDestroyed();
if (appletStarted)
return;
appletStarted = true;
try {
AppletDesc appletDesc = file.getApplet();
applet.setStub(this);
frame.setLayout(new BorderLayout());
frame.add(applet);
frame.validate();
frame.pack(); // cause insets to be calculated
Insets insets = frame.getInsets();
frame.setSize(appletDesc.getWidth() + insets.left + insets.right,
appletDesc.getHeight() + insets.top + insets.bottom);
// do first because some applets need to be displayed before
// starting (they use Component.getImage or something)
frame.show();
applet.init();
applet.start();
frame.invalidate(); // this should force the applet to
frame.validate(); // the correct size and to repaint
frame.repaint();
}
catch (Exception ex) {
if (JNLPRuntime.isDebug())
ex.printStackTrace();
// should also kill the applet?
}
}
// applet context methods
/**
* Returns the applet if the applet's name is specified,
* otherwise return null.
*/
public Applet getApplet(String name) {
checkDestroyed();
if (name != null && name.equals(file.getApplet().getName()))
return applet;
else
return null;
}
/**
* Returns an enumeration that contains only the applet
* from the JNLP file.
*/
public Enumeration getApplets() {
checkDestroyed();
return Collections.enumeration( Arrays.asList(new Applet[] { applet }) );
}
/**
* Returns an audio clip.
*/
public AudioClip getAudioClip(URL location) {
checkDestroyed();
AppletAudioClip clip = new AppletAudioClip(location);
weakClips.add(clip);
weakClips.trimToSize();
return clip;
}
/**
* Return an image loaded from the specified location.
*/
public Image getImage(URL location) {
checkDestroyed();
//return Toolkit.getDefaultToolkit().createImage(location);
Image image = (new ImageIcon(location)).getImage();
return image;
}
/**
* Not implemented yet.
*/
public void showDocument(java.net.URL uRL) {
checkDestroyed();
}
/**
* Not implemented yet.
*/
public void showDocument(java.net.URL uRL, java.lang.String str) {
checkDestroyed();
}
/**
* Not implemented yet.
*/
public void showStatus(java.lang.String str) {
checkDestroyed();
}
/**
* Required for JRE1.4, but not implemented yet.
*/
public void setStream(String key, InputStream stream) {
checkDestroyed();
}
/**
* Required for JRE1.4, but not implemented yet.
*/
public InputStream getStream(String key) {
checkDestroyed();
return null;
}
/**
* Required for JRE1.4, but not implemented yet.
*/
public Iterator getStreamKeys() {
checkDestroyed();
return null;
}
// stub methods
public void appletResize(int width, int height) {
checkDestroyed();
Insets insets = frame.getInsets();
frame.setSize(width + insets.left + insets.right,
height + insets.top + insets.bottom);
}
public AppletContext getAppletContext() {
checkDestroyed();
return this;
}
public URL getCodeBase() {
checkDestroyed();
return file.getCodeBase();
}
public URL getDocumentBase() {
checkDestroyed();
return file.getApplet().getDocumentBase();
}
public String getParameter(String name) {
checkDestroyed();
return (String) parameters.get(name);
}
public boolean isActive() {
checkDestroyed();
// it won't be started or stopped, so if it can call it's running
return true;
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/AppletInstance.java 0000666 0001750 0001750 00000006424 07623004234 022767 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.applet.*;
import java.awt.*;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.List;
import java.security.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import netx.jnlp.*;
/**
* Represents a launched application instance created from a JNLP
* file. This class does not control the operation of the applet,
* use the AppletEnvironment class to start and stop the applet.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.9 $
*/
public class AppletInstance extends ApplicationInstance {
/** whether the applet's stop and destroy methods have been called */
private boolean appletStopped = false;
/** the applet */
private Applet applet;
/** the applet environment */
private AppletEnvironment environment;
/**
* Create a New Task based on the Specified URL
*/
public AppletInstance(JNLPFile file, ThreadGroup group, ClassLoader loader, Applet applet) {
super(file, group, loader);
this.applet = applet;
this.environment = new AppletEnvironment(file, this);
}
/**
* Sets whether the applet is resizable or not. Applets default
* to being not resizable.
*/
public void setResizable(boolean resizable) {
environment.getAppletFrame().setResizable(resizable);
}
/**
* Returns whether the applet is resizable.
*/
public boolean isResizable() {
return environment.getAppletFrame().isResizable();
}
/**
* Returns the application title.
*/
public String getTitle() {
return getJNLPFile().getApplet().getName();
}
/**
* Returns the applet environment.
*/
public AppletEnvironment getAppletEnvironment() {
return environment;
}
/**
* Returns the applet.
*/
public Applet getApplet() {
return applet;
}
/**
* Stop the application and destroy its resources.
*/
public void destroy() {
if (appletStopped)
return;
appletStopped = true;
try {
applet.stop();
applet.destroy();
}
catch (Exception ex) {
if (JNLPRuntime.isDebug())
ex.printStackTrace();
}
environment.destroy();
super.destroy();
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/ApplicationInstance.java 0000666 0001750 0001750 00000015363 07624373142 024017 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.awt.*;
import java.util.*;
import java.util.List;
import java.security.*;
import javax.swing.event.EventListenerList;
import netx.jnlp.*;
import netx.jnlp.event.*;
import netx.jnlp.util.*;
/**
* Represents a running instance of an application described in a
* JNLPFile. This class provides a way to track the application's
* resources and destroy the application.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.15 $
*/
public class ApplicationInstance {
// todo: should attempt to unload the environment variables
// installed by the application.
/** the file */
private JNLPFile file;
/** the thread group */
private ThreadGroup group;
/** the classloader */
private ClassLoader loader;
/** whether the application has stopped running */
private boolean stopped = false;
/** weak list of windows opened by the application */
private WeakList weakWindows = new WeakList();
/** list of application listeners */
private EventListenerList listeners = new EventListenerList();
/**
* Create an application instance for the file.
*/
public ApplicationInstance(JNLPFile file, ThreadGroup group, ClassLoader loader) {
this.file = file;
this.group = group;
this.loader = loader;
}
/**
* Add an Application listener
*/
public void addApplicationListener(ApplicationListener listener) {
listeners.add(ApplicationListener.class, listener);
}
/**
* Remove an Application Listener
*/
public void removeApplicationListener(ApplicationListener listener) {
listeners.remove(ApplicationListener.class, listener);
}
/**
* Notify listeners that the application has been terminated.
*/
protected void fireDestroyed() {
Object list[] = listeners.getListenerList();
ApplicationEvent event = null;
for (int i=list.length-1; i>0; i-=2) { // last to first required
if (event == null)
event = new ApplicationEvent(this);
((ApplicationListener)list[i]).applicationDestroyed(event);
}
}
/**
* Initialize the application's environment (installs
* environment variables, etc).
*/
public void initialize() {
installEnvironment();
}
/**
* Releases the application's resources before it is collected.
* Only collectable if classloader and thread group are
* also collectable so basically is almost never called (an
* application would have to close its windows and exit its
* threads but not call System.exit).
*/
public void finalize() {
destroy();
}
/**
* Install the environment variables.
*/
void installEnvironment() {
final PropertyDesc props[] = file.getResources().getProperties();
PrivilegedAction installProps = new PrivilegedAction() {
public Object run() {
for (int i=0; i < props.length; i++) {
System.setProperty(props[i].getKey(), props[i].getValue());
}
return null;
}
};
AccessController.doPrivileged(installProps);
}
/**
* Returns the JNLP file for this task.
*/
public JNLPFile getJNLPFile() {
return file;
}
/**
* Returns the application title.
*/
public String getTitle() {
return file.getTitle();
}
/**
* Returns whether the application is running.
*/
public boolean isRunning() {
return !stopped;
}
/**
* Stop the application and destroy its resources.
*/
public void destroy() {
if (stopped)
return;
try {
// destroy resources
for (int i=0; i < weakWindows.size(); i++) {
Window w = (Window) weakWindows.get(i);
if (w != null)
w.dispose();
}
weakWindows.clear();
// interrupt threads
Thread threads[] = new Thread[ group.activeCount() * 2 ];
int nthreads = group.enumerate(threads);
for (int i=0; i < nthreads; i++) {
if (JNLPRuntime.isDebug())
System.out.println("Interrupt thread: "+threads[i]);
threads[i].interrupt();
}
// then stop
Thread.currentThread().yield();
nthreads = group.enumerate(threads);
for (int i=0; i < nthreads; i++) {
if (JNLPRuntime.isDebug())
System.out.println("Stop thread: "+threads[i]);
threads[i].stop();
}
// then destroy - except Thread.destroy() not implemented in jdk
}
finally {
stopped = true;
fireDestroyed();
}
}
/**
* Returns the thread group.
*
* @throws IllegalStateException if the app is not running
*/
public ThreadGroup getThreadGroup() throws IllegalStateException {
if (stopped)
throw new IllegalStateException();
return group;
}
/**
* Returns the classloader.
*
* @throws IllegalStateException if the app is not running
*/
public ClassLoader getClassLoader() throws IllegalStateException {
if (stopped)
throw new IllegalStateException();
return loader;
}
/**
* Adds a window that this application opened. When the
* application is disposed, these windows will also be disposed.
*/
protected void addWindow(Window window) {
weakWindows.add(window);
weakWindows.trimToSize();
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/AppThreadGroup.java 0000666 0001750 0001750 00000003611 07622737604 022752 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.awt.*;
/**
* Thread group for a JNLP application.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.5 $
*/
public class AppThreadGroup extends ThreadGroup {
/** the app */
private ApplicationInstance app = null;
/**
* Creates new JavaAppThreadGroup
*
* @param name of the App
*/
public AppThreadGroup(ThreadGroup parent, String name) {
super(parent, name);
}
/**
* Sets the JNLP app this group is for; can only be called once.
*/
public void setApplication(ApplicationInstance app) {
if (this.app != null)
throw new IllegalStateException("Application can only be set once");
this.app = app;
}
/**
* Returns the JNLP app for this thread group.
*/
public ApplicationInstance getApplication() {
return app;
}
/**
* Handle uncaught exceptions for the app.
*/
public void uncaughtException(Thread t, Throwable e) {
super.uncaughtException(t, e);
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/Boot.java 0000666 0001750 0001750 00000030572 07624413662 020773 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.util.*;
import java.util.List;
import java.io.*;
import java.net.*;
import java.security.*;
import netx.jnlp.*;
import netx.jnlp.cache.*;
import netx.jnlp.util.*;
import netx.jnlp.runtime.*;
import netx.jnlp.services.*;
/**
* This is the main entry point for the JNLP client. The main
* method parses the command line parameters and loads a JNLP
* file into the secure runtime environment. This class is meant
* to be called from the command line or file association; to
* initialize the netx engine from other code invoke the
*
*
* The JNLP runtime can be locked to prevent further changes to
* the runtime environment except by a specified class. If set,
* only instances of the exit class can exit the JVM or
* change the JNLP runtime settings once the runtime has been
* initialized.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.19 $
*/
public class JNLPRuntime {
static {
loadResources();
}
/** the localized resource strings */
private static ResourceBundle resources;
/** the security manager */
private static JNLPSecurityManager security;
/** the security policy */
private static JNLPPolicy policy;
/** the base dir for cache, etc */
private static File baseDir;
/** a default launch handler */
private static LaunchHandler handler = null;
/** default download indicator */
private static DownloadIndicator indicator = null;
/** update policy that controls when to check for updates */
private static UpdatePolicy updatePolicy = UpdatePolicy.ALWAYS;
/** netx window icon */
private static Image windowIcon = null;
/** whether initialized */
private static boolean initialized = false;
/** whether netx is in command-line mode (headless) */
private static boolean headless = false;
/** whether the runtime uses security */
private static boolean securityEnabled = true;
/** whether debug mode is on */
private static boolean debug = false; // package access by Boot
/**
* Returns whether the JNLP runtime environment has been
* initialized. Once initialized, some properties such as the
* base directory cannot be changed. Before
*/
public static boolean isInitialized() {
return initialized;
}
/**
* Initialize the JNLP runtime environment by installing the
* security manager and security policy, initializing the JNLP
* standard services, etc.
*
* This method cannot be called more than once. Once
* initialized, methods that alter the runtime can only be
* called by the exit class.
*
* @throws IllegalStateException if the runtime was previously initialized
*/
public static void initialize() throws IllegalStateException {
checkInitialized();
initialized = true;
if (headless == false)
checkHeadless();
if (!headless && windowIcon == null)
loadWindowIcon();
if (!headless && indicator == null)
indicator = new DefaultDownloadIndicator();
if (handler == null)
handler = new DefaultLaunchHandler();
if (baseDir == null)
baseDir = getDefaultBaseDir();
if (baseDir == null)
throw new IllegalStateException(JNLPRuntime.getMessage("BNoBase"));
policy = new JNLPPolicy();
security = new JNLPSecurityManager(); // side effect: create JWindow
if (securityEnabled) {
Policy.setPolicy(policy); // do first b/c our SM blocks setPolicy
System.setSecurityManager(security);
}
ServiceManager.setServiceManagerStub(new XServiceManagerStub()); // ignored if we're running under Web Start
}
/**
* Returns the window icon.
*/
public static Image getWindowIcon() {
return windowIcon;
}
/**
* Sets the window icon that is displayed in Java applications
* and applets instead of the default Java icon.
*
* @throws IllegalStateException if caller is not the exit class
*/
public static void setWindowIcon(Image image) {
checkExitClass();
windowIcon = image;
}
/**
* Returns whether the JNLP client will use any AWT/Swing
* components.
*/
public static boolean isHeadless() {
return headless;
}
/**
* Sets whether the JNLP client will use any AWT/Swing
* components. In headless mode, client features that use the
* AWT are disabled such that the client can be used in
* headless mode (
*
* @param enabled whether security should be enabled
* @throws IllegalStateException if the runtime is already initialized
*/
public static void setSecurityEnabled(boolean enabled) {
checkInitialized();
securityEnabled = enabled;
}
/**
* Returns the system default base dir for or if not set,
* prompts the user for the location.
*
* @return the base dir, or null if the user canceled the dialog
* @throws IOException if there was an io exception
*/
public static File getDefaultBaseDir() {
PropertiesFile props = JNLPRuntime.getProperties();
loadWindowIcon();
String baseStr = props.getProperty("basedir");
if (baseStr != null)
return new File(baseStr);
if (isHeadless())
return null;
File baseDir = InstallDialog.getInstallDir();
if (baseDir == null)
return null;
props.setProperty("basedir", baseDir.toString());
props.store();
return baseDir;
}
/**
* Set a class that can exit the JVM; if not set then any class
* can exit the JVM.
*
* @throws IllegalStateException if caller is not the exit class
*/
public static void setExitClass(Class exitClass) {
checkExitClass();
security.setExitClass(exitClass);
}
/**
* Return the current Application, or null if none can be
* determined.
*/
public static ApplicationInstance getApplication() {
return security.getApplication();
}
/**
* Return a PropertiesFile object backed by the runtime's
* properties file.
*/
public static PropertiesFile getProperties() {
File netxrc = new File(System.getProperty("user.home"), ".netxrc");
return new PropertiesFile(netxrc);
}
/**
* Return whether debug statements for the JNLP client code
* should be printed.
*/
public static boolean isDebug() {
return debug;
}
/**
* Sets whether debug statements for the JNLP client code
* should be printed to the standard output.
*
* @throws IllegalStateException if caller is not the exit class
*/
public static void setDebug(boolean enabled) {
checkExitClass();
debug = enabled;
}
/**
* Sets the default update policy.
*
* @throws IllegalStateException if caller is not the exit class
*/
public static void setDefaultUpdatePolicy(UpdatePolicy policy) {
checkExitClass();
updatePolicy = policy;
}
/**
* Returns the default update policy.
*/
public static UpdatePolicy getDefaultUpdatePolicy() {
return updatePolicy;
}
/**
* Sets the default launch handler.
*/
public static void setDefaultLaunchHandler(LaunchHandler handler) {
checkExitClass();
JNLPRuntime.handler = handler;
}
/**
* Returns the default launch handler.
*/
public static LaunchHandler getDefaultLaunchHandler() {
return handler;
}
/**
* Sets the default download indicator.
*
* @throws IllegalStateException if caller is not the exit class
*/
public static void setDefaultDownloadIndicator(DownloadIndicator indicator) {
checkExitClass();
JNLPRuntime.indicator = indicator;
}
/**
* Returns the default download indicator.
*/
public static DownloadIndicator getDefaultDownloadIndicator() {
return indicator;
}
/**
* Returns the localized resource string identified by the
* specified key. If the message is empty, a null is
* returned.
*/
public static String getMessage(String key) {
try {
String result = resources.getString(key);
if (result.length() == 0)
return null;
else
return result;
}
catch (Exception ex) {
if (!key.equals("RNoResource"))
return getMessage("RNoResource", new Object[] {key});
else
return "Missing resource: "+key;
}
}
/**
* Returns the localized resource string using the specified
* arguments.
*
* @param args the formatting arguments to the resource string
*/
public static String getMessage(String key, Object args[]) {
return MessageFormat.format(getMessage(key), args);
}
/**
* Throws an exception if called when the runtime is
* already initialized.
*/
private static void checkInitialized() {
if (initialized)
throw new IllegalStateException("JNLPRuntime already initialized.");
}
/**
* Throws an exception if called with security enabled but
* a caller is not the exit class and the runtime has been
* initialized.
*/
private static void checkExitClass() {
if (securityEnabled && initialized)
if (!security.isExitClass())
throw new IllegalStateException("Caller is not the exit class");
}
/**
* Check whether the VM is in headless mode.
*/
private static void checkHeadless() {
//if (GraphicsEnvironment.isHeadless()) // jdk1.4+ only
// headless = true;
try {
if ("true".equalsIgnoreCase(System.getProperty("java.awt.headless")))
headless = true;
}
catch (SecurityException ex) {
}
}
/**
* Load the resources.
*/
private static void loadResources() {
try {
resources = ResourceBundle.getBundle("netx.jnlp.resources.Messages");
}
catch (Exception ex) {
throw new IllegalStateException("Missing resource bundle in netx.jar:/netx/jnlp/resource/Messages.properties");
}
}
/**
* Load the window icon.
*/
private static void loadWindowIcon() {
if (windowIcon != null)
return;
try {
ClassLoader cl = JNLPRuntime.class.getClassLoader();
windowIcon = new javax.swing.ImageIcon(cl.getResource("netx/jnlp/resources/netx-icon.png")).getImage();
}
catch (Exception ex) {
if (JNLPRuntime.isDebug())
ex.printStackTrace();
}
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/JNLPSecurityManager.java 0000666 0001750 0001750 00000030436 07623646740 023661 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.lang.ref.*;
import javax.swing.*;
import java.security.*;
import netx.jnlp.util.*;
/**
* Security manager for JNLP environment. This security manager
* cannot be replaced as it always denies attempts to replace the
* security manager or policy.
*
* The JNLP security manager tracks windows created by an
* application, allowing those windows to be disposed when the
* application exits but the JVM does not. If security is not
* enabled then the first application to call System.exit will
* halt the JVM.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.17 $
*/
class JNLPSecurityManager extends SecurityManager {
// todo: some apps like JDiskReport can close the VM even when
// an exit class is set - fix!
// todo: create an event dispatch thread for each application,
// so that the context classloader doesn't have to be switched
// to the foreground application (the currently the approach
// since some apps need their classloader as event dispatch
// thread's context classloader).
// todo: use a custom Permission object to identify the current
// application in an AccessControlContext by setting a side
// effect in its implies method. Use a custom
// AllPermissions-like permission to do this for apps granted
// all permissions (but investigate whether this will nuke
// the all-permission optimizations in the JRE).
// todo: does not exit app if close button pressed on JFrame
// with CLOSE_ON_EXIT (or whatever) set; if doesn't exit, use an
// WindowListener to catch WindowClosing event, then if exit is
// called immediately afterwards from AWT thread.
// todo: deny all permissions to applications that should have
// already been 'shut down' by closing their resources and
// interrupt the threads if operating in a shared-VM (exit class
// set). Deny will probably will slow checks down a lot though.
// todo: weak remember last getProperty application and
// re-install properties if another application calls, or find
// another way for different apps to have different properties
// in java.lang.Sytem with the same names.
private static String R(String key) { return JNLPRuntime.getMessage(key); }
/** only class that can exit the JVM, if set */
private Object exitClass = null;
/** this exception prevents exiting the JVM */
private SecurityException closeAppEx = // making here prevents huge stack traces
new SecurityException(JNLPRuntime.getMessage("RShutdown"));
/** weak list of windows created */
private WeakList weakWindows = new WeakList();
/** weak list of applications corresponding to window list */
private WeakList weakApplications = new WeakList();
/** weak reference to most app who's windows was most recently activated */
private WeakReference activeApplication = null;
/** listener installs the app's classloader on the event dispatch thread */
private ContextUpdater contextListener = new ContextUpdater();
private class ContextUpdater extends WindowAdapter implements PrivilegedAction {
private ApplicationInstance app = null;
public void windowActivated(WindowEvent e) {
app = getApplication(e.getWindow());
AccessController.doPrivileged(this);
app = null;
}
public Object run() {
if (app != null) {
Thread.currentThread().setContextClassLoader(app.getClassLoader());
activeApplication = new WeakReference(app);
}
else
Thread.currentThread().setContextClassLoader(this.getClass().getClassLoader());
return null;
}
public void windowDeactivated(WindowEvent e) {
activeApplication = null;
}
};
/**
* Creates a JNLP SecurityManager.
*/
JNLPSecurityManager() {
// this has the side-effect of creating the Swing shared Frame
// owner. Since no application is running at this time, it is
// not added to any window list when checkTopLevelWindow is
// called for it (and not disposed).
if (!JNLPRuntime.isHeadless())
new JWindow().getOwner();
}
/**
* Returns whether the exit class is present on the stack, or
* true if no exit class is set.
*/
public boolean isExitClass() {
return isExitClass(getClassContext());
}
/**
* Returns whether the exit class is present on the stack, or
* true if no exit class is set.
*/
private boolean isExitClass(Class stack[]) {
if (exitClass == null)
return true;
for (int i=0; i < stack.length; i++)
if (stack[i] == exitClass)
return true;
return false;
}
/**
* Set the exit class, which is the only class that can exit the
* JVM; if not set then any class can exit the JVM.
*
* @param exitClass the exit class
* @throws IllegalStateException if the exit class is already set
*/
public void setExitClass(Class exitClass) throws IllegalStateException {
if (this.exitClass != null)
throw new IllegalStateException(R("RExitTaken"));
this.exitClass = exitClass;
}
/**
* Return the current Application, or null if none can be
* determined.
*/
protected ApplicationInstance getApplication() {
return getApplication(getClassContext(), 0);
}
/**
* Return the application the opened the specified window (only
* call from event dispatch thread).
*/
protected ApplicationInstance getApplication(Window window) {
for (int i = weakWindows.size(); i-->0;) {
Window w = (Window) weakWindows.get(i);
if (w == null) {
weakWindows.remove(i);
weakApplications.remove(i);
}
if (w == window)
return (ApplicationInstance) weakApplications.get(i);
}
return null;
}
/**
* Return the current Application, or null.
*/
protected ApplicationInstance getApplication(Class stack[], int maxDepth) {
if (maxDepth <= 0)
maxDepth = stack.length;
// this needs to be tightened up
for (int i=0; i < stack.length && i < maxDepth; i++) {
if (stack[i].getClassLoader() instanceof JNLPClassLoader) {
JNLPClassLoader loader = (JNLPClassLoader) stack[i].getClassLoader();
if (loader != null && loader.getApplication() != null) {
return loader.getApplication();
}
}
}
return null;
}
/**
* Returns the application's thread group if the application can
* be determined; otherwise returns super.getThreadGroup()
*/
public ThreadGroup getThreadGroup() {
ApplicationInstance app = getApplication();
if (app == null)
return super.getThreadGroup();
return app.getThreadGroup();
}
/**
* Throws a SecurityException if the permission is denied,
* otherwise return normally. This method always denies
* permission to change the security manager or policy.
*/
public void checkPermission(Permission perm) {
String name = perm.getName();
if ("setPolicy".equals(name) ||
"setSecurityManager".equals(name))
throw new SecurityException(R("RCantReplaceSM"));
try {
// deny all permissions to stopped applications
if (JNLPRuntime.isDebug()) {
if (!"getClassLoader".equals(name)) {
ApplicationInstance app = getApplication();
if (app != null && !app.isRunning())
throw new SecurityException(R("RDenyStopped"));
}
}
super.checkPermission(perm);
}
catch (SecurityException ex) {
if (JNLPRuntime.isDebug())
System.out.println("denying permission: "+perm);
throw ex;
}
}
/**
* Checks whether the window can be displayed without an applet
* warning banner, and adds the window to the list of windows to
* be disposed when the calling application exits.
*/
public boolean checkTopLevelWindow(Object window) {
ApplicationInstance app = getApplication();
// remember window -> application mapping for focus, close on exit
if (app != null && window instanceof Window) {
Window w = (Window) window;
if (JNLPRuntime.isDebug())
System.err.println("SM: app: "+app.getTitle()+" is adding a window: "+window);
weakWindows.add(window); // for mapping window -> app
weakApplications.add(app);
w.addWindowListener(contextListener); // for dynamic context classloader
app.addWindow(w);
}
// change coffee cup to netx for default icon
if (window instanceof Window)
for (Window w = (Window)window; w != null; w = w.getOwner())
if (window instanceof Frame)
((Frame)window).setIconImage(JNLPRuntime.getWindowIcon());
// todo: set awt.appletWarning to custom message
// todo: logo on with glass pane on JFrame/JWindow?
return super.checkTopLevelWindow(window);
}
/**
* Checks whether the caller can exit the system. This method
* identifies whether the caller is a real call to Runtime.exec
* and has special behavior when returning from this method
* would exit the JVM and an exit class is set: if the caller is
* not the exit class then the calling application will be
* stopped and its resources destroyed (when possible), and an
* exception will be thrown to prevent the JVM from shutting
* down.
*
* Calls not from Runtime.exit or with no exit class set will
* behave normally, and the exit class can always exit the JVM.
*/
public void checkExit(int status) {
super.checkExit(status);
Class stack[] = getClassContext();
boolean realCall = (stack[1] == Runtime.class);
if (isExitClass(stack)) // either exitClass called or no exitClass set
return; // to Runtime.exit or fake call to see if app has permission
// not called from Runtime.exit()
if (!realCall) {
// apps that can't exit should think they can exit normally
super.checkExit(status);
return;
}
// but when they really call, stop only the app instead of the JVM
ApplicationInstance app = getApplication(stack, 0);
if (app == null) {
// should check caller to make sure it is JFrame.close or
// other known System.exit call
if (activeApplication != null)
app = (ApplicationInstance) activeApplication.get();
if (app == null)
throw new SecurityException(R("RExitNoApp"));
}
app.destroy();
throw closeAppEx;
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/package.html 0000666 0001750 0001750 00000001324 07617774060 021503 0 ustar god god
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.8 $
*/
public class ServiceUtil {
/**
* Returns the BasicService reference, or null if the service is
* unavailable.
*/
public static BasicService getBasicService() {
return (BasicService) getService("javax.jnlp.BasicService");
}
/**
* Returns the ClipboardService reference, or null if the service is
* unavailable.
*/
public static ClipboardService getClipboardService() {
return (ClipboardService) getService("javax.jnlp.ClipboardService");
}
/**
* Returns the DownloadService reference, or null if the service is
* unavailable.
*/
public static DownloadService getDownloadService() {
return (DownloadService) getService("javax.jnlp.DownloadService");
}
/**
* Returns the ExtensionInstallerService reference, or null if the service is
* unavailable.
*/
public static ExtensionInstallerService getExtensionInstallerService() {
return (ExtensionInstallerService) getService("javax.jnlp.ExtensionInstallerService");
}
/**
* Returns the FileOpenService reference, or null if the service is
* unavailable.
*/
public static FileOpenService getFileOpenService() {
return (FileOpenService) getService("javax.jnlp.FileOpenService");
}
/**
* Returns the FileSaveService reference, or null if the service is
* unavailable.
*/
public static FileSaveService getFileSaveService() {
return (FileSaveService) getService("javax.jnlp.FileSaveService");
}
/**
* Returns the PersistenceService reference, or null if the service is
* unavailable.
*/
public static PersistenceService getPersistenceService() {
return (PersistenceService) getService("javax.jnlp.PersistenceService");
}
/**
* Returns the PrintService reference, or null if the service is
* unavailable.
*/
public static PrintService getPrintService() {
return (PrintService) getService("javax.jnlp.PrintService");
}
/**
* Returns the service, or null instead of an UnavailableServiceException
*/
private static Object getService(String name) {
try {
return ServiceManager.lookup(name);
}
catch (UnavailableServiceException ex) {
return null;
}
}
/**
* Creates a Proxy object implementing the specified interface
* when makes all calls in the security context of the system
* classes (ie, AllPermissions). This means that the services
* must be more than extremely careful in the operations they
* perform.
*/
static Object createPrivilegedProxy(Class iface, final Object receiver) {
return Proxy.newProxyInstance(XServiceManagerStub.class.getClassLoader(),
new Class[] { iface },
new PrivilegedHandler(receiver));
}
/**
* calls the object's method using privileged access
*/
private static class PrivilegedHandler implements InvocationHandler {
private final Object receiver;
PrivilegedHandler(Object receiver) {
this.receiver = receiver;
}
public Object invoke(Object proxy, final Method method, final Object[] args) throws Throwable {
if (JNLPRuntime.isDebug()) {
System.err.println("call privileged method: "+method.getName());
if (args != null)
for (int i=0; i < args.length; i++)
System.err.println(" arg: "+args[i]);
}
PrivilegedExceptionAction invoker = new PrivilegedExceptionAction() {
public Object run() throws Exception {
return method.invoke(receiver, args);
}
};
Object result = AccessController.doPrivileged(invoker);
if (JNLPRuntime.isDebug())
System.err.println(" result: "+result);
return result;
}
};
}
libnetx-java-0.5.orig/src/netx/jnlp/services/XBasicService.java 0000666 0001750 0001750 00000012270 07623004246 022706 0 ustar god god // Copyright (C) 2001 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.services;
import java.io.*;
import java.net.*;
import javax.jnlp.*;
import javax.swing.*;
import netx.jnlp.*;
import netx.jnlp.util.*;
import netx.jnlp.runtime.*;
/**
* The BasicService JNLP service.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.10 $
*/
class XBasicService implements BasicService {
/** command used to exec the native browser */
private String command = null;
/** whether the command was loaded / prompted for */
private boolean initialized = false;
protected XBasicService() {
}
/**
* Returns the codebase of the application, applet, or
* installer. If the codebase was not specified in the JNLP
* element then the main JAR's location is returned. If no main
* JAR was specified then the location of the JAR containing the
* main class is returned.
*/
public URL getCodeBase() {
ApplicationInstance app = JNLPRuntime.getApplication();
if (app != null) {
JNLPFile file = app.getJNLPFile();
// return the codebase.
if (file.getCodeBase() != null)
return file.getCodeBase();
// else return the main JAR's URL.
JARDesc mainJar = file.getResources().getMainJAR();
if (mainJar != null)
return mainJar.getLocation();
// else find JAR where main class was defined.
//
// JNLPFile file = app.getJNLPFile();
// String mainClass = file.getLaunchInfo().getMainClass()+".class";
// URL jarUrl = app.getClassLoader().getResource(mainClass);
// go through list of JARDesc to find one matching jarUrl
}
return null;
}
/**
* Return true if the Environment is Offline
*/
public boolean isOffline() {
return false;
}
/**
* Return true if a Web Browser is Supported
*/
public boolean isWebBrowserSupported() {
initialize();
return command != null;
}
/**
* Show a document.
*
* @return whether the document was opened
*/
public boolean showDocument(URL url) {
initialize();
if (url.toString().endsWith(".jnlp")) {
try {
new Launcher().launchExternal(url);
return true;
}
catch (Exception ex) {
return false;
}
}
if (command != null) {
try {
// this is bogus because the command may require options;
// should use a StreamTokenizer or similar to get tokens
// outside of quotes.
Runtime.getRuntime().exec(command + url.toString());
//Runtime.getRuntime().exec(new String[]{command,url.toString()});
return true;
}
catch(IOException ex){
if (JNLPRuntime.isDebug())
ex.printStackTrace();
}
}
return false;
}
private void initialize() {
if (initialized)
return;
initialized = true;
if(isWindows()) {
command = "rundll32 url.dll,FileProtocolHandler ";
}
else {
PropertiesFile props = JNLPRuntime.getProperties();
command = props.getProperty("browser.command");
if(command == null) { // prompt & store
command = promptForCommand(null);
if(command != null) {
props.setProperty("browser.command", command);
props.store();
}
}
}
}
private boolean isWindows() {
String os = System.getProperty("os.name");
if(os != null && os.startsWith("Windows"))
return true;
else
return false;
}
private String promptForCommand(String cmd) {
return JOptionPane.showInputDialog(new JPanel(),
"Browser Location:",
"Specify Browser Location",
JOptionPane.PLAIN_MESSAGE
);
}
}
libnetx-java-0.5.orig/src/netx/jnlp/services/XDownloadService.java 0000666 0001750 0001750 00000011577 07622737604 023457 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.services;
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.ref.*;
import javax.jnlp.*;
import netx.jnlp.*;
/**
* The BasicService JNLP service.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.7 $
*/
class XDownloadService implements DownloadService {
protected XDownloadService() {
}
// comments copied from DownloadService interface
/**
* Returns a listener that will automatically display download
* progress to the user.
*/
public DownloadServiceListener getDefaultProgressWindow() {
return null;
}
/**
* Returns whether the part in an extension (specified by the
* url and version) is cached locally.
*/
public boolean isExtensionPartCached(URL ref, String version, String part) {
return true;
}
/**
* Returns whether the parts in an extension (specified by the
* url and version) are cached locally.
*/
public boolean isExtensionPartCached(URL ref, String version, String[] parts) {
return true;
}
/**
* Returns whether the part of the calling application is cached
* locally. If called by code specified by an extension
* descriptor, the specified part refers to the extension not
* the application.
*/
public boolean isPartCached(String part) {
return true;
}
/**
* Returns whether all of the parts of the calling application
* are cached locally. If called by code in an extension, the
* part refers the the part of the extension not the
* application.
*/
public boolean isPartCached(String[] parts) {
return true;
}
/**
* Returns whether the resource is cached locally. This method
* only returns true if the resource is specified by the calling
* application or extension.
*/
public boolean isResourceCached(URL ref, String version) {
return true;
}
/**
* Downloads the parts of an extension.
*
* @throws IOException
*/
public void loadExtensionPart(URL ref, String version, String[] parts, DownloadServiceListener progress) throws IOException {
}
/**
* Downloads a part of an extension.
*
* @throws IOException
*/
public void loadExtensionPart(URL ref, String version, String part, DownloadServiceListener progress) throws IOException {
}
/**
* Downloads the parts.
*
* @throws IOException
*/
public void loadPart(String[] parts, DownloadServiceListener progress) throws IOException {
}
/**
* Downloads the part.
*
* @throws IOException
*/
public void loadPart(String part, DownloadServiceListener progress) throws IOException {
}
/**
* Downloads a resource.
*
* @throws IOException
*/
public void loadResource(URL ref, String version, DownloadServiceListener progress) throws IOException {
}
/**
* Notify the system that an extension's part is no longer
* important to cache.
*
* @throws IOException
*/
public void removeExtensionPart(URL ref, String version, String part) throws IOException {
}
/**
* Notify the system that an extension's parts are no longer
* important to cache.
*
* @throws IOException
*/
public void removeExtensionPart(URL ref, String version, String[] parts) throws IOException {
}
/**
* Notifies the system that a part is no longer important to
* cache.
*
* @throws IOException
*/
public void removePart(String part) throws IOException {
}
/**
* Notifies the system that the parts is no longer important to
* cache.
*
* @throws IOException
*/
public void removePart(String[] parts) throws IOException {
}
/**
* Notifies the system that the resource is no longer important
* to cache.
*
* @throws IOException
*/
public void removeResource(URL ref, String version) throws IOException {
}
}
libnetx-java-0.5.orig/src/netx/jnlp/services/XExtensionInstallerService.java 0000666 0001750 0001750 00000004526 07622737604 025536 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.services;
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.ref.*;
import javax.jnlp.*;
import netx.jnlp.*;
/**
* The BasicService JNLP service.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.6 $
*/
class XExtensionInstallerService implements ExtensionInstallerService {
protected XExtensionInstallerService() {
}
/**
*
*/
public URL getExtensionLocation() {
return null;
}
/**
*
*/
public String getExtensionVersion() {
return null;
}
/**
*
*/
public String getInstalledJRE(java.net.URL url, java.lang.String version) {
return null;
}
/**
*
*/
public String getInstallPath() {
return null;
}
/**
*
*/
public void hideProgressBar() {
}
/**
*
*/
public void hideStatusWindow() {
}
/**
*
*/
public void installFailed() {
}
/**
*
*/
public void installSucceeded(boolean needsReboot) {
}
/**
*
*/
public void setHeading(java.lang.String heading) {
}
/**
*
*/
public void setJREInfo(java.lang.String platformVersion, java.lang.String jrePath) {
}
/**
*
*/
public void setNativeLibraryInfo(java.lang.String path) {
}
/**
*
*/
public void setStatus(java.lang.String status) {
}
/**
*
*/
public void updateProgress(int value) {
}
}
libnetx-java-0.5.orig/src/netx/jnlp/services/XFileContents.java 0000666 0001750 0001750 00000005716 07622737604 022762 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.services;
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.ref.*;
import javax.jnlp.*;
import netx.jnlp.*;
/**
* File contents.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.6 $
*/
class XFileContents implements FileContents {
/** the file */
private File file;
/**
* Create a file contents implementation for the file.
*/
protected XFileContents(File file) {
this.file = file;
}
/**
*
* @throws IOException if an I/O exception occurs.
*/
public boolean canRead() throws IOException {
return file.canRead();
}
/**
*
* @throws IOException if an I/O exception occurs.
*/
public boolean canWrite() throws IOException {
return file.canWrite();
}
/**
*
* @throws IOException if an I/O exception occurs.
*/
public InputStream getInputStream() throws IOException {
return new FileInputStream(file);
}
/**
*
* @throws IOException if an I/O exception occurs.
*/
public long getLength() throws IOException {
return file.length();
}
/**
*
* @throws IOException if an I/O exception occurs.
*/
public long getMaxLength() throws IOException {
return Long.MAX_VALUE;
}
/**
*
* @throws IOException if an I/O exception occurs.
*/
public String getName() throws IOException {
return file.getName();
}
/**
*
* @throws IOException if an I/O exception occurs.
*/
public OutputStream getOutputStream(boolean overwrite) throws IOException {
// file.getPath compatible with pre-1.4 JREs
return new FileOutputStream(file.getPath(), !overwrite);
}
/**
*
* @throws IOException if an I/O exception occurs.
*/
public JNLPRandomAccessFile getRandomAccessFile(String mode) throws IOException {
return null;
}
/**
*
* @throws IOException if an I/O exception occurs.
*/
public long setMaxLength(long maxlength) throws IOException {
return maxlength;
}
}
libnetx-java-0.5.orig/src/netx/jnlp/services/XPersistenceService.java 0000666 0001750 0001750 00000012743 07622737604 024170 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.services;
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.ref.*;
import javax.jnlp.*;
import netx.jnlp.runtime.*;
import netx.jnlp.cache.*;
import netx.jnlp.*;
/**
* The BasicService JNLP service.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.7 $
*/
class XPersistenceService implements PersistenceService {
// todo: recheck delete, etc to make sure security is tight
protected XPersistenceService() {
}
/**
* Checks whether the application has access to URL area
* requested. If the method returns normally then the specified
* location can be accessed by the current application.
*
* @throws MalformedURLException if the application cannot access the location
*/
protected void checkLocation(URL location) throws MalformedURLException {
ApplicationInstance app = JNLPRuntime.getApplication();
if (app == null)
throw new MalformedURLException("Cannot determine the current application.");
URL source = app.getJNLPFile().getCodeBase();
if (!source.getHost().equalsIgnoreCase(location.getHost()))
throw new MalformedURLException("Cannot access data from a different host.");
// test for above codebase, not perfect but works for now
String requestPath = location.getFile();
if (-1 != requestPath.lastIndexOf("/"))
requestPath = requestPath.substring(0, requestPath.lastIndexOf("/"));
else
requestPath = "";
if (JNLPRuntime.isDebug()) {
System.out.println("codebase path: "+source.getFile());
System.out.println("request path: "+requestPath);
}
if (!source.getFile().startsWith(requestPath))
throw new MalformedURLException("Cannot access data below source URL path.");
}
/**
* Converts a URL into a file in the persistence store.
*
* @return the file
*/
protected File toCacheFile(URL location) throws MalformedURLException {
return CacheUtil.urlToPath(location, "pcache");
}
/**
*
* @return the maximum size of storage that got granted, in bytes
* @throws MalformedURLException if the application cannot access the location
*/
public long create(URL location, long maxsize) throws MalformedURLException, IOException {
checkLocation(location);
File file = toCacheFile(location);
file.getParentFile().mkdirs();
if (!file.createNewFile())
throw new IOException("File already exists.");
return maxsize;
}
/**
*
* @throws MalformedURLException if the application cannot access the location
*/
public void delete(URL location) throws MalformedURLException, IOException {
checkLocation(location);
toCacheFile(location).delete();
}
/**
*
* @throws MalformedURLException if the application cannot access the location
*/
public FileContents get(URL location) throws MalformedURLException, IOException, FileNotFoundException {
checkLocation(location);
File file = toCacheFile(location);
file.getParentFile().mkdirs();
return (FileContents) ServiceUtil.createPrivilegedProxy(FileContents.class, new XFileContents(file));
}
/**
*
* @throws MalformedURLException if the application cannot access the location
*/
public String[] getNames(URL location) throws MalformedURLException, IOException {
checkLocation(location);
File file = toCacheFile(location);
if (!file.isDirectory())
return new String[0];
List result = new ArrayList();
// check whether this is right: only add files and not directories.
File entries[] = file.listFiles();
for (int i=0; i < entries.length; i++)
if (entries[i].isFile())
result.add(entries[i].getName());
return (String[]) result.toArray(new String[result.size()]);
}
/**
*
* @throws MalformedURLException if the application cannot access the location
*/
public int getTag(URL location) throws MalformedURLException, IOException {
checkLocation(location);
// todo: actually implement tags
if (toCacheFile(location).exists())
return PersistenceService.CACHED;
return PersistenceService.CACHED;
}
/**
*
* @throws MalformedURLException if the application cannot access the location
*/
public void setTag(URL location, int tag) throws MalformedURLException, IOException {
checkLocation(location);
// todo: actually implement tags
}
}
libnetx-java-0.5.orig/src/netx/jnlp/services/XServiceManagerStub.java 0000666 0001750 0001750 00000006221 07622737604 024106 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.services;
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.ref.*;
import java.lang.reflect.*;
import java.security.*;
import javax.jnlp.*;
import netx.jnlp.*;
/**
* Lookup table for services.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.6 $
*/
public class XServiceManagerStub implements ServiceManagerStub {
// todo: only include ExtensionInstallerService if an installer
// is getting the service, otherwise return null.
// todo: fix services to do their own privileged actions that
// run less code in the secure environment (or avoid privileged
// actions by giving permission to the code source).
private static String serviceNames[] = {
"javax.jnlp.BasicService", // required
"javax.jnlp.DownloadService", // required
"javax.jnlp.ExtensionInstallerService", // required
"javax.jnlp.PersistenceService",
};
private static Object services[] = {
ServiceUtil.createPrivilegedProxy(BasicService.class, new XBasicService()),
ServiceUtil.createPrivilegedProxy(DownloadService.class, new XDownloadService()),
ServiceUtil.createPrivilegedProxy(ExtensionInstallerService.class, new XExtensionInstallerService()),
ServiceUtil.createPrivilegedProxy(PersistenceService.class, new XPersistenceService()),
};
public XServiceManagerStub() {
}
/**
* Returns the service names.
*/
public String[] getServiceNames() {
// make sure it is a copy because we might be returning to
// code we don't own.
String result[] = new String[serviceNames.length];
System.arraycopy(serviceNames, 0, result, 0, serviceNames.length);
return result;
}
/**
* Returns the service.
*
* @throws UnavailableServiceException if service is not available
*/
public Object lookup(String name) throws UnavailableServiceException {
// exact match
for (int i=0; i < serviceNames.length; i++)
if (serviceNames[i].equals(name))
return services[i];
// substring match
for (int i=0; i < serviceNames.length; i++)
if (-1 != serviceNames[i].indexOf(name))
return services[i];
throw new UnavailableServiceException(""+name);
}
}
libnetx-java-0.5.orig/src/netx/jnlp/util/ 0000777 0001750 0001750 00000000000 07625173272 016511 5 ustar god god libnetx-java-0.5.orig/src/netx/jnlp/util/PropertiesFile.java 0000666 0001750 0001750 00000007551 07623002136 022304 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.util;
import java.io.*;
import java.net.*;
import java.util.*;
import netx.jnlp.*;
/**
* A properties object backed by a specified file without throwing
* exceptions. The properties are automatically loaded from the
* file when the first property is requested, but the save method
* must be called before changes are saved to the file.
*
* This class does not report IO exceptions.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.4 $
*/
public class PropertiesFile extends Properties {
/** the file to save to */
File file;
/** the header string */
String header = "netx file";
/** lazy loaded on getProperty */
boolean loaded = false;
/**
* Create a properties object backed by the specified file.
*
* @param file the file to save and load to
*/
public PropertiesFile(File file) {
this.file = file;
}
/**
* Create a properties object backed by the specified file.
*
* @param file the file to save and load to
* @param header the file header
*/
public PropertiesFile(File file, String header) {
this.file = file;
this.header = header;
}
/**
* Returns the value of the specified key, or null if the key
* does not exist.
*/
public String getProperty(String key) {
if (!loaded)
load();
return super.getProperty(key);
}
/**
* Returns the value of the specified key, or the default value
* if the key does not exist.
*/
public String getProperty(String key, String defaultValue) {
if (!loaded)
load();
return super.getProperty(key, defaultValue);
}
/**
* Sets the value for the specified key.
*
* @return the previous value
*/
public Object setProperty(String key, String value) {
if (!loaded)
load();
return super.setProperty(key, value);
}
/**
* Returns the file backing this properties object.
*/
public File getStoreFile() {
return file;
}
/**
* Ensures that the file backing these properties has been
* loaded; call this method before calling any method defined by
* a superclass.
*/
public void load() {
loaded = true;
try {
if (!file.exists())
return;
InputStream s = new FileInputStream(file);
load(s);
}
catch (IOException ex) {
// eat
}
}
/**
* Saves the properties to the file.
*/
public void store() {
if (!loaded)
return; // nothing could have changed so save unnecessary load/save
try {
OutputStream s = new FileOutputStream(file);
store(s, header);
}
catch (IOException ex) {
// eat
}
}
}
libnetx-java-0.5.orig/src/netx/jnlp/util/Reflect.java 0000666 0001750 0001750 00000010735 07624373452 020747 0 ustar god god // Copyright (C) 2003 Jon A. Maxwell (JAM)
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.util;
import java.util.*;
import java.lang.reflect.*;
/**
* Provides simply, convenient methods to invoke methods by
* name. This class is used to consolidate reflection needed to
* access methods specific to Sun's JVM or to remain backward
* compatible while supporting method in newer JVMs.
*
* Most methods of this class invoke the first method on the
* specified object that matches the name and number of
* parameters. The type of the parameters are not considered, so
* do not attempt to use this class to invoke overloaded
* methods.
*
* Instances of this class are not synchronized.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.1 $
*/
public class Reflect {
// todo: check non-null parameter types, try to send to proper
// method if overloaded ones exist on the target object
// todo: optimize slightly using hashtable of Methods
private boolean accessible;
private static Object zero[] = new Object[0];
/**
* Create a new Reflect instance.
*/
public Reflect() {
//
}
/**
* Create a new Reflect instance.
*
* @param accessible whether to bypass access permissions
*/
public Reflect(boolean accessible) {
this.accessible = accessible;
}
/**
* Invoke a zero-parameter static method by name.
*/
public Object invokeStatic(String className, String method) {
return invokeStatic(className, method, zero);
}
/**
* Invoke the static method using the specified parameters.
*/
public Object invokeStatic(String className, String method, Object args[]) {
try {
Class c = Class.forName(className, true, Reflect.class.getClassLoader());
Method m = getMethod(c, method, args);
if (m.isAccessible() != accessible)
m.setAccessible(accessible);
return m.invoke(null, args);
}
catch (Exception ex) { // eat
return null;
}
}
/**
* Invoke a zero-parameter method by name on the specified
* object.
*/
public Object invoke(Object object, String method) {
return invoke(object, method, zero);
}
/**
* Invoke a method by name with the specified parameters.
*
* @return the result of the method, or null on exception.
*/
public Object invoke(Object object, String method, Object args[]) {
try {
Method m = getMethod(object.getClass(), method, args);
if (m.isAccessible() != accessible)
m.setAccessible(accessible);
return m.invoke(object, args);
}
catch (Exception ex) { // eat
ex.printStackTrace();
return null;
}
}
/**
* Return the Method matching the specified name and number of
* arguments.
*/
public Method getMethod(Class type, String method, Object args[]) {
try {
for (Class c = type; c != null; c = c.getSuperclass()) {
Method methods[] = c.getMethods();
for (int i=0; i < methods.length; i++) {
if (methods[i].getName().equals(method)) {
Class parameters[] = methods[i].getParameterTypes();
if (parameters.length == args.length)
return methods[i];
}
}
}
}
catch (Exception ex) { // eat
ex.printStackTrace();
}
return null;
}
}
libnetx-java-0.5.orig/src/netx/jnlp/util/WeakList.java 0000666 0001750 0001750 00000007257 07624373526 021115 0 ustar god god // Copyright (C) 2002-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.util;
import java.lang.ref.*;
import java.util.*;
/**
* This list stores objects automatically using weak references.
* Objects are added and removed from the list as normal, but may
* turn to null at any point (ie, indexOf(x) followed by get(x)
* may return null). The weak references are only removed when
* the trimToSize method is called so that the indices remain
* constant otherwise.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.3 $
*/
public class WeakList extends AbstractList {
/* list of weak references */
private ArrayList refs = new ArrayList();
/**
* Create a weak random-access list.
*/
public WeakList() {
}
/**
* Extract the hard reference out of a weak reference.
*/
private Object deref(Object o) {
if (o != null && o instanceof WeakReference)
return ((WeakReference)o).get();
else
return null;
}
/**
* Returns the object at the specified index, or null if the
* object has been collected.
*/
public Object get(int index) {
return deref(refs.get(index));
}
/**
* Returns the size of the list, including already collected
* objects.
*/
public int size() {
return refs.size();
}
/**
* Sets the object at the specified position and returns the
* previous object at that position or null if it was already
* collected.
*/
public Object set(int index, Object element) {
return deref(refs.set(index, new WeakReference(element)));
}
/**
* Inserts the object at the specified position in the list.
* Automatically creates a weak reference to the object.
*/
public void add(int index, Object element) {
refs.add(index, new WeakReference(element));
}
/**
* Removes the object at the specified position and returns it
* or returns null if it was already collected.
*/
public Object remove(int index) {
return deref(refs.remove(index));
}
/**
* Returns a list of hard references to the objects. The
* returned list does not include the collected elements, so its
* indices do not necessarily correlate with those of this list.
*/
public List hardList() {
List result = new ArrayList();
for (int i=0; i < size(); i++) {
Object tmp = get(i);
if (tmp != null)
result.add(tmp);
}
return result;
}
/**
* Compacts the list by removing references to collected
* objects.
*/
public void trimToSize() {
for (int i=size(); i-->0;)
if (get(i)==null)
remove(i);
}
}
libnetx-java-0.5.orig/src/netx/jnlp/Version.java 0000666 0001750 0001750 00000025310 07622737604 020027 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp;
import java.io.*;
import java.net.*;
import java.util.*;
/**
* A JNLP Version string in the form "1.2-3_abc" followed by an
* optional + (includes all later versions) or * (matches any
* suffixes on versions). More than one version can be included
* in a string by separating them with spaces.
*
* Version strings are divided by "._-" charecters into parts.
* These parts are compared numerically if they can be parsed as
* integers or lexographically as strings otherwise. If the
* number of parts is different between two version strings then
* the smaller one is padded with zero or the empty string. Note
* that the padding in this version means that 1.2+ matches
* 1.4.0-beta1, but may not in future versions.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.5 $
*/
public class Version {
// to do: web start does not match versions with a "-" like
// "1.4-beta1" using the + modifier, change to mimic that
// behavior.
// also refactor into Version and VersionID classes so that
// individual version ids can be easily modified to add/remove
// "*" and "+" modifiers.
/** separates parts of a version string */
private static String seperators = ".-_";
/** magic key for whether a version part was created due to normalization */
private static String emptyString = new String("JNLPRuntime.initialize method after configuring
* the runtime.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.21 $
*/
public final class Boot implements PrivilegedAction {
// todo: decide whether a spawned netx (external launch)
// should inherit the same options as this instance (store argv?)
private static String R(String key) { return JNLPRuntime.getMessage(key); }
private static String R(String key, Object param) { return JNLPRuntime.getMessage(key, new Object[] {param}); }
private static final String version = "0.5";
/** the JNLP file to open to display the network-based about window */
private static final String aboutFile =
"http://jnlp.sourceforge.net/netx/about/netx"+version+".jnlp";
/** the text to display before launching the about link */
private static final String aboutMessage = ""
+ "netx v"+version+" - (C)2001-2003 Jon A. Maxwell (jmaxwell@users.sourceforge.net)\n"
+ "\n"
+ R("BLaunchAbout");
/** the JNLP file to open if -jnlp not specified (null for no default) */
private static final String defaultFile = "jar:"
+ Boot.class.getProtectionDomain().getCodeSource().getLocation()
+ "!/default.jnlp";
private static final String miniLicense = "\n"
+ " netx - an open-source JNLP client.\n"
+ " Copyright (C) 2001-2003 Jon A. Maxwell (JAM)\n"
+ "\n"
+ " // This library is free software; you can redistribute it and/or\n"
+ " modify it under the terms of the GNU Lesser General Public\n"
+ " License as published by the Free Software Foundation; either\n"
+ " version 2.1 of the License, or (at your option) any later version.\n"
+ "\n"
+ " This library is distributed in the hope that it will be useful,\n"
+ " but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+ " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
+ " Lesser General Public License for more details.\n"
+ "\n"
+ " You should have received a copy of the GNU Lesser General Public\n"
+ " License along with this library; if not, write to the Free Software\n"
+ " Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n"
+ "\n";
private static final String helpMessage = "\n"
+ R("BOUsage")+"\n"
+ " -basedir dir "+R("BOBasedir")+"\n"
+ " -jnlp location "+R("BOJnlp")+"\n"
+ " -arg arg "+R("BOArg")+"\n"
+ " -param name=value "+R("BOParam")+"\n"
+ " -property name=value "+R("BOProperty")+"\n"
+ " -update seconds "+R("BOUpdate")+"\n"
+ " -license "+R("BOLicense")+"\n"
+ " -verbose "+R("BOVerbose")+"\n"
+ " -about "+R("BOAbout")+"\n"
+ " -nosecurity "+R("BONosecurity")+"\n"
+ " -noupdate "+R("BONoupdate")+"\n"
+ " -headless "+R("BOHeadless")+"\n"
+ " -strict "+R("BOStrict")+"\n"
+ " -help "+R("BOHelp")+"\n";
private static final String doubleArgs = "-basedir -jnlp -arg -param -property -update";
private static String args[]; // avoid the hot potato
/**
* Launch the JNLP file specified by the command-line arguments.
*/
public static void main(String[] argsIn) {
args = argsIn;
if (null != getOption("-license")) {
System.out.println(miniLicense);
System.exit(0);
}
if (null != getOption("-help")) {
System.out.println(helpMessage);
System.exit(0);
}
if (null != getOption("-about"))
System.out.println(aboutMessage);
if (null != getOption("-verbose"))
JNLPRuntime.setDebug(true);
if (null != getOption("-update")) {
int value = Integer.parseInt(getOption("-update"));
JNLPRuntime.setDefaultUpdatePolicy(new UpdatePolicy(value*1000l));
}
if (null != getOption("-headless"))
JNLPRuntime.setHeadless(true);
if (null != getOption("-noupdate"))
JNLPRuntime.setDefaultUpdatePolicy(UpdatePolicy.NEVER);
// do in a privileged action to clear the security context of
// the Boot13 class, which doesn't have any privileges in
// JRE1.3; JRE1.4 works without Boot13 or this PrivilegedAction.
AccessController.doPrivileged(new Boot());
args = null; // might save a couple bytes...
}
/**
* The privileged part (jdk1.3 compatibility).
*/
public Object run() {
JNLPRuntime.setBaseDir(getBaseDir());
JNLPRuntime.setSecurityEnabled(null == getOption("-nosecurity"));
JNLPRuntime.initialize();
try {
new Launcher().launch(getFile());
}
catch (LaunchException ex) {
// default handler prints this
}
catch (Exception ex) {
if (JNLPRuntime.isDebug())
ex.printStackTrace();
fatalError(ex.getMessage());
}
return null;
}
private static void fatalError(String message) {
System.err.println("netx: "+message);
System.exit(1);
}
/**
* Returns the file to open; does not return if no file was
* specified.
*/
private static JNLPFile getFile() throws ParseException, MalformedURLException, IOException {
String location = getOption("-jnlp");
// override -jnlp with aboutFile
if (null != getOption("-about"))
location = aboutFile;
// still null, use default
if (location == null)
location = defaultFile;
if (location == null)
fatalError(R("BNeedsFile")+helpMessage);
if (JNLPRuntime.isDebug())
System.out.println(R("BFileLoc")+": "+location);
URL url = null;
if (new File(location).exists())
url = new File(location).toURL(); // Why use file.getCanonicalFile?
else
url = new URL(ServiceUtil.getBasicService().getCodeBase(), location);
boolean strict = (null != getOption("-strict"));
JNLPFile file = new JNLPFile(url, strict);
// add in extra params from command line
addProperties(file);
if (file.isApplet())
addParameters(file);
if (file.isApplication())
addArguments(file);
if (JNLPRuntime.isDebug()) {
if (getOption("-arg") != null)
if (file.isInstaller() || file.isApplet())
System.out.println(R("BArgsNA"));
if (getOption("-param") != null)
if (file.isApplication())
System.out.println(R("BParamNA"));
}
return file;
}
/**
* Add the properties to the JNLP file.
*/
private static void addProperties(JNLPFile file) {
String props[] = getOptions("-property");
ResourcesDesc resources = file.getResources();
for (int i=0; i < props.length; i++) {
// allows empty property, not sure about validity of that.
int equals = props[i].indexOf("=");
if (equals == -1)
fatalError(R("BBadProp", props[i]));
String key = props[i].substring(0, equals);
String value = props[i].substring(equals+1, props[i].length());
resources.addResource(new PropertyDesc(key, value));
}
}
/**
* Add the params to the JNLP file; only call if file is
* actually an applet file.
*/
private static void addParameters(JNLPFile file) {
String params[] = getOptions("-param");
AppletDesc applet = file.getApplet();
for (int i=0; i < params.length; i++) {
// allows empty param, not sure about validity of that.
int equals = params[i].indexOf("=");
if (equals == -1)
fatalError(R("BBadParam", params[i]));
String name = params[i].substring(0, equals);
String value = params[i].substring(equals+1, params[i].length());
applet.addParameter(name, value);
}
}
/**
* Add the arguments to the JNLP file; only call if file is
* actually an application (not installer).
*/
private static void addArguments(JNLPFile file) {
String args[] = getOptions("-arg"); // FYI args also global variable
ApplicationDesc app = file.getApplication();
for (int i=0; i < args.length; i++) {
app.addArgument(args[i]);
}
}
/**
* Return value of the first occurence of the specified
* option, or null if the option is not present. If the
* option is a flag (0-parameter) and is present then the
* option name is returned.
*/
private static String getOption(String option) {
String result[] = getOptions(option);
if (result.length == 0)
return null;
else
return result[0];
}
/**
* Return all the values of the specified option, or an empty
* array if the option is not present. If the option is a
* flag (0-parameter) and is present then the option name is
* returned once for each occurrence.
*/
private static String[] getOptions(String option) {
List result = new ArrayList();
for (int i=0; i < args.length; i++) {
if (option.equals(args[i])) {
if (-1 == doubleArgs.indexOf(option))
result.add(option);
else
if (i+1 < args.length)
result.add(args[i+1]);
}
if (args[i].startsWith("-") && -1 != doubleArgs.indexOf(args[i]))
i++;
}
return (String[]) result.toArray( new String[result.size()] );
}
/**
* Return the base dir. If the base dir parameter is not set
* the value is read from the "${user.home}/.netxrc" file (as
* defined by JNLPRuntime). If that file does not exist, an
* install dialog is displayed to select the base directory.
*/
private static File getBaseDir() {
if (getOption("-basedir") != null) {
File basedir = new File(getOption("-basedir"));
if (!basedir.exists() || !basedir.isDirectory())
fatalError(R("BNoDir", basedir));
return basedir;
}
// check .netxrc, display dialog
File basedir = JNLPRuntime.getDefaultBaseDir();
if (basedir == null)
fatalError(R("BNoBase"));
return basedir;
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/Boot13.java 0000666 0001750 0001750 00000007424 07622737604 021142 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.lang.reflect.*;
import java.io.*;
import java.net.*;
import java.security.*;
import javax.swing.*;
/**
* Allows a Policy and SecurityManager to be set in JRE1.3 without
* running the code with only applet permissions; this class is
* for backward compatibility only and is totally unnecessary if
* running in jdk 1.4 or later (can call Boot directly).
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.5 $
*/
public class Boot13 extends URLClassLoader {
// The problem with setting a Policy in jdk1.3 is that the
// system and application classes seem to be loaded in such a
// way that only their protection domain determines the
// permissions; the policy object is never asked for permissions
// after the class is loaded. This hack creates a classloader
// that loads duplicate versions of the classes in such a
// manner where they ask with the policy object. The jdk1.4
// correctly honors the Policy object making this unneccessary
// post-1.3.
private Boot13(URL source[]) {
super(source);
}
protected PermissionCollection getPermissions(CodeSource source) {
Permissions result = new Permissions();
result.add( new AllPermission() );
return result;
}
public Class loadClass(String name) throws ClassNotFoundException {
Class c = findLoadedClass(name);
if (c != null)
return c;
// reverse the search order so that classes from this
// classloader, which sets the right permissions, are found
// before the parent classloader which has the same classes
// but the wrong permissions.
try {
return findClass(name);
}
catch (ClassNotFoundException ex) {
}
return getParent().loadClass(name);
}
public static void main(final String args[]) throws Exception {
URL cs = Boot13.class.getProtectionDomain().getCodeSource().getLocation();
// instead of using a custom loadClass search order, we could
// put the classes in a boot/ subdir of the JAR and load
// them from there. This would be an improvement by not
// allowing applications to get a duplicate jnlp engine (one
// with applet access permissions) by using the system
// classloader but a drawback by not allowing Boot to be
// called directly.
//cs = new URL("jar:"+cs+"!/boot/");
if (cs == null) {
System.err.println("fatal: cannot determine code source.");
System.exit(1);
}
Boot13 b = new Boot13(new URL[] {cs});
Thread.currentThread().setContextClassLoader(b); // try to prevent getting the non-policy version of classes
Class c = b.loadClass("netx.jnlp.runtime.Boot");
Method main = c.getDeclaredMethod("main", new Class[] {String[].class} );
main.invoke(null, new Object[] { args } );
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/InstallDialog.java 0000666 0001750 0001750 00000012657 07622777136 022631 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.List;
import javax.swing.*;
import javax.jnlp.*;
import netx.jnlp.*;
/**
* Prompt for an install location.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.7 $
*/
class InstallDialog extends Dialog implements ActionListener {
private static String R(String key) { return JNLPRuntime.getMessage(key); }
private ImageIcon background;
private TextField installField = new TextField();
private Button ok = new Button(R("ButOk"));
private Button cancel = new Button(R("ButCancel"));
private Button browse = new Button(R("ButBrowse"));
private boolean canceled = false;
static Frame createFrame() {
Frame f = new Frame();
f.setIconImage(JNLPRuntime.getWindowIcon());
return f;
}
InstallDialog() {
super(createFrame(), R("CChooseCache"), true);
background =
new ImageIcon(getClass().getClassLoader().getResource("netx/jnlp/resources/install.png"));
setLayout(new BorderLayout());
setBackground(Color.white);
String home = System.getProperty("java.io.tmpdir");
installField.setText((new File(home)).toString());
ok.addActionListener(this);
cancel.addActionListener(this);
browse.addActionListener(this);
Font f = new Font("SansSerif", Font.BOLD, 14);
installField.setFont(f);
ok.setFont(f);
cancel.setFont(f);
browse.setFont(f);
Panel top = new Panel(new GridLayout(2, 1, 0, 10));
Label l1 = new Label(R("CChooseCacheInfo"));
Label l2 = new Label(R("CChooseCacheDir")+":");
l1.setFont(f);
l2.setFont(f);
top.add(l1);
top.add(l2);
Panel field = new Panel(new BorderLayout());
field.add(top, BorderLayout.NORTH);
field.add(installField, BorderLayout.CENTER);
field.add(browse, BorderLayout.EAST);
Panel grid = new Panel(new GridLayout(1, 2, 8, 8));
grid.add(ok);
grid.add(cancel);
Panel choice = new Panel(new FlowLayout(FlowLayout.CENTER, 4, 0));
choice.add(grid);
add(field, BorderLayout.NORTH);
add(new Panel(), BorderLayout.CENTER);
add(choice, BorderLayout.SOUTH);
}
public Insets getInsets() {
Insets s = super.getInsets();
return new Insets(s.top + 55, s.left + 7, s.bottom + 6, s.right + 4);
//return new Insets(s.top + 115, s.left + 7, s.bottom + 6, s.right + 4);
}
public Dimension getPreferredSize() {
Dimension d = super.getPreferredSize();
if (background == null)
return d;
Insets in = super.getInsets();
d.width = background.getIconWidth() + in.left + in.right;
d.height = Math.max(d.height + 8, background.getIconHeight() + 8 + in.top + in.bottom);
return d;
}
public void paint(Graphics g) {
Insets sin = super.getInsets();
g.drawImage(background.getImage(), sin.left, sin.top, this);
}
public void actionPerformed(ActionEvent evt) {
if (evt.getSource() == cancel) {
canceled = true;
dispose();
}
if (evt.getSource() == ok) {
File f = new File(installField.getText());
try {
f.mkdirs();
dispose();
}
catch (Exception ex) {
JOptionPane.showMessageDialog(this, "Install directory cannot be created.",
"ERROR", JOptionPane.ERROR_MESSAGE);
}
}
if (evt.getSource() == browse) {
JFileChooser fc = new JFileChooser();
fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
int r = fc.showOpenDialog(this);
if (r == JFileChooser.APPROVE_OPTION)
installField.setText(fc.getSelectedFile().toString());
}
}
static File getInstallDir() {
InstallDialog id = new InstallDialog();
//id.setResizable(false);
id.pack();
Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
id.setLocation(screen.width/2-id.getWidth()/2,
screen.height/2-id.getHeight()/2);
id.show();
if (id.canceled)
return null;
return new File(id.installField.getText());
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/JNLPClassLoader.java 0000666 0001750 0001750 00000047756 07623742570 022766 0 ustar god god
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.jar.*;
import java.security.*;
import java.lang.reflect.*;
import javax.jnlp.*;
import netx.jnlp.cache.*;
import netx.jnlp.*;
/**
* Classloader that takes it's resources from a JNLP file. If the
* JNLP file defines extensions, separate classloaders for these
* will be created automatically. Classes are loaded with the
* security context when the classloader was created.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.20 $
*/
public class JNLPClassLoader extends URLClassLoader {
// todo: initializePermissions should get the permissions from
// extension classes too so that main file classes can load
// resources in an extension.
/** map from JNLPFile url to shared classloader */
private static Map urlToLoader = new HashMap(); // never garbage collected!
/** number of times a classloader with native code is created */
private static int nativeCounter = 0;
/** the directory for native code */
private File nativeDir = null; // if set, some native code exists
/** security context */
private AccessControlContext acc = AccessController.getContext();
/** the permissions for the cached jar files */
private List resourcePermissions;
/** the app */
private ApplicationInstance app = null; // here for faster lookup in security manager
/** list of this, local and global loaders this loader uses */
private JNLPClassLoader loaders[] = null; // ..[0]==this
/** whether to strictly adhere to the spec or not */
private boolean strict = true;
/** loads the resources */
private ResourceTracker tracker = new ResourceTracker(true); // prefetch
/** the update policy for resources */
private UpdatePolicy updatePolicy;
/** the JNLP file */
private JNLPFile file;
/** the resources section */
private ResourcesDesc resources;
/** the security section */
private SecurityDesc security;
/** all jars not yet part of classloader or active */
private List available = new ArrayList();
/**
* Create a new JNLPClassLoader from the specified file.
*
* @param file the JNLP file
*/
protected JNLPClassLoader(JNLPFile file, UpdatePolicy policy) {
super(new URL[0], JNLPClassLoader.class.getClassLoader());
if (JNLPRuntime.isDebug())
System.out.println("New classloader: "+file.getFileLocation());
this.file = file;
this.updatePolicy = policy;
this.resources = file.getResources();
this.security = file.getSecurity();
// initialize extensions
initializeExtensions();
// initialize permissions
initializePermissions();
// populate the resource tracker and load the inital jars
initializeResources();
}
/**
* Returns a JNLP classloader for the specified JNLP file.
*
* @param file the file to load classes for
* @param policy the update policy to use when downloading resources
*/
public static JNLPClassLoader getInstance(JNLPFile file, UpdatePolicy policy) {
JNLPClassLoader loader = null;
URL location = file.getFileLocation();
if (location != null)
loader = (JNLPClassLoader) urlToLoader.get(location);
if (loader == null)
loader = new JNLPClassLoader(file, policy);
if (file.getInformation().isSharingAllowed())
urlToLoader.put(location, loader);
return loader;
}
/**
* Returns a JNLP classloader for the JNLP file at the specified
* location.
*
* @param location the file's location
* @param policy the update policy to use when downloading resources
*/
public static JNLPClassLoader getInstance(URL location, UpdatePolicy policy) throws IOException, ParseException {
JNLPClassLoader loader = (JNLPClassLoader) urlToLoader.get(location);
if (loader == null)
loader = getInstance(new JNLPFile(location, false, policy), policy);
return loader;
}
/**
* Load the extensions specified in the JNLP file.
*/
void initializeExtensions() {
ExtensionDesc ext[] = resources.getExtensions();
List loaderList = new ArrayList();
loaderList.add(this);
for (int i=0; i < ext.length; i++) {
try {
JNLPClassLoader loader = getInstance(ext[i].getLocation(), updatePolicy);
loaderList.add(loader);
}
catch (Exception ex) {
if (JNLPRuntime.isDebug())
ex.printStackTrace();
// should throw an exception here?
}
}
loaders = (JNLPClassLoader[]) loaderList.toArray(new JNLPClassLoader[ loaderList.size()]);
}
/**
* Make permission objects for the classpath.
*/
void initializePermissions() {
resourcePermissions = new ArrayList();
JARDesc jars[] = resources.getJARs();
for (int i=0; i < jars.length; i++) {
Permission p = CacheUtil.getReadPermission(jars[i].getLocation(),
jars[i].getVersion());
if (p != null)
resourcePermissions.add(p);
}
}
/**
* Load all of the JARs used in this JNLP file into the
* ResourceTracker for downloading.
*/
void initializeResources() {
JARDesc jars[] = resources.getJARs();
List initialJars = new ArrayList();
for (int i=0; i < jars.length; i++) {
available.add(jars[i]);
if (jars[i].isEager())
initialJars.add(jars[i]); // regardless of part
tracker.addResource(jars[i].getLocation(),
jars[i].getVersion(),
JNLPRuntime.getDefaultUpdatePolicy()
);
}
if (strict)
fillInPartJars(initialJars); // add in each initial part's lazy jars
activateJars(initialJars);
}
/**
* Add applet's codebase URL. This allows compatibility with
* applets that load resources from their codebase instead of
* through JARs, but can slow down resource loading. Resources
* loaded from the codebase are not cached.
*/
public void enableCodeBase() {
addURL( file.getCodeBase() ); // nothing happens if called more that once?
}
/**
* Sets the JNLP app this group is for; can only be called once.
*/
public void setApplication(ApplicationInstance app) {
if (this.app != null) {
if (JNLPRuntime.isDebug()) {
Exception ex = new IllegalStateException("Application can only be set once");
ex.printStackTrace();
}
return;
}
this.app = app;
}
/**
* Returns the JNLP app for this classloader
*/
public ApplicationInstance getApplication() {
return app;
}
/**
* Returns the JNLP file the classloader was created from.
*/
public JNLPFile getJNLPFile() {
return file;
}
/**
* Returns the permissions for the CodeSource.
*/
protected PermissionCollection getPermissions(CodeSource cs) {
Permissions result = new Permissions();
// should check for extensions or boot, automatically give all
// access w/o security dialog once we actually check certificates.
// copy security permissions from SecurityDesc element
Enumeration e = security.getPermissions().elements();
while (e.hasMoreElements())
result.add((Permission) e.nextElement());
// add in permission to read the cached JAR files
for (int i=0; i < resourcePermissions.size(); i++)
result.add((Permission) resourcePermissions.get(i));
return result;
}
/**
* Adds to the specified list of JARS any other JARs that need
* to be loaded at the same time as the JARs specified (ie, are
* in the same part).
*/
protected void fillInPartJars(List jars) {
for (int i=0; i < jars.size(); i++) {
String part = ((JARDesc) jars.get(i)).getPart();
for (int a=0; a < available.size(); a++) {
JARDesc jar = (JARDesc) available.get(a);
if (part != null && part.equals(jar.getPart()))
if (!jars.contains(jar))
jars.add(jar);
}
}
}
/**
* Ensures that the list of jars have all been transferred, and
* makes them available to the classloader. If a jar contains
* native code, the libraries will be extracted and placed in
* the path.
*
* @param jars the list of jars to load
*/
protected void activateJars(final List jars) {
PrivilegedAction activate = new PrivilegedAction() {
public Object run() {
// transfer the Jars
waitForJars(jars);
for (int i=0; i < jars.size(); i++) {
JARDesc jar = (JARDesc) jars.get(i);
available.remove(jar);
// add jar
File localFile = tracker.getCacheFile(jar.getLocation());
try {
URL location = jar.getLocation(); // non-cacheable, use source location
if (localFile != null)
location = localFile.toURL(); // cached file
addURL(location);
if (JNLPRuntime.isDebug())
System.err.println("Activate jar: "+location);
}
catch (Exception ex) {
if (JNLPRuntime.isDebug())
ex.printStackTrace();
}
if (jar.isNative())
activateNative(jar);
}
return null;
}
};
AccessController.doPrivileged(activate, acc);
}
/**
* Enable the native code contained in a JAR by copying the
* native files into the filesystem. Called in the security
* context of the classloader.
*/
protected void activateNative(JARDesc jar) {
if (JNLPRuntime.isDebug())
System.out.println("Activate native: "+jar.getLocation());
File localFile = tracker.getCacheFile(jar.getLocation());
if (localFile == null)
return;
if (nativeDir == null)
nativeDir = getNativeDir();
try {
JarFile jarFile = new JarFile(localFile, false);
Enumeration entries = jarFile.entries();
while (entries.hasMoreElements()) {
JarEntry e = (JarEntry) entries.nextElement();
if (e.isDirectory() || e.getName().indexOf('/') != -1)
continue;
File outFile = new File(nativeDir, e.getName());
CacheUtil.streamCopy(jarFile.getInputStream(e),
new FileOutputStream(outFile));
}
}
catch (IOException ex) {
if (JNLPRuntime.isDebug())
ex.printStackTrace();
}
}
/**
* Return the base directory to store native code files in.
* This method does not need to return the same directory across
* calls.
*/
protected File getNativeDir() {
nativeDir = new File(System.getProperty("java.io.tmpdir")
+ File.separator + "netx-native-"
+ (new Random().nextInt() & 0xFFFF));
if (!nativeDir.mkdirs())
return null;
else
return nativeDir;
}
/**
* Return the absolute path to the native library.
*/
protected String findLibrary(String lib) {
if (nativeDir == null)
return null;
String syslib = System.mapLibraryName(lib);
File target = new File(nativeDir, syslib);
if (target.exists())
return target.toString();
else {
String result = super.findLibrary(lib);
if (result != null)
return result;
return findLibraryExt(lib);
}
}
/**
* Try to find the library path from another peer classloader.
*/
protected String findLibraryExt(String lib) {
for (int i=0; i < loaders.length; i++) {
String result = null;
if (loaders[i] != this)
result = loaders[i].findLibrary(lib);
if (result != null)
return result;
}
return null;
}
/**
* Wait for a group of JARs, and send download events if there
* is a download listener or display a progress window otherwise.
*
* @param jars the jars
*/
private void waitForJars(List jars) {
URL urls[] = new URL[jars.size()];
for (int i=0; i < jars.size(); i++) {
JARDesc jar = (JARDesc) jars.get(i);
urls[i] = jar.getLocation();
}
CacheUtil.waitForResources(app, tracker, urls, file.getTitle());
}
/**
* Find the loaded class in this loader or any of its extension loaders.
*/
protected Class findLoadedClassAll(String name) {
for (int i=0; i < loaders.length; i++) {
Class result = null;
if (loaders[i] == this)
result = super.findLoadedClass(name);
else
result = loaders[i].findLoadedClassAll(name);
if (result != null)
return result;
}
return null;
}
/**
* Find a JAR in the shared 'extension' classloaders, this
* classloader, or one of the classloaders for the JNLP file's
* extensions.
*/
public Class loadClass(String name) throws ClassNotFoundException {
Class result = findLoadedClassAll(name);
// try parent classloader
if (result == null) {
try {
ClassLoader parent = getParent();
if (parent == null)
parent = ClassLoader.getSystemClassLoader();
return parent.loadClass(name);
}
catch (ClassNotFoundException ex) { }
}
// filter out 'bad' package names like java, javax
// validPackage(name);
// search this and the extension loaders
if (result == null)
result = loadClassExt(name);
return result;
}
/**
* Find the class in this loader or any of its extension loaders.
*/
protected Class findClass(String name) throws ClassNotFoundException {
for (int i=0; i < loaders.length; i++) {
try {
if (loaders[i] == this)
return super.findClass(name);
else
return loaders[i].findClass(name);
}
catch(ClassNotFoundException ex) { }
}
throw new ClassNotFoundException(name);
}
/**
* Search for the class by incrementally adding resources to the
* classloader and its extension classloaders until the resource
* is found.
*/
private Class loadClassExt(String name) throws ClassNotFoundException {
// make recursive
addAvailable();
// find it
try {
return findClass(name);
}
catch(ClassNotFoundException ex) {
}
// add resources until found
while (true) {
JNLPClassLoader addedTo = addNextResource();
if (addedTo == null)
throw new ClassNotFoundException(name);
try {
return addedTo.findClass(name);
}
catch(ClassNotFoundException ex) {
}
}
}
/**
* Finds the resource in this, the parent, or the extension
* class loaders.
*/
public URL getResource(String name) {
URL result = super.getResource(name);
for (int i=1; i < loaders.length; i++)
if (result == null)
result = loaders[i].getResource(name);
return result;
}
/**
* Finds the resource in this, the parent, or the extension
* class loaders.
*/
public Enumeration findResources(String name) throws IOException {
Vector resources = new Vector();
for (int i=0; i < loaders.length; i++) {
Enumeration e;
if (loaders[i] == this)
e = super.findResources(name);
else
e = loaders[i].findResources(name);
while (e.hasMoreElements())
resources.add(e.nextElement());
}
return resources.elements();
}
/**
* Adds whatever resources have already been downloaded in the
* background.
*/
protected void addAvailable() {
// go through available, check tracker for it and all of its
// part brothers being available immediately, add them.
for (int i=1; i < loaders.length; i++) {
loaders[i].addAvailable();
}
}
/**
* Adds the next unused resource to the classloader. That
* resource and all those in the same part will be downloaded
* and added to the classloader before returning. If there are
* no more resources to add, the method returns immediately.
*
* @return the classloader that resources were added to, or null
*/
protected JNLPClassLoader addNextResource() {
if (available.size() == 0) {
for (int i=1; i < loaders.length; i++) {
JNLPClassLoader result = loaders[i].addNextResource();
if (result != null)
return result;
}
return null;
}
// add jar
List jars = new ArrayList();
jars.add(available.get(0));
fillInPartJars(jars);
activateJars(jars);
return this;
}
// this part compatibility with previous classloader
/**
* @deprecated
*/
public String getExtensionName() {
String result = file.getInformation().getTitle();
if (result == null)
result = file.getInformation().getDescription();
if (result == null && file.getFileLocation() != null)
result = file.getFileLocation().toString();
if (result == null && file.getCodeBase() != null)
result = file.getCodeBase().toString();
return result;
}
/**
* @deprecated
*/
public String getExtensionHREF() {
return file.getFileLocation().toString();
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/JNLPPolicy.java 0000666 0001750 0001750 00000005341 07622737604 022012 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.awt.*;
import javax.swing.*;
import java.security.*;
/**
* Policy for JNLP environment. This class delegates to the
* system policy but always grants permissions to the JNLP code
* and system CodeSources (no separate policy file needed). This
* class may also grant permissions to applications at runtime if
* approved by the user.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.7 $
*/
public class JNLPPolicy extends Policy {
/** classes from this source have all permissions */
private static CodeSource shellSource;
/** classes from this source have all permissions */
private static CodeSource systemSource;
/** the previous policy */
private static Policy systemPolicy;
protected JNLPPolicy() {
shellSource = JNLPPolicy.class.getProtectionDomain().getCodeSource();
systemSource = Policy.class.getProtectionDomain().getCodeSource();
systemPolicy = Policy.getPolicy();
}
/**
* Return a mutable, heterogeneous-capable permission collection
* for the source.
*/
public PermissionCollection getPermissions(CodeSource source) {
if (source == null
|| source.equals(systemSource)
|| source.equals(shellSource))
return getAllPermissions();
// if we check the SecurityDesc here then keep in mind that
// code can add properties at runtime to the ResourcesDesc!
// delegate to original Policy object; required to run under WebStart
return systemPolicy.getPermissions(source);
}
/**
* Refresh.
*/
public void refresh() {
// no op
}
/**
* Return an all-permissions collection.
*/
private Permissions getAllPermissions() {
Permissions result = new Permissions();
result.add( new AllPermission() );
return result;
}
}
libnetx-java-0.5.orig/src/netx/jnlp/runtime/JNLPRuntime.java 0000666 0001750 0001750 00000032526 07624373362 022202 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.runtime;
import java.io.*;
import java.awt.*;
import java.text.*;
import java.util.*;
import java.security.*;
import javax.jnlp.*;
import netx.jnlp.*;
import netx.jnlp.cache.*;
import netx.jnlp.util.*;
import netx.jnlp.services.*;
/**
* Configure and access the runtime environment. This class
* stores global jnlp properties such as default download
* indicators, the install/base directory, the default resource
* update policy, etc. Some settings, such as the base directory,
* cannot be changed once the runtime has been initialized.java.awt.headless=true).
*
* @throws IllegalStateException if the runtime was previously initialized
*/
public static void setHeadless(boolean enabled) {
checkInitialized();
headless = enabled;
}
/**
* Return the base directory containing the cache, persistence
* store, etc.
*/
public static File getBaseDir() {
return baseDir;
}
/**
* Sets the base directory containing the cache, persistence
* store, etc.
*
* @throws IllegalStateException if caller is not the exit class
*/
public static void setBaseDir(File baseDirectory) {
checkInitialized();
baseDir = baseDirectory;
}
/**
* Returns whether the secure runtime environment is enabled.
*/
public static boolean isSecurityEnabled() {
return securityEnabled;
}
/**
* Sets whether to enable the secure runtime environment.
* Disabling security can increase performance for some
* applications, and can be used to use netx with other code
* that uses its own security manager or policy.
*
* Disabling security is not recommended and should only be
* used if the JNLP files opened are trusted. This method can
* only be called before initalizing the runtime.Package Specification
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see:
libnetx-java-0.5.orig/src/netx/jnlp/SecurityDesc.java 0000666 0001750 0001750 00000014071 07622737604 021012 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp;
import java.io.*;
import java.net.*;
import java.util.*;
import java.security.*;
import java.awt.AWTPermission;
/**
* The security element.
*
* @author Jon A. Maxwell (JAM) - initial author
* @version $Revision: 1.7 $
*/
public class SecurityDesc {
// todo: make sure classloader's native code support checks
// the security permissions
// shouldn't need to verify that native code only runs in
// trusted environment because the parser and/or classloader
// should kick it.
/** All permissions. */
public static final Object ALL_PERMISSIONS = "All";
/** Applet permissions. */
public static final Object SANDBOX_PERMISSIONS = "Sandbox";
/** J2EE permissions. */
public static final Object J2EE_PERMISSIONS = "J2SE";
/** permissions type */
private Object type;
/** the download host */
private String downloadHost;
/** the JNLP file */
private JNLPFile file;
/** basic permissions for restricted mode */
private static Permission j2eePermissions[] = {
new AWTPermission("accessClipboard"),
// disabled because we can't at this time prevent an
// application from accessing other applications' event
// queues, or even prevent access to security dialog queues.
//
// new AWTPermission("accessEventQueue"),
new AWTPermission("showWindowWithoutWarningBanner"),
new RuntimePermission("exitVM"),
new RuntimePermission("loadLibrary"),
new RuntimePermission("queuePrintJob"),
new SocketPermission("*", "connect"),
new SocketPermission("localhost:1024-", "accept, listen"),
new FilePermission("*", "read, write"),
new PropertyPermission("*", "read"),
};
/** basic permissions for restricted mode */
private static Permission sandboxPermissions[] = {
new SocketPermission("localhost:1024-", "listen"),
// new SocketPermission("Package Specification
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see:
libnetx-java-0.5.orig/src/netx/jnlp/services/ServiceUtil.java 0000666 0001750 0001750 00000012300 07622737604 022456 0 ustar god god // Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package netx.jnlp.services;
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.reflect.*;
import java.security.*;
import javax.jnlp.*;
import netx.jnlp.*;
import netx.jnlp.runtime.*;
/**
* Provides static methods to interact useful for using the JNLP
* services.
Under construction.
double-click .JAR file (must have Java installed)
Command Line:
java -jar netx.jar [parameters]
java -classpath netx.jar netx.jnlp.runtime.Boot [parameters]
Usage: java -jar netx.jar [-options] -jnlp location
-basedir dir Directory where the cache is kept.
-jnlp location Location of JNLP file to launch (url or file).
-arg arg Adds an application argument before launching.
-param name=value Adds an applet parameter before launching.
-property name=value Sets a system property before launching.
-update seconds Update check if seconds since last checked.
-license Display the GPL license and exit.
-verbose Enable verbose output.
-about Streamed from the internet.
-nosecurity Disables the secure runtime environment.
-noupdate Disables checking for updates.
-headless Disables download window, other UIs.
-strict Enables strict checking of JNLP file format.
-help Print this message and exit.
Will have instructions on use of API in other
programs, design, etc.
Basically, create a netx.jnlp.JNLPFile object
for the JNLP file and start it using a
netx.jnlp.Launcher instance. Use
netx.jnlp.runtime.JNLPRuntime to control the
overall behavior and options.