public boolean isAllowed(HttpServletRequest request) {
boolean allowed = hostAcl.shouldAllowAll();
if (!allowed) {
try {
final InetAddress remoteClient = InetAddress.getByName(request.getRemoteHost());
for (InetAddress allowedAddress : hostAcl.getAllowedHosts()) {
if (remoteClient.equals(allowedAddress)) {
allowed = true;
break;
}
}
} catch (UnknownHostException uhe) {
LOG.error(
"Unknown host exception caught while trying to resolve host: "
+ request.getRemoteHost()
+ " Reason: "
+ uhe.getMessage(),
uhe);
}
}
return allowed;
}
@Override
public CashRegister getCashRegister(HttpServletRequest request) {
CashRegister cashRegister = this.cashRegisterRepository.findOne(request.getRemoteHost());
if (cashRegister != null) {
return cashRegister;
}
return this.cashRegisterRepository.save(
new CashRegister(request.getRemoteHost(), request.getRemoteAddr()));
}
/**
* Validate the form.
*
* @param mapping_ The action map from struts-config.xml.
* @param request_ The servlet request object.
* @return ActionErrors when an error is found, otherwise null.
*/
public ActionErrors validate(ActionMapping mapping_, HttpServletRequest request_) {
ActionErrors errors = new ActionErrors();
HttpSession session = request_.getSession();
if (session == null) {
_logger.info("No session exists. [" + this.getClass().getName() + "]");
errors.add("bean", new ActionMessage("error.nobean"));
return errors;
}
AlertBean ub = (AlertBean) session.getAttribute(AlertBean._SESSIONNAME);
if (ub == null) {
_logger.info("No session bean exists. [" + this.getClass().getName() + "]");
errors.add("bean", new ActionMessage("error.nobean"));
return errors;
}
if (!ub.getKey().equals(_sessionKey)) {
_logger.error(
"Sessionkeys do not match. ["
+ ub.getUser()
+ "] ["
+ this.getClass().getName()
+ "] [Page "
+ _sessionKey
+ "] [Bean "
+ ub.getKey()
+ "]");
errors.add("bean", new ActionMessage("error.nobean"));
return errors;
}
if (!ub.checkHost(request_.getRemoteHost())) {
_logger.error(
"Request is made from a host other than the creator. ["
+ ub.getUser()
+ "] ["
+ this.getClass().getName()
+ "] [Creator "
+ ub.getRemoteHost()
+ "] [Requestor "
+ request_.getRemoteHost()
+ "]");
errors.add("bean", new ActionMessage("error.nobean"));
return errors;
}
return validate(mapping_, request_, ub, errors);
}
/**
* Static Service Method for testing spiders against existing spider files.
*
* @param request
* @return true|false if the request was detected to be from a spider.
*/
public static boolean isSpider(HttpServletRequest request) {
return isSpider(
request.getRemoteAddr(),
request.getHeader("X-Forwarded-For"),
request.getRemoteHost(),
request.getHeader("User-Agent"));
}
/**
* 发卡
*
* @author cai.yc 2012-11-20
* @param model
* @param query query.createCount : 生成数量,为必填项目,最大不能超过50000<br>
* query.cityCode : 六位城市代码,如201000<br>
* query.typeCode : 四位类型服务级别代码,如0102表示类型为01,服务级别为02<br>
* @param req
* @param res
* @return 返回"c"含义：<br>
* "A0000" : 成功<br>
* "A0001" : 卡号剩余数量不够<br>
* "A0002" : 输入的发卡数量不合法可能为0,或超过500000<br>
*/
@RequestMapping("/doCreateCard.html")
public String doCreateCardAction(
ModelMap model, CardQueryModel query, HttpServletRequest req, HttpServletResponse res) {
int leftCount = cardBO.cardIdLeft(query);
if (query.getCreateCount() == null) {
model.put("c", "A0003");
} else if (query.getCreateCount() <= 0 || query.getCreateCount() > 500000) {
// 发卡数量不合法
model.put("c", "A0002");
} else if (leftCount < query.getCreateCount()) {
// 剩余数量不足
model.put("c", "A0001");
model.put("d", leftCount);
} else {
// 参数合法,生成卡、激活码
query.setCreateIp(req.getRemoteHost());
query.setCreateUserId((String) req.getSession().getAttribute("MY120_MARKET_LOGIN_USER_INFO"));
int result = cardBO.createCard(query);
model.put("timestamp", query.getGmtCreate());
model.put("cardTypeName", cardTypeBO.getCardTypeName(query.getTypeCode()));
model.put("d", result);
model.put("c", "A0000");
}
return "card/do_create_card.html";
}
public boolean performAction(HttpServletRequest request, ServletContext context)
throws ApplicationException {
try {
if (request.getParameter("yes") != null) {
MugenCaller caller = (MugenCaller) request.getSession().getAttribute("caller");
Workflow wf = (Workflow) request.getAttribute("workflow");
int gaid = new Integer(wf.getAttribute("gaid")).intValue();
modelManager.removeGene(gaid, caller);
projectManager.log(
"user " + caller.getName() + " removed gene " + gaid,
getName(),
caller.getName(),
request.getRemoteAddr(),
request.getRemoteHost());
}
return true;
} catch (ApplicationException e) {
throw e;
} catch (Exception e) {
throw new ApplicationException("RemoveGeneAction Failed To Perform Action", e);
}
}
/**
* Determine the host name that the client targeted with their {@code request}. If {@code
* considerHostHeader} is {@code true}, and a HTTP {@code Host} header is present, the value of
* the header will be used as the host name. If the header is not present, or if {@code
* considerHostHeader} is {@code false}, the host name will be determined using {@link
* javax.servlet.http.HttpServletRequest#getRemoteHost()}. If {@code
* performLocalhostIpTranslation} is {@code true}, and the host name is {@code LOCAL_HOST_IPV4} or
* {@code LOCAL_HOST_IPV6}, then the host name will be set to {@code LOCAL_HOST_NAME}.
*
* @param request the request
* @return the host name targeted by the {@code request}
*/
private String determineHostName(HttpServletRequest request) {
String hostName = null;
// If there is a 'Host' header with the request, and if
// we are supposed to consider it when determining the host name,
// then use it.
// This is the best way to go, because the client is indicating
// what host and port they targeted
final String hostHeader = request.getHeader(HOST_HEADER);
if (considerHostHeader && hostHeader != null && hostHeader.trim().length() != 0) {
hostName = parseHostHeader(hostHeader)[0];
}
// Either the 'Host' header wasn't considered, or parsing it failed for some reason.
// So we fall back on request.getRemoteHost()
if (hostName == null) {
hostName = request.getRemoteHost();
}
if (performLocalhostIpTranslation) {
if (LOCAL_HOST_IPV4.equals(hostName) || LOCAL_HOST_IPV6.equals(hostName)) {
hostName = LOCAL_HOST_NAME;
}
}
return hostName;
}
@RequestMapping(value = "saveRole", method = RequestMethod.POST)
public String save(
@ModelAttribute @Valid RoleDomain roleDomain,
BindingResult bindingResult,
HttpServletRequest request,
HttpSession session) {
if (Strings.isNullOrEmpty(roleDomain.getName())) {
bindingResult.rejectValue("name", "", "角色名称不能为空");
return "";
}
OsRole osRole = new OsRole();
osRole.setName(roleDomain.getName());
osRole.setRemark(roleDomain.getRemark());
iRoleService.save(osRole, roleDomain.getOsPermissions());
String user =
null != session.getAttribute("account")
? String.valueOf(session.getAttribute("account"))
: "admin";
StringBuilder stringBuilder =
new StringBuilder("管理员[")
.append(user)
.append("]")
.append("创建了角色[")
.append(roleDomain.getName())
.append("]");
applicationContext.publishEvent(
new LogEvent(this, stringBuilder.toString(), user, request.getRemoteHost()));
return "redirect:roles";
}
@POST
public Response doPost(@Context HttpServletRequest req) {
if (log.isDebugEnabled())
log.debug(
" ****** (POST) Connected from: " + req.getRemoteAddr() + " " + req.getRemoteHost());
// Read the request
String inputString = "";
try (BufferedReader br = new BufferedReader(new InputStreamReader(req.getInputStream())); ) {
String line;
StringBuffer sb = new StringBuffer();
while ((line = br.readLine()) != null) {
sb.append(line + "\n");
}
br.close();
inputString = sb.toString();
// discard "request="
if (inputString.startsWith("request=")) {
inputString = inputString.substring(8, inputString.length());
inputString = java.net.URLDecoder.decode(inputString, "UTF-8");
}
} catch (Exception e) {
log.error("Exception reading input stream.", e);
}
ISirResponse sirResp = this.requestOperator.doPostOperation(inputString);
return doResponse(sirResp);
}
@Test
public void testInvokeNotAllowedRemoteAddr() throws Exception {
// PREPARE
FilterDef filterDef = new FilterDef();
filterDef.addInitParameter("internalProxies", "192\\.168\\.0\\.10|192\\.168\\.0\\.11");
filterDef.addInitParameter("trustedProxies", "proxy1|proxy2|proxy3");
filterDef.addInitParameter("remoteIpHeader", "x-forwarded-for");
filterDef.addInitParameter("proxiesHeader", "x-forwarded-by");
MockHttpServletRequest request = new MockHttpServletRequest();
request.setRemoteAddr("not-allowed-internal-proxy");
request.setRemoteHost("not-allowed-internal-proxy-host");
request.setHeader("x-forwarded-for", "140.211.11.130, proxy1, proxy2");
// TEST
HttpServletRequest actualRequest = testRemoteIpFilter(filterDef, request);
// VERIFY
String actualXForwardedFor = actualRequest.getHeader("x-forwarded-for");
assertEquals(
"x-forwarded-for must be unchanged", "140.211.11.130, proxy1, proxy2", actualXForwardedFor);
String actualXForwardedBy = actualRequest.getHeader("x-forwarded-by");
assertNull("x-forwarded-by must be null", actualXForwardedBy);
String actualRemoteAddr = actualRequest.getRemoteAddr();
assertEquals("remoteAddr", "not-allowed-internal-proxy", actualRemoteAddr);
String actualRemoteHost = actualRequest.getRemoteHost();
assertEquals("remoteHost", "not-allowed-internal-proxy-host", actualRemoteHost);
}
@Test
public void testInvokeAllProxiesAreInternal() throws Exception {
// PREPARE
FilterDef filterDef = new FilterDef();
filterDef.addInitParameter("internalProxies", "192\\.168\\.0\\.10|192\\.168\\.0\\.11");
filterDef.addInitParameter("trustedProxies", "proxy1|proxy2|proxy3");
filterDef.addInitParameter("remoteIpHeader", "x-forwarded-for");
filterDef.addInitParameter("proxiesHeader", "x-forwarded-by");
MockHttpServletRequest request = new MockHttpServletRequest();
request.setRemoteAddr("192.168.0.10");
request.setRemoteHost("remote-host-original-value");
request.addHeader("x-forwarded-for", "140.211.11.130, 192.168.0.10, 192.168.0.11");
// TEST
HttpServletRequest actualRequest = testRemoteIpFilter(filterDef, request);
// VERIFY
String actualXForwardedFor = actualRequest.getHeader("x-forwarded-for");
assertNull("all proxies are internal, x-forwarded-for must be null", actualXForwardedFor);
String actualXForwardedBy = actualRequest.getHeader("x-forwarded-by");
assertNull("all proxies are internal, x-forwarded-by must be null", actualXForwardedBy);
String actualRemoteAddr = actualRequest.getRemoteAddr();
assertEquals("remoteAddr", "140.211.11.130", actualRemoteAddr);
String actualRemoteHost = actualRequest.getRemoteHost();
assertEquals("remoteHost", "140.211.11.130", actualRemoteHost);
}
@Test
public void testIncomingRequestIsSecuredButProtocolHeaderSaysItIsNotWithDefaultValues()
throws Exception {
// PREPARE
FilterDef filterDef = new FilterDef();
filterDef.addInitParameter("protocolHeader", "x-forwarded-proto");
MockHttpServletRequest request = new MockHttpServletRequest();
request.setRemoteAddr("192.168.0.10");
request.setSecure(true);
request.setScheme("https");
request.setHeader("x-forwarded-for", "140.211.11.130");
request.setHeader("x-forwarded-proto", "http");
// TEST
HttpServletRequest actualRequest = testRemoteIpFilter(filterDef, request);
// VERIFY
boolean actualSecure = actualRequest.isSecure();
assertFalse(
"request must be unsecured as header x-forwarded-proto said it is http", actualSecure);
String actualScheme = actualRequest.getScheme();
assertEquals(
"scheme must be http as header x-forwarded-proto said it is http", "http", actualScheme);
String actualRemoteAddr = actualRequest.getRemoteAddr();
assertEquals("remoteAddr", "140.211.11.130", actualRemoteAddr);
String actualRemoteHost = actualRequest.getRemoteHost();
assertEquals("remoteHost", "140.211.11.130", actualRemoteHost);
}
/** @see junit.framework.TestCase#setUp() */
@Before
public void setUp() throws Exception {
super.setUp();
trustedLoginFilter = new TrustedLoginFilter();
when(componentManager.get(ServerConfigurationService.class))
.thenReturn(serverConfigurationService);
when(componentManager.get(SessionManager.class)).thenReturn(sessionManager);
when(componentManager.get(UserDirectoryService.class)).thenReturn(userDirectoryService);
when(serverConfigurationService.getBoolean(
TrustedLoginFilter.ORG_SAKAIPROJECT_UTIL_TRUSTED_LOGIN_FILTER_ENABLED, true))
.thenReturn(true);
when(serverConfigurationService.getString(
TrustedLoginFilter.ORG_SAKAIPROJECT_UTIL_TRUSTED_LOGIN_FILTER_SHARED_SECRET, null))
.thenReturn("e2KS54H35j6vS5Z38nK40");
when(serverConfigurationService.getString(
TrustedLoginFilter.ORG_SAKAIPROJECT_UTIL_TRUSTED_LOGIN_FILTER_SAFE_HOSTS,
trustedLoginFilter.safeHosts))
.thenReturn(trustedLoginFilter.safeHosts);
when(request.getRemoteHost()).thenReturn("localhost");
when(request.getHeader("x-sakai-token"))
.thenReturn("sw9TTTqlEbGQkELqQuQPq92ydr4=;username;nonce");
// default to non-existing session to exercise more code
when(existingSession.getUserEid()).thenReturn(null);
when(sessionManager.getCurrentSession()).thenReturn(existingSession);
when(sessionManager.startSession()).thenReturn(newSession);
when(user.getEid()).thenReturn("username");
when(user.getId()).thenReturn("uuid1234567890");
when(userDirectoryService.getUserByEid("username")).thenReturn(user);
trustedLoginFilter.setupTestCase(componentManager);
trustedLoginFilter.init(config);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
try {
String password = WebUtils.getCleanParam(request, PASSWORD);
String username = WebUtils.getCleanParam(request, USERNAME);
boolean rememberMe = WebUtils.isTrue(request, REMEMBER_ME);
String host = request.getRemoteHost();
UsernamePasswordToken token = new UsernamePasswordToken(username, password, rememberMe, host);
try {
Subject subject = SecurityUtils.getSubject();
loginWithNewSession(token, subject);
// subject.login(token);
issueJson(response, HTTP_STATUS_OK, MESSAGE, "ok");
} catch (AuthenticationException e) {
issue(
MIME_TEXT_PLAIN,
HTTP_STATUS_NOT_FOUND,
"cannot authorize " + username + ": " + e.getMessage(),
response);
}
} catch (Exception e) {
issue(
MIME_TEXT_PLAIN,
HTTP_STATUS_INTERNAL_SERVER_ERROR,
"Internal error: " + e.getMessage(),
response);
}
}
protected void _init(PageContext pc, Map<String, String> arguments) {
this.pc = pc;
// header
HttpServletRequest req = pc.getHttpServletRequest();
header = new StringBuffer();
createHeader(header, "context-path", req.getContextPath());
createHeader(header, "remote-user", req.getRemoteUser());
createHeader(header, "remote-addr", req.getRemoteAddr());
createHeader(header, "remote-host", req.getRemoteHost());
createHeader(
header,
"script-name",
StringUtil.emptyIfNull(req.getContextPath())
+ StringUtil.emptyIfNull(req.getServletPath()));
createHeader(header, "server-name", req.getServerName());
createHeader(header, "protocol", req.getProtocol());
createHeader(header, "server-port", Caster.toString(req.getServerPort()));
createHeader(
header,
"path-info",
StringUtil.replace(
StringUtil.emptyIfNull(req.getRequestURI()),
StringUtil.emptyIfNull(req.getServletPath()),
"",
true));
// createHeader(header,"path-translated",pc.getBasePageSource().getDisplayPath());
createHeader(header, "query-string", req.getQueryString());
createHeader(header, "unit", unitShortToString(unit));
createHeader(header, "min-time-nano", min + "");
content = new StringBuffer();
// directory
String strDirectory = arguments.get("directory");
if (dir == null) {
if (StringUtil.isEmpty(strDirectory)) {
dir = getTemp(pc);
} else {
try {
dir = ResourceUtil.toResourceNotExisting(pc, strDirectory, false);
if (!dir.exists()) {
dir.createDirectory(true);
} else if (dir.isFile()) {
err(
pc,
"can not create directory [" + dir + "], there is already a file with same name.");
}
} catch (Throwable t) {
err(pc, t);
dir = getTemp(pc);
}
}
}
file = dir.getRealResource((pc.getId()) + "-" + CreateUUID.call(pc) + ".exl");
file.createNewFile();
start = System.currentTimeMillis();
}
@Override
JSONStreamAware processRequest(HttpServletRequest req) {
JSONObject response = new JSONObject();
response.put("host", req.getRemoteHost());
response.put("address", req.getRemoteAddr());
return response;
}
private void initResult(HttpServletRequest request, JUnitResult result) {
result.setAgent(request.getHeader("User-Agent"));
result.setHost(request.getRemoteHost());
Throwable throwable = result.getException();
if (throwable != null) {
deobfuscateStackTrace(throwable);
}
}
/**
* Test method for {@link
* org.sakaiproject.hybrid.util.TrustedLoginFilter#doFilter(javax.servlet.ServletRequest,
* javax.servlet.ServletResponse, javax.servlet.FilterChain)} .
*
* @throws ServletException
* @throws IOException
*/
@Test
public void testDoFilterUnsafeHost() throws IOException, ServletException {
when(request.getRemoteHost()).thenReturn("big.bad.hacker.com");
trustedLoginFilter.doFilter(request, response, chain);
verify(sessionManager, never()).startSession();
verify(sessionManager, never()).setCurrentSession(newSession);
verify(sessionManager, never()).setCurrentSession(existingSession);
verify(chain).doFilter(request, response);
}
/*
* While pinning files this requestId value "qos" will be stored for the pin.
* Storing requestId insures the possibility to filter files being pinned by Qos or SRM.
*/
public void pin(FileAttributes fileAttributes, CellStub cellStub) throws URISyntaxException {
HttpProtocolInfo protocolInfo =
new HttpProtocolInfo(
"Http",
1,
1,
new InetSocketAddress(request.getRemoteHost(), 0),
null,
null,
null,
new URI("http", request.getRemoteHost(), null, null));
PinManagerPinMessage message =
new PinManagerPinMessage(fileAttributes, protocolInfo, requestId, -1);
cellStub.notify(message);
}
@RequestMapping(method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
public @ResponseBody Error save(@RequestBody Error error, HttpServletRequest request) {
error.setIp(request.getRemoteAddr());
error.setHostname(request.getRemoteHost());
error.setAgent(request.getHeader("User-Agent"));
error.setTimestamp(new Date());
return this.errorService.save(error);
}
/**
* Build a InMessage from an HttpServletrequest
*
* @param request The HttpservletRequest
*/
public InMessage(HttpServletRequest request) {
// TODO : Check this code : WSDL request are not well recorded !
this.method = request.getMethod();
// Set the headers
this.headers = new Headers();
Enumeration<String> headerNameEnum = request.getHeaderNames();
while (headerNameEnum.hasMoreElements()) {
String headerName = headerNameEnum.nextElement();
this.headers.addHeader(new Header(headerName, request.getHeader(headerName)));
}
// Set protocol, server, port, path
this.protocol = request.getProtocol().substring(0, request.getProtocol().indexOf('/'));
this.protocolVersion = request.getProtocol().substring(request.getProtocol().indexOf('/') + 1);
this.server = request.getServerName();
this.port = request.getServerPort();
this.path = request.getRequestURI();
this.remoteHost = request.getRemoteHost();
// this.completeUrl = request.getRequestURL().toString();
// Set url parameters
this.queryString = new QueryString();
Enumeration<String> parametersNameEnum = request.getParameterNames();
while (parametersNameEnum.hasMoreElements()) {
String parameterName = parametersNameEnum.nextElement();
for (String parameterValue : request.getParameterValues(parameterName)) {
this.queryString.addQueryParam(new QueryParam(parameterName, parameterValue));
}
}
this.messageContent = new MessageContent();
StringBuffer requestBody = new StringBuffer();
BufferedReader requestBodyReader = null;
CharBuffer buffer = CharBuffer.allocate(512);
try {
requestBodyReader = new BufferedReader(new InputStreamReader(request.getInputStream()));
while (requestBodyReader.read(buffer) >= 0) {
requestBody.append(buffer.flip());
buffer.clear();
}
this.messageContent.setRawContent(requestBody.toString());
this.messageContent.setSize(requestBody.length());
this.messageContent.setMimeType(request.getContentType());
} catch (Exception ex) {
logger.warn("Error while reading request body !", ex);
} finally {
try {
if (requestBodyReader != null) {
requestBodyReader.close();
}
} catch (IOException ex) {
// logger.warn("Error while closing the requestBodyReader !",
// ex);
}
}
this.comment = "";
}
/*
* Test {@link RemoteIpFilter} in Tomcat standalone server
*/
@Test
public void testWithTomcatServer() throws Exception {
// mostly default configuration : enable "x-forwarded-proto"
Map<String, String> remoteIpFilterParameter = new HashMap<>();
remoteIpFilterParameter.put("protocolHeader", "x-forwarded-proto");
// SETUP
Tomcat tomcat = getTomcatInstance();
Context root = tomcat.addContext("", TEMP_DIR);
FilterDef filterDef = new FilterDef();
filterDef.getParameterMap().putAll(remoteIpFilterParameter);
filterDef.setFilterClass(RemoteIpFilter.class.getName());
filterDef.setFilterName(RemoteIpFilter.class.getName());
root.addFilterDef(filterDef);
FilterMap filterMap = new FilterMap();
filterMap.setFilterName(RemoteIpFilter.class.getName());
filterMap.addURLPattern("*");
root.addFilterMap(filterMap);
MockHttpServlet mockServlet = new MockHttpServlet();
Tomcat.addServlet(root, mockServlet.getClass().getName(), mockServlet);
root.addServletMapping("/test", mockServlet.getClass().getName());
getTomcatInstance().start();
// TEST
HttpURLConnection httpURLConnection =
(HttpURLConnection)
new URL("http://localhost:" + tomcat.getConnector().getLocalPort() + "/test")
.openConnection();
String expectedRemoteAddr = "my-remote-addr";
httpURLConnection.addRequestProperty("x-forwarded-for", expectedRemoteAddr);
httpURLConnection.addRequestProperty("x-forwarded-proto", "https");
// VALIDATE
Assert.assertEquals(HttpURLConnection.HTTP_OK, httpURLConnection.getResponseCode());
HttpServletRequest request = mockServlet.getRequest();
Assert.assertNotNull(request);
// VALIDATE X-FOWARDED-FOR
Assert.assertEquals(expectedRemoteAddr, request.getRemoteAddr());
Assert.assertEquals(expectedRemoteAddr, request.getRemoteHost());
// VALIDATE X-FORWARDED-PROTO
Assert.assertTrue(request.isSecure());
Assert.assertEquals("https", request.getScheme());
Assert.assertEquals(443, request.getServerPort());
}
private void processOpen(
String aSessionId, String aConnectorId, HttpServletRequest aReq, HttpServletResponse aResp)
throws IOException {
try {
String lOrigin = aReq.getScheme() + "://" + aReq.getRemoteHost();
if (!EngineUtils.isOriginValid(lOrigin, mEngine.getConfiguration().getDomains())) {
sendMessage(401, "Origin not allowed!", aResp);
return;
}
mConnectorsManager.add(aSessionId, aConnectorId);
HTTPConnector lConnector = getConnector(aConnectorId, aReq, aResp);
lConnector.setRemoteHost(InetAddress.getByName(aReq.getRemoteHost()));
// starting connector on request thread intentionally
lConnector.startConnector();
} catch (Exception lEx) {
sendMessage(500, lEx.getLocalizedMessage(), aResp);
}
}
public void autoSetLocation(HttpServletRequest request) {
DbDao db = new DbDao();
System.out.println("RemAddr: " + request.getRemoteAddr());
System.out.println("RemHost: " + request.getRemoteHost());
String ipAddress = request.getRemoteAddr();
location = null; // db.getLocationByIp("24.68.70.242");
if (location == null) {
int[] tempLoc = {-1, -1, -1, -1};
location = tempLoc;
}
}
@Override
public String getRemoteHost() {
HttpServletRequest request = (HttpServletRequest) getRequest();
String headerValue;
headerValue = request.getHeader(headerPrefix + "REMOTE_HOST");
if (headerValue != null) {
return headerValue;
} else {
return request.getRemoteHost();
}
}
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String action = request.getParameter("action");
String name = request.getParameter("name");
String redirect = "/user.jsp?name=" + name;
Client client = ClientRepository.getInstance().getClient(name);
if ("kick".equals(action)) {
logger.info(
client.getUser().getName()
+ " ("
+ client.getInetAddress()
+ ") has been kicked by "
+ request.getRemoteUser()
+ " ("
+ request.getRemoteHost()
+ ")");
} else if ("ban".equals(action)) {
Banlist banlist = Banlist.getInstance();
banlist.ban(client.getInetAddress().getHostAddress());
logger.info(
client.getUser().getName()
+ " ("
+ client.getInetAddress()
+ ") has been banned by "
+ request.getRemoteUser()
+ " ("
+ request.getRemoteHost()
+ ")");
// save the server configuration
Server.getInstance().getConfig().save();
}
client.disconnect();
response.sendRedirect("/channel.jsp?name=" + client.getChannel().getConfig().getName());
}
private UserGroup getIpGroup(HttpServletRequest request) {
UserGroup ipUserGroup = null;
HttpSession session = ((HttpServletRequest) request).getSession(true);
if (session.getAttribute("isIpGroupChecked") == null) {
ipUserGroup = groupService.findIpGroupUser(request.getRemoteHost());
if (ipUserGroup != null) {
session.setAttribute("ipUserGroup", ipUserGroup);
session.setAttribute("isIpGroupChecked", true);
}
} else {
ipUserGroup = (UserGroup) session.getAttribute("ipUserGroup");
}
return ipUserGroup;
}
HTTPConnector getConnector(
String aConnectorId,
HttpServletRequest aReq,
HttpServletResponse aResp,
boolean aStartupConnection)
throws Exception {
HTTPConnector lConnector =
(HTTPConnector) mConnectorsManager.getConnectorById(aConnectorId, aStartupConnection);
lConnector.setRemoteHost(InetAddress.getByName(aReq.getRemoteHost()));
lConnector.setSSL(aReq.getScheme().equals("https"));
lConnector.setHttpResponse(aResp);
return lConnector;
}
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
resp.setHeader("Cache-Control", "no-cache, no-store, must-revalidate, private");
resp.setHeader("Pragma", "no-cache");
resp.setDateHeader("Expires", 0);
resp.setContentType("text/html; charset=UTF-8");
if (API.allowedBotHosts != null && !API.allowedBotHosts.contains(req.getRemoteHost())) {
resp.sendError(HttpServletResponse.SC_FORBIDDEN);
return;
}
try (PrintWriter writer = resp.getWriter()) {
writer.print(header1);
writer.print(buildLinks(req));
writer.print(header2);
String requestType = Convert.nullToEmpty(req.getParameter("requestType"));
APIServlet.APIRequestHandler requestHandler = APIServlet.apiRequestHandlers.get(requestType);
StringBuilder bufJSCalls = new StringBuilder();
if (requestHandler != null) {
writer.print(
form(
requestType,
true,
requestHandler.getClass().getName(),
requestHandler.getParameters(),
requestHandler.requirePost()));
bufJSCalls.append("apiCalls.push(\"").append(requestType).append("\");\n");
} else {
String requestTag = Convert.nullToEmpty(req.getParameter("requestTag"));
Set<String> taggedTypes = requestTags.get(requestTag);
for (String type : (taggedTypes != null ? taggedTypes : allRequestTypes)) {
requestHandler = APIServlet.apiRequestHandlers.get(type);
writer.print(
form(
type,
false,
requestHandler.getClass().getName(),
APIServlet.apiRequestHandlers.get(type).getParameters(),
APIServlet.apiRequestHandlers.get(type).requirePost()));
bufJSCalls.append("apiCalls.push(\"").append(type).append("\");\n");
}
}
writer.print(footer1);
writer.print(bufJSCalls.toString());
writer.print(footer2);
}
}
public static String getIpAddr(HttpServletRequest request) {
String ip = request.getHeader("x-forwarded-for");
if (ip != null && ip.length() > 0 && !"unknown".equalsIgnoreCase(ip)) {
return ip;
} else if (null != request.getHeader("Proxy-Client-IP")
&& request.getHeader("Proxy-Client-IP").length() > 0
&& !"unknown".equalsIgnoreCase(request.getHeader("Proxy-Client-IP"))) {
return request.getHeader("Proxy-Client-IP");
} else if (null != request.getHeader("WL-Proxy-Client-IP")
&& request.getHeader("WL-Proxy-Client-IP").length() > 0
&& !"unknown".equalsIgnoreCase(request.getHeader("WL-Proxy-Client-IP"))) {
return request.getHeader("WL-Proxy-Client-IP");
} else {
return request.getRemoteHost();
}
}