1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.eclipse.jetty.server;
20
21 import java.io.BufferedReader;
22 import java.io.ByteArrayOutputStream;
23 import java.io.File;
24 import java.io.IOException;
25 import java.io.InputStream;
26 import java.io.InputStreamReader;
27 import java.io.UnsupportedEncodingException;
28 import java.net.InetAddress;
29 import java.net.InetSocketAddress;
30 import java.nio.charset.Charset;
31 import java.nio.charset.StandardCharsets;
32 import java.nio.charset.UnsupportedCharsetException;
33 import java.security.Principal;
34 import java.util.ArrayList;
35 import java.util.Collection;
36 import java.util.Collections;
37 import java.util.Enumeration;
38 import java.util.EventListener;
39 import java.util.HashMap;
40 import java.util.List;
41 import java.util.Locale;
42 import java.util.Map;
43
44 import javax.servlet.AsyncContext;
45 import javax.servlet.AsyncListener;
46 import javax.servlet.DispatcherType;
47 import javax.servlet.MultipartConfigElement;
48 import javax.servlet.RequestDispatcher;
49 import javax.servlet.ServletContext;
50 import javax.servlet.ServletException;
51 import javax.servlet.ServletInputStream;
52 import javax.servlet.ServletRequest;
53 import javax.servlet.ServletRequestAttributeEvent;
54 import javax.servlet.ServletRequestAttributeListener;
55 import javax.servlet.ServletRequestEvent;
56 import javax.servlet.ServletRequestListener;
57 import javax.servlet.ServletResponse;
58 import javax.servlet.http.Cookie;
59 import javax.servlet.http.HttpServletRequest;
60 import javax.servlet.http.HttpServletResponse;
61 import javax.servlet.http.HttpSession;
62 import javax.servlet.http.HttpUpgradeHandler;
63 import javax.servlet.http.Part;
64
65 import org.eclipse.jetty.http.HttpCookie;
66 import org.eclipse.jetty.http.HttpFields;
67 import org.eclipse.jetty.http.HttpHeader;
68 import org.eclipse.jetty.http.HttpMethod;
69 import org.eclipse.jetty.http.HttpStatus;
70 import org.eclipse.jetty.http.HttpURI;
71 import org.eclipse.jetty.http.HttpVersion;
72 import org.eclipse.jetty.http.MimeTypes;
73 import org.eclipse.jetty.server.handler.ContextHandler;
74 import org.eclipse.jetty.server.handler.ContextHandler.Context;
75 import org.eclipse.jetty.server.session.AbstractSession;
76 import org.eclipse.jetty.util.Attributes;
77 import org.eclipse.jetty.util.AttributesMap;
78 import org.eclipse.jetty.util.IO;
79 import org.eclipse.jetty.util.MultiException;
80 import org.eclipse.jetty.util.MultiMap;
81 import org.eclipse.jetty.util.MultiPartInputStreamParser;
82 import org.eclipse.jetty.util.StringUtil;
83 import org.eclipse.jetty.util.URIUtil;
84 import org.eclipse.jetty.util.UrlEncoded;
85 import org.eclipse.jetty.util.log.Log;
86 import org.eclipse.jetty.util.log.Logger;
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120 public class Request implements HttpServletRequest
121 {
122 public static final String __MULTIPART_CONFIG_ELEMENT = "org.eclipse.jetty.multipartConfig";
123 public static final String __MULTIPART_INPUT_STREAM = "org.eclipse.jetty.multiPartInputStream";
124 public static final String __MULTIPART_CONTEXT = "org.eclipse.jetty.multiPartContext";
125
126 private static final Logger LOG = Log.getLogger(Request.class);
127 private static final Collection<Locale> __defaultLocale = Collections.singleton(Locale.getDefault());
128 private static final int __NONE = 0, _STREAM = 1, __READER = 2;
129
130 private final HttpChannel<?> _channel;
131 private final HttpFields _fields=new HttpFields();
132 private final List<ServletRequestAttributeListener> _requestAttributeListeners=new ArrayList<>();
133 private final HttpInput<?> _input;
134
135 public static class MultiPartCleanerListener implements ServletRequestListener
136 {
137 @Override
138 public void requestDestroyed(ServletRequestEvent sre)
139 {
140
141 MultiPartInputStreamParser mpis = (MultiPartInputStreamParser)sre.getServletRequest().getAttribute(__MULTIPART_INPUT_STREAM);
142 if (mpis != null)
143 {
144 ContextHandler.Context context = (ContextHandler.Context)sre.getServletRequest().getAttribute(__MULTIPART_CONTEXT);
145
146
147 if (context == sre.getServletContext())
148 {
149 try
150 {
151 mpis.deleteParts();
152 }
153 catch (MultiException e)
154 {
155 sre.getServletContext().log("Errors deleting multipart tmp files", e);
156 }
157 }
158 }
159 }
160
161 @Override
162 public void requestInitialized(ServletRequestEvent sre)
163 {
164
165 }
166
167 }
168
169
170
171 private boolean _secure;
172 private boolean _asyncSupported = true;
173 private boolean _newContext;
174 private boolean _cookiesExtracted = false;
175 private boolean _handled = false;
176 private boolean _paramsExtracted;
177 private boolean _requestedSessionIdFromCookie = false;
178 private volatile Attributes _attributes;
179 private Authentication _authentication;
180 private String _characterEncoding;
181 private ContextHandler.Context _context;
182 private String _contextPath;
183 private CookieCutter _cookies;
184 private DispatcherType _dispatcherType;
185 private int _inputState = __NONE;
186 private HttpMethod _httpMethod;
187 private String _httpMethodString;
188 private MultiMap<String> _queryParameters;
189 private MultiMap<String> _contentParameters;
190 private MultiMap<String> _parameters;
191 private String _pathInfo;
192 private int _port;
193 private HttpVersion _httpVersion = HttpVersion.HTTP_1_1;
194 private String _queryEncoding;
195 private String _queryString;
196 private BufferedReader _reader;
197 private String _readerEncoding;
198 private InetSocketAddress _remote;
199 private String _requestedSessionId;
200 private String _requestURI;
201 private Map<Object, HttpSession> _savedNewSessions;
202 private String _scheme = URIUtil.HTTP;
203 private UserIdentity.Scope _scope;
204 private String _serverName;
205 private String _servletPath;
206 private HttpSession _session;
207 private SessionManager _sessionManager;
208 private long _timeStamp;
209 private HttpURI _uri;
210 private MultiPartInputStreamParser _multiPartInputStream;
211 private AsyncContextState _async;
212
213
214 public Request(HttpChannel<?> channel, HttpInput<?> input)
215 {
216 _channel = channel;
217 _input = input;
218 }
219
220
221 public HttpFields getHttpFields()
222 {
223 return _fields;
224 }
225
226
227 public HttpInput<?> getHttpInput()
228 {
229 return _input;
230 }
231
232
233 public void addEventListener(final EventListener listener)
234 {
235 if (listener instanceof ServletRequestAttributeListener)
236 _requestAttributeListeners.add((ServletRequestAttributeListener)listener);
237 if (listener instanceof AsyncListener)
238 throw new IllegalArgumentException(listener.getClass().toString());
239 }
240
241 public void extractParameters()
242 {
243 if (_paramsExtracted)
244 return;
245
246 _paramsExtracted = true;
247
248
249
250 if (_queryParameters == null)
251 _queryParameters = extractQueryParameters();
252
253
254
255
256 if (_contentParameters == null)
257 _contentParameters = extractContentParameters();
258
259 _parameters = restoreParameters();
260 }
261
262 private MultiMap<String> extractQueryParameters()
263 {
264 MultiMap<String> result = new MultiMap<>();
265 if (_uri != null && _uri.hasQuery())
266 {
267 if (_queryEncoding == null)
268 {
269 _uri.decodeQueryTo(result);
270 }
271 else
272 {
273 try
274 {
275 _uri.decodeQueryTo(result, _queryEncoding);
276 }
277 catch (UnsupportedEncodingException e)
278 {
279 if (LOG.isDebugEnabled())
280 LOG.warn(e);
281 else
282 LOG.warn(e.toString());
283 }
284 }
285 }
286 return result;
287 }
288
289 private MultiMap<String> extractContentParameters()
290 {
291 MultiMap<String> result = new MultiMap<>();
292
293 String contentType = getContentType();
294 if (contentType != null && !contentType.isEmpty())
295 {
296 contentType = HttpFields.valueParameters(contentType, null);
297 int contentLength = getContentLength();
298 if (contentLength != 0)
299 {
300 if (MimeTypes.Type.FORM_ENCODED.is(contentType) && _inputState == __NONE &&
301 (HttpMethod.POST.is(getMethod()) || HttpMethod.PUT.is(getMethod())))
302 {
303 extractFormParameters(result);
304 }
305 else if (contentType.startsWith("multipart/form-data") &&
306 getAttribute(__MULTIPART_CONFIG_ELEMENT) != null &&
307 _multiPartInputStream == null)
308 {
309 extractMultipartParameters(result);
310 }
311 }
312 }
313
314 return result;
315 }
316
317 public void extractFormParameters(MultiMap<String> params)
318 {
319 try
320 {
321 int maxFormContentSize = -1;
322 int maxFormKeys = -1;
323
324 if (_context != null)
325 {
326 maxFormContentSize = _context.getContextHandler().getMaxFormContentSize();
327 maxFormKeys = _context.getContextHandler().getMaxFormKeys();
328 }
329
330 if (maxFormContentSize < 0)
331 {
332 Object obj = _channel.getServer().getAttribute("org.eclipse.jetty.server.Request.maxFormContentSize");
333 if (obj == null)
334 maxFormContentSize = 200000;
335 else if (obj instanceof Number)
336 {
337 Number size = (Number)obj;
338 maxFormContentSize = size.intValue();
339 }
340 else if (obj instanceof String)
341 {
342 maxFormContentSize = Integer.valueOf((String)obj);
343 }
344 }
345
346 if (maxFormKeys < 0)
347 {
348 Object obj = _channel.getServer().getAttribute("org.eclipse.jetty.server.Request.maxFormKeys");
349 if (obj == null)
350 maxFormKeys = 1000;
351 else if (obj instanceof Number)
352 {
353 Number keys = (Number)obj;
354 maxFormKeys = keys.intValue();
355 }
356 else if (obj instanceof String)
357 {
358 maxFormKeys = Integer.valueOf((String)obj);
359 }
360 }
361
362 int contentLength = getContentLength();
363 if (contentLength > maxFormContentSize && maxFormContentSize > 0)
364 {
365 throw new IllegalStateException("Form too large: " + contentLength + " > " + maxFormContentSize);
366 }
367 InputStream in = getInputStream();
368 if (_input.isAsync())
369 throw new IllegalStateException("Cannot extract parameters with async IO");
370
371 UrlEncoded.decodeTo(in,params,getCharacterEncoding(),contentLength<0?maxFormContentSize:-1,maxFormKeys);
372 }
373 catch (IOException e)
374 {
375 if (LOG.isDebugEnabled())
376 LOG.warn(e);
377 else
378 LOG.warn(e.toString());
379 }
380 }
381
382 private void extractMultipartParameters(MultiMap<String> result)
383 {
384 try
385 {
386 getParts(result);
387 }
388 catch (IOException | ServletException e)
389 {
390 LOG.warn(e);
391 throw new RuntimeException(e);
392 }
393 }
394
395
396 @Override
397 public AsyncContext getAsyncContext()
398 {
399 HttpChannelState state = getHttpChannelState();
400 if (_async==null || !state.isAsyncStarted())
401 throw new IllegalStateException(state.getStatusString());
402
403 return _async;
404 }
405
406
407 public HttpChannelState getHttpChannelState()
408 {
409 return _channel.getState();
410 }
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426 @Override
427 public Object getAttribute(String name)
428 {
429 if (name.startsWith("org.eclipse.jetty"))
430 {
431 if ("org.eclipse.jetty.server.Server".equals(name))
432 return _channel.getServer();
433 if ("org.eclipse.jetty.server.HttpChannel".equals(name))
434 return _channel;
435 if ("org.eclipse.jetty.server.HttpConnection".equals(name) &&
436 _channel.getHttpTransport() instanceof HttpConnection)
437 return _channel.getHttpTransport();
438 }
439 return (_attributes == null)?null:_attributes.getAttribute(name);
440 }
441
442
443
444
445
446 @Override
447 public Enumeration<String> getAttributeNames()
448 {
449 if (_attributes == null)
450 return Collections.enumeration(Collections.<String>emptyList());
451
452 return AttributesMap.getAttributeNamesCopy(_attributes);
453 }
454
455
456
457
458 public Attributes getAttributes()
459 {
460 if (_attributes == null)
461 _attributes = new AttributesMap();
462 return _attributes;
463 }
464
465
466
467
468
469
470
471 public Authentication getAuthentication()
472 {
473 return _authentication;
474 }
475
476
477
478
479
480 @Override
481 public String getAuthType()
482 {
483 if (_authentication instanceof Authentication.Deferred)
484 setAuthentication(((Authentication.Deferred)_authentication).authenticate(this));
485
486 if (_authentication instanceof Authentication.User)
487 return ((Authentication.User)_authentication).getAuthMethod();
488 return null;
489 }
490
491
492
493
494
495 @Override
496 public String getCharacterEncoding()
497 {
498 return _characterEncoding;
499 }
500
501
502
503
504
505 public HttpChannel<?> getHttpChannel()
506 {
507 return _channel;
508 }
509
510
511
512
513
514 @Override
515 public int getContentLength()
516 {
517 return (int)_fields.getLongField(HttpHeader.CONTENT_LENGTH.toString());
518 }
519
520
521
522
523
524 @Override
525 public long getContentLengthLong()
526 {
527 return _fields.getLongField(HttpHeader.CONTENT_LENGTH.toString());
528 }
529
530
531 public long getContentRead()
532 {
533 return _input.getContentRead();
534 }
535
536
537
538
539
540 @Override
541 public String getContentType()
542 {
543 return _fields.getStringField(HttpHeader.CONTENT_TYPE);
544 }
545
546
547
548
549
550 public Context getContext()
551 {
552 return _context;
553 }
554
555
556
557
558
559 @Override
560 public String getContextPath()
561 {
562 return _contextPath;
563 }
564
565
566
567
568
569 @Override
570 public Cookie[] getCookies()
571 {
572 if (_cookiesExtracted)
573 {
574 if (_cookies == null || _cookies.getCookies().length == 0)
575 return null;
576
577 return _cookies.getCookies();
578 }
579
580 _cookiesExtracted = true;
581
582 Enumeration<?> enm = _fields.getValues(HttpHeader.COOKIE.toString());
583
584
585 if (enm != null)
586 {
587 if (_cookies == null)
588 _cookies = new CookieCutter();
589
590 while (enm.hasMoreElements())
591 {
592 String c = (String)enm.nextElement();
593 _cookies.addCookieField(c);
594 }
595 }
596
597
598 if (_cookies == null || _cookies.getCookies().length == 0)
599 return null;
600
601 return _cookies.getCookies();
602 }
603
604
605
606
607
608 @Override
609 public long getDateHeader(String name)
610 {
611 return _fields.getDateField(name);
612 }
613
614
615 @Override
616 public DispatcherType getDispatcherType()
617 {
618 return _dispatcherType;
619 }
620
621
622
623
624
625 @Override
626 public String getHeader(String name)
627 {
628 return _fields.getStringField(name);
629 }
630
631
632
633
634
635 @Override
636 public Enumeration<String> getHeaderNames()
637 {
638 return _fields.getFieldNames();
639 }
640
641
642
643
644
645 @Override
646 public Enumeration<String> getHeaders(String name)
647 {
648 Enumeration<String> e = _fields.getValues(name);
649 if (e == null)
650 return Collections.enumeration(Collections.<String>emptyList());
651 return e;
652 }
653
654
655
656
657
658 public int getInputState()
659 {
660 return _inputState;
661 }
662
663
664
665
666
667 @Override
668 public ServletInputStream getInputStream() throws IOException
669 {
670 if (_inputState != __NONE && _inputState != _STREAM)
671 throw new IllegalStateException("READER");
672 _inputState = _STREAM;
673
674 if (_channel.isExpecting100Continue())
675 _channel.continue100(_input.available());
676
677 return _input;
678 }
679
680
681
682
683
684 @Override
685 public int getIntHeader(String name)
686 {
687 return (int)_fields.getLongField(name);
688 }
689
690
691
692
693
694
695 @Override
696 public Locale getLocale()
697 {
698 Enumeration<String> enm = _fields.getValues(HttpHeader.ACCEPT_LANGUAGE.toString(),HttpFields.__separators);
699
700
701 if (enm == null || !enm.hasMoreElements())
702 return Locale.getDefault();
703
704
705 List<?> acceptLanguage = HttpFields.qualityList(enm);
706 if (acceptLanguage.size() == 0)
707 return Locale.getDefault();
708
709 int size = acceptLanguage.size();
710
711 if (size > 0)
712 {
713 String language = (String)acceptLanguage.get(0);
714 language = HttpFields.valueParameters(language,null);
715 String country = "";
716 int dash = language.indexOf('-');
717 if (dash > -1)
718 {
719 country = language.substring(dash + 1).trim();
720 language = language.substring(0,dash).trim();
721 }
722 return new Locale(language,country);
723 }
724
725 return Locale.getDefault();
726 }
727
728
729
730
731
732 @Override
733 public Enumeration<Locale> getLocales()
734 {
735
736 Enumeration<String> enm = _fields.getValues(HttpHeader.ACCEPT_LANGUAGE.toString(),HttpFields.__separators);
737
738
739 if (enm == null || !enm.hasMoreElements())
740 return Collections.enumeration(__defaultLocale);
741
742
743 List<String> acceptLanguage = HttpFields.qualityList(enm);
744
745 if (acceptLanguage.size() == 0)
746 return Collections.enumeration(__defaultLocale);
747
748 List<Locale> langs = new ArrayList<>();
749
750
751 for (String language : acceptLanguage)
752 {
753 language = HttpFields.valueParameters(language, null);
754 String country = "";
755 int dash = language.indexOf('-');
756 if (dash > -1)
757 {
758 country = language.substring(dash + 1).trim();
759 language = language.substring(0, dash).trim();
760 }
761 langs.add(new Locale(language, country));
762 }
763
764 if (langs.size() == 0)
765 return Collections.enumeration(__defaultLocale);
766
767 return Collections.enumeration(langs);
768 }
769
770
771
772
773
774 @Override
775 public String getLocalAddr()
776 {
777 InetSocketAddress local=_channel.getLocalAddress();
778 if (local==null)
779 return "";
780 InetAddress address = local.getAddress();
781 if (address==null)
782 return local.getHostString();
783 return address.getHostAddress();
784 }
785
786
787
788
789
790 @Override
791 public String getLocalName()
792 {
793 InetSocketAddress local=_channel.getLocalAddress();
794 return local.getHostString();
795 }
796
797
798
799
800
801 @Override
802 public int getLocalPort()
803 {
804 InetSocketAddress local=_channel.getLocalAddress();
805 return local.getPort();
806 }
807
808
809
810
811
812 @Override
813 public String getMethod()
814 {
815 return _httpMethodString;
816 }
817
818
819
820
821
822 @Override
823 public String getParameter(String name)
824 {
825 if (!_paramsExtracted)
826 extractParameters();
827 if (_parameters == null)
828 _parameters = restoreParameters();
829 return _parameters.getValue(name,0);
830 }
831
832
833
834
835
836 @Override
837 public Map<String, String[]> getParameterMap()
838 {
839 if (!_paramsExtracted)
840 extractParameters();
841 if (_parameters == null)
842 _parameters = restoreParameters();
843 return Collections.unmodifiableMap(_parameters.toStringArrayMap());
844 }
845
846
847
848
849
850 @Override
851 public Enumeration<String> getParameterNames()
852 {
853 if (!_paramsExtracted)
854 extractParameters();
855 if (_parameters == null)
856 _parameters = restoreParameters();
857 return Collections.enumeration(_parameters.keySet());
858 }
859
860
861
862
863
864 @Override
865 public String[] getParameterValues(String name)
866 {
867 if (!_paramsExtracted)
868 extractParameters();
869 if (_parameters == null)
870 _parameters = restoreParameters();
871 List<String> vals = _parameters.getValues(name);
872 if (vals == null)
873 return null;
874 return vals.toArray(new String[vals.size()]);
875 }
876
877 private MultiMap<String> restoreParameters()
878 {
879 MultiMap<String> result = new MultiMap<>();
880 if (_queryParameters == null)
881 _queryParameters = extractQueryParameters();
882 result.addAllValues(_queryParameters);
883 result.addAllValues(_contentParameters);
884 return result;
885 }
886
887 public MultiMap<String> getQueryParameters()
888 {
889 return _queryParameters;
890 }
891
892 public void setQueryParameters(MultiMap<String> queryParameters)
893 {
894 _queryParameters = queryParameters;
895 }
896
897 public void setContentParameters(MultiMap<String> contentParameters)
898 {
899 _contentParameters = contentParameters;
900 }
901
902 public void resetParameters()
903 {
904 _parameters = null;
905 }
906
907
908
909
910
911 @Override
912 public String getPathInfo()
913 {
914 return _pathInfo;
915 }
916
917
918
919
920
921 @Override
922 public String getPathTranslated()
923 {
924 if (_pathInfo == null || _context == null)
925 return null;
926 return _context.getRealPath(_pathInfo);
927 }
928
929
930
931
932
933 @Override
934 public String getProtocol()
935 {
936 return _httpVersion.toString();
937 }
938
939
940
941
942
943 public HttpVersion getHttpVersion()
944 {
945 return _httpVersion;
946 }
947
948
949 public String getQueryEncoding()
950 {
951 return _queryEncoding;
952 }
953
954
955
956
957
958 @Override
959 public String getQueryString()
960 {
961 if (_queryString == null && _uri != null)
962 {
963 if (_queryEncoding == null)
964 _queryString = _uri.getQuery();
965 else
966 _queryString = _uri.getQuery(_queryEncoding);
967 }
968 return _queryString;
969 }
970
971
972
973
974
975 @Override
976 public BufferedReader getReader() throws IOException
977 {
978 if (_inputState != __NONE && _inputState != __READER)
979 throw new IllegalStateException("STREAMED");
980
981 if (_inputState == __READER)
982 return _reader;
983
984 String encoding = getCharacterEncoding();
985 if (encoding == null)
986 encoding = StringUtil.__ISO_8859_1;
987
988 if (_reader == null || !encoding.equalsIgnoreCase(_readerEncoding))
989 {
990 final ServletInputStream in = getInputStream();
991 _readerEncoding = encoding;
992 _reader = new BufferedReader(new InputStreamReader(in,encoding))
993 {
994 @Override
995 public void close() throws IOException
996 {
997 in.close();
998 }
999 };
1000 }
1001 _inputState = __READER;
1002 return _reader;
1003 }
1004
1005
1006
1007
1008
1009 @Override
1010 public String getRealPath(String path)
1011 {
1012 if (_context == null)
1013 return null;
1014 return _context.getRealPath(path);
1015 }
1016
1017
1018
1019
1020
1021
1022
1023
1024 public InetSocketAddress getRemoteInetSocketAddress()
1025 {
1026 InetSocketAddress remote = _remote;
1027 if (remote == null)
1028 remote = _channel.getRemoteAddress();
1029
1030 return remote;
1031 }
1032
1033
1034
1035
1036
1037 @Override
1038 public String getRemoteAddr()
1039 {
1040 InetSocketAddress remote=_remote;
1041 if (remote==null)
1042 remote=_channel.getRemoteAddress();
1043
1044 if (remote==null)
1045 return "";
1046
1047 InetAddress address = remote.getAddress();
1048 if (address==null)
1049 return remote.getHostString();
1050
1051 return address.getHostAddress();
1052 }
1053
1054
1055
1056
1057
1058 @Override
1059 public String getRemoteHost()
1060 {
1061 InetSocketAddress remote=_remote;
1062 if (remote==null)
1063 remote=_channel.getRemoteAddress();
1064 return remote==null?"":remote.getHostString();
1065 }
1066
1067
1068
1069
1070
1071 @Override
1072 public int getRemotePort()
1073 {
1074 InetSocketAddress remote=_remote;
1075 if (remote==null)
1076 remote=_channel.getRemoteAddress();
1077 return remote==null?0:remote.getPort();
1078 }
1079
1080
1081
1082
1083
1084 @Override
1085 public String getRemoteUser()
1086 {
1087 Principal p = getUserPrincipal();
1088 if (p == null)
1089 return null;
1090 return p.getName();
1091 }
1092
1093
1094
1095
1096
1097 @Override
1098 public RequestDispatcher getRequestDispatcher(String path)
1099 {
1100 if (path == null || _context == null)
1101 return null;
1102
1103
1104 if (!path.startsWith("/"))
1105 {
1106 String relTo = URIUtil.addPaths(_servletPath,_pathInfo);
1107 int slash = relTo.lastIndexOf("/");
1108 if (slash > 1)
1109 relTo = relTo.substring(0,slash + 1);
1110 else
1111 relTo = "/";
1112 path = URIUtil.addPaths(relTo,path);
1113 }
1114
1115 return _context.getRequestDispatcher(path);
1116 }
1117
1118
1119
1120
1121
1122 @Override
1123 public String getRequestedSessionId()
1124 {
1125 return _requestedSessionId;
1126 }
1127
1128
1129
1130
1131
1132 @Override
1133 public String getRequestURI()
1134 {
1135 if (_requestURI == null && _uri != null)
1136 _requestURI = _uri.getPathAndParam();
1137 return _requestURI;
1138 }
1139
1140
1141
1142
1143
1144 @Override
1145 public StringBuffer getRequestURL()
1146 {
1147 final StringBuffer url = new StringBuffer(128);
1148 URIUtil.appendSchemeHostPort(url,getScheme(),getServerName(),getServerPort());
1149 url.append(getRequestURI());
1150 return url;
1151 }
1152
1153
1154 public Response getResponse()
1155 {
1156 return _channel.getResponse();
1157 }
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170 public StringBuilder getRootURL()
1171 {
1172 StringBuilder url = new StringBuilder(128);
1173 URIUtil.appendSchemeHostPort(url,getScheme(),getServerName(),getServerPort());
1174 return url;
1175 }
1176
1177
1178
1179
1180
1181 @Override
1182 public String getScheme()
1183 {
1184 return _scheme;
1185 }
1186
1187
1188
1189
1190
1191 @Override
1192 public String getServerName()
1193 {
1194
1195 if (_serverName != null)
1196 return _serverName;
1197
1198 if (_uri == null)
1199 throw new IllegalStateException("No uri");
1200
1201
1202 _serverName = _uri.getHost();
1203 if (_serverName != null)
1204 {
1205 _port = _uri.getPort();
1206 return _serverName;
1207 }
1208
1209
1210 String hostPort = _fields.getStringField(HttpHeader.HOST);
1211
1212 _port=0;
1213 if (hostPort != null)
1214 {
1215 int len=hostPort.length();
1216 loop: for (int i = len; i-- > 0;)
1217 {
1218 char c2 = (char)(0xff & hostPort.charAt(i));
1219 switch (c2)
1220 {
1221 case ']':
1222 break loop;
1223
1224 case ':':
1225 try
1226 {
1227 len=i;
1228 _port = StringUtil.toInt(hostPort.substring(i+1));
1229 }
1230 catch (NumberFormatException e)
1231 {
1232 LOG.warn(e);
1233 _serverName=hostPort;
1234 _port=0;
1235 return _serverName;
1236 }
1237 break loop;
1238 }
1239 }
1240 if (hostPort.charAt(0)=='[')
1241 {
1242 if (hostPort.charAt(len-1)!=']')
1243 {
1244 LOG.warn("Bad IPv6 "+hostPort);
1245 _serverName=hostPort;
1246 _port=0;
1247 return _serverName;
1248 }
1249 _serverName = hostPort.substring(0,len);
1250 }
1251 else if (len==hostPort.length())
1252 _serverName=hostPort;
1253 else
1254 _serverName = hostPort.substring(0,len);
1255
1256 return _serverName;
1257 }
1258
1259
1260 if (_channel != null)
1261 {
1262 _serverName = getLocalName();
1263 _port = getLocalPort();
1264 if (_serverName != null && !StringUtil.ALL_INTERFACES.equals(_serverName))
1265 return _serverName;
1266 }
1267
1268
1269 try
1270 {
1271 _serverName = InetAddress.getLocalHost().getHostAddress();
1272 }
1273 catch (java.net.UnknownHostException e)
1274 {
1275 LOG.ignore(e);
1276 }
1277 return _serverName;
1278 }
1279
1280
1281
1282
1283
1284 @Override
1285 public int getServerPort()
1286 {
1287 if (_port <= 0)
1288 {
1289 if (_serverName == null)
1290 getServerName();
1291
1292 if (_port <= 0)
1293 {
1294 if (_serverName != null && _uri != null)
1295 _port = _uri.getPort();
1296 else
1297 {
1298 InetSocketAddress local = _channel.getLocalAddress();
1299 _port = local == null?0:local.getPort();
1300 }
1301 }
1302 }
1303
1304 if (_port <= 0)
1305 {
1306 if (getScheme().equalsIgnoreCase(URIUtil.HTTPS))
1307 return 443;
1308 return 80;
1309 }
1310 return _port;
1311 }
1312
1313
1314 @Override
1315 public ServletContext getServletContext()
1316 {
1317 return _context;
1318 }
1319
1320
1321
1322
1323 public String getServletName()
1324 {
1325 if (_scope != null)
1326 return _scope.getName();
1327 return null;
1328 }
1329
1330
1331
1332
1333
1334 @Override
1335 public String getServletPath()
1336 {
1337 if (_servletPath == null)
1338 _servletPath = "";
1339 return _servletPath;
1340 }
1341
1342
1343 public ServletResponse getServletResponse()
1344 {
1345 return _channel.getResponse();
1346 }
1347
1348
1349
1350
1351
1352 public String changeSessionId()
1353 {
1354 HttpSession session = getSession(false);
1355 if (session == null)
1356 throw new IllegalStateException("No session");
1357
1358 if (session instanceof AbstractSession)
1359 {
1360 AbstractSession abstractSession = ((AbstractSession)session);
1361 abstractSession.renewId(this);
1362 if (getRemoteUser() != null)
1363 abstractSession.setAttribute(AbstractSession.SESSION_KNOWN_ONLY_TO_AUTHENTICATED, Boolean.TRUE);
1364 if (abstractSession.isIdChanged())
1365 _channel.getResponse().addCookie(_sessionManager.getSessionCookie(abstractSession, getContextPath(), isSecure()));
1366 }
1367
1368 return session.getId();
1369 }
1370
1371
1372
1373
1374
1375 @Override
1376 public HttpSession getSession()
1377 {
1378 return getSession(true);
1379 }
1380
1381
1382
1383
1384
1385 @Override
1386 public HttpSession getSession(boolean create)
1387 {
1388 if (_session != null)
1389 {
1390 if (_sessionManager != null && !_sessionManager.isValid(_session))
1391 _session = null;
1392 else
1393 return _session;
1394 }
1395
1396 if (!create)
1397 return null;
1398
1399 if (getResponse().isCommitted())
1400 throw new IllegalStateException("Response is committed");
1401
1402 if (_sessionManager == null)
1403 throw new IllegalStateException("No SessionManager");
1404
1405 _session = _sessionManager.newHttpSession(this);
1406 HttpCookie cookie = _sessionManager.getSessionCookie(_session,getContextPath(),isSecure());
1407 if (cookie != null)
1408 _channel.getResponse().addCookie(cookie);
1409
1410 return _session;
1411 }
1412
1413
1414
1415
1416
1417 public SessionManager getSessionManager()
1418 {
1419 return _sessionManager;
1420 }
1421
1422
1423
1424
1425
1426
1427
1428 public long getTimeStamp()
1429 {
1430 return _timeStamp;
1431 }
1432
1433
1434
1435
1436
1437 public HttpURI getUri()
1438 {
1439 return _uri;
1440 }
1441
1442
1443 public UserIdentity getUserIdentity()
1444 {
1445 if (_authentication instanceof Authentication.Deferred)
1446 setAuthentication(((Authentication.Deferred)_authentication).authenticate(this));
1447
1448 if (_authentication instanceof Authentication.User)
1449 return ((Authentication.User)_authentication).getUserIdentity();
1450 return null;
1451 }
1452
1453
1454
1455
1456
1457
1458 public UserIdentity getResolvedUserIdentity()
1459 {
1460 if (_authentication instanceof Authentication.User)
1461 return ((Authentication.User)_authentication).getUserIdentity();
1462 return null;
1463 }
1464
1465
1466 public UserIdentity.Scope getUserIdentityScope()
1467 {
1468 return _scope;
1469 }
1470
1471
1472
1473
1474
1475 @Override
1476 public Principal getUserPrincipal()
1477 {
1478 if (_authentication instanceof Authentication.Deferred)
1479 setAuthentication(((Authentication.Deferred)_authentication).authenticate(this));
1480
1481 if (_authentication instanceof Authentication.User)
1482 {
1483 UserIdentity user = ((Authentication.User)_authentication).getUserIdentity();
1484 return user.getUserPrincipal();
1485 }
1486
1487 return null;
1488 }
1489
1490
1491
1492 public boolean isHandled()
1493 {
1494 return _handled;
1495 }
1496
1497 @Override
1498 public boolean isAsyncStarted()
1499 {
1500 return getHttpChannelState().isAsyncStarted();
1501 }
1502
1503
1504
1505 @Override
1506 public boolean isAsyncSupported()
1507 {
1508 return _asyncSupported;
1509 }
1510
1511
1512
1513
1514
1515 @Override
1516 public boolean isRequestedSessionIdFromCookie()
1517 {
1518 return _requestedSessionId != null && _requestedSessionIdFromCookie;
1519 }
1520
1521
1522
1523
1524
1525 @Override
1526 public boolean isRequestedSessionIdFromUrl()
1527 {
1528 return _requestedSessionId != null && !_requestedSessionIdFromCookie;
1529 }
1530
1531
1532
1533
1534
1535 @Override
1536 public boolean isRequestedSessionIdFromURL()
1537 {
1538 return _requestedSessionId != null && !_requestedSessionIdFromCookie;
1539 }
1540
1541
1542
1543
1544
1545 @Override
1546 public boolean isRequestedSessionIdValid()
1547 {
1548 if (_requestedSessionId == null)
1549 return false;
1550
1551 HttpSession session = getSession(false);
1552 return (session != null && _sessionManager.getSessionIdManager().getClusterId(_requestedSessionId).equals(_sessionManager.getClusterId(session)));
1553 }
1554
1555
1556
1557
1558
1559 @Override
1560 public boolean isSecure()
1561 {
1562 return _secure;
1563 }
1564
1565
1566 public void setSecure(boolean secure)
1567 {
1568 _secure=secure;
1569 }
1570
1571
1572
1573
1574
1575 @Override
1576 public boolean isUserInRole(String role)
1577 {
1578 if (_authentication instanceof Authentication.Deferred)
1579 setAuthentication(((Authentication.Deferred)_authentication).authenticate(this));
1580
1581 if (_authentication instanceof Authentication.User)
1582 return ((Authentication.User)_authentication).isUserInRole(_scope,role);
1583 return false;
1584 }
1585
1586
1587 public HttpSession recoverNewSession(Object key)
1588 {
1589 if (_savedNewSessions == null)
1590 return null;
1591 return _savedNewSessions.get(key);
1592 }
1593
1594
1595 protected void recycle()
1596 {
1597 if (_context != null)
1598 throw new IllegalStateException("Request in context!");
1599
1600 if (_inputState == __READER)
1601 {
1602 try
1603 {
1604 int r = _reader.read();
1605 while (r != -1)
1606 r = _reader.read();
1607 }
1608 catch (Exception e)
1609 {
1610 LOG.ignore(e);
1611 _reader = null;
1612 }
1613 }
1614
1615 _dispatcherType=null;
1616 setAuthentication(Authentication.NOT_CHECKED);
1617 getHttpChannelState().recycle();
1618 if (_async!=null)
1619 _async.reset();
1620 _async=null;
1621 _asyncSupported = true;
1622 _handled = false;
1623 if (_attributes != null)
1624 _attributes.clearAttributes();
1625 _characterEncoding = null;
1626 _contextPath = null;
1627 if (_cookies != null)
1628 _cookies.reset();
1629 _cookiesExtracted = false;
1630 _context = null;
1631 _newContext=false;
1632 _serverName = null;
1633 _httpMethod=null;
1634 _httpMethodString = null;
1635 _pathInfo = null;
1636 _port = 0;
1637 _httpVersion = HttpVersion.HTTP_1_1;
1638 _queryEncoding = null;
1639 _queryString = null;
1640 _requestedSessionId = null;
1641 _requestedSessionIdFromCookie = false;
1642 _secure=false;
1643 _session = null;
1644 _sessionManager = null;
1645 _requestURI = null;
1646 _scope = null;
1647 _scheme = URIUtil.HTTP;
1648 _servletPath = null;
1649 _timeStamp = 0;
1650 _uri = null;
1651 _queryParameters = null;
1652 _contentParameters = null;
1653 _parameters = null;
1654 _paramsExtracted = false;
1655 _inputState = __NONE;
1656
1657 if (_savedNewSessions != null)
1658 _savedNewSessions.clear();
1659 _savedNewSessions=null;
1660 _multiPartInputStream = null;
1661 _remote=null;
1662 _fields.clear();
1663 _input.recycle();
1664 }
1665
1666
1667
1668
1669
1670 @Override
1671 public void removeAttribute(String name)
1672 {
1673 Object old_value = _attributes == null?null:_attributes.getAttribute(name);
1674
1675 if (_attributes != null)
1676 _attributes.removeAttribute(name);
1677
1678 if (old_value != null && !_requestAttributeListeners.isEmpty())
1679 {
1680 final ServletRequestAttributeEvent event = new ServletRequestAttributeEvent(_context,this,name,old_value);
1681 for (ServletRequestAttributeListener listener : _requestAttributeListeners)
1682 listener.attributeRemoved(event);
1683 }
1684 }
1685
1686
1687 public void removeEventListener(final EventListener listener)
1688 {
1689 _requestAttributeListeners.remove(listener);
1690 }
1691
1692
1693 public void saveNewSession(Object key, HttpSession session)
1694 {
1695 if (_savedNewSessions == null)
1696 _savedNewSessions = new HashMap<>();
1697 _savedNewSessions.put(key,session);
1698 }
1699
1700
1701 public void setAsyncSupported(boolean supported)
1702 {
1703 _asyncSupported = supported;
1704 }
1705
1706
1707
1708
1709
1710
1711
1712
1713 @Override
1714 public void setAttribute(String name, Object value)
1715 {
1716 Object old_value = _attributes == null?null:_attributes.getAttribute(name);
1717
1718 if ("org.eclipse.jetty.server.Request.queryEncoding".equals(name))
1719 setQueryEncoding(value == null?null:value.toString());
1720 else if ("org.eclipse.jetty.server.sendContent".equals(name))
1721 LOG.warn("Deprecated: org.eclipse.jetty.server.sendContent");
1722
1723 if (_attributes == null)
1724 _attributes = new AttributesMap();
1725 _attributes.setAttribute(name,value);
1726
1727 if (!_requestAttributeListeners.isEmpty())
1728 {
1729 final ServletRequestAttributeEvent event = new ServletRequestAttributeEvent(_context,this,name,old_value == null?value:old_value);
1730 for (ServletRequestAttributeListener l : _requestAttributeListeners)
1731 {
1732 if (old_value == null)
1733 l.attributeAdded(event);
1734 else if (value == null)
1735 l.attributeRemoved(event);
1736 else
1737 l.attributeReplaced(event);
1738 }
1739 }
1740 }
1741
1742
1743
1744
1745 public void setAttributes(Attributes attributes)
1746 {
1747 _attributes = attributes;
1748 }
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759 public void setAuthentication(Authentication authentication)
1760 {
1761 _authentication = authentication;
1762 }
1763
1764
1765
1766
1767
1768 @Override
1769 public void setCharacterEncoding(String encoding) throws UnsupportedEncodingException
1770 {
1771 if (_inputState != __NONE)
1772 return;
1773
1774 _characterEncoding = encoding;
1775
1776
1777 if (!StringUtil.isUTF8(encoding))
1778 {
1779 try
1780 {
1781 Charset.forName(encoding);
1782 }
1783 catch (UnsupportedCharsetException e)
1784 {
1785 throw new UnsupportedEncodingException(e.getMessage());
1786 }
1787 }
1788 }
1789
1790
1791
1792
1793
1794 public void setCharacterEncodingUnchecked(String encoding)
1795 {
1796 _characterEncoding = encoding;
1797 }
1798
1799
1800
1801
1802
1803 public void setContentType(String contentType)
1804 {
1805 _fields.put(HttpHeader.CONTENT_TYPE,contentType);
1806
1807 }
1808
1809
1810
1811
1812
1813
1814
1815
1816 public void setContext(Context context)
1817 {
1818 _newContext = _context != context;
1819 _context = context;
1820 }
1821
1822
1823
1824
1825
1826
1827 public boolean takeNewContext()
1828 {
1829 boolean nc = _newContext;
1830 _newContext = false;
1831 return nc;
1832 }
1833
1834
1835
1836
1837
1838
1839
1840 public void setContextPath(String contextPath)
1841 {
1842 _contextPath = contextPath;
1843 }
1844
1845
1846
1847
1848
1849
1850 public void setCookies(Cookie[] cookies)
1851 {
1852 if (_cookies == null)
1853 _cookies = new CookieCutter();
1854 _cookies.setCookies(cookies);
1855 }
1856
1857
1858 public void setDispatcherType(DispatcherType type)
1859 {
1860 _dispatcherType = type;
1861 }
1862
1863
1864 public void setHandled(boolean h)
1865 {
1866 _handled = h;
1867 }
1868
1869
1870
1871
1872
1873
1874 public void setMethod(HttpMethod httpMethod, String method)
1875 {
1876 _httpMethod=httpMethod;
1877 _httpMethodString = method;
1878 }
1879
1880
1881 public boolean isHead()
1882 {
1883 return HttpMethod.HEAD==_httpMethod;
1884 }
1885
1886
1887
1888
1889
1890
1891 public void setPathInfo(String pathInfo)
1892 {
1893 _pathInfo = pathInfo;
1894 }
1895
1896
1897
1898
1899
1900
1901 public void setHttpVersion(HttpVersion version)
1902 {
1903 _httpVersion = version;
1904 }
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915 public void setQueryEncoding(String queryEncoding)
1916 {
1917 _queryEncoding = queryEncoding;
1918 _queryString = null;
1919 }
1920
1921
1922
1923
1924
1925
1926 public void setQueryString(String queryString)
1927 {
1928 _queryString = queryString;
1929 _queryEncoding = null;
1930 }
1931
1932
1933
1934
1935
1936
1937 public void setRemoteAddr(InetSocketAddress addr)
1938 {
1939 _remote = addr;
1940 }
1941
1942
1943
1944
1945
1946
1947 public void setRequestedSessionId(String requestedSessionId)
1948 {
1949 _requestedSessionId = requestedSessionId;
1950 }
1951
1952
1953
1954
1955
1956
1957 public void setRequestedSessionIdFromCookie(boolean requestedSessionIdCookie)
1958 {
1959 _requestedSessionIdFromCookie = requestedSessionIdCookie;
1960 }
1961
1962
1963
1964
1965
1966
1967 public void setRequestURI(String requestURI)
1968 {
1969 _requestURI = requestURI;
1970 }
1971
1972
1973
1974
1975
1976
1977 public void setScheme(String scheme)
1978 {
1979 _scheme = scheme;
1980 }
1981
1982
1983
1984
1985
1986
1987 public void setServerName(String host)
1988 {
1989 _serverName = host;
1990 }
1991
1992
1993
1994
1995
1996
1997 public void setServerPort(int port)
1998 {
1999 _port = port;
2000 }
2001
2002
2003
2004
2005
2006
2007 public void setServletPath(String servletPath)
2008 {
2009 _servletPath = servletPath;
2010 }
2011
2012
2013
2014
2015
2016
2017 public void setSession(HttpSession session)
2018 {
2019 _session = session;
2020 }
2021
2022
2023
2024
2025
2026
2027 public void setSessionManager(SessionManager sessionManager)
2028 {
2029 _sessionManager = sessionManager;
2030 }
2031
2032
2033 public void setTimeStamp(long ts)
2034 {
2035 _timeStamp = ts;
2036 }
2037
2038
2039
2040
2041
2042
2043 public void setUri(HttpURI uri)
2044 {
2045 _uri = uri;
2046 }
2047
2048
2049 public void setUserIdentityScope(UserIdentity.Scope scope)
2050 {
2051 _scope = scope;
2052 }
2053
2054
2055 @Override
2056 public AsyncContext startAsync() throws IllegalStateException
2057 {
2058 if (!_asyncSupported)
2059 throw new IllegalStateException("!asyncSupported");
2060 HttpChannelState state = getHttpChannelState();
2061 if (_async==null)
2062 _async=new AsyncContextState(state);
2063 AsyncContextEvent event = new AsyncContextEvent(_context,_async,state,this,this,getResponse());
2064 state.startAsync(event);
2065 return _async;
2066 }
2067
2068
2069 @Override
2070 public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException
2071 {
2072 if (!_asyncSupported)
2073 throw new IllegalStateException("!asyncSupported");
2074 HttpChannelState state = getHttpChannelState();
2075 if (_async==null)
2076 _async=new AsyncContextState(state);
2077 AsyncContextEvent event = new AsyncContextEvent(_context,_async,state,this,servletRequest,servletResponse);
2078 event.setDispatchContext(getServletContext());
2079 event.setDispatchPath(URIUtil.addPaths(getServletPath(),getPathInfo()));
2080 state.startAsync(event);
2081 return _async;
2082 }
2083
2084
2085 @Override
2086 public String toString()
2087 {
2088 return String.format("%s%s%s %s%s@%x",
2089 getClass().getSimpleName(),
2090 _handled ? "[" : "(",
2091 getMethod(),
2092 _uri,
2093 _handled ? "]" : ")",
2094 hashCode());
2095 }
2096
2097
2098 @Override
2099 public boolean authenticate(HttpServletResponse response) throws IOException, ServletException
2100 {
2101 if (_authentication instanceof Authentication.Deferred)
2102 {
2103 setAuthentication(((Authentication.Deferred)_authentication).authenticate(this,response));
2104 return !(_authentication instanceof Authentication.ResponseSent);
2105 }
2106 response.sendError(HttpStatus.UNAUTHORIZED_401);
2107 return false;
2108 }
2109
2110
2111 @Override
2112 public Part getPart(String name) throws IOException, ServletException
2113 {
2114 getParts();
2115
2116 return _multiPartInputStream.getPart(name);
2117 }
2118
2119
2120 @Override
2121 public Collection<Part> getParts() throws IOException, ServletException
2122 {
2123 if (getContentType() == null || !getContentType().startsWith("multipart/form-data"))
2124 throw new ServletException("Content-Type != multipart/form-data");
2125 return getParts(null);
2126 }
2127
2128 private Collection<Part> getParts(MultiMap<String> params) throws IOException, ServletException
2129 {
2130 if (_multiPartInputStream == null)
2131 _multiPartInputStream = (MultiPartInputStreamParser)getAttribute(__MULTIPART_INPUT_STREAM);
2132
2133 if (_multiPartInputStream == null)
2134 {
2135 MultipartConfigElement config = (MultipartConfigElement)getAttribute(__MULTIPART_CONFIG_ELEMENT);
2136
2137 if (config == null)
2138 throw new IllegalStateException("No multipart config for servlet");
2139
2140 _multiPartInputStream = new MultiPartInputStreamParser(getInputStream(),
2141 getContentType(), config,
2142 (_context != null?(File)_context.getAttribute("javax.servlet.context.tempdir"):null));
2143
2144 setAttribute(__MULTIPART_INPUT_STREAM, _multiPartInputStream);
2145 setAttribute(__MULTIPART_CONTEXT, _context);
2146 Collection<Part> parts = _multiPartInputStream.getParts();
2147 ByteArrayOutputStream os = null;
2148 for (Part p:parts)
2149 {
2150 MultiPartInputStreamParser.MultiPart mp = (MultiPartInputStreamParser.MultiPart)p;
2151 if (mp.getContentDispositionFilename() == null)
2152 {
2153
2154 String charset = null;
2155 if (mp.getContentType() != null)
2156 charset = MimeTypes.getCharsetFromContentType(mp.getContentType());
2157
2158 try (InputStream is = mp.getInputStream())
2159 {
2160 if (os == null)
2161 os = new ByteArrayOutputStream();
2162 IO.copy(is, os);
2163 String content=new String(os.toByteArray(),charset==null?StandardCharsets.UTF_8:Charset.forName(charset));
2164 if (_contentParameters == null)
2165 _contentParameters = params == null ? new MultiMap<String>() : params;
2166 _contentParameters.add(mp.getName(), content);
2167 }
2168 os.reset();
2169 }
2170 }
2171 }
2172
2173 return _multiPartInputStream.getParts();
2174 }
2175
2176
2177 @Override
2178 public void login(String username, String password) throws ServletException
2179 {
2180 if (_authentication instanceof Authentication.Deferred)
2181 {
2182 _authentication=((Authentication.Deferred)_authentication).login(username,password,this);
2183 if (_authentication == null)
2184 throw new Authentication.Failed("Authentication failed for username '"+username+"'");
2185 }
2186 else
2187 {
2188 throw new Authentication.Failed("Authenticated failed for username '"+username+"'. Already authenticated as "+_authentication);
2189 }
2190 }
2191
2192
2193 @Override
2194 public void logout() throws ServletException
2195 {
2196 if (_authentication instanceof Authentication.User)
2197 ((Authentication.User)_authentication).logout();
2198 _authentication=Authentication.UNAUTHENTICATED;
2199 }
2200
2201 public void mergeQueryParameters(String newQuery, boolean updateQueryString)
2202 {
2203 MultiMap<String> newQueryParams = new MultiMap<>();
2204
2205 UrlEncoded.decodeTo(newQuery, newQueryParams, UrlEncoded.ENCODING, -1);
2206
2207 MultiMap<String> oldQueryParams = _queryParameters;
2208 if (oldQueryParams == null && _queryString != null)
2209 {
2210 oldQueryParams = new MultiMap<>();
2211 UrlEncoded.decodeTo(_queryString, oldQueryParams, getQueryEncoding(), -1);
2212 }
2213
2214 MultiMap<String> mergedQueryParams = newQueryParams;
2215 if (oldQueryParams != null)
2216 {
2217
2218 mergedQueryParams = new MultiMap<>(newQueryParams);
2219 mergedQueryParams.addAllValues(oldQueryParams);
2220 }
2221
2222 setQueryParameters(mergedQueryParams);
2223 resetParameters();
2224
2225 if (updateQueryString)
2226 {
2227
2228
2229 StringBuilder mergedQuery = new StringBuilder(newQuery);
2230 for (Map.Entry<String, List<String>> entry : mergedQueryParams.entrySet())
2231 {
2232 if (newQueryParams.containsKey(entry.getKey()))
2233 continue;
2234 for (String value : entry.getValue())
2235 mergedQuery.append("&").append(entry.getKey()).append("=").append(value);
2236 }
2237
2238 setQueryString(mergedQuery.toString());
2239 }
2240 }
2241
2242
2243
2244
2245 @Override
2246 public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException
2247 {
2248 if (getContext() == null)
2249 throw new ServletException ("Unable to instantiate "+handlerClass);
2250
2251 try
2252 {
2253
2254 T h = getContext().createInstance(handlerClass);
2255
2256
2257
2258 return h;
2259 }
2260 catch (Exception e)
2261 {
2262 if (e instanceof ServletException)
2263 throw (ServletException)e;
2264 throw new ServletException(e);
2265 }
2266 }
2267 }