This commit was manufactured by cvs2svn to create tag 'Last140MergeSource'.

git-svn-id: svn://10.0.0.236/tags/Last140MergeSource@10343 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/js/src/liveconnect/MANIFEST

@@ -0,0 +1,5 @@
+# This is a list of local files which get copied to the mozilla:dist directory
+#
+
+jsjava.h
+nsILiveconnect.h

mozilla/js/src/liveconnect/Makefile

@@ -0,0 +1,89 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+
+
+DEPTH		= ../../..
+
+include $(DEPTH)/config/config.mk
+
+ifdef NSJVM
+DIRS		= classes
+endif
+
+MODULE		= java
+LIBRARY_NAME	= jsj
+
+REQUIRES	= java js applet nspr img util layer xpcom
+
+CSRCS = jsj.c		  \
+	jsj_JSObject.c	  \
+	jsj_JavaArray.c	  \
+	jsj_JavaClass.c	  \
+	jsj_JavaMember.c  \
+	jsj_JavaObject.c  \
+	jsj_JavaPackage.c \
+	jsj_array.c	  \
+	jsj_class.c	  \
+	jsj_convert.c	  \
+	jsj_field.c	  \
+	jsj_hash.c	  \
+	jsj_method.c	  \
+	jsj_utils.c		\
+    nsCLiveconnect.c          \
+	nsCLiveconnectFactory.c
+
+
+LLIBS=$(LIBNSPR) $(DIST)/lib/js$(MOZ_BITS)$(VERSION_NUMBER).lib \
+ $(DIST)/lib/xpcom32.lib	
+
+
+ifdef NSJVM
+JNI_GEN		= netscape.javascript.JSObject netscape.javascript.JSException
+endif
+
+EXPORTS		= jsjava.h \
+		  $(JNI_GEN_DIR)/netscape_javascript_JSObject.h \
+		  $(JNI_GEN_DIR)/netscape_javascript_JSException.h \
+		  nsILiveconnect.h \
+		  $(NULL)
+
+
+
+include $(DEPTH)/config/rules.mk
+
+######################################################################
+
+# Generate jsj_nodl.c (so that you can check it in)
+# These make rules only works on IRIX...sigh
+
+ifeq ($(OS_ARCH),IRIX)
+jsj_nodl.c: $(OBJDIR)/stubs.o Makefile $(DEPTH)/config/nodl.pl
+	rm -f $@
+	$(PERL) $(DEPTH)/config/nodl.pl "jsj_nodl_tab" \
+	    `nm -Bn $(OBJDIR)/stubs.o | egrep Java_.*_stub | awk '{print $$3;}'` > $@
+endif
+
+ifdef JAVA_OR_OJI
+$(OBJDIR)/stubs.o:					 \
+	$(JNI_GEN_DIR)/netscape_javascript_JSObject.c	 \
+	$(JNI_GEN_DIR)/netscape_javascript_JSException.c \
+	$(NULL)
+else
+$(OBJDIR)/stubs.o:
+endif
+

mozilla/js/src/liveconnect/Makefile.in

@@ -0,0 +1,90 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+include $(topsrcdir)/config/config.mk
+
+ifdef NSJVM
+DIRS		= classes
+endif
+
+
+MODULE		= java
+LIBRARY_NAME	= jsj
+
+REQUIRES	= java js applet nspr img util layer xpcom caps oji plugin
+
+CSRCS = jsj.c		  \
+	jsj_JSObject.c	  \
+	jsj_JavaArray.c	  \
+	jsj_JavaClass.c	  \
+	jsj_JavaMember.c  \
+	jsj_JavaObject.c  \
+	jsj_JavaPackage.c \
+	jsj_array.c	  \
+	jsj_class.c	  \
+	jsj_convert.c	  \
+	jsj_field.c	  \
+	jsj_hash.c	  \
+	jsj_method.c	  \
+	jsj_utils.c
+ nsCLiveconnect.c  \
+	nsCLiveconnectFactory.c
+
+
+ifdef NSJVM
+JNI_GEN		= netscape.javascript.JSObject netscape.javascript.JSException
+endif
+
+EXPORTS		= $(srcdir)/jsjava.h \
+		  $(srcdir)/$(JNI_GEN_DIR)/netscape_javascript_JSObject.h \
+		  $(srcdir)/$(JNI_GEN_DIR)/netscape_javascript_JSException.h \
+		  $(NULL)
+
+
+
+include $(topsrcdir)/config/rules.mk
+
+######################################################################
+
+# Generate jsj_nodl.c (so that you can check it in)
+# These make rules only works on IRIX...sigh
+
+ifeq ($(OS_ARCH),IRIX)
+jsj_nodl.c: $(OBJDIR)/stubs.o Makefile $(topsrcdir)/config/nodl.pl
+	rm -f $@
+	$(PERL) $(topsrcdir)/config/nodl.pl "jsj_nodl_tab" \
+	    `nm -Bn $(OBJDIR)/stubs.o | egrep Java_.*_stub | awk '{print $$3;}'` > $@
+endif
+
+ifdef JAVA_OR_OJI
+$(OBJDIR)/stubs.o:					 \
+	$(JRI_GEN_DIR)/netscape_javascript_JSObject.c	 \
+	$(JRI_GEN_DIR)/netscape_javascript_JSException.c \
+	$(NULL)
+else
+$(OBJDIR)/stubs.o:
+endif
+

mozilla/js/src/liveconnect/_jni/netscape_javascript_JSException.h

@@ -0,0 +1,14 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include "jni.h"
+
+/* Header for class netscape_javascript_JSException */
+
+#ifndef _Included_netscape_javascript_JSException
+#define _Included_netscape_javascript_JSException
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif

mozilla/js/src/liveconnect/_jni/netscape_javascript_JSObject.h

@@ -0,0 +1,102 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include "jni.h"
+
+/* Header for class netscape_javascript_JSObject */
+
+#ifndef _Included_netscape_javascript_JSObject
+#define _Included_netscape_javascript_JSObject
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    initClass
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_netscape_javascript_JSObject_initClass
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    getMember
+ * Signature: (Ljava/lang/String;)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_netscape_javascript_JSObject_getMember
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    getSlot
+ * Signature: (I)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_netscape_javascript_JSObject_getSlot
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    setMember
+ * Signature: (Ljava/lang/String;Ljava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_netscape_javascript_JSObject_setMember
+  (JNIEnv *, jobject, jstring, jobject);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    setSlot
+ * Signature: (ILjava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_netscape_javascript_JSObject_setSlot
+  (JNIEnv *, jobject, jint, jobject);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    removeMember
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_netscape_javascript_JSObject_removeMember
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    call
+ * Signature: (Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_netscape_javascript_JSObject_call
+  (JNIEnv *, jobject, jstring, jobjectArray);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    eval
+ * Signature: (Ljava/lang/String;)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_netscape_javascript_JSObject_eval
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    toString
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_netscape_javascript_JSObject_toString
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    getWindow
+ * Signature: (Ljava/applet/Applet;)Lnetscape/javascript/JSObject;
+ */
+JNIEXPORT jobject JNICALL Java_netscape_javascript_JSObject_getWindow
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    finalize
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_netscape_javascript_JSObject_finalize
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

mozilla/js/src/liveconnect/classes/Makefile

@@ -0,0 +1,65 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+
+
+DEPTH		= ../../../..
+
+MODULE		= java
+
+#
+# the idea is that the install phase for those modules will
+# make their own signed jar files
+# there are some exceptions here that we deal with
+# stuff in modules and in ns/js/jsj
+#
+JMODS		= netscape/javascript netscape/javascript/adapters
+
+#
+# JDIRS is dependant on JAVA_DESTPATH in config/rules.m[a]k. 
+# Be sure to touch that directory if you add a new directory to
+# JDIRS, or else it will not build. FIXME
+#
+JDIRS		= $(JMODS)
+
+JAR_JSJ		= jsj10.jar
+JAR_JSJ_CLASSES	= $(JMODS)  
+
+#
+# jars to build at install time
+#
+JARS		= $(JAR_JSJ)
+
+include $(DEPTH)/config/rules.mk
+
+JAVA_SOURCEPATH	= $(DEPTH)/js/src/liveconnect/classes
+
+doc::
+	$(JAVADOC) -d $(DIST)/doc netscape.javascript
+
+natives_list:: FORCE
+	rm -rf $@
+	find . -name "*.class" -print | sed 's@\./\(.*\)\.class$$@\1@' | \
+		sed 's@/@.@g' | xargs $(JVH) -natives | sort > $@
+
+check_natives:: natives_list
+	rm -f found_natives
+	nm -B	../$(OBJDIR)/*.o \
+	    | egrep "Java.*_stub" | awk '{ print $$3; }' | sort > found_natives
+	diff found_natives natives_list
+
+FORCE:

mozilla/js/src/liveconnect/classes/Makefile.in

@@ -0,0 +1,70 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+
+
+DEPTH		= ../../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= java
+
+#
+# the idea is that the install phase for those modules will
+# make their own signed jar files
+# there are some exceptions here that we deal with
+# stuff in modules and in ns/js/jsj
+#
+JMODS		= netscape/javascript netscape/javascript/adapters
+
+#
+# JDIRS is dependant on JAVA_DESTPATH in config/rules.m[a]k. 
+# Be sure to touch that directory if you add a new directory to
+# JDIRS, or else it will not build. FIXME
+#
+JDIRS		= $(JMODS)
+
+JAR_JSJ		= jsj10.jar
+JAR_JSJ_CLASSES	= $(JMODS)  
+
+#
+# jars to build at install time
+#
+JARS		= $(JAR_JSJ)
+
+include $(topsrcdir)/config/rules.mk
+
+JAVA_SOURCEPATH	= $(topsrcdir)/js/src/liveconnect/classes
+
+doc::
+	$(JAVADOC) -d $(DIST)/doc netscape.javascript
+
+natives_list:: FORCE
+	rm -rf $@
+	find . -name "*.class" -print | sed 's@\./\(.*\)\.class$$@\1@' | \
+		sed 's@/@.@g' | xargs $(JVH) -natives | sort > $@
+
+check_natives:: natives_list
+	rm -f found_natives
+	nm -B	../$(OBJDIR)/*.o \
+	    | egrep "Java.*_stub" | awk '{ print $$3; }' | sort > found_natives
+	diff found_natives natives_list
+
+FORCE:

mozilla/js/src/liveconnect/classes/makefile.win

@@ -0,0 +1,78 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+IGNORE_MANIFEST=1
+# 
+
+#//------------------------------------------------------------------------
+#//
+#// Makefile to build the JavaScript-Java tree
+#//
+#//------------------------------------------------------------------------
+
+DEPTH = ..\..\..\..
+
+JAVA_SOURCEPATH=$(DEPTH)\js\src\liveconnect\classes
+
+#//------------------------------------------------------------------------
+#// 
+#// Define the files necessary to build the target (ie. OBJS)
+#//
+#//------------------------------------------------------------------------
+include <$(DEPTH)\config\config.mak>
+
+JMOZ =  \
+        netscape/javascript		\
+	$(NULL)
+
+
+all::
+
+MODULE=java 
+JMODS=netscape/javascript
+!ifdef JAVA_OR_NSJVM
+JDIRS=$(JMODS) 
+JAR_JSJ_CLASSES=$(JMODS) 
+JAR_NAME = jsj10.jar
+!endif
+
+include <$(DEPTH)\config\rules.mak>
+
+!ifdef JAVA_OR_NSJVM
+install:: 
+	cd $(JAVA_DESTPATH)
+	@echo +++ building/updating $(JAR_NAME)
+	-for %i in ($(JAR_JSJ_CLASSES:/=\)) do @$(ZIP_PROG) $(ZIP_FLAGS) $(JAR_NAME) %i\*.class
+	cd $(MAKEDIR)
+
+!ifdef REGENERATE
+install::
+	cd $(JAVA_DESTPATH)
+	@echo +++ updating $(DEPTH)\nav-java\stubs\classes\$(JAR_NAME) for checkin
+	-for %i in ($(JAR_JSJ_CLASSES:/=\)) do @$(ZIP_PROG) $(ZIP_FLAGS) ..\..\nav-java\stubs\classes\$(JAR_NAME) %i\*.class
+	cd $(MAKEDIR)
+!endif
+!endif
+
+javadoc:
+	-mkdir $(XPDIST)\javadoc 2> NUL
+	echo $(JAVADOC) -sourcepath . -d $(XPDIST)\javadoc $(JDIRS:/=.)
+	$(JAVADOC) -sourcepath . -d $(XPDIST)\javadoc $(JDIRS:/=.)
+
+
+
+

mozilla/js/src/liveconnect/classes/netscape/javascript/JSException.java

@@ -0,0 +1,56 @@
+/* Insert copyright and license here 19** */
+
+package netscape.javascript;
+
+/**
+ * JSException is an exception which is thrown when JavaScript code
+ * returns an error.
+ */
+
+public
+class JSException extends Exception {
+    String filename;
+    int lineno;
+    String source;
+    int tokenIndex;
+
+    /**
+     * Constructs a JSException without a detail message.
+     * A detail message is a String that describes this particular exception.
+     */
+    public JSException() {
+	super();
+        filename = "unknown";
+        lineno = 0;
+        source = "";
+        tokenIndex = 0;
+    }
+
+    /**
+     * Constructs a JSException with a detail message.
+     * A detail message is a String that describes this particular exception.
+     * @param s the detail message
+     */
+    public JSException(String s) {
+	super(s);
+        filename = "unknown";
+        lineno = 0;
+        source = "";
+        tokenIndex = 0;
+    }
+
+    /**
+     * Constructs a JSException with a detail message and all the
+     * other info that usually comes with a JavaScript error.
+     * @param s the detail message
+     */
+    public JSException(String s, String filename, int lineno,
+                       String source, int tokenIndex) {
+	super(s);
+        this.filename = filename;
+        this.lineno = lineno;
+        this.source = source;
+        this.tokenIndex = tokenIndex;
+    }
+}
+

mozilla/js/src/liveconnect/classes/netscape/javascript/JSObject.java

@@ -0,0 +1,150 @@
+/* -*- Mode: C; tab-width: 4; -*- */
+
+/* Insert copyright and license here 19** */
+
+/* more doc todo:
+ *  threads
+ *  gc
+ *  
+ *
+ */
+
+package netscape.javascript;
+
+import java.applet.Applet;
+
+/**
+ * JSObject allows Java to manipulate objects that are
+ * defined in JavaScript.
+ * Values passed from Java to JavaScript are converted as
+ * follows:<ul>
+ * <li>JSObject is converted to the original JavaScript object
+ * <li>Any other Java object is converted to a JavaScript wrapper,
+ *   which can be used to access methods and fields of the java object.
+ *   Converting this wrapper to a string will call the toString method
+ *   on the original object, converting to a number will call the
+ *   floatValue method if possible and fail otherwise.  Converting
+ *   to a boolean will try to call the booleanValue method in the
+ *   same way.
+ * <li>Java arrays are wrapped with a JavaScript object that understands
+ *   array.length and array[index]
+ * <li>A Java boolean is converted to a JavaScript boolean
+ * <li>Java byte, char, short, int, long, float, and double are converted
+ *   to JavaScript numbers
+ * </ul>
+ * Values passed from JavaScript to Java are converted as follows:<ul>
+ * <li>objects which are wrappers around java objects are unwrapped
+ * <li>other objects are wrapped with a JSObject
+ * <li>strings, numbers and booleans are converted to String, Float,
+ *   and Boolean objects respectively
+ * </ul>
+ * This means that all JavaScript values show up as some kind
+ * of java.lang.Object in Java.  In order to make much use of them,
+ * you will have to cast them to the appropriate subclass of Object,
+ * e.g. <code>(String) window.getMember("name");</code> or
+ * <code>(JSObject) window.getMember("document");</code>.
+ */
+public final class JSObject {
+    /* the internal object data */
+    private int                               internal;
+
+    /**
+     * initialize
+     */
+    private static native void initClass();
+    static {
+    	// On MRJ, this property won't exist, because the library is preloaded.
+    	String liveConnectLibrary = System.getProperty("netscape.jsj.dll", null);
+    	if (liveConnectLibrary != null) {
+			System.loadLibrary(liveConnectLibrary);
+			initClass();
+		}
+    }
+
+    /**
+     * it is illegal to construct a JSObject manually
+     */
+    private JSObject(int jsobj_addr) {
+        internal = jsobj_addr;
+    }
+
+    /**
+     * Retrieves a named member of a JavaScript object. 
+     * Equivalent to "this.<i>name</i>" in JavaScript.
+     */
+    public native Object	getMember(String name);
+
+    /**
+     * Retrieves an indexed member of a JavaScript object.
+     * Equivalent to "this[<i>index</i>]" in JavaScript.
+     */
+//    public Object		getMember(int index) { return getSlot(index); }
+    public native Object	getSlot(int index);
+
+    /**
+     * Sets a named member of a JavaScript object. 
+     * Equivalent to "this.<i>name</i> = <i>value</i>" in JavaScript.
+     */
+    public native void 		setMember(String name, Object value);
+
+    /**
+     * Sets an indexed member of a JavaScript object. 
+     * Equivalent to "this[<i>index</i>] = <i>value</i>" in JavaScript.
+     */
+//    public void 		setMember(int index, Object value) {
+//        setSlot(index, value);
+//    }
+    public native void 		setSlot(int index, Object value);
+
+    /**
+     * Removes a named member of a JavaScript object.
+     */
+    public native void 		removeMember(String name);
+
+    /**
+     * Calls a JavaScript method.
+     * Equivalent to "this.<i>methodName</i>(<i>args</i>[0], <i>args</i>[1], ...)" in JavaScript.
+     */
+    public native Object	call(String methodName, Object args[]);
+
+    /**
+     * Evaluates a JavaScript expression. The expression is a string 
+     * of JavaScript source code which will be evaluated in the context
+     * given by "this".
+     */
+    public native Object	eval(String s);
+
+    /**
+     * Converts a JSObject to a String.
+     */
+    public native String        toString();
+
+    // should use some sort of identifier rather than String
+    // is "property" the right word?
+  //    native String[]                         listProperties();
+
+
+    /**
+     * get a JSObject for the window containing the given applet
+     */
+    public static native JSObject	getWindow(Applet applet);
+
+    /**
+     * Finalization decrements the reference count on the corresponding
+     * JavaScript object.
+     */
+    protected native void	finalize();
+
+    /**
+     * Override java.lang.Object.equals() because identity is not preserved
+     * with instances of JSObject.
+     */
+    public boolean equals(Object obj) {
+        JSObject jsobj;
+
+        if (!(obj instanceof JSObject))
+            return false;
+        jsobj = (JSObject)obj;
+	return (internal == jsobj.internal);
+    }
+}

mozilla/js/src/liveconnect/classes/netscape/javascript/JSProxy.java

@@ -0,0 +1,37 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+/* ** */
+/**
+ * The JSProxy interface allows applets and plugins to
+ * share javascript contexts.
+ */
+
+package netscape.javascript;
+import java.applet.Applet;
+
+public interface JSProxy {
+    Object  getMember(JSObject jso, String name);
+    Object  getSlot(JSObject jso, int index);
+    void    setMember(JSObject jso, String name, Object value);
+    void    setSlot(JSObject jso, int index, Object value);
+    void    removeMember(JSObject jso, String name);
+    Object  call(JSObject jso, String methodName, Object args[]);
+    Object  eval(JSObject jso, String s);
+    String      toString(JSObject jso);
+    JSObject    getWindow(Applet applet);
+}

mozilla/js/src/liveconnect/classes/netscape/javascript/JSRunnable.java

@@ -0,0 +1,31 @@
+package netscape.javascript;
+
+/**
+ * Runs a JavaScript object with a run() method in a separate thread.
+ */
+public class JSRunnable implements Runnable {
+	private JSObject runnable;
+
+	public JSRunnable(JSObject runnable) {
+		this.runnable = runnable;
+		synchronized(this) {
+			new Thread(this).start();
+			try {
+				this.wait();
+			} catch (InterruptedException ie) {
+			}
+		}
+	}
+	
+	public void run() {
+		try {
+			runnable.call("run", null);
+			synchronized(this) {
+				notifyAll();
+			}
+		} catch (Throwable t) {
+			System.err.println(t);
+			t.printStackTrace(System.err);
+		}
+	}
+}

mozilla/js/src/liveconnect/classes/netscape/javascript/JSUtil.java

@@ -0,0 +1,38 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+/* ** */
+
+package netscape.javascript;
+import java.io.*;
+
+public class JSUtil {
+
+    /* Return the stack trace of an exception or error as a String */
+    public static String getStackTrace(Throwable t) {
+	ByteArrayOutputStream captureStream;
+	PrintStream p;
+	
+	captureStream = new ByteArrayOutputStream();
+	p = new PrintStream(captureStream);
+
+	t.printStackTrace(p);
+	p.flush();
+
+	return captureStream.toString();
+    }
+}

mozilla/js/src/liveconnect/jsj.c

@@ -0,0 +1,876 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+ 
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the top-level initialization code and the implementation of the
+ * public API.
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jsj_private.h"        /* LiveConnect internals */
+#include "jsjava.h"             /* LiveConnect external API */
+
+/*
+ * At certain times during initialization, there may be no JavaScript context
+ * available to direct error reports to, in which case the error messages
+ * are sent to this function.  The caller is responsible for free'ing
+ * the js_error_msg argument.
+ */
+static void
+report_java_initialization_error(JNIEnv *jEnv, const char *js_error_msg)
+{
+    const char *error_msg, *java_error_msg;
+
+    java_error_msg = NULL;
+#if 0   /* This can never work here, because jsj_GetJavaErrorMessage relies on 
+           jlThrowable_toString which is set up by the initialization that calls 
+           this function. */
+    if (jEnv) {
+        java_error_msg = jsj_GetJavaErrorMessage(jEnv);
+        (*jEnv)->ExceptionClear(jEnv);
+    }
+#endif
+    if (java_error_msg) { 
+        error_msg = PR_smprintf("initialization error: %s (%s)\n",
+                                js_error_msg, java_error_msg);
+        free((void*)java_error_msg);
+    } else {
+        error_msg = PR_smprintf("initialization error: %s\n",
+                                js_error_msg);
+    }
+
+    jsj_LogError(error_msg);
+}
+
+/*
+ * Opaque JVM handles to Java classes and methods required for Java reflection.
+ * These are computed and cached during initialization.
+ */
+
+jclass jlObject;                        /* java.lang.Object */
+jclass jlrMethod;                       /* java.lang.reflect.Method */
+jclass jlrField;                        /* java.lang.reflect.Field */
+jclass jlVoid;                          /* java.lang.Void */
+jclass jlrConstructor;                  /* java.lang.reflect.Constructor */
+jclass jlThrowable;                     /* java.lang.Throwable */
+jclass jlSystem;                        /* java.lang.System */
+jclass jlClass;                         /* java.lang.Class */
+jclass jlBoolean;                       /* java.lang.Boolean */
+jclass jlDouble;                        /* java.lang.Double */
+jclass jlString;                        /* java.lang.String */
+jclass njJSObject;                      /* netscape.javascript.JSObject */
+jclass njJSException;                   /* netscape.javascript.JSException */
+jclass njJSUtil;                        /* netscape.javascript.JSUtil */
+
+jmethodID jlClass_getMethods;           /* java.lang.Class.getMethods() */
+jmethodID jlClass_getConstructors;      /* java.lang.Class.getConstructors() */
+jmethodID jlClass_getFields;            /* java.lang.Class.getFields() */
+jmethodID jlClass_getName;              /* java.lang.Class.getName() */
+jmethodID jlClass_getComponentType;     /* java.lang.Class.getComponentType() */
+jmethodID jlClass_getModifiers;         /* java.lang.Class.getModifiers() */
+jmethodID jlClass_isArray;              /* java.lang.Class.isArray() */
+
+jmethodID jlrMethod_getName;            /* java.lang.reflect.Method.getName() */
+jmethodID jlrMethod_getParameterTypes;  /* java.lang.reflect.Method.getParameterTypes() */
+jmethodID jlrMethod_getReturnType;      /* java.lang.reflect.Method.getReturnType() */
+jmethodID jlrMethod_getModifiers;       /* java.lang.reflect.Method.getModifiers() */
+
+jmethodID jlrConstructor_getParameterTypes; /* java.lang.reflect.Constructor.getParameterTypes() */
+jmethodID jlrConstructor_getModifiers;  /* java.lang.reflect.Constructor.getModifiers() */
+
+jmethodID jlrField_getName;             /* java.lang.reflect.Field.getName() */
+jmethodID jlrField_getType;             /* java.lang.reflect.Field.getType() */
+jmethodID jlrField_getModifiers;        /* java.lang.reflect.Field.getModifiers() */
+
+jmethodID jlBoolean_Boolean;            /* java.lang.Boolean constructor */
+jmethodID jlBoolean_booleanValue;       /* java.lang.Boolean.booleanValue() */
+jmethodID jlDouble_Double;              /* java.lang.Double constructor */
+jmethodID jlDouble_doubleValue;         /* java.lang.Double.doubleValue() */
+
+jmethodID jlThrowable_toString;         /* java.lang.Throwable.toString() */
+jmethodID jlThrowable_getMessage;       /* java.lang.Throwable.getMessage() */
+
+jmethodID jlSystem_identityHashCode;    /* java.lang.System.identityHashCode() */
+
+jobject jlVoid_TYPE;                    /* java.lang.Void.TYPE value */
+
+jmethodID njJSException_JSException;    /* netscape.javascript.JSexception constructor */
+jmethodID njJSObject_JSObject;          /* netscape.javascript.JSObject constructor */
+jmethodID njJSUtil_getStackTrace;       /* netscape.javascript.JSUtil.getStackTrace() */
+jfieldID njJSObject_internal;           /* netscape.javascript.JSObject.internal */
+jfieldID njJSException_lineno;          /* netscape.javascript.JSException.lineno */
+jfieldID njJSException_tokenIndex;      /* netscape.javascript.JSException.tokenIndex */
+jfieldID njJSException_source;          /* netscape.javascript.JSException.source */
+jfieldID njJSException_filename;        /* netscape.javascript.JSException.filename */
+
+/* Obtain a reference to a Java class */
+#define LOAD_CLASS(qualified_name, class)                                    \
+    {                                                                        \
+        jclass _##class = (*jEnv)->FindClass(jEnv, #qualified_name);         \
+        if (_##class == 0) {                                                 \
+            (*jEnv)->ExceptionClear(jEnv);                                   \
+            report_java_initialization_error(jEnv,                           \
+                "Can't load class " #qualified_name);                        \
+            return JS_FALSE;                                                 \
+        }                                                                    \
+        class = (*jEnv)->NewGlobalRef(jEnv, _##class);                       \
+    }
+
+/* Obtain a methodID reference to a Java method or constructor */
+#define _LOAD_METHOD(qualified_class, method, mvar, signature, class, is_static)\
+    if (is_static) {                                                         \
+        class##_##mvar =                                                     \
+            (*jEnv)->GetStaticMethodID(jEnv, class, #method, signature);     \
+    } else {                                                                 \
+        class##_##mvar =                                                     \
+            (*jEnv)->GetMethodID(jEnv, class, #method, signature);           \
+    }                                                                        \
+    if (class##_##mvar == 0) {                                               \
+        report_java_initialization_error(jEnv,                               \
+               "Can't get mid for " #qualified_class "." #method "()");      \
+        return JS_FALSE;                                                     \
+    }
+
+/* Obtain a methodID reference to a Java instance method */
+#define LOAD_METHOD(qualified_class, method, signature, class)               \
+    _LOAD_METHOD(qualified_class, method, method, signature, class, JS_FALSE)
+
+/* Obtain a methodID reference to a Java static method */
+#define LOAD_STATIC_METHOD(qualified_class, method, signature, class)        \
+    _LOAD_METHOD(qualified_class, method, method, signature, class, JS_TRUE)
+
+/* Obtain a methodID reference to a Java constructor */
+#define LOAD_CONSTRUCTOR(qualified_class, method, signature, class)          \
+    _LOAD_METHOD(qualified_class,<init>, method, signature, class, JS_FALSE)
+
+/* Obtain a fieldID reference to a Java instance or static field */
+#define _LOAD_FIELDID(qualified_class, field, signature, class, is_static)   \
+    if (is_static) {                                                         \
+        class##_##field = (*jEnv)->GetStaticFieldID(jEnv, class, #field, signature);\
+    } else {                                                                 \
+        class##_##field = (*jEnv)->GetFieldID(jEnv, class, #field, signature);\
+    }                                                                        \
+    if (class##_##field == 0) {                                              \
+        report_java_initialization_error(jEnv,                               \
+                "Can't get fid for " #qualified_class "." #field);           \
+        return JS_FALSE;                                                     \
+    }
+
+/* Obtain a fieldID reference to a Java instance field */
+#define LOAD_FIELDID(qualified_class, field, signature, class)               \
+    _LOAD_FIELDID(qualified_class, field, signature, class, JS_FALSE)
+
+/* Obtain the value of a static field in a Java class */
+#define LOAD_FIELD_VAL(qualified_class, field, signature, class, type)       \
+    {                                                                        \
+        jfieldID field_id;                                                   \
+        field_id = (*jEnv)->GetStaticFieldID(jEnv, class, #field, signature);\
+        if (field_id == 0) {                                                 \
+            report_java_initialization_error(jEnv,                           \
+                "Can't get fid for " #qualified_class "." #field);           \
+            return JS_FALSE;                                                 \
+        }                                                                    \
+        class##_##field =                                                    \
+            (*jEnv)->GetStatic##type##Field(jEnv, class, field_id);          \
+        if (class##_##field == 0) {                                          \
+            report_java_initialization_error(jEnv,                           \
+                "Can't read static field " #qualified_class "." #field);     \
+            return JS_FALSE;                                                 \
+        }                                                                    \
+    }
+
+/* Obtain the value of a static field in a Java class, which is known to
+   contain an object value. */
+#define LOAD_FIELD_OBJ(qualified_class, field, signature, class)             \
+    LOAD_FIELD_VAL(qualified_class, field, signature, class, Object);        \
+    class##_##field = (*jEnv)->NewGlobalRef(jEnv, class##_##field);
+
+/*
+ * Load the Java classes, and the method and field descriptors required for Java reflection.
+ * Returns JS_TRUE on success, JS_FALSE on failure.
+ */
+static JSBool
+init_java_VM_reflection(JSJavaVM *jsjava_vm, JNIEnv *jEnv)
+{
+    /* Load Java system classes and method, including java.lang.reflect classes */
+    LOAD_CLASS(java/lang/Object,                jlObject);
+    LOAD_CLASS(java/lang/Class,                 jlClass);
+    LOAD_CLASS(java/lang/reflect/Method,        jlrMethod);
+    LOAD_CLASS(java/lang/reflect/Constructor,   jlrConstructor);
+    LOAD_CLASS(java/lang/reflect/Field,         jlrField);
+    LOAD_CLASS(java/lang/Throwable,             jlThrowable);
+    LOAD_CLASS(java/lang/System,                jlSystem);
+    LOAD_CLASS(java/lang/Boolean,               jlBoolean);
+    LOAD_CLASS(java/lang/Double,                jlDouble);
+    LOAD_CLASS(java/lang/String,                jlString);
+    LOAD_CLASS(java/lang/Void,                  jlVoid);
+
+    LOAD_METHOD(java.lang.Class,            getMethods,         "()[Ljava/lang/reflect/Method;",jlClass);
+    LOAD_METHOD(java.lang.Class,            getConstructors,    "()[Ljava/lang/reflect/Constructor;",jlClass);
+    LOAD_METHOD(java.lang.Class,            getFields,          "()[Ljava/lang/reflect/Field;", jlClass);
+    LOAD_METHOD(java.lang.Class,            getName,            "()Ljava/lang/String;",         jlClass);
+    LOAD_METHOD(java.lang.Class,            isArray,            "()Z",                          jlClass);
+    LOAD_METHOD(java.lang.Class,            getComponentType,   "()Ljava/lang/Class;",          jlClass);
+    LOAD_METHOD(java.lang.Class,            getModifiers,       "()I",                          jlClass);
+
+    LOAD_METHOD(java.lang.reflect.Method,   getName,            "()Ljava/lang/String;",         jlrMethod);
+    LOAD_METHOD(java.lang.reflect.Method,   getParameterTypes,  "()[Ljava/lang/Class;",         jlrMethod);
+    LOAD_METHOD(java.lang.reflect.Method,   getReturnType,      "()Ljava/lang/Class;",          jlrMethod);
+    LOAD_METHOD(java.lang.reflect.Method,   getModifiers,       "()I",                          jlrMethod);
+
+    LOAD_METHOD(java.lang.reflect.Constructor,  getParameterTypes,  "()[Ljava/lang/Class;",     jlrConstructor);
+    LOAD_METHOD(java.lang.reflect.Constructor,  getModifiers,       "()I",                      jlrConstructor);
+    
+    LOAD_METHOD(java.lang.reflect.Field,    getName,            "()Ljava/lang/String;",         jlrField);
+    LOAD_METHOD(java.lang.reflect.Field,    getType,            "()Ljava/lang/Class;",          jlrField);
+    LOAD_METHOD(java.lang.reflect.Field,    getModifiers,       "()I",                          jlrField);
+
+    LOAD_METHOD(java.lang.Throwable,        toString,           "()Ljava/lang/String;",         jlThrowable);
+    LOAD_METHOD(java.lang.Throwable,        getMessage,         "()Ljava/lang/String;",         jlThrowable);
+
+    LOAD_METHOD(java.lang.Double,           doubleValue,        "()D",                          jlDouble);
+
+    LOAD_METHOD(java.lang.Boolean,          booleanValue,       "()Z",                          jlBoolean);
+    
+    LOAD_STATIC_METHOD(java.lang.System,    identityHashCode,   "(Ljava/lang/Object;)I",        jlSystem);
+
+    LOAD_CONSTRUCTOR(java.lang.Boolean,     Boolean,            "(Z)V",                         jlBoolean);
+    LOAD_CONSTRUCTOR(java.lang.Double,      Double,             "(D)V",                         jlDouble);
+
+    LOAD_FIELD_OBJ(java.lang.Void,          TYPE,               "Ljava/lang/Class;",            jlVoid);
+  
+    return JS_TRUE;
+}
+
+#if XP_MAC
+
+/**
+ * Workaround for the fact that MRJ loads a different instance of the shared library.
+ */
+
+#include "netscape_javascript_JSObject.h"
+
+static JSObject_RegisterNativeMethods(JNIEnv* jEnv)
+{
+    // Manually load the required native methods.
+    static JNINativeMethod nativeMethods[] = {
+        "initClass", "()V", (void*)&Java_netscape_javascript_JSObject_initClass,
+        "getMember", "(Ljava/lang/String;)Ljava/lang/Object;", (void*)&Java_netscape_javascript_JSObject_getMember,
+        "getSlot", "(I)Ljava/lang/Object;", (void*)&Java_netscape_javascript_JSObject_getSlot,
+        "setMember", "(Ljava/lang/String;Ljava/lang/Object;)V", (void*)&Java_netscape_javascript_JSObject_setMember,
+        "setSlot", "(ILjava/lang/Object;)V", (void*)&Java_netscape_javascript_JSObject_setSlot,
+        "removeMember", "(Ljava/lang/String;)V", (void*)&Java_netscape_javascript_JSObject_removeMember,
+        "call", "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object;", (void*)&Java_netscape_javascript_JSObject_call,
+        "eval", "(Ljava/lang/String;)Ljava/lang/Object;", (void*)&Java_netscape_javascript_JSObject_eval,
+        
+        "toString", "()Ljava/lang/String;", (void*)&Java_netscape_javascript_JSObject_toString,
+        "getWindow", "(Ljava/applet/Applet;)Lnetscape/javascript/JSObject;", (void*)&Java_netscape_javascript_JSObject_getWindow,
+        "finalize", "()V", (void*)&Java_netscape_javascript_JSObject_finalize,
+        /* "equals", "(Ljava/lang/Object;)Z", (void*)&Java_netscape_javascript_JSObject_equals */
+    };
+    (*jEnv)->RegisterNatives(jEnv, njJSObject, nativeMethods, sizeof(nativeMethods) / sizeof(JNINativeMethod));
+    if ((*jEnv)->ExceptionOccurred(jEnv)) {
+        report_java_initialization_error(jEnv, "Couldn't initialize JSObject native methods.");
+        (*jEnv)->ExceptionClear(jEnv);
+    }
+    /* call the initClass method, since we nailed the static initializer for testing. */
+    Java_netscape_javascript_JSObject_initClass(jEnv, njJSObject);
+}
+
+#endif
+
+/* Load Netscape-specific Java extension classes, methods, and fields */
+static JSBool
+init_netscape_java_classes(JSJavaVM *jsjava_vm, JNIEnv *jEnv)
+{
+    LOAD_CLASS(netscape/javascript/JSObject,    njJSObject);
+    LOAD_CLASS(netscape/javascript/JSException, njJSException);
+    LOAD_CLASS(netscape/javascript/JSUtil,      njJSUtil);
+
+#if XP_MAC
+    JSObject_RegisterNativeMethods(jEnv);
+#endif
+
+    LOAD_CONSTRUCTOR(netscape.javascript.JSObject,
+                                            JSObject,           "(I)V",                         njJSObject);
+    LOAD_CONSTRUCTOR(netscape.javascript.JSException,
+                                            JSException,        "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;I)V",
+                                                                                                njJSException);
+    LOAD_FIELDID(netscape.javascript.JSObject,  
+                                            internal,           "I",                            njJSObject);
+    LOAD_FIELDID(netscape.javascript.JSException,  
+                                            lineno,             "I",                            njJSException);
+    LOAD_FIELDID(netscape.javascript.JSException,  
+                                            tokenIndex,         "I",                            njJSException);
+    LOAD_FIELDID(netscape.javascript.JSException,  
+                                            source,             "Ljava/lang/String;",           njJSException);
+    LOAD_FIELDID(netscape.javascript.JSException,  
+                                            filename,           "Ljava/lang/String;",           njJSException);
+
+    LOAD_STATIC_METHOD(netscape.javascript.JSUtil,
+                                            getStackTrace,      "(Ljava/lang/Throwable;)Ljava/lang/String;",
+                                                                                                njJSUtil);
+
+    return JS_TRUE;
+}
+
+JSJavaVM *jsjava_vm_list = NULL;
+
+/*
+ * Called once per Java VM, this function initializes the classes, fields, and
+ * methods required for Java reflection.  If java_vm is NULL, a new Java VM is
+ * created, using the provided classpath in addition to any default classpath.
+ * The classpath argument is ignored, however, if java_vm_arg is non-NULL.
+ */
+JSJavaVM *
+JSJ_ConnectToJavaVM(SystemJavaVM *java_vm_arg, void* initargs)
+{
+    SystemJavaVM* java_vm;
+    JSJavaVM *jsjava_vm;
+    JNIEnv *jEnv;
+
+    PR_ASSERT(JSJ_callbacks);
+    PR_ASSERT(JSJ_callbacks->attach_current_thread);
+    PR_ASSERT(JSJ_callbacks->detach_current_thread);
+    PR_ASSERT(JSJ_callbacks->get_java_vm);
+
+    jsjava_vm = (JSJavaVM*)malloc(sizeof(JSJavaVM));
+    if (!jsjava_vm)
+        return NULL;
+    memset(jsjava_vm, 0, sizeof(JSJavaVM));
+
+    java_vm = java_vm_arg;
+
+    /* If a Java VM was passed in, try to attach to it on the current thread. */
+    if (java_vm) {
+        jEnv = JSJ_callbacks->attach_current_thread(java_vm);
+        if (jEnv == NULL) {
+            jsj_LogError("Failed to attach to Java VM thread\n");
+            free(jsjava_vm);
+            return NULL;
+        }
+    }
+    else {
+        PRBool ok;
+        PR_ASSERT(JSJ_callbacks->create_java_vm);
+        PR_ASSERT(JSJ_callbacks->destroy_java_vm);
+
+        ok = JSJ_callbacks->create_java_vm(&java_vm, &jEnv, initargs);
+        if (!ok || java_vm == NULL) {
+            jsj_LogError("Failed to create Java VM\n");
+            free(jsjava_vm);
+            return NULL;
+        }
+
+        /* Remember that we created the VM so that we know to destroy it later */
+        jsjava_vm->jsj_created_java_vm = JS_TRUE;
+    }
+
+    jsjava_vm->java_vm = java_vm;
+    jsjava_vm->main_thread_env = jEnv;
+    
+    /* Load the Java classes, and the method and field descriptors required for
+       Java reflection. */
+    if (!init_java_VM_reflection(jsjava_vm, jEnv)) {
+        JSJ_DisconnectFromJavaVM(jsjava_vm);
+        return NULL;
+    }
+
+    /*
+     * JVM initialization for netscape.javascript.JSObject is performed
+     * independently of the other classes that are initialized in
+     * init_java_VM_reflection, because we allow it to fail.  In the case
+     * of failure, LiveConnect is still operative, but only when calling
+     * from JS to Java and not vice-versa.
+     */
+    init_netscape_java_classes(jsjava_vm, jEnv);
+
+    /* Put this VM on the list of all created VMs */
+    jsjava_vm->next = jsjava_vm_list;
+    jsjava_vm_list = jsjava_vm;
+
+    return jsjava_vm;
+}
+
+JSJCallbacks *JSJ_callbacks = NULL;
+
+/* Called once to set up callbacks for all instances of LiveConnect */
+void
+JSJ_Init(JSJCallbacks *callbacks)
+{
+    PR_ASSERT(callbacks);
+    JSJ_callbacks = callbacks;
+}
+
+/*
+ * Initialize the provided JSContext by setting up the JS classes necessary for
+ * reflection and by defining JavaPackage objects for the default Java packages
+ * as properties of global_obj.  Additional packages may be pre-defined by
+ * setting the predefined_packages argument.  (Pre-defining a Java package at
+ * initialization time is not necessary, but it will make package lookup faster
+ * and, more importantly, will avoid unnecessary network accesses if classes
+ * are being loaded over the network.)
+ */
+JSBool
+JSJ_InitJSContext(JSContext *cx, JSObject *global_obj,
+                  JavaPackageDef *predefined_packages)
+{
+    /* Initialize the JavaScript classes used for reflection */
+    if (!jsj_init_JavaObject(cx, global_obj))
+        return JS_FALSE;
+    
+/*    if (!jsj_init_JavaMember(cx, global_obj))
+        return JS_FALSE; */
+    
+    if (!jsj_init_JavaPackage(cx, global_obj, predefined_packages))
+        return JS_FALSE;
+
+    if (!jsj_init_JavaClass(cx, global_obj))
+        return JS_FALSE;
+
+    if (!jsj_init_JavaArray(cx, global_obj))
+        return JS_FALSE;
+
+    if (!jsj_init_JavaMember(cx, global_obj))
+        return JS_FALSE;
+    
+    return JS_TRUE;
+}
+
+/* Eliminate a reference to a Java class */
+#define UNLOAD_CLASS(qualified_name, class)                                  \
+    if (class) {                                                             \
+        (*jEnv)->DeleteGlobalRef(jEnv, class);                               \
+        class = NULL;                                                        \
+    }
+
+/*
+ * This routine severs the connection to a Java VM, freeing all related resources.
+ * It shouldn't be called until the global scope has been cleared in all related
+ * JSContexts (so that all LiveConnect objects are finalized) and a JavaScript
+ * GC is performed.  Otherwise, accessed to free'ed memory could result.
+ */
+void
+JSJ_DisconnectFromJavaVM(JSJavaVM *jsjava_vm)
+{
+    JNIEnv *jEnv;
+    SystemJavaVM *java_vm;
+    JSJavaVM *j, **jp;
+
+    java_vm = jsjava_vm->java_vm;
+    jEnv = jsjava_vm->main_thread_env;
+
+    /* Drop all references to Java objects and classes */
+    jsj_DiscardJavaObjReflections(jEnv);
+    jsj_DiscardJavaClassReflections(jEnv);
+
+    if (jsjava_vm->jsj_created_java_vm) { 
+        (void)JSJ_callbacks->destroy_java_vm(java_vm, jEnv);
+    } else {
+        UNLOAD_CLASS(java/lang/Object,                jlObject);
+        UNLOAD_CLASS(java/lang/Class,                 jlClass);
+        UNLOAD_CLASS(java/lang/reflect/Method,        jlrMethod);
+        UNLOAD_CLASS(java/lang/reflect/Constructor,   jlrConstructor);
+        UNLOAD_CLASS(java/lang/reflect/Field,         jlrField);
+        UNLOAD_CLASS(java/lang/Throwable,             jlThrowable);
+        UNLOAD_CLASS(java/lang/System,                jlSystem);
+        UNLOAD_CLASS(java/lang/Boolean,               jlBoolean);
+        UNLOAD_CLASS(java/lang/Double,                jlDouble);
+        UNLOAD_CLASS(java/lang/String,                jlString);
+        UNLOAD_CLASS(java/lang/Void,                  jlVoid);
+        UNLOAD_CLASS(netscape/javascript/JSObject,    njJSObject);
+        UNLOAD_CLASS(netscape/javascript/JSException, njJSException);
+        UNLOAD_CLASS(netscape/javascript/JSUtil,      njJSUtil);
+    }
+
+
+    /* Remove this VM from the list of all JSJavaVM objects. */
+    for (jp = &jsjava_vm_list; (j = *jp) != NULL; jp = &j->next) {
+        if (j == jsjava_vm) {
+            *jp = jsjava_vm->next;
+            break;
+        }
+    }
+    PR_ASSERT(j);
+    
+    free(jsjava_vm);
+}
+
+static JSJavaThreadState *thread_list = NULL;
+
+static JSJavaThreadState *
+new_jsjava_thread_state(JSJavaVM *jsjava_vm, const char *thread_name, JNIEnv *jEnv)
+{
+    JSJavaThreadState *jsj_env;
+
+    jsj_env = (JSJavaThreadState *)malloc(sizeof(JSJavaThreadState));
+    if (!jsj_env)
+        return NULL;
+    memset(jsj_env, 0, sizeof(JSJavaThreadState));
+
+    jsj_env->jEnv = jEnv;
+    jsj_env->jsjava_vm = jsjava_vm;
+    if (thread_name)
+        jsj_env->name = strdup(thread_name);
+
+    /* THREADSAFETY - need to protect against races */
+    jsj_env->next = thread_list;
+    thread_list = jsj_env;
+
+    return jsj_env;
+}
+
+static JSJavaThreadState *
+find_jsjava_thread(JNIEnv *jEnv)
+{
+    JSJavaThreadState *e, **p, *jsj_env;
+    jsj_env = NULL;
+
+    /* THREADSAFETY - need to protect against races in manipulating the thread list */
+
+    /* Search for the thread state among the list of all created
+       LiveConnect threads */
+    for (p = &thread_list; (e = *p) != NULL; p = &(e->next)) {
+        if (e->jEnv == jEnv) {
+            jsj_env = e;
+            *p = jsj_env->next;
+            break;
+        }
+    }
+
+    /* Move a found thread to head of list for faster search next time. */
+    if (jsj_env)
+        thread_list = jsj_env;
+    
+    return jsj_env;
+}
+
+PR_IMPLEMENT(JSJavaThreadState *)
+JSJ_AttachCurrentThreadToJava(JSJavaVM *jsjava_vm, const char *name, JNIEnv **java_envp)
+{
+    JNIEnv *jEnv;
+    SystemJavaVM *java_vm;
+    JSJavaThreadState *jsj_env;
+
+    /* Try to attach a Java thread to the current native thread */
+    java_vm = jsjava_vm->java_vm;
+    jEnv = JSJ_callbacks->attach_current_thread(java_vm);
+    if (jEnv == NULL) 
+        return NULL;
+
+    /* If we found an existing thread state, just return it. */
+    jsj_env = find_jsjava_thread(jEnv);
+    if (jsj_env)
+        return jsj_env;
+
+    /* Create a new wrapper around the thread/VM state */
+    jsj_env = new_jsjava_thread_state(jsjava_vm, name, jEnv);
+
+    if (java_envp)
+        *java_envp = jEnv;
+    return jsj_env;
+}
+
+static JSJavaVM *
+map_java_vm_to_jsjava_vm(SystemJavaVM *java_vm)
+{
+    JSJavaVM *v;
+    for (v = jsjava_vm_list; v; v = v->next) {
+        if (v->java_vm == java_vm)
+            return v;
+    }
+    return NULL;
+}
+
+/*
+ * Unfortunately, there's no standard means to associate any private data with
+ * a JNI thread environment, so we need to use the Java environment pointer as
+ * the key in a lookup table that maps it to a JSJavaThreadState structure, 
+ * where we store all our per-thread private data.  If no existing thread state
+ * is found, a new one is created.
+ *
+ * If an error occurs, returns NULL and sets the errp argument to an error
+ * message, which the caller is responsible for free'ing.
+ */
+JSJavaThreadState *
+jsj_MapJavaThreadToJSJavaThreadState(JNIEnv *jEnv, char **errp)
+{
+    JSJavaThreadState *jsj_env;
+    SystemJavaVM *java_vm;
+    JSJavaVM *jsjava_vm;
+
+    /* If we found an existing thread state, just return it. */
+    jsj_env = find_jsjava_thread(jEnv);
+    if (jsj_env)
+        return jsj_env;
+
+    /* No one set up a LiveConnect thread state for a given Java thread.
+       Invoke the callback to create one on-the-fly. */
+
+    /* First, figure out which Java VM is calling us */
+    java_vm = JSJ_callbacks->get_java_vm(jEnv);
+    if (jsjava_vm == NULL)
+        return NULL;
+
+    /* Get our private JavaVM data */
+    jsjava_vm = map_java_vm_to_jsjava_vm(java_vm);
+    if (!jsjava_vm) {
+        *errp = PR_smprintf("Total weirdness:   No JSJavaVM wrapper ever created "
+                            "for JavaVM 0x%08x", java_vm);
+        return NULL;
+    }
+
+    jsj_env = new_jsjava_thread_state(jsjava_vm, NULL, jEnv);
+    if (!jsj_env)
+        return NULL;
+
+    return jsj_env;
+}
+
+/*
+ * This function is used to specify a particular JSContext as *the* JavaScript
+ * execution environment to be used when LiveConnect is accessed from the given
+ * Java thread, i.e. by using one of the methods of netscape.javascript.JSObject.
+ * (There can only be one such JS context for a given Java thread.  To
+ * multiplex JSContexts among a single thread, this function must be called
+ * before Java is invoked on that thread.)  The return value is the previous
+ * context associated with the given Java thread.
+ */
+PR_IMPLEMENT(JSContext *)
+JSJ_SetDefaultJSContextForJavaThread(JSContext *cx, JSJavaThreadState *jsj_env)
+{
+    JSContext *old_context;
+    old_context = jsj_env->cx;
+    jsj_env->cx = cx;
+    return old_context;
+}
+
+PR_IMPLEMENT(JSBool)
+JSJ_DetachCurrentThreadFromJava(JSJavaThreadState *jsj_env)
+{
+    SystemJavaVM *java_vm;
+    JNIEnv* jEnv;
+    JSJavaThreadState *e, **p;
+
+    /* Disassociate the current native thread from its corresponding Java thread */
+    java_vm = jsj_env->jsjava_vm->java_vm;
+    jEnv = jsj_env->jEnv;
+    if (!JSJ_callbacks->detach_current_thread(java_vm, jEnv))
+        return JS_FALSE;
+
+    /* Destroy the LiveConnect execution environment passed in */
+    jsj_ClearPendingJSErrors(jsj_env);
+
+    /* THREADSAFETY - need to protect against races */
+    for (p = &thread_list; (e = *p) != NULL; p = &(e->next)) {
+        if (e == jsj_env) {
+            *p = jsj_env->next;
+            break;
+        }
+    }
+
+    free(jsj_env);
+    return JS_TRUE;
+}
+
+JSBool
+JSJ_ConvertJavaObjectToJSValue(JSContext *cx, jobject java_obj, jsval *vp)
+{
+    JNIEnv *jEnv;
+            
+    /* Get the Java per-thread environment pointer for this JSContext */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+
+    return jsj_ConvertJavaObjectToJSValue(cx, jEnv, java_obj, vp);
+}
+
+/*===========================================================================*/
+
+#ifndef MOZILLA_CLIENT
+
+/* The convenience functions below present a complete, but simplified
+   LiveConnect API which is designed to handle the special case of a single 
+   Java-VM, single-threaded operation, and use of only one JSContext. */
+
+/* We can get away with global variables in our single-threaded,
+   single-JSContext case. */
+static JSJavaVM *           the_jsj_vm = NULL;
+static JSContext *          the_cx = NULL;
+static JSJavaThreadState *  the_jsj_thread = NULL;
+static JSObject *           the_global_js_obj = NULL;
+
+/* Trivial implementation of callback function */
+static JSJavaThreadState *
+default_map_js_context_to_jsj_thread(JSContext *cx, char **errp)
+{
+    return the_jsj_thread;
+}
+
+/* Trivial implementation of callback function */
+static JSContext *
+default_map_jsj_thread_to_js_context(JSJavaThreadState *jsj_env, JNIEnv *jEnv, char **errp)
+{
+    return the_cx;
+}
+
+/* Trivial implementation of callback function */
+static JSObject *
+default_map_java_object_to_js_object(JNIEnv *jEnv, jobject hint, char **errp)
+{
+    return the_global_js_obj;
+}
+
+static PRBool PR_CALLBACK
+default_create_java_vm(SystemJavaVM* *jvm, JNIEnv* *initialEnv, void* initargs)
+{
+    jint err;
+    const char* user_classpath = (const char*)initargs;
+
+    /* No Java VM supplied, so create our own */
+    JDK1_1InitArgs vm_args;
+        
+    /* Magic constant indicates JRE version 1.1 */
+    vm_args.version = 0x00010001;
+    JNI_GetDefaultJavaVMInitArgs(&vm_args);
+        
+    /* Prepend the classpath argument to the default JVM classpath */
+    if (user_classpath) {
+#ifdef XP_UNIX
+        const char *full_classpath = PR_smprintf("%s:%s", user_classpath, vm_args.classpath);
+#else
+        const char *full_classpath = PR_smprintf("%s;%s", user_classpath, vm_args.classpath);
+#endif
+        if (!full_classpath) {
+            return PR_FALSE;
+        }
+        vm_args.classpath = (char*)full_classpath;
+    }
+
+    err = JNI_CreateJavaVM((JavaVM**)jvm, initialEnv, &vm_args);
+    return err == 0;
+}
+
+static PRBool PR_CALLBACK
+default_destroy_java_vm(SystemJavaVM* jvm, JNIEnv* initialEnv)
+{
+    JavaVM* java_vm = (JavaVM*)jvm;
+    jint err = (*java_vm)->DestroyJavaVM(java_vm);
+    return err == 0;
+}
+
+static JNIEnv* PR_CALLBACK
+default_attach_current_thread(SystemJavaVM* jvm)
+{
+    JavaVM* java_vm = (JavaVM*)jvm;
+    JNIEnv* env = NULL;
+    jint err = (*java_vm)->AttachCurrentThread(java_vm, &env, NULL);
+    return env;
+}
+
+static PRBool PR_CALLBACK
+default_detach_current_thread(SystemJavaVM* jvm, JNIEnv* env)
+{
+    JavaVM* java_vm = (JavaVM*)jvm;
+    /* assert that env is the JNIEnv of the current thread */
+    jint err = (*java_vm)->DetachCurrentThread(java_vm);
+    return err == 0;
+}
+
+static SystemJavaVM* PR_CALLBACK
+default_get_java_vm(JNIEnv* env)
+{
+    JavaVM* java_vm = NULL;
+    jint err = (*env)->GetJavaVM(env, &java_vm);
+    return (SystemJavaVM*)java_vm;
+}
+
+/* Trivial implementations of callback functions */
+JSJCallbacks jsj_default_callbacks = {
+    default_map_jsj_thread_to_js_context,
+    default_map_js_context_to_jsj_thread,
+    default_map_java_object_to_js_object,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    default_create_java_vm,
+    default_destroy_java_vm,
+    default_attach_current_thread,
+    default_detach_current_thread,
+    default_get_java_vm
+};
+
+/*
+ * Initialize the provided JSContext by setting up the JS classes necessary for
+ * reflection and by defining JavaPackage objects for the default Java packages
+ * as properties of global_obj.  If java_vm is NULL, a new Java VM is
+ * created, using the provided classpath in addition to any default classpath.
+ * The classpath argument is ignored, however, if java_vm is non-NULL.
+ */
+JSBool
+JSJ_SimpleInit(JSContext *cx, JSObject *global_obj, SystemJavaVM *java_vm, const char *classpath)
+{
+    JNIEnv *jEnv;
+
+    PR_ASSERT(!the_jsj_vm);
+    the_jsj_vm = JSJ_ConnectToJavaVM(java_vm, (void*)classpath);
+    if (!the_jsj_vm)
+        return JS_FALSE;
+
+    JSJ_Init(&jsj_default_callbacks);
+
+    if (!JSJ_InitJSContext(cx, global_obj, NULL))
+        goto error;
+    the_cx = cx;
+    the_global_js_obj = global_obj;
+
+    the_jsj_thread = JSJ_AttachCurrentThreadToJava(the_jsj_vm, "main thread", &jEnv);
+    if (!the_jsj_thread)
+        goto error;
+    JSJ_SetDefaultJSContextForJavaThread(cx, the_jsj_thread);
+    return JS_TRUE;
+
+error:
+    JSJ_SimpleShutdown();
+    return JS_FALSE;
+}
+
+/*
+ * Free up all LiveConnect resources.  Destroy the Java VM if it was
+ * created by LiveConnect.
+ */
+PR_IMPLEMENT(void)
+JSJ_SimpleShutdown()
+{
+    PR_ASSERT(the_jsj_vm);
+    JSJ_DisconnectFromJavaVM(the_jsj_vm);
+    the_jsj_vm = NULL;
+    the_cx = NULL;
+    the_global_js_obj = NULL;
+    the_jsj_thread = NULL;
+}
+
+#endif /* MOZILLA_CLIENT */

mozilla/js/src/liveconnect/jsj1640.rc

@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// Version stamp for this .DLL
+
+#include <windows.h>
+
+#include <ver.h>
+
+
+
+VS_VERSION_INFO     VERSIONINFO
+
+  FILEVERSION       4 // major, minor, release (alpha 1), build #
+
+  PRODUCTVERSION    4
+
+  FILEFLAGSMASK     0
+
+  FILEFLAGS         0 // final version
+
+  FILEOS            VOS_DOS_WINDOWS16
+
+  FILETYPE          VFT_DLL
+
+  FILESUBTYPE       0   // not used
+
+BEGIN
+
+    BLOCK "StringFileInfo"
+
+    BEGIN
+
+        BLOCK "040904E4" // Lang=US English, CharSet=Windows Multilingual
+
+        BEGIN
+
+            VALUE "CompanyName",     "Netscape Communications Corporation\0"
+
+            VALUE "FileDescription", "Netscape 16-bit JavaScript-Java Module\0"
+
+            VALUE "FileVersion",     "4.0\0"
+
+            VALUE "InternalName",    "JSJ1640\0"
+
+            VALUE "LegalCopyright",  "Copyright Netscape Communications. 1994-96\0"
+
+            VALUE "LegalTrademarks", "Netscape, Mozilla\0"
+
+            VALUE "OriginalFilename","JSJ1640.DLL\0"
+
+            VALUE "ProductName",     "NETSCAPE\0"
+
+            VALUE "ProductVersion",  "4.0\0"
+
+        END
+
+    END
+
+END
+

mozilla/js/src/liveconnect/jsj_JavaArray.c

@@ -0,0 +1,403 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the definition of the JavaScript JavaArray class.
+ * Instances of JavaArray are used to reflect Java arrays.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jsj_private.h"      /* LiveConnect internals */
+
+/* Shorthands for ASCII (7-bit) decimal and hex conversion. */
+#define JS7_ISDEC(c)    (((c) >= '0') && ((c) <= '9'))
+#define JS7_UNDEC(c)    ((c) - '0')
+
+/*
+ * Convert any jsval v to an integer jsval if ToString(v)
+ * contains a base-10 integer that fits into 31 bits.
+ * Otherwise return v.
+ */
+static jsval
+try_convert_to_jsint(JSContext *cx, jsval idval)
+{
+    const jschar *cp;
+    JSString *jsstr;
+    
+    jsstr = JS_ValueToString(cx, idval);
+    if (!jsstr)
+        return idval;
+
+    cp = JS_GetStringChars(jsstr);
+    if (JS7_ISDEC(*cp)) {
+        jsuint index = JS7_UNDEC(*cp++);
+        jsuint oldIndex = 0;
+        jsuint c = 0;
+        if (index != 0) {
+            while (JS7_ISDEC(*cp)) {
+                oldIndex = index;
+                c = JS7_UNDEC(*cp);
+                index = 10*index + c;
+                cp++;
+            }
+        }
+        if (*cp == 0 &&
+            (oldIndex < (JSVAL_INT_MAX / 10) ||
+            (oldIndex == (JSVAL_INT_MAX / 10) && c < (JSVAL_INT_MAX % 10)))) {
+            return INT_TO_JSVAL(index);
+        }
+    }
+    return idval;
+}
+
+
+static JSBool
+access_java_array_element(JSContext *cx,
+                          JNIEnv *jEnv,
+                          JSObject *obj,
+                          jsid id,
+                          jsval *vp,
+                          JSBool do_assignment)
+{
+    jsval idval;
+    jarray java_array;
+    JavaClassDescriptor *class_descriptor;
+    JavaObjectWrapper *java_wrapper;
+    jsize array_length, index;
+    JavaSignature *array_component_signature;
+    
+    /* printf("In JavaArray_getProperty\n"); */
+    
+    java_wrapper = JS_GetPrivate(cx, obj);
+    if (!java_wrapper) {
+        const char *property_name;
+        if (JS_IdToValue(cx, id, &idval) && JSVAL_IS_STRING(idval) &&
+            (property_name = JS_GetStringBytes(JSVAL_TO_STRING(idval))) != NULL) {
+            if (!strcmp(property_name, "constructor")) {
+                *vp = JSVAL_VOID;
+                return JS_TRUE;
+            }
+        }
+        JS_ReportError(cx, "illegal operation on JavaArray prototype object");
+        return JS_FALSE;
+    }
+    class_descriptor = java_wrapper->class_descriptor;
+    java_array = java_wrapper->java_obj;
+    
+    PR_ASSERT(class_descriptor->type == JAVA_SIGNATURE_ARRAY);
+
+    JS_IdToValue(cx, id, &idval);
+
+    if (!JSVAL_IS_INT(idval))
+        idval = try_convert_to_jsint(cx, idval);
+
+    if (!JSVAL_IS_INT(idval)) {
+        /*
+         * Usually, properties of JavaArray objects are indexed by integers, but
+         * Java arrays also inherit all the methods of java.lang.Object, so a
+         * string-valued property is also possible.
+         */
+        if (JSVAL_IS_STRING(idval)) {
+            const char *member_name;
+            
+            member_name = JS_GetStringBytes(JSVAL_TO_STRING(idval));
+            
+            if (do_assignment) {
+                JSVersion version = JS_GetVersion(cx);
+
+                if (!JSVERSION_IS_ECMA(version)) {
+ 
+                    JS_ReportError(cx, "Attempt to write to invalid Java array "
+                                       "element \"%s\"", member_name);
+                    return JS_FALSE;
+                } else {
+                    *vp = JSVAL_VOID;
+                    return JS_TRUE;
+                }
+            } else {
+                if (!strcmp(member_name, "length")) {
+                    array_length = jsj_GetJavaArrayLength(cx, jEnv, java_array);
+                    if (array_length < 0)
+                        return JS_FALSE;
+                    if (vp)
+                        *vp = INT_TO_JSVAL(array_length);
+                    return JS_TRUE;
+                }
+
+                /* Check to see if we're reflecting a Java array method */
+                return JavaObject_getPropertyById(cx, obj, id, vp);
+            }
+        }
+
+        JS_ReportError(cx, "invalid Java array index expression");
+        return JS_FALSE;
+    }
+    
+    index = JSVAL_TO_INT(idval);
+
+#if 0
+    array_length = jsj_GetJavaArrayLength(cx, jEnv, java_array);
+    if (array_length < 0)
+        return JS_FALSE;
+
+    /* Just let Java throw an exception instead of checking array bounds here */
+    if (index < 0 || index >= array_length) {
+        JS_ReportError(cx, "Java array index %d out of range", index);
+        return JS_FALSE;
+    }
+#endif
+
+    array_component_signature = class_descriptor->array_component_signature;
+
+    if (!vp)
+        return JS_TRUE;
+
+    if (do_assignment) {
+        return jsj_SetJavaArrayElement(cx, jEnv, java_array, index,
+                                       array_component_signature, *vp);
+    } else {
+        return jsj_GetJavaArrayElement(cx, jEnv, java_array, index,
+                                       array_component_signature, vp);
+    }
+}
+
+PR_STATIC_CALLBACK(JSBool)
+JavaArray_getPropertyById(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
+{
+    JNIEnv *jEnv;
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+    return access_java_array_element(cx, jEnv, obj, id, vp, JS_FALSE);
+}
+
+PR_STATIC_CALLBACK(JSBool)
+JavaArray_setPropertyById(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
+{
+    JNIEnv *jEnv;
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+    return access_java_array_element(cx, jEnv, obj, id, vp, JS_TRUE);
+}
+
+static JSBool
+JavaArray_lookupProperty(JSContext *cx, JSObject *obj, jsid id,
+                         JSObject **objp, JSProperty **propp
+#if defined JS_THREADSAFE && defined DEBUG
+                            , const char *file, uintN line
+#endif
+                            )
+{
+    JNIEnv *jEnv;
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+
+    return access_java_array_element(cx, jEnv, obj, id, NULL, JS_FALSE);
+}
+
+static JSBool
+JavaArray_defineProperty(JSContext *cx, JSObject *obj, jsid id, jsval value,
+                         JSPropertyOp getter, JSPropertyOp setter,
+                         uintN attrs, JSProperty **propp)
+{
+    JS_ReportError(cx, "Cannot define a new property in a JavaArray");
+    return JS_FALSE;
+}
+
+static JSBool
+JavaArray_getAttributes(JSContext *cx, JSObject *obj, jsid id,
+                        JSProperty *prop, uintN *attrsp)
+{
+    /* We don't maintain JS property attributes for Java class members */
+    *attrsp = JSPROP_PERMANENT|JSPROP_ENUMERATE;
+    return JS_FALSE;
+}
+
+static JSBool
+JavaArray_setAttributes(JSContext *cx, JSObject *obj, jsid id,
+                        JSProperty *prop, uintN *attrsp)
+{
+    /* We don't maintain JS property attributes for Java class members */
+    if (*attrsp != (JSPROP_PERMANENT|JSPROP_ENUMERATE)) {
+        PR_ASSERT(0);
+        return JS_FALSE;
+    }
+
+    /* Silently ignore all setAttribute attempts */
+    return JS_TRUE;
+}
+
+static JSBool
+JavaArray_deleteProperty(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
+{
+    JSVersion version = JS_GetVersion(cx);
+
+    *vp = JSVAL_FALSE;
+    
+    if (!JSVERSION_IS_ECMA(version)) {
+        JS_ReportError(cx, "Properties of JavaArray objects may not be deleted");
+        return JS_FALSE;
+    } else {
+        /* Attempts to delete permanent properties are silently ignored
+           by ECMAScript. */
+        return JS_TRUE;
+    }
+}
+
+static JSBool
+JavaArray_defaultValue(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
+{
+    /* printf("In JavaArray_defaultValue()\n"); */
+    return JavaObject_convert(cx, obj, JSTYPE_STRING, vp);
+}
+
+static JSBool
+JavaArray_newEnumerate(JSContext *cx, JSObject *obj, JSIterateOp enum_op,
+                       jsval *statep, jsid *idp)
+{
+    JavaObjectWrapper *java_wrapper;
+    JNIEnv *jEnv;
+    jsize array_length, index;
+
+    java_wrapper = JS_GetPrivate(cx, obj);
+    /* Check for prototype object */
+    if (!java_wrapper) {
+        *statep = JSVAL_NULL;
+        if (idp)
+            *idp = INT_TO_JSVAL(0);
+        return JS_TRUE;
+    }
+        
+    /* Get the Java per-thread environment pointer for this JSContext */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+
+    array_length = jsj_GetJavaArrayLength(cx, jEnv, java_wrapper->java_obj);
+    if (array_length < 0)
+        return JS_FALSE;
+
+    switch(enum_op) {
+    case JSENUMERATE_INIT:
+        *statep = INT_TO_JSVAL(0);
+
+        if (idp)
+            *idp = INT_TO_JSVAL(array_length);
+        return JS_TRUE;
+        
+    case JSENUMERATE_NEXT:
+        index = JSVAL_TO_INT(*statep);
+        if (index < array_length) {
+            JS_ValueToId(cx, INT_TO_JSVAL(index), idp);
+            index++;
+            *statep = INT_TO_JSVAL(index);
+            return JS_TRUE;
+        }
+
+        /* Fall through ... */
+
+    case JSENUMERATE_DESTROY:
+        *statep = JSVAL_NULL;
+        return JS_TRUE;
+
+    default:
+        PR_ASSERT(0);
+        return JS_FALSE;
+    }
+}
+
+static JSBool
+JavaArray_checkAccess(JSContext *cx, JSObject *obj, jsid id,
+                      JSAccessMode mode, jsval *vp, uintN *attrsp)
+{
+    switch (mode) {
+    case JSACC_WATCH:
+        JS_ReportError(cx, "Cannot place watchpoints on JavaArray object properties");
+        return JS_FALSE;
+
+    case JSACC_IMPORT:
+        JS_ReportError(cx, "Cannot export a JavaArray object's properties");
+        return JS_FALSE;
+
+    default:
+        return JS_TRUE;
+    }
+}
+
+JSObjectOps JavaArray_ops = {
+    /* Mandatory non-null function pointer members. */
+    NULL,                       /* newObjectMap */
+    NULL,                       /* destroyObjectMap */
+    JavaArray_lookupProperty,
+    JavaArray_defineProperty,
+    JavaArray_getPropertyById,  /* getProperty */
+    JavaArray_setPropertyById,  /* setProperty */
+    JavaArray_getAttributes,
+    JavaArray_setAttributes,
+    JavaArray_deleteProperty,
+    JavaArray_defaultValue,
+    JavaArray_newEnumerate,
+    JavaArray_checkAccess,
+
+    /* Optionally non-null members start here. */
+    NULL,                       /* thisObject */
+    NULL,                       /* dropProperty */
+    NULL,                       /* call */
+    NULL,                       /* construct */
+    NULL,                       /* xdrObject */
+    NULL                        /* hasInstance */
+};
+
+static JSObjectOps *
+JavaArray_getObjectOps(JSContext *cx, JSClass *clazz)
+{
+    return &JavaArray_ops;
+}
+
+JSClass JavaArray_class = {
+    "JavaArray", JSCLASS_HAS_PRIVATE,
+    NULL, NULL, NULL, NULL,
+    NULL, NULL, JavaObject_convert, JavaObject_finalize,
+    JavaArray_getObjectOps,
+};
+
+extern PR_IMPORT_DATA(JSObjectOps) js_ObjectOps;
+
+
+/* Initialize the JS JavaArray class */
+JSBool
+jsj_init_JavaArray(JSContext *cx, JSObject *global_obj)
+{
+    JavaArray_ops.newObjectMap = js_ObjectOps.newObjectMap;
+    JavaArray_ops.destroyObjectMap = js_ObjectOps.destroyObjectMap;
+
+    if (!JS_InitClass(cx, global_obj, 
+        0, &JavaArray_class, 0, 0,
+        0, 0, 0, 0))
+        return JS_FALSE;
+    
+    return JS_TRUE;
+}
+

mozilla/js/src/liveconnect/jsj_JavaClass.c

@@ -0,0 +1,586 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+
+/* This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the native code implementation of JS's JavaClass class.
+ *
+ * A JavaClass is JavaScript's representation of a Java class.
+ * Its parent JS object is always a JavaPackage object.  A JavaClass is not an
+ * exact reflection of Java's corresponding java.lang.Class object.  Rather,
+ * the properties of a JavaClass are the static methods and properties of the
+ * corresponding Java class.
+ *
+ * Note that there is no runtime equivalent to the JavaClass class in Java.
+ * (Although there are instances of java.lang.String and there are static
+ * methods of java.lang.String that can be invoked, there's no such thing as
+ * a first-class object that can be referenced simply as "java.lang.String".)
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jsj_private.h"        /* LiveConnect internals */
+
+static JSBool
+JavaClass_convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
+{
+    char *name;
+    JSString *str;
+
+    JavaClassDescriptor *class_descriptor;
+    
+    class_descriptor = JS_GetPrivate(cx, obj);
+    if (!class_descriptor)
+        return JS_FALSE;
+
+    switch(type) {
+
+
+    case JSTYPE_STRING:
+        /* Convert '/' to '.' so that it looks like Java language syntax. */
+        if (!class_descriptor->name)
+            break;
+        name = PR_smprintf("[JavaClass %s]", class_descriptor->name);
+        if (!name) {
+            JS_ReportOutOfMemory(cx);
+            return JS_FALSE;
+        }
+
+        str = JS_NewString(cx, name, strlen(name));
+        if (!str) {
+            free(name);
+            /* It's not necessary to call JS_ReportOutOfMemory(), as
+               JS_NewString() will do so on failure. */
+            return JS_FALSE;
+        }
+
+        *vp = STRING_TO_JSVAL(str);
+        return JS_TRUE;
+
+    default:
+      break;
+    }
+    return JS_TRUE;
+}
+
+static JSBool
+lookup_static_member_by_id(JSContext *cx, JNIEnv *jEnv, JSObject *obj,
+                           JavaClassDescriptor **class_descriptorp,
+                           jsid id, JavaMemberDescriptor **memberp)
+{
+    jsval idval;
+    JavaMemberDescriptor *member_descriptor;
+    const char *member_name;
+    JavaClassDescriptor *class_descriptor;
+
+    class_descriptor = JS_GetPrivate(cx, obj);
+    if (!class_descriptor) {
+        *class_descriptorp = NULL;
+        *memberp = NULL;
+        return JS_TRUE;
+    }
+    
+    if (class_descriptorp)
+        *class_descriptorp = class_descriptor;
+    
+    member_descriptor = jsj_LookupJavaStaticMemberDescriptorById(cx, jEnv, class_descriptor, id);
+    if (!member_descriptor) {
+        JS_IdToValue(cx, id, &idval);
+        if (!JSVAL_IS_STRING(idval)) {
+            JS_ReportError(cx, "invalid JavaClass property expression. "
+                "(methods and fields of a JavaClass object can only be identified by their name)");
+            return JS_FALSE;
+        }
+
+        member_name = JS_GetStringBytes(JSVAL_TO_STRING(idval));
+
+        /* Why do we have to do this ? */
+        if (!strcmp(member_name, "prototype")) {
+            *memberp = NULL;
+            return JS_TRUE;
+        }
+
+        JS_ReportError(cx, "Java class %s has no public static field or method named \"%s\"",
+                       class_descriptor->name, member_name);
+        return JS_FALSE;
+    }
+    if (memberp)
+        *memberp = member_descriptor;
+    return JS_TRUE;
+}
+
+PR_STATIC_CALLBACK(JSBool)
+JavaClass_getPropertyById(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
+{
+    jsval idval;
+    jclass java_class;
+    const char *member_name;
+    JavaClassDescriptor *class_descriptor;
+    JavaMemberDescriptor *member_descriptor;
+    JNIEnv *jEnv;
+
+    /* printf("In JavaClass_getProperty\n"); */
+    
+    /* Get the Java per-thread environment pointer for this JSContext */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+
+    if (!lookup_static_member_by_id(cx, jEnv, obj, &class_descriptor, id, &member_descriptor))
+        return JS_FALSE;
+    if (!member_descriptor) {
+        *vp = JSVAL_VOID;
+        return JS_TRUE;
+    }
+
+    java_class = class_descriptor->java_class;
+
+    if (member_descriptor->field) {
+        if (!member_descriptor->methods) {
+            return jsj_GetJavaFieldValue(cx, jEnv, member_descriptor->field, java_class, vp);
+        } else {
+            PR_ASSERT(0);
+        }
+    } else {
+        JSFunction *function;
+        
+        /* TODO - eliminate JSFUN_BOUND_METHOD */
+        JS_IdToValue(cx, id, &idval);
+        member_name = JS_GetStringBytes(JSVAL_TO_STRING(idval));
+        function = JS_NewFunction(cx, jsj_JavaStaticMethodWrapper, 0,
+                                  JSFUN_BOUND_METHOD, obj, member_name);
+        if (!function)
+            return JS_FALSE;
+
+        *vp = OBJECT_TO_JSVAL(JS_GetFunctionObject(function));
+    }
+    return JS_TRUE;
+}
+
+PR_STATIC_CALLBACK(JSBool)
+JavaClass_setPropertyById(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
+{
+    jclass java_class;
+    const char *member_name;
+    JavaClassDescriptor *class_descriptor;
+    JavaMemberDescriptor *member_descriptor;
+    jsval idval;
+    JNIEnv *jEnv;
+
+    /* printf("In JavaClass_setProperty\n"); */
+
+    /* Get the Java per-thread environment pointer for this JSContext */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+    
+    if (!lookup_static_member_by_id(cx, jEnv, obj, &class_descriptor, id, &member_descriptor))
+        return JS_FALSE;
+
+    /* Check for the case where there is a method with the given name, but no field
+       with that name */
+    if (!member_descriptor->field)
+        goto no_such_field;
+
+    /* Silently fail if field value is final (immutable), as required by ECMA spec */
+    if (member_descriptor->field->modifiers & ACC_FINAL)
+        return JS_TRUE;
+
+    java_class = class_descriptor->java_class;
+    return jsj_SetJavaFieldValue(cx, jEnv, member_descriptor->field, java_class, *vp);
+
+no_such_field:
+    JS_IdToValue(cx, id, &idval);
+    member_name = JS_GetStringBytes(JSVAL_TO_STRING(idval));
+    JS_ReportError(cx, "No static field named \"%s\" in Java class %s",
+                   member_name, class_descriptor->name);
+    return JS_FALSE;
+}
+
+/*
+ * Free the private native data associated with the JavaPackage object.
+ */
+PR_STATIC_CALLBACK(void)
+JavaClass_finalize(JSContext *cx, JSObject *obj)
+{
+    JNIEnv *jEnv;
+
+    JavaClassDescriptor *class_descriptor = JS_GetPrivate(cx, obj);
+    if (!class_descriptor)
+        return;
+    
+    /* Get the Java per-thread environment pointer for this JSContext */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return;
+
+    /* printf("Finalizing %s\n", class_descriptor->name); */
+    jsj_ReleaseJavaClassDescriptor(cx, jEnv, class_descriptor);
+}
+
+
+static JSBool
+JavaClass_lookupProperty(JSContext *cx, JSObject *obj, jsid id,
+                         JSObject **objp, JSProperty **propp
+#if defined JS_THREADSAFE && defined DEBUG
+                            , const char *file, uintN line
+#endif
+                            )
+{
+    JNIEnv *jEnv;
+    JSErrorReporter old_reporter;
+
+    /* printf("In JavaClass_lookupProperty()\n"); */
+    
+    /* Get the Java per-thread environment pointer for this JSContext */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+
+    old_reporter = JS_SetErrorReporter(cx, NULL);
+    if (lookup_static_member_by_id(cx, jEnv, obj, NULL, id, NULL)) {
+        *objp = obj;
+        *propp = (JSProperty*)1;
+    } else {
+        *objp = NULL;
+        *propp = NULL;
+    }
+
+    JS_SetErrorReporter(cx, old_reporter);
+    return JS_TRUE;
+}
+
+static JSBool
+JavaClass_defineProperty(JSContext *cx, JSObject *obj, jsid id, jsval value,
+                         JSPropertyOp getter, JSPropertyOp setter,
+                         uintN attrs, JSProperty **propp)
+{
+    JS_ReportError(cx, "Cannot define a new property in a JavaClass");
+    return JS_FALSE;
+}
+
+static JSBool
+JavaClass_getAttributes(JSContext *cx, JSObject *obj, jsid id,
+                        JSProperty *prop, uintN *attrsp)
+{
+    /* We don't maintain JS property attributes for Java class members */
+    *attrsp = JSPROP_PERMANENT|JSPROP_ENUMERATE;
+    return JS_FALSE;
+}
+
+static JSBool
+JavaClass_setAttributes(JSContext *cx, JSObject *obj, jsid id,
+                        JSProperty *prop, uintN *attrsp)
+{
+    /* We don't maintain JS property attributes for Java class members */
+    if (*attrsp != (JSPROP_PERMANENT|JSPROP_ENUMERATE)) {
+        PR_ASSERT(0);
+        return JS_FALSE;
+    }
+
+    /* Silently ignore all setAttribute attempts */
+    return JS_TRUE;
+}
+
+static JSBool
+JavaClass_deleteProperty(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
+{
+    JSVersion version = JS_GetVersion(cx);
+    
+    *vp = JSVAL_FALSE;
+
+    if (!JSVERSION_IS_ECMA(version)) {
+        JS_ReportError(cx, "Properties of JavaClass objects may not be deleted");
+        return JS_FALSE;
+    } else {
+        /* Attempts to delete permanent properties are silently ignored
+           by ECMAScript. */
+        return JS_TRUE;
+    }
+}
+
+static JSBool
+JavaClass_defaultValue(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
+{
+    /* printf("In JavaClass_defaultValue()\n"); */
+    return JavaClass_convert(cx, obj, JSTYPE_STRING, vp);
+}
+
+static JSBool
+JavaClass_newEnumerate(JSContext *cx, JSObject *obj, JSIterateOp enum_op,
+                       jsval *statep, jsid *idp)
+{
+    JavaMemberDescriptor *member_descriptor;
+    JavaClassDescriptor *class_descriptor;
+    JNIEnv *jEnv;
+    
+    class_descriptor = JS_GetPrivate(cx, obj);
+
+    /* Check for prototype JavaClass object */
+    if (!class_descriptor) {
+        *statep = JSVAL_NULL;
+        if (idp)
+            *idp = INT_TO_JSVAL(0);
+        return JS_TRUE;
+    }
+    
+    switch(enum_op) {
+    case JSENUMERATE_INIT:
+        /* Get the Java per-thread environment pointer for this JSContext */
+        jsj_MapJSContextToJSJThread(cx, &jEnv);
+        if (!jEnv)
+            return JS_FALSE;
+        member_descriptor = jsj_GetClassStaticMembers(cx, jEnv, class_descriptor);
+        *statep = PRIVATE_TO_JSVAL(member_descriptor);
+        if (idp)
+            *idp = INT_TO_JSVAL(class_descriptor->num_instance_members);
+        return JS_TRUE;
+        
+    case JSENUMERATE_NEXT:
+        member_descriptor = JSVAL_TO_PRIVATE(*statep);
+        if (member_descriptor) {
+            *idp = member_descriptor->id;
+            *statep = PRIVATE_TO_JSVAL(member_descriptor->next);
+            return JS_TRUE;
+        }
+        /* Fall through ... */
+
+    case JSENUMERATE_DESTROY:
+        *statep = JSVAL_NULL;
+        return JS_TRUE;
+
+    default:
+        PR_ASSERT(0);
+        return JS_FALSE;
+    }
+}
+
+static JSBool
+JavaClass_checkAccess(JSContext *cx, JSObject *obj, jsid id,
+                      JSAccessMode mode, jsval *vp, uintN *attrsp)
+{
+    switch (mode) {
+    case JSACC_WATCH:
+        JS_ReportError(cx, "Cannot place watchpoints on JavaClass object properties");
+        return JS_FALSE;
+
+    case JSACC_IMPORT:
+        JS_ReportError(cx, "Cannot export a JavaClass object's properties");
+        return JS_FALSE;
+
+    default:
+        return JS_TRUE;
+    }
+}
+
+/*
+ * Implement the JavaScript instanceof operator for JavaClass objects by using
+ * the equivalent Java instanceof operation.
+ */
+static JSBool
+JavaClass_hasInstance(JSContext *cx, JSObject *obj, jsval candidate_jsval,
+                      JSBool *has_instancep)
+{
+    JavaClassDescriptor *class_descriptor;
+    JavaObjectWrapper *java_wrapper;
+    JSClass *js_class;
+    JSBool has_instance;
+    JSObject *candidate_obj;
+    jclass java_class;
+    jobject java_obj;
+    JNIEnv *jEnv;
+    
+    has_instance = JS_FALSE;
+    class_descriptor = JS_GetPrivate(cx, obj);
+    if (!class_descriptor) {
+        JS_ReportError(cx, "illegal operation on JavaClass prototype object");
+        return JS_FALSE;
+    }
+
+    /*
+     * Make sure that the thing to the left of the instanceof operator is a
+     * Java object.
+     */
+    if (!JSVAL_IS_OBJECT(candidate_jsval))
+        goto done;
+    candidate_obj = JSVAL_TO_OBJECT(candidate_jsval);
+    js_class = JS_GetClass(candidate_obj);
+    if ((js_class != &JavaObject_class) && (js_class != &JavaArray_class))
+        goto done;
+
+    java_class = class_descriptor->java_class;
+    java_wrapper = JS_GetPrivate(cx, candidate_obj);
+    if (!java_wrapper) {
+        JS_ReportError(cx, "illegal operation on prototype object");
+        return JS_FALSE;
+    }
+    java_obj = java_wrapper->java_obj;
+    /* Get JNI pointer */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    has_instance = (*jEnv)->IsInstanceOf(jEnv, java_obj, java_class);
+
+done:
+    *has_instancep = has_instance;
+    return JS_TRUE;
+}
+
+JSObjectOps JavaClass_ops = {
+    /* Mandatory non-null function pointer members. */
+    NULL,                       /* newObjectMap */
+    NULL,                       /* destroyObjectMap */
+    JavaClass_lookupProperty,
+    JavaClass_defineProperty,
+    JavaClass_getPropertyById,  /* getProperty */
+    JavaClass_setPropertyById,  /* setProperty */
+    JavaClass_getAttributes,
+    JavaClass_setAttributes,
+    JavaClass_deleteProperty,
+    JavaClass_defaultValue,
+    JavaClass_newEnumerate,
+    JavaClass_checkAccess,
+
+    /* Optionally non-null members start here. */
+    NULL,                       /* thisObject */
+    NULL,                       /* dropProperty */
+    jsj_JavaConstructorWrapper, /* call */
+    jsj_JavaConstructorWrapper, /* construct */
+    NULL,                       /* xdrObject */
+    JavaClass_hasInstance,      /* hasInstance */
+};
+
+static JSObjectOps *
+JavaClass_getObjectOps(JSContext *cx, JSClass *clazz)
+{
+    return &JavaClass_ops;
+}
+
+JSClass JavaClass_class = {
+    "JavaClass", JSCLASS_HAS_PRIVATE,
+    NULL, NULL, NULL, NULL,
+    NULL, NULL, JavaClass_convert, JavaClass_finalize,
+    JavaClass_getObjectOps,
+};
+
+static JSObject *
+jsj_new_JavaClass(JSContext *cx, JNIEnv *jEnv, JSObject* parent_obj,
+                  JavaClassDescriptor *class_descriptor)
+{
+    JSObject *JavaClass_obj;
+
+    JavaClass_obj = JS_NewObject(cx, &JavaClass_class, 0, parent_obj);
+    if (!JavaClass_obj)
+        return NULL;
+
+    JS_SetPrivate(cx, JavaClass_obj, (void *)class_descriptor);
+
+#ifdef DEBUG
+    /*    printf("JavaClass \'%s\' created\n", class_descriptor->name); */
+#endif
+
+    return JavaClass_obj;
+}
+
+JSObject *
+jsj_define_JavaClass(JSContext *cx, JNIEnv *jEnv, JSObject* parent_obj,
+                     const char *simple_class_name,
+                     jclass java_class)
+{
+    JavaClassDescriptor *class_descriptor;
+    JSObject *JavaClass_obj;
+
+    class_descriptor = jsj_GetJavaClassDescriptor(cx, jEnv, java_class);
+    if (!class_descriptor)
+        return NULL;
+
+    JavaClass_obj = jsj_new_JavaClass(cx, jEnv, parent_obj, class_descriptor);
+    if (!JavaClass_obj)
+        return NULL;
+
+    if (!JS_DefineProperty(cx, parent_obj, simple_class_name,
+                           OBJECT_TO_JSVAL(JavaClass_obj), 0, 0,
+                           JSPROP_PERMANENT|JSPROP_READONLY|JSPROP_ENUMERATE))
+        return NULL;
+    return JavaClass_obj;
+}
+
+
+/*
+ * The getClass() native JS method is defined as a property of the global
+ * object.  Given a JavaObject it returns the corresponding JavaClass.  This
+ * is useful for accessing static methods and fields.
+ *
+ *    js> getClass(new java.lang.String("foo"))
+ *    [JavaClass java.lang.String]
+ */
+static JSBool
+getClass(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
+{
+    JSObject *obj_arg, *JavaClass_obj;
+    JavaObjectWrapper *java_wrapper;
+    JavaClassDescriptor *class_descriptor;
+    JNIEnv *jEnv;
+
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+
+    if (argc != 1 ||
+    !JSVAL_IS_OBJECT(argv[0]) ||
+    !(obj_arg = JSVAL_TO_OBJECT(argv[0])) ||
+    (!JS_InstanceOf(cx, obj_arg, &JavaObject_class, 0) &&
+         !JS_InstanceOf(cx, obj_arg, &JavaArray_class, 0))) {
+        JS_ReportError(cx, "getClass expects a Java object argument");
+    return JS_FALSE;
+    }
+
+    java_wrapper = JS_GetPrivate(cx, obj_arg);
+    if (!java_wrapper) {
+        JS_ReportError(cx, "getClass called on prototype object");
+        return JS_FALSE;
+    }
+
+    class_descriptor = java_wrapper->class_descriptor;
+
+    JavaClass_obj = jsj_new_JavaClass(cx, jEnv, NULL, class_descriptor);
+    if (!JavaClass_obj)
+        return JS_FALSE;
+    *rval = OBJECT_TO_JSVAL(JavaClass_obj);
+    return JS_TRUE;
+}
+
+extern PR_IMPORT_DATA(JSObjectOps) js_ObjectOps;
+
+JSBool
+jsj_init_JavaClass(JSContext *cx, JSObject *global_obj)
+{
+    JavaClass_ops.newObjectMap = js_ObjectOps.newObjectMap;
+    JavaClass_ops.destroyObjectMap = js_ObjectOps.destroyObjectMap;
+    
+    /* Define JavaClass class */
+    if (!JS_InitClass(cx, global_obj, 0, &JavaClass_class, 0, 0, 0, 0, 0, 0))
+        return JS_FALSE;
+
+    if (!JS_DefineFunction(cx, global_obj, "getClass", getClass, 0,
+                           JSPROP_READONLY))
+        return JS_FALSE;
+
+    return jsj_InitJavaClassReflectionsTable();
+}
+

mozilla/js/src/liveconnect/jsj_JavaMember.c

@@ -0,0 +1,134 @@
+/* -*- Mode: C; tab-width: 8 -*-
+ * Copyright (C) 1998 Netscape Communications Corporation, All Rights Reserved.
+ */
+
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the native code implementation of JS's JavaMember class.
+ * JavaMember's are a strange beast required only to handle the special case
+ * of a public field and a public method that appear in the same class and
+ * have the same name.  When such a field/method is used in Java, the compiler
+ * can statically determine from context whether the field or the method is
+ * being referenced, but that is not possible with JavaScript.  For example:
+ *
+ * ambiguousVal = javaObj.fieldOrMethod; // ambiguousVal is a JavaMember object
+ * a = ambiguousVal();                   // ambiguousVal used as a method value
+ * b = ambiguousVal + 4;                 // ambiguousVal used as a field value
+ *
+ * A JavaMember instance carries both the captured value of the Java field and
+ * the method value until the context that the value is to be used in is known,
+ * at which point conversion forces the use of one or the other.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jsj_private.h"      /* LiveConnect internals */
+
+/* Private, native portion of a JavaMember */
+typedef struct JavaMethodOrFieldValue {
+    jsval method_val;
+    jsval field_val;
+} JavaMethodOrFieldValue;
+
+JSObject *
+jsj_CreateJavaMember(JSContext *cx, jsval method_val, jsval field_val)
+{
+    JavaMethodOrFieldValue *member_val;
+    JSObject *JavaMember_obj;
+    
+    member_val = (JavaMethodOrFieldValue *)JS_malloc(cx, sizeof(*member_val));
+    if (!member_val)
+        return NULL;
+    
+    JavaMember_obj = JS_NewObject(cx, &JavaMember_class, 0, 0);
+    if (!JavaMember_obj) {
+        JS_free(cx, member_val);
+        return NULL;
+    }
+
+    JS_SetPrivate(cx, JavaMember_obj, (void *)member_val);
+    member_val->method_val = method_val;
+    JS_AddRoot(cx, &member_val->method_val);
+    member_val->field_val = field_val;
+    if (JSVAL_IS_GCTHING(field_val))
+        JS_AddRoot(cx, &member_val->field_val);
+
+    return JavaMember_obj;
+}
+
+static void
+JavaMember_finalize(JSContext *cx, JSObject *obj)
+{
+    JavaMethodOrFieldValue *member_val;
+    JNIEnv *jEnv;
+
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return;
+
+    member_val = JS_GetPrivate(cx, obj);
+    if (!member_val)
+        return;
+    JS_RemoveRoot(cx, &member_val->method_val);
+    if (JSVAL_IS_GCTHING(member_val->method_val))
+        JS_RemoveRoot(cx, &member_val->method_val);
+    JS_free(cx, member_val);
+}
+
+static JSBool
+JavaMember_convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
+{
+    JavaMethodOrFieldValue *member_val;
+        
+    member_val = JS_GetPrivate(cx, obj);
+    if (!member_val) {
+        if (type == JSTYPE_OBJECT) {
+            *vp = OBJECT_TO_JSVAL(obj);
+            return JS_TRUE;
+        }
+        
+        JS_ReportError(cx, "illegal operation on JavaObject prototype object");
+        return JS_FALSE;
+    }
+
+    switch (type) {
+    case JSTYPE_VOID:
+    case JSTYPE_STRING:
+    case JSTYPE_NUMBER:
+    case JSTYPE_BOOLEAN:
+    case JSTYPE_OBJECT:
+        *vp = member_val->field_val;
+        return JS_TRUE;
+
+    case JSTYPE_FUNCTION:
+        *vp = member_val->method_val;
+        return JS_TRUE;
+
+    default:
+        PR_ASSERT(0);
+        return JS_FALSE;
+    }
+}
+
+JSClass JavaMember_class = {
+    "JavaMember", JSCLASS_HAS_PRIVATE,
+    JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
+    JS_EnumerateStub, JS_ResolveStub, 
+    JavaMember_convert, JavaMember_finalize
+};
+
+extern PR_IMPORT_DATA(JSObjectOps) js_ObjectOps;
+
+JSBool
+jsj_init_JavaMember(JSContext *cx, JSObject *global_obj)
+{
+    if (!JS_InitClass(cx, global_obj, 
+        0, &JavaMember_class, 0, 0,
+        0, 0,
+        0, 0))
+        return JS_FALSE;
+
+    return JS_TRUE;
+}

mozilla/js/src/liveconnect/jsj_JavaObject.c

@@ -0,0 +1,686 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the native code implementation of JS's JavaObject class.
+ *
+ * An instance of JavaObject is the JavaScript reflection of a Java object.
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jsj_private.h"      /* LiveConnect internals */
+#include "jsj_hash.h"         /* Hash table with Java object as key */
+
+
+/*
+ * This is a hash table that maps from Java objects to JS objects.
+ * It is used to ensure that the same JS object is obtained when a Java
+ * object is reflected more than once, so that JS object equality tests
+ * work in the expected manner, i.e. the "==" and "===" operators.
+ *
+ * The table entry keys are Java objects (of type jobject) and the entry values
+ * are JSObject pointers.  Because the jobject type is an opaque handle and
+ * not necessarily a pointer, the hashing and key comparison functions must
+ * invoke the appropriate JVM functions.
+ *
+ * When the corresponding JS object instance is finalized, the entry is
+ * removed from the table, and a Java GC root for the Java object is removed.
+ */
+static JSJHashTable *java_obj_reflections = NULL;
+
+#ifdef JS_THREADSAFE
+static PRMonitor *java_obj_reflections_monitor = NULL;
+#endif
+
+static JSBool
+init_java_obj_reflections_table()
+{
+    java_obj_reflections =
+        JSJ_NewHashTable(512, jsj_HashJavaObject, jsj_JavaObjectComparator,
+                         NULL, NULL, NULL);
+    if (!java_obj_reflections)
+        return JS_FALSE;
+
+#ifdef JS_THREADSAFE
+    java_obj_reflections_monitor = PR_NewNamedMonitor("java_obj_reflections");
+    if (!java_obj_reflections_monitor) {
+        PR_HashTableDestroy(java_obj_reflections);
+        return JS_FALSE;
+    }
+#endif
+
+    return JS_TRUE;
+}
+
+JSObject *
+jsj_WrapJavaObject(JSContext *cx,
+                   JNIEnv *jEnv,
+                   jobject java_obj,
+                   jclass java_class)
+{
+    JSJHashNumber hash_code;
+    JSClass *js_class;
+    JSObject *js_wrapper_obj;
+    JavaObjectWrapper *java_wrapper;
+    JavaClassDescriptor *class_descriptor;
+    JSJHashEntry *he, **hep;
+
+    js_wrapper_obj = NULL;
+
+    hash_code = jsj_HashJavaObject((void*)java_obj, (void*)jEnv);
+
+#ifdef JS_THREADSAFE
+    PR_EnterMonitor(java_obj_reflections_monitor);
+#endif
+    
+    hep = JSJ_HashTableRawLookup(java_obj_reflections,
+                                 hash_code, java_obj, (void*)jEnv);
+    he = *hep;
+    if (he) {
+        js_wrapper_obj = (JSObject *)he->value;
+        if (js_wrapper_obj)
+            goto done;
+    }
+
+    /* No existing reflection found.  Construct a new one */
+    class_descriptor = jsj_GetJavaClassDescriptor(cx, jEnv, java_class);
+    if (!class_descriptor)
+        goto done;
+    if (class_descriptor->type == JAVA_SIGNATURE_ARRAY) {
+        js_class = &JavaArray_class;
+    } else {
+        PR_ASSERT(class_descriptor->type == JAVA_SIGNATURE_CLASS);
+        js_class = &JavaObject_class;
+    }
+    
+    /* Create new JS object to reflect Java object */
+    js_wrapper_obj = JS_NewObject(cx, js_class, NULL, NULL);
+    if (!js_wrapper_obj)
+        goto done;
+
+    /* Create private, native portion of JavaObject */
+    java_wrapper =
+        (JavaObjectWrapper *)JS_malloc(cx, sizeof(JavaObjectWrapper));
+    if (!java_wrapper) {
+        jsj_ReleaseJavaClassDescriptor(cx, jEnv, class_descriptor);
+        goto done;
+    }
+    JS_SetPrivate(cx, js_wrapper_obj, java_wrapper);
+    java_wrapper->class_descriptor = class_descriptor;
+
+    java_obj = (*jEnv)->NewGlobalRef(jEnv, java_obj);
+    java_wrapper->java_obj = java_obj;
+    if (!java_obj)
+        goto out_of_memory;
+
+    /* Add the JavaObject to the hash table */
+    he = JSJ_HashTableRawAdd(java_obj_reflections, hep, hash_code,
+                             java_obj, js_wrapper_obj, (void*)jEnv);
+    if (!he) {
+        (*jEnv)->DeleteGlobalRef(jEnv, java_obj);
+        goto out_of_memory;
+    } 
+
+done:
+#ifdef JS_THREADSAFE
+        PR_ExitMonitor(java_obj_reflections_monitor);
+#endif
+        
+    return js_wrapper_obj;
+
+out_of_memory:
+    /* No need to free js_wrapper_obj, as it will be finalized by GC. */
+    JS_ReportOutOfMemory(cx);
+    js_wrapper_obj = NULL;
+    goto done;
+}
+
+static void
+remove_java_obj_reflection_from_hashtable(jobject java_obj, JNIEnv *jEnv)
+{
+    JSJHashNumber hash_code;
+    JSJHashEntry *he, **hep;
+
+    hash_code = jsj_HashJavaObject((void*)java_obj, (void*)jEnv);
+
+#ifdef JS_THREADSAFE
+    PR_EnterMonitor(java_obj_reflections_monitor);
+#endif
+
+    hep = JSJ_HashTableRawLookup(java_obj_reflections, hash_code,
+                                 java_obj, (void*)jEnv);
+    he = *hep;
+
+    PR_ASSERT(he);
+    if (he)
+        JSJ_HashTableRawRemove(java_obj_reflections, hep, he, (void*)jEnv);
+
+#ifdef JS_THREADSAFE
+    PR_ExitMonitor(java_obj_reflections_monitor);
+#endif
+}
+
+void
+JavaObject_finalize(JSContext *cx, JSObject *obj)
+{
+    JavaObjectWrapper *java_wrapper;
+    jobject java_obj;
+    JNIEnv *jEnv;
+
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return;
+
+    java_wrapper = JS_GetPrivate(cx, obj);
+    if (!java_wrapper)
+        return;
+    java_obj = java_wrapper->java_obj;
+
+    if (java_obj) {
+        remove_java_obj_reflection_from_hashtable(java_obj, jEnv);
+        (*jEnv)->DeleteGlobalRef(jEnv, java_obj);
+    }
+    jsj_ReleaseJavaClassDescriptor(cx, jEnv, java_wrapper->class_descriptor);
+    JS_free(cx, java_wrapper);
+}
+
+/* Trivial helper for jsj_DiscardJavaObjReflections(), below */
+static PRIntn
+enumerate_remove_java_obj(JSJHashEntry *he, PRIntn i, void *arg)
+{
+    JNIEnv *jEnv = (JNIEnv*)arg;
+    jobject java_obj;
+    JavaObjectWrapper *java_wrapper;
+    JSObject *java_wrapper_obj;
+
+    java_wrapper_obj = (JSObject *)he->value;
+    java_wrapper = JS_GetPrivate(NULL, java_wrapper_obj);
+    java_obj = java_wrapper->java_obj;
+    (*jEnv)->DeleteGlobalRef(jEnv, java_obj);
+    java_wrapper->java_obj = NULL;
+    return HT_ENUMERATE_REMOVE;
+}
+
+/* This shutdown routine discards all JNI references to Java objects
+   that have been reflected into JS, even if there are still references
+   to them from JS. */
+void
+jsj_DiscardJavaObjReflections(JNIEnv *jEnv)
+{
+    if (java_obj_reflections) {
+        JSJ_HashTableEnumerateEntries(java_obj_reflections,
+                                      enumerate_remove_java_obj,
+                                      (void*)jEnv);
+        JSJ_HashTableDestroy(java_obj_reflections);
+        java_obj_reflections = NULL;
+    }
+}
+
+PR_CALLBACK JSBool
+JavaObject_convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
+{
+    JavaObjectWrapper *java_wrapper;
+    JavaClassDescriptor *class_descriptor;
+    jobject java_obj;
+    JNIEnv *jEnv;
+    
+    /* Get the Java per-thread environment pointer for this JSContext */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+        
+    java_wrapper = JS_GetPrivate(cx, obj);
+    if (!java_wrapper) {
+        if (type == JSTYPE_OBJECT) {
+            *vp = OBJECT_TO_JSVAL(obj);
+            return JS_TRUE;
+        }
+        
+        JS_ReportError(cx, "illegal operation on JavaObject prototype object");
+        return JS_FALSE;
+    }
+
+    java_obj = java_wrapper->java_obj;
+    class_descriptor = java_wrapper->class_descriptor;
+
+    switch (type) {
+    case JSTYPE_OBJECT:
+        *vp = OBJECT_TO_JSVAL(obj);
+        return JS_TRUE;
+
+    case JSTYPE_FUNCTION:
+        JS_ReportError(cx, "can't convert Java object to function");
+        return JS_FALSE;
+
+    case JSTYPE_VOID:
+    case JSTYPE_STRING:
+        /* Either extract a C-string from the java.lang.String object
+           or call the Java toString() method */
+        return jsj_ConvertJavaObjectToJSString(cx, jEnv, class_descriptor, java_obj, vp);
+
+    case JSTYPE_NUMBER:
+        /* Call Java doubleValue() method, if applicable */
+        return jsj_ConvertJavaObjectToJSNumber(cx, jEnv, class_descriptor, java_obj, vp);
+
+    case JSTYPE_BOOLEAN:
+        /* Call booleanValue() method, if applicable */
+        return jsj_ConvertJavaObjectToJSBoolean(cx, jEnv, class_descriptor, java_obj, vp);
+
+    default:
+        PR_ASSERT(0);
+        return JS_FALSE;
+    }
+}
+
+static JSBool
+lookup_member_by_id(JSContext *cx, JNIEnv *jEnv, JSObject *obj,
+                    JavaObjectWrapper **java_wrapperp,
+                    jsid id,
+                    JavaMemberDescriptor **member_descriptorp)
+{
+    jsval idval;
+    JavaObjectWrapper *java_wrapper;
+    JavaMemberDescriptor *member_descriptor;
+    const char *member_name, *property_name;
+    JavaClassDescriptor *class_descriptor;
+
+    java_wrapper = JS_GetPrivate(cx, obj);
+    if (!java_wrapper) {
+        if (JS_IdToValue(cx, id, &idval) && JSVAL_IS_STRING(idval) &&
+            (property_name = JS_GetStringBytes(JSVAL_TO_STRING(idval))) != NULL) {
+            if (!strcmp(property_name, "constructor")) {
+                *java_wrapperp = NULL;
+                *member_descriptorp = NULL;
+                return JS_TRUE;
+            }
+        }
+        JS_ReportError(cx, "illegal operation on JavaObject prototype object");
+        return JS_FALSE;
+    }
+
+    class_descriptor = java_wrapper->class_descriptor;
+    PR_ASSERT(class_descriptor->type == JAVA_SIGNATURE_CLASS ||
+              class_descriptor->type == JAVA_SIGNATURE_ARRAY);
+
+    member_descriptor = jsj_LookupJavaMemberDescriptorById(cx, jEnv, class_descriptor, id);
+    if (!member_descriptor) {
+        JS_IdToValue(cx, id, &idval);
+        if (!JSVAL_IS_STRING(idval)) {
+            JS_ReportError(cx, "invalid JavaObject property expression. "
+                "(methods and field properties of a JavaObject object can only be strings)");
+            return JS_FALSE;
+        }
+
+        member_name = JS_GetStringBytes(JSVAL_TO_STRING(idval));
+
+        JS_ReportError(cx, "Java class %s has no public instance field or "
+                           "method named \"%s\"",
+                       class_descriptor->name, member_name);
+        return JS_FALSE;
+    }
+
+    /* Success.  Handle the multiple return values */
+    if (java_wrapperp)
+        *java_wrapperp = java_wrapper;
+    if (member_descriptorp)
+        *member_descriptorp = member_descriptor;
+    return JS_TRUE;
+}
+
+PR_CALLBACK JSBool
+JavaObject_getPropertyById(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
+{
+    jobject java_obj;
+    JavaMemberDescriptor *member_descriptor;
+    JavaObjectWrapper *java_wrapper;
+    JNIEnv *jEnv;
+    JSObject *funobj;
+    jsval field_val, method_val;
+    JSBool success;
+
+    /* printf("In JavaObject_getProperty\n"); */
+
+    /* Get the Java per-thread environment pointer for this JSContext */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+        
+    if (!lookup_member_by_id(cx, jEnv, obj, &java_wrapper, id, &member_descriptor))
+        return JS_FALSE;
+
+    /* Handle access to "constructor" property of prototype object with
+       silent failure. */
+    if (!member_descriptor) {
+        *vp = JSVAL_VOID;
+        return JS_TRUE;
+    }
+
+    java_obj = java_wrapper->java_obj;
+    field_val = method_val = JSVAL_VOID;
+
+    /* If a field member, get the value of the field */
+    if (member_descriptor->field) {
+        success = jsj_GetJavaFieldValue(cx, jEnv, member_descriptor->field, java_obj, &field_val);
+        if (!success)
+            return JS_FALSE;
+    }
+
+    /* If a method member, build a wrapper around the Java method */
+    if (member_descriptor->methods) {
+        /* Create a function object with this JavaObject as its parent, so that
+           JSFUN_BOUND_METHOD binds it as the default 'this' for the function. */
+        funobj = JS_CloneFunctionObject(cx, member_descriptor->invoke_func_obj, obj);
+        if (!funobj)
+            return JS_FALSE;
+        method_val = OBJECT_TO_JSVAL(funobj);
+    }
+
+#if TEST_JAVAMEMBER
+    /* Always create a JavaMember object, even though it's inefficient */
+    obj = jsj_CreateJavaMember(cx, method_val, field_val);
+    if (!obj)
+        return JS_FALSE;
+    *vp = OBJECT_TO_JSVAL(obj);
+#else   /* !TEST_JAVAMEMBER */
+
+    if (member_descriptor->field) {
+        if (!member_descriptor->methods) {
+            /* Return value of Java field */
+            *vp = field_val;
+        } else {
+            /* Handle special case of access to a property that could refer
+               to either a Java field or a method that share the same name.
+               In Java, such ambiguity is not possible because the compiler 
+               can statically determine which is being accessed. */
+            obj = jsj_CreateJavaMember(cx, method_val, field_val);
+            if (!obj)
+                return JS_FALSE;
+            *vp = OBJECT_TO_JSVAL(obj);
+        }
+
+    } else {
+        /* Return wrapper around Java method */
+        *vp = method_val;
+    }
+
+#endif  /* !TEST_JAVAMEMBER */
+
+    return JS_TRUE;
+}
+
+PR_STATIC_CALLBACK(JSBool)
+JavaObject_setPropertyById(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
+{
+    jobject java_obj;
+    const char *member_name;
+    JavaObjectWrapper *java_wrapper;
+    JavaClassDescriptor *class_descriptor;
+    JavaMemberDescriptor *member_descriptor;
+    jsval idval;
+    JNIEnv *jEnv;
+
+    /* printf("In JavaObject_setProperty\n"); */
+
+    /* Get the Java per-thread environment pointer for this JSContext */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+    
+    if (!lookup_member_by_id(cx, jEnv, obj, &java_wrapper, id, &member_descriptor))
+        return JS_FALSE;
+
+    /* Check for the case where there is a method with the give name, but no field
+       with that name */
+    if (!member_descriptor->field)
+        goto no_such_field;
+
+    /* Silently fail if field value is final (immutable), as required by ECMA spec */
+    if (member_descriptor->field->modifiers & ACC_FINAL)
+        return JS_TRUE;
+    
+    java_obj = java_wrapper->java_obj;
+    return jsj_SetJavaFieldValue(cx, jEnv, member_descriptor->field, java_obj, *vp);
+
+no_such_field:
+        JS_IdToValue(cx, id, &idval);
+        member_name = JS_GetStringBytes(JSVAL_TO_STRING(idval));
+        class_descriptor = java_wrapper->class_descriptor;
+        JS_ReportError(cx, "No instance field named \"%s\" in Java class %s",
+                       member_name, class_descriptor->name);
+        return JS_FALSE;
+}
+
+static JSBool
+JavaObject_lookupProperty(JSContext *cx, JSObject *obj, jsid id,
+                         JSObject **objp, JSProperty **propp
+#if defined JS_THREADSAFE && defined DEBUG
+                            , const char *file, uintN line
+#endif
+                            )
+{
+    JNIEnv *jEnv;
+    JSErrorReporter old_reporter;
+
+    /* printf("In JavaObject_lookupProperty()\n"); */
+    
+    /* Get the Java per-thread environment pointer for this JSContext */
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+
+    old_reporter = JS_SetErrorReporter(cx, NULL);
+    if (lookup_member_by_id(cx, jEnv, obj, NULL, id, NULL)) {
+        *objp = obj;
+        *propp = (JSProperty*)1;
+    } else {
+        *objp = NULL;
+        *propp = NULL;
+    }
+
+    JS_SetErrorReporter(cx, old_reporter);
+    return JS_TRUE;
+}
+
+static JSBool
+JavaObject_defineProperty(JSContext *cx, JSObject *obj, jsid id, jsval value,
+                         JSPropertyOp getter, JSPropertyOp setter,
+                         uintN attrs, JSProperty **propp)
+{
+    JS_ReportError(cx, "Cannot define a new property in a JavaObject");
+    return JS_FALSE;
+}
+
+static JSBool
+JavaObject_getAttributes(JSContext *cx, JSObject *obj, jsid id,
+                        JSProperty *prop, uintN *attrsp)
+{
+    /* We don't maintain JS property attributes for Java class members */
+    *attrsp = JSPROP_PERMANENT|JSPROP_ENUMERATE;
+    return JS_FALSE;
+}
+
+static JSBool
+JavaObject_setAttributes(JSContext *cx, JSObject *obj, jsid id,
+                        JSProperty *prop, uintN *attrsp)
+{
+    /* We don't maintain JS property attributes for Java class members */
+    if (*attrsp != (JSPROP_PERMANENT|JSPROP_ENUMERATE)) {
+        PR_ASSERT(0);
+        return JS_FALSE;
+    }
+
+    /* Silently ignore all setAttribute attempts */
+    return JS_TRUE;
+}
+
+static JSBool
+JavaObject_deleteProperty(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
+{
+    JSVersion version = JS_GetVersion(cx);
+    
+    *vp = JSVAL_FALSE;
+
+    if (!JSVERSION_IS_ECMA(version)) {
+        JS_ReportError(cx, "Properties of JavaObject objects may not be deleted");
+        return JS_FALSE;
+    } else {
+        /* Attempts to delete permanent properties are silently ignored
+           by ECMAScript. */
+        return JS_TRUE;
+    }
+}
+
+static JSBool
+JavaObject_defaultValue(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
+{
+    /* printf("In JavaObject_defaultValue()\n"); */
+    return JavaObject_convert(cx, obj, type, vp);
+}
+
+static JSBool
+JavaObject_newEnumerate(JSContext *cx, JSObject *obj, JSIterateOp enum_op,
+                        jsval *statep, jsid *idp)
+{
+    JavaObjectWrapper *java_wrapper;
+    JavaMemberDescriptor *member_descriptor;
+    JavaClassDescriptor *class_descriptor;
+    JNIEnv *jEnv;
+
+    java_wrapper = JS_GetPrivate(cx, obj);
+    /* Check for prototype object */
+    if (!java_wrapper) {
+        *statep = JSVAL_NULL;
+        if (idp)
+            *idp = INT_TO_JSVAL(0);
+        return JS_TRUE;
+    }
+
+    class_descriptor = java_wrapper->class_descriptor;
+
+    switch(enum_op) {
+    case JSENUMERATE_INIT:
+        
+        /* Get the Java per-thread environment pointer for this JSContext */
+        jsj_MapJSContextToJSJThread(cx, &jEnv);
+        if (!jEnv)
+            return JS_FALSE;
+
+        member_descriptor = jsj_GetClassInstanceMembers(cx, jEnv, class_descriptor);
+        *statep = PRIVATE_TO_JSVAL(member_descriptor);
+        if (idp)
+            *idp = INT_TO_JSVAL(class_descriptor->num_instance_members);
+        return JS_TRUE;
+        
+    case JSENUMERATE_NEXT:
+        member_descriptor = JSVAL_TO_PRIVATE(*statep);
+        if (member_descriptor) {
+            *idp = member_descriptor->id;
+            *statep = PRIVATE_TO_JSVAL(member_descriptor->next);
+            return JS_TRUE;
+        }
+
+        /* Fall through ... */
+
+    case JSENUMERATE_DESTROY:
+        *statep = JSVAL_NULL;
+        return JS_TRUE;
+
+    default:
+        PR_ASSERT(0);
+        return JS_FALSE;
+    }
+}
+
+static JSBool
+JavaObject_checkAccess(JSContext *cx, JSObject *obj, jsid id,
+                      JSAccessMode mode, jsval *vp, uintN *attrsp)
+{
+    switch (mode) {
+    case JSACC_WATCH:
+        JS_ReportError(cx, "Cannot place watchpoints on JavaObject object properties");
+        return JS_FALSE;
+
+    case JSACC_IMPORT:
+        JS_ReportError(cx, "Cannot export a JavaObject object's properties");
+        return JS_FALSE;
+
+    default:
+        return JS_TRUE;
+    }
+}
+
+JSObjectOps JavaObject_ops = {
+    /* Mandatory non-null function pointer members. */
+    NULL,                       /* newObjectMap */
+    NULL,                       /* destroyObjectMap */
+    JavaObject_lookupProperty,
+    JavaObject_defineProperty,
+    JavaObject_getPropertyById, /* getProperty */
+    JavaObject_setPropertyById, /* setProperty */
+    JavaObject_getAttributes,
+    JavaObject_setAttributes,
+    JavaObject_deleteProperty,
+    JavaObject_defaultValue,
+    JavaObject_newEnumerate,
+    JavaObject_checkAccess,
+
+    /* Optionally non-null members start here. */
+    NULL,                       /* thisObject */
+    NULL,                       /* dropProperty */
+    NULL,                       /* call */
+    NULL,                       /* construct */
+    NULL,                       /* xdrObject */
+    NULL,                       /* hasInstance */
+};
+
+static JSObjectOps *
+JavaObject_getObjectOps(JSContext *cx, JSClass *clazz)
+{
+    return &JavaObject_ops;
+}
+
+JSClass JavaObject_class = {
+    "JavaObject", JSCLASS_HAS_PRIVATE,
+    NULL, NULL, NULL, NULL,
+    NULL, NULL, JavaObject_convert, JavaObject_finalize,
+    JavaObject_getObjectOps,
+};
+
+extern PR_IMPORT_DATA(JSObjectOps) js_ObjectOps;
+
+
+JSBool
+jsj_init_JavaObject(JSContext *cx, JSObject *global_obj)
+{
+    JavaObject_ops.newObjectMap = js_ObjectOps.newObjectMap;
+    JavaObject_ops.destroyObjectMap = js_ObjectOps.destroyObjectMap;
+
+    if (!JS_InitClass(cx, global_obj, 
+        0, &JavaObject_class, 0, 0,
+        0, 0,
+        0, 0))
+        return JS_FALSE;
+
+    return init_java_obj_reflections_table();
+}

mozilla/js/src/liveconnect/jsj_JavaPackage.c

@@ -0,0 +1,500 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+
+/* This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the native code implementation of the JavaPackage class.
+ *
+ * A JavaPackage is JavaScript's representation of a Java package.  The
+ * JavaPackage object contains only a string, which is the path to the package,
+ * e.g. "java/lang".  The JS properties of a JavaPackage are either nested packages
+ * or a JavaClass object, which represents the path to a Java class.
+ *
+ * Note that there is no equivalent to a JavaPackage object in Java.  Example:
+ * Although there are instances of java.lang.String and there are static methods
+ * of java.lang.String that can be invoked, there's no such thing as a java.lang
+ * object in Java that exists at run time.
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jsj_private.h"        /* LiveConnect internals */
+#include "jsjava.h"
+
+
+JSClass JavaPackage_class;      /* Forward declaration */
+
+/*
+ * The native part of a JavaPackage object.  It gets stored in the object's
+ * private slot.
+ */
+typedef struct {
+    const char * path;          /* e.g. "java/lang" or NULL if top level package */
+    int flags;                  /* e.g. PKG_SYSTEM, PKG_CLASS */
+} JavaPackage_Private;
+
+static JSObject *
+define_JavaPackage(JSContext *cx, JSObject *parent_obj,
+                   const char *obj_name, const char *path, int flags)
+{
+    JSObject *package_obj;
+    JavaPackage_Private *package;
+
+    package_obj = JS_DefineObject(cx, parent_obj, obj_name, &JavaPackage_class, 0,
+                                  JSPROP_PERMANENT | JSPROP_READONLY);
+    if (!package_obj)
+        return NULL;
+    
+    /* Attach private, native data to the JS object */
+    package = (JavaPackage_Private *)JS_malloc(cx, sizeof(JavaPackage_Private));
+    JS_SetPrivate(cx, package_obj, (void *)package);
+    if (path)
+        package->path = JS_strdup(cx, path);
+    else
+        package->path = "";
+
+    package->flags = flags;
+
+    /* Check for OOM */
+    if (!package->path) {
+        JS_DeleteProperty(cx, parent_obj, obj_name);
+        JS_free(cx, package);
+        return NULL;
+    }
+
+    return package_obj;
+}
+
+/* JavaPackage uses standard JS getProperty */
+
+/*
+ * Don't allow user-defined properties to be set on Java package objects, e.g.
+ * it is illegal to write "java.lang.myProperty = 4".  We probably could relax
+ * this restriction, but it's potentially confusing and not clearly useful.
+ */
+static JSBool
+JavaPackage_setProperty(JSContext *cx, JSObject *obj, jsval slot, jsval *vp)
+{
+    JavaPackage_Private *package = JS_GetPrivate(cx, obj);
+    if (!package) {
+        JS_ReportError(cx, "illegal attempt to add property to "
+                           "JavaPackage prototype object");
+        return JS_FALSE;
+    }
+    JS_ReportError(cx, "You may not add properties to a JavaPackage object");
+    return JS_FALSE;
+}
+
+static JSBool quiet_resolve_failure;
+
+/*
+ * Resolve a component name to be either the name of a class or a package.
+ */
+static JSBool
+JavaPackage_resolve(JSContext *cx, JSObject *obj, jsval id)
+{
+    JavaPackage_Private *package;
+    JSBool ok = JS_TRUE;
+    jclass jclazz;
+    char *subPath, *newPath;
+    const char *path;
+    JNIEnv *jEnv;
+
+    package = (JavaPackage_Private *)JS_GetPrivate(cx, obj);
+    if (!package)
+        return JS_TRUE;
+
+    if (!JSVAL_IS_STRING(id))
+        return JS_TRUE;
+    subPath = JS_GetStringBytes(JSVAL_TO_STRING(id));
+
+    /*
+     * There will be an attempt to invoke the toString() method when producing
+     * the string representation of a JavaPackage.  When this occurs, avoid
+     * creating a bogus toString package.  (This means that no one can ever
+     * create a package with the simple name "toString", but we'll live with
+     * that limitation.)
+     */
+    if (!strcmp(subPath, "toString"))
+        return JS_FALSE;
+
+    path = package->path;
+    newPath = PR_smprintf("%s%s%s", path, (path[0] ? "/" : ""), subPath);
+    if (!newPath) {
+        JS_ReportOutOfMemory(cx);
+        return JS_FALSE;
+    }
+
+    jsj_MapJSContextToJSJThread(cx, &jEnv);
+    if (!jEnv)
+        return JS_FALSE;
+
+    /*
+        Unfortunately, Java provides no way to find out whether a particular
+        name is a package or not.  The only way to tell is to try to load the
+        name as a class file and, if that fails, assume it's a package.  This
+        makes things work as expected for the most part, but it has three
+        noticeable problems that keep coming up:
+
+        - You can refer to a package like java.lang.i.buried.paul without
+          generating a complaint.  Of course, you'll never be able to refer to
+          any classes through it.
+
+        - An annoying consequence of the above is that misspelling a class name
+          results in a cryptic error about packages.
+
+        - In a browser context, i.e. where applets are involved, figuring out
+          whether something is a class may require looking for it over the net
+          using the current classloader.  This means that the first time you
+          refer to java.lang.System in a js context, there will be an attempt
+          to search for [[DOCBASE]]/java.class on the server.
+    
+        A solution is to explicitly tell jsjava the names of all the (local)
+        packages on the CLASSPATH.  (Not implemented yet.)
+
+    */
+    jclazz = (*jEnv)->FindClass(jEnv, newPath);
+    if (jclazz) {
+        JSObject *newClass;
+
+        newClass = jsj_define_JavaClass(cx, jEnv, obj, subPath, jclazz);
+        if (!newClass) {
+            ok = JS_FALSE;
+            goto out;
+        }
+    } else {
+
+        /* We assume that any failed attempt to load a class is because it
+           doesn't exist.  If we wanted to do a better job, we would check
+           the exception type and make sure that it's NoClassDefFoundError */
+        (*jEnv)->ExceptionClear(jEnv);
+
+        /* beard: this has to be done here, so built-in classes will be defined. */
+        /* Painful hack for pre_define_java_packages() */
+        if (quiet_resolve_failure) {
+            ok = JS_FALSE;
+            goto out;
+        }
+
+        /*
+         * If there's no class of the given name, then we must be referring to
+         * a package.  However, don't allow bogus sub-packages of pre-defined
+         * system packages to be created.
+         */
+        if (JS_InstanceOf(cx, obj, &JavaPackage_class, NULL)) {
+            JavaPackage_Private *package;
+
+            package = JS_GetPrivate(cx, obj);
+            if (package->flags & PKG_SYSTEM) {
+                char *msg, *cp;
+
+                msg = PR_smprintf("No Java system package with name \"%s\" was identified "
+                                  "and no Java class with that name exists either",
+                                  newPath);
+
+                /* Check for OOM */
+                if (msg) {
+                    /* Convert package of form "java/lang" to "java.lang" */
+                    for (cp = msg; *cp != '\0'; cp++)
+                        if (*cp == '/')
+                            *cp = '.';
+                    JS_ReportError(cx, msg);
+                    free((char*)msg);
+                }
+                               
+                ok = JS_FALSE;
+                goto out;
+            }
+        }
+
+        if (!define_JavaPackage(cx, obj, subPath, newPath, 0)) {
+            ok = JS_FALSE;
+            goto out;
+        }
+        
+#ifdef DEBUG
+        /* printf("JavaPackage \'%s\' created\n", newPath); */
+#endif
+
+    }
+    
+out:
+    free(newPath);
+    return ok;
+}
+
+static JSBool
+JavaPackage_convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
+{
+    JSString *str;
+    char *name, *cp;
+
+    JavaPackage_Private *package = JS_GetPrivate(cx, obj);
+    if (!package) {
+        fprintf(stderr, "JavaPackage_resolve: no private data!\n");
+        return JS_FALSE;
+    }
+
+    switch (type) {
+
+    /* Pretty-printing of JavaPackage */
+    case JSTYPE_VOID:   /* Default value */
+    case JSTYPE_NUMBER:
+    case JSTYPE_STRING:
+        /* Convert '/' to '.' so that it looks like Java language syntax. */
+        if (!package->path)
+            break;
+        name = PR_smprintf("[JavaPackage %s]", package->path);
+        if (!name) {
+            JS_ReportOutOfMemory(cx);
+            return JS_FALSE;
+        }
+        for (cp = name; *cp != '\0'; cp++)
+            if (*cp == '/')
+                *cp = '.';
+        str = JS_NewString(cx, name, strlen(name));
+        if (!str) {
+            free(name);
+            /* It's not necessary to call JS_ReportOutOfMemory(), as
+               JS_NewString() will do so on failure. */
+            return JS_FALSE;
+        }
+
+        *vp = STRING_TO_JSVAL(str);
+        break;
+
+    case JSTYPE_OBJECT:
+        *vp = OBJECT_TO_JSVAL(obj);
+        break;
+
+    default:
+        break;
+    }
+    return JS_TRUE;
+}
+
+/*
+ * Free the private native data associated with the JavaPackage object.
+ */
+static void
+JavaPackage_finalize(JSContext *cx, JSObject *obj)
+{
+    JavaPackage_Private *package = JS_GetPrivate(cx, obj);
+    if (!package)
+        return;
+
+    if (package->path)
+        JS_free(cx, (char *)package->path);
+    JS_free(cx, package);
+}
+
+/*
+ * The definition of the JavaPackage class
+ */
+JSClass JavaPackage_class = {
+    "JavaPackage", JSCLASS_HAS_PRIVATE,
+    JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JavaPackage_setProperty,
+    JS_EnumerateStub, JavaPackage_resolve,
+    JavaPackage_convert, JavaPackage_finalize
+};
+
+JavaPackageDef
+standard_java_packages[] = {
+    {"java",                NULL,   PKG_USER},
+    {"java.applet",         NULL,   PKG_USER},
+    {"java.awt",            NULL,   PKG_USER},
+    {"java.awt.datatransfer",
+                            NULL,   PKG_SYSTEM},
+    {"java.awt.event",      NULL,   PKG_SYSTEM},
+    {"java.awt.image",      NULL,   PKG_SYSTEM},
+    {"java.awt.peer",       NULL,   PKG_SYSTEM},
+    {"java.beans",          NULL,   PKG_USER},
+    {"java.io",             NULL,   PKG_SYSTEM},
+    {"java.lang",           NULL,   PKG_USER},
+    {"java.lang.reflect",   NULL,   PKG_SYSTEM},
+    {"java.math",           NULL,   PKG_SYSTEM},
+    {"java.net",            NULL,   PKG_USER},
+    {"java.rmi",            NULL,   PKG_USER},
+    {"java.rmi.dgc",        NULL,   PKG_USER},
+    {"java.rmi.user",       NULL,   PKG_USER},
+    {"java.rmi.registry",   NULL,   PKG_USER},
+    {"java.rmi.server",     NULL,   PKG_USER},
+    {"java.security",       NULL,   PKG_USER},
+    {"java.security.acl",   NULL,   PKG_SYSTEM},
+    {"java.security.interfaces",
+                            NULL,   PKG_SYSTEM},
+    {"java.sql",            NULL,   PKG_USER},
+    {"java.text",           NULL,   PKG_USER},
+    {"java.text.resources", NULL,   PKG_SYSTEM},
+    {"java.util",           NULL,   PKG_USER},
+    {"java.util.zip",       NULL,   PKG_SYSTEM},
+
+    {"netscape",            NULL,   PKG_USER},
+    {"netscape.applet",     NULL,   PKG_SYSTEM},
+    {"netscape.application",NULL,   PKG_SYSTEM},
+    {"netscape.debug",      NULL,   PKG_SYSTEM},
+    {"netscape.javascript", NULL,   PKG_SYSTEM},
+    {"netscape.ldap",       NULL,   PKG_SYSTEM},
+    {"netscape.misc",       NULL,   PKG_SYSTEM},
+    {"netscape.net",        NULL,   PKG_SYSTEM},
+    {"netscape.plugin",     NULL,   PKG_SYSTEM},
+    {"netscape.util",       NULL,   PKG_SYSTEM},
+    {"netscape.secfile",    NULL,   PKG_SYSTEM},
+    {"netscape.security",   NULL,   PKG_SYSTEM},
+    {"netscape.WAI",        NULL,   PKG_SYSTEM},
+
+    {"sun",                 NULL,   PKG_USER},
+    {"Packages",            "",     PKG_USER},
+
+    {NULL,                  NULL,   0}
+};
+
+/*
+ * Pre-define a hierarchy of JavaPackage objects.
+ * Pre-defining a Java package at initialization time is not necessary, but
+ * it will make package lookup faster and, more importantly, will avoid
+ * unnecessary network accesses if classes are being loaded over the network.
+ */
+static JSBool
+pre_define_java_packages(JSContext *cx, JSObject *global_obj,
+                         JavaPackageDef *predefined_packages)
+{
+    JSBool package_exists;
+    JSObject *parent_obj;
+    JavaPackageDef *package_def;
+    char *simple_name, *cp, *package_name, *path;
+    int flags;
+
+    if (!predefined_packages)
+        return JS_TRUE;
+
+    /* Iterate over all pre-defined Java packages */
+    for (package_def = predefined_packages; package_def->name; package_def++) {
+        package_name = path = NULL;
+
+        parent_obj = global_obj;
+        package_name = strdup(package_def->name);
+        if (!package_name)
+            goto out_of_memory;
+
+        /* Walk the chain of JavaPackage objects to get to the parent of the
+           rightmost sub-package in the fully-qualified package name. */
+        for (simple_name = strtok(package_name, "."); 1; simple_name = strtok(NULL, ".")) {
+            jsval v;
+
+            if (!simple_name) {
+                JS_ReportError(cx, "Package %s defined twice ?", package_name);
+                goto error;
+            }
+
+            /* Check to see if the sub-package already exists */
+            quiet_resolve_failure = JS_TRUE;
+            package_exists = JS_LookupProperty(cx, parent_obj, simple_name, &v) && JSVAL_IS_OBJECT(v);
+            quiet_resolve_failure = JS_FALSE;
+
+            if (package_exists) {
+                    parent_obj = JSVAL_TO_OBJECT(v);
+                    continue;
+            } else {
+                /* New package objects should only be created at the terminal
+                   sub-package in a fully-qualified package-name */
+                if (strtok(NULL, ".")) {
+                    JS_ReportError(cx, "Illegal predefined package definition for %s",
+                                   package_def->name);
+                    goto error;
+                }
+                
+                if (package_def->path) {
+                    path = strdup(package_def->path);
+                    if (!path)
+                        goto out_of_memory;
+                } else {
+
+                    /*
+                     * The default path is specified, so create it from the
+                     * fully-qualified package name.
+                     */
+                    path = strdup(package_def->name);
+                    if (!path)
+                        goto out_of_memory;
+                    /* Transform package name, e.g. "java.lang" ==> "java/lang" */
+                    for (cp = path; *cp != '\0'; cp++) {
+                        if (*cp == '.')
+                             *cp = '/';
+                    }
+                }
+                flags = package_def->flags;
+                parent_obj = define_JavaPackage(cx, parent_obj, simple_name, path, flags);
+                if (!parent_obj)
+                    goto error;
+     
+                free(path);
+                break;
+            }
+        }
+        free(package_name);
+    }
+    return JS_TRUE;
+
+out_of_memory:
+    JS_ReportOutOfMemory(cx);
+
+error:
+    JS_FREE_IF(cx, package_name);
+    JS_FREE_IF(cx, path);
+    return JS_FALSE;
+}
+
+static JSBool
+JavaPackage_toString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
+                 jsval *rval)
+{
+    if (!JS_InstanceOf(cx, obj, &JavaPackage_class, argv))
+        return JS_FALSE;
+    return JavaPackage_convert(cx, obj, JSTYPE_STRING, rval);
+}
+
+static JSFunctionSpec JavaPackage_methods[] = {
+    {"toString",   JavaPackage_toString,        0},
+    {0}
+};
+
+/*
+ * One-time initialization for the JavaPackage class.  (This is not
+ * run once per thread, rather it's run once for a given JSContext.)
+ */
+JSBool
+jsj_init_JavaPackage(JSContext *cx, JSObject *global_obj,
+                     JavaPackageDef *additional_predefined_packages) {
+
+    /* Define JavaPackage class */
+    if (!JS_InitClass(cx, global_obj, 0, &JavaPackage_class,
+                      0, 0, 0, JavaPackage_methods, 0, 0))
+        return JS_FALSE;
+
+    /* Add top-level packages, e.g. : java, netscape, sun */
+    if (!pre_define_java_packages(cx, global_obj, standard_java_packages))
+        return JS_FALSE;
+    if (!pre_define_java_packages(cx, global_obj, additional_predefined_packages))
+        return JS_FALSE;
+    
+    return JS_TRUE;
+}

mozilla/js/src/liveconnect/jsj_array.c

@@ -0,0 +1,180 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+ 
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the code for reading and writing elements of a Java array.
+ */
+
+#include "jsj_private.h"      /* LiveConnect internals */
+
+/*
+ * Read the Java value at a given index into a Java array and convert it
+ * to a JS value.  The array_component_signature describes the type of
+ * the resulting Java value, which can be a primitive type or an object type.
+ * More specifically it can be an array type in the case of multidimensional
+ * arrays.
+ */
+JSBool
+jsj_GetJavaArrayElement(JSContext *cx, JNIEnv *jEnv, jarray java_array, jsize index,
+                        JavaSignature *array_component_signature,
+                        jsval *vp)
+{
+    jvalue java_value;
+    JavaSignatureChar component_type;
+
+#define GET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Type,member)                   \
+    (*jEnv)->Get##Type##ArrayRegion(jEnv, java_array, index, 1,              \
+                                    &java_value.member);                     \
+    if ((*jEnv)->ExceptionOccurred(jEnv)) {                                  \
+        jsj_ReportJavaError(cx, jEnv, "Error reading element of "            \
+                                      "Java primitive array");               \
+        return JS_FALSE;                                                     \
+    }
+
+    component_type = array_component_signature->type;
+    switch(component_type) {
+    case JAVA_SIGNATURE_BYTE:
+        GET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Byte,b);
+        break;
+
+    case JAVA_SIGNATURE_CHAR:
+        GET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Char,c);
+        break;
+
+    case JAVA_SIGNATURE_SHORT:
+        GET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Short,s);
+        break;
+
+    case JAVA_SIGNATURE_INT:
+        GET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Int,i);
+        break;
+
+    case JAVA_SIGNATURE_BOOLEAN:
+        GET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Boolean,z);
+        break;
+
+    case JAVA_SIGNATURE_LONG:
+        GET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Long,j);
+        break;
+  
+    case JAVA_SIGNATURE_FLOAT:
+        GET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Float,f);
+        break;
+
+    case JAVA_SIGNATURE_DOUBLE:
+        GET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Double,d);
+        break;
+
+    case JAVA_SIGNATURE_CLASS:
+    case JAVA_SIGNATURE_ARRAY:
+        java_value.l = (*jEnv)->GetObjectArrayElement(jEnv, java_array, index);
+        if ((*jEnv)->ExceptionOccurred(jEnv)) {
+            jsj_ReportJavaError(cx, jEnv, "Error reading Java object array");
+            return JS_FALSE;
+        }
+        break;
+
+#undef GET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY
+    default:
+        PR_ASSERT(0);        /* Unknown java type signature */
+        return JS_FALSE;
+    }
+
+    return jsj_ConvertJavaValueToJSValue(cx, jEnv, array_component_signature, &java_value, vp);
+}
+
+JSBool
+jsj_SetJavaArrayElement(JSContext *cx, JNIEnv *jEnv, jarray java_array, jsize index,
+                        JavaSignature *array_component_signature,
+                        jsval js_val)
+{
+    int dummy_cost;
+    jvalue java_value;
+    JavaSignatureChar component_type;
+    JSBool is_local_ref;
+
+    if (!jsj_ConvertJSValueToJavaValue(cx, jEnv, js_val, array_component_signature,
+                                       &dummy_cost, &java_value, &is_local_ref))
+        return JS_FALSE;
+
+#define SET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Type,member)                   \
+    (*jEnv)->Set##Type##ArrayRegion(jEnv, java_array, index, 1,              \
+                                    &java_value.member);                     \
+    if ((*jEnv)->ExceptionOccurred(jEnv)) {                                  \
+        jsj_ReportJavaError(cx, jEnv, "Error assigning to element of "       \
+                                      "Java primitive array");               \
+        return JS_FALSE;                                                     \
+    }
+
+    component_type = array_component_signature->type;
+    switch(component_type) {
+    case JAVA_SIGNATURE_BYTE:
+        SET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Byte,b);
+        break;
+
+    case JAVA_SIGNATURE_CHAR:
+        SET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Char,c);
+        break;
+
+    case JAVA_SIGNATURE_SHORT:
+        SET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Short,s);
+        break;
+
+    case JAVA_SIGNATURE_INT:
+        SET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Int,i);
+        break;
+
+    case JAVA_SIGNATURE_BOOLEAN:
+        SET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Boolean,z);
+        break;
+
+    case JAVA_SIGNATURE_LONG:
+        SET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Long,j);
+        break;
+  
+    case JAVA_SIGNATURE_FLOAT:
+        SET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Float,f);
+        break;
+
+    case JAVA_SIGNATURE_DOUBLE:
+        SET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY(Double,d);
+        break;
+
+    case JAVA_SIGNATURE_CLASS:
+    case JAVA_SIGNATURE_ARRAY:
+        (*jEnv)->SetObjectArrayElement(jEnv, java_array, index, java_value.l);
+        if (is_local_ref)                                                           \
+            (*jEnv)->DeleteLocalRef(jEnv, java_value.l);
+        if ((*jEnv)->ExceptionOccurred(jEnv)) {
+            jsj_ReportJavaError(cx, jEnv, "Error assigning to Java object array");
+            return JS_FALSE;
+        }
+        break;
+
+#undef SET_ELEMENT_FROM_PRIMITIVE_JAVA_ARRAY
+    default:
+        PR_ASSERT(0);        /* Unknown java type signature */
+        return JS_FALSE;
+    }
+
+    return JS_TRUE;
+}
+

mozilla/js/src/liveconnect/jsj_class.c

@@ -0,0 +1,605 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the code that constructs and manipulates JavaClassDescriptor
+ * structs, which are the native wrappers for Java classes.
+ * JavaClassDescriptors are used to describe the signatures of methods and
+ * fields.  There is a JavaClassDescriptor associated with the reflection of
+ * each Java Object.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jsj_private.h"        /* LiveConnect internals */
+#include "jsj_hash.h"           /* Hash tables */
+
+/* A one-to-one mapping between all referenced java.lang.Class objects and
+   their corresponding JavaClassDescriptor objects */
+static JSJHashTable *java_class_reflections;
+
+/*
+ * Given a JVM handle to a java.lang.Class object, malloc a C-string
+ * containing the UTF8 encoding of the fully qualified name of the class.
+ * It's the caller's responsibility to free the returned string.
+ *
+ * If an error occurs, NULL is returned and the error reporter called.
+ */
+const char *
+jsj_GetJavaClassName(JSContext *cx, JNIEnv *jEnv, jclass java_class)
+{
+    jstring java_class_name_jstr;
+    const char *java_class_name;
+
+    /* Get java.lang.String object containing class name */
+    java_class_name_jstr =
+        (*jEnv)->CallObjectMethod(jEnv, java_class, jlClass_getName);
+
+
+    if (!java_class_name_jstr)
+        goto error;
+
+    /* Convert to UTF8 encoding and copy */
+    java_class_name = jsj_DupJavaStringUTF(cx, jEnv, java_class_name_jstr);
+    if (!java_class_name)
+        return NULL;
+
+    return java_class_name;
+
+error:
+    jsj_UnexpectedJavaError(cx, jEnv, "Can't get Java class name using"
+                                      "java.lang.Class.getName()");
+    return NULL;
+}
+
+/*
+ * Convert in-place a string of the form "java.lang.String" into "java/lang/String".
+ * Though the former style is conventionally used by Java programmers, the latter is
+ * what the JNI functions require.
+ */
+void
+jsj_MakeJNIClassname(char * class_name)
+{
+    char * c;
+    for (c = class_name; *c; c++)
+        if (*c == '.')
+            *c = '/';
+}
+
+/*
+ * Classify an instance of java.lang.Class as either one of the primitive
+ * types, e.g. int, char, etc., as an array type or as a non-array object type
+ * (subclass of java.lang.Object) by returning the appropriate enum member.
+ *
+ */
+static JavaSignatureChar
+get_signature_type(JSContext *cx, JavaClassDescriptor *class_descriptor)
+{
+    JavaSignatureChar type;
+    const char *java_class_name;
+
+    /* Get UTF8 encoding of class name */
+    java_class_name = class_descriptor->name;
+    PR_ASSERT(java_class_name);
+    if (!java_class_name)
+        return JAVA_SIGNATURE_UNKNOWN;
+
+    if (!strcmp(java_class_name, "byte"))
+        type = JAVA_SIGNATURE_BYTE;
+    else if (!strcmp(java_class_name, "char"))
+        type = JAVA_SIGNATURE_CHAR;
+    else if (!strcmp(java_class_name, "float"))
+        type = JAVA_SIGNATURE_FLOAT;
+    else if (!strcmp(java_class_name, "double"))
+        type = JAVA_SIGNATURE_DOUBLE;
+    else if (!strcmp(java_class_name, "int"))
+        type = JAVA_SIGNATURE_INT;
+    else if (!strcmp(java_class_name, "long"))
+        type = JAVA_SIGNATURE_LONG;
+    else if (!strcmp(java_class_name, "short"))
+        type = JAVA_SIGNATURE_SHORT;
+    else if (!strcmp(java_class_name, "boolean"))
+        type = JAVA_SIGNATURE_BOOLEAN;
+    else if (!strcmp(java_class_name, "void"))
+        type = JAVA_SIGNATURE_VOID;
+    else
+        /* Well, I guess it's a Java class, then. */
+        type = JAVA_SIGNATURE_CLASS;
+    
+    return type;
+}
+
+static JSBool
+is_java_array_class(JNIEnv *jEnv, jclass java_class)
+{
+    return (*jEnv)->CallBooleanMethod(jEnv, java_class, jlClass_isArray);
+}
+
+/*
+ * Return the class of a Java array's component type.  This is not the same
+ * as the array's element type.  For example, the component type of an array
+ * of type SomeType[][][] is SomeType[][], but its element type is SomeType.
+ *
+ * If an error occurs, NULL is returned and an error reported.
+ */
+static jclass
+get_java_array_component_class(JSContext *cx, JNIEnv *jEnv, jclass java_class)
+{
+    jclass result;
+    result = (*jEnv)->CallObjectMethod(jEnv, java_class, jlClass_getComponentType);
+    if (!result) {
+        jsj_UnexpectedJavaError(cx, jEnv,
+                                "Can't get Java array component class using "
+                                "java.lang.Class.getComponentType()");
+        return NULL;
+    }
+    return result;
+}
+
+/*
+ * Given a Java class, fill in the signature structure that describes the class.
+ * If an error occurs, JS_FALSE is returned and the error reporter called.
+ */
+static JSBool
+compute_java_class_signature(JSContext *cx, JNIEnv *jEnv, JavaSignature *signature)
+{
+    jclass java_class = signature->java_class;
+
+    if (is_java_array_class(jEnv, java_class)) {
+        jclass component_class;
+        
+        signature->type = JAVA_SIGNATURE_ARRAY;
+
+        component_class = get_java_array_component_class(cx, jEnv, java_class);
+        if (!component_class)
+            return JS_FALSE;
+
+        signature->array_component_signature =
+            jsj_GetJavaClassDescriptor(cx, jEnv, component_class);
+        if (!signature->array_component_signature)
+            return JS_FALSE;
+    } else {
+        signature->type = get_signature_type(cx, signature);
+    }
+    return JS_TRUE;
+}
+
+/*
+ * Convert a JavaSignature object into a string format as used by
+ * the JNI functions, e.g. java.lang.Object ==> "Ljava/lang/Object;"
+ * The caller is responsible for freeing the resulting string.
+ *
+ * If an error is encountered, NULL is returned and an error reported.
+ */
+const char *
+jsj_ConvertJavaSignatureToString(JSContext *cx, JavaSignature *signature)
+{
+    char *sig;
+
+    if (signature->type == JAVA_SIGNATURE_CLASS) {
+        /* A non-array object class */
+        sig = PR_smprintf("L%s;", signature->name);
+        if (sig)
+            jsj_MakeJNIClassname(sig);
+
+    } else if (signature->type == JAVA_SIGNATURE_ARRAY) {
+        /* An array class */
+        const char *component_signature_string;
+
+        component_signature_string =
+            jsj_ConvertJavaSignatureToString(cx, signature->array_component_signature);
+        if (!component_signature_string)
+            return NULL;
+        sig = PR_smprintf("[%s", component_signature_string);
+        JS_free(cx, (char*)component_signature_string);
+
+    } else {
+        /* A primitive class */
+        sig = PR_smprintf("%c", (char)signature->type);
+    }
+
+    if (!sig) {
+        JS_ReportOutOfMemory(cx);
+        return NULL;
+    }
+    return sig;
+}
+
+/*
+ * Convert a JavaSignature object into a human-readable string format as seen
+ * in Java source files, e.g. "byte", or "int[][]" or "java.lang.String".
+ * The caller is responsible for freeing the resulting string.
+ *
+ * If an error is encountered, NULL is returned and an error reported.
+ */
+const char *
+jsj_ConvertJavaSignatureToHRString(JSContext *cx,
+                                   JavaSignature *signature)
+{
+    char *sig;
+    JavaSignature *acs;
+
+    if (signature->type == JAVA_SIGNATURE_ARRAY) {
+        /* An array class */
+        const char *component_signature_string;
+        acs = signature->array_component_signature;
+        component_signature_string =
+            jsj_ConvertJavaSignatureToHRString(cx, acs);
+        if (!component_signature_string)
+            return NULL;
+        sig = PR_smprintf("%s[]", component_signature_string);
+        JS_free(cx, (char*)component_signature_string);
+
+    } else {
+        /* A primitive class or a non-array object class */
+        sig = JS_strdup(cx, signature->name);
+    }
+
+    if (!sig) {
+        JS_ReportOutOfMemory(cx);
+        return NULL;
+    }
+    return sig;
+}
+
+static void
+destroy_java_member_descriptor(JSContext *cx, JNIEnv *jEnv, JavaMemberDescriptor *member_descriptor)
+{
+    JavaMethodSpec *method, *next_method;
+    if (member_descriptor->field)
+        jsj_DestroyFieldSpec(cx, jEnv, member_descriptor->field);
+
+    method = member_descriptor->methods;
+    while (method) {
+        next_method = method->next;
+        jsj_DestroyMethodSpec(cx, jEnv, method);
+        method = next_method;
+    }
+
+    if (member_descriptor->invoke_func_obj)
+        JS_RemoveRoot(cx, &member_descriptor->invoke_func_obj);
+}
+
+static void
+destroy_class_member_descriptors(JSContext *cx, JNIEnv *jEnv, JavaMemberDescriptor *member_descriptor)
+{
+    JavaMemberDescriptor *next_member;
+    
+    while (member_descriptor) {
+        next_member = member_descriptor->next;
+        destroy_java_member_descriptor(cx, jEnv, member_descriptor);
+        member_descriptor = next_member;
+    }
+}
+
+static void
+destroy_class_descriptor(JSContext *cx, JNIEnv *jEnv, JavaClassDescriptor *class_descriptor)
+{
+    JS_FREE_IF(cx, (char *)class_descriptor->name);
+    if (class_descriptor->java_class) {
+        JSJ_HashTableRemove(java_class_reflections,
+                            class_descriptor->java_class, (void*)jEnv);
+        (*jEnv)->DeleteGlobalRef(jEnv, class_descriptor->java_class);
+    }
+
+    if (class_descriptor->array_component_signature)
+        jsj_ReleaseJavaClassDescriptor(cx, jEnv, class_descriptor->array_component_signature);
+
+    destroy_class_member_descriptors(cx, jEnv, class_descriptor->instance_members);
+    destroy_class_member_descriptors(cx, jEnv, class_descriptor->static_members);
+    destroy_class_member_descriptors(cx, jEnv, class_descriptor->constructors);
+    JS_free(cx, class_descriptor);
+}
+
+static JavaClassDescriptor *
+new_class_descriptor(JSContext *cx, JNIEnv *jEnv, jclass java_class)
+{
+    JavaClassDescriptor *class_descriptor;
+
+    class_descriptor = (JavaClassDescriptor *)JS_malloc(cx, sizeof(JavaClassDescriptor));
+    if (!class_descriptor)
+        return NULL;
+    memset(class_descriptor, 0, sizeof(JavaClassDescriptor));
+
+    class_descriptor->name = jsj_GetJavaClassName(cx, jEnv, java_class);
+    if (!class_descriptor->name)
+        goto error;
+
+    java_class = (*jEnv)->NewGlobalRef(jEnv, java_class);
+    if (!java_class) {
+        jsj_UnexpectedJavaError(cx, jEnv, "Unable to reference Java class");
+        goto error;
+    }
+    class_descriptor->java_class = java_class;
+
+    if (!compute_java_class_signature(cx, jEnv, class_descriptor))
+        goto error;
+
+    class_descriptor->modifiers =
+        (*jEnv)->CallIntMethod(jEnv, java_class, jlClass_getModifiers);
+    class_descriptor->ref_count = 1;
+
+    if (!JSJ_HashTableAdd(java_class_reflections, java_class, class_descriptor,
+                          (void*)jEnv))
+        goto error;
+
+    return class_descriptor;
+
+error:
+    destroy_class_descriptor(cx, jEnv, class_descriptor);
+    return NULL;
+}
+
+/* Trivial helper for jsj_DiscardJavaClassReflections(), below */
+static PRIntn
+enumerate_remove_java_class(JSJHashEntry *he, PRIntn i, void *arg)
+{
+    JNIEnv *jEnv = (JNIEnv*)arg;
+    jclass java_class;
+    JavaClassDescriptor *class_descriptor;
+
+    class_descriptor = (JavaClassDescriptor*)he->value;
+
+    java_class = class_descriptor->java_class;
+    (*jEnv)->DeleteGlobalRef(jEnv, java_class);
+    class_descriptor->java_class = NULL;
+
+    return HT_ENUMERATE_REMOVE;
+}
+
+/* This shutdown routine discards all JNI references to Java objects
+   that have been reflected into JS, even if there are still references
+   to them from JS. */
+void
+jsj_DiscardJavaClassReflections(JNIEnv *jEnv)
+{
+    if (java_class_reflections) {
+        JSJ_HashTableEnumerateEntries(java_class_reflections,
+                                      enumerate_remove_java_class,
+                                      (void*)jEnv);
+        JSJ_HashTableDestroy(java_class_reflections);
+        java_class_reflections = NULL;
+    }
+}
+
+extern JavaClassDescriptor *
+jsj_GetJavaClassDescriptor(JSContext *cx, JNIEnv *jEnv, jclass java_class)
+{
+    JavaClassDescriptor *class_descriptor;
+    class_descriptor = JSJ_HashTableLookup(java_class_reflections,
+                                           (const void *)java_class,
+                                           (void*)jEnv);
+    if (!class_descriptor)
+        return new_class_descriptor(cx, jEnv, java_class);
+
+    PR_ASSERT(class_descriptor->ref_count > 0);
+    class_descriptor->ref_count++;
+    return class_descriptor;
+}
+
+void
+jsj_ReleaseJavaClassDescriptor(JSContext *cx, JNIEnv *jEnv, JavaClassDescriptor *class_descriptor)
+{
+    if (!--class_descriptor->ref_count)
+        destroy_class_descriptor(cx, jEnv, class_descriptor);
+}
+
+static JSBool
+reflect_java_methods_and_fields(JSContext *cx,
+                                JNIEnv *jEnv,
+                                JavaClassDescriptor *class_descriptor,
+                                JSBool reflect_statics_only)
+{
+    JavaMemberDescriptor *member_descriptor;
+
+    if (reflect_statics_only)
+        class_descriptor->static_members_reflected = JS_TRUE;
+    else
+        class_descriptor->instance_members_reflected = JS_TRUE;
+    
+    if (!jsj_ReflectJavaMethods(cx, jEnv, class_descriptor, reflect_statics_only))
+        return JS_FALSE;
+    if (!jsj_ReflectJavaFields(cx, jEnv, class_descriptor, reflect_statics_only))
+        return JS_FALSE;
+
+    if (reflect_statics_only) {
+        member_descriptor = class_descriptor->static_members;
+        while (member_descriptor) {
+            class_descriptor->num_static_members++;
+            member_descriptor = member_descriptor->next;
+        }
+    } else {
+        member_descriptor = class_descriptor->instance_members;
+        while (member_descriptor) {
+            class_descriptor->num_instance_members++;
+            member_descriptor = member_descriptor->next;
+        }
+    }
+    return JS_TRUE;
+}
+
+JavaMemberDescriptor *
+jsj_GetClassStaticMembers(JSContext *cx,
+                          JNIEnv *jEnv,
+                          JavaClassDescriptor *class_descriptor)
+{
+    if (!class_descriptor->static_members_reflected)
+        reflect_java_methods_and_fields(cx, jEnv, class_descriptor, JS_TRUE);
+    return class_descriptor->static_members;
+}
+
+JavaMemberDescriptor *
+jsj_GetClassInstanceMembers(JSContext *cx,
+                            JNIEnv *jEnv,
+                            JavaClassDescriptor *class_descriptor)
+{
+    if (!class_descriptor->instance_members_reflected)
+        reflect_java_methods_and_fields(cx, jEnv, class_descriptor, JS_FALSE);
+    return class_descriptor->instance_members;
+}
+
+JavaMemberDescriptor *
+jsj_LookupJavaStaticMemberDescriptorById(JSContext *cx,
+                                         JNIEnv *jEnv,
+                                         JavaClassDescriptor *class_descriptor,
+                                         jsid id)
+{
+    JavaMemberDescriptor *member_descriptor;
+
+    member_descriptor = jsj_GetClassStaticMembers(cx, jEnv, class_descriptor);
+    while (member_descriptor) {
+        if (id == member_descriptor->id)
+            return member_descriptor;
+        member_descriptor = member_descriptor->next;
+    }
+    return NULL;
+}
+
+JavaMemberDescriptor *
+jsj_GetJavaStaticMemberDescriptor(JSContext *cx,
+                                  JNIEnv *jEnv, 
+                                  JavaClassDescriptor *class_descriptor,
+                                  jstring member_name_jstr)
+{
+    JavaMemberDescriptor *member_descriptor;
+    jsid id;
+
+    if (!JavaStringToId(cx, jEnv, member_name_jstr, &id))
+        return NULL;
+
+    member_descriptor = jsj_LookupJavaStaticMemberDescriptorById(cx, jEnv, class_descriptor, id);
+    if (member_descriptor)
+        return member_descriptor;
+
+    member_descriptor = JS_malloc(cx, sizeof(JavaMemberDescriptor));
+    if (!member_descriptor)
+        return NULL;
+    memset(member_descriptor, 0, sizeof(JavaMemberDescriptor));
+
+    member_descriptor->name = jsj_DupJavaStringUTF(cx, jEnv, member_name_jstr);
+    if (!member_descriptor->name) {
+        JS_free(cx, member_descriptor);
+        return NULL;
+    }
+    member_descriptor->id = id;
+
+    member_descriptor->next = class_descriptor->static_members;
+    class_descriptor->static_members = member_descriptor;
+
+    return member_descriptor;
+}
+
+JavaMemberDescriptor *
+jsj_GetJavaClassConstructors(JSContext *cx,
+                             JavaClassDescriptor *class_descriptor)
+{
+    JavaMemberDescriptor *member_descriptor;
+
+    if (class_descriptor->constructors)
+        return class_descriptor->constructors;
+
+    member_descriptor = JS_malloc(cx, sizeof(JavaMemberDescriptor));
+    if (!member_descriptor)
+        return NULL;
+    memset(member_descriptor, 0, sizeof(JavaMemberDescriptor));
+
+    member_descriptor->name = JS_strdup(cx, "<init>");
+    if (!member_descriptor->name) {
+        JS_free(cx, member_descriptor);
+        return NULL;
+    }
+
+    class_descriptor->constructors = member_descriptor;
+
+    return member_descriptor;
+}
+
+JavaMemberDescriptor *
+jsj_LookupJavaClassConstructors(JSContext *cx, JNIEnv *jEnv,
+                                JavaClassDescriptor *class_descriptor)
+{
+    if (!class_descriptor->static_members_reflected)
+        reflect_java_methods_and_fields(cx, jEnv, class_descriptor, JS_TRUE);
+    return class_descriptor->constructors;
+}
+
+JavaMemberDescriptor *
+jsj_LookupJavaMemberDescriptorById(JSContext *cx, JNIEnv *jEnv,
+                                   JavaClassDescriptor *class_descriptor,
+                                   jsid id)
+{
+    JavaMemberDescriptor *member_descriptor;
+
+    member_descriptor = jsj_GetClassInstanceMembers(cx, jEnv, class_descriptor);
+    while (member_descriptor) {
+        if (id == member_descriptor->id)
+            return member_descriptor;
+        member_descriptor = member_descriptor->next;
+    }
+    return NULL;
+}
+
+JavaMemberDescriptor *
+jsj_GetJavaMemberDescriptor(JSContext *cx,
+                            JNIEnv *jEnv, 
+                            JavaClassDescriptor *class_descriptor,
+                            jstring member_name_jstr)
+{
+    JavaMemberDescriptor *member_descriptor;
+    jsid id;
+
+    if (!JavaStringToId(cx, jEnv, member_name_jstr, &id))
+        return NULL;
+
+    member_descriptor = jsj_LookupJavaMemberDescriptorById(cx, jEnv, class_descriptor, id);
+    if (member_descriptor)
+        return member_descriptor;
+
+    member_descriptor = JS_malloc(cx, sizeof(JavaMemberDescriptor));
+    if (!member_descriptor)
+        return NULL;
+    memset(member_descriptor, 0, sizeof(JavaMemberDescriptor));
+
+    member_descriptor->name = jsj_DupJavaStringUTF(cx, jEnv, member_name_jstr);
+    if (!member_descriptor->name) {
+        JS_free(cx, member_descriptor);
+        return NULL;
+    }
+    member_descriptor->id = id;
+
+    member_descriptor->next = class_descriptor->instance_members;
+    class_descriptor->instance_members = member_descriptor;
+
+    return member_descriptor;
+}
+
+JSBool
+jsj_InitJavaClassReflectionsTable()
+{
+    java_class_reflections =
+        JSJ_NewHashTable(64, jsj_HashJavaObject, jsj_JavaObjectComparator,
+                         NULL, NULL, NULL);
+
+    if (!java_class_reflections)
+        return JS_FALSE;
+    return JS_TRUE;
+}

mozilla/js/src/liveconnect/jsj_convert.c

@@ -0,0 +1,806 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+
+/* This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * Below is the code that converts between Java and JavaScript values of all
+ * types.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jsj_private.h"      /* LiveConnect internals */
+
+/* Floating-point double utilities, stolen from jsnum.h */
+#ifdef IS_LITTLE_ENDIAN
+#define JSDOUBLE_HI32(x)        (((uint32 *)&(x))[1])
+#define JSDOUBLE_LO32(x)        (((uint32 *)&(x))[0])
+#else
+#define JSDOUBLE_HI32(x)        (((uint32 *)&(x))[0])
+#define JSDOUBLE_LO32(x)        (((uint32 *)&(x))[1])
+#endif
+#define JSDOUBLE_HI32_SIGNBIT   0x80000000
+#define JSDOUBLE_HI32_EXPMASK   0x7ff00000
+#define JSDOUBLE_HI32_MANTMASK  0x000fffff
+
+#define JSDOUBLE_IS_NaN(x)                                                    \
+    ((JSDOUBLE_HI32(x) & JSDOUBLE_HI32_EXPMASK) == JSDOUBLE_HI32_EXPMASK &&   \
+     (JSDOUBLE_LO32(x) || (JSDOUBLE_HI32(x) & JSDOUBLE_HI32_MANTMASK)))
+
+#define JSDOUBLE_IS_INFINITE(x)                                               \
+    ((JSDOUBLE_HI32(x) & ~JSDOUBLE_HI32_SIGNBIT) == JSDOUBLE_HI32_EXPMASK &&  \
+     !JSDOUBLE_LO32(x))
+
+static JSBool
+convert_js_obj_to_JSObject_wrapper(JSContext *cx, JNIEnv *jEnv, JSObject *js_obj,
+                                   JavaSignature *signature,
+                                   int *cost, jobject *java_value)
+{
+    if (!njJSObject) {
+        if (java_value)
+            JS_ReportError(cx, "Couldn't convert JavaScript object to an "
+                               "instance of netscape.javascript.JSObject "
+                               "because that class could not be loaded.");
+        return JS_FALSE;
+    }
+
+    if (!(*jEnv)->IsAssignableFrom(jEnv, njJSObject, signature->java_class))
+        return JS_FALSE;
+
+    if (!java_value)
+        return JS_TRUE;
+
+    *java_value = jsj_WrapJSObject(cx, jEnv, js_obj);
+
+    return (*java_value != NULL);   
+}
+
+jstring
+jsj_ConvertJSStringToJavaString(JSContext *cx, JNIEnv *jEnv, JSString *js_str)
+{
+    jstring result;
+    result = (*jEnv)->NewString(jEnv, JS_GetStringChars(js_str),
+                                JS_GetStringLength(js_str));
+    if (!result) {
+        jsj_UnexpectedJavaError(cx, jEnv, "Couldn't construct instance "
+                                          "of java.lang.String");
+    }
+    return result;
+}
+
+/*
+ * Convert a JS value to an instance of java.lang.Object or one of its subclasses, 
+ * performing any necessary type coercion.  If non-trivial coercion is required,
+ * the cost value is incremented.  If the java_value pass-by-reference argument
+ * is non-NULL, the resulting Java value is stored there.
+ *
+ * Returns JS_TRUE if the conversion is possible, JS_FALSE otherwise
+ */
+JSBool
+jsj_ConvertJSValueToJavaObject(JSContext *cx, JNIEnv *jEnv, jsval v, JavaSignature *signature,
+                               int *cost, jobject *java_value, JSBool *is_local_refp)
+{
+    JSString *jsstr;
+    jclass target_java_class;
+    
+    PR_ASSERT(signature->type == JAVA_SIGNATURE_CLASS ||
+        signature->type == JAVA_SIGNATURE_ARRAY);
+
+    /* Initialize to default case, in which no new Java object is
+       synthesized to perform the conversion and, therefore, no JNI local
+       references are being held. */
+    *is_local_refp = JS_FALSE;
+
+    /* Get the Java type of the target value */
+    target_java_class = signature->java_class;
+    
+    if (JSVAL_IS_OBJECT(v)) {
+        JSObject *js_obj = JSVAL_TO_OBJECT(v);
+        
+        /* JS null is always assignable to a Java object */
+        if (!js_obj) {
+            if (java_value)
+                *java_value = NULL;
+            return JS_TRUE;
+        }
+        
+        if (JS_InstanceOf(cx, js_obj, &JavaObject_class, 0) ||
+            JS_InstanceOf(cx, js_obj, &JavaArray_class, 0)) {
+            
+            /* The source value is a Java object wrapped inside a JavaScript
+               object.  Unwrap the JS object and return the original Java
+               object if it's class makes it assignment-compatible with the
+               target class using Java's assignability rules. */
+            JavaObjectWrapper *java_wrapper = JS_GetPrivate(cx, js_obj);
+            jobject java_obj = java_wrapper->java_obj;
+            
+            if ((*jEnv)->IsInstanceOf(jEnv, java_obj, target_java_class)) {
+                if (java_value)
+                    *java_value = java_obj;
+                return JS_TRUE;
+            }
+            
+#ifdef LIVECONNECT_IMPROVEMENTS
+            /* Don't allow wrapped Java objects to be converted to strings */
+            goto conversion_error;
+#else
+            /* Fall through, to attempt conversion to a Java string */
+#endif
+            
+        } else if (JS_InstanceOf(cx, js_obj, &JavaClass_class, 0)) {
+            /* We're dealing with the reflection of a Java class */
+            JavaClassDescriptor *java_class_descriptor = JS_GetPrivate(cx, js_obj);
+            
+            /* Check if target type is java.lang.Class class */
+            if ((*jEnv)->IsAssignableFrom(jEnv, jlClass, target_java_class)) {
+                if (java_value)
+                    *java_value = java_class_descriptor->java_class;
+                return JS_TRUE;
+            }
+            
+            /* Check if target type is netscape.javascript.JSObject wrapper class */
+            if (convert_js_obj_to_JSObject_wrapper(cx, jEnv, js_obj, signature, cost, java_value)) {
+                if (*java_value)
+                    *is_local_refp = JS_TRUE;
+                return JS_TRUE;
+            }
+            
+            /* Fall through, to attempt conversion to a Java string */
+            
+        } else if (JS_InstanceOf(cx, js_obj, &JavaMember_class, 0)) {
+
+            if (!JS_ConvertValue(cx, v, JSTYPE_OBJECT, &v))
+                return JS_FALSE;
+            return jsj_ConvertJSValueToJavaObject(cx, jEnv, v, signature, cost,
+                                                  java_value, is_local_refp);
+
+        } else {
+            /* Otherwise, see if the target type is the  netscape.javascript.JSObject
+               wrapper class or one of its subclasses, in which case a
+               reference is passed to the original JS object by wrapping it
+               inside an instance of netscape.javascript.JSObject */
+            if (convert_js_obj_to_JSObject_wrapper(cx, jEnv, js_obj, signature, cost, java_value))             {
+                return JS_TRUE;
+            }
+            
+            /* Fall through, to attempt conversion to a Java string */
+        }
+        
+    } else if (JSVAL_IS_NUMBER(v)) {
+        /* JS numbers, integral or not, can be converted to instances of java.lang.Double */
+        if ((*jEnv)->IsAssignableFrom(jEnv, jlDouble, target_java_class)) {
+            if (java_value) {
+                jsdouble d;
+                if (!JS_ValueToNumber(cx, v, &d))
+                    goto conversion_error;
+                *java_value = (*jEnv)->NewObject(jEnv, jlDouble, jlDouble_Double, d);
+                if (*java_value) {
+                    *is_local_refp = JS_TRUE;
+                } else {
+                    jsj_UnexpectedJavaError(cx, jEnv,
+                        "Couldn't construct instance of java.lang.Double");
+                    return JS_FALSE;
+                }
+            }
+#ifdef LIVECONNECT_IMPROVEMENTS
+            (*cost)++;
+#endif
+            return JS_TRUE;
+        }
+        /* Fall through, to attempt conversion to a java.lang.String ... */
+        
+    } else if (JSVAL_IS_BOOLEAN(v)) {
+        /* JS boolean values can be converted to instances of java.lang.Boolean */
+        if ((*jEnv)->IsAssignableFrom(jEnv, jlBoolean, target_java_class)) {
+            if (java_value) {
+                JSBool b;
+                if (!JS_ValueToBoolean(cx, v, &b))
+                    goto conversion_error;
+                *java_value =
+                    (*jEnv)->NewObject(jEnv, jlBoolean, jlBoolean_Boolean, b);
+                if (*java_value) {
+                    *is_local_refp = JS_TRUE;
+                } else {
+                    jsj_UnexpectedJavaError(cx, jEnv, "Couldn't construct instance " 
+                        "of java.lang.Boolean");
+                    return JS_FALSE;
+                }
+            }
+#ifdef LIVECONNECT_IMPROVEMENTS
+            (*cost)++;
+#endif
+            return JS_TRUE;
+        }
+        /* Fall through, to attempt conversion to a java.lang.String ... */
+    }
+    
+    /* If no other conversion is possible, see if the target type is java.lang.String */
+    if ((*jEnv)->IsAssignableFrom(jEnv, jlString, target_java_class)) {
+#ifdef LIVECONNECT_IMPROVEMENTS
+        JSBool is_string = JSVAL_IS_STRING(v);
+#endif
+        
+        /* Convert to JS string, if necessary, and then to a Java Unicode string */
+        jsstr = JS_ValueToString(cx, v);
+        if (jsstr) {
+            if (java_value) {
+                *java_value = jsj_ConvertJSStringToJavaString(cx, jEnv, jsstr);
+                if (*java_value) {
+                    *is_local_refp = JS_TRUE;
+                } else {
+                    return JS_FALSE;
+                }
+            }
+#ifdef LIVECONNECT_IMPROVEMENTS
+            if (!is_string)
+                (*cost)++;
+#endif
+            return JS_TRUE;
+        }
+    }
+    
+conversion_error:
+    return JS_FALSE;
+}
+
+/* Valid ranges for Java numeric types */
+#define jbyte_MAX_VALUE   127.0
+#define jbyte_MIN_VALUE  -128.0
+#define jchar_MAX_VALUE   65535.0
+#define jchar_MIN_VALUE   0.0
+#define jshort_MAX_VALUE  32767.0
+#define jshort_MIN_VALUE -32768.0
+#define jint_MAX_VALUE    2147483647.0
+#define jint_MIN_VALUE   -2147483648.0
+#define jlong_MAX_VALUE   9223372036854775807.0
+#define jlong_MIN_VALUE  -9223372036854775808.0
+
+/* Utility macro for jsj_ConvertJSValueToJavaValue(), below */
+#define JSVAL_TO_INTEGRAL_JVALUE(type_name, member_name, member_type, jsval, java_value) \
+    if (!JSVAL_IS_NUMBER(v)) {                                           \
+        if (!JS_ConvertValue(cx, v, JSTYPE_NUMBER, &v))                  \
+            goto conversion_error;                                       \
+        (*cost)++;                                                       \
+    }                                                                    \
+    {                                                                    \
+        member_type member_name;                                         \
+                                                                         \
+        if (JSVAL_IS_INT(v)) {                                           \
+            jsint ival = JSVAL_TO_INT(v);                                \
+            member_name = (member_type) ival;                            \
+                                                                         \
+            /* Check to see if the jsval's magnitude is too large to be  \
+               representable in the target java type */                  \
+            if (member_name != ival)                                     \
+                goto numeric_conversion_error;                           \
+        } else {                                                         \
+            jdouble dval = *JSVAL_TO_DOUBLE(v);                          \
+                                                                         \
+            /* NaN becomes zero when converted to integral value */      \
+            if (JSDOUBLE_IS_NaN(dval))                                   \
+                member_name = 0;                                         \
+                                                                         \
+            /* Unrepresentably large numbers, including infinities, */   \
+            /* cause an error. */                                        \
+            else if ((dval > member_type ## _MAX_VALUE) ||               \
+                     (dval < member_type ## _MIN_VALUE)) {               \
+                goto numeric_conversion_error;                           \
+            } else                                                       \
+                member_name = (member_type) dval;                        \
+                                                                         \
+            /* Don't allow a non-integral number to be converted         \
+               to an integral type */                                    \
+            /* Actually, we have to allow this for LC1 compatibility */  \
+            /* if ((jdouble)member_name != dval)                         \
+                (*cost)++; */                                            \
+        }                                                                \
+        if (java_value)                                                  \
+            java_value->member_name = member_name;                       \
+    }
+
+#if XP_MAC
+
+/* on MRJ jlong is typedef'd to wide, which is a struct. */
+#include <Math64.h>
+
+static jsint jlong_to_jsint(jlong lvalue)
+{
+    SInt64 val = WideToSInt64(lvalue);
+    return S32Set(val);
+}
+
+static jlong jsint_to_jlong(jsint ivalue)
+{
+    SInt64 val = S64Set(ivalue);
+    wide wval =SInt64ToWide(val);
+    return *(jlong*)&wval;
+}
+
+static jdouble jlong_to_jdouble(jlong lvalue)
+{
+    SInt64 val = WideToSInt64(lvalue);
+    return SInt64ToLongDouble(val);
+}
+
+static jlong jdouble_to_jlong(jdouble dvalue)
+{
+    SInt64 val = LongDoubleToSInt64(dvalue);
+    wide wval = SInt64ToWide(val);
+    return *(jlong*)&wval;
+}
+
+/* Mac utility macro for jsj_ConvertJSValueToJavaValue(), below */
+#define JSVAL_TO_JLONG_JVALUE(member_name, member_type, jsvalue, java_value) \
+if (!JSVAL_IS_NUMBER(jsvalue)) {                                         \
+        if (!JS_ConvertValue(cx, jsvalue, JSTYPE_NUMBER, &jsvalue))      \
+        goto conversion_error;                                           \
+    (*cost)++;                                                           \
+    }                                                                    \
+    {                                                                    \
+        member_type member_name;                                         \
+                                                                         \
+        if (JSVAL_IS_INT(jsvalue)) {                                     \
+            jsint ival = JSVAL_TO_INT(jsvalue);                          \
+            member_name = jsint_to_jlong(ival);                          \
+                                                                         \
+        } else {                                                         \
+            jdouble dval = *JSVAL_TO_DOUBLE(jsvalue);                    \
+                                                                         \
+            /* NaN becomes zero when converted to integral value */      \
+            if (JSDOUBLE_IS_NaN(dval))                                   \
+                member_name = jsint_to_jlong(0);                         \
+                                                                         \
+            /* Unrepresentably large numbers, including infinities, */   \
+            /* cause an error. */                                        \
+            else if ((dval > member_type ## _MAX_VALUE) ||               \
+                     (dval < member_type ## _MIN_VALUE)) {               \
+                goto numeric_conversion_error;                           \
+            } else                                                       \
+                member_name = jdouble_to_jlong(dval);                    \
+                                                                         \
+            /* Don't allow a non-integral number to be converted         \
+               to an integral type */                                    \
+            /* Actually, we have to allow this for LC1 compatibility */  \
+            /*if (jlong_to_jdouble(member_name) != dval)                 \
+                (*cost)++;*/                                             \
+        }                                                                \
+        if (java_value)                                                  \
+            java_value->member_name = member_name;                       \
+    }
+
+#else
+
+#define jlong_to_jdouble(lvalue) ((jdouble) lvalue)
+
+#endif
+
+/*
+ * Convert a JS value to a Java value of the given type signature.  The cost
+ * variable is incremented if coercion is required, e.g. the source value is
+ * a string, but the target type is a boolean.
+ *
+ * Returns JS_FALSE if no conversion is possible, either because the jsval has
+ * a type that is wholly incompatible with the Java value, or because a scalar
+ * jsval can't be represented in a variable of the target type without loss of
+ * precision, e.g. the source value is "4.2" but the destination type is byte.
+ * If conversion is not possible and java_value is non-NULL, the JS error
+ * reporter is called with an appropriate message.
+ */  
+JSBool
+jsj_ConvertJSValueToJavaValue(JSContext *cx, JNIEnv *jEnv, jsval v,
+                              JavaSignature *signature,
+                              int *cost, jvalue *java_value, JSBool *is_local_refp)
+{
+    JavaSignatureChar type;
+    JSBool success = JS_FALSE;
+
+    /* Initialize to default case, in which no new Java object is
+       synthesized to perform the conversion and, therefore, no JNI local
+       references are being held. */
+    *is_local_refp = JS_FALSE;   
+    
+    type = signature->type;
+    switch (type) {
+    case JAVA_SIGNATURE_BOOLEAN:
+        if (!JSVAL_IS_BOOLEAN(v)) {
+            if (!JS_ConvertValue(cx, v, JSTYPE_BOOLEAN, &v))
+                goto conversion_error;
+            (*cost)++;
+        }
+        if (java_value)
+            java_value->z = (jboolean)(JSVAL_TO_BOOLEAN(v) == JS_TRUE);
+        break;
+
+    case JAVA_SIGNATURE_SHORT:
+        JSVAL_TO_INTEGRAL_JVALUE(short, s, jshort, v, java_value);
+        break;
+
+    case JAVA_SIGNATURE_BYTE:
+        JSVAL_TO_INTEGRAL_JVALUE(byte, b, jbyte, v, java_value);
+        break;
+
+    case JAVA_SIGNATURE_CHAR:
+        /* A one-character string can be converted into a character */
+        if (JSVAL_IS_STRING(v) && (JS_GetStringLength(JSVAL_TO_STRING(v)) == 1)) {
+            v = INT_TO_JSVAL(*JS_GetStringChars(JSVAL_TO_STRING(v)));
+        }
+        JSVAL_TO_INTEGRAL_JVALUE(char, c, jchar, v, java_value);
+        break;
+
+    case JAVA_SIGNATURE_INT:
+        JSVAL_TO_INTEGRAL_JVALUE(int, i, jint, v, java_value);
+        break;
+
+    case JAVA_SIGNATURE_LONG:
+#if XP_MAC
+        JSVAL_TO_JLONG_JVALUE(j, jlong, v, java_value);
+#else
+        JSVAL_TO_INTEGRAL_JVALUE(long, j, jlong, v, java_value);
+#endif
+        break;
+    
+    case JAVA_SIGNATURE_FLOAT:
+        if (!JSVAL_IS_NUMBER(v)) {
+            if (!JS_ConvertValue(cx, v, JSTYPE_NUMBER, &v))
+                goto conversion_error;
+            (*cost)++;
+        }
+        if (java_value) {
+            if (JSVAL_IS_INT(v))
+                java_value->f = (jfloat) JSVAL_TO_INT(v);
+            else
+                java_value->f = (jfloat) *JSVAL_TO_DOUBLE(v);
+        }
+        break;
+
+    case JAVA_SIGNATURE_DOUBLE:
+        if (!JSVAL_IS_NUMBER(v)) {
+            if (!JS_ConvertValue(cx, v, JSTYPE_NUMBER, &v))
+                goto conversion_error;
+            (*cost)++;
+        }
+        if (java_value) {
+            if (JSVAL_IS_INT(v))
+                java_value->d = (jdouble) JSVAL_TO_INT(v);
+            else
+                java_value->d = (jdouble) *JSVAL_TO_DOUBLE(v);
+        }
+        break;
+
+    case JAVA_SIGNATURE_CLASS:
+    case JAVA_SIGNATURE_ARRAY:
+        if (!jsj_ConvertJSValueToJavaObject(cx, jEnv, v, signature, cost,
+            &java_value->l, is_local_refp))
+            goto conversion_error;
+        break;
+
+    default:
+        PR_ASSERT(0);
+        return JS_FALSE;
+    }
+
+    /* Success */
+    return JS_TRUE;
+
+numeric_conversion_error:
+    success = JS_TRUE;
+    /* Fall through ... */
+
+conversion_error:
+
+    if (java_value) {
+        const char *jsval_string;
+        JSString *jsstr;
+
+        jsval_string = NULL;
+        jsstr = JS_ValueToString(cx, v);
+        if (jsstr)
+            jsval_string = JS_GetStringBytes(jsstr);
+        if (!jsval_string)
+            jsval_string = "";
+        
+        JS_ReportError(cx, "Unable to convert JavaScript value %s to "
+                           "Java value of type %s",
+                       jsval_string, signature->name);
+        return JS_FALSE;
+    }
+    return success;
+}
+
+/*
+ * A utility routine to create a JavaScript Unicode string from a
+ * java.lang.String (Unicode) string.
+ */
+JSString *
+jsj_ConvertJavaStringToJSString(JSContext *cx, JNIEnv *jEnv, jstring java_str)
+{
+    JSString *js_str;
+    jboolean is_copy;
+    const jchar *ucs2_str;
+    jchar *copy_ucs2_str;
+    jsize ucs2_str_len, num_bytes;
+
+    ucs2_str_len = (*jEnv)->GetStringLength(jEnv, java_str);
+    ucs2_str = (*jEnv)->GetStringChars(jEnv, java_str, &is_copy);
+    if (!ucs2_str) {
+        jsj_UnexpectedJavaError(cx, jEnv,
+                                "Unable to extract native Unicode from Java string");
+        return NULL;
+    }
+
+    js_str = NULL;
+
+    /* The string data passed into JS_NewUCString() is
+       not copied, so make a copy of the Unicode character vector. */
+    num_bytes = ucs2_str_len * sizeof(jchar);
+    copy_ucs2_str = (jchar*)JS_malloc(cx, num_bytes);
+    if (!copy_ucs2_str)
+        goto done;
+    memcpy(copy_ucs2_str, ucs2_str, num_bytes);
+
+    js_str = JS_NewUCString(cx, (jschar*)copy_ucs2_str, ucs2_str_len);
+
+done:
+    (*jEnv)->ReleaseStringChars(jEnv, java_str, ucs2_str);
+    return js_str;
+}
+
+/*
+ * Attempt to obtain a JS string representation of a Java object.
+ * The java_obj argument must be of type java.lang.Object or a subclass.
+ * If java_obj is a Java string, it's value is simply extracted and
+ * copied into a JS string.  Otherwise, the toString() method is called
+ * on java_obj.
+ */
+JSBool
+jsj_ConvertJavaObjectToJSString(JSContext *cx,
+                                JNIEnv *jEnv,
+                                JavaClassDescriptor *class_descriptor,
+                                jobject java_obj, jsval *vp)
+{
+    JSString *js_str;
+    jstring java_str;
+    jmethodID toString;
+    
+    /* Create a Java string, unless java_obj is already a java.lang.String */
+    if ((*jEnv)->IsInstanceOf(jEnv, java_obj, jlString)) {
+        java_str = java_obj;
+    } else {
+        jclass java_class;
+
+        java_class = class_descriptor->java_class;
+        toString = (*jEnv)->GetMethodID(jEnv, java_class, "toString",
+                                        "()Ljava/lang/String;");
+        if (!toString) {
+            /* All Java objects have a toString method */
+            jsj_UnexpectedJavaError(cx, jEnv, "No toString() method for class %s!",
+                                    class_descriptor->name);
+            return JS_FALSE;
+        }
+        java_str = (*jEnv)->CallObjectMethod(jEnv, java_obj, toString);
+        if (!java_str) {
+            jsj_ReportJavaError(cx, jEnv, "toString() method failed");
+            return JS_FALSE;
+        }
+    }
+
+    /* Extract Unicode from java.lang.String instance and convert to JS string */
+    js_str = jsj_ConvertJavaStringToJSString(cx, jEnv, java_str);
+    if (!js_str)
+        return JS_FALSE;
+
+    *vp = STRING_TO_JSVAL(js_str);
+    return JS_TRUE;
+}
+
+/*
+ * Convert a Java object to a number by attempting to call the
+ * doubleValue() method on a Java object to get a double result.
+ * This usually only works on instances of java.lang.Double, but the code
+ * is generalized to work with any Java object that supports this method.
+ *
+ * Returns JS_TRUE if the call was successful.
+ * Returns JS_FALSE if conversion is not possible or an error occurs.
+ */
+JSBool
+jsj_ConvertJavaObjectToJSNumber(JSContext *cx, JNIEnv *jEnv,
+                                JavaClassDescriptor *class_descriptor,
+                                jobject java_obj, jsval *vp)
+{
+    jdouble d;
+    jmethodID doubleValue;
+    jclass java_class;
+
+    java_class = class_descriptor->java_class;
+    doubleValue = (*jEnv)->GetMethodID(jEnv, java_class, "doubleValue", "()D");
+    if (!doubleValue) {
+        /* There is no doubleValue() method for the object.  Try toString()
+           instead and the JS engine will attempt to convert the result to
+           a number. */
+        (*jEnv)->ExceptionClear(jEnv);
+        return jsj_ConvertJavaObjectToJSString(cx, jEnv, class_descriptor,
+                                               java_obj, vp);
+    }
+
+    d = (*jEnv)->CallDoubleMethod(jEnv, java_obj, doubleValue);
+    if ((*jEnv)->ExceptionOccurred(jEnv)) {
+        jsj_UnexpectedJavaError(cx, jEnv, "doubleValue() method failed");
+        return JS_FALSE;
+    }
+    return JS_NewDoubleValue(cx, d, vp);
+}
+
+/*
+ * Convert a Java object to a boolean by attempting to call the
+ * booleanValue() method on a Java object to get a boolean result.
+ * This usually only works on instances of java.lang.Boolean, but the code
+ * is generalized to work with any Java object that supports this method.
+ *
+ * Returns JS_TRUE if the call was successful.
+ * Returns JS_FALSE if conversion is not possible or an error occurs.
+ */
+extern JSBool
+jsj_ConvertJavaObjectToJSBoolean(JSContext *cx, JNIEnv *jEnv,
+                                 JavaClassDescriptor *class_descriptor,
+                                 jobject java_obj, jsval *vp)
+{
+    jboolean b;
+    jmethodID booleanValue;
+    jclass java_class;
+    
+    /* Null converts to false. */
+    if (!java_obj) {
+        *vp = JSVAL_FALSE;
+        return JS_TRUE;
+    }
+    java_class = class_descriptor->java_class;
+    booleanValue = (*jEnv)->GetMethodID(jEnv, java_obj, "booleanValue", "()Z");
+
+    /* Non-null Java object does not have a booleanValue() method, so
+       it converts to true. */
+    if (!booleanValue) {
+        (*jEnv)->ExceptionClear(jEnv);
+        *vp = JSVAL_TRUE;
+        return JS_TRUE;
+    }
+
+    b = (*jEnv)->CallBooleanMethod(jEnv, java_obj, booleanValue);
+    if ((*jEnv)->ExceptionOccurred(jEnv)) {
+        jsj_UnexpectedJavaError(cx, jEnv, "booleanValue() method failed");
+        return JS_FALSE;
+    }
+    *vp = BOOLEAN_TO_JSVAL(b);
+    return JS_TRUE;
+}
+
+/*
+ * Reflect a Java object into a JS value.  The source object, java_obj, must
+ * be of type java.lang.Object or a subclass and may, therefore, be an array.
+ */
+JSBool
+jsj_ConvertJavaObjectToJSValue(JSContext *cx, JNIEnv *jEnv,
+                               jobject java_obj, jsval *vp)
+{
+    jclass java_class;
+    JSObject *js_obj;
+
+    /* A null in Java-land is also null in JS */
+    if (!java_obj) {
+        *vp = JSVAL_NULL;
+        return JS_TRUE;
+    }
+
+    java_class = (*jEnv)->GetObjectClass(jEnv, java_obj);
+
+    /*
+     * If it's an instance of netscape.javascript.JSObject, i.e. a wrapper
+     * around a JS object that has been passed into the Java world, unwrap
+     * it to obtain the original JS object.
+     */
+     if (njJSObject && (*jEnv)->IsInstanceOf(jEnv, java_obj, njJSObject)) {
+#ifdef PRESERVE_JSOBJECT_IDENTITY
+        js_obj = (JSObject *)((*jEnv)->GetIntField(jEnv, java_obj, njJSObject_internal));
+#else
+        js_obj = jsj_UnwrapJSObjectWrapper(jEnv, java_obj);
+#endif
+        PR_ASSERT(js_obj);
+        if (!js_obj)
+            return JS_FALSE;
+        *vp = OBJECT_TO_JSVAL(js_obj);
+        return JS_TRUE;
+     }
+
+    /*
+     * Instances of java.lang.String are wrapped so we can call methods on
+     * them, but they convert to a JS string if used in a string context.
+     */
+    /* TODO - let's get rid of this annoying "feature" */
+
+    /* otherwise, wrap it inside a JavaObject */
+    js_obj = jsj_WrapJavaObject(cx, jEnv, java_obj, java_class);
+    if (!js_obj)
+        return JS_FALSE;
+    *vp = OBJECT_TO_JSVAL(js_obj);
+    return JS_TRUE;
+}
+
+/*
+ * Convert a Java value (primitive or object) to a JS value.
+ *
+ * This is usually an infallible operation, but JS_FALSE is returned
+ * on an out-of-memory condition and the error reporter is called.
+ */
+JSBool
+jsj_ConvertJavaValueToJSValue(JSContext *cx, JNIEnv *jEnv,
+                              JavaSignature *signature,
+                              jvalue *java_value,
+                              jsval *vp)
+{
+    int32 ival32;
+
+    switch (signature->type) {
+    case JAVA_SIGNATURE_VOID:
+        *vp = JSVAL_VOID;
+        return JS_TRUE;
+
+    case JAVA_SIGNATURE_BYTE:
+        *vp = INT_TO_JSVAL((jsint)java_value->b);
+        return JS_TRUE;
+
+    case JAVA_SIGNATURE_CHAR:
+        *vp = INT_TO_JSVAL((jsint)java_value->c);
+        return JS_TRUE;
+
+    case JAVA_SIGNATURE_SHORT:
+        *vp = INT_TO_JSVAL((jsint)java_value->s);
+        return JS_TRUE;
+
+    case JAVA_SIGNATURE_INT:
+        ival32 = java_value->i;
+        if (INT_FITS_IN_JSVAL(ival32)) {
+            *vp = INT_TO_JSVAL((jsint) ival32);
+            return JS_TRUE;
+        } else {
+            return JS_NewDoubleValue(cx, ival32, vp);
+        }
+
+    case JAVA_SIGNATURE_BOOLEAN:
+        *vp = BOOLEAN_TO_JSVAL((JSBool) java_value->z);
+        return JS_TRUE;
+
+    case JAVA_SIGNATURE_LONG:
+        return JS_NewDoubleValue(cx, jlong_to_jdouble(java_value->j), vp);
+  
+    case JAVA_SIGNATURE_FLOAT:
+        return JS_NewDoubleValue(cx, java_value->f, vp);
+
+    case JAVA_SIGNATURE_DOUBLE:
+        return JS_NewDoubleValue(cx, java_value->d, vp);
+
+    case JAVA_SIGNATURE_CLASS:
+    case JAVA_SIGNATURE_ARRAY:
+        return jsj_ConvertJavaObjectToJSValue(cx, jEnv, java_value->l, vp);
+
+    default:
+        PR_ASSERT(0);
+        return JS_FALSE;
+    }
+}
+

mozilla/js/src/liveconnect/jsj_field.c

@@ -0,0 +1,383 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+ 
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the code used to reflect Java fields as properties of
+ * JavaObject objects and the code to access those fields.
+ *
+ */
+
+#include <stdlib.h>
+
+#include "jsj_private.h"      /* LiveConnect internals */
+
+/*
+ * Add a single field, described by java_field, to the JavaMemberDescriptor
+ * named by field_name within the given JavaClassDescriptor.
+ *
+ * Returns JS_TRUE on success. Otherwise, returns JS_FALSE and reports an error.
+ */
+static JSBool
+add_java_field_to_class_descriptor(JSContext *cx,
+                                   JNIEnv *jEnv,
+                                   JavaClassDescriptor *class_descriptor, 
+                                   jstring field_name_jstr,
+                                   jobject java_field,  /* a java.lang.reflect.Field */
+                                   jint modifiers)
+{
+    jclass fieldType;
+    jfieldID fieldID;
+    jclass java_class;
+
+    JSBool is_static_field;
+    JavaMemberDescriptor *member_descriptor = NULL;
+    const char *sig_cstr = NULL;
+    const char *field_name = NULL;
+    JavaSignature *signature = NULL;
+    JavaFieldSpec *field_spec = NULL;
+        
+    is_static_field = modifiers & ACC_STATIC;
+    if (is_static_field) {
+        member_descriptor = jsj_GetJavaStaticMemberDescriptor(cx, jEnv, class_descriptor, field_name_jstr);
+    } else {
+        member_descriptor = jsj_GetJavaMemberDescriptor(cx, jEnv, class_descriptor, field_name_jstr);
+    }
+    if (!member_descriptor)
+        goto error;
+    
+    field_spec = (JavaFieldSpec*)JS_malloc(cx, sizeof(JavaFieldSpec));
+    if (!field_spec)
+        goto error;
+
+    field_spec->modifiers = modifiers;
+
+    /* Get the Java class corresponding to the type of the field */
+    fieldType = (*jEnv)->CallObjectMethod(jEnv, java_field, jlrField_getType);
+    if (!fieldType) {
+        jsj_UnexpectedJavaError(cx, jEnv,
+                                "Unable to determine type of field using"
+                                " java.lang.reflect.Field.getType()");
+        goto error;
+    }
+    
+    signature = jsj_GetJavaClassDescriptor(cx, jEnv, fieldType);
+    if (!signature)
+        goto error;
+    field_spec->signature = signature;
+
+    field_name = jsj_DupJavaStringUTF(cx, jEnv, field_name_jstr);
+    if (!field_name)
+        goto error;
+    field_spec->name = field_name;
+
+    /* Compute the JNI-style (string-based) signature of the field type */
+    sig_cstr = jsj_ConvertJavaSignatureToString(cx, signature);
+    if (!sig_cstr)
+        goto error;
+
+    /* Compute the JNI fieldID and cache it for quick field access */
+    java_class = class_descriptor->java_class;
+    if (is_static_field)
+        fieldID = (*jEnv)->GetStaticFieldID(jEnv, java_class, field_name, sig_cstr);
+    else
+        fieldID = (*jEnv)->GetFieldID(jEnv, java_class, field_name, sig_cstr);
+    if (!fieldID) {
+       jsj_UnexpectedJavaError(cx, jEnv,
+                           "Can't get Java field ID for class %s, field %s (sig=%s)",
+                           class_descriptor->name, field_name, sig_cstr);
+       goto error;
+    }
+    field_spec->fieldID = fieldID;
+    
+    JS_free(cx, (char*)sig_cstr);
+    
+    member_descriptor->field = field_spec;
+
+    /* Success */
+    return JS_TRUE;
+
+error:
+    if (field_spec) {
+        JS_FREE_IF(cx, (char*)field_spec->name);
+        JS_free(cx, field_spec);
+    }
+    JS_FREE_IF(cx, (char*)sig_cstr);
+    if (signature)
+        jsj_ReleaseJavaClassDescriptor(cx, jEnv, signature);
+    return JS_FALSE;
+}
+
+/*
+ * Free up a JavaFieldSpec and all its resources.
+ */
+void
+jsj_DestroyFieldSpec(JSContext *cx, JNIEnv *jEnv, JavaFieldSpec *field)
+{
+    JS_FREE_IF(cx, (char*)field->name);
+    jsj_ReleaseJavaClassDescriptor(cx, jEnv, field->signature);
+    JS_free(cx, field);
+}
+
+/*
+ * Add a JavaMemberDescriptor to the collection of members in class_descriptor
+ * for every public field of the identified Java class.  (A separate collection
+ * is kept in class_descriptor for static and instance members.)
+ * If reflect_only_static_fields is set, instance fields are not reflected.  If
+ * it isn't set, only instance fields are reflected and static fields are not
+ * reflected.
+ *
+ * Returns JS_TRUE on success. Otherwise, returns JS_FALSE and reports an error.
+ */
+JSBool 
+jsj_ReflectJavaFields(JSContext *cx, JNIEnv *jEnv, JavaClassDescriptor *class_descriptor,
+                      JSBool reflect_only_static_fields)
+{
+    int i;
+    JSBool ok;
+    jint modifiers;
+    jobject java_field;
+    jstring field_name_jstr;
+    jarray joFieldArray;
+    jsize num_fields;
+    jclass java_class;
+
+    /* Get a java array of java.lang.reflect.Field objects, by calling
+       java.lang.Class.getFields(). */
+    java_class = class_descriptor->java_class;
+    joFieldArray = (*jEnv)->CallObjectMethod(jEnv, java_class, jlClass_getFields);
+    if (!joFieldArray) {
+        jsj_UnexpectedJavaError(cx, jEnv,
+                                "Can't determine Java object's fields "
+                                "using java.lang.Class.getFields()");
+        return JS_FALSE;
+    }
+
+    /* Iterate over the class fields */
+    num_fields = (*jEnv)->GetArrayLength(jEnv, joFieldArray);
+    for (i = 0; i < num_fields; i++) {
+       
+        /* Get the i'th reflected field */
+        java_field = (*jEnv)->GetObjectArrayElement(jEnv, joFieldArray, i);
+        if (!java_field) {
+            jsj_UnexpectedJavaError(cx, jEnv, "Can't access a Field[] array");
+            return JS_FALSE;
+        }
+
+        /* Get the field modifiers, e.g. static, public, private, etc. */
+        modifiers = (*jEnv)->CallIntMethod(jEnv, java_field, jlrField_getModifiers);
+        if ((*jEnv)->ExceptionOccurred(jEnv)) {
+            jsj_UnexpectedJavaError(cx, jEnv,
+                                    "Can't access a Field's modifiers using"
+                                    "java.lang.reflect.Field.getModifiers()");
+            return JS_FALSE;
+        }
+
+        /* Don't allow access to private or protected Java fields. */
+        if (!(modifiers & ACC_PUBLIC))
+            continue;
+
+        /* Reflect all instance fields or all static fields, but not both */
+        if (reflect_only_static_fields != ((modifiers & ACC_STATIC) != 0))
+            continue;
+
+        /* Determine the unqualified name of the field */
+        field_name_jstr = (*jEnv)->CallObjectMethod(jEnv, java_field, jlrField_getName);
+        if (!field_name_jstr) {
+            jsj_UnexpectedJavaError(cx, jEnv,
+                                    "Can't obtain a Field's name"
+                                    "java.lang.reflect.Field.getName()");
+            return JS_FALSE;
+        }
+        
+        /* Add a JavaFieldSpec object to the JavaClassDescriptor */
+        ok = add_java_field_to_class_descriptor(cx, jEnv, class_descriptor, field_name_jstr,
+                                                java_field, modifiers);
+        if (!ok)
+            return JS_FALSE;
+    }
+
+    /* Success */
+    return JS_TRUE;
+}
+
+/*
+ * Read the value of a Java field and return it as a JavaScript value.
+ * If the field is static, then java_obj is a Java class, otherwise
+ * it's a Java instance object.
+ *
+ * Returns JS_TRUE on success. Otherwise, returns JS_FALSE and reports an error.
+ */
+JSBool
+jsj_GetJavaFieldValue(JSContext *cx, JNIEnv *jEnv, JavaFieldSpec *field_spec,
+                      jobject java_obj, jsval *vp)
+{
+    JSBool is_static_field;
+    jvalue java_value;
+    JavaSignature *signature;
+    JavaSignatureChar field_type;
+    jfieldID fieldID = field_spec->fieldID;
+
+    is_static_field = field_spec->modifiers & ACC_STATIC;
+
+#define GET_JAVA_FIELD(Type,member)                                          \
+    PR_BEGIN_MACRO                                                           \
+    if (is_static_field)                                                     \
+        java_value.member =                                                  \
+            (*jEnv)->GetStatic##Type##Field(jEnv, java_obj, fieldID);        \
+    else                                                                     \
+        java_value.member =                                                  \
+            (*jEnv)->Get##Type##Field(jEnv, java_obj, fieldID);              \
+    if ((*jEnv)->ExceptionOccurred(jEnv)) {                                  \
+        jsj_UnexpectedJavaError(cx, jEnv, "Error reading Java field");           \
+        return JS_FALSE;                                                     \
+    }                                                                        \
+    PR_END_MACRO
+
+    signature = field_spec->signature;
+    field_type = signature->type;
+    switch(field_type) {
+    case JAVA_SIGNATURE_BYTE:
+        GET_JAVA_FIELD(Byte,b);
+        break;
+
+    case JAVA_SIGNATURE_CHAR:
+        GET_JAVA_FIELD(Char,c);
+        break;
+
+    case JAVA_SIGNATURE_SHORT:
+        GET_JAVA_FIELD(Short,s);
+        break;
+
+    case JAVA_SIGNATURE_INT:
+        GET_JAVA_FIELD(Int,i);
+        break;
+
+    case JAVA_SIGNATURE_BOOLEAN:
+        GET_JAVA_FIELD(Boolean,z);
+        break;
+
+    case JAVA_SIGNATURE_LONG:
+        GET_JAVA_FIELD(Long,j);
+        break;
+  
+    case JAVA_SIGNATURE_FLOAT:
+        GET_JAVA_FIELD(Float,f);
+        break;
+
+    case JAVA_SIGNATURE_DOUBLE:
+        GET_JAVA_FIELD(Double,d);
+        break;
+
+    case JAVA_SIGNATURE_CLASS:
+    case JAVA_SIGNATURE_ARRAY:
+        GET_JAVA_FIELD(Object,l);
+        break;
+
+#undef GET_JAVA_FIELD
+    default:
+        PR_ASSERT(0);        /* Unknown java type signature */
+        return JS_FALSE;
+    }
+
+    return jsj_ConvertJavaValueToJSValue(cx, jEnv, signature, &java_value, vp);
+}
+
+JSBool
+jsj_SetJavaFieldValue(JSContext *cx, JNIEnv *jEnv, JavaFieldSpec *field_spec,
+                      jclass java_obj, jsval js_val)
+{
+    JSBool is_static_field, is_local_ref;
+    int dummy_cost;
+    jvalue java_value;
+    JavaSignature *signature;
+    JavaSignatureChar field_type;
+    jfieldID fieldID = field_spec->fieldID;
+
+    is_static_field = field_spec->modifiers & ACC_STATIC;
+
+#define SET_JAVA_FIELD(Type,member)                                          \
+    PR_BEGIN_MACRO                                                           \
+    if (is_static_field) {                                                   \
+        (*jEnv)->SetStatic##Type##Field(jEnv, java_obj, fieldID,             \
+                                        java_value.member);                  \
+    } else {                                                                 \
+        (*jEnv)->Set##Type##Field(jEnv, java_obj, fieldID,java_value.member);\
+    }                                                                        \
+    if ((*jEnv)->ExceptionOccurred(jEnv)) {                                  \
+        jsj_UnexpectedJavaError(cx, jEnv, "Error assigning to Java field");      \
+        return JS_FALSE;                                                     \
+    }                                                                        \
+    PR_END_MACRO
+
+    signature = field_spec->signature;
+    if (!jsj_ConvertJSValueToJavaValue(cx, jEnv, js_val, signature, &dummy_cost,
+                                       &java_value, &is_local_ref))
+        return JS_FALSE;
+
+    field_type = signature->type;
+    switch(field_type) {
+    case JAVA_SIGNATURE_BYTE:
+        SET_JAVA_FIELD(Byte,b);
+        break;
+
+    case JAVA_SIGNATURE_CHAR:
+        SET_JAVA_FIELD(Char,c);
+        break;
+
+    case JAVA_SIGNATURE_SHORT:
+        SET_JAVA_FIELD(Short,s);
+        break;
+
+    case JAVA_SIGNATURE_INT:
+        SET_JAVA_FIELD(Int,i);
+        break;
+
+    case JAVA_SIGNATURE_BOOLEAN:
+        SET_JAVA_FIELD(Boolean,z);
+        break;
+
+    case JAVA_SIGNATURE_LONG:
+        SET_JAVA_FIELD(Long,j);
+        break;
+  
+    case JAVA_SIGNATURE_FLOAT:
+        SET_JAVA_FIELD(Float,f);
+        break;
+
+    case JAVA_SIGNATURE_DOUBLE:
+        SET_JAVA_FIELD(Double,d);
+        break;
+
+    case JAVA_SIGNATURE_CLASS:
+    case JAVA_SIGNATURE_ARRAY:
+        SET_JAVA_FIELD(Object,l);
+        if (is_local_ref)
+            (*jEnv)->DeleteLocalRef(jEnv, java_value.l);
+        break;
+
+#undef SET_JAVA_FIELD
+    default:
+        PR_ASSERT(0);        /* Unknown java type signature */
+        return JS_FALSE;
+    }
+    
+    return JS_TRUE;
+}

mozilla/js/src/liveconnect/jsj_hash.c

@@ -0,0 +1,487 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+ 
+/*
+ * This is a copy of the NSPR hash-table library, but it has been slightly
+ * modified to allow an additional argument to be passed into the hash
+ * key-comparision function.  This is used to maintain thread-safety by
+ * passing in a JNIEnv pointer to the key-comparison function rather
+ * than storing it in a global.  All types,function names, etc. have
+ * been renamed from their original NSPR names to protect the innocent.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jsj_hash.h"
+#include "prtypes.h"
+#ifdef NSPR20
+#    include "prlog.h"
+#    include "prbit.h"
+#else
+#    include "prassert.h"
+#endif
+
+/* Compute the number of buckets in ht */
+#define NBUCKETS(ht)    (1 << (JSJ_HASH_BITS - (ht)->shift))
+
+/* The smallest table has 16 buckets */
+#define MINBUCKETSLOG2  4
+#define MINBUCKETS      (1 << MINBUCKETSLOG2)
+
+/* Compute the maximum entries given n buckets that we will tolerate, ~90% */
+#define OVERLOADED(n)   ((n) - ((n) >> 3))
+
+/* Compute the number of entries below which we shrink the table by half */
+#define UNDERLOADED(n)  (((n) > MINBUCKETS) ? ((n) >> 2) : 0)
+
+/*
+** Stubs for default hash allocator ops.
+*/
+static void *
+DefaultAllocTable(void *pool, size_t size)
+{
+#if defined(XP_MAC)
+#pragma unused (pool)
+#endif
+
+    return malloc(size);
+}
+
+static void
+DefaultFreeTable(void *pool, void *item)
+{
+#if defined(XP_MAC)
+#pragma unused (pool)
+#endif
+
+    free(item);
+}
+
+static JSJHashEntry *
+DefaultAllocEntry(void *pool, const void *key)
+{
+#if defined(XP_MAC)
+#pragma unused (pool,key)
+#endif
+
+    return malloc(sizeof(JSJHashEntry));
+}
+
+static void
+DefaultFreeEntry(void *pool, JSJHashEntry *he, PRUintn flag)
+{
+#if defined(XP_MAC)
+#pragma unused (pool)
+#endif
+
+    if (flag == HT_FREE_ENTRY)
+        free(he);
+}
+
+static JSJHashAllocOps defaultHashAllocOps = {
+    DefaultAllocTable, DefaultFreeTable,
+    DefaultAllocEntry, DefaultFreeEntry
+};
+
+PR_IMPLEMENT(JSJHashTable *)
+JSJ_NewHashTable(PRUint32 n, JSJHashFunction keyHash,
+                JSJHashComparator keyCompare, JSJHashComparator valueCompare,
+                JSJHashAllocOps *allocOps, void *allocPriv)
+{
+    JSJHashTable *ht;
+    PRUint32 nb;
+
+    if (n <= MINBUCKETS) {
+        n = MINBUCKETSLOG2;
+    } else {
+        n = PR_CeilingLog2(n);
+        if ((PRInt32)n < 0)
+            return 0;
+    }
+
+    if (!allocOps) allocOps = &defaultHashAllocOps;
+
+    ht = (*allocOps->allocTable)(allocPriv, sizeof *ht);
+    if (!ht)
+    return 0;
+    memset(ht, 0, sizeof *ht);
+    ht->shift = JSJ_HASH_BITS - n;
+    n = 1 << n;
+#if defined(XP_PC) && !defined(_WIN32)
+    if (n > 16000) {
+        (*allocOps->freeTable)(allocPriv, ht);
+        return 0;
+    }
+#endif  /* WIN16 */
+    nb = n * sizeof(JSJHashEntry *);
+    ht->buckets = (*allocOps->allocTable)(allocPriv, nb);
+    if (!ht->buckets) {
+        (*allocOps->freeTable)(allocPriv, ht);
+        return 0;
+    }
+    memset(ht->buckets, 0, nb);
+
+    ht->keyHash = keyHash;
+    ht->keyCompare = keyCompare;
+    ht->valueCompare = valueCompare;
+    ht->allocOps = allocOps;
+    ht->allocPriv = allocPriv;
+    return ht;
+}
+
+PR_IMPLEMENT(void)
+JSJ_HashTableDestroy(JSJHashTable *ht)
+{
+    PRUint32 i, n;
+    JSJHashEntry *he, *next;
+    JSJHashAllocOps *allocOps = ht->allocOps;
+    void *allocPriv = ht->allocPriv;
+
+    n = NBUCKETS(ht);
+    for (i = 0; i < n; i++) {
+        for (he = ht->buckets[i]; he; he = next) {
+            next = he->next;
+            (*allocOps->freeEntry)(allocPriv, he, HT_FREE_ENTRY);
+        }
+    }
+#ifdef DEBUG
+    memset(ht->buckets, 0xDB, n * sizeof ht->buckets[0]);
+#endif
+    (*allocOps->freeTable)(allocPriv, ht->buckets);
+#ifdef DEBUG
+    memset(ht, 0xDB, sizeof *ht);
+#endif
+    (*allocOps->freeTable)(allocPriv, ht);
+}
+
+/*
+** Multiplicative hash, from Knuth 6.4.
+*/
+#define GOLDEN_RATIO    0x9E3779B9U
+
+PR_IMPLEMENT(JSJHashEntry **)
+JSJ_HashTableRawLookup(JSJHashTable *ht, JSJHashNumber keyHash, const void *key, void *arg)
+{
+    JSJHashEntry *he, **hep, **hep0;
+    JSJHashNumber h;
+
+#ifdef HASHMETER
+    ht->nlookups++;
+#endif
+    h = keyHash * GOLDEN_RATIO;
+    h >>= ht->shift;
+    hep = hep0 = &ht->buckets[h];
+    while ((he = *hep) != 0) {
+        if (he->keyHash == keyHash && (*ht->keyCompare)(key, he->key, arg)) {
+            /* Move to front of chain if not already there */
+            if (hep != hep0) {
+                *hep = he->next;
+                he->next = *hep0;
+                *hep0 = he;
+            }
+            return hep0;
+        }
+        hep = &he->next;
+#ifdef HASHMETER
+        ht->nsteps++;
+#endif
+    }
+    return hep;
+}
+
+PR_IMPLEMENT(JSJHashEntry *)
+JSJ_HashTableRawAdd(JSJHashTable *ht, JSJHashEntry **hep,
+                    JSJHashNumber keyHash, const void *key, void *value,
+                    void *arg)
+{
+    PRUint32 i, n;
+    JSJHashEntry *he, *next, **oldbuckets;
+    PRUint32 nb;
+
+    /* Grow the table if it is overloaded */
+    n = NBUCKETS(ht);
+    if (ht->nentries >= OVERLOADED(n)) {
+#ifdef HASHMETER
+        ht->ngrows++;
+#endif
+        ht->shift--;
+        oldbuckets = ht->buckets;
+#if defined(XP_PC) && !defined(_WIN32)
+        if (2 * n > 16000)
+            return 0;
+#endif  /* WIN16 */
+        nb = 2 * n * sizeof(JSJHashEntry *);
+        ht->buckets = (*ht->allocOps->allocTable)(ht->allocPriv, nb);
+        if (!ht->buckets) {
+            ht->buckets = oldbuckets;
+            return 0;
+        }
+        memset(ht->buckets, 0, nb);
+
+        for (i = 0; i < n; i++) {
+            for (he = oldbuckets[i]; he; he = next) {
+                next = he->next;
+                hep = JSJ_HashTableRawLookup(ht, he->keyHash, he->key, arg);
+                PR_ASSERT(*hep == 0);
+                he->next = 0;
+                *hep = he;
+            }
+        }
+#ifdef DEBUG
+        memset(oldbuckets, 0xDB, n * sizeof oldbuckets[0]);
+#endif
+        (*ht->allocOps->freeTable)(ht->allocPriv, oldbuckets);
+        hep = JSJ_HashTableRawLookup(ht, keyHash, key, arg);
+    }
+
+    /* Make a new key value entry */
+    he = (*ht->allocOps->allocEntry)(ht->allocPriv, key);
+    if (!he)
+    return 0;
+    he->keyHash = keyHash;
+    he->key = key;
+    he->value = value;
+    he->next = *hep;
+    *hep = he;
+    ht->nentries++;
+    return he;
+}
+
+PR_IMPLEMENT(JSJHashEntry *)
+JSJ_HashTableAdd(JSJHashTable *ht, const void *key, void *value, void *arg)
+{
+    JSJHashNumber keyHash;
+    JSJHashEntry *he, **hep;
+
+    keyHash = (*ht->keyHash)(key, arg);
+    hep = JSJ_HashTableRawLookup(ht, keyHash, key, arg);
+    if ((he = *hep) != 0) {
+        /* Hit; see if values match */
+        if ((*ht->valueCompare)(he->value, value, arg)) {
+            /* key,value pair is already present in table */
+            return he;
+        }
+        if (he->value)
+            (*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_VALUE);
+        he->value = value;
+        return he;
+    }
+    return JSJ_HashTableRawAdd(ht, hep, keyHash, key, value, arg);
+}
+
+PR_IMPLEMENT(void)
+JSJ_HashTableRawRemove(JSJHashTable *ht, JSJHashEntry **hep, JSJHashEntry *he, void *arg)
+{
+    PRUint32 i, n;
+    JSJHashEntry *next, **oldbuckets;
+    PRUint32 nb;
+
+    *hep = he->next;
+    (*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_ENTRY);
+
+    /* Shrink table if it's underloaded */
+    n = NBUCKETS(ht);
+    if (--ht->nentries < UNDERLOADED(n)) {
+#ifdef HASHMETER
+        ht->nshrinks++;
+#endif
+        ht->shift++;
+        oldbuckets = ht->buckets;
+        nb = n * sizeof(JSJHashEntry*) / 2;
+        ht->buckets = (*ht->allocOps->allocTable)(ht->allocPriv, nb);
+        if (!ht->buckets) {
+            ht->buckets = oldbuckets;
+            return;
+        }
+        memset(ht->buckets, 0, nb);
+
+        for (i = 0; i < n; i++) {
+            for (he = oldbuckets[i]; he; he = next) {
+                next = he->next;
+                hep = JSJ_HashTableRawLookup(ht, he->keyHash, he->key, arg);
+                PR_ASSERT(*hep == 0);
+                he->next = 0;
+                *hep = he;
+            }
+        }
+#ifdef DEBUG
+        memset(oldbuckets, 0xDB, n * sizeof oldbuckets[0]);
+#endif
+        (*ht->allocOps->freeTable)(ht->allocPriv, oldbuckets);
+    }
+}
+
+PR_IMPLEMENT(PRBool)
+JSJ_HashTableRemove(JSJHashTable *ht, const void *key, void *arg)
+{
+    JSJHashNumber keyHash;
+    JSJHashEntry *he, **hep;
+
+    keyHash = (*ht->keyHash)(key, arg);
+    hep = JSJ_HashTableRawLookup(ht, keyHash, key, arg);
+    if ((he = *hep) == 0)
+        return PR_FALSE;
+
+    /* Hit; remove element */
+    JSJ_HashTableRawRemove(ht, hep, he, arg);
+    return PR_TRUE;
+}
+
+PR_IMPLEMENT(void *)
+JSJ_HashTableLookup(JSJHashTable *ht, const void *key, void *arg)
+{
+    JSJHashNumber keyHash;
+    JSJHashEntry *he, **hep;
+
+    keyHash = (*ht->keyHash)(key, arg);
+    hep = JSJ_HashTableRawLookup(ht, keyHash, key, arg);
+    if ((he = *hep) != 0) {
+        return he->value;
+    }
+    return 0;
+}
+
+/*
+** Iterate over the entries in the hash table calling func for each
+** entry found. Stop if "f" says to (return value & PR_ENUMERATE_STOP).
+** Return a count of the number of elements scanned.
+*/
+PR_IMPLEMENT(int)
+JSJ_HashTableEnumerateEntries(JSJHashTable *ht, JSJHashEnumerator f, void *arg)
+{
+    JSJHashEntry *he, **hep;
+    PRUint32 i, nbuckets;
+    int rv, n = 0;
+    JSJHashEntry *todo = 0;
+
+    nbuckets = NBUCKETS(ht);
+    for (i = 0; i < nbuckets; i++) {
+        hep = &ht->buckets[i];
+        while ((he = *hep) != 0) {
+            rv = (*f)(he, n, arg);
+            n++;
+            if (rv & (HT_ENUMERATE_REMOVE | HT_ENUMERATE_UNHASH)) {
+                *hep = he->next;
+                if (rv & HT_ENUMERATE_REMOVE) {
+                    he->next = todo;
+                    todo = he;
+                }
+            } else {
+                hep = &he->next;
+            }
+            if (rv & HT_ENUMERATE_STOP) {
+                goto out;
+            }
+        }
+    }
+
+out:
+    hep = &todo;
+    while ((he = *hep) != 0) {
+        JSJ_HashTableRawRemove(ht, hep, he, arg);
+    }
+    return n;
+}
+
+#ifdef HASHMETER
+#include <math.h>
+#include <stdio.h>
+
+PR_IMPLEMENT(void)
+JSJ_HashTableDumpMeter(JSJHashTable *ht, JSJHashEnumerator dump, FILE *fp)
+{
+    double mean, variance;
+    PRUint32 nchains, nbuckets;
+    PRUint32 i, n, maxChain, maxChainLen;
+    JSJHashEntry *he;
+
+    variance = 0;
+    nchains = 0;
+    maxChainLen = 0;
+    nbuckets = NBUCKETS(ht);
+    for (i = 0; i < nbuckets; i++) {
+        he = ht->buckets[i];
+        if (!he)
+            continue;
+        nchains++;
+        for (n = 0; he; he = he->next)
+            n++;
+        variance += n * n;
+        if (n > maxChainLen) {
+            maxChainLen = n;
+            maxChain = i;
+        }
+    }
+    mean = (double)ht->nentries / nchains;
+    variance = fabs(variance / nchains - mean * mean);
+
+    fprintf(fp, "\nHash table statistics:\n");
+    fprintf(fp, "     number of lookups: %u\n", ht->nlookups);
+    fprintf(fp, "     number of entries: %u\n", ht->nentries);
+    fprintf(fp, "       number of grows: %u\n", ht->ngrows);
+    fprintf(fp, "     number of shrinks: %u\n", ht->nshrinks);
+    fprintf(fp, "   mean steps per hash: %g\n", (double)ht->nsteps
+                                                / ht->nlookups);
+    fprintf(fp, "mean hash chain length: %g\n", mean);
+    fprintf(fp, "    standard deviation: %g\n", sqrt(variance));
+    fprintf(fp, " max hash chain length: %u\n", maxChainLen);
+    fprintf(fp, "        max hash chain: [%u]\n", maxChain);
+
+    for (he = ht->buckets[maxChain], i = 0; he; he = he->next, i++)
+        if ((*dump)(he, i, fp) != HT_ENUMERATE_NEXT)
+            break;
+}
+#endif /* HASHMETER */
+
+PR_IMPLEMENT(int)
+JSJ_HashTableDump(JSJHashTable *ht, JSJHashEnumerator dump, FILE *fp)
+{
+    int count;
+
+    count = JSJ_HashTableEnumerateEntries(ht, dump, fp);
+#ifdef HASHMETER
+    JSJ_HashTableDumpMeter(ht, dump, fp);
+#endif
+    return count;
+}
+
+PR_IMPLEMENT(JSJHashNumber)
+JSJ_HashString(const void *key)
+{
+    JSJHashNumber h;
+    const unsigned char *s;
+
+    h = 0;
+    for (s = key; *s; s++)
+        h = (h >> 28) ^ (h << 4) ^ *s;
+    return h;
+}
+
+PR_IMPLEMENT(int)
+JSJ_CompareStrings(const void *v1, const void *v2)
+{
+    return strcmp(v1, v2) == 0;
+}
+
+PR_IMPLEMENT(int)
+JSJ_CompareValues(const void *v1, const void *v2)
+{
+    return v1 == v2;
+}

mozilla/js/src/liveconnect/jsj_hash.h

@@ -0,0 +1,141 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+
+/*
+ * This is a copy of the NSPR hash-table library, but it has been slightly
+ * modified to allow an additional argument to be passed into the hash
+ * key-comparision function.  This is used to maintain thread-safety by
+ * passing in a JNIEnv pointer to the key-comparison function rather
+ * than storing it in a global.  All types,function names, etc. have
+ * been renamed from their original NSPR names to protect the innocent.
+ */
+
+#ifndef jsj_hash_h___
+#define jsj_hash_h___
+/*
+ * API to portable hash table code.
+ */
+#include <stddef.h>
+#include <stdio.h>
+#include "prtypes.h"
+
+PR_BEGIN_EXTERN_C
+
+typedef struct JSJHashEntry  JSJHashEntry;
+typedef struct JSJHashTable  JSJHashTable;
+typedef PRUint32 JSJHashNumber;
+#define JSJ_HASH_BITS 32
+typedef JSJHashNumber (*JSJHashFunction)(const void *key, void *arg);
+typedef PRIntn (*JSJHashComparator)(const void *v1, const void *v2, void *arg);
+typedef PRIntn (*JSJHashEnumerator)(JSJHashEntry *he, PRIntn i, void *arg);
+
+/* Flag bits in JSJHashEnumerator's return value */
+#define HT_ENUMERATE_NEXT       0       /* continue enumerating entries */
+#define HT_ENUMERATE_STOP       1       /* stop enumerating entries */
+#define HT_ENUMERATE_REMOVE     2       /* remove and free the current entry */
+#define HT_ENUMERATE_UNHASH     4       /* just unhash the current entry */
+
+typedef struct JSJHashAllocOps {
+    void *              (*allocTable)(void *pool, size_t size);
+    void                (*freeTable)(void *pool, void *item);
+    JSJHashEntry *      (*allocEntry)(void *pool, const void *key);
+    void                (*freeEntry)(void *pool, JSJHashEntry *he, PRUintn flag);
+} JSJHashAllocOps;
+
+#define HT_FREE_VALUE   0               /* just free the entry's value */
+#define HT_FREE_ENTRY   1               /* free value and entire entry */
+
+struct JSJHashEntry {
+    JSJHashEntry        *next;          /* hash chain linkage */
+    JSJHashNumber       keyHash;        /* key hash function result */
+    const void          *key;           /* ptr to opaque key */
+    void                *value;         /* ptr to opaque value */
+};
+
+struct JSJHashTable {
+    JSJHashEntry         **buckets;      /* vector of hash buckets */
+    PRUint32              nentries;       /* number of entries in table */
+    PRUint32              shift;          /* multiplicative hash shift */
+    JSJHashFunction     keyHash;        /* key hash function */
+    JSJHashComparator   keyCompare;     /* key comparison function */
+    JSJHashComparator   valueCompare;   /* value comparison function */
+    JSJHashAllocOps     *allocOps;      /* allocation operations */
+    void                *allocPriv;     /* allocation private data */
+#ifdef HASHMETER
+    PRUint32              nlookups;       /* total number of lookups */
+    PRUint32              nsteps;         /* number of hash chains traversed */
+    PRUint32              ngrows;         /* number of table expansions */
+    PRUint32              nshrinks;       /* number of table contractions */
+#endif
+};
+
+/*
+ * Create a new hash table.
+ * If allocOps is null, use default allocator ops built on top of malloc().
+ */
+PR_EXTERN(JSJHashTable *)
+JSJ_NewHashTable(PRUint32 n, JSJHashFunction keyHash,
+                JSJHashComparator keyCompare, JSJHashComparator valueCompare,
+                JSJHashAllocOps *allocOps, void *allocPriv);
+
+PR_EXTERN(void)
+JSJ_HashTableDestroy(JSJHashTable *ht);
+
+/* Low level access methods */
+PR_EXTERN(JSJHashEntry **)
+JSJ_HashTableRawLookup(JSJHashTable *ht, JSJHashNumber keyHash, const void *key, void *arg);
+
+PR_EXTERN(JSJHashEntry *)
+JSJ_HashTableRawAdd(JSJHashTable *ht, JSJHashEntry **hep, JSJHashNumber keyHash,
+                   const void *key, void *value, void *arg);
+
+PR_EXTERN(void)
+JSJ_HashTableRawRemove(JSJHashTable *ht, JSJHashEntry **hep, JSJHashEntry *he, void *arg);
+
+/* Higher level access methods */
+PR_EXTERN(JSJHashEntry *)
+JSJ_HashTableAdd(JSJHashTable *ht, const void *key, void *value, void *arg);
+
+PR_EXTERN(PRBool)
+JSJ_HashTableRemove(JSJHashTable *ht, const void *key, void *arg);
+
+PR_EXTERN(PRIntn)
+JSJ_HashTableEnumerateEntries(JSJHashTable *ht, JSJHashEnumerator f, void *arg);
+
+PR_EXTERN(void *)
+JSJ_HashTableLookup(JSJHashTable *ht, const void *key, void *arg);
+
+PR_EXTERN(PRIntn)
+JSJ_HashTableDump(JSJHashTable *ht, JSJHashEnumerator dump, FILE *fp);
+
+/* General-purpose C string hash function. */
+PR_EXTERN(JSJHashNumber)
+JSJ_HashString(const void *key);
+
+/* Compare strings using strcmp(), return true if equal. */
+PR_EXTERN(int)
+JSJ_CompareStrings(const void *v1, const void *v2);
+
+/* Stub function just returns v1 == v2 */
+PR_EXTERN(PRIntn)
+JSJ_CompareValues(const void *v1, const void *v2);
+
+PR_END_EXTERN_C
+
+#endif /* jsj_hash_h___ */

mozilla/js/src/liveconnect/jsj_private.h

@@ -0,0 +1,552 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * Declarations of private (internal) functions/data/types for
+ * JavaScript <==> Java communication.
+ *
+ */
+ 
+
+#ifndef _JSJAVA_PVT_H
+#define _JSJAVA_PVT_H
+
+#include "prtypes.h"
+
+/* NSPR1 compatibility definitions */
+#ifdef NSPR20
+#   include "prprf.h"
+#   include "prlog.h"
+#   include "plhash.h"          /* NSPR hash-tables      */
+#else
+#   include "prprintf.h"
+#   include "prassert.h"
+#   include "prhash.h"          /* NSPR hash-tables      */
+#   define PRHashNumber prhashcode
+#endif
+
+#ifdef XP_MAC
+#    include "prosdep.h"
+#endif
+
+#include "jsj_hash.h"        /* Hash tables */
+#include "jni.h"             /* Java Native Interface */
+#include "jsapi.h"           /* JavaScript engine API */
+#include "jsjava.h"          /* LiveConnect public API */
+
+
+/*************************** Type Declarations ******************************/
+
+/* Forward type declarations */
+typedef struct JavaMemberDescriptor JavaMemberDescriptor;
+typedef struct JavaMethodSpec JavaMethodSpec;
+typedef struct JavaClassDescriptor JavaClassDescriptor;
+typedef struct JavaClassDescriptor JavaSignature;
+typedef struct CapturedJSError CapturedJSError;
+typedef struct JavaMemberVal JavaMemberVal;
+
+/*
+ * This enum uses the same character encoding used by the JDK to encode
+ * Java type signatures, but the enum is easier to debug/compile with.
+ */
+typedef enum {
+    JAVA_SIGNATURE_ARRAY    =   '[',
+    JAVA_SIGNATURE_BYTE     =   'B',
+    JAVA_SIGNATURE_CHAR     =   'C',
+    JAVA_SIGNATURE_CLASS    =   'L',
+    JAVA_SIGNATURE_FLOAT    =   'F',
+    JAVA_SIGNATURE_DOUBLE   =   'D',
+    JAVA_SIGNATURE_INT      =   'I',
+    JAVA_SIGNATURE_LONG     =   'J',
+    JAVA_SIGNATURE_SHORT    =   'S',
+    JAVA_SIGNATURE_VOID     =   'V',
+    JAVA_SIGNATURE_BOOLEAN  =   'Z',
+    JAVA_SIGNATURE_UNKNOWN  =    0
+} JavaSignatureChar;
+
+/* The signature of a Java method consists of the signatures of all its
+   arguments and its return type signature. */
+typedef struct JavaMethodSignature {
+    jsize                   num_args;               /* Length of arg_signatures array */
+    JavaSignature **        arg_signatures;         /* Array of argument signatures */
+    JavaSignature *         return_val_signature;   /* Return type signature */
+} JavaMethodSignature;
+
+/* A descriptor for the reflection of a single Java field */
+typedef struct JavaFieldSpec {
+    jfieldID                fieldID;    /* JVM opaque access handle for field */
+    JavaSignature *         signature;  /* Java type of field */
+    int                     modifiers;  /* Bitfield indicating field qualifiers */
+    const char *            name;       /* UTF8; TODO - Should support Unicode field names */
+} JavaFieldSpec;
+
+/* A descriptor for the reflection of a single Java method.
+   Each overloaded method has a separate corresponding JavaMethodSpec. */
+struct JavaMethodSpec {
+    jmethodID               methodID;   /* JVM opaque access handle for method */
+    JavaMethodSignature     signature;
+    const char *            name;       /* UTF8; TODO - Should support Unicode method names */
+    JavaMethodSpec *        next;       /* next method in chain of overloaded methods */
+};
+
+/*
+ * A descriptor for the reflection of a single member of a Java object.
+ * This can represent one or more Java methods and/or a single field.
+ * (When there is more than one method attached to a single JavaMemberDescriptor
+ * they are overloaded methods sharing the same simple name.)  This same
+ * descriptor type is used for both static or instance members.
+ */
+struct JavaMemberDescriptor {
+    const char *            name;       /* simple name of field and/or method */
+    jsid                    id;         /* hashed name for quick JS property lookup */
+    JavaFieldSpec *         field;      /* field with the given name, if any */
+    JavaMethodSpec *        methods;    /* Overloaded methods which share the same name, if any */
+    JavaMemberDescriptor *  next;       /* next descriptor in same defining class */
+    JSObject *              invoke_func_obj; /* If non-null, JSFunction obj to invoke method */
+};
+
+/* This is the native portion of a reflected Java class */
+struct JavaClassDescriptor {
+    const char *            name;       /* Name of class, e.g. "java/lang/Byte" */
+    JavaSignatureChar       type;       /* class category: primitive type, object, array */
+    jclass                  java_class; /* Opaque JVM handle to corresponding java.lang.Class */
+    int                     num_instance_members;
+    int                     num_static_members;
+    JSBool                  instance_members_reflected;
+    JavaMemberDescriptor *  instance_members;
+    JSBool                  static_members_reflected;
+    JavaMemberDescriptor *  static_members;
+    JavaMemberDescriptor *  constructors;
+    int                     modifiers;  /* Class declaration qualifiers,
+                                           e.g. abstract, private */
+    int                     ref_count;  /* # of references to this struct */
+    JavaSignature *         array_component_signature; /* Only non-NULL for array classes */
+};
+
+/* This is the native portion of a reflected Java method or field */
+struct JavaMemberVal {
+    jsval                   field_val;              /* Captured value of Java field */
+    jsval                   invoke_method_func_val; /* JSFunction wrapper around Java method invoker */
+    JavaMemberDescriptor *  descriptor;
+    JavaMemberVal *         next;
+};
+
+/* This is the native portion of a reflected Java object */
+typedef struct JavaObjectWrapper {
+    jobject                 java_obj;           /* Opaque JVM ref to Java object */
+    JavaClassDescriptor *   class_descriptor;   /* Java class info */
+} JavaObjectWrapper;
+
+/* These are definitions of the Java class/method/field modifier bits.
+   These really shouldn't be hard-coded here.  Rather,
+   they should be read from java.lang.reflect.Modifier */
+#define ACC_PUBLIC          0x0001      /* visible to everyone */
+#define ACC_STATIC          0x0008      /* instance variable is static */
+#define ACC_FINAL           0x0010      /* no further subclassing,overriding */
+#define ACC_INTERFACE       0x0200      /* class is an interface */
+#define ACC_ABSTRACT	    0x0400      /* no definition provided */
+
+/* A JSJavaVM structure must be created for each Java VM that is accessed
+   via LiveConnect */
+struct JSJavaVM {
+/* TODO -  all LiveConnect global variables should be migrated into this
+           structure in order to allow more than one LiveConnect-enabled
+           Java VM to exist within the same process. */
+    SystemJavaVM *      java_vm;
+    JNIEnv *            main_thread_env;       /* Main-thread Java environment */
+    JSBool              jsj_created_java_vm;
+    int                 num_attached_threads;
+    JSJavaVM *          next;           /* next VM among all created VMs */
+};
+
+/* Per-thread state that encapsulates the connection to the Java VM */
+struct JSJavaThreadState {
+    const char *        name;           /* Thread name, for debugging */
+    JSJavaVM *          jsjava_vm;      /* All per-JVM state */
+    JNIEnv *            jEnv;           /* Per-thread opaque handle to Java VM */
+    CapturedJSError *   pending_js_errors; /* JS errors to be thrown as Java exceptions */
+    JSContext *         cx;             /* current JS context for thread */
+    JSJavaThreadState * next;           /* next thread state among all created threads */
+};
+
+struct JavaToJSSavedState {
+	JSErrorReporter error_reporter;
+	JSJavaThreadState* java_jsj_env;
+};
+typedef struct JavaToJSSavedState JavaToJSSavedState;
+
+
+
+/******************************** Globals ***********************************/
+
+extern JSJCallbacks *JSJ_callbacks;
+
+/* JavaScript classes that reflect Java objects */
+extern JSClass JavaObject_class;
+extern JSClass JavaArray_class;
+extern JSClass JavaClass_class;
+extern JSClass JavaMember_class;
+
+/*
+ * Opaque JVM handles to Java classes, methods and objects required for
+ * Java reflection.  These are computed and cached during initialization.
+ * TODO: These should be moved inside the JSJavaVM struct
+ */
+extern jclass jlObject;                        /* java.lang.Object */
+extern jclass jlrConstructor;                  /* java.lang.reflect.Constructor */
+extern jclass jlThrowable;                     /* java.lang.Throwable */
+extern jclass jlSystem;                        /* java.lang.System */
+extern jclass jlClass;                         /* java.lang.Class */
+extern jclass jlBoolean;                       /* java.lang.Boolean */
+extern jclass jlDouble;                        /* java.lang.Double */
+extern jclass jlString;                        /* java.lang.String */
+extern jclass njJSObject;                      /* netscape.javascript.JSObject */
+extern jclass njJSException;                   /* netscape.javascript.JSException */
+extern jclass njJSUtil;                        /* netscape.javascript.JSUtil */
+
+extern jmethodID jlClass_getMethods;           /* java.lang.Class.getMethods() */
+extern jmethodID jlClass_getConstructors;      /* java.lang.Class.getConstructors() */
+extern jmethodID jlClass_getFields;            /* java.lang.Class.getFields() */
+extern jmethodID jlClass_getName;              /* java.lang.Class.getName() */
+extern jmethodID jlClass_getComponentType;     /* java.lang.Class.getComponentType() */
+extern jmethodID jlClass_getModifiers;         /* java.lang.Class.getModifiers() */
+extern jmethodID jlClass_isArray;              /* java.lang.Class.isArray() */
+
+extern jmethodID jlrMethod_getName;            /* java.lang.reflect.Method.getName() */
+extern jmethodID jlrMethod_getParameterTypes;  /* java.lang.reflect.Method.getParameterTypes() */
+extern jmethodID jlrMethod_getReturnType;      /* java.lang.reflect.Method.getReturnType() */
+extern jmethodID jlrMethod_getModifiers;       /* java.lang.reflect.Method.getModifiers() */
+
+extern jmethodID jlrConstructor_getParameterTypes; /* java.lang.reflect.Constructor.getParameterTypes() */
+extern jmethodID jlrConstructor_getModifiers;  /* java.lang.reflect.Constructor.getModifiers() */
+
+extern jmethodID jlrField_getName;             /* java.lang.reflect.Field.getName() */
+extern jmethodID jlrField_getType;             /* java.lang.reflect.Field.getType() */
+extern jmethodID jlrField_getModifiers;        /* java.lang.reflect.Field.getModifiers() */
+
+extern jmethodID jlThrowable_getMessage;       /* java.lang.Throwable.getMessage() */
+extern jmethodID jlThrowable_toString;         /* java.lang.Throwable.toString() */
+
+extern jmethodID jlBoolean_Boolean;            /* java.lang.Boolean constructor */
+extern jmethodID jlBoolean_booleanValue;       /* java.lang.Boolean.booleanValue() */
+extern jmethodID jlDouble_Double;              /* java.lang.Double constructor */
+extern jmethodID jlDouble_doubleValue;         /* java.lang.Double.doubleValue() */
+
+extern jmethodID jlSystem_identityHashCode;    /* java.lang.System.identityHashCode() */
+
+extern jobject jlVoid_TYPE;                    /* java.lang.Void.TYPE value */
+
+extern jmethodID njJSException_JSException;    /* netscape.javascipt.JSexception constructor */
+extern jmethodID njJSObject_JSObject;          /* netscape.javascript.JSObject constructor */
+extern jmethodID njJSUtil_getStackTrace;       /* netscape.javascript.JSUtil.getStackTrace() */
+extern jfieldID njJSObject_internal;           /* netscape.javascript.JSObject.internal */
+extern jfieldID njJSException_lineno;          /* netscape.javascript.JSException.lineno */
+extern jfieldID njJSException_tokenIndex;      /* netscape.javascript.JSException.tokenIndex */
+extern jfieldID njJSException_source;          /* netscape.javascript.JSException.source */
+extern jfieldID njJSException_filename;        /* netscape.javascript.JSException.filename */
+
+
+/**************** Java <==> JS conversions and Java types *******************/
+extern JSBool
+jsj_ComputeJavaClassSignature(JSContext *cx,
+                              JavaSignature *signature,
+                              jclass java_class);
+
+extern const char *
+jsj_ConvertJavaSignatureToString(JSContext *cx, JavaSignature *signature);
+extern const char *
+jsj_ConvertJavaSignatureToHRString(JSContext *cx,
+                                   JavaSignature *signature);
+extern JavaMethodSignature *
+jsj_InitJavaMethodSignature(JSContext *cx, JNIEnv *jEnv, jobject method,
+                            JavaMethodSignature *method_signature);
+
+extern const char *
+jsj_ConvertJavaMethodSignatureToString(JSContext *cx,
+                                       JavaMethodSignature *method_signature);
+extern const char *
+jsj_ConvertJavaMethodSignatureToHRString(JSContext *cx,
+                                         const char *method_name,
+                                         JavaMethodSignature *method_signature);
+extern void
+jsj_PurgeJavaMethodSignature(JSContext *cx, JNIEnv *jEnv, JavaMethodSignature *signature);
+
+extern JSBool
+jsj_ConvertJSValueToJavaValue(JSContext *cx, JNIEnv *jEnv, jsval v, JavaSignature *signature,
+			      int *cost, jvalue *java_value, JSBool *is_local_refp);
+extern JSBool
+jsj_ConvertJSValueToJavaObject(JSContext *cx, JNIEnv *jEnv, jsval v, JavaSignature *signature,
+			       int *cost, jobject *java_value, JSBool *is_local_refp);
+extern jstring
+jsj_ConvertJSStringToJavaString(JSContext *cx, JNIEnv *jEnv, JSString *js_str);
+
+extern JSBool
+jsj_ConvertJavaValueToJSValue(JSContext *cx, JNIEnv *jEnv, JavaSignature *signature,
+                              jvalue *java_value, jsval *vp);
+extern JSBool
+jsj_ConvertJavaObjectToJSValue(JSContext *cx, JNIEnv *jEnv,
+                               jobject java_obj, jsval *vp);
+
+extern JSString *
+jsj_ConvertJavaStringToJSString(JSContext *cx, JNIEnv *jEnv, jstring java_str);
+
+extern JSBool
+jsj_ConvertJavaObjectToJSString(JSContext *cx, JNIEnv *jEnv,
+                                JavaClassDescriptor *class_descriptor,
+                                jobject java_obj, jsval *vp);
+extern JSBool
+jsj_ConvertJavaObjectToJSNumber(JSContext *cx, JNIEnv *jEnv,
+                                JavaClassDescriptor *class_descriptor,
+                                jobject java_obj, jsval *vp);
+extern JSBool
+jsj_ConvertJavaObjectToJSBoolean(JSContext *cx, JNIEnv *jEnv,
+                                 JavaClassDescriptor *class_descriptor,
+                                 jobject java_obj, jsval *vp);
+extern JSJavaThreadState *
+jsj_enter_js(JNIEnv *jEnv, jobject java_wrapper_obj,
+         JSContext **cxp, JSObject **js_objp, JavaToJSSavedState* saved_state);
+extern JSBool
+jsj_exit_js(JSContext *cx, JSJavaThreadState *jsj_env, JavaToJSSavedState* original_state);
+
+extern JavaClassDescriptor *
+jsj_get_jlObject_descriptor(JSContext *cx, JNIEnv *jEnv);
+
+extern JSBool
+jsj_remove_js_obj_reflection_from_hashtable(JSContext *cx, JSObject *js_obj);
+
+extern JSBool
+jsj_init_js_obj_reflections_table();
+
+/************************ Java package reflection **************************/
+extern JSBool
+jsj_init_JavaPackage(JSContext *, JSObject *,
+                     JavaPackageDef *predefined_packages);
+
+/************************* Java class reflection ***************************/
+extern JSBool
+jsj_init_JavaClass(JSContext *cx, JSObject *global_obj);
+
+extern void
+jsj_DiscardJavaClassReflections(JNIEnv *jEnv);
+
+extern const char *
+jsj_GetJavaClassName(JSContext *cx, JNIEnv *jEnv, jclass java_class);
+
+extern JavaClassDescriptor *
+jsj_GetJavaClassDescriptor(JSContext *cx, JNIEnv *jEnv, jclass java_class);
+
+extern void
+jsj_ReleaseJavaClassDescriptor(JSContext *cx, JNIEnv *jEnv, JavaClassDescriptor *class_descriptor);
+
+extern JSObject *
+jsj_define_JavaClass(JSContext *cx, JNIEnv *jEnv, JSObject *obj,
+                     const char *unqualified_class_name,
+                     jclass jclazz);
+
+extern JavaMemberDescriptor *
+jsj_GetJavaMemberDescriptor(JSContext *cx,
+                            JNIEnv *jEnv,
+                            JavaClassDescriptor *class_descriptor,
+                            jstring member_name);
+
+extern JavaMemberDescriptor *
+jsj_LookupJavaMemberDescriptorById(JSContext *cx, JNIEnv *jEnv,
+                                   JavaClassDescriptor *class_descriptor,
+                                   jsid id);
+
+extern JavaMemberDescriptor *
+jsj_LookupJavaStaticMemberDescriptorById(JSContext *cx, JNIEnv *jEnv,
+                                         JavaClassDescriptor *class_descriptor,
+                                         jsid id);
+
+extern JavaMemberDescriptor *
+jsj_GetJavaStaticMemberDescriptor(JSContext *cx, JNIEnv *jEnv,
+                                  JavaClassDescriptor *class_descriptor,
+                                  jstring member_name);
+
+extern JavaMemberDescriptor *
+jsj_GetJavaClassConstructors(JSContext *cx,
+                             JavaClassDescriptor *class_descriptor);
+
+extern JavaMemberDescriptor *
+jsj_LookupJavaClassConstructors(JSContext *cx, JNIEnv *jEnv,
+                                JavaClassDescriptor *class_descriptor);
+
+extern JavaMemberDescriptor *
+jsj_GetClassInstanceMembers(JSContext *cx, JNIEnv *jEnv,
+                            JavaClassDescriptor *class_descriptor);
+
+extern JavaMemberDescriptor *
+jsj_GetClassStaticMembers(JSContext *cx, JNIEnv *jEnv,
+                          JavaClassDescriptor *class_descriptor);
+
+extern JSBool
+jsj_InitJavaClassReflectionsTable();
+
+/************************* Java field reflection ***************************/
+
+extern JSBool
+jsj_GetJavaFieldValue(JSContext *cx, JNIEnv *jEnv, JavaFieldSpec *field_spec,
+                      jobject java_obj, jsval *vp);
+extern JSBool
+jsj_SetJavaFieldValue(JSContext *cx, JNIEnv *jEnv, JavaFieldSpec *field_spec,
+                      jobject java_obj, jsval js_val);
+extern JSBool 
+jsj_ReflectJavaFields(JSContext *cx, JNIEnv *jEnv,
+                      JavaClassDescriptor *class_descriptor,
+                      JSBool reflect_only_static_fields);
+extern void
+jsj_DestroyFieldSpec(JSContext *cx, JNIEnv *jEnv, JavaFieldSpec *field);
+
+/************************* Java method reflection ***************************/
+extern JSBool
+jsj_JavaInstanceMethodWrapper(JSContext *cx, JSObject *obj,
+                              uintN argc, jsval *argv, jsval *vp);
+extern JSBool
+jsj_JavaStaticMethodWrapper(JSContext *cx, JSObject *obj,
+                            uintN argc, jsval *argv, jsval *vp);
+extern JSBool
+jsj_JavaConstructorWrapper(JSContext *cx, JSObject *obj,
+                           uintN argc, jsval *argv, jsval *vp);
+extern JSBool 
+jsj_ReflectJavaMethods(JSContext *cx, JNIEnv *jEnv,
+                       JavaClassDescriptor *class_descriptor,
+                       JSBool reflect_only_static_methods);
+extern void
+jsj_DestroyMethodSpec(JSContext *cx, JNIEnv *jEnv, JavaMethodSpec *method_spec);
+
+/************************* Java member reflection ***************************/
+extern JSBool
+jsj_init_JavaMember(JSContext *, JSObject *);
+
+extern JSBool
+jsj_ReflectJavaMethodsAndFields(JSContext *cx, JavaClassDescriptor *class_descriptor,
+                                JSBool reflect_only_statics);
+
+extern JSObject *
+jsj_CreateJavaMember(JSContext *cx, jsval method_val, jsval field_val);
+
+/************************* Java object reflection **************************/
+extern JSBool
+jsj_init_JavaObject(JSContext *, JSObject *);
+
+extern JSObject *
+jsj_WrapJavaObject(JSContext *cx, JNIEnv *jEnv, jobject java_obj, jclass java_class);
+
+extern void
+jsj_DiscardJavaObjReflections(JNIEnv *jEnv);
+
+extern JSBool
+JavaObject_convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp);
+
+extern void
+JavaObject_finalize(JSContext *cx, JSObject *obj);
+
+extern JSBool
+JavaObject_resolve(JSContext *cx, JSObject *obj, jsval id);
+
+extern JSBool
+JavaObject_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
+
+extern JSBool
+JavaObject_getPropertyById(JSContext *cx, JSObject *obj, jsid id, jsval *vp);
+
+/************************* Java array reflection ***************************/
+extern JSBool
+jsj_init_JavaArray(JSContext *cx, JSObject *global_obj);
+
+extern JSBool
+jsj_GetJavaArrayElement(JSContext *cx, JNIEnv *jEnv, jarray java_array,
+                        jsize index, JavaSignature *array_component_signature,
+                        jsval *vp);
+   
+extern JSBool     
+jsj_SetJavaArrayElement(JSContext *cx, JNIEnv *jEnv, jarray java_array,
+                        jsize index, JavaSignature *array_component_signature,
+                        jsval js_val);
+
+/********************* JavaScript object reflection ************************/                        
+extern jobject
+jsj_WrapJSObject(JSContext *cx, JNIEnv *jEnv, JSObject *js_obj);
+
+extern JSObject *
+jsj_UnwrapJSObjectWrapper(JNIEnv *jEnv, jobject java_wrapper_obj);
+
+extern void
+jsj_ClearPendingJSErrors(JSJavaThreadState *jsj_env);
+
+extern JSBool
+jsj_ReportUncaughtJSException(JSContext *cx, JNIEnv *jEnv, jthrowable java_exception);
+
+/**************************** Utilities ************************************/
+extern void
+jsj_ReportJavaError(JSContext *cx, JNIEnv *env, const char *format, ...);
+
+extern void
+jsj_UnexpectedJavaError(JSContext *cx, JNIEnv *env, const char *format, ...);
+
+extern const char *
+jsj_GetJavaErrorMessage(JNIEnv *env);
+
+extern void
+jsj_LogError(const char *error_msg);
+
+PR_CALLBACK JSJHashNumber
+jsj_HashJavaObject(const void *key, void* env);
+
+PR_CALLBACK intN
+jsj_JavaObjectComparator(const void *v1, const void *v2, void *arg);
+
+extern JSJavaThreadState *
+jsj_MapJavaThreadToJSJavaThreadState(JNIEnv *jEnv, char **errp);
+
+extern void
+jsj_MakeJNIClassname(char *jClassName);
+
+extern const char *
+jsj_ClassNameOfJavaObject(JSContext *cx, JNIEnv *jEnv, jobject java_object);
+
+extern jsize
+jsj_GetJavaArrayLength(JSContext *cx, JNIEnv *jEnv, jarray java_array);
+
+extern JSBool
+JavaStringToId(JSContext *cx, JNIEnv *jEnv, jstring jstr, jsid *idp);
+
+extern const char *
+jsj_DupJavaStringUTF(JSContext *cx, JNIEnv *jEnv, jstring jstr);
+
+JSJavaThreadState *
+jsj_MapJSContextToJSJThread(JSContext *cx, JNIEnv **envp);
+
+JSJavaThreadState *
+jsj_SetJavaJSJEnv(JSJavaThreadState* java_jsj_env);
+
+#ifdef DEBUG
+#define DEBUG_LOG(args) printf args
+#endif
+
+#define JS_FREE_IF(cx, x)                                                   \
+    PR_BEGIN_MACRO                                                          \
+        if (x)                                                              \
+            JS_free(cx, x);                                                 \
+    PR_END_MACRO
+
+#endif   /* _JSJAVA_PVT_H */

mozilla/js/src/liveconnect/jsj_utils.c

@@ -0,0 +1,361 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains low-level utility code.
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jsj_private.h"        /* LiveConnect internals */
+#include "jsjava.h"             /* External LiveConnect API */
+
+
+/*
+ * This is a hash-table utility routine that computes the hash code of a Java
+ * object by calling java.lang.System.identityHashCode()
+ */
+PR_CALLBACK JSJHashNumber
+jsj_HashJavaObject(const void *key, void* env)
+{
+    PRHashNumber hash_code;
+    jobject java_obj;
+    JNIEnv *jEnv;
+
+    java_obj = (jobject)key;
+    jEnv = (JNIEnv*) env;
+    hash_code = (*jEnv)->CallStaticIntMethod(jEnv, jlSystem,
+                                             jlSystem_identityHashCode, java_obj);
+    PR_ASSERT(!(*jEnv)->ExceptionOccurred(jEnv));
+    return hash_code;
+}
+
+/* 
+ * This is a hash-table utility routine for comparing two Java objects.
+ * It's not possible to use the == operator to directly compare two jobject's,
+ * since they're opaque references and aren't guaranteed to be simple pointers
+ * or handles (though they may be in some JVM implementations).  Instead,
+ * use the JNI routine for comparing the two objects.
+ */
+PR_CALLBACK intN
+jsj_JavaObjectComparator(const void *v1, const void *v2, void *arg)
+{
+    jobject java_obj1, java_obj2;
+    JNIEnv *jEnv;
+
+    jEnv = (JNIEnv*)arg;
+    java_obj1 = (jobject)v1;
+    java_obj2 = (jobject)v2;
+
+    if (java_obj1 == java_obj2)
+        return 1;
+    return (*jEnv)->IsSameObject(jEnv, java_obj1, java_obj2);
+}
+
+/*
+ * Return a UTF8, null-terminated encoding of a Java string.  The string must
+ * be free'ed by the caller.
+ *
+ * If an error occurs, returns NULL and calls the JS error reporter.
+ */
+const char *
+jsj_DupJavaStringUTF(JSContext *cx, JNIEnv *jEnv, jstring jstr)
+{
+    const char *str, *retval;
+
+    str = (*jEnv)->GetStringUTFChars(jEnv, jstr, 0);
+    if (!str) {
+        jsj_UnexpectedJavaError(cx, jEnv, "Can't get UTF8 characters from "
+                                          "Java string");
+        return NULL;
+    }
+    retval = JS_strdup(cx, str);
+    (*jEnv)->ReleaseStringUTFChars(jEnv, jstr, str);
+    return retval;
+}
+
+JSBool
+JavaStringToId(JSContext *cx, JNIEnv *jEnv, jstring jstr, jsid *idp)
+{
+    const jschar *ucs2;
+    JSString *jsstr;
+    jsize ucs2_len;
+    jsval val;
+    
+    ucs2 = (*jEnv)->GetStringChars(jEnv, jstr, 0);
+    if (!ucs2) {
+        jsj_UnexpectedJavaError(cx, jEnv, "Couldn't obtain Unicode characters"
+                                "from Java string");
+        return JS_FALSE;
+    }
+    
+    ucs2_len = (*jEnv)->GetStringLength(jEnv, jstr);
+    jsstr = JS_InternUCStringN(cx, ucs2, ucs2_len);
+    (*jEnv)->ReleaseStringChars(jEnv, jstr, ucs2);
+    if (!jsstr)
+        return JS_FALSE;
+
+    val = STRING_TO_JSVAL(jsstr);
+    JS_ValueToId(cx, STRING_TO_JSVAL(jsstr), idp);
+    return JS_TRUE;
+}
+
+/* Not used ?
+const char *
+jsj_ClassNameOfJavaObject(JSContext *cx, JNIEnv *jEnv, jobject java_object)
+{
+    jobject java_class;
+
+    java_class = (*jEnv)->GetObjectClass(jEnv, java_object);
+
+    if (!java_class) {
+        PR_ASSERT(0);
+        return NULL;
+    }
+
+    return jsj_GetJavaClassName(cx, jEnv, java_class);
+}
+*/
+
+/*
+ * Return, as a C string, the error message associated with a Java exception
+ * that occurred as a result of a JNI call, preceded by the class name of
+ * the exception.  As a special case, if the class of the exception is
+ * netscape.javascript.JSException, the exception class name is omitted.
+ *
+ * NULL is returned if no Java exception is pending.  The caller is
+ * responsible for free'ing the returned string.  On exit, the Java exception
+ * is *not* cleared.
+ */
+const char *
+jsj_GetJavaErrorMessage(JNIEnv *jEnv)
+{
+    const char *java_error_msg;
+    char *error_msg = NULL;
+    jthrowable exception;
+    jstring java_exception_jstring;
+
+    exception = (*jEnv)->ExceptionOccurred(jEnv);
+    if (exception && jlThrowable_toString) {
+        java_exception_jstring =
+            (*jEnv)->CallObjectMethod(jEnv, exception, jlThrowable_toString);
+        java_error_msg = (*jEnv)->GetStringUTFChars(jEnv, java_exception_jstring, NULL);
+        error_msg = strdup((char*)java_error_msg);
+        (*jEnv)->ReleaseStringUTFChars(jEnv, java_exception_jstring, java_error_msg);
+
+#ifdef DEBUG
+        /* (*jEnv)->ExceptionDescribe(jEnv); */
+#endif
+    }
+    return error_msg;
+}    
+
+/*
+ * Return, as a C string, the JVM stack trace associated with a Java
+ * exception, as would be printed by java.lang.Throwable.printStackTrace().
+ * The caller is responsible for free'ing the returned string.
+ *
+ * Returns NULL if an error occurs.
+ */
+static const char *
+get_java_stack_trace(JSContext *cx, JNIEnv *jEnv, jthrowable java_exception)
+{
+    const char *backtrace;
+    jstring backtrace_jstr;
+
+    backtrace = NULL;
+    if (java_exception && njJSUtil_getStackTrace) {
+        backtrace_jstr = (*jEnv)->CallStaticObjectMethod(jEnv, njJSUtil,
+                                                         njJSUtil_getStackTrace,
+                                                         java_exception);
+        if (!backtrace_jstr) {
+            jsj_UnexpectedJavaError(cx, jEnv, "Unable to get exception stack trace");
+            return NULL;
+        }
+        backtrace = jsj_DupJavaStringUTF(cx, jEnv, backtrace_jstr);
+    }
+    return backtrace;
+} 
+
+/* Full Java backtrace when Java exceptions reported to JavaScript */
+#define REPORT_JAVA_EXCEPTION_STACK_TRACE
+
+/*
+ * This is a wrapper around JS_ReportError(), useful when an error condition
+ * is the result of a JVM failure or exception condition.  It appends the
+ * message associated with the pending Java exception to the passed in
+ * printf-style format string and arguments.
+ */
+static void
+vreport_java_error(JSContext *cx, JNIEnv *jEnv, const char *format, va_list ap)
+{
+    char *error_msg, *js_error_msg;
+    const char *java_stack_trace;
+    const char *java_error_msg;
+    jthrowable java_exception;
+        
+    java_error_msg = NULL;
+    java_exception = (*jEnv)->ExceptionOccurred(jEnv);
+    if (java_exception && njJSException && 
+        (*jEnv)->IsInstanceOf(jEnv, java_exception, njJSException)) {
+        (*jEnv)->ExceptionClear(jEnv);
+        jsj_ReportUncaughtJSException(cx, jEnv, java_exception);
+        return;
+    }
+
+    js_error_msg = PR_vsmprintf(format, ap);
+
+    if (!js_error_msg) {
+        PR_ASSERT(0);       /* Out-of-memory */
+        return;
+    }
+
+#ifdef REPORT_JAVA_EXCEPTION_STACK_TRACE
+
+    java_stack_trace = get_java_stack_trace(cx, jEnv, java_exception);
+    if (java_stack_trace) {
+        error_msg = PR_smprintf("%s\n%s", js_error_msg, java_stack_trace);
+        free((char*)java_stack_trace);
+        if (!error_msg) {
+            PR_ASSERT(0);       /* Out-of-memory */
+            return;
+        }
+    } else
+
+#endif
+    {
+        java_error_msg = jsj_GetJavaErrorMessage(jEnv);
+        if (java_error_msg) {
+            error_msg = PR_smprintf("%s (%s)\n", js_error_msg, java_error_msg);
+            free((char*)java_error_msg);
+            free(js_error_msg);
+        } else {
+            error_msg = js_error_msg;
+        }
+    }
+    
+    JS_ReportError(cx, error_msg);
+    
+    /* Important: the Java exception must not be cleared until the reporter
+       has been called, because the capture_js_error_reports_for_java(),
+       called from JS_ReportError(), needs to read the exception from the JVM */
+    (*jEnv)->ExceptionClear(jEnv);
+    free(error_msg);
+}
+
+void
+jsj_ReportJavaError(JSContext *cx, JNIEnv *env, const char *format, ...)
+{
+    va_list ap;
+
+    va_start(ap, format);
+    vreport_java_error(cx, env, format, ap);
+    va_end(ap);
+}
+
+/*
+ * Same as jsj_ReportJavaError, except "internal error: " is prepended
+ * to message.
+ */
+void
+jsj_UnexpectedJavaError(JSContext *cx, JNIEnv *env, const char *format, ...)
+{
+    va_list ap;
+    const char *format2;
+
+    va_start(ap, format);
+    format2 = PR_smprintf("internal error: %s", format);
+    if (format2) {
+        vreport_java_error(cx, env, format2, ap);
+        free((void*)format2);
+    }
+    va_end(ap);
+}
+
+/*
+ * Most LiveConnect errors are signaled by calling JS_ReportError(),
+ * but in some circumstances, the target JSContext for such errors
+ * is not determinable, e.g. during initialization.  In such cases
+ * any error messages are routed to this function.
+ */
+void
+jsj_LogError(const char *error_msg)
+{
+    if (JSJ_callbacks && JSJ_callbacks->error_print)
+        JSJ_callbacks->error_print(error_msg);
+    else
+        fputs(error_msg, stderr);
+}
+
+jsize
+jsj_GetJavaArrayLength(JSContext *cx, JNIEnv *jEnv, jarray java_array)
+{
+    jsize array_length = (*jEnv)->GetArrayLength(jEnv, java_array);
+    if ((*jEnv)->ExceptionOccurred(jEnv)) {
+        jsj_UnexpectedJavaError(cx, jEnv, "Couldn't obtain array length");
+        return -1;
+    }
+    return array_length;
+}
+
+static JSJavaThreadState *the_java_jsj_env = NULL;
+
+JSJavaThreadState *
+jsj_MapJSContextToJSJThread(JSContext *cx, JNIEnv **envp)
+{
+    JSJavaThreadState *jsj_env;
+    char *err_msg;
+
+    *envp = NULL;
+    err_msg = NULL;
+    
+    jsj_env = the_java_jsj_env;
+    if (jsj_env == NULL)
+	    jsj_env = JSJ_callbacks->map_js_context_to_jsj_thread(cx, &err_msg);
+    if (!jsj_env) {
+        if (err_msg) {
+            JS_ReportError(cx, err_msg);
+            free(err_msg);
+        }
+        return NULL;
+    }
+    if (envp)
+        *envp = jsj_env->jEnv;
+    return jsj_env;
+}
+
+/**
+ * Since only one Java thread is allowed to enter JavaScript, this function is
+ * used to enforce the use of that thread's state. The static global the_java_jsj_env
+ * overrides using JSJ_callbacks->map_js_context_to_jsj_thread, which maps
+ * native threads to JSJavaThreadStates. This isn't appropriate when Java calls
+ * JavaScript, as there can be a many to one mapping from Java threads to native
+ * threads.
+ */
+JSJavaThreadState *
+jsj_SetJavaJSJEnv(JSJavaThreadState* java_jsj_env)
+{
+    JSJavaThreadState *old_jsj_env = the_java_jsj_env;
+    the_java_jsj_env = java_jsj_env;
+    return old_jsj_env;
+}

mozilla/js/src/liveconnect/jsjava.h

@@ -0,0 +1,264 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this file except in
+ * compliance with the License.  You may obtain a copy of the License at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+ 
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * Publicly exported functions for JavaScript <==> Java communication.
+ *
+ */
+ 
+#ifndef _JSJAVA_H
+#define _JSJAVA_H
+
+#ifndef prtypes_h___
+#include "prtypes.h"
+#endif
+
+PR_BEGIN_EXTERN_C
+
+#include "jni.h"             /* Java Native Interface */
+#include "jsapi.h"           /* JavaScript engine API */
+
+/*
+ * A JSJavaVM structure is a wrapper around a JavaVM which incorporates
+ * additional LiveConnect state.
+ */
+typedef struct JSJavaVM JSJavaVM;
+
+/* LiveConnect and Java state, one per thread */
+typedef struct JSJavaThreadState JSJavaThreadState;
+
+/*
+ * An opaque type that represents the connection to the Java VM. In stand-alone
+ * Java environments, this may be a JNI JavaVM object; in the browser environment
+ * it is a reference to a JVM plugin. A set of callbacks in the JSJCallbacks
+ * struct allow it to be manipulated.
+ */
+typedef struct SystemJavaVM SystemJavaVM;
+
+/*
+ * This callback table provides hooks to external functions that implement
+ * functionality specific to the embedding.  For example, these callbacks are
+ * necessary in multi-threaded environments or to implement a security
+ * policy.
+ */
+typedef struct JSJCallbacks {
+
+    /* This callback is invoked when there is no JavaScript execution
+       environment (JSContext) associated with the current Java thread and
+       a call is made from Java into JavaScript.  (A JSContext is associated
+       with a Java thread by calling the JSJ_SetJSContextForJavaThread()
+       function.)  This callback is only invoked when Java spontaneously calls
+       into JavaScript, i.e. it is not called when JS calls into Java which
+       calls back into JS.
+       
+       This callback can be used to create a JSContext lazily, or obtain
+       one from a pool of available JSContexts.  The implementation of this
+       callback can call JSJ_SetJSContextForJavaThread() to avoid any further
+       callbacks of this type for this Java thread. */
+    JSContext *	        (*map_jsj_thread_to_js_context)(JSJavaThreadState *jsj_env,
+                                                        JNIEnv *jEnv,
+                                                        char **errp);
+
+    /* This callback is invoked whenever a call is made into Java from
+       JavaScript.  It's responsible for mapping from a JavaScript execution
+       environment (JSContext) to a Java thread.  (A JavaContext can only
+       be associated with one Java thread at a time.) */
+    JSJavaThreadState * (*map_js_context_to_jsj_thread)(JSContext *cx,
+                                                        char **errp);
+                                                        
+    /* This callback implements netscape.javascript.JSObject.getWindow(),
+       a method named for its behavior in the browser environment, where it
+       returns the JS "Window" object corresponding to the HTML window that an
+       applet is embedded within.  More generally, it's a way for Java to get
+       hold of a JS object that has not been explicitly passed to it. */
+    JSObject *	        (*map_java_object_to_js_object)(JNIEnv *jEnv, void *pJavaObject,
+                                                        char **errp);
+        
+    /* An interim callback function until the LiveConnect security story is
+       straightened out.  This function pointer can be set to NULL. */
+    JSPrincipals *      (*get_JSPrincipals_from_java_caller)(JNIEnv *jEnv, JSContext *pJSContext);
+    
+    /* The following two callbacks sandwich any JS evaluation performed
+       from Java.   They may be used to implement concurrency constraints, e.g.
+       by suspending the current thread until some condition is met.  In the
+       browser embedding, these are used to maintain the run-to-completion
+       semantics of JavaScript.  It is acceptable for either function pointer
+       to be NULL. */
+    JSBool	        (*enter_js_from_java)(JNIEnv *jEnv, char **errp);
+    void	        (*exit_js)(JNIEnv *jEnv);
+
+    /* Most LiveConnect errors are signaled by calling JS_ReportError(), but in
+       some circumstances, the target JSContext for such errors is not
+       determinable, e.g. during initialization.  In such cases any error
+       messages are routed to this function.  If the function pointer is set to
+       NULL, error messages are sent to stderr. */
+    void                (*error_print)(const char *error_msg);
+
+    /* This enables liveconnect to ask the VM for a java wrapper so that VM gets a chance to
+       store a mapping between a jsobject and java wrapper. So the unwrapping can be done on the
+       VM side before calling nsILiveconnect apis. This saves on a round trip request. */
+    jobject             (*get_java_wrapper)(JNIEnv *jEnv, jint jsobject);
+
+    /* The following set of methods abstract over the JavaVM object. */
+    PRBool              (*create_java_vm)(SystemJavaVM* *jvm, JNIEnv* *initialEnv, void* initargs);
+    PRBool              (*destroy_java_vm)(SystemJavaVM* jvm, JNIEnv* initialEnv);
+    JNIEnv*             (*attach_current_thread)(SystemJavaVM* jvm);
+    PRBool              (*detach_current_thread)(SystemJavaVM* jvm, JNIEnv* env);
+    SystemJavaVM*       (*get_java_vm)(JNIEnv* env);
+
+    /* Reserved for future use */
+    void *              reserved[10];
+} JSJCallbacks;
+
+/*===========================================================================*/
+
+/* A flag that denotes that a Java package has no sub-packages other than those
+   explicitly pre-defined at the time of initialization.  An access
+   to a simple name within such a package, therefore, must either correspond to
+   one of these explicitly pre-defined sub-packages or to a class within this
+   package.  It is reasonable for LiveConnect to signal an error if a simple
+   name does not comply with these criteria. */
+#define PKG_SYSTEM      1
+
+/* A flag that denotes that a Java package which might contain sub-packages
+   that are not pre-defined at initialization time, because the sub-packages
+   may not be the same in all installations.  Therefore, an access to a simple
+   name within such a a package which does not correspond to either a
+   pre-defined sub-package or to a class, must be assummed to refer to an
+   unknown sub-package.  This behavior may cause bogus JavaPackage objects to be
+   created if a package name is misspelled, e.g. sun.oi.net. */
+#define PKG_USER        2
+
+/* A Java package defined at initialization time. */
+typedef struct JavaPackageDef {
+    const char *        name;   /* e.g. "java.lang" */
+    const char *        path;   /* e.g. "java/lang", or NULL for default */
+    int                 flags;  /* PKG_USER, PKG_SYSTEM, etc. */
+} JavaPackageDef;
+
+/*===========================================================================*/
+
+/* The following two convenience functions present a complete, but simplified
+   LiveConnect API which is designed to handle the special case of a single 
+   Java-VM, with single-threaded operation, and the use of only one JSContext.
+   The full API is in the section below. */
+
+/* Initialize the provided JSContext by setting up the JS classes necessary for
+   reflection and by defining JavaPackage objects for the default Java packages
+   as properties of global_obj.  If java_vm is NULL, a new Java VM is
+   created, using the provided classpath in addition to any default classpath.
+   The classpath argument is ignored, however, if java_vm is non-NULL. */
+PR_IMPLEMENT(JSBool)
+JSJ_SimpleInit(JSContext *cx, JSObject *global_obj,
+               SystemJavaVM *java_vm, const char *classpath);
+
+/* Free up all resources.  Destroy the Java VM if it was created by LiveConnect */
+PR_IMPLEMENT(void)
+JSJ_SimpleShutdown();
+
+/*===========================================================================*/
+
+/* The "full" LiveConnect API, required when more than one thread, Java VM, or
+   JSContext is involved.  Initialization pseudocode might go roughly like
+   this:
+
+   JSJ_Init()   // Setup callbacks
+   for each JavaVM {
+      JSJ_ConnectToJavaVM(...)
+   }
+   for each JSContext {
+      JSJ_InitJSContext(...)
+   }
+   for each JS evaluation {
+      run JavaScript code in the JSContext;
+   }
+ */
+
+/* Called once for all instances of LiveConnect to set up callbacks */
+PR_IMPLEMENT(void)
+JSJ_Init(JSJCallbacks *callbacks);
+
+/* Called once per Java VM, this function initializes the classes, fields, and
+   methods required for Java reflection.  If java_vm is NULL, a new Java VM is
+   created according to the create_java_vm callback in the JSJCallbacks,
+   using the provided classpath in addition to any default initargs.
+   The initargs argument is ignored, however, if java_vm is non-NULL. */
+PR_IMPLEMENT(JSJavaVM *)
+JSJ_ConnectToJavaVM(SystemJavaVM *java_vm, void* initargs);
+
+/* Initialize the provided JSContext by setting up the JS classes necessary for
+   reflection and by defining JavaPackage objects for the default Java packages
+   as properties of global_obj.  Additional packages may be pre-defined by
+   setting the predefined_packages argument.  (Pre-defining a Java package at
+   initialization time is not necessary, but it will make package lookup faster
+   and, more importantly, will avoid unnecessary network accesses if classes
+   are being loaded over the network.) */
+PR_IMPLEMENT(JSBool)
+JSJ_InitJSContext(JSContext *cx, JSObject *global_obj,
+                  JavaPackageDef *predefined_packages);
+   
+/* This function returns a structure that encapsulates the Java and JavaScript
+   execution environment for the current native thread.  It is intended to
+   be called from the embedder's implementation of JSJCallback's
+   map_js_context_to_jsj_thread() function.  The thread_name argument is only
+   used for debugging purposes and can be set to NULL.  The Java JNI
+   environment associated with this thread is returned through the java_envp
+   argument if java_envp is non-NULL.  */
+PR_IMPLEMENT(JSJavaThreadState *)
+JSJ_AttachCurrentThreadToJava(JSJavaVM *jsjava_vm, const char *thread_name,
+                              JNIEnv **java_envp);
+
+/* Destructor routine for per-thread JSJavaThreadState structure */
+PR_IMPLEMENT(JSBool)
+JSJ_DetachCurrentThreadFromJava(JSJavaThreadState *jsj_env);
+
+/* This function is used to specify a particular JSContext as *the* JavaScript
+   execution environment to be used when LiveConnect is accessed from the given
+   Java thread, i.e. when one of the methods of netscape.javascript.JSObject
+   has been called.  There can only be one such JS context for any given Java
+   thread at a time.  (To multiplex JSContexts among a single thread, this
+   function could be called before Java is invoked on that thread.)  The return
+   value is the previous JSContext associated with the given Java thread.
+
+   If this function has not been called for a thread and a crossing is made
+   into JavaScript from Java, the map_jsj_thread_to_js_context() callback will
+   be invoked to determine the JSContext for the thread.  The purpose of the 
+   function is to improve performance by avoiding the expense of the callback.
+*/
+PR_IMPLEMENT(JSContext *)
+JSJ_SetDefaultJSContextForJavaThread(JSContext *cx, JSJavaThreadState *jsj_env);
+
+/* This routine severs the connection to a Java VM, freeing all related resources.
+   It shouldn't be called until the global scope has been cleared in all related
+   JSContexts (so that all LiveConnect objects are finalized) and a JavaScript
+   GC is performed.  Otherwise, accessed to free'ed memory could result. */
+PR_IMPLEMENT(void)
+JSJ_DisconnectFromJavaVM(JSJavaVM *);
+
+/*
+ * Reflect a Java object into a JS value.  The source object, java_obj, must
+ * be of type java.lang.Object or a subclass and may, therefore, be an array.
+ */
+PR_IMPLEMENT(JSBool)
+JSJ_ConvertJavaObjectToJSValue(JSContext *cx, jobject java_obj, jsval *vp);
+
+PR_END_EXTERN_C
+#endif  /* _JSJAVA_H */

mozilla/js/src/liveconnect/makefile.win

@@ -0,0 +1,182 @@
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+IGNORE_MANIFEST=1
+
+#//------------------------------------------------------------------------
+#//
+#// Makefile to build the Java reflections of JavaScript objects
+#//
+#//------------------------------------------------------------------------
+
+
+#//------------------------------------------------------------------------
+#//
+#// Specify the depth of the current directory relative to the
+#// root of NS
+#//
+#//------------------------------------------------------------------------
+DEPTH= ..\..\..
+
+include <$(DEPTH)/config/config.mak>
+
+!ifdef NSJVM
+DIRS = classes
+!endif
+
+
+#//------------------------------------------------------------------------
+#//
+#// Define any Public Make Variables here: (ie. PDFFILE, MAPFILE, ...)
+#//
+#//------------------------------------------------------------------------
+DLLNAME=jsj$(MOZ_BITS)$(VERSION_NUMBER)
+PDBFILE=$(DLLNAME).pdb
+MAPFILE		= $(DLLNAME).map
+RESFILE		= jsj1640.res
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
+MAKE_OBJ_TYPE	= DLL
+
+!if "$(MOZ_BITS)" == "16"
+DEFFILE		= $(DLLNAME).def
+!endif
+
+LLIBS=$(LIBNSPR) $(DIST)\lib\js$(MOZ_BITS)$(VERSION_NUMBER).lib \
+ $(DIST)\lib\xpcom32.lib	
+
+!if "$(MOZ_BITS)"=="32" && defined(MOZ_DEBUG) && defined(GLOWCODE)
+LLIBS=$(LLIBS) $(GLOWDIR)\glowcode.lib
+!endif
+
+#//------------------------------------------------------------------------
+#// 
+#// Define the files necessary to build the target (ie. OBJS)
+#//
+#//------------------------------------------------------------------------
+OBJS=                                       \
+    .\$(OBJDIR)\jsj.obj                     \
+    .\$(OBJDIR)\jsj_JSObject.obj            \
+    .\$(OBJDIR)\jsj_JavaArray.obj           \
+    .\$(OBJDIR)\jsj_JavaClass.obj           \
+    .\$(OBJDIR)\jsj_JavaMember.obj          \
+    .\$(OBJDIR)\jsj_JavaObject.obj          \
+    .\$(OBJDIR)\jsj_JavaPackage.obj         \
+    .\$(OBJDIR)\jsj_array.obj               \
+    .\$(OBJDIR)\jsj_class.obj               \
+    .\$(OBJDIR)\jsj_convert.obj             \
+    .\$(OBJDIR)\jsj_field.obj               \
+    .\$(OBJDIR)\jsj_hash.obj                \
+    .\$(OBJDIR)\jsj_method.obj              \
+    .\$(OBJDIR)\jsj_utils.obj               \
+    .\$(OBJDIR)\nsCLiveconnect.obj          \
+    .\$(OBJDIR)\nsCLiveconnectFactory.obj   \
+!if "$(MOZ_BITS)" == "16"
+    .\$(OBJDIR)\jsj_nodl.obj                \
+!endif
+    $(NULL)
+
+#//------------------------------------------------------------------------
+#//
+#// install headers
+#//
+#//------------------------------------------------------------------------
+INSTALL_DIR=$(PUBLIC)\js
+INSTALL_FILE_LIST=	\
+	jsjava.h nsILiveconnect.h
+
+#//------------------------------------------------------------------------
+#//
+#// Define any Public Targets here (ie. PROGRAM, LIBRARY, DLL, ...)
+#// (these must be defined before the common makefiles are included)
+#//		  
+#//------------------------------------------------------------------------
+
+!ifdef NSJVM
+JNI_GEN=                            \
+        netscape.javascript.JSObject            \
+        netscape.javascript.JSException         \
+	$(NULL)
+
+!endif
+
+MODULE = java
+EXPORTS =				       \
+ 	$(JNI_GEN_DIR)\netscape_javascript_JSObject.h    \
+ 	$(JNI_GEN_DIR)\netscape_javascript_JSException.h \
+	$(NULL)
+
+
+#//------------------------------------------------------------------------
+#//
+#// Define any local options for the make tools 
+#//     (ie. LCFLAGS, LLFLAGS, LLIBS, LINCS)
+#//
+#//------------------------------------------------------------------------
+
+LINCS=$(LINCS) -I$(JNI_GEN_DIR) \
+               -I$(PUBLIC)\js \
+               -I$(PUBLIC)\java \
+               -I$(PUBLIC)\xpcom \
+	$(NULL)
+
+
+#!ifdef SERVER_BUILD
+#LLIBS=$(DIST)/lib/httpdlw.lib $(DIST)/lib/libsjboot.lib
+#!endif
+
+#//------------------------------------------------------------------------
+#//
+#// Include the common makefile rules
+#//
+#//------------------------------------------------------------------------
+include <$(DEPTH)/config/rules.mak>
+
+export::  INSTALL_FILES
+
+libs::  $(DLL)
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).dll $(DIST)\bin
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
+
+
+####
+# this bit of extreme scariness came from the js/src makefile
+#  reproduced here since that's where jsjava.c lives now...
+
+!if ("$(MOZ_BITS)" == "16") 
+#//
+#// Win16 Hoovers SO BAD!!!   
+#//
+
+!if !defined(MOZ_DEBUG)
+#//
+#// We must turn off codeview debug info so jni.c can build.  
+#// Otherwise the linker gives errors about data in the $SYMBOLS 
+#// segment being beyond a segment boundary.
+#//
+$(OBJDIR)\jsjava.obj: jsjava.c
+    @$(CC) @<<$(CFGFILE)
+        -c 
+        -Od 
+        $(CFLAGS)
+        $(LCFLAGS)
+        $(LINCS) 
+        $(LINCS_1) 
+        $(INCS)
+        -Fd$(PDBFILE)
+        -Fo.\$(OBJDIR)\
+        $(*B).c
+<<KEEP
+!endif
+!endif

mozilla/js/src/liveconnect/netscape_javascript_JSObject.h

@@ -0,0 +1,111 @@
+/* -*- Mode: C; tab-width: 8 -*-
+ * Copyright (C) 1998 Netscape Communications Corporation, All Rights Reserved.
+ */
+#include <jni.h>
+/* Header for class netscape_javascript_JSObject */
+
+#ifndef _Included_netscape_javascript_JSObject
+#define _Included_netscape_javascript_JSObject
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    initClass
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_netscape_javascript_JSObject_initClass
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    getMember
+ * Signature: (Ljava/lang/String;)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_netscape_javascript_JSObject_getMember
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    getSlot
+ * Signature: (I)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_netscape_javascript_JSObject_getSlot
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    setMember
+ * Signature: (Ljava/lang/String;Ljava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_netscape_javascript_JSObject_setMember
+  (JNIEnv *, jobject, jstring, jobject);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    setSlot
+ * Signature: (ILjava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_netscape_javascript_JSObject_setSlot
+  (JNIEnv *, jobject, jint, jobject);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    removeMember
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_netscape_javascript_JSObject_removeMember
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    call
+ * Signature: (Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_netscape_javascript_JSObject_call
+  (JNIEnv *, jobject, jstring, jobjectArray);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    eval
+ * Signature: (Ljava/lang/String;)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_netscape_javascript_JSObject_eval
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    toString
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_netscape_javascript_JSObject_toString
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    getWindow
+ * Signature: (Ljava/applet/Applet;)Lnetscape/javascript/JSObject;
+ */
+JNIEXPORT jobject JNICALL Java_netscape_javascript_JSObject_getWindow
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    finalize
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_netscape_javascript_JSObject_finalize
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     netscape_javascript_JSObject
+ * Method:    equals
+ * Signature: (Ljava/lang/Object;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_netscape_javascript_JSObject_equals
+  (JNIEnv *, jobject, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

mozilla/js/src/liveconnect/nsCLiveconnect.cpp

@@ -0,0 +1,567 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the implementation providing nsIFactory XP-COM interface.
+ *
+ */
+
+
+#include <stdlib.h>
+#include <string.h>
+#include "prtypes.h"
+#include "prprf.h"
+#include "prlog.h"
+PR_BEGIN_EXTERN_C
+
+#ifdef XP_MAC
+#include "prosdep.h"
+#endif
+
+#include "jsj_private.h"
+#include "jsjava.h"
+
+#include "jscntxt.h"        /* For js_ReportErrorAgain().
+                               TODO - get rid of private header */
+
+#include "netscape_javascript_JSObject.h"   /* javah-generated headers */
+
+
+/* A captured JavaScript error, created when JS_ReportError() is called while
+   running JavaScript code that is itself called from Java. */
+struct CapturedJSError {
+    char *              message;
+    JSErrorReport       report;         /* Line # of error, etc. */
+    jthrowable          java_exception; /* Java exception, error, or null */
+    CapturedJSError *   next;                   /* Next oldest captured JS error */
+};
+PR_END_EXTERN_C
+
+#include "nsCLiveconnect.h"
+
+static NS_DEFINE_IID(kILiveconnectIID, NS_ILIVECONNECT_IID);
+static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
+
+
+////////////////////////////////////////////////////////////////////////////
+// from nsISupports and AggregatedQueryInterface:
+
+// Thes macro expands to the aggregated query interface scheme.
+
+NS_IMPL_AGGREGATED(nsCLiveconnect);
+
+NS_METHOD
+nsCLiveconnect::AggregatedQueryInterface(const nsIID& aIID, void** aInstancePtr)
+{
+    if (aIID.Equals(kISupportsIID)) {
+      *aInstancePtr = GetInner();
+      AddRef();
+      return NS_OK;
+    }
+    if (aIID.Equals(kILiveconnectIID)) {
+        *aInstancePtr = this;
+        AddRef();
+        return NS_OK;
+    }
+    return NS_NOINTERFACE;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// from nsILiveconnect:
+
+/**
+ * get member of a Native JSObject for a given name.
+ *
+ * @param jEnv       - JNIEnv on which the call is being made.
+ * @param obj        - A Native JS Object.
+ * @param name       - Name of a member.
+ * @param pjobj      - return parameter as a java object representing 
+ *                     the member. If it is a basic data type it is converted to
+ *                     a corresponding java type. If it is a NJSObject, then it is
+ *                     wrapped up as java wrapper netscape.javascript.JSObject.
+ */
+NS_METHOD	
+nsCLiveconnect::GetMember(JNIEnv *jEnv, jsobject obj, const char *name, jobject *pjobj)
+{
+    JSContext         *cx             = NULL;
+    JSJavaThreadState *jsj_env        = NULL;
+    JSObject          *js_obj         = (JSObject *)obj;
+    nsresult           err            = NS_OK;
+    jobject            member         = NULL;
+    jsval              js_val         = NULL;
+    int                dummy_cost     = 0;
+    JSBool             dummy_bool     = PR_FALSE;
+    JavaToJSSavedState saved_state    = {NULL,NULL};
+
+    if(jEnv == NULL)
+    {
+       return NS_ERROR_FAILURE;
+    }
+    jsj_env = jsj_enter_js(jEnv, NULL, &cx, NULL, &saved_state);
+    if (!jsj_env)
+        return NS_ERROR_FAILURE;
+
+    if (!name) {
+        JS_ReportError(cx, "illegal null member name");
+        member = NULL;
+        goto done;
+    }
+
+    
+    if (!JS_GetProperty(cx, js_obj, name, &js_val))
+        goto done;
+
+    jsj_ConvertJSValueToJavaObject(cx, jEnv, js_val, jsj_get_jlObject_descriptor(cx, jEnv),
+                                   &dummy_cost, &member, &dummy_bool);
+
+done:
+    if (!jsj_exit_js(cx, jsj_env, &saved_state))
+        return NS_ERROR_FAILURE;
+    
+    *pjobj = member;
+
+    return NS_OK;
+}
+
+
+/**
+ * get member of a Native JSObject for a given index.
+ *
+ * @param jEnv       - JNIEnv on which the call is being made.
+ * @param obj        - A Native JS Object.
+ * @param index      - Index of a member.
+ * @param pjobj      - return parameter as a java object representing 
+ *                     the member. 
+ */
+NS_METHOD	
+nsCLiveconnect::GetSlot(JNIEnv *jEnv, jsobject obj, int slot, jobject *pjobj)
+{
+    JSContext         *cx             = NULL;
+    JSJavaThreadState *jsj_env        = NULL;
+    JSObject          *js_obj         = (JSObject *)obj;
+    nsresult           err            = NS_OK;
+    jobject            member         = NULL;
+    jsval              js_val         = NULL;
+    int                dummy_cost     = 0;
+    JSBool             dummy_bool     = PR_FALSE;
+    JavaToJSSavedState saved_state    = {NULL,NULL};
+
+    if(jEnv == NULL)
+    {
+       return NS_ERROR_FAILURE;
+    }
+    jsj_env = jsj_enter_js(jEnv, NULL, &cx, NULL, &saved_state);
+    if (!jsj_env)
+       return NS_ERROR_FAILURE;
+    
+    // =-= sudu: check to see if slot can be passed in as is.
+    //           Should it be converted to a jsint?
+    if (!JS_GetElement(cx, js_obj, slot, &js_val))
+        goto done;
+    if (!jsj_ConvertJSValueToJavaObject(cx, jEnv, js_val, jsj_get_jlObject_descriptor(cx, jEnv),
+                                        &dummy_cost, &member, &dummy_bool))
+        goto done;
+
+done:
+    if (!jsj_exit_js(cx, jsj_env, &saved_state))
+       return NS_ERROR_FAILURE;
+    
+    *pjobj = member;
+    return NS_OK;
+}
+
+/**
+ * set member of a Native JSObject for a given name.
+ *
+ * @param jEnv       - JNIEnv on which the call is being made.
+ * @param obj        - A Native JS Object.
+ * @param name       - Name of a member.
+ * @param jobj       - Value to set. If this is a basic data type, it is converted
+ *                     using standard JNI calls but if it is a wrapper to a JSObject
+ *                     then a internal mapping is consulted to convert to a NJSObject.
+ */
+NS_METHOD	
+nsCLiveconnect::SetMember(JNIEnv *jEnv, jsobject obj, const char *name, jobject java_obj)
+{
+    JSContext         *cx             = NULL;
+    JSJavaThreadState *jsj_env        = NULL;
+    JSObject          *js_obj         = (JSObject *)obj;
+    nsresult           err            = NS_OK;
+    jobject            member         = NULL;
+    jsval              js_val         = NULL;
+    JavaToJSSavedState saved_state    = {NULL,NULL};
+
+    if(jEnv == NULL)
+    {
+       return NS_ERROR_FAILURE;
+    }
+    
+    jsj_env = jsj_enter_js(jEnv, NULL, &cx, NULL, &saved_state);
+    if (!jsj_env)
+        return NS_ERROR_FAILURE;
+    
+    if (!name) {
+        JS_ReportError(cx, "illegal null member name");
+        goto done;
+    }
+
+    if (!jsj_ConvertJavaObjectToJSValue(cx, jEnv, java_obj, &js_val))
+        goto done;
+
+    JS_SetProperty(cx, js_obj, name, &js_val);
+
+done:
+    jsj_exit_js(cx, jsj_env, &saved_state);
+   return NS_OK;
+}
+
+
+/**
+ * set member of a Native JSObject for a given index.
+ *
+ * @param jEnv       - JNIEnv on which the call is being made.
+ * @param obj        - A Native JS Object.
+ * @param index      - Index of a member.
+ * @param jobj       - Value to set. If this is a basic data type, it is converted
+ *                     using standard JNI calls but if it is a wrapper to a JSObject
+ *                     then a internal mapping is consulted to convert to a NJSObject.
+ */
+NS_METHOD	
+nsCLiveconnect::SetSlot(JNIEnv *jEnv, jsobject obj, int slot, jobject java_obj)
+{
+    JSContext         *cx             = NULL;
+    JSJavaThreadState *jsj_env        = NULL;
+    JSObject          *js_obj         = (JSObject *)obj;
+    nsresult           err            = NS_OK;
+    jsval              js_val         = NULL;
+    JavaToJSSavedState saved_state    = {NULL,NULL};
+
+    if(jEnv == NULL)
+    {
+       return NS_ERROR_FAILURE;
+    }
+    jsj_env = jsj_enter_js(jEnv, NULL, &cx, NULL, &saved_state);
+    if (!jsj_env)
+        return NS_ERROR_FAILURE;
+    
+    if (!jsj_ConvertJavaObjectToJSValue(cx, jEnv, java_obj, &js_val))
+        goto done;
+    JS_SetElement(cx, js_obj, slot, &js_val);
+
+done:
+    jsj_exit_js(cx, jsj_env, &saved_state);
+    return NS_OK;
+}
+
+
+/**
+ * remove member of a Native JSObject for a given name.
+ *
+ * @param jEnv       - JNIEnv on which the call is being made.
+ * @param obj        - A Native JS Object.
+ * @param name       - Name of a member.
+ */
+NS_METHOD	
+nsCLiveconnect::RemoveMember(JNIEnv *jEnv, jsobject obj, const char *name)
+{
+    JSContext         *cx             = NULL;
+    JSJavaThreadState *jsj_env        = NULL;
+    JSObject          *js_obj         = (JSObject *)obj;
+    nsresult           err            = NS_OK;
+    jsval              js_val         = NULL;
+    JavaToJSSavedState saved_state    = {NULL,NULL};
+
+    if(jEnv == NULL)
+    {
+       return NS_ERROR_FAILURE;
+    }
+    jsj_env = jsj_enter_js(jEnv, NULL, &cx, NULL, &saved_state);
+    if (!jsj_env)
+        return NS_ERROR_FAILURE;
+    
+    if (!name) {
+        JS_ReportError(cx, "illegal null member name");
+        goto done;
+    }
+    JS_DeleteProperty2(cx, js_obj, name, &js_val);
+
+done:
+    jsj_exit_js(cx, jsj_env, &saved_state);
+    return NS_OK;
+}
+
+
+/**
+ * call a method of Native JSObject. 
+ *
+ * @param jEnv       - JNIEnv on which the call is being made.
+ * @param obj        - A Native JS Object.
+ * @param name       - Name of a method.
+ * @param jobjArr    - Array of jobjects representing parameters of method being caled.
+ * @param pjobj      - return value.
+ */
+NS_METHOD	
+nsCLiveconnect::Call(JNIEnv *jEnv, jsobject obj, const char *name, jobjectArray java_args, jobject *pjobj)
+{
+    int                i              = 0;
+    int                argc           = 0;
+    int                arg_num        = 0;
+    jsval             *argv           = 0;
+    JSContext         *cx             = NULL;
+    JSJavaThreadState *jsj_env        = NULL;
+    JSObject          *js_obj         = (JSObject *)obj;
+    nsresult           err            = NS_OK;
+    jobject            member         = NULL;
+    jsval              js_val         = NULL;
+    jsval              function_val   = NULL;
+    int                dummy_cost     = 0;
+    JSBool             dummy_bool     = PR_FALSE;
+    JavaToJSSavedState saved_state    = {NULL,NULL};
+    jobject            result         = NULL;
+
+    if(jEnv == NULL)
+    {
+       return NS_ERROR_FAILURE;
+    }
+    jsj_env = jsj_enter_js(jEnv, NULL, &cx, NULL, &saved_state);
+    if (!jsj_env)
+        return NS_ERROR_FAILURE;
+    
+    result = NULL;
+    if (!name) {
+        JS_ReportError(cx, "illegal null JavaScript function name");
+        goto done;
+    }
+
+    
+    /* FIXME: What about security stuff ? Don't principals need to be set here ? */
+
+    /* Allocate space for JS arguments */
+    if (java_args) {
+        argc = jEnv->GetArrayLength(java_args);
+        argv = (jsval*)JS_malloc(cx, argc * sizeof(jsval));
+    } else {
+        argc = 0;
+        argv = 0;
+    }
+
+    /* Convert arguments from Java to JS values */
+    for (arg_num = 0; arg_num < argc; arg_num++) {
+        jobject arg = jEnv->GetObjectArrayElement(java_args, arg_num);
+
+        if (!jsj_ConvertJavaObjectToJSValue(cx, jEnv, arg, &argv[arg_num]))
+            goto cleanup_argv;
+        JS_AddRoot(cx, &argv[arg_num]);
+    }
+
+    if (!JS_GetProperty(cx, js_obj, name, &function_val))
+        goto cleanup_argv;
+
+    if (!JS_CallFunctionValue(cx, js_obj, function_val, argc, argv, &js_val))
+        goto cleanup_argv;
+
+    jsj_ConvertJSValueToJavaObject(cx, jEnv, js_val, jsj_get_jlObject_descriptor(cx, jEnv),
+                                   &dummy_cost, &result, &dummy_bool);
+
+cleanup_argv:
+    if (argv) {
+        for (i = 0; i < arg_num; i++)
+            JS_RemoveRoot(cx, &argv[i]);
+        JS_free(cx, argv);
+    }
+
+done:
+    if (!jsj_exit_js(cx, jsj_env, &saved_state))
+        return NS_ERROR_FAILURE;
+    
+    *pjobj = result;
+
+    return NS_OK;
+}
+
+
+/**
+ * Evaluate a script with a Native JS Object representing scope.
+ *
+ * @param jEnv       - JNIEnv on which the call is being made.
+ * @param obj                - A Native JS Object.
+ * @param pNSIPrincipaArray  - Array of principals to be used to compare privileges.
+ * @param numPrincipals      - Number of principals being passed.
+ * @param script             - Script to be executed.
+ * @param pjobj              - return value.
+ */
+NS_METHOD	
+nsCLiveconnect::Eval(JNIEnv *jEnv, jsobject obj, const char *script, jobject *pjobj)
+{
+    JSContext         *cx             = NULL;
+    JSJavaThreadState *jsj_env        = NULL;
+    JSObject          *js_obj         = (JSObject *)obj;
+    nsresult           err            = NS_OK;
+    jobject            member         = NULL;
+    jsval              js_val         = NULL;
+    jsval              function_val   = NULL;
+    int                dummy_cost     = 0;
+    JSBool             dummy_bool     = PR_FALSE;
+    JavaToJSSavedState saved_state    = {NULL,NULL};
+    jobject            result         = NULL;
+	   const char		      *codebase       = NULL;
+    JSPrincipals      *principals     = NULL;
+    JSBool             eval_succeeded = PR_FALSE;
+
+    if(jEnv == NULL)
+    {
+       return NS_ERROR_FAILURE;
+    }
+    jsj_env = jsj_enter_js(jEnv, NULL, &cx, NULL, &saved_state);
+    if (!jsj_env)
+        return NULL;
+    
+    result = NULL;
+    if (!script) {
+        JS_ReportError(cx, "illegal null string eval argument");
+        goto done;
+    }
+
+    
+    /* Set up security stuff */
+    principals = NULL;
+    if (JSJ_callbacks->get_JSPrincipals_from_java_caller)
+        principals = JSJ_callbacks->get_JSPrincipals_from_java_caller(jEnv, cx);
+    codebase = principals ? principals->codebase : NULL;
+
+    /* Have the JS engine evaluate the unicode string */
+    eval_succeeded = JS_EvaluateScriptForPrincipals(cx, js_obj, principals,
+                                                      script, strlen(script),
+                                                      codebase, 0, &js_val);
+    if (!eval_succeeded)
+        goto done;
+
+    /* Convert result to a subclass of java.lang.Object */
+    jsj_ConvertJSValueToJavaObject(cx, jEnv, js_val, jsj_get_jlObject_descriptor(cx, jEnv),
+                                   &dummy_cost, &result, &dummy_bool);
+
+done:
+    if (!jsj_exit_js(cx, jsj_env, &saved_state))
+        return NULL;
+    
+    *pjobj = result;
+    return NS_OK;
+}
+
+
+/**
+ * Get the window object for a plugin instance.
+ *
+ * @param jEnv               - JNIEnv on which the call is being made.
+ * @param pJavaObject        - Either a jobject or a pointer to a plugin instance 
+ *                             representing the java object.
+ * @param pjobj              - return value. This is a native js object 
+ *                             representing the window object of a frame 
+ *                             in which a applet/bean resides.
+ */
+NS_METHOD	
+nsCLiveconnect::GetWindow(JNIEnv *jEnv, void *pJavaObject, jsobject *pobj)
+{
+    char              *err_msg        = NULL;
+    JSContext         *cx             = NULL;
+    JSObject          *js_obj         = NULL;
+    jsval              js_val         = NULL;
+    int                dummy_cost     = 0;
+    JSBool             dummy_bool     = PR_FALSE;
+    JavaToJSSavedState saved_state    = {NULL,NULL};
+    jobject            java_obj         = NULL;
+    JSJavaThreadState *jsj_env        = NULL;
+
+    if(jEnv == NULL)
+    {
+       return NS_ERROR_FAILURE;
+    }
+    jsj_env = jsj_enter_js(jEnv, NULL, &cx, NULL, &saved_state);
+    if (!jsj_env)
+        return NULL;
+    
+    err_msg = NULL;
+    java_obj = NULL;
+    js_obj = JSJ_callbacks->map_java_object_to_js_object(jEnv, pJavaObject, &err_msg);
+    if (!js_obj) {
+        if (err_msg) {
+            JS_ReportError(cx, err_msg);
+            free(err_msg);
+        }
+        goto done;
+    }
+#if 0
+    js_val = OBJECT_TO_JSVAL(js_obj);
+    jsj_ConvertJSValueToJavaObject(cx, jEnv, js_val, jsj_get_jlObject_descriptor(cx, jEnv),
+                                   &dummy_cost, &java_obj, &dummy_bool);
+#endif
+done:
+    if (!jsj_exit_js(cx, jsj_env, &saved_state))
+        return NULL;
+    
+    //*pjobj = java_obj;
+    *pobj = (jint)js_obj;
+    return NS_OK;
+}
+
+/**
+ * Get the window object for a plugin instance.
+ *
+ * @param jEnv       - JNIEnv on which the call is being made.
+ * @param obj        - A Native JS Object.
+ */
+NS_METHOD	
+nsCLiveconnect::FinalizeJSObject(JNIEnv *jEnv, jsobject obj)
+{
+    JSContext         *cx             = NULL;
+    JavaToJSSavedState saved_state    = {NULL,NULL};
+    JSJavaThreadState *jsj_env        = NULL;
+    JSObject          *js_obj         = (JSObject *)obj;
+    
+    if(jEnv == NULL)
+    {
+       return NS_ERROR_FAILURE;
+    }
+    jsj_env = jsj_enter_js(jEnv, NULL, &cx, NULL, &saved_state);
+    if (!jsj_env)   /* Note: memory leak if we exit here */
+        return NS_ERROR_FAILURE;
+#ifdef PRESERVE_JSOBJECT_IDENTITY
+    jsj_remove_js_obj_reflection_from_hashtable(cx, js_obj);
+#endif  /* PRESERVE_JSOBJECT_IDENTITY */
+    jsj_exit_js(cx, jsj_env, &saved_state);
+    return NS_OK;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// from nsCLiveconnect:
+
+nsCLiveconnect::nsCLiveconnect(nsISupports *aOuter)
+{
+    NS_INIT_AGGREGATED(aOuter);
+    jsj_init_js_obj_reflections_table();
+}
+
+nsCLiveconnect::~nsCLiveconnect()
+{
+}
+

mozilla/js/src/liveconnect/nsCLiveconnect.h

@@ -0,0 +1,166 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains class definition implementing the public interface.
+ *
+ */
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the class definition to implement nsILiveconnect XP-COM interface.
+ *
+ */
+
+
+#ifndef nsCLiveconnect_h___
+#define nsCLiveconnect_h___
+
+#include "nsILiveconnect.h"
+#include "nsAgg.h"
+
+
+/**
+ * nsCLiveconnect implements nsILiveconnect interface for navigator.
+ * This is used by a JVM to implement netscape.javascript.JSObject functionality.
+ */
+class nsCLiveconnect :public nsILiveconnect {
+public:
+    ////////////////////////////////////////////////////////////////////////////
+    // from nsISupports and AggregatedQueryInterface:
+
+    NS_DECL_AGGREGATED
+
+    ////////////////////////////////////////////////////////////////////////////
+    // from nsILiveconnect:
+
+    /**
+     * get member of a Native JSObject for a given name.
+     *
+     * @param obj        - A Native JS Object.
+     * @param name       - Name of a member.
+     * @param pjobj      - return parameter as a java object representing 
+     *                     the member. If it is a basic data type it is converted to
+     *                     a corresponding java type. If it is a NJSObject, then it is
+     *                     wrapped up as java wrapper netscape.javascript.JSObject.
+     */
+    NS_IMETHOD	
+    GetMember(JNIEnv *jEnv, jsobject obj, const char *name, jobject *pjobj);
+
+    /**
+     * get member of a Native JSObject for a given index.
+     *
+     * @param obj        - A Native JS Object.
+     * @param index      - Index of a member.
+     * @param pjobj      - return parameter as a java object representing 
+     *                     the member. 
+     */
+    NS_IMETHOD	
+    GetSlot(JNIEnv *jEnv, jsobject obj, int index, jobject *pjobj);
+
+    /**
+     * set member of a Native JSObject for a given name.
+     *
+     * @param obj        - A Native JS Object.
+     * @param name       - Name of a member.
+     * @param jobj       - Value to set. If this is a basic data type, it is converted
+     *                     using standard JNI calls but if it is a wrapper to a JSObject
+     *                     then a internal mapping is consulted to convert to a NJSObject.
+     */
+    NS_IMETHOD	
+    SetMember(JNIEnv *jEnv, jsobject obj, const char *name, jobject jobj);
+
+    /**
+     * set member of a Native JSObject for a given index.
+     *
+     * @param obj        - A Native JS Object.
+     * @param index      - Index of a member.
+     * @param jobj       - Value to set. If this is a basic data type, it is converted
+     *                     using standard JNI calls but if it is a wrapper to a JSObject
+     *                     then a internal mapping is consulted to convert to a NJSObject.
+     */
+    NS_IMETHOD	
+    SetSlot(JNIEnv *jEnv, jsobject obj, int slot, jobject jobj);
+
+    /**
+     * remove member of a Native JSObject for a given name.
+     *
+     * @param obj        - A Native JS Object.
+     * @param name       - Name of a member.
+     */
+    NS_IMETHOD	
+    RemoveMember(JNIEnv *jEnv, jsobject obj, const char *name);
+
+    /**
+     * call a method of Native JSObject. 
+     *
+     * @param obj        - A Native JS Object.
+     * @param name       - Name of a method.
+     * @param jobjArr    - Array of jobjects representing parameters of method being caled.
+     * @param pjobj      - return value.
+     */
+    NS_IMETHOD	
+    Call(JNIEnv *jEnv, jsobject obj, const char *name, jobjectArray jobjArr, jobject *pjobj);
+
+    /**
+     * Evaluate a script with a Native JS Object representing scope.
+     *
+     * @param obj                - A Native JS Object.
+     * @param pNSIPrincipaArray  - Array of principals to be used to compare privileges.
+     * @param numPrincipals      - Number of principals being passed.
+     * @param script             - Script to be executed.
+     * @param pjobj              - return value.
+     */
+    NS_IMETHOD	
+    //Eval(JNIEnv *jEnv, jsobject obj, nsIPrincipal **pNSIPrincipaArray, PRInt32 numPrincipals, const char *script, jobject *pjobj);
+    Eval(JNIEnv *jEnv, jsobject obj, const char *script, jobject *pjobj);
+
+    /**
+     * Get the window object for a plugin instance.
+     *
+     * @param pJavaObject        - Either a jobject or a pointer to a plugin instance 
+     *                             representing the java object.
+     * @param pjobj              - return value. This is a native js object 
+     *                             representing the window object of a frame 
+     *                             in which a applet/bean resides.
+     */
+    NS_IMETHOD	
+    GetWindow(JNIEnv *jEnv, void *pJavaObject, jsobject *pobj);
+
+    /**
+     * Get the window object for a plugin instance.
+     *
+     * @param jEnv       - JNIEnv on which the call is being made.
+     * @param obj        - A Native JS Object.
+     */
+    NS_IMETHOD	
+    FinalizeJSObject(JNIEnv *jEnv, jsobject obj);
+
+   
+    ////////////////////////////////////////////////////////////////////////////
+    // from nsCLiveconnect:
+
+    nsCLiveconnect(nsISupports *aOuter);
+    virtual ~nsCLiveconnect(void);
+
+protected:
+};
+
+#endif // nsCLiveconnect_h___

mozilla/js/src/liveconnect/nsCLiveconnectFactory.cpp

@@ -0,0 +1,168 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the implementation providing nsILiveconnect XP-COM interface.
+ *
+ */
+#include "prtypes.h"
+#include "nspr.h"
+#include "prmem.h"
+#include "prmon.h"
+#include "prlog.h"
+
+#include "nsCLiveconnect.h"
+#include "nsCLiveconnectFactory.h"
+#include "nsRepository.h"
+
+static NS_DEFINE_IID(kISupportsIID,    NS_ISUPPORTS_IID);
+static NS_DEFINE_IID(kIFactoryIID,     NS_IFACTORY_IID);
+static NS_DEFINE_CID(kCLiveconnectCID, NS_CLIVECONNECT_CID);
+static NS_DEFINE_IID(kILiveconnectIID, NS_ILIVECONNECT_IID);
+
+nsIFactory      *nsCLiveconnectFactory::m_pNSIFactory     = NULL;
+nsCLiveconnect  *nsCLiveconnectFactory::m_pNSCLiveconnect = NULL;
+
+
+
+/*+++++++++++++++++++++++++++++++++++++++++++++++++
+ * NSGetFactory:
+ * Provides entry point to liveconnect dll.
+ +++++++++++++++++++++++++++++++++++++++++++++++++*/
+
+extern "C" NS_EXPORT nsresult
+NSGetFactory(const nsCID &aClass, nsIFactory **aFactory)
+{
+    
+    if (!aClass.Equals(kCLiveconnectCID)) {
+        return NS_ERROR_FACTORY_NOT_LOADED;     // XXX right error?
+    }
+    nsCLiveconnectFactory* pCLiveConnectFactory = new nsCLiveconnectFactory();
+    if (pCLiveConnectFactory == NULL)
+        return NS_ERROR_OUT_OF_MEMORY;
+    pCLiveConnectFactory->AddRef();
+    *aFactory = pCLiveConnectFactory;
+    return NS_OK;
+}
+
+extern "C" NS_EXPORT PRBool
+NSCanUnload(void)
+{
+    return PR_FALSE;
+}
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// from nsISupports 
+
+NS_METHOD
+nsCLiveconnectFactory::QueryInterface(const nsIID& aIID, void** aInstancePtr) 
+{
+    PR_ASSERT(NULL != aInstancePtr); 
+    if (NULL == aInstancePtr) {
+        return NS_ERROR_NULL_POINTER; 
+    } 
+    if (aIID.Equals(kIFactoryIID) ||
+        aIID.Equals(kISupportsIID)) {
+        *aInstancePtr = (void*) this; 
+        AddRef(); 
+        return NS_OK; 
+    }
+    return NS_NOINTERFACE; 
+}
+
+NS_IMPL_ADDREF(nsCLiveconnectFactory)
+NS_IMPL_RELEASE(nsCLiveconnectFactory)
+
+
+////////////////////////////////////////////////////////////////////////////
+// from nsIFactory:
+
+NS_METHOD
+nsCLiveconnectFactory::CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult)
+{
+   nsCLiveconnect *pNSCLiveconnect = NULL;
+   *aResult  = NULL;
+   
+   if (aOuter && !aIID.Equals(kISupportsIID))
+       return NS_NOINTERFACE;   // XXX right error?
+   if (m_pNSCLiveconnect == NULL)
+   {
+      m_pNSCLiveconnect = new nsCLiveconnect(aOuter);
+   }
+   if (m_pNSCLiveconnect == NULL)
+   {
+         return NS_ERROR_FAILURE;
+   }
+   if (m_pNSCLiveconnect->QueryInterface(aIID,
+                            (void**)aResult) != NS_OK) {
+       // then we're trying get a interface other than nsISupports and
+       // nsICapsManager
+       return NS_ERROR_FAILURE;
+   }
+   return NS_OK;
+}
+
+NS_METHOD
+nsCLiveconnectFactory::LockFactory(PRBool aLock)
+{
+   return NS_OK;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// from nsCLiveconnectFactory:
+
+nsCLiveconnectFactory::nsCLiveconnectFactory(void)
+{
+      if( m_pNSIFactory != NULL)
+      {
+         return;
+      }
+
+      NS_INIT_REFCNT();
+      nsresult     err         = NS_OK;
+      NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
+
+      err = this->QueryInterface(kIFactoryIID, (void**)&m_pNSIFactory);
+      if ( (err == NS_OK) && (m_pNSIFactory != NULL) )
+      {
+         NS_DEFINE_CID(kCLiveconnectCID, NS_CLIVECONNECT_CID);
+         nsRepository::RegisterFactory(kCLiveconnectCID, m_pNSIFactory,
+                                     PR_FALSE);
+      }
+}
+
+nsCLiveconnectFactory::~nsCLiveconnectFactory()
+{
+    if(mRefCnt == 0)
+    {
+      NS_DEFINE_CID(kCLiveconnectCID, NS_CLIVECONNECT_CID);
+      nsRepository::UnregisterFactory(kCLiveconnectCID, (nsIFactory *)m_pNSIFactory);
+      
+    }
+}
+
+

mozilla/js/src/liveconnect/nsCLiveconnectFactory.h

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the class definition to implement nsIFactory XP-COM interface.
+ *
+ */
+
+#ifndef nsCLiveconnectFactory_h___
+#define nsCLiveconnectFactory_h___
+
+#include "nsISupports.h"
+#include "nsIFactory.h"
+
+class nsCLiveconnectFactory : public nsIFactory {
+public:
+    ////////////////////////////////////////////////////////////////////////////
+    // from nsISupports and AggregatedQueryInterface:
+
+    NS_DECL_ISUPPORTS
+
+    ////////////////////////////////////////////////////////////////////////////
+    // from nsIFactory:
+
+    NS_IMETHOD
+    CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult);
+
+    NS_IMETHOD
+    LockFactory(PRBool aLock);
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    // from nsCLiveconnectFactory:
+
+    nsCLiveconnectFactory(void);
+    virtual ~nsCLiveconnectFactory(void);
+
+protected:
+    static nsIFactory      *m_pNSIFactory;  
+    static nsCLiveconnect  *m_pNSCLiveconnect;  
+};
+
+#endif // nsCLiveconnectFactory_h___

mozilla/js/src/liveconnect/nsILiveconnect.h

@@ -0,0 +1,157 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+/*
+ * This file is part of the Java-vendor-neutral implementation of LiveConnect
+ *
+ * It contains the public XP-COM based interface for java to javascript communication.
+ *
+ */
+
+#ifndef nsILiveconnect_h___
+#define nsILiveconnect_h___
+
+#include "nsISupports.h"
+#include "nsIFactory.h"
+#include "jni.h"
+
+
+typedef jint jsobject;
+
+class nsILiveconnect : public nsISupports {
+public:
+    /**
+     * get member of a Native JSObject for a given name.
+     *
+     * @param obj        - A Native JS Object.
+     * @param name       - Name of a member.
+     * @param pjobj      - return parameter as a java object representing 
+     *                     the member. If it is a basic data type it is converted to
+     *                     a corresponding java type. If it is a NJSObject, then it is
+     *                     wrapped up as java wrapper netscape.javascript.JSObject.
+     */
+    NS_IMETHOD	
+    GetMember(JNIEnv *jEnv, jsobject obj, const char *name, jobject *pjobj) = 0;
+
+    /**
+     * get member of a Native JSObject for a given index.
+     *
+     * @param obj        - A Native JS Object.
+     * @param index      - Index of a member.
+     * @param pjobj      - return parameter as a java object representing 
+     *                     the member. 
+     */
+    NS_IMETHOD	
+    GetSlot(JNIEnv *jEnv, jsobject obj, int index, jobject *pjobj) = 0;
+
+    /**
+     * set member of a Native JSObject for a given name.
+     *
+     * @param obj        - A Native JS Object.
+     * @param name       - Name of a member.
+     * @param jobj       - Value to set. If this is a basic data type, it is converted
+     *                     using standard JNI calls but if it is a wrapper to a JSObject
+     *                     then a internal mapping is consulted to convert to a NJSObject.
+     */
+    NS_IMETHOD	
+    SetMember(JNIEnv *jEnv, jsobject obj, const char *name, jobject jobj) = 0;
+
+    /**
+     * set member of a Native JSObject for a given index.
+     *
+     * @param obj        - A Native JS Object.
+     * @param index      - Index of a member.
+     * @param jobj       - Value to set. If this is a basic data type, it is converted
+     *                     using standard JNI calls but if it is a wrapper to a JSObject
+     *                     then a internal mapping is consulted to convert to a NJSObject.
+     */
+    NS_IMETHOD	
+    SetSlot(JNIEnv *jEnv, jsobject obj, int slot, jobject jobj) = 0;
+
+    /**
+     * remove member of a Native JSObject for a given name.
+     *
+     * @param obj        - A Native JS Object.
+     * @param name       - Name of a member.
+     */
+    NS_IMETHOD	
+    RemoveMember(JNIEnv *jEnv, jsobject obj, const char *name) = 0;
+
+    /**
+     * call a method of Native JSObject. 
+     *
+     * @param obj        - A Native JS Object.
+     * @param name       - Name of a method.
+     * @param jobjArr    - Array of jobjects representing parameters of method being caled.
+     * @param pjobj      - return value.
+     */
+    NS_IMETHOD	
+    Call(JNIEnv *jEnv, jsobject obj, const char *name, jobjectArray jobjArr, jobject *pjobj) = 0;
+
+    /**
+     * Evaluate a script with a Native JS Object representing scope.
+     *
+     * @param obj                - A Native JS Object.
+     * @param pNSIPrincipaArray  - Array of principals to be used to compare privileges.
+     * @param numPrincipals      - Number of principals being passed.
+     * @param script             - Script to be executed.
+     * @param pjobj              - return value.
+     */
+    NS_IMETHOD	
+    //Eval(jsobject obj, nsIPrincipal **pNSIPrincipaArray, PRInt32 numPrincipals, const char *script, jobject *pjobj) = 0;
+    Eval(JNIEnv *jEnv, jsobject obj, const char *script, jobject *pjobj) = 0;
+
+    /**
+     * Get the window object for a plugin instance.
+     *
+     * @param pJavaObject        - Either a jobject or a pointer to a plugin instance 
+     *                             representing the java object.
+     * @param pjobj              - return value. This is a native js object 
+     *                             representing the window object of a frame 
+     *                             in which a applet/bean resides.
+     */
+    NS_IMETHOD	
+    GetWindow(JNIEnv *jEnv, void *pJavaObject, jsobject *pobj) = 0;
+
+    /**
+     * Get the window object for a plugin instance.
+     *
+     * @param jEnv       - JNIEnv on which the call is being made.
+     * @param obj        - A Native JS Object.
+     */
+    NS_IMETHOD	
+    FinalizeJSObject(JNIEnv *jEnv, jsobject obj) = 0;
+
+};
+
+#define NS_ILIVECONNECT_IID                          \
+{ /* 68190910-3318-11d2-97f0-00805f8a28d0 */         \
+    0x68190910,                                      \
+    0x3318,                                          \
+    0x11d2,                                          \
+    {0x97, 0xf0, 0x00, 0x80, 0x5f, 0x8a, 0x28, 0xd0} \
+};
+
+#define NS_CLIVECONNECT_CID                          \
+{ /* b8f0cef0-3931-11d2-97f0-00805f8a28d0 */         \
+    0xb8f0cef0,                                      \
+    0x3931,                                          \
+    0x11d2,                                          \
+    {0x97, 0xf0, 0x00, 0x80, 0x5f, 0x8a, 0x28, 0xd0} \
+};
+
+#endif // nsILiveconnect_h___

mozilla/security/psm/lib/Makefile

@@ -1,74 +0,0 @@
-#! gmake
-#
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-#
-
-#######################################################################
-# (1) Include initial platform-independent assignments (MANDATORY).   #
-#######################################################################
-
-include manifest.mn
-
-#######################################################################
-# (2) Include "global" configuration information. (OPTIONAL)          #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/config.mk
-
-#######################################################################
-# (3) Include "component" configuration information. (OPTIONAL)       #
-#######################################################################
-
-
-
-#######################################################################
-# (4) Include "local" platform-dependent assignments (OPTIONAL).      #
-#######################################################################
-
-
-
-#######################################################################
-# (5) Execute "global" rules. (OPTIONAL)                              #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/rules.mk
-
-#######################################################################
-# (6) Execute "component" rules. (OPTIONAL)                           #
-#######################################################################
-
-
-
-#######################################################################
-# (7) Execute "local" rules. (OPTIONAL).                              #
-#######################################################################
-

mozilla/security/psm/lib/Makefile.in

@@ -1,32 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-
-DEPTH		= ../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS		= protocol client
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/security/psm/lib/client/MANIFEST

@@ -1,3 +0,0 @@
-cmtclist.h
-cmtcmn.h
-cmtjs.h

mozilla/security/psm/lib/client/Makefile

@@ -1,74 +0,0 @@
-#! gmake
-#
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-#
-
-#######################################################################
-# (1) Include initial platform-independent assignments (MANDATORY).   #
-#######################################################################
-
-include manifest.mn
-
-#######################################################################
-# (2) Include "global" configuration information. (OPTIONAL)          #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/config.mk
-
-#######################################################################
-# (3) Include "component" configuration information. (OPTIONAL)       #
-#######################################################################
-
-
-
-#######################################################################
-# (4) Include "local" platform-dependent assignments (OPTIONAL).      #
-#######################################################################
-include config.mk
-
-
-#######################################################################
-# (5) Execute "global" rules. (OPTIONAL)                              #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/rules.mk
-
-#######################################################################
-# (6) Execute "component" rules. (OPTIONAL)                           #
-#######################################################################
-
-
-
-#######################################################################
-# (7) Execute "local" rules. (OPTIONAL).                              #
-#######################################################################
-

mozilla/security/psm/lib/client/Makefile.in

@@ -1,70 +0,0 @@
-#! gmake
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-LIBRARY_NAME	= cmt
-
-EXPORTS = \
-	cmtcmn.h \
-	cmtjs.h  \
-	cmtclist.h \
-	$(NULL)
-
-MODULE = security
-
-CSRCS = cmtinit.c  \
-	cmtssl.c   \
-	cmtutils.c \
-	cmtcert.c  \
-	cmthash.c  \
-	cmtpkcs7.c \
-	cmtres.c   \
-	cmtjs.c    \
-	cmtevent.c \
-        cmtpasswd.c \
-	cmtadvisor.c \
-	cmtrng.c \
-	cmtsdr.c \
-	$(NULL)
-
-EXTRA_DSO_LDOPTS	+= -L$(DIST)/bin -lprotocol
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/security/psm/lib/client/cmtadvisor.c

@@ -1,99 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#ifdef XP_MAC
-#include "cmtmac.h"
-#endif
-
-CMTStatus CMT_SecurityAdvisor(PCMT_CONTROL control, CMTSecurityAdvisorData* data, CMUint32 *resID)
-{
-    CMTItem message = {0, NULL, 0};
-    SecurityAdvisorRequest request;
-    SingleNumMessage reply;
-
-    if (!control) {
-        return CMTFailure;
-    }
-
-    if (!data) {
-        return CMTFailure;
-    }
-
-    request.infoContext = data->infoContext;
-    request.resID = data->resID;
-    request.hostname = data->hostname;
-	request.senderAddr = data->senderAddr;
-	request.encryptedP7CInfo = data->encryptedP7CInfo;
-	request.signedP7CInfo = data->signedP7CInfo;
-	request.decodeError = data->decodeError;
-	request.verifyError = data->verifyError;
-	request.encryptthis = data->encryptthis;
-	request.signthis = data->signthis;
-	request.numRecipients = data->numRecipients;
-	request.recipients = data->recipients;
-    message.type = SSM_REQUEST_MESSAGE | SSM_SECURITY_ADVISOR;
-
-    if (CMT_EncodeMessage(SecurityAdvisorRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Send the message and get the response */
-	if (CMT_SendMessage(control, &message) != CMTSuccess) {
-        goto loser;
-	}
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_SECURITY_ADVISOR)) {
-        goto loser;
-    }
-
-    /* Decode the message */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *resID = reply.value;
-
-    return CMTSuccess;
-loser:
-
-    if (message.data) {
-        free(message.data);
-    }
-    return CMTFailure;
-}
-
-
-
-

mozilla/security/psm/lib/client/cmtclist.h

@@ -1,111 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef cmtclist_h___
-#define cmtclist_h___
-
-typedef struct CMTCListStr CMTCList;
-/*
-** Circular linked list
-*/
-struct CMTCListStr {
-    CMTCList	*next;
-    CMTCList	*prev;
-};
-
-/*
-** Insert element "_e" into the list, before "_l".
-*/
-#define CMT_INSERT_BEFORE(_e,_l)	 \
-	(_e)->next = (_l);	 \
-	(_e)->prev = (_l)->prev; \
-	(_l)->prev->next = (_e); \
-	(_l)->prev = (_e);	 \
-
-/*
-** Insert element "_e" into the list, after "_l".
-*/
-#define CMT_INSERT_AFTER(_e,_l)	 \
-	(_e)->next = (_l)->next; \
-	(_e)->prev = (_l);	 \
-	(_l)->next->prev = (_e); \
-	(_l)->next = (_e);	 \
-
-/*
-** Append an element "_e" to the end of the list "_l"
-*/
-#define CMT_APPEND_LINK(_e,_l) CMT_INSERT_BEFORE(_e,_l)
-
-/*
-** Insert an element "_e" at the head of the list "_l"
-*/
-#define CMT_INSERT_LINK(_e,_l) CMT_INSERT_AFTER(_e,_l)
-
-/* Return the head/tail of the list */
-#define CMT_LIST_HEAD(_l) (_l)->next
-#define CMT_LIST_TAIL(_l) (_l)->prev
-
-/*
-** Remove the element "_e" from it's circular list.
-*/
-#define CMT_REMOVE_LINK(_e)	       \
-	(_e)->prev->next = (_e)->next; \
-	(_e)->next->prev = (_e)->prev; \
-
-/*
-** Remove the element "_e" from it's circular list. Also initializes the
-** linkage.
-*/
-#define CMT_REMOVE_AND_INIT_LINK(_e)    \
-	(_e)->prev->next = (_e)->next; \
-	(_e)->next->prev = (_e)->prev; \
-	(_e)->next = (_e);	       \
-	(_e)->prev = (_e);	       \
-
-/*
-** Return non-zero if the given circular list "_l" is empty, zero if the
-** circular list is not empty
-*/
-#define CMT_CLIST_IS_EMPTY(_l) \
-    ((_l)->next == (_l))
-
-/*
-** Initialize a circular list
-*/
-#define CMT_INIT_CLIST(_l)  \
-	(_l)->next = (_l); \
-	(_l)->prev = (_l); \
-
-#define CMT_INIT_STATIC_CLIST(_l) \
-    {(_l), (_l)}
-
-#endif /* cmtclist_h___ */

mozilla/security/psm/lib/client/cmtevent.c

@@ -1,480 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include <string.h>
-#ifdef XP_UNIX
-#include <sys/time.h>
-#endif
-
-/* Typedefs */
-typedef void (*taskcompleted_handler_fn)(CMUint32 resourceID, CMUint32 numReqProcessed, CMUint32 resultCode, void* data);
-
-CMTStatus CMT_SetUIHandlerCallback(PCMT_CONTROL control, 
-                                   uiHandlerCallback_fn f, void *data)
-{
-    return CMT_RegisterEventHandler(control, SSM_UI_EVENT, 0,
-                                    (void_fun)f, data);
-}
-
-void CMT_SetFilePathPromptCallback(PCMT_CONTROL control,
-                                   filePathPromptCallback_fn f, void* arg)
-{
-    control->userFuncs.promptFilePath = f;
-    control->userFuncs.filePromptArg  = arg;
-}
-
-void CMT_SetPromptCallback(PCMT_CONTROL control, 
-                           promptCallback_fn f, void *arg)
-{
-    control->userFuncs.promptCallback = f;
-    control->userFuncs.promptArg      = arg;
-}
-
-void CMT_SetSavePrefsCallback(PCMT_CONTROL control, savePrefsCallback_fn f)
-{
-    control->userFuncs.savePrefs = f;
-}
-
-CMTStatus CMT_RegisterEventHandler(PCMT_CONTROL control, CMUint32 type, 
-                                   CMUint32 resourceID, void_fun handler, 
-                                   void* data)
-{
-    PCMT_EVENT ptr;
-
-    /* This is the first connection */
-    if (control->cmtEventHandlers == NULL) {
-        control->cmtEventHandlers = ptr = 
-            (PCMT_EVENT)calloc(sizeof(CMT_EVENT), 1);
-        if (!ptr) {
-            goto loser;
-        }
-    } else {
-        /* Look for another event handler of the same type.  Make sure the
-           event handler with a rsrcid of 0 is farther down the list so
-	   that it doesn't get chosen when there's an event handler for
-	   a specific rsrcid.
-	 */
-	for (ptr=control->cmtEventHandlers; ptr != NULL; ptr = ptr->next) {
-            if (ptr->type == type && resourceID != 0) {
-                /* So we've got an event handler that wants to over-ride
-                   an existing event handler.  We'll put it before the one
-                   that's already here.
-                 */
-                if (ptr->previous == NULL) {
-                    /* We're going to insert at the front of the list*/
-                    control->cmtEventHandlers = ptr->previous = 
-                        (PCMT_EVENT)calloc(sizeof(CMT_EVENT), 1);
-                    if (ptr->previous == NULL) {
-                        goto loser;
-		    }
-		    ptr->previous->next = ptr;
-		    ptr = control->cmtEventHandlers;
-		} else {
-		    /* We want to insert in the middle of the list */
-		    PCMT_EVENT tmpEvent;
-		    
-		    tmpEvent = (PCMT_EVENT)calloc(sizeof(CMT_EVENT), 1);
-		    if (tmpEvent == NULL) {
-		        goto loser;
-		    }
-		    tmpEvent->previous  = ptr->previous;
-		    ptr->previous->next = tmpEvent;
-		    tmpEvent->next      = ptr;
-		    ptr->previous       = tmpEvent;
-		    ptr = tmpEvent;
-		}
-		break;
-	    }
-	    if (ptr->next == NULL) break;
-	}
-	if (ptr == NULL) {
-	    goto loser;	
-	}
-	if (ptr->next == NULL) {
-	    /* We're adding the event handler at the end of the list. */
-	    ptr->next = (PCMT_EVENT)calloc(sizeof(CMT_EVENT), 1);
-	    if (!ptr->next) {
-	        goto loser;
-	    } 
-	    /* Fix up the pointers */
-	    ptr->next->previous = ptr;
-	    ptr = ptr->next;
-	}
-    }
-
-    /* Fill in the data */
-    ptr->type = type;
-    ptr->resourceID = resourceID;
-    ptr->handler = handler;
-    ptr->data = data;
-    
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_UnregisterEventHandler(PCMT_CONTROL control, CMUint32 type, 
-                                     CMUint32 resourceID) 
-{
-    PCMT_EVENT ptr, pptr = NULL;
-    
-    for (ptr = control->cmtEventHandlers; ptr != NULL;
-	 pptr = ptr, ptr = ptr->next) {
-        if ((ptr->type == type) && (ptr->resourceID == resourceID)) {
-	    if (pptr == NULL) {
-	        /* node is at head */
-	        control->cmtEventHandlers = ptr->next;
-            if (control->cmtEventHandlers != NULL) {
-                control->cmtEventHandlers->previous = NULL;
-            }
-            free(ptr);
-            return CMTSuccess;
-	    }
-	    /* node is elsewhere */
-	    pptr->next = ptr->next;
-        if (ptr->next != NULL) {
-            ptr->next->previous = pptr;
-        }
-	    free(ptr);
-	    return CMTSuccess;
-        }
-    }
-    return CMTFailure;
-}
-
-PCMT_EVENT CMT_GetEventHandler(PCMT_CONTROL control, CMUint32 type, 
-                               CMUint32 resourceID)
-{
-    PCMT_EVENT ptr;
-    
-    for (ptr = control->cmtEventHandlers; ptr != NULL; ptr = ptr->next) {
-        if ((ptr->type == type) && ((ptr->resourceID == resourceID) || 
-                                    !ptr->resourceID)) {
-            return ptr;
-        }
-    }
-    return NULL;
-}
-
-PCMT_EVENT CMT_GetFirstEventHandler(PCMT_CONTROL control, CMUint32 type, 
-                                    CMUint32 resourceID)
-{
-    PCMT_EVENT ptr;
-
-    for (ptr = control->cmtEventHandlers; ptr != NULL; ptr = ptr->next) {
-        if ((ptr->type == type) && ((ptr->resourceID == resourceID) || 
-                                    !ptr->resourceID)) {
-            return ptr;
-        }
-    }
-    return NULL;
-}
-
-PCMT_EVENT CMT_GetNextEventHandler(PCMT_CONTROL control, PCMT_EVENT e)
-{
-    PCMT_EVENT ptr;
-
-    for (ptr = control->cmtEventHandlers; ptr != NULL || ptr == e; 
-         ptr = ptr->next) {
-    }
-
-    for (; ptr != NULL; ptr = ptr->next) {
-        if ((ptr->type == e->type) && ((ptr->resourceID == e->resourceID) || 
-                                       !ptr->resourceID)) {
-            return ptr;
-        }
-    }
-    return NULL;
-}
-
-void CMT_ProcessEvent(PCMT_CONTROL cm_control)
-{
-    CMTSocket sock; 
-    CMTItem eventData={ 0, NULL, 0 };
-
-    /* Get the control socket */
-    sock = cm_control->sock;
-
-    /* Acquire a lock on the control connection */
-    CMT_LOCK(cm_control->mutex);
-    /* Do another select here to be sure 
-       that the socket is readable */
-    if (cm_control->sockFuncs.select(&sock, 1, 1) != sock) {
-        /* There's no event. */
-        goto done;
-    }
-
-    /* Read the event */
-    if (CMT_ReceiveMessage(cm_control, &eventData) == CMTFailure) {
-        goto done;
-    }
-    CMT_UNLOCK(cm_control->mutex);
-    /* Dispatch the event */
-    CMT_DispatchEvent(cm_control, &eventData);
-    return;
-done:
-    /* Release the lock on the control connection */
-    CMT_UNLOCK(cm_control->mutex);
-}
-
-void CMT_EventLoop(PCMT_CONTROL cm_control)
-{
-    CMTSocket sock;
-
-    /* Get the control socket */
-    sock = cm_control->sock;
-    CMT_ReferenceControlConnection(cm_control);
-    /* Select on the control socket to see if it's readable */
-    while(cm_control->sockFuncs.select(&sock, 1, 0)) {
-      CMT_ProcessEvent(cm_control);
-    }
-    CMT_CloseControlConnection(cm_control);
-    return;
-}
-
-void
-CMT_PromptUser(PCMT_CONTROL cm_control, CMTItem *eventData)
-{
-    char *promptReply  = NULL;
-    CMTItem   response={ 0, NULL, 0 };
-    PromptRequest request;
-    PromptReply reply;
-    void * clientContext;
-
-    /* Decode the message */
-    if (CMT_DecodeMessage(PromptRequestTemplate, &request, eventData) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Copy the client context to a pointer */
-    clientContext = CMT_CopyItemToPtr(request.clientContext);
-
-    if (cm_control->userFuncs.promptCallback == NULL) {
-        goto loser;
-    }
-    promptReply = 
-        cm_control->userFuncs.promptCallback(cm_control->userFuncs.promptArg, 
-                                             request.prompt, clientContext, 1);
-
-    response.type = SSM_EVENT_MESSAGE | SSM_PROMPT_EVENT;
-    if (!promptReply) {
-        /* the user canceled the prompt or other errors occurred */
-        reply.cancel = CM_TRUE;
-    }
-    else {
-        /* note that this includes an empty string (zero length) password */
-        reply.cancel = CM_FALSE;
-    }
-    reply.resID = request.resID;
-    reply.promptReply = promptReply;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(PromptReplyTemplate, &response, &reply) != CMTSuccess) {
-        goto loser;
-    }
-
-    CMT_TransmitMessage(cm_control, &response);
- loser:
-    if (promptReply != NULL) {
-      cm_control->userFuncs.userFree(promptReply);
-    }
-    return;
-}
-
-void CMT_GetFilePath(PCMT_CONTROL cm_control, CMTItem * eventData)
-{
-    char *fileName=NULL;
-    CMTItem response = { 0, NULL, 0 };
-    FilePathRequest request;
-    FilePathReply reply;
-
-    /* Decode the request */
-    if (CMT_DecodeMessage(FilePathRequestTemplate, &request, eventData) != CMTSuccess) {
-        goto loser;
-    }
-
-    if (cm_control->userFuncs.promptFilePath == NULL) {
-        goto loser;
-    }
-    fileName = 
-     cm_control->userFuncs.promptFilePath(cm_control->userFuncs.filePromptArg,
-                                          request.prompt, request.fileRegEx, 
-                                          request.getExistingFile);
-
-    response.type = SSM_EVENT_MESSAGE | SSM_FILE_PATH_EVENT;
-    reply.resID = request.resID;
-    reply.filePath = fileName;
-
-    /* Encode the reply */
-    if (CMT_EncodeMessage(FilePathReplyTemplate, &response, &reply) != CMTSuccess) {
-        goto loser;
-    }
-
-    CMT_TransmitMessage(cm_control, &response);
-    cm_control->userFuncs.userFree(fileName); 
-loser:
-   return;
-}
-
-void CMT_SavePrefs(PCMT_CONTROL cm_control, CMTItem* eventData)
-{
-    SetPrefListMessage request;
-    int i;
-
-    /* decode the request */
-    if (CMT_DecodeMessage(SetPrefListMessageTemplate, &request, eventData) !=
-        CMTSuccess) {
-        return;
-    }
-
-    if (cm_control->userFuncs.savePrefs == NULL) {
-        /* callback was not registered: bail */
-        return;
-    }
-    cm_control->userFuncs.savePrefs(request.length, 
-                                    (CMTSetPrefElement*)request.list);
-
-    for (i = 0; i < request.length; i++) {
-        if (request.list[i].key != NULL) {
-            free(request.list[i].key);
-        }
-        if (request.list[i].value != NULL) {
-            free(request.list[i].value);
-        }
-    }
-    return;
-}
-
-void CMT_DispatchEvent(PCMT_CONTROL cm_control, CMTItem * eventData)
-{
-    CMUint32 eventType;
-    CMTItem msgCopy;
-
-    /* Init the msgCopy */
-    msgCopy.data = 0;    
-
-    /* Get the event type */
-    if ((eventData->type & SSM_CATEGORY_MASK) != SSM_EVENT_MESSAGE) {
-        /* Somehow there was a message on the socket that was not 
-         * an event message.  Dropping it on the floor.
-         */
-        goto loser;
-    }
-    eventType = (eventData->type & SSM_TYPE_MASK);
-
-    /* We must now dispatch the event based on it's type */
-    switch (eventType) {
-        case SSM_UI_EVENT:
-        {
-            PCMT_EVENT p;
-            UIEvent event;
-            void * clientContext = NULL;
-
-	    /* Copy the message to allow a second try with the old format */
-	    msgCopy.len = eventData->len;
-	    msgCopy.data = calloc(msgCopy.len, 1);
-	    if (msgCopy.data) {
-              memcpy(msgCopy.data, eventData->data, eventData->len);
-	    }
-
-            /* Get the event data first */
-            if (CMT_DecodeMessage(UIEventTemplate, &event, eventData) != CMTSuccess) {
-		/* Attempt to decode using the old format.  Modal is True */
-		if (!msgCopy.data || 
-		    CMT_DecodeMessage(OldUIEventTemplate, &event, &msgCopy) != CMTSuccess) {
-                  goto loser;
-                }
-
-                /* Set default modal value */
-                event.isModal = CM_TRUE;
-            }
-
-            /* Convert the client context to a pointer */
-            clientContext = CMT_CopyItemToPtr(event.clientContext);
-
-            /* Call any handlers for this event */
-            p = CMT_GetEventHandler(cm_control, eventType, event.resourceID);
-            if (!p) {
-                goto loser;
-            }
-            (*(uiHandlerCallback_fn)(p->handler))(event.resourceID, 
-                                                  clientContext, event.width,
-                                                  event.height, event.isModal, event.url, 
-                                                  p->data);
-            break;
-        }
-
-        case SSM_TASK_COMPLETED_EVENT:
-        {
-           PCMT_EVENT p;
-           TaskCompletedEvent event;
-
-            /* Get the event data */
-            if (CMT_DecodeMessage(TaskCompletedEventTemplate, &event, eventData) != CMTSuccess) {
-                goto loser;
-            }
-
-            /* Call handler for this event */
-            p = CMT_GetEventHandler(cm_control, eventType, event.resourceID);
-            if (!p) {
-                goto loser;
-            }
-            (*(taskcompleted_handler_fn)(p->handler))(event.resourceID, 
-                                                      event.numTasks, 
-                                                      event.result, p->data);
-            break;
-        }
-        case SSM_AUTH_EVENT: 
-             CMT_ServicePasswordRequest(cm_control, eventData);
-             break;
-        case SSM_FILE_PATH_EVENT:
-    	     CMT_GetFilePath(cm_control, eventData);
-             break;
-        case SSM_PROMPT_EVENT:
-	         CMT_PromptUser(cm_control, eventData);
-	         break;
-        case SSM_SAVE_PREF_EVENT:
-            CMT_SavePrefs(cm_control, eventData);
-            break;
-        default:
-            break;
-    }
-loser:
-    free(eventData->data);
-    free(msgCopy.data);
-    return;
-}
-

mozilla/security/psm/lib/client/cmthash.c

@@ -1,216 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#else
-#ifdef XP_MAC
-#include "macsocket.h"
-#include "string.h"
-#else
-#include <windows.h>
-#include <winsock.h>
-#endif
-#endif
-#include <errno.h>
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include "rsrcids.h"
-
-CMTStatus CMT_HashCreate(PCMT_CONTROL control, CMUint32 algID, 
-                         CMUint32 * connID)
-{
-    CMTItem message;
-    SingleNumMessage request;
-    DataConnectionReply reply;
-
-    /* Check passed in parameters */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.value = algID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | SSM_HASH_STREAM;
-
-    /* Send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the response */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | SSM_HASH_STREAM)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        CMTSocket sock;
-
-        sock = control->sockFuncs.socket(0);
-        if(sock == NULL) {
-            goto loser;
-        }
-        
-        if (control->sockFuncs.connect(sock, reply.port, NULL) != CMTSuccess) {
-            goto loser;
-        }
-        /* Send the hello message */
-		control->sockFuncs.send(sock, control->nonce.data, control->nonce.len);
-
-        /* Save connection info */
-        if (CMT_AddDataConnection(control, sock, reply.connID)
-		    != CMTSuccess) {
-            goto loser;
-        }
-
-        /* Set the connection ID */
-        *connID = reply.connID;
-        return CMTSuccess;
-	} 
-loser:
-    *connID = 0;
-	return CMTFailure;
-}
-
-CMTStatus CMT_HASH_Destroy(PCMT_CONTROL control, CMUint32 connectionID)
-{
-    if (!control) {
-        goto loser;
-    }
-
-    /* Get the cotext implementation data */
-    if (CMT_CloseDataConnection(control, connectionID) == CMTFailure) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-
-loser:
-
-    return CMTFailure;
-}
-
-CMTStatus CMT_HASH_Begin(PCMT_CONTROL control, CMUint32 connectionID)
-{
-    return CMTSuccess;
-}
-
-CMTStatus CMT_HASH_Update(PCMT_CONTROL control, CMUint32 connectionID, const unsigned char * buf, CMUint32 len)
-{
-    CMTSocket sock;
-    CMUint32 sent;
-
-    /* Do some parameter checking */
-    if (!control || !buf) {
-        goto loser;
-    }
-
-    /* Get the data socket */
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Write the data to the socket */
-    sent = CMT_WriteThisMany(control, sock, (void*)buf, len);
-    if (sent != len) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-
-loser:
-
-    return CMTFailure;
-}
-
-CMTStatus CMT_HASH_End(PCMT_CONTROL control, CMUint32 connectionID, 
-                       unsigned char * result, CMUint32 * resultlen, 
-                       CMUint32 maxLen)
-{
-    CMTItem hash = { 0, NULL, 0 };
-
-    /* Do some parameter checking */
-    if (!control || !result || !resultlen) {
-        goto loser;
-    }
-
-    /* Close the connection */
-    if (CMT_CloseDataConnection(control, connectionID) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Get the context info */
-    if (CMT_GetStringAttribute(control, connectionID, SSM_FID_HASHCONN_RESULT,
-                               &hash) == CMTFailure) {
-        goto loser;
-    }
-    if (!hash.data) {
-        goto loser;
-    }
-
-    *resultlen = hash.len;
-    if (hash.len > maxLen) {
-        memcpy(result, hash.data, maxLen);
-    } else {
-        memcpy(result, hash.data, hash.len);
-    }   
-
-    if (hash.data) {
-        free(hash.data);
-    }
-
-    return CMTSuccess;
-
-loser:
-    if (hash.data) {
-        free(hash.data);
-    }
-
-    return CMTFailure;
-}

mozilla/security/psm/lib/client/cmtimpl.h

@@ -1,56 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __CMTIMPL_H_
-#define __CMTIMPL_H_
-
-typedef unsigned long CMT_HANDLE;
-
-struct _CMTControl {
-  CMT_HANDLE channelID;
-  int socketID;
-  CMTStatus (* cmtEventCallback)(struct _CMTControl * control, 
-				 CMTItem * event,  void * arg);
-  void * cmtEventCallbackArg;
-  struct _CMTData * cmtDataConnection;
-} _CMTControl;
-
-
-
-struct _CMTData {
-  CMT_HANDLE channelID;
-  int socketID;
-  struct _CMTData * next;
-  struct _CMTData * previous;
-};
-
-#endif /*__CMTIMPL_H_*/

mozilla/security/psm/lib/client/cmtinit.c

@@ -1,484 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <sys/stat.h>
-#include <netinet/tcp.h>
-#else
-#ifdef XP_MAC
-#include <Events.h> // for WaitNextEvent
-#else /* Windows */
-#include <windows.h>
-#include <winsock.h>
-#include <direct.h>
-#include <sys/stat.h>
-#endif
-#endif
-
-#include "messages.h"
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include <string.h>
-
-#ifdef XP_UNIX
-#define DIRECTORY_SEPARATOR '/'
-#elif defined WIN32
-#define DIRECTORY_SEPARATOR '\\'
-#elif defined XP_MAC
-#define DIRECTORY_SEPARATOR ':'
-#endif
-
-/* Local defines */
-#define CARTMAN_PORT	11111
-#define MAX_PATH_LEN    256
-
-/* write to the cmnav.log */
-#if 0
-#define LOG(x); do { FILE *f; f=fopen("cmnav.log","a+"); if (f) { \
-   fprintf(f, x); fclose(f); } } while(0);
-#define LOG_S(x); do { FILE *f; f=fopen("cmnav.log","a+"); if (f) { \
-   fprintf(f, "%s", x); fclose(f); } } while(0);
-#define ASSERT(x); if (!(x)) { LOG("ASSERT:"); LOG(#x); LOG("\n"); exit(-1); }
-#else
-#define LOG(x); ;
-#define LOG_S(x); ;
-#define ASSERT(x); ;
-#endif
-
-static char*
-getCurrWorkDir(char *buf, int maxLen)
-{
-#if defined WIN32
-    return _getcwd(buf, maxLen);
-#elif defined XP_UNIX
-    return getcwd(buf, maxLen);
-#else
-    return NULL;
-#endif
-}
-
-static void
-setWorkingDir(char *path)
-{
-#if defined WIN32
-    _chdir(path);
-#elif defined XP_UNIX
-    chdir(path);
-#else
-    return;
-#endif
-}
-
-static CMTStatus
-launch_psm(char *executable)
-{
-    char command[MAX_PATH_LEN];
-#ifdef WIN32
-    STARTUPINFO sui;
-    PROCESS_INFORMATION pi;
-    UNALIGNED long *posfhnd;
-    int i;
-    char *posfile;
-
-    sprintf(command,"%s > psmlog", executable);
-    ZeroMemory( &sui, sizeof(sui) );
-    sui.cb = sizeof(sui);
-    sui.cbReserved2 = (WORD)(sizeof( int ) + (3 * (sizeof( char ) + 
-                                                   sizeof( long ))));
-    sui.lpReserved2 = calloc( sui.cbReserved2, 1 );
-    *((UNALIGNED int *)(sui.lpReserved2)) = 3;
-    posfile = (char *)(sui.lpReserved2 + sizeof( int ));
-    posfhnd = (UNALIGNED long *)(sui.lpReserved2 + sizeof( int ) + 
-                                 (3 * sizeof( char )));
-    
-    for ( i = 0, posfile = (char *)(sui.lpReserved2 + sizeof( int )),
-              posfhnd = (UNALIGNED long *)(sui.lpReserved2 + sizeof( int ) + (3 * sizeof( char ))) ;
-          i < 3 ; i++, posfile++, posfhnd++ ) {
-        
-        *posfile = 0;
-        *posfhnd = (long)INVALID_HANDLE_VALUE;
-    }
-    /* Now, fire up PSM */
-    if (!CreateProcess(NULL, command, NULL, NULL, TRUE, DETACHED_PROCESS, 
-                       NULL, NULL, &sui, &pi)) {
-        goto loser;
-    }
-
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-#elif defined XP_UNIX
-    sprintf(command,"./%s &", executable);
-    if (system(command) == -1) {
-        goto loser;
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-#else
-    return CMTFailure;
-#endif
-}
-
-PCMT_CONTROL CMT_EstablishControlConnection(char            *inPath, 
-                                            CMT_SocketFuncs *sockFuncs,
-                                            CMT_MUTEX       *mutex)
-{
-    PCMT_CONTROL control;
-    char *executable;
-    char *newWorkingDir;
-    char oldWorkingDir[MAX_PATH_LEN];
-    int i;
-    char *path = NULL;
-    size_t stringLen;
-
-    /*	On the Mac, we do special magic in the Seamonkey PSM component, so
-    	if PSM isn't launched by the time we reach this point, we're not doing well. */
-#ifndef XP_MAC
-
-    struct stat stbuf;
-    
-    /*
-     * Create our own copy of path.
-     * I'd like to do a straight strdup here, but that caused problems
-     * for https.
-     */
-    stringLen = strlen(inPath);
-
-    path = (char*) malloc(stringLen+1);
-    memcpy(path, inPath, stringLen);
-    path[stringLen] = '\0';
-
-    control = CMT_ControlConnect(mutex, sockFuncs);
-    if (control != NULL) {
-        return control;
-    }
-    /*
-     * We have to try to launch it now, so it better be a valid 
-     * path.
-     */
-    if (stat(path, &stbuf) == -1) {
-        goto loser;
-    }
-    /*
-     * Now we have to parse the path and launch the psm server.
-     */
-    executable = strrchr(path, DIRECTORY_SEPARATOR);
-    if (executable != NULL) {
-        *executable = '\0';
-        executable ++;
-        newWorkingDir = path;
-    } else {
-        executable = path;
-        newWorkingDir = NULL;
-    }
-    if (getCurrWorkDir(oldWorkingDir, MAX_PATH_LEN) == NULL) {
-        goto loser;
-    }
-    setWorkingDir(newWorkingDir);
-    if (launch_psm(executable) != CMTSuccess) {
-        goto loser;
-    }
-    setWorkingDir(oldWorkingDir);
-#endif
-
-    /*
-     * Now try to connect to the psm server.  We will try to connect
-     * a maximum of 30 times and then give up.
-     */
-#ifdef WIN32
-    for (i=0; i<30; i++) {
-        Sleep(1000);
-        control = CMT_ControlConnect(mutex, sockFuncs);
-        if (control != NULL) {
-            break;
-        }
-    }
-#elif defined XP_UNIX
-    i = 0;
-    while (i<1000) {
-        i += sleep(10);
-	control = CMT_ControlConnect(mutex, sockFuncs);
-	if (control != NULL) {
-	  break;
-	}
-    }
-#elif defined(XP_MAC)
-	for (i=0; i<30; i++) 
-	{
-		EventRecord theEvent;
-		WaitNextEvent(0, &theEvent, 30, NULL);
-		control = CMT_ControlConnect(mutex, sockFuncs);
-		if (control != NULL) 
-			break;
-	}
-
-#else
-    /*
-     * Figure out how to sleep for a while first
-     */
-    for (i=0; i<30; i++) {
-      control = CMT_ControlConnect(mutex, sockFuncs);
-      if (control!= NULL) {
-	break;
-      }
-    }
-#endif
-    if (control == NULL) {
-        goto loser;
-    }
-    if (path) {
-        free (path);
-    }
-    return control;
- loser:
-    if (control != NULL) {
-        CMT_CloseControlConnection(control);
-    }
-    if (path) {
-        free(path);
-    }
-    return NULL;
-}
-
-
-PCMT_CONTROL CMT_ControlConnect(CMT_MUTEX *mutex, CMT_SocketFuncs *sockFuncs)
-{
-    PCMT_CONTROL control = NULL; 
-    CMTSocket sock=NULL;
-#ifdef XP_UNIX
-    int unixSock = 1;
-    char path[20];
-#else
-    int unixSock = 0;
-    char *path=NULL;
-#endif
-
-    if (sockFuncs == NULL) {
-        return NULL;
-    }
-#ifdef XP_UNIX
-    sprintf(path, "/tmp/.nsmc-%d", (int)geteuid());
-#endif    
-
-    sock = sockFuncs->socket(unixSock);
-    if (sock == NULL) {
-        LOG("Could not create a socket to connect to Control Connection.\n");
-        goto loser;
-    }
-    /* Connect to the psm process */
-    if (sockFuncs->connect(sock, CARTMAN_PORT, path)) {
-	  LOG("Could not connect to Cartman\n");
-	  goto loser;
-    }
-
-#ifdef XP_UNIX
-    if (sockFuncs->verify(sock) != CMTSuccess) {
-        goto loser;
-    }
-#endif
-
-	LOG("Connected to Cartman\n");
-	
-	/* fill in the CMTControl struct */
-	control = (PCMT_CONTROL)calloc(sizeof(CMT_CONTROL), 1);
-	if (control == NULL ) {
-		goto loser;
-	}
-	control->sock = sock;
-    if (mutex != NULL) {
-        control->mutex = (CMT_MUTEX*)calloc(sizeof(CMT_MUTEX),1);
-        if (control->mutex == NULL) {
-            goto loser;
-        }
-        *control->mutex = *mutex;
-    }
-    memcpy(&control->sockFuncs, sockFuncs, sizeof(CMT_SocketFuncs));
-    control->refCount = 1;
-	goto done;
-    
- loser:
-	if (control != NULL) {
-		free(control);
-    }
-    if (sock != NULL) {
-        sockFuncs->close(sock);
-    }
-	control = NULL;
-    
- done:
-	return control;
-}
-
-CMTStatus CMT_CloseControlConnection(PCMT_CONTROL control)
-{
-	/* XXX Don't know what to do here yet */
-    if (control != NULL) {
-        CMInt32 refCount;
-        CMT_LOCK(control->mutex);
-        control->refCount--;
-        refCount = control->refCount;
-        CMT_UNLOCK(control->mutex);
-        if (refCount <= 0) {
-            if (control->mutex != NULL) {
-                free (control->mutex);
-            }
-            control->sockFuncs.close(control->sock);
-            free(control);
-        }
-    }
-    
-	return CMTSuccess;
-}
-
-CMTStatus CMT_Hello(PCMT_CONTROL control, CMUint32 version, char* profile, 
-                    char* profileDir)
-{
-	CMTItem message;
-    PCMT_EVENT eventHandler;
-    CMBool doesUI;
-    HelloRequest request;
-    HelloReply reply;
-
-	/* Check the passed parameters */
-	if (!control) {
-		return CMTFailure;
-	}
-	if (!profile) {
-		return CMTFailure;
-	}
-    if (!profileDir) {
-        return CMTFailure;
-    }
-    
-	/* Create the hello message */
-    eventHandler = CMT_GetEventHandler(control, SSM_UI_EVENT, 0);
-    doesUI = (eventHandler == NULL) ? CM_FALSE : CM_TRUE;
-
-    /* Setup the request struct */
-    request.version = version;
-    request.policy = 0; /* no more policy */
-    request.doesUI = doesUI;
-    request.profile = profile;
-    request.profileDir = profileDir;
-
-    message.type = SSM_REQUEST_MESSAGE | SSM_HELLO_MESSAGE;
-
-    if (CMT_EncodeMessage(HelloRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-	/* Send the message and get the response */
-	if (CMT_SendMessage(control, &message) != CMTSuccess) {
-        goto loser;
-	}
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_HELLO_MESSAGE)) {
-        goto loser;
-    }
-
-    /* Decode the message */
-    if (CMT_DecodeMessage(HelloReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-	/* Successful response */
-	if (reply.result == 0) {
-            /* Save the nonce value */
-            control->sessionID = reply.sessionID;
-            control->protocolVersion = reply.version;
-            control->port = reply.httpPort;
-            control->nonce = reply.nonce;
-            control->policy = reply.policy;
-            control->serverStringVersion = reply.stringVersion;
-
-            /* XXX Free the messages */
-            return CMTSuccess;
-	}
-loser:
-	/* XXX Free the messages */
-	return CMTFailure;
-}
-
-CMTStatus CMT_PassAllPrefs(PCMT_CONTROL control, int num,
-                           CMTSetPrefElement* list)
-{
-    SetPrefListMessage request;
-    SingleNumMessage reply;
-    CMTItem message;
-
-    if ((control == NULL) || (list == NULL)) {
-        return CMTFailure;
-    }
-
-    /* pack the request */
-    request.length = num;
-    request.list = (SetPrefElement*)list;
-
-    if (CMT_EncodeMessage(SetPrefListMessageTemplate, &message, &request) !=
-        CMTSuccess) {
-        goto loser;
-    }
-    message.type = SSM_REQUEST_MESSAGE | SSM_PREF_ACTION;
-
-    /* send the message */
-    if (CMT_SendMessage(control, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PREF_ACTION)) {
-        goto loser;
-    }
-
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* don't really need to check the return value */
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-char* CMT_GetServerStringVersion(PCMT_CONTROL control)
-{
-    if (control == NULL) {
-        return NULL;
-    }
-    return control->serverStringVersion;
-}

mozilla/security/psm/lib/client/cmtjs.c

@@ -1,556 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmtutils.h"
-#include "cmtjs.h"
-#include "messages.h"
-
-CMTStatus
-CMT_GenerateKeyPair(PCMT_CONTROL control, CMUint32 keyGenContext, 
-		    CMUint32 mechType, CMTItem *param, CMUint32 keySize, 
-		    CMUint32 *keyPairId)
-{
-    CMTItem message;
-    CMTStatus rv;
-    KeyPairGenRequest request = {0, 0, 0, {0, NULL, 0}};
-    SingleNumMessage reply;
-
-    if (!control) {
-        return CMTFailure;
-    }
-
-    request.keyGenCtxtID = keyGenContext;
-    request.genMechanism = mechType;
-    if (param) {
-        request.params = *param;
-    }
-    request.keySize = keySize;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(KeyPairGenRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    message.type = SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | SSM_CREATE_KEY_PAIR;
-
-    /* Send the message and get the response */
-    rv = CMT_SendMessage(control, &message); 
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION | SSM_CREATE_KEY_PAIR)) {
-        goto loser;
-    }
-
-    /* Decode the message */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-    *keyPairId = reply.value;
-    return CMTSuccess;
-    
-loser:
-    *keyPairId = 0;
-    return CMTFailure;
-}
-
-
-CMTStatus
-CMT_CreateNewCRMFRequest(PCMT_CONTROL control, CMUint32 keyPairID, 
-			 SSMKeyGenType keyGenType, CMUint32 *reqID)
-{
-    CMTItem message;
-    CMTStatus rv;
-    SingleNumMessage request;
-    SingleNumMessage reply;
-    
-    if (!control) {
-        return CMTFailure;
-    }
-
-    request.value = keyPairID;
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    message.type = SSM_REQUEST_MESSAGE | SSM_CRMF_ACTION | 
-                    SSM_CREATE_CRMF_REQ;
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-  
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_CRMF_ACTION | SSM_CREATE_CRMF_REQ)) {
-        goto loser;
-    }
-
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *reqID = reply.value;
-
-    rv = CMT_SetNumericAttribute(control, *reqID, SSM_FID_CRMFREQ_KEY_TYPE,
-				 keyGenType);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_EncodeCRMFRequest(PCMT_CONTROL control, CMUint32 *crmfReqID, 
-		      CMUint32 numRequests, char ** der)
-{
-    CMTItem   message;
-    CMTStatus  rv;
-    EncodeCRMFReqRequest request;
-    SingleItemMessage reply;
-
-    if (!control) {
-        return CMTFailure;
-    }
-
-    request.numRequests = numRequests;
-    request.reqIDs = (long *) crmfReqID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(EncodeCRMFReqRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    message.type = SSM_REQUEST_MESSAGE | SSM_CRMF_ACTION | SSM_DER_ENCODE_REQ;
-
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_CRMF_ACTION | SSM_DER_ENCODE_REQ)) {
-        goto loser;
-    }
-
-    /* XXX Should this be a string? Decode the message */
-    if (CMT_DecodeMessage(SingleItemMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *der = (char *) reply.item.data;
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_ProcessCMMFResponse(PCMT_CONTROL control, char *nickname,
-			char *certRepString, CMBool doBackup,
-			void *clientContext)
-{
-    CMTItem   message;
-    CMTStatus  rv;
-    CMMFCertResponseRequest request;
-
-    if(!control) {
-        return CMTFailure;
-    }
-
-    request.nickname = nickname;
-    request.base64Der = certRepString;
-    request.doBackup = doBackup;
-    request.clientContext = CMT_CopyPtrToItem(clientContext);
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(CMMFCertResponseRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    message.type =  SSM_REQUEST_MESSAGE | SSM_CRMF_ACTION | SSM_PROCESS_CMMF_RESP;
-
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_CRMF_ACTION | SSM_PROCESS_CMMF_RESP)) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_CreateResource(PCMT_CONTROL control, SSMResourceType resType,
-		   CMTItem *params, CMUint32 *rsrcId, CMUint32 *errorCode)
-{
-    CMTItem message;
-    CMTStatus rv;
-    CreateResourceRequest request = {0, {0, NULL, 0}};
-    CreateResourceReply reply;
-
-    request.type = resType;
-    if (params) {
-        request.params = *params;
-    } 
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(CreateResourceRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_CREATE_RESOURCE;
-    
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_CREATE_RESOURCE)) {
-        goto loser;
-    }
-
-    /* Decode the message */
-    if (CMT_DecodeMessage(CreateResourceReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *rsrcId = reply.resID;
-    *errorCode = reply.result;
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_SignText(PCMT_CONTROL control, CMUint32 resID, char* stringToSign, char* hostName, char* caOption, CMInt32 numCAs, char** caNames)
-{
-    CMTItem message;
-    SignTextRequest request;
-
-    
-    /* So some basic parameter checking */
-    if (!control || !stringToSign) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = resID;
-    request.stringToSign = stringToSign;
-    request.hostName = hostName;
-    request.caOption = caOption;
-    request.numCAs = numCAs;
-    request.caNames = caNames;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(SignTextRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_FORMSIGN_ACTION | SSM_SIGN_TEXT;
-
-    /* Send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_FORMSIGN_ACTION | SSM_SIGN_TEXT)) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_ProcessChallengeResponse(PCMT_CONTROL control, char *challengeString,
-			     char **responseString)
-{
-    CMTItem   message;
-    CMTStatus  rv;
-    SingleStringMessage request;
-    SingleStringMessage reply;
-
-    /* Set the request */
-    request.string = challengeString;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleStringMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_CRMF_ACTION | SSM_CHALLENGE;
-
-    /* Send the message */
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-    
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_CRMF_ACTION | SSM_CHALLENGE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(SingleStringMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *responseString = reply.string;
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_FinishGeneratingKeys(PCMT_CONTROL control, CMUint32 keyGenContext)
-{
-    CMTItem message;
-    CMTStatus rv;
-    SingleNumMessage request;
-
-    /* Set up the request */
-    request.value = keyGenContext;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | SSM_FINISH_KEY_GEN;
-
-    /* Send the message */
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the reply */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION | SSM_FINISH_KEY_GEN)) {
-        goto loser;
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_GetLocalizedString(PCMT_CONTROL        control,
-                       SSMLocalizedString  whichString,
-                       char              **localizedString)
-{
-    CMTItem message;
-    CMTStatus rv;
-    SingleNumMessage request;
-    GetLocalizedTextReply reply;
-
-    /* Set up the request */
-    request.value = whichString;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_LOCALIZED_TEXT;
-
-    /* Send the message */
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_LOCALIZED_TEXT)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(GetLocalizedTextReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    if (reply.whichString != whichString) {
-        goto loser;
-    }
-    *localizedString = reply.localizedString;
-    return CMTSuccess;
- loser:
-    *localizedString = NULL;
-    return rv; 
-}
-
-CMTStatus
-CMT_AddNewModule(PCMT_CONTROL  control,
-                 char         *moduleName,
-                 char         *libraryPath,
-                 unsigned long pubMechFlags,
-                 unsigned long pubCipherFlags)
-{
-    CMTItem message;
-    CMTStatus rv;
-    AddNewSecurityModuleRequest request;
-    SingleNumMessage reply;
-
-    /* Set up the request */
-    request.moduleName = moduleName;
-    request.libraryPath = libraryPath;
-    request.pubMechFlags = pubMechFlags;
-    request.pubCipherFlags = pubCipherFlags;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(AddNewSecurityModuleRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | SSM_ADD_NEW_MODULE;
-
-    /* Send the message */
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION | SSM_ADD_NEW_MODULE)) {
-        goto loser;
-    }
-
-    /* Decode the response */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    return (CMTStatus) reply.value;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_DeleteModule(PCMT_CONTROL  control,
-                 char         *moduleName,
-                 int          *moduleType)
-{
-    CMTItem message;
-    CMTStatus rv;
-    SingleStringMessage request;
-    SingleNumMessage reply;
-
-    /* Set up the request */
-    request.string = moduleName;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleStringMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | SSM_DEL_MODULE;
-
-    /* Send the message */
-    rv = CMT_SendMessage(control, &message);
-    if (rv != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION | SSM_DEL_MODULE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *moduleType = reply.value;
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_LogoutAllTokens(PCMT_CONTROL control)
-{
-  CMTItem message;
-  CMTStatus rv;
-
-  message.type = SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | SSM_LOGOUT_ALL;
-  message.data = NULL;
-  message.len  = 0;
-
-  rv = CMT_SendMessage(control, &message);
-  if (rv != CMTSuccess) {
-    return rv;
-  }
-  if (message.type !=  (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION | 
-			SSM_LOGOUT_ALL)) {
-    return CMTFailure;
-  }
-  return CMTSuccess;
-}
-
-CMTStatus CMT_GetSSLCapabilities(PCMT_CONTROL control, CMInt32 *capabilites)
-{
-    SingleNumMessage reply;
-    CMTItem message;
-    CMTStatus rv;
-
-    message.type = (SSM_REQUEST_MESSAGE | SSM_PKCS11_ACTION | 
-                    SSM_ENABLED_CIPHERS);
-    message.data = NULL;
-    message.len  = 0;
-
-    rv = CMT_SendMessage(control, &message);
-
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_PKCS11_ACTION |
-			 SSM_ENABLED_CIPHERS)) {
-        goto loser;
-    }
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, 
-                          &message) != CMTSuccess) {
-        goto loser;
-    }
-    *capabilites = reply.value;
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}

mozilla/security/psm/lib/client/cmtjs.h

@@ -1,555 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef _CMTJS_H_
-#define _CMTJS_H_
-#include "cmtcmn.h"
-#include "ssmdefs.h"
-#include "rsrcids.h"
-/*
- * Define some constants.
- */
-
-/*
- * These defines are used in conjuction with the function
- * CMT_AddNewModule.
- */
-#define PUBLIC_MECH_RSA_FLAG         0x00000001ul
-#define PUBLIC_MECH_DSA_FLAG         0x00000002ul
-#define PUBLIC_MECH_RC2_FLAG         0x00000004ul
-#define PUBLIC_MECH_RC4_FLAG         0x00000008ul
-#define PUBLIC_MECH_DES_FLAG         0x00000010ul
-#define PUBLIC_MECH_DH_FLAG          0x00000020ul
-#define PUBLIC_MECH_FORTEZZA_FLAG    0x00000040ul
-#define PUBLIC_MECH_RC5_FLAG         0x00000080ul
-#define PUBLIC_MECH_SHA1_FLAG        0x00000100ul
-#define PUBLIC_MECH_MD5_FLAG         0x00000200ul
-#define PUBLIC_MECH_MD2_FLAG         0x00000400ul
- 
-#define PUBLIC_MECH_RANDOM_FLAG      0x08000000ul
-#define PUBLIC_MECH_FRIENDLY_FLAG    0x10000000ul
-#define PUBLIC_OWN_PW_DEFAULTS       0X20000000ul
-#define PUBLIC_DISABLE_FLAG          0x40000000ul
-
-
-/*
- * This is the lone supported constant for the Cipher flag
- * for CMT_AddNewModule
- */
-#define PUBLIC_CIPHER_FORTEZZA_FLAG  0x00000001ul
-
-CMT_BEGIN_EXTERN_C
-
-/*
- * FUNCTION: CMT_GenerateKeyPair
- * -----------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    keyGenContext
- *        The Resource ID of a key gen context to use for creating the
- *        key pair.
- *    mechType
- *        A PKCS11 mechanism used to generate the key pair. Valid values are:
- *          CKM_RSA_PKCS_KEY_PAIR_GEN    0x00000000
- *          CKM_DSA_KEY_PAIR_GEN         0x00000010
- *        The definition of these values can be found at 
- *        http://www.rsa.com/rsalabs/pubs/pkcs11.html
- *        The psm module currently supports v2.01 of PKCS11
- *    params
- *        This parameter will be used to pass parameters to the Key Pair
- *        generation process.  Currently this feature is not supported, so 
- *        pass in NULL for this parameter.
- *    keySize
- *        The size (in bits) of the key to generate.
- *    keyPairId
- *        A pointer to pre-allocated memory where the function can place
- *        the value of the resource ID of the key pair that gets created.
- *
- * NOTES:
- * This function will send a message to the psm server requesting that 
- * a public/private key pair be generated. The key gen context will queue
- * the request. You can send as many key gen requests as you want with a
- * given key gen context. After sending all the key gen requests, the user
- * must call CMT_FinishGeneratingKeys so that the key gen context actually
- * generates the keys.
- *
- * RETURN:
- * A return value of CMTSuccess indicates the request for key generation
- * was queued successfully and the corresponding resource ID can be found
- * at *keyPairId.  Any other return value indicates an error and the value
- * at *keyPairId should be ignored.
- */
-CMTStatus
-CMT_GenerateKeyPair(PCMT_CONTROL control, CMUint32 keyGenContext, 
-		    CMUint32 mechType, CMTItem *params, CMUint32 keySize, 
-		    CMUint32 *keyPairId);
-
-/*
- * FUNCTION: CMT_FinishGeneratingKeys
- * ----------------------------------
- * INPUTS
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    keyGenContext
- *        The resource ID of the key gen context which should finish 
- *        generating its key pairs.
- * NOTES
- * This function will send a message to the psm server notifying the key 
- * gen context with the resource ID of keyGenContext to finish generating
- * all of the key gen requests it has queued up. After each key gen has 
- * finished, the psm server will send a SSM_TASK_COMPLETED_EVENT. So in order
- * to detect when all of the key gens are done, the user should register 
- * an event handler.  See comments for CMT_RegisterEventHandler for information
- * on how to successfully register event handler callbacks. You must register
- * the event handler with keyGenContext as the target resource ID for this
- * to work correctly.
- *
- * RETURN:
- * A return value of CMTSuccess indicates the key gen context has started to
- * generate the key pairs in its queue. Any other return value indicates an
- * error and the key pairs will not be generated.
- */
-CMTStatus
-CMT_FinishGeneratingKeys(PCMT_CONTROL control, CMUint32 keyGenContext);
-
-/*
- * FUNCTION: CMT_CreateNewCRMFRequest
- * ----------------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    keyPairID
- *        The resource ID of the key pair that should be associated with
- *        the CRMF request created. At the time this function is called,
- *        key pair should have already been created. 
- *    keyGenType
- *        An enumeration that explains how the key pair will be used.
- *        Look at the definition of SSMKeyGenType in ssmdefs.h for valid
- *        values and their affects on the request.
- *    reqID
- *        A pointer to a pre-allocatd chunk of memory where the library 
- *        can place the resource ID of the new CRMF request.
- * NOTES:
- * This function sends a message to the psm server requesting that a new 
- * CRMF resource object be created. Each CRMF request must be associated with 
- * a public/private key pair, that is why the keyPairID parameter exists.
- * The keyGenType parameter is used to initialize the request, eg set the
- * correct keyUsage extension.
- * 
- * Before encoding a CRMF request, the user will want to set the appropriate
- * attributes to build up the request. The supported attributes are:
- *
- * Attribute Enumeration          Attribute Type       What value means
- * ---------------------          --------------       ----------------
- * SSM_FID_CRMFREQ_REGTOKEN       String               The value to encode as 
- *                                                     the registration token
- *                                                     value for the request.
- *
- * SSM_FID_CRMFREQ_AUTHENTICATOR String                The value to encode as
- *                                                     authenticator control
- *                                                     in the request.
- * 
- * SSM_FID_DN                    String                The RFC1485 formatted
- *                                                     DN to include in the
- *                                                     CRMF request.
- *
- * For information on how to properly set the attribute of a resource, refer
- * to the comments for the functions CMT_SetNumericAttribute and 
- * CMT_SetStringAttribute.
- *
- * RETURN:
- * A return value of CMTSuccess indicates a new CRMF resource was created by
- * the psm server and has the resource ID placed at *reqID. Any other return
- * value indicates an error and the value at *reqID should be ignored.
- */
-CMTStatus
-CMT_CreateNewCRMFRequest(PCMT_CONTROL control, CMUint32 keyPairID, 
-			 SSMKeyGenType keyGenType, CMUint32 *reqID);
-
-/*
- * FUNCTION: CMT_EncodeCRMFRequest
- * ------------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    crmfReqID
- *        An array of resource ID's for CRMF objects to be encoded.
- *    numRequests
- *        The length of the array crmfReqID that is passed in.
- *    der
- *        A pointer to a pre-allocated pointer for a char* where the library
- *        can place the final DER-encoding of the requests.
- * NOTES
- * This function will send a message to the psm server requesting that 
- * a number of CRMF requests be encoded into their appropriate DER 
- * representation. The DER that is sent back will be of the type 
- * CertReqMessages as define in the internet draft for CRMF. To look at the
- * draft, visit the following URL: 
- * http://search.ietf.org/internet-drafts/internet-draft-ietf-pkix-crmf-01.txt
- *
- * RETURN:
- * A return value of CMTSuccess indicates psm successfully encoded the requests
- * and placed the base64 DER encoded request at *der. Any other return value
- * indicates an error and the value at *der should be ignored.
- */
-CMTStatus
-CMT_EncodeCRMFRequest(PCMT_CONTROL control, CMUint32 *crmfReqID, 
-		      CMUint32 numRequests, char ** der);
-
-/*
- * FUNCTION: CMT_ProcessCMMFResponse
- * ---------------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    nickname
- *        The nickname that should be associated with the certificate 
- *        contained in the CMMF Response.
- *    certRepString
- *        This is the base 64 encoded CertRepContent that issues a certificate.
- *        The psm server will decode the base 64 data and then parse the
- *        CertRepContent.
- *    doBackup
- *        A boolean value indicating whether or not psm should initiate the
- *        process of backing up the newly issued certificate into a PKCS-12
- *        file.
- *    clientContext
- *         Client supplied data pointer that is returned to the client during
- *         a UI event.
- * NOTES:
- * This function takes a CertRepContent as defined in the CMMF internet draft
- * (http://search.ietf.org/internet-drafts/draft-ietf-pkix-cmmf-02.txt) and
- * imports the certificate into the user's database. The certificate will have
- * the string value of nickanme as it's nickname when added to the database
- * unless another certificate with that same Distinguished Name (DN) already
- * exists in the database, in which case the nickname of the certificate that
- * already exists will be used. If the value passed in for doBackup is 
- * non-zero, then the psm server will initiate the process of backing up the
- * certificate(s) that were just imported.
- *
- * RETURN:
- * A return value of CMTSuccess indicates the certificate(s) were successfully
- * added to the database. Any other return value means the certificate(s) could
- * not be successfully added to the database.
- */
-CMTStatus
-CMT_ProcessCMMFResponse(PCMT_CONTROL control, char *nickname, 
-			char *certRepString, CMBool doBackup,
-			void *clientContext);
-
-/*
- * FUNCTION: CMT_CreateResource
- * ----------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    resType
- *        The enumeration representing the resource type to create.
- *    params
- *        A resource dependent binary string that will be sent to the psm 
- *        server. Each resource will expect a binary string it defines.
- *    rsrcId
- *        A pointer to a pre-allocated chunk of memory where the library
- *        can place the resource ID of the newly created resource.
- *    errorCode
- *        A pointer to a pre-allocated chunk of memory where the library
- *        can place the errorCode returned by the psm server after creating
- *        the resource.
- * NOTES:
- * This function sends a message to the psm server requesting that a new 
- * resource be created.  The params parameter depends on the type of resource
- * being created.  Below is a table detailing the format of the params for 
- * a given resource type. Only the resource types listed below can be created
- * by calling this function.
- *
- * Resource Type constant                  Value for params
- * ------------------------------          ----------------
- * SSM_RESTYPE_KEYGEN_CONTEXT              NULL
- * SSM_RESTYPE_SECADVISOR_CONTEXT          NULL
- * SSM_RESTYPE_SIGNTEXT                    NULL
- *
- * RETURN
- * A return value of CMTSuccess means the psm server received the request and
- * processed the create resource create. If the value at *errorCode is zero,
- * then the value at *rsrcId is the resource ID of the newly created resource.
- * Otherwise, creating the new resource failed and *errorCode contains the
- * error code returned by the psm server. ???What are the return values and
- * what do they mean. Any other return value indicates there was an error 
- * in the communication with the psm server and the values at *rsrcId and 
- * *errorCode should be ignored.
- */
-CMTStatus
-CMT_CreateResource(PCMT_CONTROL control, SSMResourceType resType,
-		   CMTItem *params, CMUint32 *rsrcId, CMUint32 *errorCode);
-
-/*
- * FUNCTION: CMT_SignText
- * ----------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    resID
- *        The resource ID of an SSMSignTextResource.
- *    stringToSign
- *        The string that the psm server should sign.
- *    hostName
- *        The host name of the site that is requesting a string to be
- *        signed.  This is used for displaying the UI that tells the user
- *        a web site has requested the use sign some text.
- *    caOption
- *        If the value is "auto" then psm will select the certificate
- *        to use for signing automatically.
- *        If the value is "ask" then psm will display a list of 
- *        certificates for signing.
- *    numCAs
- *        The number of CA names included in the array caNames passed in as
- *        the last parameter to this function.
- *    caNames
- *        An array of CA Names to use for filtering the user certs to use
- *        for signing the text.
- * NOTES
- * This function will sign the text passed via the parameter stringToSign.
- * The function will also cause the psm server to send some UI notifying the
- * user that a site has requested the user sign some text.  The hostName 
- * parameter is used in the UI to inform the user which site is requesting
- * the signed text.  The caOption is used to determine if the psm server 
- * should automatically select which personal cert to use in signing the
- * text.  The caNames array is ussed to narrow down the field of personal
- * certs to use when signing the text. In other words, only personal certs 
- * trusted by the CA's passed in will be used.
- *
- * RETURN
- * If the function returns CMTSuccess, that indicates the psm server 
- * successfully signed the text.  The signed text can be retrieved by 
- * calling CMT_GetStringResource and passing in SSM_FID_SIGNTEXT_RESULT
- * as the field ID. Any other return value indicates an error meaning the
- * string was not signed successfully.
- */
-CMTStatus
-CMT_SignText(PCMT_CONTROL control, CMUint32 resID, char* stringToSign,
-             char* hostName, char *caOption, CMInt32 numCAs, char** caNames);
-
-/*
- * FUNCTION: CMT_ProcessChallengeResponse
- * --------------------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    challengeString
- *        The base64 encoded Challenge string received as the 
- *        Proof-Of-Possession Challenge in response to CRMF request that
- *        specified Challenge-Reponse as the method for Proof-Of-Possession.
- *    responseString
- *        A pointer to pre-allocated char* where the library can place a
- *        copy of the bas64 encoded response to the challenge presented.
- * NOTES
- * This function takes the a challenge--that is encrypted with the public key
- * of a certificate we created--and decrypts it with the private key we 
- * generated.  The format of the challenge is as follows:
- *
- * Challenge ::= SEQUENCE { 
- *      owf                 AlgorithmIdentifier  OPTIONAL, 
- *      -- MUST be present in the first Challenge; MAY be omitted in any 
- *      -- subsequent Challenge in POPODecKeyChallContent (if omitted, 
- *      -- then the owf used in the immediately preceding Challenge is 
- *      -- to be used). 
- *      witness             OCTET STRING, 
- *      -- the result of applying the one-way function (owf) to a 
- *      -- randomly-generated INTEGER, A.  [Note that a different 
- *      -- INTEGER MUST be used for each Challenge.] 
- *      sender              GeneralName, 
- *      -- the name of the sender. 
- *      key                 OCTET STRING, 
- *      -- the public key used to encrypt the challenge.  This will allow 
- *      -- the client to find the appropriate key to do the decryption. 
- *      challenge           OCTET STRING 
- *      -- the encryption (under the public key for which the cert. 
- *      -- request is being made) of Rand, where Rand is specified as 
- *      --   Rand ::= SEQUENCE { 
- *      --      int      INTEGER, 
- *      --       - the randomly-generated INTEGER A (above) 
- *      --      senderHash  OCTET STRING 
- *      --       - the result of applying the one-way function (owf) to 
- *      --       - the sender's general name 
- *      --   } 
- *      -- the size of "int" must be small enough such that "Rand" can be 
- *      -- contained within a single PKCS #1 encryption block. 
- *  } 
- * This challenge is based on the Challenge initially defined in the CMMF
- * internet draft, but differs in that this structure includes the sender
- * as part of the challenge along with the public key and includes a has
- * of the sender in the encrypted Rand structure.  The reason for including
- * the key is to facilitate looking up the key that should be used to 
- * decipher the challenge.  Including the hash of the sender in the encrypted
- * Rand structure makes the challenge smaller and allows it to fit in 
- * one RSA block. 
- *
- * The response is of the type POPODecKeyRespContent as defined in the CMMF
- * internet draft.
- *
- * RETURN
- * A return value of CMTSuccess indicates psm successfully parsed and processed
- * the challenge and created a response.  The base64 encoded response to the
- * challenge is placed at *responseString.  Any other return value indicates
- * an error and the value at *responseString should be ignored.
- */
-CMTStatus
-CMT_ProcessChallengeResponse(PCMT_CONTROL control, char *challengeString,
-			     char **responseString);
-
-/*
- * FUNCTION: CMT_GetLocalizedString
- * --------------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    whichString
- *        The enumerated value corresponding to the localized string to 
- *        retrieve from the psm server
- *    localizedString
- *        A pointer to a pre-allocated char* where the library can place 
- *        copy of the localized string retrieved from the psm server.
- * NOTES
- * This function retrieves a localized string from the psm server.  These 
- * strings are useful for strings that aren't localized in the client 
- * making use of the psm server, but need to be displayed by the user. Look
- * in protocol.h for the enumerations of the localized strings that can 
- * be fetched from psm via this method.
- *
- * RETURN
- * A return value of CMTSuccess indicates the localized string was retrieved
- * successfully and the localized value is located at *localizedString.  Any
- * other return value indicates an error and the value at *localizedString
- * should be ignored.
- */
-CMTStatus 
-CMT_GetLocalizedString(PCMT_CONTROL        control, 
-                       SSMLocalizedString  whichString,
-                       char              **localizedString); 
-
-/*
- * FUNCTION: CMT_DeleteModule
- * --------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    moduleName
- *        The name of the PKCS11 module to delete.
- *    moduleType
- *        A pointer to a pre-allocated integer where the library can place
- *        a value that tells what the type of module was deleted.
- * NOTES
- * This function will send a message to the psm server requesting the server 
- * delete a PKCS-11 module stored in psm's security module database. moduleName
- * is the value passed in as moduleName when the module was added to the 
- * security module database of psm.
- * The values that may be returned by psm for moduleType are:
- *
- *    0      The module was an external module developped by a third party
- *           that was added to the psm security module.
- *
- *    1      The module deleted was the internal PKCS-11 module that comes
- *           built in with the psm server.
- *
- *    2      The module that was deleted was the FIPS  internal module.
- *
- * RETURN
- * A return value of CMTSuccess indicates the security module was successfully
- * delete from the psm security module database and the value at *moduleType
- * will tell what type of module was deleted.
- * Any other return value indicates an error and the value at *moduleType 
- * should be ignored.
- */
-CMTStatus
-CMT_DeleteModule(PCMT_CONTROL  control,
-                 char         *moduleName,
-                 int          *moduleType);
-
-
-/*
- * FUNCTION: CMT_AddNewModule
- * --------------------------
- * INPUTS:
- *    control
- *        The Control Connection that has already established a connection
- *        with the psm server.
- *    moduleName
- *        The name to be associated with the module once it is added to 
- *        the psm security module database.
- *    libraryPath
- *        The path to the library to be  loaded.  The library should be 
- *        loadable at run-time.
- *    pubMechFlags
- *        A bit vector indicating all cryptographic mechanisms that should
- *        be turned on by default.  This module will become the default 
- *        handler for the mechanisms that are set by this bit vector.
- *    pubCipherFlags
- *        A bit vector indicating all SSL or S/MIME cipher functions
- *        supported by the module. Most modules will pas in 0x0 for this
- *        parameter.
- * NOTES:
- * This function sends a message to the psm server and requests the .so
- * file on UNIX or .dll file on Windows be loaded as a PKCS11 module and 
- * be stored in the psm security module database.  The module will be stored
- * with the name moduleName that is passed in and will always expect the 
- * library to live at the path passed in via the parameter libraryPath.
- * The pubMechFlags tell the psm server how this module should be used.
- * Valid values are the #define constants defined at the beginning of
- * this file.
- * 
- * RETURN
- * A return value of CMTSuccess indicates the module was successfully loaded
- * and placed in the security module database of psm.  Any other return value
- * indicates an error and means the module was not loaded successfully and
- * not stored in the psm server's security module database.
- */
-CMTStatus
-CMT_AddNewModule(PCMT_CONTROL  control,
-                 char         *moduleName,
-                 char         *libraryPath,
-                 unsigned long pubMechFlags,
-                 unsigned long pubCipherFlags);
-
-CMT_END_EXTERN_C
-
-#endif /*_CMTJS_H_*/

mozilla/security/psm/lib/client/cmtmac.c

@@ -1,75 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-
-#include "cmtmac.h"
-#include "macsocket.h"
-#include "stdlib.h"
-
-#ifndef XP_MAC
-#error Link with the builtin strdup() on your platform.
-#endif
-
-
-static void 
-my_strcpy(char *dest, const char *source)
-{
-	char *i = dest;
-	const char *j = source;
-	while(*j)
-		*i++ = *j++;
-	*i = '\0';
-}
-
-static int
-my_strlen(const char *str)
-{
-	const char *c = str;
-	int i = 0;
-	
-	while(*c++ != '\0')
-		i++;
-	return i;
-}
-
-char * strdup(const char *oldstr)
-{
-	/* used to keep the mac client library from referring to strdup elsewhere */
-	char *newstr;
-	
-	newstr = (char *) malloc(my_strlen(oldstr)+1);
-	if (newstr)
-		my_strcpy(newstr, oldstr);
-	return newstr;
-}
-

mozilla/security/psm/lib/client/cmtmac.h

@@ -1,40 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-
-#ifndef __CMTMAC_H__
-#define __CMTMAC_H__
-
-char * strdup(const char *str);
-
-#endif

mozilla/security/psm/lib/client/cmtpasswd.c

@@ -1,119 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/************************************************************************
- * Code to handle password requests from the the PSM module.
- * 
- ************************************************************************
- */
-
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-
-void CMT_SetAppFreeCallback(PCMT_CONTROL control, 
-			    applicationFreeCallback_fn f)
-{
-  control->userFuncs.userFree = f;
-}
-    
-void CMT_ServicePasswordRequest(PCMT_CONTROL cm_control, CMTItem * requestData)
-{ 
-  CMTItem response = {0, NULL, 0};
-  PasswordRequest request;
-  PasswordReply reply;
-  void * clientContext;
-
-  /********************************************
-   *  What we trying to do here: 
-   *  1) Throw up a dialog box and request a password.
-   *  2) Create a message and send it to the PSM module.
-   ********************************************
-   */
-  
-  /* Decode the request */
-  if (CMT_DecodeMessage(PasswordRequestTemplate, &request, requestData) != CMTSuccess) {
-      goto loser;
-  }
-
-  /* Copy the client context to a pointer */
-  clientContext = CMT_CopyItemToPtr(request.clientContext);
-
-  if (cm_control->userFuncs.promptCallback == NULL) {
-      goto loser;
-  }
-  reply.passwd = 
-    cm_control->userFuncs.promptCallback(cm_control->userFuncs.promptArg, 
-					 request.prompt, clientContext, 1);
-  reply.tokenID = request.tokenKey;
-  if (!reply.passwd) {
-      /* the user cancelled the prompt or other errors occurred */
-      reply.result = -1;
-  }
-  else {
-      /* note that this includes an empty string (zero length password) */
-      reply.result = 0;
-  }
-
-  /* Encode the reply */
-  if (CMT_EncodeMessage(PasswordReplyTemplate, &response, &reply) != CMTSuccess) {
-      goto loser;
-  }
-
-  /* Set the message response type */
-  response.type = SSM_EVENT_MESSAGE | SSM_AUTH_EVENT;
-  CMT_TransmitMessage(cm_control, &response);
-  goto done;
-loser:
-  /* something has gone wrong */
-
-done:
-  /*clean up anyway */
-  /* We can't just free up memory allocated by the host
-     application because the versions of free may not match up.
-     When you run the plug-in with an optimized older browser,
-     you'll see tons of Asserts (why they still have asserts in an
-     optimized build is a different question, but without them 
-     I wouldn't have figured out this problem) about a pointer not
-     being a valid heap pointer and eventually crash.  This was 
-     the offending free line.
-     So we need to call a function within the browser that 
-     calls the free linked in with it.  js_free is
-     such a function.  But this is extremely ugly.
-   */
-  if (reply.passwd) 
-    cm_control->userFuncs.userFree(reply.passwd);
-  if (request.prompt) 
-    free(request.prompt);
-  return;
-}
-

mozilla/security/psm/lib/client/cmtpkcs7.c

@@ -1,636 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <sys/time.h>
-#else
-#ifdef XP_MAC
-#include "macsocket.h"
-#else /* Windows */
-#include <windows.h>
-#include <winsock.h>
-#endif
-#endif
-#include <errno.h>
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include "rsrcids.h"
-
-typedef struct _CMTP7Private {
-    CMTPrivate priv;
-    CMTP7ContentCallback cb;
-    void *cb_arg;
-} CMTP7Private;
-
-CMTStatus CMT_PKCS7DecoderStart(PCMT_CONTROL control, void* clientContext, CMUint32 * connectionID, CMInt32 * result,
-                                CMTP7ContentCallback cb, void *cb_arg)
-{
-    CMTItem message;
-    CMTStatus rv;
-    CMTP7Private *priv=NULL;
-    SingleItemMessage request;
-    DataConnectionReply reply;
-
-    /* Check passed in parameters */
-    if (!control) {
-        goto loser;
-    }
-
-    request.item = CMT_CopyPtrToItem(clientContext);
-
-    /* Encode message */
-    if (CMT_EncodeMessage(SingleItemMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | SSM_PKCS7DECODE_STREAM;
-
-    /* Send the message. */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | SSM_PKCS7DECODE_STREAM)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        CMTSocket sock;
-
-        priv = (CMTP7Private *)malloc(sizeof(CMTP7Private));
-        if (priv == NULL)
-            goto loser;
-        priv->priv.dest = (CMTReclaimFunc) free;
-        priv->cb = cb;
-        priv->cb_arg = cb_arg;
-        sock = control->sockFuncs.socket(0);
-        if (sock == NULL) {
-            goto loser;
-        }
- 
-       if (control->sockFuncs.connect(sock, (short)reply.port, 
-                                      NULL) != CMTSuccess) {
-            goto loser;
-        }
- 
-        if (control->sockFuncs.send(sock, control->nonce.data, 
-                                    control->nonce.len) != control->nonce.len){
-            goto loser;
-        }
-
-        /* Save connection info */
-        if (CMT_AddDataConnection(control, sock, reply.connID)
-            != CMTSuccess) {
-            goto loser;
-        }
-        *connectionID = reply.connID;
-
-        rv = CMT_SetPrivate(control, reply.connID, &priv->priv);
-        if (rv != CMTSuccess)
-            goto loser;
-
-        return CMTSuccess;
-    } 
-
-loser:
-    if (priv) {
-        free(priv);
-    }
-
-	*result = reply.result;
-    return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7DecoderUpdate(PCMT_CONTROL control, CMUint32 connectionID, const char * buf, CMUint32 len)
-{
-    CMUint32 sent;
-    CMTP7Private *priv;
-    unsigned long nbytes;
-    char read_buf[128];
-    CMTSocket sock, ctrlsock, selSock, sockArr[2];
-
-    /* Do some parameter checking */
-    if (!control || !buf) {
-        goto loser;
-    }
-
-    /* Get the data socket */
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    priv = (CMTP7Private *)CMT_GetPrivate(control, connectionID);
-    if (priv == NULL)
-        goto loser;
-
-    /* Write the data to the socket */
-    sent = CMT_WriteThisMany(control, sock, (void*)buf, len);
-    if (sent != len) {
-        goto loser;
-    }
-
-	ctrlsock = control->sock;
-	sockArr[0] = ctrlsock;
-	sockArr[1] = sock;
-    while ((selSock = control->sockFuncs.select(sockArr,2,1))) 
-    {
-		if (selSock == ctrlsock) {
-			CMT_ProcessEvent(control);
-		} else {
-	        nbytes = control->sockFuncs.recv(sock, read_buf, sizeof(read_buf));
-		    if (nbytes == -1) {
-			    goto loser;
-			}
-			if (nbytes == 0) {
-	            break;
-		    }
-			priv->cb(priv->cb_arg, read_buf, nbytes);
-		}
-    }
-
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-                                                                                
-CMTStatus CMT_PKCS7DecoderFinish(PCMT_CONTROL control, CMUint32 connectionID, 
-                                 CMUint32 * resourceID)
-{
-    CMTP7Private *priv;
-    long nbytes;
-    char buf[128];
-    CMTSocket sock, ctrlsock, selSock, sockArr[2];
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    priv = (CMTP7Private *)CMT_GetPrivate(control, connectionID);
-    if (priv == NULL)
-        goto loser;
-
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    ctrlsock = control->sock;
-    /* drain socket before we close it */
-    control->sockFuncs.shutdown(sock);
-    sockArr[0] = sock;
-    sockArr[1] = ctrlsock;
-    /* Let's see if doing a poll first gets rid of a weird bug where we
-     * lock up the client.
-     */
-#ifndef XP_MAC
-    if (control->sockFuncs.select(sockArr,2,1) != NULL)
-#endif
-	{
-        while (1) {
-            selSock = control->sockFuncs.select(sockArr,2,0);
-            if (selSock == ctrlsock) {
-                CMT_ProcessEvent(control);
-            } else if (selSock == sock) {
-                nbytes = control->sockFuncs.recv(sock, buf, sizeof(buf));
-                if (nbytes < 0) {
-                    goto loser;
-                } else if (nbytes == 0) {
-                    break;
-                }
-                priv->cb(priv->cb_arg, buf, nbytes);
-            }
-        }
-    }
-    
-    if (CMT_CloseDataConnection(control, connectionID) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Get the PKCS7 content info */
-    if (CMT_GetRIDAttribute(control, connectionID, SSM_FID_P7CONN_CONTENT_INFO,
-                            resourceID) == CMTFailure) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-
-loser:
-    if (control) {
-        CMT_CloseDataConnection(control, connectionID);
-    }
-    
-    return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7DestroyContentInfo(PCMT_CONTROL control, CMUint32 resourceID)
-{
-    if (!control) {
-        goto loser;
-    }
-
-    /* Delete the resource */
-    if (CMT_DestroyResource(control, resourceID, SSM_FID_P7CONN_CONTENT_INFO) == CMTFailure) {
-        goto loser;
-    }
-    return CMTSuccess;
-
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7VerifyDetachedSignature(PCMT_CONTROL control, CMUint32 resourceID, CMUint32 certUsage, CMUint32 hashAlgID, CMUint32 keepCerts, CMTItem* digest, CMInt32 * result)
-{
-    CMTItem message;
-    VerifyDetachedSigRequest request;
-    SingleNumMessage reply;
-
-    /* Do some parameter checking */
-    if (!control || !digest || !result) {
-        goto loser;
-    }
-
-    /* Set the request */
-    request.pkcs7ContentID = resourceID;
-    request.certUsage = certUsage;
-    request.hashAlgID = hashAlgID;
-    request.keepCert = (CMBool) keepCerts;
-    request.hash = *digest;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(VerifyDetachedSigRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_OBJECT_SIGNING | SSM_VERIFY_DETACHED_SIG;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_OBJECT_SIGNING |SSM_VERIFY_DETACHED_SIG)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *result = reply.value;
-    return CMTSuccess;
-loser:
-	*result = reply.value;
-	return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7VerifySignature(PCMT_CONTROL control, CMUint32 pubKeyAlgID,
-                                   CMTItem *pubKeyParams, CMTItem *signerPubKey,
-                                   CMTItem *computedHash, CMTItem *signature,
-                                   CMInt32 *result)
-{
-	return CMTFailure;
-}
-
-CMTStatus CMT_CreateSigned(PCMT_CONTROL control, CMUint32 scertRID,
-                           CMUint32 ecertRID, CMUint32 dig_alg,
-                           CMTItem *digest, CMUint32 *ciRID, CMInt32 *errCode)
-{
-    CMTItem message;
-    CreateSignedRequest request;
-    CreateContentInfoReply reply;
-
-    /* Do some parameter checking */
-    if (!control || !scertRID || !ecertRID || !digest || !ciRID) {
-        goto loser;
-    }
-
-    /* Set the request */
-    request.scertRID = scertRID;
-    request.ecertRID = ecertRID;
-    request.dig_alg = dig_alg;
-    request.digest = *digest;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(CreateSignedRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_OBJECT_SIGNING | SSM_CREATE_SIGNED;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_OBJECT_SIGNING | SSM_CREATE_SIGNED)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(CreateContentInfoReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *ciRID = reply.ciRID;
-    if (reply.result == 0) {
-		return CMTSuccess;
-	} 
-
-loser:
-    if (CMT_DecodeMessage(CreateContentInfoReplyTemplate, &reply, &message) == CMTSuccess) {
-        *errCode = reply.errorCode;
-    } else {
-        *errCode = 0;
-    }
-	return CMTFailure;
-}
-
-CMTStatus CMT_CreateEncrypted(PCMT_CONTROL control, CMUint32 scertRID,
-                              CMUint32 *rcertRIDs, CMUint32 *ciRID)
-{
-    CMTItem message;
-    CMInt32 nrcerts;
-    CreateEncryptedRequest request;
-    CreateContentInfoReply reply;
-
-    /* Do some parameter checking */
-    if (!control || !scertRID || !rcertRIDs || !ciRID) {
-        goto loser;
-    }
-
-    /* Calculate the number of certs */
-    for (nrcerts =0; rcertRIDs[nrcerts] != 0; nrcerts++) {
-        /* Nothing */
-        ;
-    }
-
-    /* Set up the request */
-    request.scertRID = scertRID;
-    request.nrcerts = nrcerts;
-    request.rcertRIDs = (long *) rcertRIDs;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(CreateEncryptedRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_OBJECT_SIGNING | SSM_CREATE_ENCRYPTED;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message response type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_OBJECT_SIGNING | SSM_CREATE_ENCRYPTED)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(CreateContentInfoReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *ciRID = reply.ciRID;
-    if (reply.result == 0) {
-		return CMTSuccess;
-	} 
-loser:
-	return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7EncoderStart(PCMT_CONTROL control, CMUint32 ciRID,
-                                CMUint32 *connectionID, CMTP7ContentCallback cb,
-                                void *cb_arg)
-{
-    CMTItem message;
-    CMTStatus rv;
-    CMTP7Private *priv;
-    PKCS7DataConnectionRequest request;
-    DataConnectionReply reply;
-
-    /* Check passed in parameters */
-    if (!control || !ciRID) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = ciRID;
-    request.clientContext.len = 0;
-    request.clientContext.data = NULL;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(PKCS7DataConnectionRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | SSM_PKCS7ENCODE_STREAM;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | SSM_PKCS7ENCODE_STREAM)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        CMTSocket sock;
-
-        priv = (CMTP7Private *)malloc(sizeof(CMTP7Private));
-        if (priv == NULL)
-            goto loser;
-        priv->priv.dest = (CMTReclaimFunc) free;
-        priv->cb = cb;
-        priv->cb_arg = cb_arg;
-
-        sock = control->sockFuncs.socket(0);
-        if (sock == NULL) {
-            goto loser;
-        }
-        if (control->sockFuncs.connect(sock, (short)reply.port, 
-                                       NULL) != CMTSuccess) {
-            goto loser;
-        }
-        if (control->sockFuncs.send(sock, control->nonce.data, 
-                                   control->nonce.len) != control->nonce.len) {
-            goto loser;
-        }
-        /* Save connection info */
-        if (CMT_AddDataConnection(control, sock, reply.connID)
-            != CMTSuccess) {
-            goto loser;
-        }
-        *connectionID = reply.connID;
-
-        rv = CMT_SetPrivate(control, reply.connID, &priv->priv);
-        if (rv != CMTSuccess)
-            goto loser;
-        return CMTSuccess;
-    } 
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7EncoderUpdate(PCMT_CONTROL control, CMUint32 connectionID,
-                                 const char *buf, CMUint32 len)
-{
-    CMUint32 sent;
-    CMTP7Private *priv;
-    unsigned long nbytes;
-    char read_buf[128];
-    CMTSocket sock, ctrlsock, sockArr[2], selSock;
-
-    /* Do some parameter checking */
-    if (!control || !connectionID || !buf) {
-        goto loser;
-    }
-
-    /* Get the data socket */
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    priv = (CMTP7Private *)CMT_GetPrivate(control, connectionID);
-    if (priv == NULL)
-        goto loser;
-
-    /* Write the data to the socket */
-    sent = CMT_WriteThisMany(control, sock, (void*)buf, len);
-    if (sent != len) {
-        goto loser;
-    }
-	ctrlsock = control->sock;
-	sockArr[0] = ctrlsock;
-	sockArr[1] = sock;
-    while ((selSock = control->sockFuncs.select(sockArr, 2, 1)) != NULL) 
-    {
-		if (selSock == ctrlsock) {
-			CMT_ProcessEvent(control);
-		} else {
-	        nbytes = control->sockFuncs.recv(sock, read_buf, sizeof(read_buf));
-		    if (nbytes == -1) {
-			    goto loser;
-			} else if (nbytes == 0) {
-	            break;
-		    } else {
-			    priv->cb(priv->cb_arg, read_buf, nbytes);
-			}
-		}
-    }
-    return CMTSuccess;
-
-loser:
-
-    return CMTFailure;
-}
-
-CMTStatus CMT_PKCS7EncoderFinish(PCMT_CONTROL control, CMUint32 connectionID)
-{
-    CMTP7Private *priv;
-    unsigned long nbytes;
-    char buf[128];
-    CMTSocket sock, ctrlsock, sockArr[2], selSock;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    priv = (CMTP7Private *)CMT_GetPrivate(control, connectionID);
-    if (priv == NULL)
-        goto loser;
-
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    ctrlsock = control->sock;
-    sockArr[0] = ctrlsock;
-    sockArr[1] = sock;
-    control->sockFuncs.shutdown(sock);
-    while (1) {
-        selSock = control->sockFuncs.select(sockArr, 2, 0);
-        if (selSock == ctrlsock) {
-            CMT_ProcessEvent(control);
-        } else if (selSock == sock) {
-            nbytes = control->sockFuncs.recv(sock, buf, sizeof(buf));
-            if (nbytes < 0) {
-                goto loser;
-            } else if (nbytes == 0) {
-                break;
-            } else {
-                priv->cb(priv->cb_arg, buf, nbytes);
-            }
-        }
-    }
-    if (CMT_CloseDataConnection(control, connectionID) == CMTFailure) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-
-loser:
-    if (control) {
-        CMT_CloseDataConnection(control, connectionID);
-    }
-    
-    return CMTFailure;
-}

mozilla/security/psm/lib/client/cmtres.c

@@ -1,479 +0,0 @@
-/* -*- mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#else
-#ifdef XP_MAC
-#include "macsocket.h"
-#else
-#include <windows.h>
-#include <winsock.h>
-#endif
-#endif
-#include <errno.h>
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include <string.h>
-
-CMTStatus CMT_GetNumericAttribute(PCMT_CONTROL control, CMUint32 resourceID, CMUint32 fieldID, CMInt32 *value)
-{
-    CMTItem message;
-    GetAttribRequest request;
-    GetAttribReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = resourceID;
-    request.fieldID = fieldID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(GetAttribRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_NUMERIC_ATTRIBUTE;
-
-    /* Send the mesage and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_NUMERIC_ATTRIBUTE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(GetAttribReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    *value = reply.value.u.numeric;
-
-    /* Success */
-    if (reply.result == 0) {
-        return CMTSuccess;
-    } 
-
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_SetNumericAttribute(PCMT_CONTROL control, CMUint32 resourceID,
-				  CMUint32 fieldID, CMInt32 value)
-{
-    CMTItem message;
-    SetAttribRequest request;
-
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set the request */
-    request.resID = resourceID;
-    request.fieldID = fieldID;
-    request.value.type = SSM_NUMERIC_ATTRIBUTE;
-    request.value.u.numeric = value;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(SetAttribRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | 
-                   SSM_SET_ATTRIBUTE | SSM_NUMERIC_ATTRIBUTE;
-
-    if (CMT_SendMessage(control, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | 
-                              SSM_SET_ATTRIBUTE    | SSM_NUMERIC_ATTRIBUTE)) {
-        goto loser;
-    }
-
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_PadStringValue(CMTItem *dest, CMTItem src)
-{
-    dest->data = NewArray(unsigned char, src.len+1);
-    if (dest->data == NULL) {
-        return CMTFailure;
-    }
-    memcpy(dest->data, src.data, src.len);
-    dest->data[src.len] = '\0';
-    dest->len = src.len;
-    free(src.data);
-    return CMTSuccess;
-}
-
-CMTStatus CMT_GetStringAttribute(PCMT_CONTROL control, CMUint32 resourceID, CMUint32 fieldID, CMTItem *value)
-{
-    CMTItem message;
-    GetAttribRequest request;
-    GetAttribReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = resourceID;
-    request.fieldID = fieldID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(GetAttribRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_STRING_ATTRIBUTE;
-    
-    /* Send the mesage and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_STRING_ATTRIBUTE)) {
-        goto loser;
-    }
-
-    /* Decode the response */
-    if (CMT_DecodeMessage(GetAttribReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        return CMT_PadStringValue(value, reply.value.u.string);
-    } 
-loser:
-    return CMTFailure;
-}
-
-CMTStatus
-CMT_SetStringAttribute(PCMT_CONTROL control, CMUint32 resourceID,
-		       CMUint32 fieldID, CMTItem *value)
-{
-    CMTItem message;
-    SetAttribRequest request;
-    
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = resourceID;
-    request.fieldID = fieldID;
-    request.value.type = SSM_STRING_ATTRIBUTE;
-    request.value.u.string = *value;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SetAttribRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | 
-                   SSM_SET_ATTRIBUTE | SSM_STRING_ATTRIBUTE;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Validate the message request type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | 
-                         SSM_SET_ATTRIBUTE    | SSM_STRING_ATTRIBUTE)) {
-        goto loser;
-    }
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_DuplicateResource(PCMT_CONTROL control, CMUint32 resourceID,
-				CMUint32 *newResID)
-{
-    CMTItem message;
-    SingleNumMessage request;
-    DupResourceReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.value = resourceID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_DUPLICATE_RESOURCE;
-
-    /* Send the mesage */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_DUPLICATE_RESOURCE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(DupResourceReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        *newResID = reply.resID;
-        return CMTSuccess;
-    } 
-
-loser:
-    *newResID = 0;
-    return CMTFailure;
-}
-
-CMTStatus CMT_DestroyResource(PCMT_CONTROL control, CMUint32 resourceID, CMUint32 resourceType)
-{
-    CMTItem message;
-    DestroyResourceRequest request;
-    SingleNumMessage reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resID = resourceID;
-    request.resType = resourceType;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(DestroyResourceRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_DESTROY_RESOURCE;
-
-    /* Send the message */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_DESTROY_RESOURCE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.value == 0) {
-        return CMTSuccess;
-    }
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_PickleResource(PCMT_CONTROL control, CMUint32 resourceID, CMTItem * pickledResource)
-{
-    CMTItem message;
-    SingleNumMessage request;
-    PickleResourceReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.value = resourceID;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_CONSERVE_RESOURCE | SSM_PICKLE_RESOURCE;
-
-    /* Send the mesage and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_CONSERVE_RESOURCE | SSM_PICKLE_RESOURCE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(PickleResourceReplyTemplate, &reply,&message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        *pickledResource = reply.blob;
-        return CMTSuccess;
-    } 
-
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_UnpickleResource(PCMT_CONTROL control, CMUint32 resourceType, CMTItem pickledResource, CMUint32 * resourceID)
-{
-    CMTItem message;
-    UnpickleResourceRequest request;
-    UnpickleResourceReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set up the request */
-    request.resourceType = resourceType;
-    request.resourceData = pickledResource;
-
-    /* Encode the request */
-    if (CMT_EncodeMessage(UnpickleResourceRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_CONSERVE_RESOURCE | SSM_UNPICKLE_RESOURCE;
-    
-    /* Send the mesage and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_CONSERVE_RESOURCE | SSM_UNPICKLE_RESOURCE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(UnpickleResourceReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        *resourceID = reply.resID;
-        return CMTSuccess;
-    } 
-
-loser:
-    *resourceID = 0;
-    return CMTFailure;
-}
-
-CMTStatus CMT_GetRIDAttribute(PCMT_CONTROL control, CMUint32 resourceID, CMUint32 fieldID, CMUint32 *value)
-{
-    CMTItem message;
-    GetAttribRequest request;
-    GetAttribReply reply;
-
-    /* Do some parameter checking */
-    if (!control) {
-        goto loser;
-    }
-
-    /* Set the request */
-    request.resID = resourceID;
-    request.fieldID = fieldID;
-
-    /* Encode the message */
-    if (CMT_EncodeMessage(GetAttribRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_RID_ATTRIBUTE;
-
-    /* Send the mesage and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message response type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION | SSM_GET_ATTRIBUTE | SSM_RID_ATTRIBUTE)) {
-        goto loser;
-    }
-
-    /* Decode the reply */
-    if (CMT_DecodeMessage(GetAttribReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Success */
-    if (reply.result == 0) {
-        *value = reply.value.u.rid;
-        return CMTSuccess;
-    } 
-loser:
-    return CMTFailure;
-}
- 

mozilla/security/psm/lib/client/cmtrng.c

@@ -1,270 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*
-  cmtrng.c -- Support for PSM random number generator and the seeding
-              thereof with data from the client.
-
-  Created by mwelch 1999 Oct 21
- */
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include "rsrcids.h"
-#include <string.h>
-
-CMTStatus
-CMT_EnsureInitializedRNGBuf(PCMT_CONTROL control)
-{
-    if (control->rng.outBuf == NULL)
-    {
-        control->rng.outBuf = (char *) calloc(RNG_OUT_BUFFER_LEN, sizeof(char));
-        if (control->rng.outBuf == NULL)
-            goto loser;
-
-        control->rng.validOutBytes = 0;
-        control->rng.out_cur = control->rng.outBuf;
-        control->rng.out_end = control->rng.out_cur + RNG_OUT_BUFFER_LEN;
-        
-        control->rng.inBuf = (char *) calloc(RNG_IN_BUFFER_LEN, sizeof(char));
-        if (control->rng.outBuf == NULL)
-            goto loser;
-    }
-
-    return CMTSuccess;
-
- loser:
-    if (control->rng.outBuf != NULL)
-    {
-        free(control->rng.outBuf);
-        control->rng.outBuf = NULL;
-    }
-    if (control->rng.inBuf != NULL)
-    {
-        free(control->rng.inBuf);
-        control->rng.inBuf = NULL;
-    }
-
-    return CMTFailure;
-}
-
-
-size_t 
-CMT_RequestPSMRandomData(PCMT_CONTROL control, 
-                         void *buf, CMUint32 maxbytes)
-{
-    SingleNumMessage req;
-    SingleItemMessage reply;
-    CMTItem message;
-    size_t rv = 0;
-    
-    /* Parameter checking */
-    if (!control || !buf || (maxbytes == 0))
-        goto loser;
-
-    /* Initialization. */
-    memset(&reply, 0, sizeof(SingleItemMessage));
-
-    /* Ask PSM for the data. */
-    req.value = maxbytes;
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &req) != CMTSuccess)
-        goto loser;
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_MISC_ACTION | SSM_MISC_GET_RNG_DATA;
-    
-    /* Send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure)
-        goto loser;
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_MISC_ACTION | SSM_MISC_GET_RNG_DATA))
-        goto loser;
-
-    /* Decode message */
-    if (CMT_DecodeMessage(SingleItemMessageTemplate, &reply, &message) != CMTSuccess)
-        goto loser;
-
-    /* Success - fill the return buf with what we got */
-    if (reply.item.len > maxbytes)
-        reply.item.len = maxbytes;
-
-    memcpy(buf, reply.item.data, reply.item.len);
-    rv = reply.item.len;
-
- loser:
-    if (reply.item.data)
-        free(reply.item.data);
-    if (message.data)
-        free(message.data);
-
-    return rv;
-}
-
-size_t 
-CMT_GenerateRandomBytes(PCMT_CONTROL control, 
-                        void *buf, CMUint32 maxbytes)
-{
-    CMUint32 remaining = maxbytes;
-    CMT_RNGState *rng = &(control->rng);
-    char *walk = (char *) buf;
-
-    /* Is there already enough in the incoming cache? */
-    while(remaining > rng->validInBytes)
-    {
-        /* Get what we have on hand. */
-        memcpy(walk, rng->in_cur, rng->validInBytes);
-        walk += rng->validInBytes;
-        remaining -= rng->validInBytes;
-
-        /* Request a buffer from PSM. */
-        rng->validInBytes = CMT_RequestPSMRandomData(control, 
-                                                     rng->inBuf, 
-                                                     RNG_IN_BUFFER_LEN);
-        if (rng->validInBytes == 0)
-            return (maxbytes - remaining); /* call failed */
-        rng->in_cur = rng->inBuf;
-    }
-    if (remaining > 0)
-    {
-        memcpy(walk, rng->in_cur, remaining);
-        rng->in_cur += remaining;
-        rng->validInBytes -= remaining;
-    }
-    return maxbytes;
-}
-
-void
-cmt_rng_xor(void *dstBuf, void *srcBuf, int len)
-{
-    unsigned char *s = (unsigned char*) srcBuf;
-    unsigned char *d = (unsigned char*) dstBuf;
-    unsigned char tmp;
-    int i;
-
-    for(i=0; i<len; i++, s++, d++)
-    {
-        tmp = *d;
-        /* I wish C had circular shift operators. So do others on the team. */
-        tmp = ((tmp << 1) | (tmp >> 7));
-        *d = tmp ^ *s;
-    }
-}
-
-CMTStatus 
-CMT_RandomUpdate(PCMT_CONTROL control, void *data, size_t numbytes)
-{
-    size_t dataLeft = numbytes, cacheLeft;
-    char *walk = (char *) data;
-
-    if (CMT_EnsureInitializedRNGBuf(control) != CMTSuccess)
-        goto loser;
-
-    /* If we have more than what the buffer can handle, wrap around. */
-    cacheLeft = (control->rng.out_end - control->rng.out_cur);
-    while (dataLeft >= cacheLeft)
-    {
-        cmt_rng_xor(control->rng.out_cur, walk, cacheLeft);
-        walk += cacheLeft;
-        dataLeft -= cacheLeft;
-
-        control->rng.out_cur = control->rng.outBuf;
-
-        /* Max out used space */
-        control->rng.validOutBytes = cacheLeft = RNG_OUT_BUFFER_LEN;
-    }
-
-    /* 
-       We now have less seed data available than we do space in the buf.
-       Write what we have and update validOutBytes if we're not looping already.
-     */
-    cmt_rng_xor(control->rng.out_cur, walk, dataLeft);
-    control->rng.out_cur += dataLeft;
-    if (control->rng.validOutBytes < RNG_OUT_BUFFER_LEN)
-        control->rng.validOutBytes += dataLeft;
-
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-size_t
-CMT_GetNoise(PCMT_CONTROL control, void *buf, CMUint32 maxbytes)
-{
-    /* ### mwelch - GetNoise and GenerateRandomBytes can be the 
-       same function now, because presumably the RNG is being 
-       seeded with environmental noise on the PSM end before we 
-       make any of these requests */
-    return CMT_GenerateRandomBytes(control, buf, maxbytes);
-}
-
-CMTStatus 
-CMT_FlushPendingRandomData(PCMT_CONTROL control)
-{
-    CMTItem message;
-
-    memset(&message, 0, sizeof(CMTItem));
-
-    if (CMT_EnsureInitializedRNGBuf(control) != CMTSuccess)
-        return CMTFailure; /* couldn't initialize RNG buffer */
-
-    if (control->rng.validOutBytes == 0)
-        return CMTSuccess; /* no random data available == we're flushed */
-
-    /* We have random data available. Send this to PSM.
-       We're sending an event, so no reply is needed. */
-    message.type = SSM_EVENT_MESSAGE 
-        | SSM_MISC_ACTION 
-        | SSM_MISC_PUT_RNG_DATA;
-    message.len = control->rng.validOutBytes;
-    message.data = (unsigned char *) calloc(message.len, sizeof(char));
-    if (!message.data)
-        goto loser;
-    memcpy(message.data, control->rng.outBuf, message.len);
-
-    if (CMT_TransmitMessage(control, &message) == CMTFailure)
-        goto loser;
-
-    /* Clear the RNG ring buffer, we've used that data */
-    control->rng.out_cur = control->rng.outBuf;
-    control->rng.validOutBytes = 0;
-    /* zero the buffer, because we XOR in new data */
-    memset(control->rng.outBuf, 0, RNG_OUT_BUFFER_LEN);
-
-    goto done;
- loser:
-    if (message.data)
-        free(message.data);
-    return CMTFailure;
- done:
-    return CMTSuccess;
-}

mozilla/security/psm/lib/client/cmtsdr.c

@@ -1,237 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*
-  cmtsdr.c -- Support for the Secret Decoder Ring, which provides
-      encryption and decryption using stored keys.
-
-  Created by thayes 18 April 2000
- */
-#include "stddef.h"
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include "protocolshr.h"
-#include "rsrcids.h"
-#include <string.h>
-
-#undef PROCESS_LOCALLY
-
-/* Encryption result - contains the key id and the resulting data */
-/* An empty key id indicates that NO encryption was performed */
-typedef struct EncryptionResult
-{
-  CMTItem keyid;
-  CMTItem data;
-} EncryptionResult;
-
-/* Constants for testing */
-static const char *kPrefix = "Encrypted:";
-
-static CMTItem
-CMT_CopyDataToItem(const unsigned char *data, CMUint32 len)
-{
-  CMTItem item;
-
-  item.data = (unsigned char*) calloc(len, 1);
-  item.len = len;
-  memcpy(item.data, data, len);
-
-  return item;
-}
-
-
-static CMTStatus
-tmp_SendMessage(PCMT_CONTROL control, CMTItem *message)
-{
-#ifndef PROCESS_LOCALLY
-  return CMT_SendMessage(control, message);
-#else
-  if (message->type == SSM_SDR_ENCRYPT_REQUEST) 
-    return CMT_DoEncryptionRequest(message);
-  else if (message->type == SSM_SDR_DECRYPT_REQUEST)
-    return CMT_DoDecryptionRequest(message);
-
-  return CMTFailure;
-#endif
-}
-/* End test code */
-
-CMTStatus
-CMT_SDREncrypt(PCMT_CONTROL control, void *ctx,
-               const unsigned char *key, CMUint32 keyLen,
-               const unsigned char *data, CMUint32 dataLen,
-               unsigned char **result, CMUint32 *resultLen)
-{
-  CMTStatus rv = CMTSuccess;
-  CMTItem message;
-  EncryptRequestMessage request;
-  SingleItemMessage reply;
-
-  /* Fill in the request */
-  request.keyid = CMT_CopyDataToItem(key, keyLen);
-  request.data = CMT_CopyDataToItem(data, dataLen);
-  request.ctx = CMT_CopyPtrToItem(ctx);
-
-  reply.item.data = 0;
-  reply.item.len = 0;
-  message.data = 0;
-  message.len = 0;
-
-  /* Encode */
-  rv = CMT_EncodeMessage(EncryptRequestTemplate, &message, &request);
-  if (rv != CMTSuccess) {
-    goto loser;
-  }
-
-  message.type = SSM_SDR_ENCRYPT_REQUEST;
-
-  /* Send */
-  /* if (CMT_SendMessage(control, &message) != CMTSuccess) goto loser; */
-  rv = tmp_SendMessage(control, &message);
-  if (rv != CMTSuccess) goto loser;
-
-  if (message.type != SSM_SDR_ENCRYPT_REPLY) { rv = CMTFailure; goto loser; }
-
-  rv = CMT_DecodeMessage(SingleItemMessageTemplate, &reply, &message);
-  if (rv != CMTSuccess)
-    goto loser;
-
-  *result = reply.item.data;
-  *resultLen = reply.item.len;
-
-  reply.item.data = 0;
-
-loser:
-  if (message.data) free(message.data);
-  if (request.keyid.data) free(request.keyid.data);
-  if (request.data.data) free(request.data.data);
-  if (request.ctx.data) free(request.ctx.data);
-  if (reply.item.data) free(reply.item.data);
-
-  return rv; /* need return value */
-}
-
-CMTStatus
-CMT_SDRDecrypt(PCMT_CONTROL control, void *ctx,
-               const unsigned char *data, CMUint32 dataLen,
-               unsigned char **result, CMUint32 *resultLen)
-{
-  CMTStatus rv;
-  CMTItem message;
-  DecryptRequestMessage request;
-  SingleItemMessage reply;
-
-  /* Fill in the request */
-  request.data = CMT_CopyDataToItem(data, dataLen);
-  request.ctx = CMT_CopyPtrToItem(ctx);
-
-  reply.item.data = 0;
-  reply.item.len = 0;
-  message.data = 0;
-  message.len = 0;
-
-  /* Encode */
-  rv = CMT_EncodeMessage(DecryptRequestTemplate, &message, &request);
-  if (rv != CMTSuccess) {
-    goto loser;
-  }
-
-  message.type = SSM_SDR_DECRYPT_REQUEST;
-
-  /* Send */
-  /* if (CMT_SendMessage(control, &message) != CMTSuccess) goto loser; */
-  rv = tmp_SendMessage(control, &message);
-  if (rv != CMTSuccess) goto loser;
-
-  if (message.type != SSM_SDR_DECRYPT_REPLY) { rv = CMTFailure; goto loser; }
-
-  rv = CMT_DecodeMessage(SingleItemMessageTemplate, &reply, &message);
-  if (rv != CMTSuccess)
-    goto loser;
-
-  *result = reply.item.data;
-  *resultLen = reply.item.len;
-
-  reply.item.data = 0;
-
-loser:
-  if (message.data) free(message.data);
-  if (request.data.data) free(request.data.data);
-  if (request.ctx.data) free(request.ctx.data);
-  if (reply.item.data) free(reply.item.data);
-
-  return rv; /* need return value */
-}
-
-CMTStatus
-CMT_SDRChangePassword(PCMT_CONTROL control, void *ctx)
-{
-  CMTStatus rv = CMTSuccess;
-  CMTItem message;
-  SingleItemMessage request;
-  SingleNumMessage reply;
-
-  /* Fill in the request */
-  request.item = CMT_CopyPtrToItem(ctx);
-
-  message.data = 0;
-  message.len = 0;
-
-  /* Encode */
-  rv = CMT_EncodeMessage(SingleItemMessageTemplate, &message, &request);
-  if (rv != CMTSuccess) {
-    goto loser;
-  }
-
-  message.type = (SSM_REQUEST_MESSAGE|SSM_MISC_ACTION|SSM_MISC_UI|SSM_UI_CHANGE_PASSWORD);
-
-  /* Send */
-  rv = CMT_SendMessage(control, &message);
-  if (rv != CMTSuccess) goto loser;
-
-  if (message.type != 
-     (SSM_REPLY_OK_MESSAGE|SSM_MISC_ACTION|SSM_MISC_UI|SSM_UI_CHANGE_PASSWORD)) { 
-    rv = CMTFailure;
-    goto loser; 
-  }
-
-  rv = CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message);
-  if (rv != CMTSuccess)
-    goto loser;
-
-loser:
-  if (request.item.data) free(request.item.data);
-  if (message.data) free(message.data);
-
-  return rv; /* need return value */
-}

mozilla/security/psm/lib/client/cmtssl.c

@@ -1,467 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#else
-#ifdef XP_MAC
-#else /* windows */
-#include <windows.h>
-#include <winsock.h>
-#endif
-#endif
-#include <errno.h>
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "messages.h"
-#include "rsrcids.h"
-
-
-
-CMTStatus CMT_OpenSSLConnection(PCMT_CONTROL control, CMTSocket sock,
-                                SSMSSLConnectionRequestType flags, 
-                                CMUint32 port, char * hostIP, 
-                                char * hostName, CMBool forceHandshake, void* clientContext)
-{
-	CMTItem message;
-    SSLDataConnectionRequest request;
-    DataConnectionReply reply;
-    CMUint32 sent;
-	
-	/* Do some parameter checking */
-	if (!control || !hostIP || !hostName) {
-		goto loser;
-	}
-
-    request.flags = flags;
-    request.port = port;
-    request.hostIP = hostIP;
-    request.hostName = hostName;
-    request.forceHandshake = forceHandshake;
-    request.clientContext = CMT_CopyPtrToItem(clientContext);
-
-    /* Encode message */
-    if (CMT_EncodeMessage(SSLDataConnectionRequestTemplate, &message, &request) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* Set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | SSM_SSL_CONNECTION;
-    
-	/* Send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | SSM_SSL_CONNECTION)) {
-        goto loser;
-    }
-
-    /* Decode message */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) != CMTSuccess) {
-        goto loser;
-    }
-
-	/* Success */
-	if (reply.result == 0) {
-	  if (control->sockFuncs.connect(sock, reply.port, NULL) != CMTSuccess) {
-            goto loser;
-	  }
-	  sent = CMT_WriteThisMany(control, sock, control->nonce.data, 
-                               control->nonce.len);
-	  if (sent != control->nonce.len) {
-            goto loser;
-	  }
-	  
-	  /* Save connection info */
-	  if (CMT_AddDataConnection(control, sock, reply.connID)
-	      != CMTSuccess) {
-	    goto loser;
-	  }
-
-	  return CMTSuccess;
-	} 
-	
-loser:
-	return CMTFailure;
-}
-
-CMTStatus CMT_GetSSLDataErrorCode(PCMT_CONTROL control, CMTSocket sock,
-                                  CMInt32* errorCode)
-{
-    CMUint32 connID;
-
-    if (!control || !errorCode) {
-        goto loser;
-    }
-
-    /* get the data connection */
-    if (CMT_GetDataConnectionID(control, sock, &connID) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* get the PR error */
-    if (CMT_GetNumericAttribute(control, connID, SSM_FID_SSLDATA_ERROR_VALUE,
-                                errorCode) != CMTSuccess) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_ReleaseSSLSocketStatus(PCMT_CONTROL control, CMTSocket sock)
-{
-    CMUint32 connectionID;
-
-    if (!control || !sock) {
-        goto loser;
-    }
-    if (CMT_GetDataConnectionID(control, sock, &connectionID) != CMTSuccess) {
-        goto loser;
-    }
-    if (CMT_SetNumericAttribute(control, connectionID, 
-                                SSM_FID_SSLDATA_DISCARD_SOCKET_STATUS,
-                                0) != CMTSuccess) {
-        goto loser;
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_GetSSLSocketStatus(PCMT_CONTROL control, CMTSocket sock, 
-                                 CMTItem* pickledStatus, CMInt32* level)
-{
-    CMUint32 connectionID;
-    SingleNumMessage request;
-    CMTItem message;
-    PickleSecurityStatusReply reply;
-
-    if (!control || !pickledStatus || !level) {
-        goto loser;
-    }
-
-	/* get the data connection */
-    if (CMT_GetDataConnectionID(control, sock, &connectionID) != CMTSuccess) {
-		goto loser;
-	}
-
-    /* set up the request */
-    request.value = connectionID;
-
-    /* encode the request */
-    if (CMT_EncodeMessage(SingleNumMessageTemplate, &message, &request) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | 
-        SSM_CONSERVE_RESOURCE | SSM_PICKLE_SECURITY_STATUS;
-
-    /* send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION |
-                         SSM_CONSERVE_RESOURCE | SSM_PICKLE_SECURITY_STATUS)) {
-        goto loser;
-    }
-
-    /* decode the reply */
-    if (CMT_DecodeMessage(PickleSecurityStatusReplyTemplate, &reply, &message)
-        != CMTSuccess) {
-        goto loser;
-    }
-
-    /* success */
-    if (reply.result == 0) {
-        *pickledStatus = reply.blob;
-        *level = reply.securityLevel;
-        return CMTSuccess;
-    }
-
-loser:
-    return CMTFailure;
-}
-
-
-CMTStatus CMT_OpenTLSConnection(PCMT_CONTROL control, CMTSocket sock,
-                                CMUint32 port, char* hostIP, char* hostName)
-{
-    TLSDataConnectionRequest request;
-    CMTItem message;
-    DataConnectionReply reply;
-    CMUint32 sent;
-
-    /* do some parameter checking */
-    if (!control || !hostIP || !hostName) {
-        goto loser;
-    }
-
-    request.port = port;
-    request.hostIP = hostIP;
-    request.hostName = hostName;
-
-    /* encode the message */
-    if (CMT_EncodeMessage(TLSDataConnectionRequestTemplate, &message, &request)
-        != CMTSuccess) {
-        goto loser;
-    }
-
-    /* set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | 
-        SSM_TLS_CONNECTION;
-
-    /* send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | 
-                         SSM_TLS_CONNECTION)) {
-        goto loser;
-    }
-
-    /* decode the message */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* success */
-    if (reply.result == 0) {
-        if (control->sockFuncs.connect(sock, reply.port, NULL) != CMTSuccess) {
-            goto loser;
-        }
-        sent = CMT_WriteThisMany(control, sock, control->nonce.data, 
-                                 control->nonce.len);
-        if (sent != control->nonce.len) {
-            goto loser;
-        }
-
-        /* save connection info */
-        if (CMT_AddDataConnection(control, sock, reply.connID) != CMTSuccess) {
-            goto loser;
-        }
-
-        return CMTSuccess;
-    }
-loser:
-    return CMTFailure;
-}
-
-
-CMTStatus CMT_TLSStepUp(PCMT_CONTROL control, CMTSocket sock, 
-                        void* clientContext)
-{
-    TLSStepUpRequest request;
-    SingleNumMessage reply;
-    CMTItem message;
-    CMUint32 connectionID;
-
-    /* check arguments */
-    if (!control || !sock) {
-        goto loser;
-    }
-
-    /* get the data connection ID */
-    if (CMT_GetDataConnectionID(control, sock, &connectionID) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* set up the request */
-    request.connID = connectionID;
-    request.clientContext = CMT_CopyPtrToItem(clientContext);
-
-    /* encode the request */
-    if (CMT_EncodeMessage(TLSStepUpRequestTemplate, &message, &request) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | SSM_TLS_STEPUP;
-
-    /* send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION |
-                         SSM_TLS_STEPUP)) {
-        goto loser;
-    }
-
-    /* decode the reply */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    return (CMTStatus) reply.value;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_OpenSSLProxyConnection(PCMT_CONTROL control, CMTSocket sock,
-                                     CMUint32 port, char* hostIP, 
-                                     char* hostName)
-{
-    TLSDataConnectionRequest request;
-    CMTItem message;
-    DataConnectionReply reply;
-    CMUint32 sent;
-
-    /* do some parameter checking */
-    if (!control || !hostIP || !hostName) {
-        goto loser;
-    }
-
-    request.port = port;
-    request.hostIP = hostIP;
-    request.hostName = hostName;
-
-    /* encode the message */
-    if (CMT_EncodeMessage(TLSDataConnectionRequestTemplate, &message, &request)
-        != CMTSuccess) {
-        goto loser;
-    }
-
-    /* set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_DATA_CONNECTION | 
-        SSM_PROXY_CONNECTION;
-
-    /* send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_DATA_CONNECTION | 
-                         SSM_PROXY_CONNECTION)) {
-        goto loser;
-    }
-
-    /* decode the message */
-    if (CMT_DecodeMessage(DataConnectionReplyTemplate, &reply, &message) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* success */
-    if (reply.result == 0) {
-        if (control->sockFuncs.connect(sock, reply.port, NULL) != CMTSuccess) {
-            goto loser;
-        }
-        sent = CMT_WriteThisMany(control, sock, control->nonce.data, 
-                                 control->nonce.len);
-        if (sent != control->nonce.len) {
-            goto loser;
-        }
-
-        /* save connection info */
-        if (CMT_AddDataConnection(control, sock, reply.connID) != CMTSuccess) {
-            goto loser;
-        }
-
-        return CMTSuccess;
-    }
-loser:
-    return CMTFailure;
-}
-
-
-CMTStatus CMT_ProxyStepUp(PCMT_CONTROL control, CMTSocket sock, 
-                        void* clientContext, char* remoteUrl)
-{
-    ProxyStepUpRequest request;
-    SingleNumMessage reply;
-    CMTItem message;
-    CMUint32 connectionID;
-
-    /* check arguments */
-    if (!control || !sock || !remoteUrl) {
-        goto loser;
-    }
-
-    /* get the data connection ID */
-    if (CMT_GetDataConnectionID(control, sock, &connectionID) != CMTSuccess) {
-        goto loser;
-    }
-
-    /* set up the request */
-    request.connID = connectionID;
-    request.clientContext = CMT_CopyPtrToItem(clientContext);
-    request.url = remoteUrl;
-
-    /* encode the request */
-    if (CMT_EncodeMessage(ProxyStepUpRequestTemplate, &message, &request) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    /* set the message request type */
-    message.type = SSM_REQUEST_MESSAGE | SSM_RESOURCE_ACTION | 
-        SSM_PROXY_STEPUP;
-
-    /* send the message and get the response */
-    if (CMT_SendMessage(control, &message) == CMTFailure) {
-        goto loser;
-    }
-
-    /* validate the message reply type */
-    if (message.type != (SSM_REPLY_OK_MESSAGE | SSM_RESOURCE_ACTION |
-                         SSM_PROXY_STEPUP)) {
-        goto loser;
-    }
-
-    /* decode the reply */
-    if (CMT_DecodeMessage(SingleNumMessageTemplate, &reply, &message) !=
-        CMTSuccess) {
-        goto loser;
-    }
-
-    return (CMTStatus) reply.value;
-loser:
-    return CMTFailure;
-}

mozilla/security/psm/lib/client/cmtutils.c

@@ -1,636 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifdef XP_UNIX
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#else
-#ifdef XP_MAC
-#include "macsocket.h"
-#else /* Windows */
-#include <windows.h>
-#include <winsock.h>
-#endif
-#endif
-#include "cmtcmn.h"
-#include "cmtutils.h"
-#include "newproto.h"
-#include <string.h>
-
-/* Local defines */
-#if 0
-#define PSM_WAIT_BEFORE_SLEEP           (CM_TicksPerSecond() * 60)
-#define PSM_SPINTIME                    PSM_WAIT_BEFORE_SLEEP
-#define PSM_KEEP_CONNECTION_ALIVE       (PSM_WAIT_BEFORE_SLEEP * 900)
-#endif
-
-/* If you want to dump the messages sent between the plug-in and the PSM 
- * server, then remove the comment for the appropriate define.
- */
-#if 0
-#define PRINT_SEND_MESSAGES
-#define PRINT_RECEIVE_MESSAGES
-#endif
-
-#ifdef PRINT_SEND_MESSAGES
-#ifndef DEBUG_MESSAGES
-#define DEBUG_MESSAGES
-#endif /*DEBUG_MESSAGES*/
-#endif /*PRINT_SEND_MESSAGES*/
-
-#ifdef PRINT_RECEIVE_MESSAGES
-#ifndef DEBUG_MESSAGES
-#define DEBUG_MESSAGES
-#endif /*DEBUG_MESSAGES*/
-#endif /*PRINT_RECEIVE_MESSAGES*/
-
-#ifdef DEBUG_MESSAGES
-#define LOG(x) do { FILE *f; f=fopen("cmnav.log","a+"); if (f) { \
-   fprintf(f, x); fclose(f); } } while(0);
-#define LOG_S(x) do { FILE *f; f=fopen("cmnav.log","a+"); if (f) { \
-   fprintf(f, "%s", x); fclose(f); } } while(0);
-#define ASSERT(x) if (!(x)) { LOG("ASSERT:"); LOG(#x); LOG("\n"); exit(-1); }
-#else
-#define LOG(x)
-#define LOG_S(x)
-#define ASSERT(x)
-#endif
-
-CMUint32
-cmt_Strlen(char *str)
-{
-    CMUint32 len = strlen(str);
-    return sizeof(CMInt32) + (((len + 3)/4)*4);
-}
-
-CMUint32
-cmt_Bloblen(CMTItem *blob)
-{
-    return sizeof(CMInt32) + (((blob->len +3)/4)*4);
-}
-
-char *
-cmt_PackString(char *buf, char *str)
-{
-    CMUint32 len = strlen(str);
-    CMUint32 networkLen = htonl(len);
-    CMUint32 padlen = ((len + 3)/4)*4;
-
-    memcpy(buf, &networkLen, sizeof(CMUint32));
-    memcpy(buf + sizeof(CMUint32), str, len);
-    memset(buf + sizeof(CMUint32) + len, 0, padlen - len);
-
-    return buf+sizeof(CMUint32)+padlen;
-}
-
-char *
-cmt_PackBlob(char *buf, CMTItem *blob)
-{
-    CMUint32 len = blob->len;
-    CMUint32 networkLen = htonl(len);
-    CMUint32 padlen = (((blob->len + 3)/4)*4);
-
-    *((CMUint32*)buf) = networkLen;
-    memcpy(buf + sizeof(CMUint32), blob->data, len);
-    memset(buf + sizeof(CMUint32) + len, 0, padlen - len);
-
-    return buf + sizeof(CMUint32) + padlen;
-}
-
-char *
-cmt_UnpackString(char *buf, char **str)
-{
-    char *p = NULL;
-    CMUint32 len, padlen;
-
-    /* Get the string length */
-    len = ntohl(*(CMUint32*)buf);
-
-    /* Get the padded length */
-    padlen = ((len + 3)/4)*4;
-
-    /* Allocate the string and copy the data */
-    p = (char *) malloc(len + 1);
-    if (!p) {
-        goto loser;
-    }
-    /* Copy the data and NULL terminate */
-    memcpy(p, buf+sizeof(CMUint32), len);
-    p[len] = 0;
-
-    *str = p;
-    return buf+sizeof(CMUint32)+padlen;
-loser:
-    *str = NULL;
-    if (p) {
-        free(p);
-    }
-    return buf+sizeof(CMUint32)+padlen;
-}
-
-char *
-cmt_UnpackBlob(char *buf, CMTItem **blob)
-{
-    CMTItem *p = NULL;
-    CMUint32 len, padlen;
-
-    /* Get the blob length */
-    len = ntohl(*(CMUint32*)buf);
-    
-    /* Get the padded length */
-    padlen = ((len + 3)/4)*4;
-
-    /* Allocate the CMTItem for the blob */
-    p = (CMTItem*)malloc(sizeof(CMTItem));
-    if (!p) {
-        goto loser;
-    }
-    p->len = len;
-    p->data = (unsigned char *) malloc(len);
-    if (!p->data) {
-        goto loser;
-    }
-
-    /* Copy that data across */
-    memcpy(p->data, buf+sizeof(CMUint32), len);
-    *blob = p;
-
-    return buf+sizeof(CMUint32)+padlen;
-
-loser:
-    *blob = NULL;
-    CMT_FreeMessage(p);
-
-    return buf+sizeof(CMUint32)+padlen;
-}
-
-#ifdef DEBUG_MESSAGES
-void prettyPrintMessage(CMTItem *msg)
-{
-  int numLines = ((msg->len+7)/8);
-  char curBuffer[9], *cursor, string[2], hexVal[8];
-  char hexArray[25];
-  int i, j, numToCopy;
-
-  /*Try printing out 8 bytes at a time. */
-  LOG("\n**********************************************************\n");
-  LOG("About to pretty Print Message\n\n");
-  curBuffer[9] = '\0';
-  hexArray[24] = '\0';
-  hexVal[2] = '\0';
-  string[1] = '\0';
-  LOG("Header Info\n");
-  LOG("Message Type: ");
-  sprintf(hexArray, "%lx\n", msg->type);
-  LOG(hexArray);
-  LOG("Message Length: ");
-  sprintf (hexArray, "%ld\n\n", msg->len);
-  LOG(hexArray);
-  LOG("Body of Message\n");
-  for (i=0, cursor=msg->data; i<numLines; i++, cursor+=8) {
-    /* First copy over the buffer to our local array */
-    numToCopy = ((msg->len - (unsigned int)((unsigned long)cursor-(unsigned long)msg->data)) < 8) ?
-                msg->len - (unsigned int)((unsigned long)cursor-(unsigned long)msg->data) : 8;
-    memcpy(curBuffer, cursor, 8);
-    for (j=0;j<numToCopy;j++) {
-      string[0] = curBuffer[j];
-      if (isprint(curBuffer[j])) {
-	string[0] = curBuffer[j];
-      } else {
-	string[0] = ' ';
-      }
-      LOG(string);
-    }
-    string[0] = ' ';
-    for (;j<8;j++) {
-      LOG(string);
-    }
-    LOG("\t");
-    for (j=0; j<numToCopy; j++) {
-      sprintf (hexVal,"%.2x", 0x0ff & (unsigned short)curBuffer[j]);
-      LOG(hexVal);
-      LOG(" ");
-    }
-    LOG("\n");
-  }
-  LOG("Done Pretty Printing Message\n");
-  LOG("**********************************************************\n\n");
-}
-#endif
-
-CMTStatus CMT_SendMessage(PCMT_CONTROL control, CMTItem* message)
-{
-	CMTStatus status;
-    CMUint32 msgCategory;
-    CMBool done = CM_FALSE;
-#ifdef PRINT_SEND_MESSAGES
-    LOG("About to print message sent to PSM\n");
-    prettyPrintMessage(message);
-#endif
-
-    /* Acquire lock on the control connection */
-    CMT_LOCK(control->mutex);
-
-    /* Try to send pending random data */
-    if (message->type != (SSM_REQUEST_MESSAGE | SSM_HELLO_MESSAGE))
-    {
-        /* If we've already said hello, then flush random data
-           just before sending the request. */
-        status = CMT_FlushPendingRandomData(control);
-        if (status != CMTSuccess)
-            goto loser;
-    }
-    
-	status = CMT_TransmitMessage(control, message);
-	if (status != CMTSuccess) {
-		goto loser;
-	}
-
-    /* We have to deal with other types of data on the socket and */
-    /* handle them accordingly */
-    while (!done) {
-    	status = CMT_ReceiveMessage(control, message);
-        if (status != CMTSuccess) {
-            goto loser;
-        }
-        msgCategory = (message->type & SSM_CATEGORY_MASK);
-        switch (msgCategory) {
-            case SSM_REPLY_OK_MESSAGE:
-                done = CM_TRUE;
-                break;
-            case SSM_REPLY_ERR_MESSAGE:
-                done = CM_TRUE;
-                break;
-            case SSM_EVENT_MESSAGE:
-                CMT_DispatchEvent(control, message);
-                break;
-            /* XXX FIX THIS!!! For the moment I'm ignoring all other types */
-            default:
-                break;
-        }
-    }
-
-    /* Release the control connection lock */
-    CMT_UNLOCK(control->mutex);
-	return CMTSuccess;
-loser:
-    /* Release the control connection lock */
-    CMT_UNLOCK(control->mutex);
-	return CMTFailure;
-}
-
-CMTStatus CMT_TransmitMessage(PCMT_CONTROL control, CMTItem * message)
-{
-    CMTMessageHeader header;
-	CMUint32 sent, rv;
-
-    /* Set up the message header */
-    header.type = htonl(message->type);
-    header.len = htonl(message->len);
-
-	/* Send the message header */
-	sent = CMT_WriteThisMany(control, control->sock, 
-                             (void *)&header, sizeof(CMTMessageHeader));
-	if (sent != sizeof(CMTMessageHeader)) {
-		goto loser;
-	}
-
-	/* Send the message body */
-	sent = CMT_WriteThisMany(control, control->sock, (void *)message->data, 
-                             message->len);
-	if (sent != message->len) {
-		goto loser;
-	}
-
-    /* Free the buffer */
-    free(message->data);
-    message->data = NULL;
-	return CMTSuccess;
-
-loser:
-	return CMTFailure;
-}
-
-CMTStatus CMT_ReceiveMessage(PCMT_CONTROL control, CMTItem * response)
-{
-    CMTMessageHeader header;
-    CMUint32 numread, rv;
-
-    /* Get the message header */
-    numread = CMT_ReadThisMany(control, control->sock, 
-                            (void *)&header, sizeof(CMTMessageHeader));
-    if (numread != sizeof(CMTMessageHeader)) {
-        goto loser;
-    }
-
-    response->type = ntohl(header.type);
-    response->len = ntohl(header.len);
-    response->data = (unsigned char *) malloc(response->len);
-    if (response->data == NULL) {
-        goto loser;
-    }
-
-    numread = CMT_ReadThisMany(control, control->sock, 
-                            (void *)(response->data), response->len); 
-    if (numread != response->len) {
-        goto loser;
-    }
-
-#ifdef PRINT_RECEIVE_MESSAGES
-    LOG("About to print message received from PSM.\n");
-    prettyPrintMessage(response);
-#endif /*PRINT_RECEIVE_MESSAGES*/
-    return CMTSuccess;
-loser:
-    if (response->data) {
-        free(response->data);
-    }
-    return CMTFailure;
-}
-
-CMUint32 CMT_ReadThisMany(PCMT_CONTROL control, CMTSocket sock, 
-                          void * buffer, CMUint32 thisMany)
-{
-	CMUint32 total = 0;
-  
-	while (total < thisMany) {
-		int got;
-		got = control->sockFuncs.recv(sock, (void*)((char*)buffer + total),
-                                      thisMany-total);
-		if (got < 0 ) {
-			break;
-		} 
-		total += got;
-	} 
-	return total;
-}
- 
-CMUint32 CMT_WriteThisMany(PCMT_CONTROL control, CMTSocket sock, 
-                           void * buffer, CMUint32 thisMany)
-{
-	CMUint32 total = 0;
-  
-	while (total < thisMany) {
-		CMInt32 got;
-		got = control->sockFuncs.send(sock, (void*)((char*)buffer+total), 
-                                      thisMany-total);
-		if (got < 0) {
-			break;
-		}
-		total += got;
-	}
-	return total;
-}
-
-CMTItem* CMT_ConstructMessage(CMUint32 type, CMUint32 length)
-{
-    CMTItem * p;
-
-    p = (CMTItem*)malloc(sizeof(CMTItem));
-    if (!p) {
-	goto loser;
-    }
-
-    p->type = type;
-    p->len = length;
-    p->data = (unsigned char *) malloc(length);
-    if (!p->data) {
-	goto loser;
-    }
-    return p;
-
-loser:
-    CMT_FreeMessage(p);
-    return NULL;
-}
-
-void CMT_FreeMessage(CMTItem * p)
-{
-    if (p != NULL) {
-	if (p->data != NULL) {
-	    free(p->data);
-	}
-	free(p);
-    }
-}
-
-CMTStatus CMT_AddDataConnection(PCMT_CONTROL control, CMTSocket sock, 
-                                CMUint32 connectionID)
-{
-	PCMT_DATA ptr;
-
-	/* This is the first connection */
-	if (control->cmtDataConnections == NULL) {
-		control->cmtDataConnections = ptr = 
-            (PCMT_DATA)calloc(sizeof(CMT_DATA), 1);
-		if (!ptr) {
-			goto loser;
-		}
-	} else {
-	    /* Position at the last entry */
-	    for (ptr = control->cmtDataConnections; (ptr != NULL && ptr->next 
-                                                 != NULL); ptr = ptr->next);
-		ptr->next = (PCMT_DATA)calloc(sizeof(CMT_DATA), 1);
-		if (!ptr->next) {
-			goto loser;
-		} 
-		/* Fix up the pointers */
-		ptr->next->previous = ptr;
-		ptr = ptr->next;
-	}
-
-	/* Fill in the data */
-	ptr->sock = sock;
-	ptr->connectionID = connectionID;
-
-	return CMTSuccess;
-loser:
-	return CMTFailure;
-}
-
-int
-CMT_DestroyDataConnection(PCMT_CONTROL control, CMTSocket sock)
-{
-    PCMT_DATA ptr, pptr = NULL;
-    int rv=CMTSuccess;
-
-    control->sockFuncs.close(sock);
-    for (ptr = control->cmtDataConnections; ptr != NULL;
-	 pptr = ptr, ptr = ptr->next) {
-	if (ptr->sock == sock) {
-	    if (pptr == NULL) {
-		/* node is at head */
-		control->cmtDataConnections = ptr->next;
-		if (ptr->priv != NULL)
-		    ptr->priv->dest(ptr->priv);
-		free(ptr);
-		return rv;
-	    }
-	    /* node is elsewhere */
-	    pptr->next = ptr->next;
-	    if (ptr->priv != NULL)
-	        ptr->priv->dest(ptr->priv);
-	    free(ptr);
-	    return rv;
-	}
-    }
-    return rv;
-}
-
-CMTStatus CMT_CloseDataConnection(PCMT_CONTROL control, CMUint32 connectionID)
-{
-    /* PCMT_DATA ptr, pptr = NULL; */
-    CMTSocket sock;
-    /* int rv;*/
-
-    /* Get the socket for this connection */
-    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
-        goto loser;
-    }
-
-    /* Free data connection associated with this socket */
-    if (CMT_DestroyDataConnection(control, sock) == CMTFailure) {
-        goto loser;
-    }
-
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-CMTStatus CMT_GetDataConnectionID(PCMT_CONTROL control, CMTSocket sock, CMUint32 * connectionID)
-{
-	PCMT_DATA ptr;
-
-	for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
-		if (ptr->sock == sock) {
-			*connectionID = ptr->connectionID;
-			return CMTSuccess;
-		}
-	}
-
-	return CMTFailure;
-}
-
-CMTStatus CMT_GetDataSocket(PCMT_CONTROL control, CMUint32 connectionID, CMTSocket * sock)
-{
-	PCMT_DATA ptr;
-
-	for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
-		if (ptr->connectionID == connectionID) {
-			*sock = ptr->sock;
-			return CMTSuccess;
-		}
-	}
-
-	return CMTFailure;
-}
-
-
-CMTStatus CMT_SetPrivate(PCMT_CONTROL control, CMUint32 connectionID,
-			 CMTPrivate *cmtpriv)
-{
-  PCMT_DATA ptr;
-
-  for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
-    if (ptr->connectionID == connectionID) {
-      ptr->priv = cmtpriv;
-      return CMTSuccess;
-    }
-  }
-  return CMTFailure;
-}
-
-CMTPrivate *CMT_GetPrivate(PCMT_CONTROL control, CMUint32 connectionID)
-{
-  PCMT_DATA ptr;
-
-  for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
-    if (ptr->connectionID == connectionID) {
-      return ptr->priv;
-    }
-  }
-  return NULL;
-}
-
-void CMT_FreeItem(CMTItem *p)
-{
-  CMT_FreeMessage(p);
-}
-
-CMTItem CMT_CopyPtrToItem(void* p)
-{
-    CMTItem value = {0, NULL, 0};
-
-    if (!p) {
-        return value;
-    }
-
-    value.len = sizeof(p);
-    value.data = (unsigned char *) malloc(value.len);
-    memcpy(value.data, &p, value.len);
-
-    return value;
-}
-
-void * CMT_CopyItemToPtr(CMTItem value)
-{
-    void * p = NULL;
-
-    if (value.len == sizeof(void*)) {
-        memcpy(&p, value.data, value.len);
-    }
-
-    return p;
-}
-
-CMTStatus CMT_ReferenceControlConnection(PCMT_CONTROL control)
-{
-    CMT_LOCK(control->mutex);
-    control->refCount++;
-    CMT_UNLOCK(control->mutex);
-    return CMTSuccess;
-}
-
-void
-CMT_LockConnection(PCMT_CONTROL control)
-{
-    CMT_LOCK(control->mutex);
-}
-
-void
-CMT_UnlockConnection(PCMT_CONTROL control)
-{
-    CMT_UNLOCK(control->mutex);
-}

mozilla/security/psm/lib/client/cmtutils.h

@@ -1,75 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __CMTUTILS_H__
-#define __CMTUTILS_H__
-
-#include "cmtcmn.h"
-
-#define New(type) (type*)malloc(sizeof(type))
-#define NewArray(type, size) (type*)malloc(sizeof(type)*(size))
-
-PCMT_EVENT CMT_GetEventHandler(PCMT_CONTROL control, CMUint32 type,
-                               CMUint32 resourceID);
-
-CMUint32 cmt_Strlen(char *str);
-char *cmt_PackString(char *buf, char *str);
-char *cmt_UnpackString(char *buf, char **str);
-
-CMUint32 cmt_Bloblen(CMTItem* len);
-char *cmt_PackBlob(char *buf, CMTItem * blob);
-char *cmt_UnpackBlob(char *buf, CMTItem **blob);
-
-CMTStatus CMT_SendMessage(PCMT_CONTROL control, CMTItem* message);
-CMTStatus CMT_TransmitMessage(PCMT_CONTROL control, CMTItem * message);
-CMTStatus CMT_ReceiveMessage(PCMT_CONTROL control, CMTItem * response);
-CMUint32 CMT_ReadThisMany(PCMT_CONTROL control, CMTSocket sock, 
-			  void * buffer, CMUint32 thisMany);
-CMUint32 CMT_WriteThisMany(PCMT_CONTROL control, CMTSocket sock, 
-			   void * buffer, CMUint32 thisMany);
-CMTItem* CMT_ConstructMessage(CMUint32 type, CMUint32 length);
-void CMT_FreeMessage(CMTItem * p);
-CMTStatus CMT_AddDataConnection(PCMT_CONTROL control, CMTSocket sock, CMUint32 connectionID);
-CMTStatus CMT_GetDataConnectionID(PCMT_CONTROL control, CMTSocket sock, CMUint32 * connectionID);
-CMTStatus CMT_GetDataSocket(PCMT_CONTROL control, CMUint32 connectionID, CMTSocket * sock);
-CMTStatus CMT_CloseDataConnection(PCMT_CONTROL control, CMUint32 connectionID);
-CMTStatus CMT_SetPrivate(PCMT_CONTROL control, CMUint32 connectionID,
-			 CMTPrivate *cmtpriv);
-CMTPrivate *CMT_GetPrivate(PCMT_CONTROL control, CMUint32 connectionID);
-void CMT_ServicePasswordRequest(PCMT_CONTROL cm_control, CMTItem * requestData);
-void CMT_ProcessEvent(PCMT_CONTROL cm_control);
-void CMT_DispatchEvent(PCMT_CONTROL cm_control, CMTItem * eventData);
-CMTItem CMT_CopyPtrToItem(void* p);
-void * CMT_CopyItemToPtr(CMTItem value);
-
-#endif /* __CMTUTILS_H__ */
-

mozilla/security/psm/lib/client/config.mk

@@ -1,44 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-#
-#  Override TARGETS variable so that only static libraries
-#  are specifed as dependencies within rules.mk.
-#
-
-TARGETS        = $(LIBRARY)
-SHARED_LIBRARY =
-IMPORT_LIBRARY =
-PURE_LIBRARY   =
-PROGRAM        =
-

mozilla/security/psm/lib/client/makefile.win

@@ -1,125 +0,0 @@
-#// 
-#// The contents of this file are subject to the Mozilla Public
-#// License Version 1.1 (the "License"); you may not use this file
-#// except in compliance with the License. You may obtain a copy of
-#// the License at http://www.mozilla.org/MPL/
-#// 
-#// Software distributed under the License is distributed on an "AS
-#// IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-#// implied. See the License for the specific language governing
-#// rights and limitations under the License.
-#// 
-#// The Original Code is the Netscape security libraries.
-#// 
-#// The Initial Developer of the Original Code is Netscape
-#// Communications Corporation.  Portions created by Netscape are 
-#// Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-#// Rights Reserved.
-#// 
-#// Contributor(s):
-#// 
-#// Alternatively, the contents of this file may be used under the
-#// terms of the GNU General Public License Version 2 or later (the
-#// "GPL"), in which case the provisions of the GPL are applicable 
-#// instead of those above.  If you wish to allow use of your 
-#// version of this file only under the terms of the GPL and not to
-#// allow others to use your version of this file under the MPL,
-#// indicate your decision by deleting the provisions above and
-#// replace them with the notice and other provisions required by
-#// the GPL.  If you do not delete the provisions above, a recipient
-#// may use your version of this file under either the MPL or the
-#// GPL.
-#// 
-IGNORE_MANIFEST=1
-#//------------------------------------------------------------------------
-#//
-#// Makefile to build the ssl library
-#//
-#//------------------------------------------------------------------------
-
-!if "$(MOZ_BITS)" == "16"
-!ifndef MOZ_DEBUG
-OPTIMIZER=-Os -UDEBUG -DNDEBUG
-!endif
-!endif
-
-#//------------------------------------------------------------------------
-#//
-#// Specify the depth of the current directory relative to the
-#// root of NS
-#//
-#//------------------------------------------------------------------------
-DEPTH= ..\..\..\..
-
-!ifndef MAKE_OBJ_TYPE
-MAKE_OBJ_TYPE=EXE
-!endif
-
-#//------------------------------------------------------------------------
-#//
-#// Define any Public Make Variables here: (ie. PDFFILE, MAPFILE, ...)
-#//
-#//------------------------------------------------------------------------
-LIBNAME=cmt
-PDBFILE=$(LIBNAME).pdb
-
-LINCS = -I$(PUBLIC)\security \
-	-I$(PUBLIC)\nspr \
-        -I$(DEPTH)\include \
-	-I..\include
-
-!ifndef OS_CONFIG
-OS_CONFIG = WIN$(MOZ_BITS)
-!endif
-
-LCFLAGS = -DEXPORT_VERSION -DLIB_BUILD
-
-#//------------------------------------------------------------------------
-#// 
-#// Define the files necessary to build the target (ie. OBJS)
-#//
-#//------------------------------------------------------------------------
-OBJS=                         \
-    .\$(OBJDIR)\cmtinit.obj  \
-    .\$(OBJDIR)\cmtssl.obj   \
-    .\$(OBJDIR)\cmtutils.obj  \
-    .\$(OBJDIR)\cmtpkcs7.obj \
-    .\$(OBJDIR)\cmthash.obj \
-    .\$(OBJDIR)\cmtcert.obj \
-    .\$(OBJDIR)\cmtres.obj \
-    .\$(OBJDIR)\cmtjs.obj \
-    .\$(OBJDIR)\cmtevent.obj \
-    .\$(OBJDIR)\cmtpasswd.obj \
-    .\$(OBJDIR)\cmtadvisor.obj \
-    .\$(OBJDIR)\cmtrng.obj \
-	.\$(OBJDIR)\cmtsdr.obj \
-    $(NULL)
-
-#//------------------------------------------------------------------------
-#//
-#// Define any Public Targets here (ie. PROGRAM, LIBRARY, DLL, ...)
-#// (these must be defined before the common makefiles are included)
-#//
-#//------------------------------------------------------------------------
-LIBRARY=.\$(OBJDIR)\$(LIBNAME).lib
-
-#//------------------------------------------------------------------------
-#//
-#// install headers
-#//
-#//------------------------------------------------------------------------
-INSTALL_DIR=$(PUBLIC)\security
-INSTALL_FILE_LIST=cmtcmn.h cmtjs.h cmtclist.h
-
-#//------------------------------------------------------------------------
-#//
-#// Include the common makefile rules
-#//
-#//------------------------------------------------------------------------
-include <$(DEPTH)/config/rules.mak>
-
-install:: $(LIBRARY)
-    $(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
-
-export:: INSTALL_FILES
-

mozilla/security/psm/lib/client/manifest.mn

@@ -1,64 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-CORE_DEPTH = ../../..
-DEPTH = ../../..
-
-EXPORTS = \
-	cmtcmn.h \
-	cmtjs.h  \
-	cmtclist.h \
-	$(NULL)
-
-MODULE = security
-
-CSRCS = cmtinit.c  \
-	cmtssl.c   \
-	cmtutils.c \
-	cmtcert.c  \
-	cmthash.c  \
-	cmtpkcs7.c \
-	cmtres.c   \
-	cmtjs.c    \
-	cmtevent.c \
-        cmtpasswd.c \
-	cmtadvisor.c \
-	cmtrng.c \
-	cmtsdr.c \
-	$(NULL)
-
-REQUIRES = nspr security
-
-LIBRARY_NAME = cmt
-
-INCLUDES += -I$(CORE_DEPTH)/include

mozilla/security/psm/lib/client/sample/Makefile

@@ -1,128 +0,0 @@
-#! gmake
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-#######################################################################
-# (1) Include initial platform-independent assignments (MANDATORY).   #
-#######################################################################
-
-include manifest.mn
-
-#######################################################################
-# (2) Include "global" configuration information. (OPTIONAL)          #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/config.mk
-
-#######################################################################
-# (3) Include "component" configuration information. (OPTIONAL)       #
-#######################################################################
-
-#######################################################################
-# (4) Include "local" platform-dependent assignments (OPTIONAL).      #
-#######################################################################
-
-ifneq ($(OS_ARCH), WINNT)
-ifeq ($(OS_ARCH), Linux)
-# On linux, we link with libstdc++
-CPLUSPLUSRUNTIME = -L /usr/lib -lstdc++ -lm
-else
-# libC, presumably, is what we must link with elsewhere
-CPLUSPLUSRUNTIME = -lC -lm
-endif
-endif
-
-ifeq ($(OS_ARCH), SunOS)
-ifeq ($(OS_RELEASE), 5.5.1)
-OS_LIBS += -ldl -lsocket -lnsl -lthread -lposix4
-endif
-ifeq ($(OS_RELEASE), 5.6)
-OS_LIBS += -ldl -lsocket -lnsl -lthread -lposix4
-endif
-endif
-
-ifeq ($(OS_ARCH), Linux)
-ifdef USE_PTHREADS
-# Replace OS_LIBS, because the order of libpthread, libdl, and libc are
-# very important. Otherwise you get horrible crashes.
-OS_LIBS = -lpthread -ldl -lc
-endif
-endif
-
-
-#######################################################################
-# (5) Execute "global" rules. (OPTIONAL)                              #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/rules.mk
-
-#######################################################################
-# (6) Execute "component" rules. (OPTIONAL)                           #
-#######################################################################
-
-
-#######################################################################
-# (7) Execute "local" rules. (OPTIONAL).                              #
-#######################################################################
-
-ifeq ($(OS_ARCH), WINNT)
-LDFLAGS += /NODEFAULTLIB:library
-endif
-
-EXTRA_LIBS = \
-	$(DIST)/lib/$(LIB_PREFIX)cmt.$(LIB_SUFFIX) \
-	$(DIST)/lib/$(LIB_PREFIX)protocol.$(LIB_SUFFIX) \
-	$(NULL)
-
-ifeq ($(OS_ARCH), WINNT)
-EXTRA_LIBS += 	wsock32.lib \
-		winmm.lib \
-		$(NULL)
-endif
-
-link:
-	if test -f $(PROGRAM); then	\
-		echo "rm $(PROGRAM)";	\
-		rm $(PROGRAM);		\
-	fi;				\
-	gmake				\
-
-build_sample:
-ifneq ($(OS_ARCH),WINNT)
-	cd $(CORE_DEPTH)/coreconf; gmake
-endif
-	cd $(CORE_DEPTH)/security; gmake import; gmake export
-	cd ../../protocol; gmake
-	cd ..; gmake
-	gmake
-

mozilla/security/psm/lib/client/sample/appsock.c

@@ -1,250 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmtcmn.h"
-#include "appsock.h"
-
-#ifdef XP_UNIX
-#include <netinet/tcp.h>
-#include <errno.h>
-#endif
-
-CMT_SocketFuncs socketFuncs = {
-    APP_GetSocket,
-    APP_Connect,
-    APP_VerifyUnixSocket,
-    APP_Send,
-    APP_Select,
-    APP_Receive,
-    APP_Shutdown,
-    APP_Close
-};
-
-CMTSocket APP_GetSocket(int unixSock)
-{
-    APPSocket *sock;
-    int on = 1;
-
-#ifndef XP_UNIX
-    if (unixSock) {
-        return NULL;
-    }
-#endif
-
-    sock = malloc(sizeof(APPSocket));
-    if (sock == NULL) {
-        return NULL;
-    }
-    if (unixSock) {
-        sock->sock = socket(AF_UNIX, SOCK_STREAM, 0);
-    } else {
-        sock->sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    }
-    if (sock->sock < 0) {
-        free(sock);
-        return NULL;
-    }
-    if (!unixSock && 
-        setsockopt(sock->sock, IPPROTO_TCP, TCP_NODELAY, (const char*)&on,
-                   sizeof(on))) {
-        free(sock);
-        return NULL;
-    }
-
-    sock->isUnix = unixSock;
-#ifdef XP_UNIX
-    memset (&sock->servAddr, 0, sizeof(struct sockaddr_un));
-#endif
-    return (CMTSocket)sock;
-}
-
-CMTStatus APP_Connect(CMTSocket sock, short port, char *path)
-{
-    APPSocket *cmSock = (APPSocket*)sock;
-    struct sockaddr_in iServAddr;
-    const struct sockaddr *servAddr;
-    size_t addrLen;
-    int error;
-
-    if (cmSock->isUnix){
-#ifndef XP_UNIX
-        return CMTFailure;
-#else
-        cmSock->servAddr.sun_family = AF_UNIX;
-	memcpy(&cmSock->servAddr.sun_path, path, strlen(path)+1);
-        servAddr = (const struct sockaddr*)&cmSock->servAddr;
-        addrLen = sizeof(cmSock->servAddr);
-#endif
-    } else {
-        iServAddr.sin_family = AF_INET;
-        iServAddr.sin_port = htons(port);
-        iServAddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-        servAddr = (const struct sockaddr*)&iServAddr;
-        addrLen = sizeof(struct sockaddr_in);
-    }
-    while (connect(cmSock->sock, servAddr, addrLen) != 0) {
-#ifdef WIN32
-        error = WSAGetLastError();
-        if (error == WSAEISCONN) {
-            break;
-        }
-        if ((error != WSAEINPROGRESS) && (error != WSAEWOULDBLOCK) && 
-            (error!= WSAEINVAL)) {
-            goto loser;
-        }
-#else
-        error = errno;
-        if (error == EISCONN) {
-            break;
-        }
-        if (error != EINPROGRESS) {
-            goto loser;
-        }
-#endif
-    }
-    return CMTSuccess;
- loser:
-    return CMTFailure;
-}
-
-CMTStatus APP_VerifyUnixSocket(CMTSocket sock)
-{
-#ifndef XP_UNIX
-    return CMTFailure;
-#else
-    APPSocket *cmSock = (APPSocket*)sock;
-    int rv;
-    struct stat statbuf;
-
-    if (!cmSock->isUnix) {
-        return CMTFailure;
-    }
-    rv = stat(cmSock->servAddr.sun_path, &statbuf);
-    if (rv < 0) {
-        goto loser;
-    }
-    if (statbuf.st_uid != geteuid()) {
-        goto loser;
-    }
-    return CMTSuccess;
- loser:
-    close(cmSock->sock);
-    free(cmSock);
-    return CMTFailure;
-#endif
-}
-
-size_t APP_Send(CMTSocket sock, void *buffer, size_t length)
-{
-    APPSocket *cmSock = (APPSocket*) sock;
-
-    return send(cmSock->sock, buffer, length, 0);
-}
-
-CMTSocket APP_Select(CMTSocket *socks, int numsocks, int poll)
-{
-    APPSocket **sockArr = (APPSocket**)socks;
-    SOCKET nsocks = 0;
-    int i, rv;
-    struct timeval timeout;
-    fd_set readfds;
-
-#ifdef WIN32
-win_startover:
-#endif
-    FD_ZERO(&readfds);
-    for (i=0; i<numsocks; i++) {
-        FD_SET(sockArr[i]->sock, &readfds);
-        if (sockArr[i]->sock > nsocks) {
-            nsocks = sockArr[i]->sock;
-        }
-    }
-    if (poll) {
-        timeout.tv_sec = 0;
-        timeout.tv_usec = 0;
-    }
-    rv = select(nsocks+1, &readfds, NULL, NULL, (poll) ? &timeout : NULL);
-
-#ifdef WIN32
-    /* XXX Win95/98 Bug (Q177346)
-     *     select() with no timeout might return even if there is no data
-     *     pending or no error has occurred.  To get around this problem,
-     *     we loop if these erroneous conditions happen.
-     */
-    if (poll == 0 && rv == 0) {
-        goto win_startover;
-    }
-#endif
-
-    /* Figure out which socket was selected */
-    if (rv == -1 || rv == 0) {
-        goto loser;
-    }
-    for (i=0; i<numsocks; i++) {
-        if (FD_ISSET(sockArr[i]->sock, &readfds)) {
-            return (CMTSocket)sockArr[i];
-        }
-    }
- loser:
-    return NULL;
-}
-
-size_t APP_Receive(CMTSocket sock, void *buffer, size_t bufSize)
-{
-    APPSocket *cmSock = (APPSocket*)sock;
-
-    return recv(cmSock->sock, buffer, bufSize, 0);
-}
-
-CMTStatus APP_Shutdown(CMTSocket sock)
-{
-    APPSocket *cmSock = (APPSocket*)sock;
-    int rv;
-
-    rv = shutdown(cmSock->sock, 1);
-    return (rv == 0) ? CMTSuccess : CMTFailure;
-}
-
-CMTStatus APP_Close(CMTSocket sock)
-{
-    APPSocket *cmSock = (APPSocket*)sock;
-    int rv;
-
-#ifdef XP_UNIX
-    rv = close(cmSock->sock);
-#else
-    rv = closesocket(cmSock->sock);
-#endif
-    free(cmSock);
-    return (rv == 0) ? CMTSuccess : CMTFailure;
-}

mozilla/security/psm/lib/client/sample/appsock.h

@@ -1,69 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef _APPSOCK_H_
-#define _APPSOCK_H_
-#include "cmtcmn.h"
-
-#ifdef XP_UNIX
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <sys/un.h>
-#include <sys/stat.h>
-
-typedef int SOCKET;
-#endif
-
-typedef struct APPSocketStr {
-    SOCKET sock;
-    int    isUnix;
-#ifdef XP_UNIX
-    struct sockaddr_un servAddr;
-#endif 
-} APPSocket; 
-
-extern CMT_SocketFuncs socketFuncs;
-
-CMTStatus APP_Close(CMTSocket sock);
-CMTStatus APP_Shutdown(CMTSocket sock);
-size_t APP_Receive(CMTSocket sock, void *buffer, size_t bufSize);
-CMTSocket APP_Select(CMTSocket *socks, int numsocks, int poll);
-size_t APP_Send(CMTSocket sock, void *buffer, size_t length);
-CMTStatus APP_VerifyUnixSocket(CMTSocket sock);
-CMTStatus APP_Connect(CMTSocket sock, short port, char *path);
-CMTSocket APP_GetSocket(int unixSock);
-
-
-#endif /* _APPSOCK_H_ */

mozilla/security/psm/lib/client/sample/config.mk

@@ -1,44 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-#
-#  Override TARGETS variable so that only static libraries
-#  are specifed as dependencies within rules.mk.
-#
-
-TARGETS        = $(PROGRAM)
-SHARED_LIBRARY =
-IMPORT_LIBRARY =
-PURE_LIBRARY   =
-LIBRARY        =
-

mozilla/security/psm/lib/client/sample/manifest.mn

@@ -1,52 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-CORE_DEPTH = ../../../../..
-
-# MODULE public and private header  directories are implicitly REQUIRED.
-MODULE	= cmtsample
-
-EXPORTS = \
-	$(NULL)
-
-CSRCS = \
-	sample.c \
-	appsock.c \
-	$(NULL)
-INCLUDES += -I../../protocol -I..
-
-# The MODULE is always implicitly required.
-# Listing it here in REQUIRES makes it appear twice in the cc command line.
-REQUIRES = security
-
-PROGRAM  = cmtsample
-

mozilla/security/psm/lib/client/sample/sample.c

@@ -1,346 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmtcmn.h"
-#include "cmtjs.h"
-#include "appsock.h"
-#include <stdarg.h>
-#include <string.h>
-
-#ifdef XP_UNIX
-#include <netdb.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#endif
-
-#ifdef WIN32
-#include <direct.h>
-#endif
-
-/*
- * This is a simple program that tries to detect if the psm server is loaded.
- * If the server is not loaded, it will start it.  The program will then 
- * connect to the server and fetch an HTML page from an SSL server.
- *
- * NOTE: This sample program does not implement a mutex for the libraries.
- * If implementing a threaded application, then pass in a mutex structure
- * so that connections to the psm server happen in a thread safe manner.
- */
-
-#define NUM_CONNECT_TRIES 10
-#define READ_BUFFER_SIZE  1024
-void
-usage(void)
-{
-    printf("Usage:\n"
-           "\tcmtsample <secure site>\n\n"
-           "This program will then echo the retrieved HTML to the screen\n");
-}
-
-void
-errorMessage(int err,char *msg, ...)
-{
-    va_list args;
-    
-    va_start(args, msg);
-    fprintf (stderr, "cmtSample%s: ", (err) ? " error" : "");
-    vfprintf (stderr, msg, args);
-    fprintf (stderr, "\n");
-    va_end(args);
-    if (err) {
-        exit (err);
-    }
-}
-
-#ifdef XP_UNIX
-#define FILE_PATH_SEPARATOR '/'
-#elif defined (WIN32)
-#define FILE_PATH_SEPARATOR '\\'
-#else
-#error Tell me what the file path separator is.
-#endif
-
-PCMT_CONTROL
-connect_to_psm(void)
-{
-    PCMT_CONTROL control=NULL;
-    char path[256], *tmp;
-
-#ifdef XP_UNIX
-    if (getcwd(path,256) == NULL) {
-      return NULL;
-    }
-#elif defined(WIN32)
-    if (_getcwd(path,256) == NULL) {
-      return NULL;
-    }
-#else
-#error Teach me how to get the current working directory.
-#endif
-    tmp = &path[strlen(path)];
-    sprintf(tmp,"%c%s", FILE_PATH_SEPARATOR, "psm");
-    return CMT_EstablishControlConnection(path, &socketFuncs, NULL);
-}
-
-#define HTTPS_STRING "https://"
-
-char*
-extract_host_from_url(char *url)
-{
-    char *start, *end, *retString=NULL;
-
-    while(isspace(*url)) {
-        url++;
-    }
-    url = strdup(url);
-    start = strstr(url, HTTPS_STRING);
-    if (start == NULL) {
-        return NULL;
-    }
-    start += strlen(HTTPS_STRING);
-    /*
-     * Figure out the end of the host name.
-     */
-    end = strchr(start, ':');
-    if (end != NULL) {
-        *end = '\0';
-    } else {
-        end = strchr(start, '/');
-        if (end != NULL) {
-            *end = '\0';
-        } else {
-            end = strchr(start, ' ');
-            if (end != NULL) {
-                *end = '\0';
-            }
-        }
-    }
-    retString = strdup(start);
-    return retString;
-}
-
-CMUint32
-get_port_from_url(char *url)
-{
-    char *colon, *port;
-
-    url = strdup(url);
-    colon = strrchr(url, ':');
-    if (colon == NULL ||
-        !isdigit(colon[1])) {
-        /* Return the default SSL port. */
-        free(url);
-        return 443;
-    }
-    colon++;
-    port = colon;
-    while(isdigit(*colon))
-        colon++;
-    colon[1] = '\0';
-    free(url);
-    return (CMUint32)atol(port);
-}
-
-char*
-extract_get_target(char *url)
-{
-    char *slash;
-
-    slash = strstr(url, "//");
-    slash += 2;
-    slash = strchr(slash, '/');
-    if (slash != NULL)
-        return strdup (slash);
-    else 
-        return strdup ("/");
-}
-
-/*
- * We'll use this function for prompting for a password.
- */
-char*
-passwordCallback(void *arg, char *prompt, void *cotext, int isPaswd)
-{
-    char input[256];
-    
-    printf(prompt);
-    fgets(input, 256, stdin);
-
-    return strdup(input);
-}
-
-void
-freeCallback(char *userInput)
-{
-  free (userInput);
-}
-
-#define NUM_PREFS 2
-
-int 
-main(int argc, char **argv)
-{
-  PCMT_CONTROL control;
-    CMTSocket sock, selSock;
-    char *hostname;
-    struct hostent *host;
-    char *ipAddress;
-    char buffer[READ_BUFFER_SIZE];
-    size_t bytesRead;
-    struct sockaddr_in destAddr;
-    char *getString;
-    char requestString[256];
-    char *profile;
-    CMTSetPrefElement prefs[NUM_PREFS];
-    char profileDir[256];
-
-#ifdef WIN32
-    WORD WSAVersion = 0x0101;
-    WSADATA WSAData;
-
-    WSAStartup (WSAVersion, &WSAData);
-#endif
-
-    if (argc < 2) {
-        usage();
-        return 1;
-    }
-    errorMessage (0,"cmtsample v1.0");
-    errorMessage (0,"Will try connecting to site %s", argv[1]);
-    if (strstr(argv[1], "https://") == NULL) {
-        errorMessage(2,"%s is not a secure site", argv[1]);
-    }
-    control = connect_to_psm();
-    if (control == NULL) {
-        errorMessage(3, "Could not connect to the psm server");
-    }
-    /* 
-     * Now we have to send the hello message.
-     */
-
-#ifdef WIN32
-    profile = strdup("default");
-    sprintf(profileDir,"%s", "c:\\default");
-#elif defined (XP_UNIX)
-    profile = getenv("LOGNAME");
-    sprintf(profileDir, "%s/.netscape", getenv("HOME"));
-#else
-#error Teach me how to fill in the user profile.
-#endif
-    if (CMT_Hello(control, PROTOCOL_VERSION,
-		  profile, profileDir) != CMTSuccess)
-    {
-        errorMessage(10, "Failed to send the Hello Message.");
-    }
-    CMT_SetPromptCallback(control, passwordCallback, NULL);
-    CMT_SetAppFreeCallback(control, freeCallback);
-    /*
-     * Now pass along some preferences to psm.  We'll pass hard coded
-     * ones here, but apps should figure out a way to manage their user's
-     * preferences.
-     */
-    prefs[0].key   = "security.enable_ssl2";
-    prefs[0].value = "true";
-    prefs[0].type  = CMT_PREF_BOOL;
-    prefs[1].key   = "security.enable_ssl3";
-    prefs[1].value = "true";
-    prefs[1].type  = CMT_PREF_BOOL;
-    CMT_PassAllPrefs(control, NUM_PREFS, prefs);
-    hostname = extract_host_from_url(argv[1]);
-    host = gethostbyname(hostname);
-    if (host == NULL) {
-        errorMessage(11, "gethostbyname for %s failed", hostname);
-    }
-    if (host->h_length != 4) {
-        errorMessage(4, "Site %s uses IV v6 socket.  Not supported by psm.");
-    }
-    
-    /* Create the socket we will use to get the decrypted data back from
-     * the psm server.
-     */
-    sock = APP_GetSocket(0);
-    if (sock == NULL) {
-        errorMessage(5, "Could not create new socket for communication with "
-                        "the psm server.");
-    }
-    memcpy(&(destAddr.sin_addr.s_addr), host->h_addr, host->h_length);
-    ipAddress = inet_ntoa(destAddr.sin_addr);
-    errorMessage(0, "Mapped %s to the following IP address: %s", argv[1],
-                 ipAddress);
-
-    if (CMT_OpenSSLConnection(control, sock, SSM_REQUEST_SSL_DATA_SSL,
-                              get_port_from_url(argv[1]), ipAddress, 
-                              hostname, CM_FALSE, NULL) != CMTSuccess) {
-        errorMessage(6, "Could not open SSL connection to %s.", argv[1]);
-    }
-
-    getString = extract_get_target(argv[1]);
-    sprintf(requestString, 
-            "GET %s HTTP/1.0\r\n"
-            "\r\n", getString, hostname);
-    APP_Send(sock, requestString, strlen(requestString));
-    /*
-     * Now all we have to do is sit here and fetch the data from the
-     * socket.
-     */
-    errorMessage (0, "About to print out the fetched page.");
-    while ((selSock=APP_Select(&sock, 1, 0)) != NULL) {
-        if (selSock == sock) {
-            bytesRead = APP_Receive(sock, buffer, READ_BUFFER_SIZE-1);
-            if (bytesRead == -1 || bytesRead == 0) {
-                break;
-            }
-            buffer[bytesRead] = '\0';
-            fprintf(stderr, buffer);
-        }
-    }
-    fprintf(stderr,"\n");
-    if (bytesRead == -1) {
-        errorMessage(7, "Error receiving decrypted data from psm.");
-    }
-    errorMessage(0, "Successfully read the entire page.");
-    if (CMT_DestroyDataConnection(control, sock) != CMTSuccess) {
-        errorMessage(8, "Error destroygin the SSL data connection "
-                     "with the psm server.");
-    }
-    if (CMT_CloseControlConnection(control) != CMTSuccess) {
-        errorMessage(9, "Error closing the control connection.");
-    }
-    return 0;
-}
-
-
-
-

mozilla/security/psm/lib/client/test.c

@@ -1,99 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "cmt.h"
-
-CMTStatus myCallback(CMTControl * control, CMTItem * event, void * arg);
-
-int main(int argc, char ** argv)
-{
-  CMTItem * msg, * event = NULL;
-  CMTStatus status;
-  int socket, datasocket;
-  int sent;
-  CMTControl * connect;
-  char * buffer = "some weird text that I feel like passing to server";
-  
-  connect = CMT_ControlConnect(myCallback, event);
-  
-  msg = CMT_ConstructMessage(10);
-
-  msg->type = (int)CMTClientMessage;
-  sprintf((char *)msg->data, "first msg!");
-
-  status = CMT_SendMessage(connect, msg, event);
-  if (status != SECSuccess)
-    perror("CMT_SendMessage");
-  
-  CMT_FreeEvent(event);
-  event = NULL;
-
-  sprintf((char *)msg->data, "second msg");
-  status = CMT_SendMessage(connect, msg, event);
-  if (status != SECSuccess)
-    perror("CMT_SendMessage");
-
-  datasocket = CMT_DataConnect(connect, NULL);
-  if (datasocket < 0) 
-    perror("CMT_DataConnect");
-  
-  sent = write(datasocket, (void *)buffer, strlen(buffer));
-  sent = write(datasocket, (void *)buffer, strlen(buffer));
-
-  close(datasocket);
-  
-  msg->type = (int)CMTClientMessage;
-  sprintf((char *)msg->data, "third msg!");
-  status = CMT_SendMessage(connect, msg, event);
-  if (status != SECSuccess)
-    perror("CMT_SendMessage"); 
-  
-  status = CMT_CloseControlConnection(connect);
-  if (status != SECSuccess)
-    perror("CMT_CloseControl");
-  
-  CMT_FreeMessage(msg);
-  CMT_FreeEvent(event);
-}
-
-CMTStatus myCallback(CMTControl * control, CMTItem * event, void * arg)
-{
-  if (event) 
-    printf("Event received is : type %d, data %s\n", event->type, event->data);
-  else printf("No event!\n");
-  if (arg) 
-    printf("Arg is %s\n", (char *)arg);
-  else printf("No arg!\n");
-
-
-  return SECSuccess;
-}

mozilla/security/psm/lib/macbuild/PSMPrefix.h

@@ -1,3 +0,0 @@
-
-
-#include "MacPrefix.h"

mozilla/security/psm/lib/macbuild/PSMPrefix_debug.h

@@ -1,2 +0,0 @@
-
-#include "MacPrefix_debug.h"

mozilla/security/psm/lib/makefile.win

@@ -1,27 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-DEPTH=..\..\..
-include <$(DEPTH)/config/config.mak>
-
-DIRS = client protocol
-
-include <$(DEPTH)\config\rules.mak>

mozilla/security/psm/lib/manifest.mn

@@ -1,43 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-#
-
-CORE_DEPTH = ../..
-DEPTH      = ../..
-
-DIRS = protocol client
-
-#
-# these dirs are not built at the moment
-#
-#NOBUILD_DIRS = jar

mozilla/security/psm/lib/protocol/MANIFEST

@@ -1,3 +0,0 @@
-obscure.h
-rsrcids.h
-ssmdefs.h

mozilla/security/psm/lib/protocol/Makefile

@@ -1,74 +0,0 @@
-#! gmake
-#
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-#
-
-#######################################################################
-# (1) Include initial platform-independent assignments (MANDATORY).   #
-#######################################################################
-
-include manifest.mn
-
-#######################################################################
-# (2) Include "global" configuration information. (OPTIONAL)          #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/config.mk
-
-#######################################################################
-# (3) Include "component" configuration information. (OPTIONAL)       #
-#######################################################################
-
-
-
-#######################################################################
-# (4) Include "local" platform-dependent assignments (OPTIONAL).      #
-#######################################################################
-include config.mk
-
-
-#######################################################################
-# (5) Execute "global" rules. (OPTIONAL)                              #
-#######################################################################
-
-include $(CORE_DEPTH)/coreconf/rules.mk
-
-#######################################################################
-# (6) Execute "component" rules. (OPTIONAL)                           #
-#######################################################################
-
-
-
-#######################################################################
-# (7) Execute "local" rules. (OPTIONAL).                              #
-#######################################################################
-

mozilla/security/psm/lib/protocol/Makefile.in

@@ -1,64 +0,0 @@
-#! gmake
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-#
-
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-LIBRARY_NAME = protocol
-MODULE = security
-
-EXPORTS = \
-	protocol.h \
-	protocolf.h \
-	protocolport.h \
-	protocolnspr20.h \
-	protocolshr.h \
-	ssmdefs.h \
-	rsrcids.h \
-	messages.h \
-	newproto.h \
-	$(NULL)
-
-
-CSRCS  = newproto.c \
-	 templates.c \
-	 protocolshr.c \
-	 $(NULL)
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/security/psm/lib/protocol/config.mk

@@ -1,44 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-#
-#  Override TARGETS variable so that only static libraries
-#  are specifed as dependencies within rules.mk.
-#
-
-TARGETS        = $(LIBRARY)
-SHARED_LIBRARY =
-IMPORT_LIBRARY =
-PURE_LIBRARY   =
-PROGRAM        =
-

mozilla/security/psm/lib/protocol/makefile.win

@@ -1,124 +0,0 @@
-#// 
-#// The contents of this file are subject to the Mozilla Public
-#// License Version 1.1 (the "License"); you may not use this file
-#// except in compliance with the License. You may obtain a copy of
-#// the License at http://www.mozilla.org/MPL/
-#// 
-#// Software distributed under the License is distributed on an "AS
-#// IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-#// implied. See the License for the specific language governing
-#// rights and limitations under the License.
-#// 
-#// The Original Code is the Netscape security libraries.
-#// 
-#// The Initial Developer of the Original Code is Netscape
-#// Communications Corporation.  Portions created by Netscape are 
-#// Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-#// Rights Reserved.
-#// 
-#// Contributor(s):
-#// 
-#// Alternatively, the contents of this file may be used under the
-#// terms of the GNU General Public License Version 2 or later (the
-#// "GPL"), in which case the provisions of the GPL are applicable 
-#// instead of those above.  If you wish to allow use of your 
-#// version of this file only under the terms of the GPL and not to
-#// allow others to use your version of this file under the MPL,
-#// indicate your decision by deleting the provisions above and
-#// replace them with the notice and other provisions required by
-#// the GPL.  If you do not delete the provisions above, a recipient
-#// may use your version of this file under either the MPL or the
-#// GPL.
-#// 
-IGNORE_MANIFEST=1
-#//------------------------------------------------------------------------
-#//
-#// Makefile to build the ssl library
-#//
-#//------------------------------------------------------------------------
-
-!if "$(MOZ_BITS)" == "16"
-!ifndef MOZ_DEBUG
-OPTIMIZER=-Os -UDEBUG -DNDEBUG
-!endif
-!endif
-
-#//------------------------------------------------------------------------
-#//
-#// Specify the depth of the current directory relative to the
-#// root of NS
-#//
-#//------------------------------------------------------------------------
-DEPTH= ..\..\..\..
-
-!ifndef MAKE_OBJ_TYPE
-MAKE_OBJ_TYPE=EXE
-!endif
-
-#//------------------------------------------------------------------------
-#//
-#// Define any Public Make Variables here: (ie. PDFFILE, MAPFILE, ...)
-#//
-#//------------------------------------------------------------------------
-LIBNAME=protocol
-PDBFILE=$(LIBNAME).pdb
-
-LINCS = -I$(PUBLIC)\security \
-	-I$(PUBLIC)\nspr \
-        -I$(DEPTH)\include \
-	-I..\include
-
-!ifndef OS_CONFIG
-OS_CONFIG = WIN$(MOZ_BITS)
-!endif
-
-LCFLAGS = -DEXPORT_VERSION -DLIB_BUILD
-
-#//------------------------------------------------------------------------
-#// 
-#// Define the files necessary to build the target (ie. OBJS)
-#//
-#//------------------------------------------------------------------------
-OBJS=                         \
-    .\$(OBJDIR)\newproto.obj  \
-    .\$(OBJDIR)\templates.obj \
-    .\$(OBJDIR)\protocolshr.obj \
-    $(NULL)
-
-#//------------------------------------------------------------------------
-#//
-#// Define any Public Targets here (ie. PROGRAM, LIBRARY, DLL, ...)
-#// (these must be defined before the common makefiles are included)
-#//
-#//------------------------------------------------------------------------
-LIBRARY=.\$(OBJDIR)\$(LIBNAME).lib
-
-#//------------------------------------------------------------------------
-#//
-#// install headers
-#//
-#//------------------------------------------------------------------------
-INSTALL_DIR=$(PUBLIC)\security
-INSTALL_FILE_LIST= protocol.h \
-   protocolf.h \
-   protocolport.h \
-   protocolnspr20.h \
-   protocolshr.h \
-   ssmdefs.h \
-   rsrcids.h \
-   messages.h \
-   newproto.h \
-   $(NULL)
-
-#//------------------------------------------------------------------------
-#//
-#// Include the common makefile rules
-#//
-#//------------------------------------------------------------------------
-include <$(DEPTH)/config/rules.mak>
-
-install:: $(LIBRARY)
-    $(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
-
-export:: INSTALL_FILES
-

mozilla/security/psm/lib/protocol/manifest.mn

@@ -1,65 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is the Netscape security libraries.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are 
-# Copyright (C) 1994-2000 Netscape Communications Corporation.  All
-# Rights Reserved.
-# 
-# Contributor(s):
-# 
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU General Public License Version 2 or later (the
-# "GPL"), in which case the provisions of the GPL are applicable 
-# instead of those above.  If you wish to allow use of your 
-# version of this file only under the terms of the GPL and not to
-# allow others to use your version of this file under the MPL,
-# indicate your decision by deleting the provisions above and
-# replace them with the notice and other provisions required by
-# the GPL.  If you do not delete the provisions above, a recipient
-# may use your version of this file under either the MPL or the
-# GPL.
-# 
-
-CORE_DEPTH = ../../..
-
-EXPORTS = \
-	protocol.h \
-	protocolf.h \
-	protocolport.h \
-	protocolnspr20.h \
-	protocolshr.h \
-	ssmdefs.h \
-	rsrcids.h \
-	messages.h \
-	newproto.h \
-	$(NULL)
-
-MODULE = security
-CSRCS  = newproto.c \
-	 protocolshr.c \
-	 templates.c \
-	 $(NULL)
-
-ifeq ($(subst /,_,$(shell uname -s)),OS2)
-	CSRCS += os2_rand.c
-endif
-
-#	mac_rand.c
-#	unix_rand.c
-#	win_rand.c
-#	prelib.c
-
-REQUIRES = security dbm nspr
-
-LIBRARY_NAME = protocol

mozilla/security/psm/lib/protocol/messages.h

@@ -1,620 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __MESSAGES_H__
-#define __MESSAGES_H__
-
-#include "newproto.h"
-
-typedef struct SingleNumMessage {
-  CMInt32 value;
-} SingleNumMessage;
-
-extern CMTMessageTemplate SingleNumMessageTemplate[];
-
-typedef struct SingleStringMessage {
-  char *string;
-} SingleStringMessage;
-
-extern CMTMessageTemplate SingleStringMessageTemplate[];
-
-typedef struct SingleItemMessage {
-  CMTItem item;
-} SingleItemMessage;
-
-extern CMTMessageTemplate SingleItemMessageTemplate[];
-
-typedef struct HelloRequest {
-  CMInt32 version;
-  CMInt32 policy;
-  CMBool doesUI;
-  char *profile;
-  char* profileDir;
-} HelloRequest;
-
-extern CMTMessageTemplate HelloRequestTemplate[];
-
-typedef struct HelloReply {
-  CMInt32 result;
-  CMInt32 sessionID;
-  CMInt32 version;
-  CMInt32 httpPort;
-  CMInt32 policy;
-  CMTItem nonce;
-  char *stringVersion;
-} HelloReply;
-
-extern CMTMessageTemplate HelloReplyTemplate[];
-
-typedef struct SSLDataConnectionRequest {
-  CMInt32 flags;
-  CMInt32 port;
-  char *hostIP;
-  char *hostName;
-  CMBool forceHandshake;
-  CMTItem clientContext;
-} SSLDataConnectionRequest;
-
-extern CMTMessageTemplate SSLDataConnectionRequestTemplate[];
-
-typedef struct TLSDataConnectionRequest {
-    CMInt32 port;
-    char* hostIP;
-    char* hostName;
-} TLSDataConnectionRequest;
-
-extern CMTMessageTemplate TLSDataConnectionRequestTemplate[];
-
-typedef struct TLSStepUpRequest {
-    CMUint32 connID;
-    CMTItem clientContext;
-} TLSStepUpRequest;
-
-extern CMTMessageTemplate TLSStepUpRequestTemplate[];
-
-typedef struct ProxyStepUpRequest {
-    CMUint32 connID;
-    CMTItem clientContext;
-    char* url;
-} ProxyStepUpRequest;
-
-extern CMTMessageTemplate ProxyStepUpRequestTemplate[];
-
-typedef struct PKCS7DataConnectionRequest {
-    CMUint32 resID;
-    CMTItem clientContext;
-} PKCS7DataConnectionRequest;
-
-extern CMTMessageTemplate PKCS7DataConnectionRequestTemplate[];
-
-typedef struct DataConnectionReply {
-  CMInt32 result;
-  CMInt32 connID;
-  CMInt32 port;
-} DataConnectionReply;
-
-extern CMTMessageTemplate DataConnectionReplyTemplate[];
-
-typedef struct UIEvent {
-  CMInt32 resourceID;
-  CMInt32 width;
-  CMInt32 height;
-  CMBool isModal;
-  char *url;
-  CMTItem clientContext;
-} UIEvent;
-
-extern CMTMessageTemplate UIEventTemplate[];
-extern CMTMessageTemplate OldUIEventTemplate[];
-
-typedef struct TaskCompletedEvent {
-  CMInt32 resourceID;
-  CMInt32 numTasks;
-  CMInt32 result;
-} TaskCompletedEvent;
-
-extern CMTMessageTemplate TaskCompletedEventTemplate[];
-
-typedef struct VerifyDetachedSigRequest {
-  CMInt32 pkcs7ContentID;
-  CMInt32 certUsage;
-  CMInt32 hashAlgID;
-  CMBool keepCert;
-  CMTItem hash;
-} VerifyDetachedSigRequest;
-
-extern CMTMessageTemplate VerifyDetachedSigRequestTemplate[];
-
-typedef struct CreateSignedRequest {
-  CMInt32 scertRID;
-  CMInt32 ecertRID;
-  CMInt32 dig_alg;
-  CMTItem digest;
-} CreateSignedRequest;
-
-extern CMTMessageTemplate CreateSignedRequestTemplate[];
-
-typedef struct CreateContentInfoReply {
-  CMInt32 ciRID;
-  CMInt32 result;
-  CMInt32 errorCode;
-} CreateContentInfoReply;
-
-extern CMTMessageTemplate CreateContentInfoReplyTemplate[];
-
-typedef struct CreateEncryptedRequest {
-  CMInt32 scertRID;
-  CMInt32 nrcerts;
-  CMInt32 *rcertRIDs;
-} CreateEncryptedRequest;
-
-extern CMTMessageTemplate CreateEncryptedRequestTemplate[];
-
-typedef struct CreateResourceRequest {
-  CMInt32 type;
-  CMTItem params;
-} CreateResourceRequest;
-
-extern CMTMessageTemplate CreateResourceRequestTemplate[];
-
-typedef struct CreateResourceReply {
-  CMInt32 result;
-  CMInt32 resID;
-} CreateResourceReply;
-
-extern CMTMessageTemplate CreateResourceReplyTemplate[];
-
-typedef struct GetAttribRequest {
-  CMInt32 resID;
-  CMInt32 fieldID;
-} GetAttribRequest;
-
-extern CMTMessageTemplate GetAttribRequestTemplate[];
-
-typedef struct GetAttribReply {
-  CMInt32 result;
-  SSMAttributeValue value;
-} GetAttribReply;
-
-extern CMTMessageTemplate GetAttribReplyTemplate[];
-
-typedef struct SetAttribRequest {
-  CMInt32 resID;
-  CMInt32 fieldID;
-  SSMAttributeValue value;
-} SetAttribRequest;
-
-extern CMTMessageTemplate SetAttribRequestTemplate[];
-
-typedef struct PickleResourceReply {
-    CMInt32 result;
-    CMTItem blob;
-} PickleResourceReply;
-
-extern CMTMessageTemplate PickleResourceReplyTemplate[];
-
-typedef struct UnpickleResourceRequest {
-  CMInt32 resourceType;
-  CMTItem resourceData;
-} UnpickleResourceRequest;
-
-extern CMTMessageTemplate UnpickleResourceRequestTemplate[];
-
-typedef struct UnpickleResourceReply {
-    CMInt32 result;
-    CMInt32 resID;
-} UnpickleResourceReply;
-
-extern CMTMessageTemplate UnpickleResourceReplyTemplate[];
-
-typedef struct PickleSecurityStatusReply {
-    CMInt32 result;
-    CMInt32 securityLevel;
-    CMTItem blob;
-} PickleSecurityStatusReply;
-
-extern CMTMessageTemplate PickleSecurityStatusReplyTemplate[];
-
-typedef struct DupResourceReply {
-    CMInt32 result;
-    CMUint32 resID;
-} DupResourceReply;
-
-extern CMTMessageTemplate DupResourceReplyTemplate[];
-
-typedef struct DestroyResourceRequest {
-  CMInt32 resID;
-  CMInt32 resType;
-} DestroyResourceRequest;
-
-extern CMTMessageTemplate DestroyResourceRequestTemplate[];
-
-typedef struct VerifyCertRequest {
-  CMInt32 resID;
-  CMInt32 certUsage;
-} VerifyCertRequest;
-
-extern CMTMessageTemplate VerifyCertRequestTemplate[];
-
-typedef struct AddTempCertToDBRequest {
-  CMInt32 resID;
-  char *nickname;
-  CMInt32 sslFlags;
-  CMInt32 emailFlags;
-  CMInt32 objSignFlags;
-} AddTempCertToDBRequest;
-
-extern CMTMessageTemplate AddTempCertToDBRequestTemplate[];
-
-typedef struct MatchUserCertRequest {
-  CMInt32 certType;
-  CMInt32 numCANames;
-  char **caNames;
-} MatchUserCertRequest;
-
-extern CMTMessageTemplate MatchUserCertRequestTemplate[];
-
-typedef struct MatchUserCertReply {
-  CMInt32 numCerts;
-  CMInt32 *certs;
-} MatchUserCertReply;
-
-extern CMTMessageTemplate MatchUserCertReplyTemplate[];
-
-typedef struct EncodeCRMFReqRequest {
-    CMInt32 numRequests;
-    CMInt32 * reqIDs;
-} EncodeCRMFReqRequest;
-
-extern CMTMessageTemplate EncodeCRMFReqRequestTemplate[];
-
-typedef struct CMMFCertResponseRequest {
-    char *nickname;
-    char *base64Der;
-    CMBool doBackup;
-    CMTItem clientContext;
-} CMMFCertResponseRequest;
-
-extern CMTMessageTemplate CMMFCertResponseRequestTemplate[];
-
-typedef struct PasswordRequest {
-    CMInt32 tokenKey;
-    char *prompt;
-    CMTItem clientContext;
-} PasswordRequest;
-
-extern CMTMessageTemplate PasswordRequestTemplate[];
-
-typedef struct PasswordReply {
-    CMInt32 result;
-    CMInt32 tokenID;
-    char * passwd;
-} PasswordReply;
-
-extern CMTMessageTemplate PasswordReplyTemplate[];
-
-typedef struct KeyPairGenRequest {
-    CMInt32 keyGenCtxtID;
-    CMInt32 genMechanism;
-    CMInt32 keySize;
-    CMTItem params;
-} KeyPairGenRequest;
-
-extern CMTMessageTemplate KeyPairGenRequestTemplate[];
-
-typedef struct DecodeAndCreateTempCertRequest {
-    CMInt32 type;
-    CMTItem cert;
-} DecodeAndCreateTempCertRequest;
-
-extern CMTMessageTemplate DecodeAndCreateTempCertRequestTemplate[];
-
-typedef struct GenKeyOldStyleRequest {
-    char *choiceString;
-    char *challenge;
-    char *typeString;
-    char *pqgString;
-} GenKeyOldStyleRequest;
-
-extern CMTMessageTemplate GenKeyOldStyleRequestTemplate[];
-
-typedef struct GenKeyOldStyleTokenRequest {
-    CMInt32 rid;
-    CMInt32 numtokens;
-    char ** tokenNames;
-} GenKeyOldStyleTokenRequest;
-
-extern CMTMessageTemplate GenKeyOldStyleTokenRequestTemplate[];
-
-typedef struct GenKeyOldStyleTokenReply {
-    CMInt32 rid;
-    CMBool cancel;
-    char * tokenName;
-} GenKeyOldStyleTokenReply;
-
-extern CMTMessageTemplate GenKeyOldStyleTokenReplyTemplate[];
-
-typedef struct GenKeyOldStylePasswordRequest {
-    CMInt32 rid;
-    char * tokenName;
-    CMBool internal;
-    CMInt32 minpwdlen;
-    CMInt32 maxpwdlen;
-} GenKeyOldStylePasswordRequest;
-
-extern CMTMessageTemplate GenKeyOldStylePasswordRequestTemplate[];
-
-typedef struct GenKeyOldStylePasswordReply {
-    CMInt32 rid;
-    CMBool cancel;
-    char * password;
-} GenKeyOldStylePasswordReply;
-
-extern CMTMessageTemplate GenKeyOldStylePasswordReplyTemplate[];
-
-typedef struct GetKeyChoiceListRequest {
-    char *type;
-    char *pqgString;
-} GetKeyChoiceListRequest;
-
-extern CMTMessageTemplate GetKeyChoiceListRequestTemplate[];
-
-typedef struct GetKeyChoiceListReply {
-    CMInt32 nchoices;
-    char **choices;
-} GetKeyChoiceListReply;
-
-extern CMTMessageTemplate GetKeyChoiceListReplyTemplate[];
-
-typedef struct AddNewSecurityModuleRequest {
-    char *moduleName;
-    char *libraryPath;
-    CMInt32 pubMechFlags;
-    CMInt32 pubCipherFlags;
-} AddNewSecurityModuleRequest;
-
-extern CMTMessageTemplate AddNewSecurityModuleRequestTemplate[];
-
-typedef struct FilePathRequest {
-    CMInt32 resID;
-    char *prompt;
-    CMBool getExistingFile;
-    char *fileRegEx;
-} FilePathRequest;
-
-extern CMTMessageTemplate FilePathRequestTemplate[];
-
-typedef struct FilePathReply {
-    CMInt32 resID;
-    char *filePath;
-} FilePathReply;
-
-extern CMTMessageTemplate FilePathReplyTemplate[];
-
-typedef struct PasswordPromptReply {
-    CMInt32 resID;
-    char *promptReply;
-} PasswordPromptReply;
-
-extern CMTMessageTemplate PasswordPromptReplyTemplate[];
-
-typedef struct SignTextRequest {
-    CMInt32 resID;
-    char *stringToSign;
-    char *hostName;
-    char *caOption;
-    CMInt32 numCAs;
-    char** caNames;
-} SignTextRequest;
-
-extern CMTMessageTemplate SignTextRequestTemplate[];
-
-typedef struct GetLocalizedTextReply {
-    CMInt32 whichString;
-    char *localizedString;
-} GetLocalizedTextReply;
-
-extern CMTMessageTemplate GetLocalizedTextReplyTemplate[];
-
-typedef struct ImportCertReply {
-    CMInt32 result;
-    CMInt32 resID;
-} ImportCertReply;
-
-extern CMTMessageTemplate ImportCertReplyTemplate[];
-
-typedef struct PromptRequest {
-    CMInt32 resID;
-    char *prompt;
-    CMTItem clientContext;
-} PromptRequest;
-
-extern CMTMessageTemplate PromptRequestTemplate[];
-
-typedef struct PromptReply {
-    CMInt32 resID;
-    CMBool cancel;
-    char *promptReply;
-} PromptReply;
-
-extern CMTMessageTemplate PromptReplyTemplate[];
-
-typedef struct RedirectCompareReqeust {
-    CMTItem socketStatus1Data;
-    CMTItem socketStatus2Data;
-} RedirectCompareRequest;
-
-extern CMTMessageTemplate RedirectCompareRequestTemplate[];
-
-typedef struct DecodeAndAddCRLRequest {
-    CMTItem  derCrl;
-    CMUint32 type;
-    char *url;
-} DecodeAndAddCRLRequest;
-
-extern CMTMessageTemplate DecodeAndAddCRLRequestTemplate[];
-
-typedef struct SecurityAdvisorRequest {
-    CMInt32 infoContext;
-    CMInt32 resID;
-    char * hostname;
-	char * senderAddr;
-    CMUint32 encryptedP7CInfo;
-    CMUint32 signedP7CInfo;
-    CMInt32 decodeError;
-    CMInt32 verifyError;
-	CMBool encryptthis;
-	CMBool signthis;
-	CMInt32 numRecipients;
-	char ** recipients;
-} SecurityAdvisorRequest;
-
-extern CMTMessageTemplate SecurityAdvisorRequestTemplate[];
-
-/* "SecurityConfig" javascript related message templates */
-typedef struct SCAddTempCertToPermDBRequest {
-    CMTItem certKey;
-    char* trustStr;
-    char* nickname;
-} SCAddTempCertToPermDBRequest;
-
-extern CMTMessageTemplate SCAddTempCertToPermDBRequestTemplate[];
-
-typedef struct SCDeletePermCertsRequest {
-    CMTItem certKey;
-    CMBool deleteAll;
-} SCDeletePermCertsRequest;
-
-extern CMTMessageTemplate SCDeletePermCertsRequestTemplate[];
-
-typedef struct TimeMessage {
-    CMInt32 year;
-    CMInt32 month;
-    CMInt32 day;
-    CMInt32 hour;
-    CMInt32 minute;
-    CMInt32 second;
-} TimeMessage;
-
-extern CMTMessageTemplate TimeMessageTemplate[];
-
-typedef struct CertEnumElement {
-    char* name;
-    CMTItem certKey;
-} CertEnumElement;
-
-typedef struct SCCertIndexEnumReply {
-      int length;
-      CertEnumElement* list;
-} SCCertIndexEnumReply;
-
-extern CMTMessageTemplate SCCertIndexEnumReplyTemplate[];
-
-/* Test message */
-typedef struct TestListElement {
-	char * name;
-	char * value;
-} TestListElement;
-
-typedef struct TestList {
-	char *listName;
-	int numElements;
-	TestListElement *elements;
-} TestList;
-
-extern CMTMessageTemplate TestListTemplate[];
-
-/* Preference-related structs */
-typedef struct SetPrefElement {
-    char* key;
-    char* value;
-    CMInt32 type;
-} SetPrefElement;
-
-typedef struct SetPrefListMessage {
-    int length;
-    SetPrefElement* list;
-} SetPrefListMessage;
-
-extern CMTMessageTemplate SetPrefListMessageTemplate[];
-
-typedef struct GetPrefElement {
-    char* key;
-    CMInt32 type;
-} GetPrefElement;
-
-typedef struct GetPrefListRequest {
-    int length;
-    GetPrefElement* list;
-} GetPrefListRequest;
-
-extern CMTMessageTemplate GetPrefListRequestTemplate[];
-
-typedef struct GetCertExtension {
-    CMUint32 resID;
-    CMUint32 extension;
-} GetCertExtension;
-
-extern CMTMessageTemplate GetCertExtensionTemplate[];
-
-typedef struct HTMLCertInfoRequest {
-    CMUint32 certID;
-    CMUint32 showImages;
-    CMUint32 showIssuer;
-} HTMLCertInfoRequest;
-
-extern CMTMessageTemplate HTMLCertInfoRequestTemplate[];
-
-typedef struct EncryptRequestMessage
-{
-  CMTItem keyid;  /* May have length 0 for default */
-  CMTItem data;
-  CMTItem ctx;  /* serialized void* ptr */
-} EncryptRequestMessage;
-
-extern CMTMessageTemplate EncryptRequestTemplate[];
-
-typedef struct SingleItemMessage EncryptReplyMessage;
-#define EncryptReplyTemplate SingleItemMessageTemplate
-
-typedef struct DecryptRequestMessage
-{
-  CMTItem data;
-  CMTItem ctx;  /* serialized void* ptr */
-} DecryptRequestMessage;
-extern CMTMessageTemplate DecryptRequestTemplate[];
-
-typedef struct SingleItemMessage DecryptReplyMessage;
-#define DecryptReplyTemplate SingleItemMessageTemplate
-
-#endif /* __MESSAGES_H__ */

mozilla/security/psm/lib/protocol/newproto.c

@@ -1,602 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include <string.h>
-#include <assert.h>
-#ifdef WIN32
-#include <winsock.h>
-#endif
-#ifdef XP_MAC
-#include "macsocket.h"
-#endif
-
-#include "newproto.h"
-
-char SSMVersionString[] = "1.1";
-
-CMT_Alloc_fn cmt_alloc = malloc;
-CMT_Free_fn cmt_free = free;
-
-#define ASSERT(x) assert(x)
-
-#define CM_ntohl ntohl
-#define CM_htonl htonl
-
-
-/*************************************************************
- *
- * CMT_Init
- *
- *
- ************************************************************/
-void
-CMT_Init(CMT_Alloc_fn allocfn, CMT_Free_fn freefn)
-{
-    cmt_alloc = allocfn;
-    cmt_free = freefn;
-}
-
-static CMTStatus
-decode_int(unsigned char **curptr, void *dest, CMInt32 *remaining)
-{
-    CMInt32 datalen = sizeof(CMInt32);
-
-    if (*remaining < datalen)
-        return CMTFailure;
-    *(CMInt32 *)dest = ntohl(**(CMInt32 **)curptr);
-    *remaining -= datalen;
-    *curptr += datalen;
-    return CMTSuccess;
-}
-
-static CMTStatus
-decode_string(unsigned char **curptr, CMInt32 *len,
-              unsigned char **data, CMInt32 *remaining)
-{
-    CMTStatus rv;
-    CMInt32 datalen;
-
-    rv = decode_int(curptr, len, remaining);
-    if (rv != CMTSuccess)
-        return CMTFailure;
-
-    /* NULL string */
-    if (*len == 0) {
-        *data = NULL;
-        goto done;
-    }
-
-    datalen = (*len + 3) & ~3;
-    if (*remaining < datalen)
-        return CMTFailure;
-
-    *data = (unsigned char *) cmt_alloc(*len + 1);
-    if (*data == NULL)
-        return CMTFailure;
-
-    memcpy(*data, *curptr, *len);
-    (*data)[*len] = 0;
-    *remaining -= datalen;
-    *curptr += datalen;
-done:
-    return CMTSuccess;
-}
-
-/*************************************************************
- * CMT_DecodeMessage
- *
- * Decode msg into dest as specified by tmpl.
- *
- ************************************************************/
-CMTStatus
-CMT_DecodeMessage(CMTMessageTemplate *tmpl, void *dest, CMTItem *msg)
-{
-    unsigned char *curptr, *destptr, *list;
-	void ** ptr;
-    CMInt32 remaining, len, choiceID = 0, listSize, listCount = 0;
-    CMBool inChoice = CM_FALSE, foundChoice = CM_FALSE, inList = CM_FALSE;
-    CMInt32 listItemSize = 0;
-    CMTStatus rv = CMTSuccess;
-	CMTMessageTemplate *startOfList, *p;
-	CMBool inStructList = CM_FALSE;
-
-    curptr = msg->data;
-    remaining = msg->len;
-
-    while(tmpl->type != CMT_DT_END) {
-        /* XXX Maybe this should be a more formal state machine? */
-        if (inChoice) {
-            if (tmpl->type == CMT_DT_END_CHOICE) {
-                if (!foundChoice)
-                    goto loser;
-                inChoice = CM_FALSE;
-                foundChoice = CM_FALSE;
-                tmpl++;
-                continue;
-            }
-            if (choiceID != tmpl->choiceID) {
-                tmpl++;
-                continue;  /* Not this option */
-            } else {
-                foundChoice = CM_TRUE;
-            }
-        }
-        if (inList) {
-            destptr = &list[listCount * listItemSize];
-            listCount++;
-        } else {
-			if (inStructList) {
-				destptr = tmpl->offset + list;
-			} else {
-				destptr = tmpl->offset + (unsigned char *)dest;
-			}
-        }
-        switch (tmpl->type) {
-          case CMT_DT_RID:
-          case CMT_DT_INT:
-          case CMT_DT_BOOL:
-            rv = decode_int(&curptr, destptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            break;
-          case CMT_DT_STRING:
-            rv = decode_string(&curptr, &len, (unsigned char **)destptr,
-                               &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            break;
-          case CMT_DT_ITEM:
-            rv = decode_string(&curptr, (long *) &((CMTItem *)destptr)->len,
-                               &((CMTItem *)destptr)->data, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            break;
-          case CMT_DT_LIST:
-            /* XXX This is too complicated */
-            rv = decode_int(&curptr, destptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            listSize = *(CMInt32 *)destptr;
-            tmpl++;
-            if (tmpl->type == CMT_DT_STRING) {
-                listItemSize = sizeof(unsigned char *);
-            } else if (tmpl->type == CMT_DT_ITEM) {
-                listItemSize = sizeof(CMTItem);
-            } else {
-                listItemSize = sizeof(CMInt32);
-            }
-            if (listSize == 0) {
-                list = NULL;
-            } else {
-                list = (unsigned char *) cmt_alloc(listSize * listItemSize);
-            }
-            *(void **)(tmpl->offset + (unsigned char *)dest) = list;
-            inList = CM_TRUE;
-            listCount = 0;
-            break;
-          case CMT_DT_STRUCT_LIST:
-            /* XXX This is too complicated */
-            rv = decode_int(&curptr, destptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            listSize = *(CMInt32 *)destptr;
-            tmpl++;
-			if (tmpl->type != CMT_DT_STRUCT_PTR) {
-				goto loser;
-			}
-			ptr = (void**)(tmpl->offset + (unsigned char *)dest);
-			startOfList = tmpl;
-			p = tmpl;
-			listItemSize = 0;
-			while (p->type != CMT_DT_END_STRUCT_LIST) {
-				if (p->type == CMT_DT_STRING) {
-					listItemSize += sizeof(unsigned char *);
-				} else if (p->type == CMT_DT_ITEM) {
-					listItemSize += sizeof(CMTItem);
-				} else if (p->type == CMT_DT_INT) {
-	                listItemSize += sizeof(CMInt32);
-		        }
-				p++;
-			}
-            if (listSize == 0) {
-                list = NULL;
-            } else {
-                list = (unsigned char *) cmt_alloc(listSize * listItemSize);
-            }
-            *ptr = list;
-            inStructList = CM_TRUE;
-            listCount = 0;
-            break;
-		  case CMT_DT_END_STRUCT_LIST:
-			listCount++;
-			if (listCount == listSize) {
-				inStructList = CM_FALSE;
-			} else {
-				list += listItemSize;
-				tmpl = startOfList;
-			}
-			break;
-          case CMT_DT_CHOICE:
-            rv = decode_int(&curptr, destptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            choiceID = *(CMInt32 *)destptr;
-            inChoice = CM_TRUE;
-            foundChoice = CM_FALSE;
-            break;
-          case CMT_DT_END_CHOICE: /* Loop should exit before we see these. */
-          case CMT_DT_END:
-          default:
-            ASSERT(0);
-            break;
-        }
-        if (inList) {
-            if (listCount == listSize) {
-                inList = CM_FALSE;
-                tmpl++;
-            }
-        } else {
-            tmpl++;
-        }
-    }
-loser:
-    /* Free the data buffer */
-    if (msg->data) {
-        cmt_free(msg->data);
-        msg->data = NULL;
-    }
-    return rv;
-}
-
-static CMTStatus
-calc_msg_len(CMTMessageTemplate *tmpl, void *src, CMInt32 *len_out)
-{
-    CMInt32 len = 0, choiceID = 0, listSize, listItemSize, listCount;
-    unsigned char *srcptr, *list;
-    CMBool inChoice = CM_FALSE, inList = CM_FALSE, foundChoice = CM_FALSE;
-	CMTMessageTemplate *startOfList, *p;
-	CMBool inStructList = CM_FALSE;
-
-    while(tmpl->type != CMT_DT_END) {
-        if (inChoice) {
-            if (tmpl->type == CMT_DT_END_CHOICE) {
-                if (!foundChoice)
-                    goto loser;
-                inChoice = CM_FALSE;
-                foundChoice = CM_FALSE;
-                tmpl++;
-                continue;
-            }
-            if (choiceID != tmpl->choiceID) {
-                tmpl++;
-                continue;  /* Not this option */
-            } else {
-                foundChoice = CM_TRUE;
-            }
-        }
-        if (inList) {
-            srcptr = &list[listCount * listItemSize];
-            listCount++;
-        } else if (inStructList) {
-			srcptr = tmpl->offset + list;
-		} else {
-            srcptr = tmpl->offset + (unsigned char *)src;
-        }
-        switch(tmpl->type) {
-          case CMT_DT_RID:
-          case CMT_DT_INT:
-          case CMT_DT_BOOL:
-            len += sizeof(CMInt32);
-            break;
-          case CMT_DT_STRING:
-            len += sizeof(CMInt32);
-            /* Non NULL string */
-            if (*(char**)srcptr) {
-                len += (strlen(*(char**)srcptr) + 4) & ~3;
-            }
-            break;
-          case CMT_DT_ITEM:
-            len += sizeof(CMInt32);
-            len += (((CMTItem *)srcptr)->len + 3) & ~3;
-            break;
-          case CMT_DT_LIST:
-            len += sizeof(CMInt32);
-            listSize = *(CMInt32 *)srcptr;
-            tmpl++;
-            if (tmpl->type == CMT_DT_STRING) {
-                listItemSize = sizeof(unsigned char *);
-            } else if (tmpl->type == CMT_DT_ITEM) {
-                listItemSize = sizeof(CMTItem);
-            } else {
-                listItemSize = sizeof(CMInt32);
-            }
-            list = *(unsigned char **)(tmpl->offset + (unsigned char *)src);
-            listCount = 0;
-            inList = CM_TRUE;
-            break;
-		  case CMT_DT_STRUCT_LIST:
-			len += sizeof(CMInt32);
-			listSize = *(CMInt32 *)srcptr;
-			tmpl++;
-			if (tmpl->type != CMT_DT_STRUCT_PTR) {
-				goto loser;
-			}
-			list = *(unsigned char**)(tmpl->offset + (unsigned char*)src);
-			startOfList = tmpl;
-			p = tmpl;
-			listItemSize = 0;
-			while (p->type != CMT_DT_END_STRUCT_LIST) {
-				if (p->type == CMT_DT_STRING) {
-					listItemSize += sizeof(unsigned char *);
-				} else if (p->type == CMT_DT_ITEM) {
-					listItemSize += sizeof(CMTItem);
-				} else if (p->type == CMT_DT_INT) {
-					listItemSize += sizeof(CMInt32);
-				}
-				p++;
-			}
-			listCount = 0;
-			inStructList = CM_TRUE;
-			break;
-		  case CMT_DT_END_STRUCT_LIST:
-			listCount++;
-			if (listCount == listSize) {
-				inStructList = CM_FALSE;
-			} else {
-				list += listItemSize;
-				tmpl = startOfList;
-			}
-			break;
-          case CMT_DT_CHOICE:
-            len += sizeof(CMInt32);
-            choiceID = *(CMInt32 *)srcptr;
-            inChoice = CM_TRUE;
-            foundChoice = CM_FALSE;
-            break;
-          case CMT_DT_END_CHOICE: /* Loop should exit before we see these. */
-          case CMT_DT_END:
-          default:
-            ASSERT(0);
-            break;
-        }
-        if (inList) {
-            if (listCount == listSize) {
-                inList = CM_FALSE;
-                tmpl++;
-            }
-        } else {
-            tmpl++;
-        }
-    }
-    *len_out = len;
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}
-
-static CMTStatus
-encode_int(unsigned char **curptr, void *src, CMInt32 *remaining)
-{
-    CMInt32 datalen = sizeof(CMInt32);
-
-    if (*remaining < datalen)
-        return CMTFailure;
-    **(CMInt32 **)curptr = CM_htonl(*(CMInt32 *)src);
-    *remaining -= datalen;
-    *curptr += datalen;
-    return CMTSuccess;
-}
-
-static CMTStatus
-encode_string(unsigned char **curptr, CMInt32 len,
-              unsigned char *data, CMInt32 *remaining)
-{
-    CMTStatus rv;
-    CMInt32 datalen;
-
-    rv = encode_int(curptr, &len, remaining);
-    if (rv != CMTSuccess)
-        return CMTFailure;
-
-    /* NULL string */
-    if (len == 0) {
-        goto done;
-    }
-
-    datalen = (len + 3) & ~3;
-    if (*remaining < datalen)
-        return CMTFailure;
-
-    memcpy(*curptr, data, len);
-    *remaining -= datalen;
-    *curptr += datalen;
-done:
-    return CMTSuccess;
-}
-
-/*************************************************************
- * CMT_EncodeMessage
- *
- * Encode src into msg as specified by tmpl.
- *
- ************************************************************/
-CMTStatus
-CMT_EncodeMessage(CMTMessageTemplate *tmpl, CMTItem *msg, void *src)
-{
-    CMInt32 choiceID = 0, listSize, listItemSize, listCount, remaining;
-    unsigned char *srcptr, *curptr, *list;
-    CMBool inChoice = CM_FALSE, inList = CM_FALSE, foundChoice = CM_FALSE;
-    CMTStatus rv = CMTSuccess;
-	CMTMessageTemplate *startOfList, *p;
-	CMBool inStructList = CM_FALSE;
-
-    rv = calc_msg_len(tmpl, src, (long *) &msg->len);
-    if (rv != CMTSuccess)
-        goto loser;
-    curptr = msg->data = (unsigned char *) cmt_alloc(msg->len);
-    if(msg->data == NULL)
-        goto loser;
-    remaining = msg->len;
-
-    while(tmpl->type != CMT_DT_END) {
-        if (inChoice) {
-            if (tmpl->type == CMT_DT_END_CHOICE) {
-                if (!foundChoice)
-                    goto loser;
-                inChoice = CM_FALSE;
-                foundChoice = CM_FALSE;
-                tmpl++;
-                continue;
-            }
-            if (choiceID != tmpl->choiceID) {
-                tmpl++;
-                continue;  /* Not this option */
-            } else {
-                foundChoice = CM_TRUE;
-            }
-        }
-        if (inList) {
-            srcptr = &list[listCount * listItemSize];
-            listCount++;
-        } else {
-			if (inStructList) {
-				srcptr = tmpl->offset + list;
-			} else {
-				srcptr = tmpl->offset + (unsigned char *)src;
-			}
-        }
-        switch(tmpl->type) {
-          case CMT_DT_RID:
-          case CMT_DT_INT:
-          case CMT_DT_BOOL:
-            rv = encode_int(&curptr, srcptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            break;
-          case CMT_DT_STRING:
-             if (*(char**)srcptr) {
-                 /* Non NULL string */
-                 rv = encode_string(&curptr, (long) strlen(*(char**)srcptr), 
-                 	                *(unsigned char**)srcptr, &remaining);
-             } else {
-                 /* NULL string */
-                 rv = encode_string(&curptr, 0L, *(unsigned char**)srcptr, &remaining);
-             }
-             if (rv != CMTSuccess)
-                goto loser;
-             break;
-          case CMT_DT_ITEM:
-            rv = encode_string(&curptr, ((CMTItem *)srcptr)->len,
-                               ((CMTItem *)srcptr)->data, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            break;
-          case CMT_DT_LIST:
-            rv = encode_int(&curptr, srcptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            listSize = *(CMInt32 *)srcptr;
-            tmpl++;
-            if (tmpl->type == CMT_DT_STRING) {
-                listItemSize = sizeof(unsigned char *);
-            } else if (tmpl->type == CMT_DT_ITEM) {
-                listItemSize = sizeof(CMTItem);
-            } else {
-                listItemSize = sizeof(CMInt32);
-            }
-            list = *(unsigned char **)(tmpl->offset + (unsigned char *)src);
-            listCount = 0;
-            inList = CM_TRUE;
-            break;
-		  case CMT_DT_STRUCT_LIST:
-            rv = encode_int(&curptr, srcptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            listSize = *(CMInt32 *)srcptr;
-			tmpl++;
-			if (tmpl->type != CMT_DT_STRUCT_PTR) {
-				goto loser;
-			}
-			list = *(unsigned char**)(tmpl->offset + (unsigned char*)src);
-			startOfList = tmpl;
-			p = tmpl;
-			listItemSize = 0;
-			while (p->type != CMT_DT_END_STRUCT_LIST) {
-				if (p->type == CMT_DT_STRING) {
-					listItemSize += sizeof(unsigned char *);
-				} else if (p->type == CMT_DT_ITEM) {
-					listItemSize += sizeof(CMTItem);
-				} else if (p->type == CMT_DT_INT) {
-					listItemSize += sizeof(CMInt32);
-				}
-				p++;
-			}
-			listCount = 0;
-			inStructList = CM_TRUE;
-			break;
-		  case CMT_DT_END_STRUCT_LIST:
-			listCount++;
-			if (listCount == listSize) {
-				inStructList = CM_FALSE;
-			} else {
-				list += listItemSize;
-				tmpl = startOfList;
-			}
-			break;
-          case CMT_DT_CHOICE:
-            rv = encode_int(&curptr, srcptr, &remaining);
-            if (rv != CMTSuccess)
-                goto loser;
-            choiceID = *(CMInt32 *)srcptr;
-            inChoice = CM_TRUE;
-            foundChoice = CM_FALSE;
-            break;
-          case CMT_DT_END_CHOICE: /* Loop should exit before we see these. */
-          case CMT_DT_END:
-          default:
-            ASSERT(0);
-            break;
-        }
-        if (inList) {
-            if (listCount == listSize) {
-                inList = CM_FALSE;
-                tmpl++;
-            }
-        } else {
-            tmpl++;
-        }
-    }
-    return CMTSuccess;
-loser:
-    return CMTFailure;
-}

mozilla/security/psm/lib/protocol/newproto.h

@@ -1,102 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __NEWPROTO_H__
-#define __NEWPROTO_H__
-
-#include <stdlib.h>
-#include "ssmdefs.h"
-
-typedef enum CMTDataType {
-    CMT_DT_END,
-    CMT_DT_RID,
-    CMT_DT_INT,
-    CMT_DT_BOOL,
-    CMT_DT_STRING,
-    CMT_DT_ITEM,
-    CMT_DT_LIST,
-    CMT_DT_CHOICE,
-    CMT_DT_END_CHOICE,
-	CMT_DT_STRUCT_LIST,
-	CMT_DT_END_STRUCT_LIST,
-	CMT_DT_STRUCT_PTR
-} CMTDataType;
-
-typedef struct CMTMessageTemplate {
-    CMTDataType type;
-    CMUint32 offset;
-    CMInt32 validator;
-    CMInt32 choiceID;
-} CMTMessageTemplate;
-
-typedef struct CMTMessageHeader {
-    CMInt32 type;
-    CMInt32 len;
-} CMTMessageHeader;
-
-typedef void *(* CMT_Alloc_fn) (size_t size);
-typedef void (* CMT_Free_fn)(void * ptr);
-
-extern CMT_Alloc_fn cmt_alloc;
-extern CMT_Free_fn cmt_free;
-
-/*************************************************************
- *
- * CMT_Init
- *
- *
- ************************************************************/
-void
-CMT_Init(CMT_Alloc_fn allocfn, CMT_Free_fn freefn);
-
-/*************************************************************
- * CMT_DecodeMessage
- *
- * Decode msg into dest as specified by tmpl.
- *
- ************************************************************/
-CMTStatus
-CMT_DecodeMessage(CMTMessageTemplate *tmpl, void *dest, CMTItem *msg);
-
-
-/*************************************************************
- * CMT_EncodeMessage
- *
- * Encode src into msg as specified by tmpl.
- *
- ************************************************************/
-CMTStatus
-CMT_EncodeMessage(CMTMessageTemplate *tmpl, CMTItem *msg, void *src);
-
-
-#endif /* __NEWPROTO_H__ */

mozilla/security/psm/lib/protocol/obsample.c

@@ -1,187 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/* SAMPLE CODE
-** Illustrates use of SSMObscure object methods.
-**
-** Author:  Nelson Bolyard	June 1999
-*/
-
-#include <stdio.h>
-#include "obscure.h"
-
-
-/* On error, returns -1.
-** On success, returns non-negative number of unobscured bytes in buf
-int
-RecvInitObscureData(int fd, SSMObscureObject * obj, void * buf, int bufSize )
-{
-    SSMObscureBool done = 0;
-
-    do {
-	int cc;
-	int rv;
-	cc = read(fd, buf, bufSize);
-	if (cc <= 0)
-	    return -1;
-	rv = SSMObscure_RecvInit(obj, buf, cc, &done);
-    } while (!done);
-    return rv;
-}
-
-
-/* returns -1 on error, 0 on success. */
-int
-SendInitObscureData(int fd, SSMObscureObject * obj)
-{
-    unsigned char * initBuf = NULL;
-    int             rv      = -1;
-
-    do {
-	int bufLen;
-	int len;
-	int cc;
-
-	bufLen = SSMObscure_SendInit(obj, NULL);
-	if (bufLen <= 0)
-	    break;
-
-	initBuf = malloc(bufLen);
-	if (!initBuf)
-	    break;
-
-	len = SSMObscure_SendInit(obj, initBuf);
-	if (len != bufLen)
-	    break;
-
-	cc = write(fd, initBuf, len);
-
-	/* Note, this code assumes a blocking socket, 
-	** and hence doesn't deal with short writes.
-	*/
-	if (cc < len) 
-	    break;
-
-    	rv = 0;
-
-    } while (0);
-
-    if (initBuf) {
-	free(initBuf);
-    	initBuf = NULL;
-    }
-    return rv;
-}
-
-/* This is like write, but it obscures the data first. */
-/* This code assumes a blocking socket, and so it doesn't handle short 
-** writes.
-*/
-int 
-obscuredWrite(SSMObscureObject * obj, int fd, void * buf, int len)
-{
-    int rv;
-    int cc;
-
-    cc = SSMObscure_Send(obj, buf, len);
-    if (cc <= 0)
-    	return cc;
-    rv = write(fd, buf, cc);
-    ASSERT(rv == cc || rv < 0);
-    return rv;
-}
-
-/* This is like read, but it unobscures the data after reading it. */
-int 
-obscuredRead(SSMObscureObject * obj, int fd, void * buf, int len)
-{
-    int rv;
-    int cc;
-
-    do {
-	cc = read(fd, buf, len);
-	if (cc <= 0)
-	    return cc;
-	rv = SSMObscure_Recv(obj, buf, len);
-    } while (rv == 0);
-    return rv;
-}
-
-SSMObscureObject * sobj;
-unsigned char buf[8192];
-
-/* Call this with fd for socket that has just been accepted.
-** returns -1 on error, 
-** On success, returns non-negative number of bytes received in buf. 
-*/
-int
-InitClientObscureObject(int fd) 
-{
-    int rv;
-
-    sobj = SSMObscure_Create(0);
-    if (!sobj)
-    	return -1;
-
-    rv = SendInitObscureData(fd, sobj);
-    if (rv < 0)
-    	return rv;
-
-    rv = RecvInitObscureData(fd, sobj, buf, sizeof buf);
-    return rv;
-}
-
-/* Call this with fd for socket that has just been connected.
-** returns -1 on error, 
-** On success, returns non-negative number of bytes received in buf. 
-*/
-int
-InitServerObscureObject(int fd)
-{
-    int cc;
-
-    sobj = SSMObscure_Create(1);
-    if (!sobj)
-    	return -1;
-
-    cc = RecvInitObscureData(fd, sobj, buf, sizeof buf);
-    if (cc < 0) 
-    	return cc;
-
-
-    rv = SendInitObscureData(fd, sobj);
-    if (rv < 0)
-    	return rv;
-
-    return cc;
-}
-

mozilla/security/psm/lib/protocol/obscure.c

@@ -1,136 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include <stdlib.h>
-#include "obspriv.h"
-#include "newproto.h"
-
-
-/* 
-** Create a new Obscuring object 
-*/
-SSMObscureObject * 
-SSMObscure_Create(SSMObscureBool IsServer)
-{
-    SSMObscureObject * obj;
-    void *             priv;
-
-    obj = (SSMObscureObject *) cmt_alloc(sizeof *obj);
-    if (!obj)
-    	return obj;
-    /* This needs to be a little more elegant */
-    priv = SSMObscure_InitPrivate(obj, IsServer);
-    if (!priv) {
-    	cmt_free(obj);
-	return NULL;
-    }
-    obj->privData = priv;
-    return obj;
-}
-
-
-/* Prepare initial buffer with initial message to send to other side to 
-** establish cryptographic * synchronization.
-**
-** If buf is NULL, function returns the size of the buffer that 
-** the caller needs to allocate for sending the initial message.
-** 
-** If buf is non-null, function returns the number of bytes of data filled 
-** into buf, the amount that the caller should then send to the other side.
-**
-*/
-int 
-SSMObscure_SendInit( SSMObscureObject * obj, void * buf)
-{
-    int rv;
-    rv = obj->sendInit(obj->privData, buf);
-    return rv;
-}
-
-/* 
-** Obscure "len" bytes in "buf" before sending it. 
-*/
-int 
-SSMObscure_Send(	SSMObscureObject * obj, 
-			void *             buf, 
-			unsigned int       len)
-{
-    int rv;
-    rv = obj->send(obj->privData, buf, len);
-    return rv;
-}
-
-/* 
-** UnObscure "len" bytes in "buf" after receiving it. 
-** This function may absorb some or all of the received bytes, leaving 
-** fewer bytes (possibly none) in the buffer for the application to use 
-** than were in the buffer when the function was called.
-** Function returns the number of bytes of unobscured data remaining in
-** buf.  Zero means all data was used internally and no data remains 
-** for application use. Negative number means error occurred.
-*/
-int 
-SSMObscure_Recv(	SSMObscureObject * obj, 
-			void *             buf, 
-			unsigned int       len)
-{
-    int rv;
-    rv = obj->recv(obj->privData, buf, len);
-    return rv;
-}
-
-/* like _Recv, but returns a flag telling when all initialization info has
-** been received.
-*/
-int 
-SSMObscure_RecvInit(	SSMObscureObject * obj, 
-			void *             buf, 
-			unsigned int       len,
-			SSMObscureBool   * done)
-{
-    int rv;
-    rv = obj->recvInit(obj->privData, buf, len, done);
-    return rv;
-}
-
-/* 
-** Destroy the Obscure Object 
-*/
-int 
-SSMObscure_Destroy(SSMObscureObject * obj)
-{
-    int rv;
-    rv = obj->destroy(obj->privData);
-    cmt_free(obj);
-    return rv;
-}
-

mozilla/security/psm/lib/protocol/obscure.h

@@ -1,98 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __obscure_h__
-#define __obscure_h__ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-typedef unsigned char SSMObscureBool;
-
-typedef struct SSMObscureObjectStr 	SSMObscureObject;
-
-/* 
-** Create a new Obscuring object 
-*/
-extern SSMObscureObject * SSMObscure_Create(SSMObscureBool IsServer);
-
-
-/* Prepare initial buffer with initial message to send to other side to 
-** establish cryptographic * synchronization.
-**
-** If buf is NULL, function returns the size of the buffer that 
-** the caller needs to allocate for sending the initial message.
-** 
-** If buf is non-null, function returns the number of bytes of data filled 
-** into buf, the amount that the caller should then send to the other side.
-**
-*/
-extern int SSMObscure_SendInit( SSMObscureObject * obj,
-				void *             buf);
-
-/* 
-** Obscure "len" bytes in "buf" before sending it. 
-*/
-extern int SSMObscure_Send(	SSMObscureObject * obj, 
-                            	void *             buf, 
-				unsigned int       len);
-
-/* 
-** UnObscure "len" bytes in "buf" after receiving it. 
-** This function may absorb some or all of the received bytes, leaving 
-** fewer bytes (possibly none) in the buffer for the application to use 
-** than were in the buffer when the function was called.
-** Function returns the number of bytes of unobscured data remaining in
-** buf.  Zero means all data was used internally and no data remains 
-** for application use. Negative number means error occurred.
-*/
-extern int SSMObscure_Recv(	SSMObscureObject * obj, 
-                                void *             buf, 
-				unsigned int       len);
-
-/* like _Recv, but returns a flag telling when all initialization info has
-** been received.
-*/
-extern int SSMObscure_RecvInit(	SSMObscureObject * obj, 
-                                void *             buf, 
-				unsigned int       len,
-				SSMObscureBool   * done);
-
-/* 
-** Destroy the Obscure Object 
-*/
-extern int SSMObscure_Destroy(SSMObscureObject * obj);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __obscure_h__ */

mozilla/security/psm/lib/protocol/obspriv.c

@@ -1,115 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "obspriv.h"
-#include "newproto.h"
-#include <string.h>
-#include <assert.h>
-#include <time.h>
-
-/* 
-   Originally this code was used to obscure the control messages
-   traveling between processes. With the relaxation of export rules,
-   this whole step is no longer necessary, and is included for
-   informational purposes only. (We need to finish removing the 
-   obscuring code.)
-*/
-struct obscureNOPStr {
-    SSMObscureObject * obj;
-};
-
-typedef struct obscureNOPStr obscureV1;
-
-static int 
-ssmObscure_Destroy(void * privData)
-{
-    obscureV1 * priv = (obscureV1 *)privData;
-
-    memset(priv, 0, sizeof *priv);
-    cmt_free(priv);
-    return 0;
-}
-
-static int
-ssmObscure_Send(void * privData, void * buf, unsigned int len)
-{
-    /* obscureV1 *  priv 		= (obscureV1 *)privData;*/
-
-    /* NOP */
-    return len;
-}
-
-static int    
-ssmObscure_Recv(void * privData, void * buf, unsigned int len)
-{
-    /*obscureV1 *  priv 		= (obscureV1 *)privData;*/
-
-    /* NOP */
-    return len;
-}
-
-static int    
-ssmObscure_SendInit(void * privData, void * buf)
-{
-    /*obscureV1 *      priv = (obscureV1 *)privData;*/
-
-    return 0;
-}
-
-static int    
-ssmObscure_RecvInit(void * privData, void * buf, unsigned int len,
-                    SSMObscureBool * pDone)
-{
-    return 0;
-}
-
-static void *
-ssmObscure_InitPrivate(SSMObscureObject * obj, SSMObscureBool IsServer)
-{
-    obscureV1 *   priv 		= (obscureV1 *) cmt_alloc(sizeof (obscureV1));
-
-    if (!priv)
-    	return NULL;
-
-    priv->obj        = obj;
-
-    obj->privData  = (void *)priv;
-    obj->destroy  = ssmObscure_Destroy;
-    obj->send     = ssmObscure_Send;
-    obj->recv     = ssmObscure_Recv;
-    obj->sendInit = ssmObscure_SendInit;
-    obj->recvInit = ssmObscure_RecvInit;
-    
-    return priv;
-}
-
-obsInitFn SSMObscure_InitPrivate = ssmObscure_InitPrivate;

mozilla/security/psm/lib/protocol/obspriv.h

@@ -1,63 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#include "obscure.h"
-
-typedef void * (* obsInitFn)    (SSMObscureObject * instance, 
-                                 SSMObscureBool     IsServer);
-typedef int    (* obsDestroyFn) (void * priv);
-typedef int    (* obsSendFn)    (void * priv, void * buf, unsigned int len);
-typedef int    (* obsRecvFn)    (void * priv, void * buf, unsigned int len);
-typedef int    (* obsSendInitFn)(void * priv, void * buf);
-typedef int    (* obsRecvInitFn)(void * priv, void * buf, unsigned int len,
-                                 SSMObscureBool * done);
-
-struct SSMObscureObjectStr {
-    void *	  privData;
-    obsDestroyFn  destroy;
-    obsSendFn     send;
-    obsRecvFn     recv;
-    obsSendInitFn sendInit;
-    obsRecvInitFn recvInit;
-};
-
-
-/* This is common to the beginning of all versions of the obscuring protocol */
-struct SSMInitMsgHdrStr {
-    short	version;
-    short	length;
-};
-
-typedef struct SSMInitMsgHdrStr SSMInitMsgHdr;
-
-extern obsInitFn SSMObscure_InitPrivate;
-

mozilla/security/psm/lib/protocol/protocol.h

@@ -1,141 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*
-  protocol.h - Definitions of various items to support the PSM protocol.
- */
-
-#ifndef __PROTOCOL_H__
-#define __PROTOCOL_H__
-
-
-#include "rsrcids.h"
-
-#define SSMPRStatus SSMStatus
-#define SSMPR_SUCCESS SSM_SUCCESS
-#define SSMPR_FAILURE SSM_FAILURE
-
-#define SSMPR_INVALID_ARGUMENT_ERROR PR_INVALID_ARGUMENT_ERROR
-#define SSMPR_OUT_OF_MEMORY_ERROR    PR_OUT_OF_MEMORY_ERROR
-
-#define SSMPRInt32 PRInt32
-#define SSMPRUint32 PRUint32
-
-#define SSMPR_ntohl  PR_ntohl
-#define SSMPR_htonl  PR_htonl
-#define SSMPORT_Free   PORT_Free
-#define SSMPORT_ZAlloc PORT_ZAlloc
-
-#define SSMPR_SetError PR_SetError
-#define SSMPR_GetError PR_GetError
-#define SSMPORT_SetError PORT_SetError
-#define SSMPORT_GetError PORT_GetError
-
-/* 
-   Current version of PSM protocol. 
-   Increment this value when the protocol changes. 
-*/
-
-#define SSMSTRING_PADDED_LENGTH(x) ((((x)+3)/4)*4)
-#define SSMPORT_ZNEW(type) (type*)SSMPORT_ZAlloc(sizeof(type))
-#define SSMPORT_ZNewArray(type,size) (type*)SSMPORT_ZAlloc(sizeof(type)*(size))
-/* Various message structs */
-
-struct _SSMHelloRequest {
-  CMUint32          m_version; /* Protocol version supported by client */
-  struct _SSMString m_profileName; /* Name of user profile (where to find 
-				 certs etc) */
-};
-
-struct _SSMHelloReply {
-  CMInt32           m_result; /* Error, if any, which occurred 
-				 (0 == success) */
-  CMUint32          m_version; /* Protocol version supported by PSM */
-  struct _SSMString m_nonce; /* Session nonce -- must be written to data channels */
-};
-
-struct _SSMRequestSSLDataConnection
-{
-  CMUint32          m_flags; /* Flags to indicate to SSM what to do with
-				the connection */
-  CMUint32          m_port; /* Port number to connect to */
-  struct _SSMString m_hostIP; /* IP address of final target machine (not proxy) */
-  /* struct _SSMString m_hostName; Host name of target machine (for server auth) -- not accessed directly */
-};
-
-struct _SSMReplySSLDataConnection {
-  CMInt32 m_result; /* Error, if any, which occurred (0 == success) */
-  CMUint32 m_connectionID; /* Connection ID of newly opened channel */
-  CMUint32 m_port; /* Port number to which to connect on PSM */
-};
-
-
-struct _SSMRequestSecurityStatus {
-  CMUint32 m_connectionID; /* ID of connection of which to stat */
-};
-
-struct _SSMReplySecurityStatus {
-  CMInt32 m_result; /* Error, if any, which occurred (0 == success) */
-  CMUint32 m_keySize; /* Key size */
-  CMUint32 m_secretKeySize; /* Secret key size */
-  struct _SSMString m_cipherName; /* Name of cipher in use */
-  /* SSMString m_certificate; -- DER encoded cert
-     We do not access this as a field, we have to skip over m_cipherName */
-};
-
-/* 
-   Use this macro to jump over strings.
-   For example, if you wanted to access m_certificate above, 
-   use a line like the following:
-
-   char *ptr = &(reply->m_cipherName) + SSM_SIZEOF_STRING(reply->m_cipherName);
-*/
-#define SSM_SIZEOF_STRING(str) (SSMSTRING_PADDED_LENGTH(PR_ntohl((str).m_length)) + sizeof(CMUint32))
-
-
-typedef struct _SSMHelloRequest SSMHelloRequest;
-typedef struct _SSMHelloReply SSMHelloReply;
-typedef struct _SSMRequestSSLDataConnection SSMRequestSSLDataConnection;
-typedef struct _SSMReplySSLDataConnection SSMReplySSLDataConnection;
-typedef struct _SSMRequestSecurityStatus SSMRequestSecurityStatus;
-typedef struct _SSMReplySecurityStatus SSMReplySecurityStatus;
-
-/* 
-   Functions to convert between an SSMString and a C string.
-   Return values are allocated using PR_Malloc (which means that
-   SSMPR_Free must be used to free up the memory after use). 
-*/
-CMTStatus SSM_StringToSSMString(SSMString ** ssmString, int len, char * string);
-CMTStatus SSM_SSMStringToString(char ** string,int *len, SSMString * ssmString);
-
-
-#endif /* __PROTOCOL_H__ */

mozilla/security/psm/lib/protocol/protocolf.h

@@ -1,359 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-#ifndef __PROTOCOLF_H__
-#define __PROTOCOLF_H__
-/*************************************************************************
- * For each type of message, parse and pack function is provided. 
- *
- * Parse functions accept a ptr to the "blob" of data received from the 
- * network and fill in fields of the message, numbers in host-order, strings
- * as C-style NULL-terminated strings. Return SSMPRStatus. 
- *
- * Pack functions take all the info to construct a message and fill in a 
- * ptr to the "blob" of data to be sent. Return length of the data blob, or 
- * a zero in case of an error
- *
- * All functions set NSPR errors when necessary.
- ************************************************************************/
-#include "protocol.h"
-#include "cert.h"
-
-SSMPRStatus SSM_ParseHelloRequest(void * helloRequest, 
-				  SSMPRUint32 * version, 
-				  PRBool * doesUI,
-				  PRInt32 * policyType,
-				  SSMPRUint32 * profileLen,
-				  char ** profile);
-SSMPRInt32 SSM_PackHelloReply(void ** helloReply, SSMPRInt32 result, 
-			      SSMPRUint32 sessionID, SSMPRUint32 version, 
-			      SSMPRUint32 httpPort, SSMPRUint32 nonceLen, 
-			      char * nonce, SSMPolicyType policy);
-
-/* Parse data connections requests */
-SSMPRStatus SSM_ParseSSLDataConnectionRequest(void *sslRequest, 
-					      SSMPRUint32 * flags, 
-					      SSMPRUint32 * port,
-					      SSMPRUint32 * hostIPLen,
-					      char ** hostIP, 
-					      SSMPRUint32 * hostNameLen,
-					      char ** hostName);
-SSMPRStatus SSM_ParseHashStreamRequest(void * hashStreamRequest,
-                                       SSMPRUint32 * type);
-SSMPRStatus SSM_ParseP7EncodeConnectionRequest(void *request,
-					       SSMPRUint32 *ciRID);
-/* Messages to initiate PKCS7 data connection */
-/* PKCS7DecodeRequest message has no data */ 
-
-/* Single data connection reply */
-SSMPRInt32 SSM_PackDataConnectionReply(void ** sslReply, 
-				       SSMPRInt32 result, 
-				       SSMPRUint32 connID, 
-				       SSMPRUint32 port);
-
-SSMPRStatus SSM_ParseSSLSocketStatusRequest(void * statusRequest, 
-					    SSMPRUint32 * connID);
-SSMPRInt32 SSM_PackSSLSocketStatusReply(void ** statusReply, 
-					SSMPRInt32 result, 
-					SSMPRUint32 resourceID);
-
-/* 
- * UI event is an asynchroneous message sent from PSM server to the client
- * NOTE: (context) is the actual context pointer, it is NOT a ptr-to-ptr.
- * The value of (context) is copied into the packet.
- */
-SSMPRInt32 SSM_PackUIEvent(void ** eventRequest, SSMPRUint32 resourceID, 
-			   SSMPRUint32 width, SSMPRUint32 height,
-			   SSMPRUint32 urlLen, char * url);
-
-SSMPRInt32 SSM_PackTaskCompletedEvent(void **event, SSMPRUint32 resourceID,
-                                     SSMPRUint32 numTasks, SSMPRUint32 result);
-
-/* Verify raw signature */
-
-SSMPRStatus SSM_ParseVerifyRawSigRequest(void * verifyRawSigRequest, 
-					 SSMPRUint32 * algorithmID,
-					 SSMPRUint32 * paramsLen, 
-					 unsigned char ** params,
-					 SSMPRUint32 * pubKeyLen,
-					 unsigned char ** pubKey,
-					 SSMPRUint32 * hashLen,
-					 unsigned char ** hash,
-					 SSMPRUint32 * signatureLen,
-					 unsigned char ** signature);
-SSMPRInt32 SSM_PackVerifyRawSigReply(void ** verifyRawSigReply, 
-				     SSMPRInt32 result);
-
-/* Verify detached signature */
-SSMPRStatus SSM_ParseVerifyDetachedSigRequest(void * request, 
-											  SSMPRInt32 * pkcs7ContentID,
-											  SSMPRInt32 * certUsage,
-											  SSMPRInt32 * hashAlgID,
-											  SSMPRUint32 * keepCert,
-											  SSMPRUint32 * digestLen,
-											  unsigned char ** hash);
-
-SSMPRInt32 SSM_PackVerifyDetachedSigReply(void ** verifyDetachedSigReply, 
-										  SSMPRInt32 result);
-
-/* PKCS#7 functions */
-SSMPRStatus SSM_ParseCreateSignedRequest(void *request,
-                                         SSMPRInt32 *scertRID,
-                                         SSMPRInt32 *ecertRID,
-                                         SSMPRUint32 *dig_alg,
-                                         SECItem **digest);
-
-SSMPRInt32 SSM_PackCreateSignedReply(void **reply, SSMPRInt32 ciRID,
-                                     SSMPRUint32 result);
-
-SSMPRStatus SSM_ParseCreateEncryptedRequest(void *request,
-					    SSMPRInt32 *scertRID,
-                                            SSMPRInt32 *nrcerts,
-					    SSMPRInt32 **rcertRIDs);
-
-SSMPRInt32 SSM_PackCreateEncryptedReply(void **reply, SSMPRInt32 ciRID,
-					SSMPRUint32 result);
-
-/* Resource functions */
-SSMPRStatus SSM_ParseCreateResourceRequest(void *request,
-                                           SSMPRUint32 *type,
-                                           unsigned char **params,
-                                           SSMPRUint32 *paramLen);
-
-SSMPRStatus SSM_PackCreateResourceReply(void **reply, SSMPRStatus rv,
-                                        SSMPRUint32 resID);
-
-SSMPRStatus SSM_ParseGetAttribRequest(void * getAttribRequest, 
-				      SSMPRUint32 * resourceID, 
-				      SSMPRUint32 * fieldID);
-
-void SSM_DestroyAttrValue(SSMAttributeValue *value, PRBool freeit);
-
-SSMPRInt32 SSM_PackGetAttribReply(void **getAttribReply,
-				  SSMPRInt32 result,
-				  SSMAttributeValue *value);
-SSMPRStatus SSM_ParseSetAttribRequest(SECItem *msg,
-				      SSMPRInt32 *resourceID,
-				      SSMPRInt32 *fieldID,
-				      SSMAttributeValue *value);
-/* Currently, there is no need for a pack version.  There is nothing to send
- * back except for the notice that the operation was successful.
- */
-				  
-				       
-				       
-/* Pickle and unpickle resources. */
-SSMPRStatus SSM_ParsePickleResourceRequest(void * pickleResourceRequest, 
-					  SSMPRUint32 * resourceID);
-SSMPRInt32 SSM_PackPickleResourceReply(void ** pickleResourceReply, 
-				       SSMPRInt32 result,
-				       SSMPRUint32 resourceLen,
-				       void * resource);
-SSMPRStatus SSM_ParseUnpickleResourceRequest(void * unpickleResourceRequest,
-					     SSMPRUint32 blobSize,
-					     SSMPRUint32 * resourceType,
-					     SSMPRUint32 * resourceLen,
-					     void ** resource);
-SSMPRInt32 SSM_PackUnpickleResourceReply(void ** unpickleResourceReply, 
-					   SSMPRInt32 result, 
-					   SSMPRUint32 resourceID);
-
-/* Destroy resource */
-SSMPRStatus SSM_ParseDestroyResourceRequest(void * destroyResourceRequest, 
-					    SSMPRUint32 * resourceID, 
-					    SSMPRUint32 * resourceType);
-SSMPRInt32 SSM_PackDestroyResourceReply(void ** destroyResourceReply, 
-                                        SSMPRInt32 result);
-
-/* Duplicate resource */
-SSMPRStatus SSM_ParseDuplicateResourceRequest(void * request, 
-					      SSMPRUint32 * resourceID);
-SSMPRInt32 SSM_PackDuplicateResourceReply(void ** reply, SSMPRInt32 result,
-					  SSMPRUint32 resID);
-
-/* Cert actions */
-typedef struct MatchUserCertRequestData {
-    PRUint32 certType;
-    PRInt32 numCANames;
-    char ** caNames;
-} MatchUserCertRequestData;
-
-typedef struct SSMCertList {
-    PRCList certs;
-    PRInt32 count;
-} SSMCertList;
-
-typedef struct SSMCertListElement {
-    PRCList links;
-    PRUint32 certResID;
-} SSMCertListElement;
-
-#define SSM_CERT_LIST_ELEMENT_PTR(_q) (SSMCertListElement*)(_q);
-
-SSMPRStatus SSM_ParseVerifyCertRequest(void * verifyCertRequest, 
-				       SSMPRUint32 * resourceID, 
-				       SSMPRInt32 * certUsage);
-SSMPRInt32 SSM_PackVerifyCertReply(void ** verifyCertReply, 
-			           SSMPRInt32 result);
-
-SSMPRStatus SSM_ParseImportCertRequest(void * importCertRequest, 
-				       SSMPRUint32 * blobLen, 
-				       void ** certBlob);
-SSMPRInt32 SSM_PackImportCertReply(void ** importCertReply, SSMPRInt32 result, 
-				   SSMPRUint32 resourceID);
-PRStatus SSM_ParseFindCertByNicknameRequest(void *request, char ** nickname);
-PRInt32 SSM_PackFindCertByNicknameReply(void ** reply, PRUint32 resourceID);
-PRStatus SSM_ParseFindCertByKeyRequest(void *request, SECItem ** key);
-PRInt32 SSM_PackFindCertByKeyReply(void ** reply, PRUint32 resourceID);
-PRStatus SSM_ParseFindCertByEmailAddrRequest(void *request, char ** emailAddr);
-PRInt32 SSM_PackFindCertByEmailAddrReply(void ** reply, PRUint32 resourceID);
-PRStatus SSM_ParseAddTempCertToDBRequest(void *request, PRUint32 *resourceID, char ** nickname, PRInt32 *ssl, PRInt32 *email, PRInt32 *objectSigning);
-PRInt32 SSM_PackAddTempCertToDBReply(void ** reply);
-PRStatus SSM_ParseMatchUserCertRequest(void *request, MatchUserCertRequestData** data);
-PRInt32 SSM_PackMatchUserCertReply(void **reply, SSMCertList * certList);
-
-SSMPRInt32 SSM_PackErrorMessage(void ** errorReply, SSMPRInt32 result);
-
-
-/* PKCS11 actions */
-SSMPRStatus SSM_ParseKeyPairGenRequest(void *keyPairGenRequest, 
-				       SSMPRInt32 requestLen,
-				       SSMPRUint32 *keyPairCtxtID,
-				       SSMPRUint32 *genMechanism,
-				       SSMPRUint32 *keySize,
-				       unsigned char **params, 
-				       SSMPRUint32 *paramLen);
-
-SSMPRInt32 SSM_PackKeyPairGenResponse(void ** keyPairGenResponse, 
-				      SSMPRUint32 keyPairId);
-
-PRStatus
-SSM_ParseFinishKeyGenRequest(void    *finishKeyGenRequest,
-                             PRInt32  requestLen,
-                             PRInt32 *keyGenContext);
-
-/* CMMF/CRMF Actions */
-SSMPRStatus SSM_ParseCreateCRMFReqRequest(void        *crmfReqRequest,
-					  SSMPRInt32   requestLen,
-					  SSMPRUint32 *keyPairId);
-
-SSMPRInt32 SSM_PackCreateCRMFReqReply(void        **crmfReqReply,
-				      SSMPRUint32   crmfReqId);
-
-SSMPRStatus SSM_ParseEncodeCRMFReqRequest(void         *encodeReq,
-					  SSMPRInt32    requestLen,
-					  SSMPRUint32 **crmfReqId,
-					  SSMPRInt32   *numRequests);
-
-SSMPRInt32 SSM_PackEncodeCRMFReqReply(void        **encodeReply,
-				      char         *crmfDER,
-				      SSMPRUint32   derLen);
-
-SSMPRStatus SSM_ParseCMMFCertResponse(void        *encodedRes,
-				      SSMPRInt32   encodeLen,
-				      char       **nickname,
-				      char       **base64Der,
-				      PRBool      *doBackup);
-
-PRStatus SSM_ParsePOPChallengeRequest(void     *challenge,
-				      PRInt32   len,
-				      char    **responseString);
-PRInt32 SSM_PackPOPChallengeResponse(void   **response,
-				     char    *responseString,
-				     PRInt32  responseStringLen);
-
-PRInt32 SSM_PackPasswdRequest(void ** passwdRequest, PRInt32 tokenID,
-                              char * prompt, PRInt32 promptLen);
-PRStatus SSM_ParsePasswordReply(void * passwdReply, PRInt32 * result, 
-                                PRInt32 * tokenID,
-                                char ** passwd, PRInt32 * passwdLen);
-
-/* Sign Text Actions */
-typedef struct {
-    char *stringToSign;
-    char *hostName;
-    char *caOption;
-    PRInt32 numCAs;
-    char **caNames;
-} signTextRequestData;
-
-PRStatus SSM_ParseSignTextRequest(void* signTextRequest, PRInt32 len, PRUint32* resID, signTextRequestData ** data);
-
-PRStatus SSM_ParseGetLocalizedTextRequest(void               *data,
-                                          SSMLocalizedString *whichString);  
-
-PRInt32 SSM_PackGetLocalizedTextResponse(void               **data,
-					 SSMLocalizedString   whichString,
-					 char                *retString);
-
-PRStatus SSM_ParseAddNewSecurityModuleRequest(void          *data, 
-					      char         **moduleName,
-					      char         **libraryPath, 
-					      unsigned long *pubMechFlags,
-					      unsigned long *pubCipherFlags);
-
-PRInt32 SSM_PackAddNewModuleResponse(void **data, PRInt32 rv);
-
-PRStatus SSM_ParseDeleteSecurityModuleRequest(void *data, char **moduleName);
-
-PRInt32 SSM_PackDeleteModuleResponse(void **data, PRInt32 moduleType);
-
-PRInt32 SSM_PackFilePathRequest(void **data, PRInt32 resID, char *prompt,
-				PRBool shouldFileExist, char *fileSuffix);
-
-PRStatus SSM_ParseFilePathReply(void *message, char **filePath,
-				PRInt32 *rid);
-
-PRInt32 SSM_PackPromptRequestEvent(void **data, PRInt32 resID, char *prompt);
-PRStatus SSM_ParsePasswordPromptReply(void *data, PRInt32 *resID, 
-				      char **reply);
-
-/* messages for importing certs *the traditional way* */
-PRInt32 SSM_PackDecodeCertReply(void ** data, PRInt32 certID);
-PRStatus SSM_ParseDecodeCertRequest(void * data, PRInt32 * len, 
-					char ** buffer);
-PRStatus SSM_ParseGetKeyChoiceListRequest(void * data, PRUint32 dataLen, 
-					  char ** type, PRUint32 *typeLen, 
-					  char ** pqgString, PRUint32 *pqgLen);
-PRInt32 SSM_PackGetKeyChoiceListReply(void **data, char ** list);
-
-PRStatus SSM_ParseGenKeyOldStyleRequest(void * data, PRUint32 datalen, 
-					char ** choiceString, 
-					char ** challenge, 
-					char ** typeString, 
-					char ** pqgString);
-PRInt32 SSM_PackGenKeyOldStyleReply(void ** data, char * keydata);
-
-PRStatus SSM_ParseDecodeAndCreateTempCertRequest(void * data, 
-			char ** certbuf, PRUint32 * certlen, int * certClass);
-
-#endif /*PROTOCOLF_H_*/

mozilla/security/psm/lib/protocol/protocolnspr20.h

@@ -1,74 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*****************************************************************************
- *
- *
- *
- *****************************************************************************
- */
-
-#ifndef NULL
-#define NULL 0x00000000
-#endif
-
-#define SSMPR_BYTES_PER_INT  4
-#define SSMPR_BYTES_PER_LONG  4
-
-/******************************************************************
- *  No NSPR - define all the SSMPR values and functions here   
- ******************************************************************
- */
-
-#define SSMPRStatus PRStatus
-#define SSMPR_SUCCESS PR_SUCCESS
-#define SSMPR_FAILURE PR_FAILURE
-
-#define SSMPR_INVALID_ARGUMENT_ERROR PR_INVALID_ARGUMENT_ERROR
-#define SSMPR_OUT_OF_MEMORY_ERROR    PR_OUT_OF_MEMORY_ERROR
-
-#define SSMPRInt32 PRInt32
-#define SSMPRUint32 PRUint32
-
-#define SSMPR_ntohl  PR_ntohl
-#define SSMPR_htonl  PR_htonl
-#define SSMPORT_Free   PORT_Free
-#define SSMPORT_ZAlloc PORT_ZAlloc
-
-#define SSMPR_SetError PR_SetError
-#define SSMPR_GetError PR_GetError
-#define SSMPORT_SetError PORT_SetError
-#define SSMPORT_GetError PORT_GetError
-
-
-
-

mozilla/security/psm/lib/protocol/protocolport.c

@@ -1,49 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*************************************************************************
- *
- * PSM portable run-time. (Used when NSPR20 is not available.)
- *
- *************************************************************************
- */
-
-SSMPRInt32 ssmprErrno;
-
-void SSMPORT_SetError(SSMPRInt32 errorcode) 
-{ ssmprErrno = errorcode; }  
-
-
-SSMPRInt32 SSMPORT_GetError(void)
-{ return ssmprErrno; }
-
-

mozilla/security/psm/lib/protocol/protocolport.h

@@ -1,93 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is the Netscape security libraries.
- * 
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are 
- * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- * 
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU General Public License Version 2 or later (the
- * "GPL"), in which case the provisions of the GPL are applicable 
- * instead of those above.  If you wish to allow use of your 
- * version of this file only under the terms of the GPL and not to
- * allow others to use your version of this file under the MPL,
- * indicate your decision by deleting the provisions above and
- * replace them with the notice and other provisions required by
- * the GPL.  If you do not delete the provisions above, a recipient
- * may use your version of this file under either the MPL or the
- * GPL.
- */
-/*****************************************************************************
- *
- *
- *
- *****************************************************************************
- */
-
-#ifndef NULL
-#define NULL 0x00000000
-#endif
-
-#define SSMPR_BYTES_PER_INT  4
-#define SSMPR_BYTES_PER_LONG  4
-
-/******************************************************************
- *  No NSPR - define all the SSMPR values and functions here   
- ******************************************************************
- */
-
-typedef enum { SSMPR_SUCCESS = 0,  SSMPR_FAILURE = -1 } SSMPRStatus;
-enum { 
-  SSMPR_INVALID_ARGUMENT_ERROR = -6000,
-  SSMPR_OUT_OF_MEMORY_ERROR =  -5987
-};
-
-#if SSMPR_BYTES_PER_INT == 4
-typedef unsigned int SSMPRUint32;
-typedef int SSMPRInt32; 
-#elif SSMPR_BYTES_PER_LONG == 4
-typedef unsigned long SSMPRUint32;
-typedef long SSMPRInt32;
-#else
-#error No suitable type for SSMPRInt32/SSMPRUint32
-#endif
-
-/*******************************************************************
- * Use libc functions instead 
- *******************************************************************
- */
-#include <sys/types.h>
-#ifdef WIN32
-#include <winsock.h>
-#else
-#include <netinet/in.h>
-#endif
-#define SSMPR_ntohl  ntohl
-#define SSMPR_htonl  htonl
-
-#include <stdlib.h>
-#define SSMPORT_Free   free
-#define SSMPR_sprint   printf
-#define SSMPORT_ZAlloc malloc
-
-extern SSMPRInt32 ssmprErrno;
-#define SSMPR_SetError(x, y) SSMPORT_SetError(x)
-#define SSMPR_GetError SSMPORT_GetError
-void SSMPORT_SetError(SSMPRInt32 errorcode);
-
-
-
-