001: /*
002: * JOnAS: Java(TM) Open Application Server
003: * Copyright (C) 1999 Bull S.A.
004: * Contact: jonas-team@objectweb.org
005: *
006: * This library is free software; you can redistribute it and/or
007: * modify it under the terms of the GNU Lesser General Public
008: * License as published by the Free Software Foundation; either
009: * version 2.1 of the License, or any later version.
010: *
011: * This library is distributed in the hope that it will be useful,
012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * Lesser General Public License for more details.
015: *
016: * You should have received a copy of the GNU Lesser General Public
017: * License along with this library; if not, write to the Free Software
018: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
019: * USA
020: *
021: * Initial developer(s): ____________________________________.
022: * Contributor(s): ______________________________________.
023: *
024: * --------------------------------------------------------------------------
025: * $Id: SSHandler.java 4759 2004-05-17 07:22:36Z durieuxp $
026: * --------------------------------------------------------------------------
027: */
028:
029: package org.objectweb.security.propagation;
030:
031: import org.objectweb.jeremie.services.handler.api.Service;
032: import org.objectweb.jonathan.apis.kernel.Context;
033: import org.objectweb.jonathan.apis.kernel.JonathanException;
034: import org.objectweb.jonathan.presentation.api.Marshaller;
035: import org.objectweb.jonathan.presentation.api.MarshallerFactory;
036: import org.objectweb.jonathan.presentation.api.UnMarshaller;
037: import org.objectweb.jonathan.resources.api.Chunk;
038: import org.objectweb.jonathan.helpers.MessageHelpers;
039: import org.objectweb.security.context.SecurityContext;
040: import org.omg.IOP.ServiceContext;
041:
042: public class SSHandler implements Service {
043:
044: private SecuritySender sender = null;
045: private SecurityReceiver receiver = null;
046: private MarshallerFactory mf;
047: private int service_id = 200; // default value
048:
049: /**
050: * Creates a new SSHandler instance.
051: */
052: public SSHandler(Context c, Object[] used_components)
053: throws JonathanException {
054: int sid = ((Integer) used_components[0]).intValue();
055: if (sid != Integer.MAX_VALUE) {
056: service_id = sid;
057: }
058:
059: try {
060: sender = (SecuritySender) used_components[1];
061: receiver = (SecurityReceiver) used_components[2];
062: mf = (MarshallerFactory) used_components[3];
063: } catch (Exception e) {
064: throw new JonathanException(e);
065: }
066: }
067:
068: /**
069: * Returns a request context.
070: * <p>
071: * If sender is not null, this method encodes the security context
072: * returned by the sending_request method of the sender, else it returns null.
073: *
074: * @param request_id the request identifier;
075: * @param response_expected unused;
076: * @param object_key unused.
077: * @return a service context.
078: */
079: public ServiceContext getRequestContext(int request_id,
080: boolean response_expected, byte[] object_key,
081: Context kContext) {
082: if (sender == null) {
083: return null;
084: }
085: SecurityContext ctx = sender.sending_request(request_id);
086: return encodeContext(ctx);
087: }
088:
089: /**
090: * Returns a reply context.
091: * <p>
092: * this method encodes the security context
093: * returned by its <code>sending_reply</code> method, else it returns null.
094: *
095: * @param request_id the corresponding request id.
096: * @return a service context.
097: */
098: public ServiceContext getReplyContext(int request_id,
099: Context kContext) {
100: if (receiver == null) {
101: return null;
102: }
103: SecurityContext ctx = receiver.sending_reply(request_id);
104: return encodeContext(ctx);
105: }
106:
107: /**
108: * This method is called by the services handler to let the operations
109: * related to the target service be performed on request arrival.
110: *
111: * @param context the service context of the request;
112: * @param request_id the request identifier;
113: * @param response_expected unused;
114: * @param object_key unused.
115: */
116: public void handleRequestContext(ServiceContext context,
117: int request_id, boolean response_expected,
118: byte[] object_key, Context kContext) {
119: if ((receiver == null) || (context == null)
120: || (context.context_data == null)
121: || (context.context_data.length == 0)) {
122: return;
123: }
124: SecurityContext ctx = decodeContext(context);
125: if (ctx != null) {
126: receiver.received_request(request_id, ctx);
127: }
128: }
129:
130: /**
131: * This method is called by the services handler to let the operations
132: * related to the target service be performed on reply arrival.
133: *
134: * @param context the service context of the reply;
135: * @param request_id the corresponding request identifier.
136: */
137: public void handleReplyContext(ServiceContext context,
138: int request_id, Context kContext) {
139: if ((receiver == null) || (context == null)
140: || (context.context_data == null)
141: || (context.context_data.length == 0)) {
142: return;
143: }
144: SecurityContext ctx = decodeContext(context);
145: if (ctx != null) {
146: sender.received_reply(request_id, ctx);
147: }
148: }
149:
150: /**
151: * Encodes a Security context into an IOP service context.
152: *
153: * @param ctx the propagation context to be encoded.
154: * @return the resulting IOP service context.
155: */
156: private ServiceContext encodeContext(SecurityContext ctx) {
157: if (ctx == null) {
158: return null;
159: }
160: Marshaller marshaller = mf.newMarshaller();
161: byte[] byteArray = null;
162: try {
163: marshaller.writeReference(ctx);
164: byteArray = MessageHelpers.copy(marshaller);
165: marshaller.close();
166: } catch (Exception e) {
167: System.err.println("SSHandler.encodeContext: exception");
168: e.printStackTrace();
169: }
170: return new ServiceContext(service_id, byteArray);
171: }
172:
173: /**
174: * Decodes a Security context from an IOP service context.
175: *
176: * @param ctx the IOP service context containing the encoded security context.
177: * @return the decoded security context.
178: */
179: private SecurityContext decodeContext(ServiceContext sc) {
180: if ((sc == null) || (sc.context_data == null)
181: || (sc.context_data.length == 0)) {
182: return null;
183: }
184: SecurityContext ctx = null;
185: byte[] byteArray = sc.context_data;
186: UnMarshaller unmarshaller = mf.newUnMarshaller(new Chunk(
187: byteArray, 0, byteArray.length), 0);
188: try {
189: ctx = (SecurityContext) unmarshaller.readReference();
190: unmarshaller.close();
191: } catch (Exception e) {
192: System.err.println("SSHandler.decodeContext: exception");
193: System.err.println(e.toString() + "\n");
194: }
195: return ctx;
196: }
197:
198: }
|