utils/webseal-simulator/src/main/java/org/openecomp/sdc/webseal/simulator/SdcProxy.java

   1 package org.openecomp.sdc.webseal.simulator;
   2
   3 import org.apache.commons.httpclient.Header;
   4 import org.apache.commons.httpclient.HttpClient;
   5 import org.apache.commons.httpclient.HttpException;
   6 import org.apache.commons.httpclient.HttpMethodBase;
   7 import org.apache.commons.httpclient.methods.*;
   8 import org.apache.commons.httpclient.protocol.Protocol;
   9 import org.openecomp.sdc.webseal.simulator.SSL.DummySSLProtocolSocketFactory;
  10 import org.openecomp.sdc.webseal.simulator.conf.Conf;
  11
  12 import javax.net.ssl.X509TrustManager;
  13 import javax.servlet.RequestDispatcher;
  14 import javax.servlet.ServletConfig;
  15 import javax.servlet.ServletException;
  16 import javax.servlet.http.Cookie;
  17 import javax.servlet.http.HttpServlet;
  18 import javax.servlet.http.HttpServletRequest;
  19 import javax.servlet.http.HttpServletResponse;
  20 import java.io.*;
  21 import java.net.MalformedURLException;
  22 import java.net.URL;
  23 import java.net.URLEncoder;
  24 import java.security.cert.CertificateException;
  25 import java.security.cert.X509Certificate;
  26 import java.util.ArrayList;
  27 import java.util.Enumeration;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.zip.GZIPInputStream;
  31
  32 public class SdcProxy extends HttpServlet {
  33
  34         private static final long serialVersionUID = 1L;
  35         private URL url;
  36         private HttpClient proxy;
  37         private Conf conf;
  38
  39         private final String SDC1 = "/sdc1";
  40         private final String ONBOARDING = "/onboarding/";
  41         private final String SCRIPTS = "/scripts";
  42         private final String STYLES = "/styles";
  43         private final String LANGUAGES = "/languages";
  44         private final String CONFIGURATIONS = "/configurations";
  45
  46         public void init(ServletConfig config) throws ServletException {
  47                 super.init(config);
  48                 conf = Conf.getInstance();
  49                 try {
  50                         String feHost = conf.getFeHost();
  51                         this.url = new URL(feHost);
  52                 } catch (MalformedURLException me) {
  53                         throw new ServletException("Proxy URL is invalid", me);
  54                 }
  55                 // Set up an HTTPS socket factory that accepts self-signed certs.
  56                 Protocol https = new Protocol("https",
  57                                 new DummySSLProtocolSocketFactory(), 9443);
  58                 Protocol.registerProtocol("https", https);
  59
  60                 this.proxy = new HttpClient();
  61                 this.proxy.getHostConfiguration().setHost(this.url.getHost());
  62
  63
  64
  65         }
  66
  67         protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  68                 proxy(request, response, MethodEnum.GET);
  69         }
  70
  71         public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  72
  73                 String userId = request.getParameter("userId");
  74                 String password = request.getParameter("password");
  75
  76                 // Already sign-in
  77                 if (userId == null){
  78                         userId = request.getHeader("USER_ID");
  79                 }
  80
  81                 System.out.println("SdcProxy -> doPost userId=" + userId);
  82                 request.setAttribute("message", "OK");
  83                 if (password != null && getUser(userId, password) == null) {
  84                         MutableHttpServletRequest mutableRequest = new MutableHttpServletRequest(request);
  85                         RequestDispatcher view = request.getRequestDispatcher("login");
  86                         request.setAttribute("message", "ERROR: userid or password incorect");
  87                         view.forward(mutableRequest, response);
  88                 } else {
  89                         System.out.println("SdcProxy -> doPost going to doGet");
  90                         request.setAttribute("HTTP_IV_USER", userId);
  91                         proxy(request, response, MethodEnum.POST);
  92                 }
  93         }
  94
  95         public void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  96                 proxy(request, response, MethodEnum.PUT);
  97         }
  98
  99         public void doDelete(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 100                 proxy(request, response, MethodEnum.DELETE);
 101         }
 102
 103         private synchronized void proxy(HttpServletRequest request, HttpServletResponse response, MethodEnum methodEnum) throws IOException, UnsupportedEncodingException, HttpException {
 104                 Map<String, String[]> requestParameters = request.getParameterMap();
 105                 System.out.print(request.getRequestURI() + " -> ");
 106
 107                 String userIdHeader = getUseridFromRequest(request);
 108                 //System.out.print(" (userIdHeader=" + userIdHeader + ") ");
 109                 User user = getUser(userIdHeader);
 110
 111                 // new request - forward to login page
 112                 if (userIdHeader == null) {
 113                         System.out.print("Going to login");
 114                         response.sendRedirect("/login");
 115                         return;
 116                 }
 117
 118                 String uri = getUri(request, requestParameters);
 119                 HttpMethodBase proxyMethod = getMethod(request, methodEnum, uri);
 120                 System.out.println(uri);
 121                 addHeaders(user, proxyMethod);
 122                 addHeaders(request, proxyMethod);
 123                 this.proxy.executeMethod(proxyMethod);
 124                 response.setStatus(proxyMethod.getStatusCode());
 125
 126                 if (request.getRequestURI().indexOf(".svg") > -1) {
 127                         response.setContentType("image/svg+xml");
 128                 }
 129
 130                 InputStream responseBodyStream = proxyMethod.getResponseBodyAsStream();
 131                 Header contentEncodingHeader = proxyMethod.getResponseHeader("Content-Encoding");
 132                 if (contentEncodingHeader != null && contentEncodingHeader.getValue().equalsIgnoreCase("gzip")) {
 133                         responseBodyStream = new GZIPInputStream(responseBodyStream);
 134                 }
 135                 write(responseBodyStream, response.getOutputStream());
 136         }
 137
 138         private void addHeaders(HttpServletRequest request, HttpMethodBase proxyMethod) {
 139                 Enumeration<String> headerNames = request.getHeaderNames();
 140                 while (headerNames.hasMoreElements()) {
 141                         String headerName = headerNames.nextElement();
 142                         Enumeration<String> headers = request.getHeaders(headerName);
 143                         while (headers.hasMoreElements()) {
 144                                 String headerValue = headers.nextElement();
 145                                 proxyMethod.addRequestHeader(headerName, headerValue);
 146                         }
 147                 }
 148         }
 149
 150         private User getUser(String userId, String password) {
 151                 User user = getUser(userId);
 152                 if (user.getPassword().equals(password)) {
 153                         return user;
 154                 }
 155                 return null;
 156         }
 157
 158         private User getUser(String userId) {
 159                 return conf.getUsers().get(userId);
 160
 161         }
 162
 163         private List<String> getContextPaths(){
 164                  List<String> contextPaths = new ArrayList<>();
 165                  contextPaths.add(SDC1);
 166                  contextPaths.add(ONBOARDING);
 167                  contextPaths.add(STYLES);
 168                  contextPaths.add(SCRIPTS);
 169                  contextPaths.add(LANGUAGES);
 170                  contextPaths.add(CONFIGURATIONS);
 171                  return contextPaths;
 172         }
 173
 174         private String getUri(HttpServletRequest request, Map<String, String[]> requestParameters) throws UnsupportedEncodingException {
 175                 String suffix = request.getRequestURI();
 176                 if (getContextPaths().stream().anyMatch(request.getRequestURI()::contains))     {
 177                         suffix = alignUrlProxy(suffix);
 178                 }
 179                 StringBuilder query = alignUrlParameters(requestParameters);
 180                 String uri = String.format("%s%s", new Object[] {this.url.toString() + suffix, query.toString() });
 181                 return uri;
 182         }
 183
 184         private HttpMethodBase getMethod(HttpServletRequest request, MethodEnum methodEnum, String uri) throws IOException {
 185                 HttpMethodBase proxyMethod = null;
 186                 switch (methodEnum) {
 187                 case GET:
 188                         proxyMethod = new GetMethod(uri);
 189                         break;
 190                 case POST:
 191                         proxyMethod = new PostMethod(uri);
 192                         ((PostMethod) proxyMethod).setRequestEntity(new InputStreamRequestEntity(request.getInputStream()));
 193                         break;
 194                 case PUT:
 195                         proxyMethod = new PutMethod(uri);
 196                         ((PutMethod) proxyMethod).setRequestBody(getBody(request));
 197                         break;
 198                 case DELETE:
 199                         proxyMethod = new DeleteMethod(uri);
 200                         break;
 201                 }
 202                 return proxyMethod;
 203         }
 204
 205         private String getUseridFromRequest(HttpServletRequest request) {
 206
 207                 String userIdHeader = request.getHeader("USER_ID");
 208                 if (userIdHeader != null){
 209                         return userIdHeader;
 210                 }
 211                 Object o = request.getAttribute("HTTP_IV_USER");
 212                 if (o != null) {
 213                         return o.toString();
 214                 }
 215                 Cookie[] cookies = request.getCookies();
 216
 217                 if (cookies != null){
 218                         for (int i=0; i<cookies.length; ++i){
 219                                 if (cookies[i].getName().equals("USER_ID")){
 220                                         userIdHeader = cookies[i].getValue();
 221                                 }
 222                         }
 223                 }
 224                 return userIdHeader;
 225         }
 226
 227         private void addHeaders(User user, HttpMethodBase proxyMethod) {
 228                 proxyMethod.addRequestHeader("HTTP_IV_USER", user.getUserId());
 229                 proxyMethod.addRequestHeader("USER_ID", user.getUserId());
 230                 proxyMethod.addRequestHeader("HTTP_CSP_FIRSTNAME", user.getFirstName());
 231                 proxyMethod.addRequestHeader("HTTP_CSP_EMAIL", user.getEmail());
 232                 proxyMethod.addRequestHeader("HTTP_CSP_LASTNAME", user.getLastName());
 233                 proxyMethod.addRequestHeader("HTTP_IV_REMOTE_ADDRESS", "0.0.0.0");
 234                 proxyMethod.addRequestHeader("HTTP_CSP_WSTYPE", "Intranet");
 235                 proxyMethod.addRequestHeader("HTTP_CSP_EMAIL", "me@mail.com");
 236         }
 237
 238         private String alignUrlProxy(String requestURI) {
 239
 240                 int i = requestURI.indexOf(ONBOARDING);
 241                 if (-1 != i){
 242                         return requestURI.substring(i);
 243                 }
 244
 245                 i = requestURI.indexOf(SDC1+SDC1);
 246                 if (-1 != i){
 247                         return requestURI.substring(SDC1.length());
 248                 }
 249
 250                 i = requestURI.indexOf(SDC1);
 251                 if (-1 != i){
 252                         return requestURI;
 253                 }
 254
 255                 return SDC1+requestURI;
 256         }
 257
 258         private StringBuilder alignUrlParameters(Map<String, String[]> requestParameters) throws UnsupportedEncodingException {
 259                 StringBuilder query = new StringBuilder();
 260                 for (String name : requestParameters.keySet()) {
 261                         for (String value : (String[]) requestParameters.get(name)) {
 262                                 if (query.length() == 0) {
 263                                         query.append("?");
 264                                 } else {
 265                                         query.append("&");
 266                                 }
 267                                 name = URLEncoder.encode(name, "UTF-8");
 268                                 value = URLEncoder.encode(value, "UTF-8");
 269
 270                                 query.append(String.format("&%s=%s", new Object[] { name, value }));
 271                         }
 272                 }
 273                 return query;
 274         }
 275
 276         private void write(InputStream inputStream, OutputStream outputStream) throws IOException {
 277                 int b;
 278                 while (inputStream != null && (b = inputStream.read()) != -1) {
 279                         outputStream.write(b);
 280                 }
 281                 outputStream.flush();
 282         }
 283
 284         public String getServletInfo() {
 285                 return "Http Proxy Servlet";
 286         }
 287
 288
 289         public String getBody(HttpServletRequest request) throws IOException {
 290
 291                 String body = null;
 292                 StringBuilder stringBuilder = new StringBuilder();
 293                 BufferedReader bufferedReader = null;
 294
 295                 try {
 296                         InputStream inputStream = request.getInputStream();
 297                         if (inputStream != null) {
 298                                 bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
 299                                 char[] charBuffer = new char[128];
 300                                 int bytesRead = -1;
 301                                 while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
 302                                         stringBuilder.append(charBuffer, 0, bytesRead);
 303                                 }
 304                         } else {
 305                                 stringBuilder.append("");
 306                         }
 307                 } catch (IOException ex) {
 308                         throw ex;
 309                 } finally {
 310                         if (bufferedReader != null) {
 311                                 try {
 312                                         bufferedReader.close();
 313                                 } catch (IOException ex) {
 314                                         throw ex;
 315                                 }
 316                         }
 317                 }
 318
 319                 body = stringBuilder.toString();
 320                 return body;
 321         }
 322
 323         private class DefaultTrustManager implements X509TrustManager {
 324
 325                 @Override
 326                 public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {}
 327
 328                 @Override
 329                 public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {}
 330
 331                 @Override
 332                 public X509Certificate[] getAcceptedIssuers() {
 333                         return null;
 334                 }
 335         }
 336 }