~ubuntu-branches/ubuntu/raring/libjboss-remoting-java/raring

throw new IOException("Can not send response due to version (" + version + ") not being supported. Supported versions: " + Version.VERSION_1 + ", " + Version.VERSION_2 + ", " + Version.VERSION_2_2);

569

}

570

}

571

}

572

573

private InvocationRequest versionedRead(Request req, RequestMap request, ResponseMap response, int version)

574

throws IOException, ClassNotFoundException

575

{

576

switch (version)

577

{

578

case Version.VERSION_1:

579

case Version.VERSION_2:

580

case Version.VERSION_2_2:

581

{

582

// UnMarshaller may not be an HTTPUnMarshaller, in which case it

583

// can ignore this parameter.

584

Object o = configuration.get(HTTPUnMarshaller.PRESERVE_LINES);

585

if (o != null)

586

{

587

request.put(HTTPUnMarshaller.PRESERVE_LINES, o);

588

}

589

590

receivedInvocationRequest.set(FALSE);

591

InvocationRequest invocationRequest = null;

592

MessageBytes method = req.method();

593

if (method.equals("GET") || method.equals("HEAD")

594

|| (method.equals("OPTIONS") && req.getContentLength() <= 0))

595

{

596

invocationRequest = createNewInvocationRequest(request, response, null);

597

} else

598

{

599

// must be POST or PUT

600

UnMarshaller unmarshaller = getUnMarshaller();

601

request.put(HTTPMetadataConstants.USE_REMOTING_CONTENT_TYPE, useRemotingContentType);

602

Object obj = null;

603

if (unmarshaller instanceof VersionedUnMarshaller)

604

obj = ((VersionedUnMarshaller)unmarshaller).read(request.getInputStream(), request, version);

605

else

606

obj = unmarshaller.read(request.getInputStream(), request);

607

if (obj instanceof InvocationRequest)

608

{

609

receivedInvocationRequest.set(TRUE);

610

invocationRequest = (InvocationRequest) obj;

611

if (invocationRequest.getReturnPayload() == null)

612

{

613

// need to create a return payload map, so can be populated with metadata

614

invocationRequest.setReturnPayload(response);

615

}

616

Map requestPayloadMap = invocationRequest.getRequestPayload();

617

if (requestPayloadMap != null)

618

{

619

request.putAll(requestPayloadMap);

620

}

621

invocationRequest.setRequestPayload(request);

622

} else

623

{

624

invocationRequest = createNewInvocationRequest(request, response, obj);

625

}

626

}

627

628

return invocationRequest;

629

}

630

631

default:

632

{

633

throw new IOException("Can not processes request due to incorrect version (" + version + "). Can only process versions: " + Version.VERSION_1 + ", " + Version.VERSION_2 + ", " + Version.VERSION_2_2);

634

}

635

}

636

}

637

638

private int getVersion(RequestMap request)

639

{

640

int version = Version.VERSION_1; // going to default to old version

641

Object versionObj = request.get(HTTPMetadataConstants.REMOTING_VERSION_HEADER);

642

if (versionObj != null)

643

{

644

String versionString = (String) versionObj;

645

try

646

{

647

version = Integer.parseInt(versionString);

648

} catch (NumberFormatException e)

649

{

650

log.error("Can not processes remoting version of " + versionString + " as is not a number.");

651

}

652

}

653

return version;

654

}

655

656

private void populateRequestMetadata(RequestMap metadata, Request req)

657

{

658

final MimeHeaders headers = req.getMimeHeaders();

659

Enumeration nameEnum = null;

660

661

if (SecurityUtility.skipAccessControl())

662

{

663

nameEnum = headers.names();

664

}

665

else

666

{

667

nameEnum = (Enumeration)AccessController.doPrivileged( new PrivilegedAction()

668

{

669

public Object run()

670

{

671

return headers.names();

672

}}

673

);

674

}

675

676

while (nameEnum.hasMoreElements())

677

{

678

Object nameObj = nameEnum.nextElement();

679

if (nameObj instanceof String)

680

{

681

Object valueObj = headers.getHeader((String) nameObj);

682

metadata.put(nameObj, valueObj);

683

}

684

}

685

686

metadata.put(HTTPMetadataConstants.METHODTYPE, req.method().getString());

687

metadata.put(HTTPMetadataConstants.PATH, req.requestURI().getString());

688

metadata.put(HTTPMetadataConstants.QUERY, req.query().toString());

689

metadata.put(HTTPMetadataConstants.HTTPVERSION, req.protocol().getString());

690

691

}

692

693

694

protected InvocationRequest createNewInvocationRequest(RequestMap requestMap, ResponseMap responseMap,

695

Object payload)

696

{

697

// will try to use the same session id if possible to track

698

String sessionId = getSessionId(requestMap);

699

String subSystem = (String) requestMap.get(HEADER_SUBSYSTEM);

700

701

InvocationRequest request = null;

702

703

boolean isLeaseQueury = checkForLeaseQuery(requestMap);

704

if(isLeaseQueury)

705

{

706

addLeaseInfo(responseMap);

707

request = new InvocationRequest(sessionId, subSystem, "$PING$", null, responseMap, null);

708

}

709

else

710

{

711

request = new InvocationRequest(sessionId, subSystem, payload,

712

requestMap, responseMap, null);

713

}

714

return request;

715

}

716

717

private boolean checkForLeaseQuery(RequestMap headers)

718

{

719

boolean isLeaseQuery = false;

720

721

if(headers != null)

722

{

723

Object val = headers.get(HTTPMetadataConstants.REMOTING_LEASE_QUERY);

724

if(val != null && val instanceof String)

725

{

726

isLeaseQuery = Boolean.valueOf((String)val).booleanValue();

727

}

728

}

729

return isLeaseQuery;

730

}

731

732

/**

733

* Parse additional request parameters.

734

735

protected boolean postParseRequest(org.apache.coyote.Request req,

736

RequestMap request,

737

org.apache.coyote.Response res,

738

ResponseMap response)

739

throws Exception

740

{

741

742

// URI decoding

743

MessageBytes decodedURI = req.decodedURI();

744

decodedURI.duplicate(req.requestURI());

745

746

if(decodedURI.getType() == MessageBytes.T_BYTES)

747

{

748

// %xx decoding of the URL

749

try

750

{

751

req.getURLDecoder().convert(decodedURI, false);

752

}

753

catch(IOException ioe)

754

{

755

res.setStatus(400);

756

res.setMessage("Invalid URI");

757

throw ioe;

758

}

759

// Normalization

760

if(!normalize(req.decodedURI()))

761

{

762

res.setStatus(400);

763

res.setMessage("Invalid URI");

764

return false;

765

}

766

// Character decoding

767

convertURI(decodedURI, request);

768

}

769

else

770

{

771

// The URL is chars or String, and has been sent using an in-memory

772

// protocol handler, we have to assume the URL has been properly

773

// decoded already

774

decodedURI.toChars();

775

}

776

777

return true;

778

779

}

780

781

782

/**

783

* Character conversion of the URI.

784

785

protected void convertURI(MessageBytes uri, RequestMap request)

786

throws Exception

787

{

788

789

ByteChunk bc = uri.getByteChunk();

790

CharChunk cc = uri.getCharChunk();

791

cc.allocate(bc.getLength(), -1);

792

793

String enc = URIEncoding;

794

if(enc != null)

795

{

796

B2CConverter conv = request.getURIConverter();

797

try

798

{

799

if(conv == null)

800

{

801

conv = new B2CConverter(enc);

802

request.setURIConverter(conv);

803

}

804

else

805

{

806

conv.recycle();

807

}

808

}

809

catch(IOException e)

810

{

811

// Ignore

812

log.error("Invalid URI encoding; using HTTP default");

813

URIEncoding = null;

814

}

815

if(conv != null)

816

{

817

try

818

{

819

conv.convert(bc, cc);

820

uri.setChars(cc.getBuffer(), cc.getStart(),

821

cc.getLength());

822

return;

823

}

824

catch(IOException e)

825

{

826

log.error("Invalid URI character encoding; trying ascii");

827

cc.recycle();

828

}

829

}

830

}

831

832

// Default encoding: fast conversion

833

byte[] bbuf = bc.getBuffer();

834

char[] cbuf = cc.getBuffer();

835

int start = bc.getStart();

836

for(int i = 0; i < bc.getLength(); i++)

837

{

838

cbuf[i] = (char) (bbuf[i + start] & 0xff);

839

}

840

uri.setChars(cbuf, 0, bc.getLength());

841

842

}

843

844

845

/**

846

* Character conversion of the a US-ASCII MessageBytes.

847

848

protected void convertMB(MessageBytes mb)

849

{

850

851

// This is of course only meaningful for bytes

852

if(mb.getType() != MessageBytes.T_BYTES)

853

{

854

return;

855

}

856

857

ByteChunk bc = mb.getByteChunk();

858

CharChunk cc = mb.getCharChunk();

859

cc.allocate(bc.getLength(), -1);

860

861

// Default encoding: fast conversion

862

byte[] bbuf = bc.getBuffer();

863

char[] cbuf = cc.getBuffer();

864

int start = bc.getStart();

865

for(int i = 0; i < bc.getLength(); i++)

866

{

867

cbuf[i] = (char) (bbuf[i + start] & 0xff);

868

}

869

mb.setChars(cbuf, 0, bc.getLength());

870

871

}

872

873

874

/**

875

* Normalize URI.

876

* <p/>

877

* This method normalizes "\", "//", "/./" and "/../". This method will

878

* return false when trying to go above the root, or if the URI contains

879

* a null byte.

880

881

* @param uriMB URI to be normalized

882

883

public static boolean normalize(MessageBytes uriMB)

884

{

885

886

ByteChunk uriBC = uriMB.getByteChunk();

887

byte[] b = uriBC.getBytes();

888

int start = uriBC.getStart();

889

int end = uriBC.getEnd();

890

891

// Expect request URI to be at least one character.

892

if (start - end == 0)

893

{

894

return false;

895

}

896

897

// URL * is acceptable

898

if((end - start == 1) && b[start] == (byte) '*')

899

{

900

return true;

901

}

902

903

int pos = 0;

904

int index = 0;

905

906

// Replace '\' with '/'

907

// Check for null byte

908

for(pos = start; pos < end; pos++)

909

{

910

if(b[pos] == (byte) '\\')

911

{

912

b[pos] = (byte) '/';

913

}

914

if(b[pos] == (byte) 0)

915

{

916

return false;

917

}

918

}

919

920

// The URL must start with '/'

921

if(b[start] != (byte) '/')

922

{

923

return false;

924

}

925

926

// Replace "//" with "/"

927

for(pos = start; pos < (end - 1); pos++)

928

{

929

if(b[pos] == (byte) '/')

930

{

931

while((pos + 1 < end) && (b[pos + 1] == (byte) '/'))

932

{

933

copyBytes(b, pos, pos + 1, end - pos - 1);

934

end--;

935

}

936

}

937

}

938

939

// If the URI ends with "/." or "/..", then we append an extra "/"

940

// Note: It is possible to extend the URI by 1 without any side effect

941

// as the next character is a non-significant WS.

942

if(((end - start) >= 2) && (b[end - 1] == (byte) '.'))

943

{

944

if((b[end - 2] == (byte) '/')

945

|| ((b[end - 2] == (byte) '.')

946

&& (b[end - 3] == (byte) '/')))

947

{

948

b[end] = (byte) '/';

949

end++;

950

}

951

}

952

953

uriBC.setEnd(end);

954

955

index = 0;

956

957

// Resolve occurrences of "/./" in the normalized path

958

while(true)

959

{

960

index = uriBC.indexOf("/./", 0, 3, index);

961

if(index < 0)

962

{

963

break;

964

}

965

copyBytes(b, start + index, start + index + 2,

966

end - start - index - 2);

967

end = end - 2;

968

uriBC.setEnd(end);

969

}

970

971

index = 0;

972

973

// Resolve occurrences of "/../" in the normalized path

974

while(true)

975

{

976

index = uriBC.indexOf("/../", 0, 4, index);

977

if(index < 0)

978

{

979

break;

980

}

981

// Prevent from going outside our context

982

if(index == 0)

983

{

984

return false;

985

}

986

int index2 = -1;

987

for(pos = start + index - 1; (pos >= 0) && (index2 < 0); pos --)

988

{

989

if(b[pos] == (byte) '/')

990

{

991

index2 = pos;

992

}

993

}

994

copyBytes(b, start + index2, start + index + 3,

995

end - start - index - 3);

996

end = end + index2 - index - 3;

997

uriBC.setEnd(end);

998

index = index2;

999

}

1000

1001

uriBC.setBytes(b, start, end);

1002

1003

return true;

1004

1005

}

1006

1007

1008

/**

1009

* Copy an array of bytes to a different position. Used during

1010

* normalization.

1011

1012

protected static void copyBytes(byte[] b, int dest, int src, int len)

1013

{

1014

for(int pos = 0; pos < len; pos++)

1015

{

1016

b[pos + dest] = b[pos + src];

1017

}

1018

}

1019

1020

1021

public void stop()

1022

{

1023

if(running)

1024

{

1025

running = false;

1026

1027

if (protocolHandlers != null)

1028

{

1029

Iterator it = protocolHandlers.iterator();

1030

while (it.hasNext())

1031

{

1032

try

1033

{

1034

ProtocolHandler protocolHandler = (ProtocolHandler) it.next();

1035

protocolHandler.destroy();

1036

}

1037

catch(Exception e)

1038

{

1039

log.error("Stop error", e);

1040

}

1041

}

1042

}

1043

}

1044

super.stop();

1045

1046

log.debug("CoyoteInvoker stopped.");

1047

}

1048

1049

/**

1050

* Find a method with the right name If found, call the method ( if param is

1051

* int or boolean we'll convert value to the right type before) - that means

1052

* you can have setDebug(1).

1053

1054

public static boolean setProperty(final Object o, String name, final String value)

1055

{

1056

String setter = "set" + capitalize(name);

1057

1058

try

1059

{

1060

Method[] methods = null;

1061

1062

if (SecurityUtility.skipAccessControl())

1063

{

1064

methods = o.getClass().getMethods();

1065

}

1066

else

1067

{

1068

methods = (Method[]) AccessController.doPrivileged( new PrivilegedAction()

1069

{

1070

public Object run()

1071

{

1072

return o.getClass().getMethods();

1073

}

1074

});

1075

}

1076

1077

Method setPropertyMethod = null;

1078

1079

// First, the ideal case - a setFoo( String ) method

1080

for(int i = 0; i < methods.length; i++)

1081

{

1082

Class paramT[] = methods[i].getParameterTypes();

1083

if(setter.equals(methods[i].getName()) && paramT.length == 1

1084

&& "java.lang.String".equals(paramT[0].getName()))

1085

{

1086

1087

methods[i].invoke(o, new Object[]{value});

1088

return true;

1089

}

1090

}

1091

1092

// Try a setFoo ( int ) or ( boolean )

1093

for(int i = 0; i < methods.length; i++)

1094

{

1095

boolean ok = true;

1096

if(setter.equals(methods[i].getName())

1097

&& methods[i].getParameterTypes().length == 1)

1098

{

1099

1100

// match - find the type and invoke it

1101

Class paramType = methods[i].getParameterTypes()[0];

1102

Object params[] = new Object[1];

1103

1104

// Try a setFoo ( int )

1105

if("java.lang.Integer".equals(paramType.getName())

1106

|| "int".equals(paramType.getName()))

1107

{

1108

try

1109

{

1110

params[0] = new Integer(value);

1111

}

1112

catch(NumberFormatException ex)

1113

{

1114

ok = false;

1115

}

1116

// Try a setFoo ( long )

1117

}

1118

else if("java.lang.Long".equals(paramType.getName())

1119

|| "long".equals(paramType.getName()))

1120

{

1121

try

1122

{

1123

params[0] = new Long(value);

1124

}

1125

catch(NumberFormatException ex)

1126

{

1127

ok = false;

1128

}

1129

1130

// Try a setFoo ( boolean )

1131

}

1132

else if("java.lang.Boolean".equals(paramType.getName())

1133

|| "boolean".equals(paramType.getName()))

1134

{

1135

params[0] = new Boolean(value);

1136

1137

// Try a setFoo ( InetAddress )

1138

}

1139

else if("java.net.InetAddress".equals(paramType.getName()))

1140

{

1141

try

1142

{

1143

params[0] = getAddressByName(value);

1144

}

1145

catch(UnknownHostException exc)

1146

{

1147

ok = false;

1148

}

1149

1150

// Unknown type

1151

}

1152

1153

if(ok)

1154

{

1155

methods[i].invoke(o, params);

1156

return true;

1157

}

1158

}

1159

1160

// save "setProperty" for later

1161

if("setProperty".equals(methods[i].getName()))

1162

{

1163

setPropertyMethod = methods[i];

1164

}

1165

}

1166

1167

// Ok, no setXXX found, try a setProperty("name", "value")

1168

if(setPropertyMethod != null)

1169

{

1170

Object params[] = new Object[2];

1171

params[0] = name;

1172

params[1] = value;

1173

setPropertyMethod.invoke(o, params);

1174

return true;

1175

}

1176

1177

}

1178

catch(Exception e)

1179

{

1180

return false;

1181

}

1182

return false;

1183

}

1184

1185

/**

1186

* Reverse of Introspector.decapitalize

1187

1188

public static String capitalize(String name)

1189

{

1190

if(name == null || name.length() == 0)

1191

{

1192

return name;

1193

}

1194

char chars[] = name.toCharArray();

1195

chars[0] = Character.toUpperCase(chars[0]);

1196

return new String(chars);

1197

}

1198

1199

1200

/**

1201

* Necessary for implementation of org.apache.coyote.Adapter interface.

1202

* Body is vacuous because event() is only used in comet mode.

1203

1204

public boolean event(Request arg0, Response arg1, SocketStatus arg2) throws Exception

1205

{

1206

return true;

1207

}

1208

1209

static private boolean isInvalidContentType(String contentType)

1210

{

1211

return contentType.indexOf('\n') + contentType.indexOf('\r') > -2;

1212

}

1213

1214

static private Object forName(final String className) throws ClassNotFoundException

1215

{

1216

if (SecurityUtility.skipAccessControl())

1217

{

1218

return Class.forName(className);

1219

}

1220

1221

try

1222

{

1223

return AccessController.doPrivileged( new PrivilegedExceptionAction()

1224

{

1225

public Object run() throws Exception

1226

{

1227

return Class.forName(className);

1228

}

1229

});

1230

}

1231

catch (PrivilegedActionException e)

1232

{

1233

throw (ClassNotFoundException) e.getCause();

1234

}

1235

}

1236

1237

static private InetAddress getAddressByName(final String host) throws UnknownHostException

1238

{

1239

if (SecurityUtility.skipAccessControl())

1240

{

1241

return InetAddress.getByName(host);

1242

}

1243

1244

try

1245

{

1246

return (InetAddress)AccessController.doPrivileged( new PrivilegedExceptionAction()

1247

{

1248

public Object run() throws IOException

1249

{

1250

return InetAddress.getByName(host);

1251

}

1252

});

1253

}

1254

catch (PrivilegedActionException e)

1255

{

1256

throw (UnknownHostException) e.getCause();

1257

}

1258

}

1259

}

Older »