/**
* Creates an invite request using the Tested Implementation and then tests creating a cancel for
* the same invite request.
*/
public void testCreateCancel() {
try {
Request invite = createTiInviteRequest(null, null, null);
ClientTransaction tran = null;
try {
tran = tiSipProvider.getNewClientTransaction(invite);
} catch (TransactionUnavailableException exc) {
throw new TiUnexpectedError(
"A TransactionUnavailableException was thrown while trying to "
+ "create a new client transaction",
exc);
}
Request cancel = null;
try {
cancel = tran.createCancel();
} catch (SipException ex) {
ex.printStackTrace();
fail("Failed to create cancel request!");
}
assertEquals(
"The created request did not have a CANCEL method.", cancel.getMethod(), Request.CANCEL);
assertEquals(
"Request-URIs of the original and the cancel request do not match",
cancel.getRequestURI(),
invite.getRequestURI());
assertEquals(
"Call-IDs of the original and the cancel request do not match",
cancel.getHeader(CallIdHeader.NAME),
invite.getHeader(CallIdHeader.NAME));
assertEquals(
"ToHeaders of the original and the cancel request do not match",
cancel.getHeader(ToHeader.NAME),
invite.getHeader(ToHeader.NAME));
assertTrue(
"The CSeqHeader's sequence number of the original and "
+ "the cancel request do not match",
((CSeqHeader) cancel.getHeader(CSeqHeader.NAME)).getSequenceNumber()
== ((CSeqHeader) invite.getHeader(CSeqHeader.NAME)).getSequenceNumber());
assertEquals(
"The CSeqHeader's method of the cancel request was not CANCEL",
((CSeqHeader) cancel.getHeader(CSeqHeader.NAME)).getMethod(),
Request.CANCEL);
assertTrue(
"There was no ViaHeader in the cancel request",
cancel.getHeaders(ViaHeader.NAME).hasNext());
Iterator cancelVias = cancel.getHeaders(ViaHeader.NAME);
ViaHeader cancelVia = ((ViaHeader) cancelVias.next());
ViaHeader inviteVia = ((ViaHeader) invite.getHeaders(ViaHeader.NAME).next());
assertEquals(
"ViaHeaders of the original and the cancel request do not match!", cancelVia, inviteVia);
assertFalse("Cancel request had more than one ViaHeader.", cancelVias.hasNext());
} catch (Throwable exc) {
exc.printStackTrace();
fail(exc.getClass().getName() + ": " + exc.getMessage());
}
assertTrue(new Exception().getStackTrace()[0].toString(), true);
}
/* Handle a request from a connection.
* Called to handle a request on the connection when either the header has been received,
* or after the entire request has been received (for short requests of known length), or
* on the dispatch of an async request.
*/
public void handleAsync(AbstractHttpConnection connection) throws IOException, ServletException {
final AsyncContinuation async = connection.getRequest().getAsyncContinuation();
final AsyncContinuation.AsyncEventState state = async.getAsyncEventState();
final Request baseRequest = connection.getRequest();
final String path = state.getPath();
if (path != null) {
// this is a dispatch with a path
final String contextPath = state.getServletContext().getContextPath();
HttpURI uri = new HttpURI(URIUtil.addPaths(contextPath, path));
baseRequest.setUri(uri);
baseRequest.setRequestURI(null);
baseRequest.setPathInfo(baseRequest.getRequestURI());
if (uri.getQuery() != null) baseRequest.mergeQueryString(uri.getQuery());
}
final String target = baseRequest.getPathInfo();
final HttpServletRequest request = (HttpServletRequest) async.getRequest();
final HttpServletResponse response = (HttpServletResponse) async.getResponse();
if (LOG.isDebugEnabled()) {
LOG.debug("REQUEST " + target + " on " + connection);
handle(target, baseRequest, request, response);
LOG.debug("RESPONSE " + target + " " + connection.getResponse().getStatus());
} else handle(target, baseRequest, request, response);
}
public JSRequest(Request request, Context cx, Scriptable scope) {
this();
ESXX esxx = ESXX.getInstance();
this.request = request;
requestURI = (JSURI) cx.newObject(scope, "URI", new Object[] {request.getRequestURI()});
scriptURI = (JSURI) cx.newObject(scope, "URI", new Object[] {request.getScriptURI()});
env = cx.newObject(scope);
headers = cx.newObject(scope);
cookies = cx.newObject(scope);
accept = cx.newObject(scope);
query = cx.newObject(scope);
args = null;
params = cx.newObject(scope);
acceptValueOf = new FunctionObject("valueOf", acceptValueOfMethod, accept);
for (String name : request.getProperties().stringPropertyNames()) {
String value = request.getProperties().getProperty(name).trim();
// Add environtment variable to esxx.env
ScriptableObject.putProperty(env, name, value);
// If this is an HTTP header, get the original name back
String hdr = esxx.cgiToHTTP(name);
if (hdr != null) {
// Add real HTTP header to this.headers
addHeader(hdr, value);
// Decode cookies
handleCookieHeader(hdr, value);
// Decode Accept* HTTP headers
handleAcceptHeader(hdr, value, cx, accept);
// Decode Content-* HTTP headers
handleContentHeader(hdr, value);
// Handle SOAPAction
if (hdr.equals("SOAPAction")) {
soapAction = value;
}
}
if (name.equals("QUERY_STRING")) {
try {
StringUtil.decodeFormVariables(value, query);
} catch (UnsupportedEncodingException ex) {
throw new ESXXException("Unable to parse request entity: " + ex.getMessage(), ex);
}
}
}
logger = JSESXX.newObject(cx, scope, "Logger", new Object[] {request, request.getScriptName()});
}
@Override
public String toString() {
return String.format(
"%s@%x{r=%s,a=%s,uri=%s}",
getClass().getSimpleName(),
hashCode(),
_requests,
_state.getState(),
_state.getState() == HttpChannelState.State.IDLE ? "-" : _request.getRequestURI());
}
public void processResponse(ResponseEvent responseReceivedEvent) {
System.out.println("Got a response");
Response response = (Response) responseReceivedEvent.getResponse();
Transaction tid = responseReceivedEvent.getClientTransaction();
System.out.println(
"Response received with client transaction id " + tid + ":\n" + response.getStatusCode());
if (tid == null) {
System.out.println("Stray response -- dropping ");
return;
}
System.out.println("transaction state is " + tid.getState());
System.out.println("Dialog = " + tid.getDialog());
System.out.println("Dialog State is " + tid.getDialog().getState());
try {
if (response.getStatusCode() == Response.OK
&& ((CSeqHeader) response.getHeader(CSeqHeader.NAME))
.getMethod()
.equals(Request.INVITE)) {
// Request cancel = inviteTid.createCancel();
// ClientTransaction ct =
// sipProvider.getNewClientTransaction(cancel);
// ct.sendRequest();
Dialog dialog = tid.getDialog();
CSeqHeader cseq = (CSeqHeader) response.getHeader(CSeqHeader.NAME);
Request ackRequest = dialog.createAck(cseq.getSeqNumber());
System.out.println("Sending ACK");
dialog.sendAck(ackRequest);
// Send a Re INVITE but this time force it
// to use UDP as the transport. Else, it will
// Use whatever transport was used to create
// the dialog.
if (reInviteCount == 0) {
Request inviteRequest = dialog.createRequest(Request.INVITE);
((SipURI) inviteRequest.getRequestURI()).removeParameter("transport");
((ViaHeader) inviteRequest.getHeader(ViaHeader.NAME)).setTransport("udp");
inviteRequest.addHeader(contactHeader);
try {
Thread.sleep(100);
} catch (Exception ex) {
}
ClientTransaction ct = udpProvider.getNewClientTransaction(inviteRequest);
dialog.sendRequest(ct);
reInviteCount++;
}
}
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
public PushBuilderImpl(
Request request,
HttpFields fields,
String method,
String queryString,
String sessionId,
boolean conditional) {
super();
_request = request;
_fields = fields;
_method = method;
_queryString = queryString;
_sessionId = sessionId;
_conditional = conditional;
_fields.add(JettyPush);
if (LOG.isDebugEnabled())
LOG.debug(
"PushBuilder({} {}?{} s={} c={})",
_method,
_request.getRequestURI(),
_queryString,
_sessionId,
_conditional);
}
/** Invoked by the HTTPClient. */
public int requestHandler(Request req, Response[] resp) {
HTTPConnection con = req.getConnection();
URI new_loc, cur_loc;
// check for retries
HttpOutputStream out = req.getStream();
if (out != null && deferred_redir_list.get(out) != null) {
copyFrom((RedirectionModule) deferred_redir_list.remove(out));
req.copyFrom(saved_req);
if (new_con) return REQ_NEWCON_RST;
else return REQ_RESTART;
}
// handle permanent redirections
try {
cur_loc =
new URI(
new URI(con.getProtocol(), con.getHost(), con.getPort(), null), req.getRequestURI());
} catch (ParseException pe) {
throw new Error("HTTPClient Internal Error: unexpected exception '" + pe + "'", pe);
}
// handle permanent redirections
Hashtable perm_redir_list =
Util.getList(perm_redir_cntxt_list, req.getConnection().getContext());
if ((new_loc = (URI) perm_redir_list.get(cur_loc)) != null) {
/*
* copy query if present in old url but not in new url. This isn't
* strictly conforming, but some scripts fail to properly propagate the
* query string to the Location header. Unfortunately it looks like we're
* f****d either way: some scripts fail if you don't propagate the query
* string, some fail if you do... God, don't you just love it when people
* can't read a spec? Anway, since we can't get it right for all scripts
* we opt to follow the spec. String nres = new_loc.getPathAndQuery(),
* oquery = Util.getQuery(req.getRequestURI()), nquery =
* Util.getQuery(nres); if (nquery == null && oquery != null) nres += "?"
* + oquery;
*/
String nres = new_loc.getPathAndQuery();
req.setRequestURI(nres);
try {
lastURI = new URI(new_loc, nres);
} catch (ParseException pe) {
if (LOG.isTraceEnabled()) {
LOG.trace("An exception occurred: " + pe.getMessage());
}
}
if (LOG.isDebugEnabled())
LOG.debug(
"Matched request in permanent redirection list - redoing request to "
+ lastURI.toExternalForm());
if (!con.isCompatibleWith(new_loc)) {
try {
con = new HTTPConnection(new_loc);
} catch (ProtocolNotSuppException e) {
throw new Error("HTTPClient Internal Error: unexpected " + "exception '" + e + "'", e);
}
con.setContext(req.getConnection().getContext());
req.setConnection(con);
return REQ_NEWCON_RST;
} else {
return REQ_RESTART;
}
}
return REQ_CONTINUE;
}
/** Invoked by the HTTPClient. */
public int responsePhase2Handler(Response resp, Request req) throws IOException {
/* handle various response status codes until satisfied */
int sts = resp.getStatusCode();
switch (sts) {
case 302: // General (temporary) Redirection (handle like 303)
/*
* Note we only do this munging for POST and PUT. For GET it's not
* necessary; for HEAD we probably want to do another HEAD. For all
* others (i.e. methods from WebDAV, IPP, etc) it's somewhat unclear -
* servers supporting those should really return a 307 or 303, but some
* don't (guess who...), so we just don't touch those.
*/
if (req.getMethod().equals("POST") || req.getMethod().equals("PUT")) {
if (LOG.isDebugEnabled())
LOG.debug(
"Received status: " + sts + " " + resp.getReasonLine() + " - treating as 303");
sts = 303;
}
case 301: // Moved Permanently
case 303: // See Other (use GET)
case 307: // Moved Temporarily (we mean it!)
if (LOG.isDebugEnabled()) LOG.debug("Handling status: " + sts + " " + resp.getReasonLine());
// the spec says automatic redirection may only be done if
// the second request is a HEAD or GET.
if (!req.getMethod().equals("GET") && !req.getMethod().equals("HEAD") && sts != 303) {
if (LOG.isDebugEnabled())
LOG.debug("Not redirected because method is neither HEAD nor GET");
if (sts == 301 && resp.getHeader("Location") != null)
update_perm_redir_list(req, resLocHdr(resp.getHeader("Location"), req));
resp.setEffectiveURI(lastURI);
return RSP_CONTINUE;
}
case 305: // Use Proxy
case 306: // Switch Proxy
if (sts == 305 || sts == 306) {
if (LOG.isDebugEnabled())
LOG.debug("Handling status: " + sts + " " + resp.getReasonLine());
}
// Don't accept 305 from a proxy
if (sts == 305 && req.getConnection().getProxyHost() != null) {
if (LOG.isDebugEnabled()) LOG.debug("305 ignored because a proxy is already in use");
resp.setEffectiveURI(lastURI);
return RSP_CONTINUE;
}
/*
* the level is a primitive way of preventing infinite redirections.
* RFC-2068 set the max to 5, but RFC-2616 has loosened this. Since some
* sites (notably M$) need more levels, this is now set to the
* (arbitrary) value of 15 (god only knows why they need to do even 5
* redirections...).
*/
if (level >= 15 || resp.getHeader("Location") == null) {
if (LOG.isDebugEnabled()) {
if (level >= 15) LOG.debug("Not redirected because of too many levels of redirection");
else LOG.debug("Not redirected because no Location header was present");
}
resp.setEffectiveURI(lastURI);
return RSP_CONTINUE;
}
level++;
URI loc = resLocHdr(resp.getHeader("Location"), req);
HTTPConnection mvd;
String nres;
new_con = false;
if (sts == 305) {
mvd =
new HTTPConnection(
req.getConnection().getProtocol(),
req.getConnection().getHost(),
req.getConnection().getPort());
mvd.setCurrentProxy(loc.getHost(), loc.getPort());
mvd.setContext(req.getConnection().getContext());
new_con = true;
nres = req.getRequestURI();
/*
* There was some discussion about this, and especially Foteos
* Macrides (Lynx) said a 305 should also imply a change to GET (for
* security reasons) - see the thread starting at
* http://www.ics.uci.edu/pub/ietf/http/hypermail/1997q4/0351.html
* However, this is not in the latest draft, but since I agree with
* Foteos we do it anyway...
*/
req.setMethod("GET");
req.setData(null);
req.setStream(null);
} else if (sts == 306) {
// We'll have to wait for Josh to create a new spec here.
return RSP_CONTINUE;
} else {
if (req.getConnection().isCompatibleWith(loc)) {
mvd = req.getConnection();
nres = loc.getPathAndQuery();
} else {
try {
mvd = new HTTPConnection(loc);
nres = loc.getPathAndQuery();
} catch (ProtocolNotSuppException e) {
if (req.getConnection().getProxyHost() == null
|| !loc.getScheme().equalsIgnoreCase("ftp")) return RSP_CONTINUE;
// We're using a proxy and the protocol is ftp -
// maybe the proxy will also proxy ftp...
mvd =
new HTTPConnection(
"http",
req.getConnection().getProxyHost(),
req.getConnection().getProxyPort());
mvd.setCurrentProxy(null, 0);
nres = loc.toExternalForm();
}
mvd.setContext(req.getConnection().getContext());
new_con = true;
}
/*
* copy query if present in old url but not in new url. This isn't
* strictly conforming, but some scripts fail to propagate the query
* properly to the Location header. See comment on line 126. String
* oquery = Util.getQuery(req.getRequestURI()), nquery =
* Util.getQuery(nres); if (nquery == null && oquery != null) nres +=
* "?" + oquery;
*/
if (sts == 303) {
// 303 means "use GET"
if (!req.getMethod().equals("HEAD")) req.setMethod("GET");
req.setData(null);
req.setStream(null);
} else {
// If they used an output stream then they'll have
// to do the resend themselves
if (req.getStream() != null) {
if (!HTTPConnection.deferStreamed) {
if (LOG.isDebugEnabled())
LOG.debug("Status " + sts + " not handled - request has an output stream");
return RSP_CONTINUE;
}
saved_req = (Request) req.clone();
deferred_redir_list.put(req.getStream(), this);
req.getStream().reset();
resp.setRetryRequest(true);
}
if (sts == 301) {
// update permanent redirection list
try {
update_perm_redir_list(req, new URI(loc, nres));
} catch (ParseException pe) {
throw new Error(
"HTTPClient Internal Error: " + "unexpected exception '" + pe + "'", pe);
}
}
}
// Adjust Referer, if present
NVPair[] hdrs = req.getHeaders();
for (int idx = 0; idx < hdrs.length; idx++)
if (hdrs[idx].getName().equalsIgnoreCase("Referer")) {
HTTPConnection con = req.getConnection();
hdrs[idx] = new NVPair("Referer", con + req.getRequestURI());
break;
}
}
req.setConnection(mvd);
req.setRequestURI(nres);
try {
resp.getInputStream().close();
} catch (IOException ioe) {
if (LOG.isTraceEnabled()) {
LOG.trace("An exception occurred: " + ioe.getMessage());
}
}
if (sts != 305 && sts != 306) {
try {
lastURI = new URI(loc, nres);
} catch (ParseException pe) {
if (LOG.isTraceEnabled()) {
LOG.trace("An exception occurred: " + pe.getMessage());
}
}
if (LOG.isDebugEnabled())
LOG.debug(
"Request redirected to "
+ lastURI.toExternalForm()
+ " using method "
+ req.getMethod());
} else {
if (LOG.isDebugEnabled())
LOG.debug(
"Resending request using "
+ "proxy "
+ mvd.getProxyHost()
+ ":"
+ mvd.getProxyPort());
}
if (req.getStream() != null) return RSP_CONTINUE;
else if (new_con) return RSP_NEWCON_REQ;
else return RSP_REQUEST;
default:
return RSP_CONTINUE;
}
}
/** Tests creating of ACK requests. */
public void testCreateAck() {
try {
// 1. Create and send the original request
Request invite = createTiInviteRequest(null, null, null);
RequestEvent receivedRequestEvent = null;
ClientTransaction tran = null;
try {
tran = tiSipProvider.getNewClientTransaction(invite);
eventCollector.collectRequestEvent(riSipProvider);
tran.sendRequest();
waitForMessage();
receivedRequestEvent = eventCollector.extractCollectedRequestEvent();
if (receivedRequestEvent == null || receivedRequestEvent.getRequest() == null)
throw new TiUnexpectedError("The sent request was not received by the RI!");
} catch (TooManyListenersException ex) {
throw new TckInternalError(
"A TooManyListenersException was thrown while trying to add "
+ "a SipListener to an RI SipProvider.",
ex);
} catch (SipException ex) {
throw new TiUnexpectedError("The TI failed to send the request!", ex);
}
Request receivedRequest = receivedRequestEvent.getRequest();
// 2. Create and send the response
Response ok = null;
try {
ok = riMessageFactory.createResponse(Response.OK, receivedRequest);
} catch (ParseException ex) {
throw new TckInternalError("Failed to create an OK response!", ex);
}
// Send the response using the RI and collect using TI
try {
eventCollector.collectResponseEvent(tiSipProvider);
} catch (TooManyListenersException ex) {
throw new TiUnexpectedError("Error while trying to add riSipProvider");
}
try {
riSipProvider.sendResponse(ok);
} catch (SipException ex) {
throw new TckInternalError("Could not send back the response", ex);
}
waitForMessage();
ResponseEvent responseEvent = eventCollector.extractCollectedResponseEvent();
// 3. Now let's create the ack
if (responseEvent == null || responseEvent.getResponse() == null)
throw new TiUnexpectedError("The TI failed to receive the response!");
if (responseEvent.getClientTransaction() != tran)
throw new TiUnexpectedError(
"The TI has associated a new ClientTransaction to a response "
+ "instead of using existing one!");
Request ack = null;
try {
ack = tran.createAck();
} catch (SipException ex) {
ex.printStackTrace();
fail("A SipException was thrown while creating an ack request");
}
assertNotNull("ClientTransaction.createAck returned null!", ack);
assertEquals(
"The created request did not have a CANCEL method.", ack.getMethod(), Request.ACK);
assertEquals(
"Request-URIs of the original and the ack request do not match",
ack.getRequestURI(),
invite.getRequestURI());
assertEquals(
"Call-IDs of the original and the ack request do not match",
ack.getHeader(CallIdHeader.NAME),
invite.getHeader(CallIdHeader.NAME));
assertEquals(
"ToHeaders of the original and the ack request do not match",
ack.getHeader(ToHeader.NAME),
invite.getHeader(ToHeader.NAME));
assertTrue(
"The CSeqHeader's sequence number of the original and " + "the ack request do not match",
((CSeqHeader) ack.getHeader(CSeqHeader.NAME)).getSequenceNumber()
== ((CSeqHeader) invite.getHeader(CSeqHeader.NAME)).getSequenceNumber());
assertEquals(
"The CSeqHeader's method of the ack request was not ACK",
((CSeqHeader) ack.getHeader(CSeqHeader.NAME)).getMethod(),
Request.ACK);
} catch (Throwable exc) {
exc.printStackTrace();
fail(exc.getClass().getName() + ": " + exc.getMessage());
}
assertTrue(new Exception().getStackTrace()[0].toString(), true);
}
/**
* Check the response and answer true if authentication succeeds. We are making simplifying
* assumptions here and assuming that the password is available to us for computation of the MD5
* hash. We also dont cache authentications so that the user has to authenticate on each
* registration.
*
* @param user is the username
* @param authHeader is the Authroization header from the SIP request.
* @param requestLine is the SIP Request line from the SIP request.
* @exception SIPAuthenticationException is thrown when authentication fails or message is bad
*/
public boolean doAuthenticate(String user, AuthorizationHeader authHeader, Request request) {
String realm = authHeader.getRealm();
String username = authHeader.getUsername();
URI requestURI = request.getRequestURI();
if (username == null) {
ProxyDebug.println(
"DEBUG, DigestAuthenticateMethod, doAuthenticate(): "
+ "WARNING: userName parameter not set in the header received!!!");
username = user;
}
if (realm == null) {
ProxyDebug.println(
"DEBUG, DigestAuthenticateMethod, doAuthenticate(): "
+ "WARNING: realm parameter not set in the header received!!! WE use the default one");
realm = DEFAULT_REALM;
}
ProxyDebug.println(
"DEBUG, DigestAuthenticateMethod, doAuthenticate(): "
+ "Trying to authenticate user: "******" for "
+ " the realm: "
+ realm);
String password = (String) passwordTable.get(username + "@" + realm);
if (password == null) {
ProxyDebug.println(
"DEBUG, DigestAuthenticateMethod, doAuthenticate(): "
+ "ERROR: password not found for the user: "******"@"
+ realm);
return false;
}
String nonce = authHeader.getNonce();
// If there is a URI parameter in the Authorization header,
// then use it.
URI uri = authHeader.getURI();
// There must be a URI parameter in the authorization header.
if (uri == null) {
ProxyDebug.println(
"DEBUG, DigestAuthenticateMethod, doAuthenticate(): "
+ "ERROR: uri paramater not set in the header received!");
return false;
}
ProxyDebug.println(
"DEBUG, DigestAuthenticationMethod, doAuthenticate(), username:"******"!");
ProxyDebug.println("DEBUG, DigestAuthenticationMethod, doAuthenticate(), realm:" + realm + "!");
ProxyDebug.println(
"DEBUG, DigestAuthenticationMethod, doAuthenticate(), password:"******"!");
ProxyDebug.println("DEBUG, DigestAuthenticationMethod, doAuthenticate(), uri:" + uri + "!");
ProxyDebug.println("DEBUG, DigestAuthenticationMethod, doAuthenticate(), nonce:" + nonce + "!");
ProxyDebug.println(
"DEBUG, DigestAuthenticationMethod, doAuthenticate(), method:" + request.getMethod() + "!");
String A1 = username + ":" + realm + ":" + password;
String A2 = request.getMethod().toUpperCase() + ":" + uri.toString();
byte mdbytes[] = messageDigest.digest(A1.getBytes());
String HA1 = ProxyUtilities.toHexString(mdbytes);
ProxyDebug.println("DEBUG, DigestAuthenticationMethod, doAuthenticate(), HA1:" + HA1 + "!");
mdbytes = messageDigest.digest(A2.getBytes());
String HA2 = ProxyUtilities.toHexString(mdbytes);
ProxyDebug.println("DEBUG, DigestAuthenticationMethod, doAuthenticate(), HA2:" + HA2 + "!");
String cnonce = authHeader.getCNonce();
String KD = HA1 + ":" + nonce;
if (cnonce != null) {
KD += ":" + cnonce;
}
KD += ":" + HA2;
mdbytes = messageDigest.digest(KD.getBytes());
String mdString = ProxyUtilities.toHexString(mdbytes);
String response = authHeader.getResponse();
ProxyDebug.println(
"DEBUG, DigestAuthenticateMethod, doAuthenticate(): "
+ "we have to compare his response: "
+ response
+ " with our computed"
+ " response: "
+ mdString);
int res = (mdString.compareTo(response));
if (res == 0) {
ProxyDebug.println(
"DEBUG, DigestAuthenticateMethod, doAuthenticate(): " + "User authenticated...");
} else {
ProxyDebug.println(
"DEBUG, DigestAuthenticateMethod, doAuthenticate(): " + "User not authenticated...");
}
return res == 0;
}
/*
* @see javax.servlet.RequestDispatcher#forward(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
*/
protected void forward(ServletRequest request, ServletResponse response, DispatcherType dispatch)
throws ServletException, IOException {
Request baseRequest =
(request instanceof Request)
? ((Request) request)
: HttpChannel.getCurrentHttpChannel().getRequest();
Response base_response = baseRequest.getResponse();
base_response.resetForForward();
if (!(request instanceof HttpServletRequest)) request = new ServletRequestHttpWrapper(request);
if (!(response instanceof HttpServletResponse))
response = new ServletResponseHttpWrapper(response);
final boolean old_handled = baseRequest.isHandled();
final String old_uri = baseRequest.getRequestURI();
final String old_context_path = baseRequest.getContextPath();
final String old_servlet_path = baseRequest.getServletPath();
final String old_path_info = baseRequest.getPathInfo();
final String old_query = baseRequest.getQueryString();
final Attributes old_attr = baseRequest.getAttributes();
final DispatcherType old_type = baseRequest.getDispatcherType();
MultiMap<String> old_params = baseRequest.getParameters();
try {
baseRequest.setHandled(false);
baseRequest.setDispatcherType(dispatch);
if (_named != null)
_contextHandler.handle(
_named, baseRequest, (HttpServletRequest) request, (HttpServletResponse) response);
else {
// process any query string from the dispatch URL
String query = _dQuery;
if (query != null) {
// force parameter extraction
if (old_params == null) {
baseRequest.extractParameters();
old_params = baseRequest.getParameters();
}
baseRequest.mergeQueryString(query);
}
ForwardAttributes attr = new ForwardAttributes(old_attr);
// If we have already been forwarded previously, then keep using the established
// original value. Otherwise, this is the first forward and we need to establish the values.
// Note: the established value on the original request for pathInfo and
// for queryString is allowed to be null, but cannot be null for the other values.
if (old_attr.getAttribute(FORWARD_REQUEST_URI) != null) {
attr._pathInfo = (String) old_attr.getAttribute(FORWARD_PATH_INFO);
attr._query = (String) old_attr.getAttribute(FORWARD_QUERY_STRING);
attr._requestURI = (String) old_attr.getAttribute(FORWARD_REQUEST_URI);
attr._contextPath = (String) old_attr.getAttribute(FORWARD_CONTEXT_PATH);
attr._servletPath = (String) old_attr.getAttribute(FORWARD_SERVLET_PATH);
} else {
attr._pathInfo = old_path_info;
attr._query = old_query;
attr._requestURI = old_uri;
attr._contextPath = old_context_path;
attr._servletPath = old_servlet_path;
}
baseRequest.setRequestURI(_uri);
baseRequest.setContextPath(_contextHandler.getContextPath());
baseRequest.setServletPath(null);
baseRequest.setPathInfo(_uri);
baseRequest.setAttributes(attr);
_contextHandler.handle(
_path, baseRequest, (HttpServletRequest) request, (HttpServletResponse) response);
if (!baseRequest.getHttpChannelState().isAsync()) commitResponse(response, baseRequest);
}
} finally {
baseRequest.setHandled(old_handled);
baseRequest.setRequestURI(old_uri);
baseRequest.setContextPath(old_context_path);
baseRequest.setServletPath(old_servlet_path);
baseRequest.setPathInfo(old_path_info);
baseRequest.setAttributes(old_attr);
baseRequest.setParameters(old_params);
baseRequest.setQueryString(old_query);
baseRequest.setDispatcherType(old_type);
}
}
/**
* Find the <tt>ProtocolProviderServiceSipImpl</tt> (one of our "candidate recipient" listeners)
* which this <tt>request</tt> should be dispatched to. The strategy is to look first at the
* request URI, and then at the To field to find a matching candidate for dispatching. Note that
* this method takes a <tt>Request</tt> as param, and not a <tt>ServerTransaction</tt>, because
* sometimes <tt>RequestEvent</tt>s have no associated <tt>ServerTransaction</tt>.
*
* @param request the <tt>Request</tt> to find a recipient for.
* @return a suitable <tt>ProtocolProviderServiceSipImpl</tt>.
*/
private ProtocolProviderServiceSipImpl findTargetFor(Request request) {
if (request == null) {
logger.error("request shouldn't be null.");
return null;
}
List<ProtocolProviderServiceSipImpl> currentListenersCopy =
new ArrayList<ProtocolProviderServiceSipImpl>(this.getSipListeners());
// Let's first narrow down candidate choice by comparing
// addresses and ports (no point in delivering to a provider with a
// non matching IP address since they will reject it anyway).
filterByAddress(currentListenersCopy, request);
if (currentListenersCopy.size() == 0) {
logger.error("no listeners");
return null;
}
URI requestURI = request.getRequestURI();
if (requestURI.isSipURI()) {
String requestUser = ((SipURI) requestURI).getUser();
List<ProtocolProviderServiceSipImpl> candidates =
new ArrayList<ProtocolProviderServiceSipImpl>();
// check if the Request-URI username is
// one of ours usernames
for (ProtocolProviderServiceSipImpl listener : currentListenersCopy) {
String ourUserID = listener.getAccountID().getUserID();
// logger.trace(ourUserID + " *** " + requestUser);
if (ourUserID.equals(requestUser)) {
if (logger.isTraceEnabled())
logger.trace("suitable candidate found: " + listener.getAccountID());
candidates.add(listener);
}
}
// the perfect match
// every other case is approximation
if (candidates.size() == 1) {
ProtocolProviderServiceSipImpl perfectMatch = candidates.get(0);
if (logger.isTraceEnabled())
logger.trace("Will dispatch to \"" + perfectMatch.getAccountID() + "\"");
return perfectMatch;
}
// more than one account match
if (candidates.size() > 1) {
// check if a custom param exists in the contact
// address (set for registrar accounts)
for (ProtocolProviderServiceSipImpl candidate : candidates) {
String hostValue =
((SipURI) requestURI).getParameter(SipStackSharing.CONTACT_ADDRESS_CUSTOM_PARAM_NAME);
if (hostValue == null) continue;
if (hostValue.equals(candidate.getContactAddressCustomParamValue())) {
if (logger.isTraceEnabled())
logger.trace(
"Will dispatch to \""
+ candidate.getAccountID()
+ "\" because "
+ "\" the custom param was set");
return candidate;
}
}
// Past this point, our guess is not reliable. We try to find
// the "least worst" match based on parameters like the To field
// check if the To header field host part
// matches any of our SIP hosts
for (ProtocolProviderServiceSipImpl candidate : candidates) {
URI fromURI = ((FromHeader) request.getHeader(FromHeader.NAME)).getAddress().getURI();
if (fromURI.isSipURI() == false) continue;
SipURI ourURI = (SipURI) candidate.getOurSipAddress((SipURI) fromURI).getURI();
String ourHost = ourURI.getHost();
URI toURI = ((ToHeader) request.getHeader(ToHeader.NAME)).getAddress().getURI();
if (toURI.isSipURI() == false) continue;
String toHost = ((SipURI) toURI).getHost();
// logger.trace(toHost + "***" + ourHost);
if (toHost.equals(ourHost)) {
if (logger.isTraceEnabled())
logger.trace(
"Will dispatch to \""
+ candidate.getAccountID()
+ "\" because "
+ "host in the To: is the same as in our AOR");
return candidate;
}
}
// fallback on the first candidate
ProtocolProviderServiceSipImpl target = candidates.iterator().next();
logger.info(
"Will randomly dispatch to \""
+ target.getAccountID()
+ "\" because there is ambiguity on the username from"
+ " the Request-URI");
if (logger.isTraceEnabled()) logger.trace("\n" + request);
return target;
}
// fallback on any account
ProtocolProviderServiceSipImpl target = currentListenersCopy.iterator().next();
if (logger.isDebugEnabled())
logger.debug(
"Will randomly dispatch to \""
+ target.getAccountID()
+ "\" because the username in the Request-URI "
+ "is unknown or empty");
if (logger.isTraceEnabled()) logger.trace("\n" + request);
return target;
} else {
logger.error("Request-URI is not a SIP URI, dropping");
}
return null;
}
@Override
public void sendError(int code, String message) throws IOException {
if (isIncluding()) return;
if (isCommitted()) LOG.warn("Committed before " + code + " " + message);
resetBuffer();
_characterEncoding = null;
setHeader(HttpHeader.EXPIRES, null);
setHeader(HttpHeader.LAST_MODIFIED, null);
setHeader(HttpHeader.CACHE_CONTROL, null);
setHeader(HttpHeader.CONTENT_TYPE, null);
setHeader(HttpHeader.CONTENT_LENGTH, null);
_outputType = OutputType.NONE;
setStatus(code);
_reason = message;
Request request = _channel.getRequest();
Throwable cause = (Throwable) request.getAttribute(Dispatcher.ERROR_EXCEPTION);
if (message == null) message = cause == null ? HttpStatus.getMessage(code) : cause.toString();
// If we are allowed to have a body
if (code != SC_NO_CONTENT
&& code != SC_NOT_MODIFIED
&& code != SC_PARTIAL_CONTENT
&& code >= SC_OK) {
ErrorHandler error_handler = null;
ContextHandler.Context context = request.getContext();
if (context != null) error_handler = context.getContextHandler().getErrorHandler();
if (error_handler == null) error_handler = _channel.getServer().getBean(ErrorHandler.class);
if (error_handler != null) {
request.setAttribute(RequestDispatcher.ERROR_STATUS_CODE, new Integer(code));
request.setAttribute(RequestDispatcher.ERROR_MESSAGE, message);
request.setAttribute(RequestDispatcher.ERROR_REQUEST_URI, request.getRequestURI());
request.setAttribute(RequestDispatcher.ERROR_SERVLET_NAME, request.getServletName());
error_handler.handle(null, _channel.getRequest(), _channel.getRequest(), this);
} else {
setHeader(HttpHeader.CACHE_CONTROL, "must-revalidate,no-cache,no-store");
setContentType(MimeTypes.Type.TEXT_HTML_8859_1.toString());
ByteArrayISO8859Writer writer = new ByteArrayISO8859Writer(2048);
if (message != null) {
message = StringUtil.replace(message, "&", "&");
message = StringUtil.replace(message, "<", "<");
message = StringUtil.replace(message, ">", ">");
}
String uri = request.getRequestURI();
if (uri != null) {
uri = StringUtil.replace(uri, "&", "&");
uri = StringUtil.replace(uri, "<", "<");
uri = StringUtil.replace(uri, ">", ">");
}
writer.write(
"<html>\n<head>\n<meta http-equiv=\"Content-Type\" content=\"text/html;charset=ISO-8859-1\"/>\n");
writer.write("<title>Error ");
writer.write(Integer.toString(code));
writer.write(' ');
if (message == null) writer.write(message);
writer.write("</title>\n</head>\n<body>\n<h2>HTTP ERROR: ");
writer.write(Integer.toString(code));
writer.write("</h2>\n<p>Problem accessing ");
writer.write(uri);
writer.write(". Reason:\n<pre> ");
writer.write(message);
writer.write("</pre>");
writer.write("</p>\n<hr /><i><small>Powered by Jetty://</small></i>");
writer.write("\n</body>\n</html>\n");
writer.flush();
setContentLength(writer.size());
writer.writeTo(getOutputStream());
writer.destroy();
}
} else if (code != SC_PARTIAL_CONTENT) {
// TODO work out why this is required?
_channel.getRequest().getHttpFields().remove(HttpHeader.CONTENT_TYPE);
_channel.getRequest().getHttpFields().remove(HttpHeader.CONTENT_LENGTH);
_characterEncoding = null;
_mimeType = null;
}
complete();
}
/** @return True if the channel is ready to continue handling (ie it is not suspended) */
public boolean handle() {
LOG.debug("{} handle enter", this);
setCurrentHttpChannel(this);
String threadName = null;
if (LOG.isDebugEnabled()) {
threadName = Thread.currentThread().getName();
Thread.currentThread().setName(threadName + " - " + _uri);
}
// Loop here to handle async request redispatches.
// The loop is controlled by the call to async.unhandle in the
// finally block below. Unhandle will return false only if an async dispatch has
// already happened when unhandle is called.
HttpChannelState.Next next = _state.handling();
while (next == Next.CONTINUE && getServer().isRunning()) {
boolean error = false;
try {
_request.setHandled(false);
_response.getHttpOutput().reopen();
if (_state.isInitial()) {
_request.setTimeStamp(System.currentTimeMillis());
_request.setDispatcherType(DispatcherType.REQUEST);
for (HttpConfiguration.Customizer customizer : _configuration.getCustomizers())
customizer.customize(getConnector(), _configuration, _request);
getServer().handle(this);
} else {
if (_request.getHttpChannelState().isExpired()) {
_request.setDispatcherType(DispatcherType.ERROR);
Throwable ex = _state.getAsyncContextEvent().getThrowable();
String reason = "Async Timeout";
if (ex != null) {
reason = "Async Exception";
_request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, ex);
}
_request.setAttribute(RequestDispatcher.ERROR_STATUS_CODE, new Integer(500));
_request.setAttribute(RequestDispatcher.ERROR_MESSAGE, reason);
_request.setAttribute(RequestDispatcher.ERROR_REQUEST_URI, _request.getRequestURI());
_response.setStatusWithReason(500, reason);
ErrorHandler eh = _state.getContextHandler().getErrorHandler();
if (eh instanceof ErrorHandler.ErrorPageMapper) {
String error_page =
((ErrorHandler.ErrorPageMapper) eh)
.getErrorPage(
(HttpServletRequest) _state.getAsyncContextEvent().getSuppliedRequest());
if (error_page != null) _state.getAsyncContextEvent().setDispatchPath(error_page);
}
} else _request.setDispatcherType(DispatcherType.ASYNC);
getServer().handleAsync(this);
}
} catch (Error e) {
if ("ContinuationThrowable".equals(e.getClass().getSimpleName())) LOG.ignore(e);
else {
error = true;
throw e;
}
} catch (Exception e) {
error = true;
if (e instanceof EofException) LOG.debug(e);
else LOG.warn(String.valueOf(_uri), e);
_state.error(e);
_request.setHandled(true);
handleException(e);
} finally {
if (error && _state.isAsyncStarted()) _state.errorComplete();
next = _state.unhandle();
}
}
if (threadName != null && LOG.isDebugEnabled()) Thread.currentThread().setName(threadName);
setCurrentHttpChannel(null);
if (next == Next.COMPLETE) {
try {
_state.completed();
if (!_response.isCommitted() && !_request.isHandled()) _response.sendError(404);
else
// Complete generating the response
_response.closeOutput();
} catch (EofException | ClosedChannelException e) {
LOG.debug(e);
} catch (Exception e) {
LOG.warn("complete failed", e);
} finally {
_request.setHandled(true);
_transport.completed();
}
}
LOG.debug("{} handle exit, result {}", this, next);
return next != Next.WAIT;
}
/** Invoked by the HTTPClient. */
public void responsePhase1Handler(Response resp, RoRequest roreq)
throws IOException, ModuleException {
try {
resp.getStatusCode();
} catch (RetryException re) {
Log.write(Log.MODS, "RtryM: Caught RetryException");
boolean got_lock = false;
try {
synchronized (re.first) {
got_lock = true;
// initialize idempotent sequence checking
IdempotentSequence seq = new IdempotentSequence();
for (RetryException e = re.first; e != null; e = e.next) seq.add(e.request);
for (RetryException e = re.first; e != null; e = e.next) {
Log.write(Log.MODS, "RtryM: handling exception ", e);
Request req = e.request;
HTTPConnection con = req.getConnection();
/* Don't retry if either the sequence is not idempotent
* (Sec 8.1.4 and 9.1.2), or we've already retried enough
* times, or the headers have been read and parsed
* already
*/
if (!seq.isIdempotent(req)
|| (con.ServProtVersKnown
&& con.ServerProtocolVersion >= HTTP_1_1
&& req.num_retries > 0)
|| ((!con.ServProtVersKnown || con.ServerProtocolVersion <= HTTP_1_0)
&& req.num_retries > 4)
|| e.response.got_headers) {
e.first = null;
continue;
}
/**
* if an output stream was used (i.e. we don't have the data to resend) then delegate
* the responsibility for resending to the application.
*/
if (req.getStream() != null) {
if (HTTPConnection.deferStreamed) {
req.getStream().reset();
e.response.setRetryRequest(true);
}
e.first = null;
continue;
}
/* If we have an entity then setup either the entity-delay
* or the Expect header
*/
if (req.getData() != null && e.conn_reset) {
if (con.ServProtVersKnown && con.ServerProtocolVersion >= HTTP_1_1)
addToken(req, "Expect", "100-continue");
else req.delay_entity = 5000L << req.num_retries;
}
/* If the next request in line has an entity and we're
* talking to an HTTP/1.0 server then close the socket
* after this request. This is so that the available()
* call (to watch for an error response from the server)
* will work correctly.
*/
if (e.next != null
&& e.next.request.getData() != null
&& (!con.ServProtVersKnown || con.ServerProtocolVersion < HTTP_1_1)
&& e.conn_reset) {
addToken(req, "Connection", "close");
}
/* If this an HTTP/1.1 server then don't pipeline retries.
* The problem is that if the server for some reason
* decides not to use persistent connections and it does
* not do a correct shutdown of the connection, then the
* response will be ReSeT. If we did pipeline then we
* would keep falling into this trap indefinitely.
*
* Note that for HTTP/1.0 servers, if they don't support
* keep-alives then the normal code will already handle
* this accordingly and won't pipe over the same
* connection.
*/
if (con.ServProtVersKnown && con.ServerProtocolVersion >= HTTP_1_1 && e.conn_reset) {
req.dont_pipeline = true;
}
// The above is too risky - for moment let's be safe
// and never pipeline retried request at all.
req.dont_pipeline = true;
// now resend the request
Log.write(
Log.MODS,
"RtryM: Retrying request '" + req.getMethod() + " " + req.getRequestURI() + "'");
if (e.conn_reset) req.num_retries++;
e.response.http_resp.set(req, con.sendRequest(req, e.response.timeout));
e.exception = null;
e.first = null;
}
}
} catch (NullPointerException npe) {
if (got_lock) throw npe;
} catch (ParseException pe) {
throw new IOException(pe.getMessage());
}
if (re.exception != null) throw re.exception;
re.restart = true;
throw re;
}
}
