| /* |
| * Copyright 2014 gitblit.com. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.gitblit.servlet; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.UnsupportedEncodingException; |
| import java.net.URLEncoder; |
| import java.text.MessageFormat; |
| import java.text.ParseException; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.TreeMap; |
| |
| import javax.servlet.ServletContext; |
| import javax.servlet.ServletException; |
| import javax.servlet.http.HttpServlet; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| |
| import org.apache.tika.Tika; |
| import org.eclipse.jgit.lib.FileMode; |
| import org.eclipse.jgit.lib.MutableObjectId; |
| import org.eclipse.jgit.lib.ObjectLoader; |
| import org.eclipse.jgit.lib.ObjectReader; |
| import org.eclipse.jgit.lib.Repository; |
| import org.eclipse.jgit.revwalk.RevCommit; |
| import org.eclipse.jgit.revwalk.RevWalk; |
| import org.eclipse.jgit.treewalk.TreeWalk; |
| import org.eclipse.jgit.treewalk.filter.PathFilter; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import com.gitblit.Constants; |
| import com.gitblit.Keys; |
| import com.gitblit.manager.IRepositoryManager; |
| import com.gitblit.manager.IRuntimeManager; |
| import com.gitblit.models.PathModel; |
| import com.gitblit.utils.ByteFormat; |
| import com.gitblit.utils.JGitUtils; |
| import com.gitblit.utils.MarkdownUtils; |
| import com.gitblit.utils.StringUtils; |
| import com.google.inject.Inject; |
| import com.google.inject.Singleton; |
| |
| /** |
| * Serves the content of a branch. |
| * |
| * @author James Moger |
| * |
| */ |
| @Singleton |
| public class RawServlet extends HttpServlet { |
| |
| private static final long serialVersionUID = 1L; |
| |
| private transient Logger logger = LoggerFactory.getLogger(RawServlet.class); |
| |
| private final IRuntimeManager runtimeManager; |
| |
| private final IRepositoryManager repositoryManager; |
| |
| @Inject |
| public RawServlet( |
| IRuntimeManager runtimeManager, |
| IRepositoryManager repositoryManager) { |
| |
| this.runtimeManager = runtimeManager; |
| this.repositoryManager = repositoryManager; |
| } |
| |
| /** |
| * Returns an url to this servlet for the specified parameters. |
| * |
| * @param baseURL |
| * @param repository |
| * @param branch |
| * @param path |
| * @return an url |
| */ |
| public static String asLink(String baseURL, String repository, String branch, String path) { |
| if (baseURL.length() > 0 && baseURL.charAt(baseURL.length() - 1) == '/') { |
| baseURL = baseURL.substring(0, baseURL.length() - 1); |
| } |
| |
| char fsc = '!'; |
| char c = GitblitContext.getManager(IRuntimeManager.class).getSettings().getChar(Keys.web.forwardSlashCharacter, '/'); |
| if (c != '/') { |
| fsc = c; |
| } |
| if (branch != null) { |
| branch = Repository.shortenRefName(branch).replace('/', fsc); |
| } |
| |
| String encodedPath = path == null ? "" : path.replace('/', fsc); |
| return baseURL + Constants.RAW_PATH + repository + "/" + (branch == null ? "" : (branch + "/" + encodedPath)); |
| } |
| |
| protected String getBranch(String repository, HttpServletRequest request) { |
| String pi = request.getPathInfo(); |
| String branch = pi.substring(pi.indexOf(repository) + repository.length() + 1); |
| int fs = branch.indexOf('/'); |
| if (fs > -1) { |
| branch = branch.substring(0, fs); |
| } |
| char c = runtimeManager.getSettings().getChar(Keys.web.forwardSlashCharacter, '/'); |
| return branch.replace('!', '/').replace(c, '/'); |
| } |
| |
| protected String getPath(String repository, String branch, HttpServletRequest request) { |
| String base = repository + "/" + branch; |
| String pi = request.getPathInfo().substring(1); |
| if (pi.equals(base)) { |
| return ""; |
| } |
| String path = pi.substring(pi.indexOf(base) + base.length() + 1); |
| if (path.endsWith("/")) { |
| path = path.substring(0, path.length() - 1); |
| } |
| char c = runtimeManager.getSettings().getChar(Keys.web.forwardSlashCharacter, '/'); |
| return path.replace('!', '/').replace(c, '/'); |
| } |
| |
| protected boolean renderIndex() { |
| return false; |
| } |
| |
| /** |
| * Retrieves the specified resource from the specified branch of the |
| * repository. |
| * |
| * @param request |
| * @param response |
| * @throws javax.servlet.ServletException |
| * @throws java.io.IOException |
| */ |
| private void processRequest(HttpServletRequest request, HttpServletResponse response) |
| throws ServletException, IOException { |
| String path = request.getPathInfo(); |
| if (path.toLowerCase().endsWith(".git")) { |
| // forward to url with trailing / |
| // this is important for relative pages links |
| response.sendRedirect(request.getServletPath() + path + "/"); |
| return; |
| } |
| if (path.charAt(0) == '/') { |
| // strip leading / |
| path = path.substring(1); |
| } |
| |
| // determine repository and resource from url |
| String repository = path; |
| Repository r = null; |
| int terminator = repository.length(); |
| do { |
| repository = repository.substring(0, terminator); |
| r = repositoryManager.getRepository(repository, false); |
| terminator = repository.lastIndexOf('/'); |
| } while (r == null && terminator > -1 ); |
| |
| ServletContext context = request.getSession().getServletContext(); |
| |
| try { |
| if (r == null) { |
| // repository not found! |
| String mkd = MessageFormat.format( |
| "# Error\nSorry, no valid **repository** specified in this url: {0}!", |
| path); |
| error(response, mkd); |
| return; |
| } |
| |
| // identify the branch |
| String branch = getBranch(repository, request); |
| if (StringUtils.isEmpty(branch)) { |
| branch = r.getBranch(); |
| if (branch == null) { |
| // no branches found! empty? |
| String mkd = MessageFormat.format( |
| "# Error\nSorry, no valid **branch** specified in this url: {0}!", |
| path); |
| error(response, mkd); |
| } else { |
| // redirect to default branch |
| String base = request.getRequestURI(); |
| String url = base + branch + "/"; |
| response.sendRedirect(url); |
| } |
| return; |
| } |
| |
| // identify the requested path |
| String requestedPath = getPath(repository, branch, request); |
| |
| // identify the commit |
| RevCommit commit = JGitUtils.getCommit(r, branch); |
| if (commit == null) { |
| // branch not found! |
| String mkd = MessageFormat.format( |
| "# Error\nSorry, the repository {0} does not have a **{1}** branch!", |
| repository, branch); |
| error(response, mkd); |
| return; |
| } |
| |
| Map<String, String> quickContentTypes = new HashMap<>(); |
| quickContentTypes.put("html", "text/html"); |
| quickContentTypes.put("htm", "text/html"); |
| quickContentTypes.put("xml", "application/xml"); |
| quickContentTypes.put("json", "application/json"); |
| |
| List<PathModel> pathEntries = JGitUtils.getFilesInPath(r, requestedPath, commit); |
| if (pathEntries.isEmpty()) { |
| // requested a specific resource |
| String file = StringUtils.getLastPathElement(requestedPath); |
| try { |
| |
| String ext = StringUtils.getFileExtension(file).toLowerCase(); |
| // We can't parse out an extension for classic "dotfiles", so make a general assumption that |
| // they're text files to allow presenting them in browser instead of only for download. |
| // |
| // However, that only holds for files with no other extension included, for files that happen |
| // to start with a dot but also include an extension, process the extension normally. |
| // This logic covers .gitattributes, .gitignore, .zshrc, etc., but does not cover .mongorc.js, .zshrc.bak |
| boolean isExtensionlessDotfile = file.charAt(0) == '.' && (file.length() == 1 || file.indexOf('.', 1) < 0); |
| String contentType = isExtensionlessDotfile ? "text/plain" : quickContentTypes.get(ext); |
| |
| if (contentType == null) { |
| List<String> exts = runtimeManager.getSettings().getStrings(Keys.web.prettyPrintExtensions); |
| if (exts.contains(ext)) { |
| // extension is a registered text type for pretty printing |
| contentType = "text/plain"; |
| } else { |
| // query Tika for the content type |
| Tika tika = new Tika(); |
| contentType = tika.detect(file); |
| } |
| } |
| |
| if (contentType == null) { |
| // ask the container for the content type |
| contentType = context.getMimeType(requestedPath); |
| |
| if (contentType == null) { |
| // still unknown content type, assume binary |
| contentType = "application/octet-stream"; |
| } |
| } |
| |
| if (isTextType(contentType) || isTextDataType(contentType)) { |
| |
| // load, interpret, and serve text content as UTF-8 |
| String [] encodings = runtimeManager.getSettings().getStrings(Keys.web.blobEncodings).toArray(new String[0]); |
| String content = JGitUtils.getStringContent(r, commit.getTree(), requestedPath, encodings); |
| if (content == null) { |
| logger.error("RawServlet Failed to load {} {} {}", repository, commit.getName(), path); |
| notFound(response, requestedPath, branch); |
| return; |
| } |
| |
| byte [] bytes = content.getBytes(Constants.ENCODING); |
| setContentType(response, contentType); |
| response.setContentLength(bytes.length); |
| ByteArrayInputStream is = new ByteArrayInputStream(bytes); |
| sendContent(response, JGitUtils.getCommitDate(commit), is); |
| |
| } else { |
| // stream binary content directly from the repository |
| if (!streamFromRepo(request, response, r, commit, requestedPath)) { |
| logger.error("RawServlet Failed to load {} {} {}", repository, commit.getName(), path); |
| notFound(response, requestedPath, branch); |
| } |
| } |
| return; |
| } catch (Exception e) { |
| logger.error(null, e); |
| } |
| } else { |
| // path request |
| if (!request.getPathInfo().endsWith("/")) { |
| // redirect to trailing '/' url |
| response.sendRedirect(request.getServletPath() + request.getPathInfo() + "/"); |
| return; |
| } |
| |
| if (renderIndex()) { |
| // locate and render an index file |
| Map<String, String> names = new TreeMap<String, String>(); |
| for (PathModel entry : pathEntries) { |
| names.put(entry.name.toLowerCase(), entry.name); |
| } |
| |
| List<String> extensions = new ArrayList<String>(); |
| extensions.add("html"); |
| extensions.add("htm"); |
| |
| String content = null; |
| for (String ext : extensions) { |
| String key = "index." + ext; |
| |
| if (names.containsKey(key)) { |
| String fileName = names.get(key); |
| String fullPath = fileName; |
| if (!requestedPath.isEmpty()) { |
| fullPath = requestedPath + "/" + fileName; |
| } |
| |
| String [] encodings = runtimeManager.getSettings().getStrings(Keys.web.blobEncodings).toArray(new String[0]); |
| String stringContent = JGitUtils.getStringContent(r, commit.getTree(), fullPath, encodings); |
| if (stringContent == null) { |
| continue; |
| } |
| content = stringContent; |
| requestedPath = fullPath; |
| break; |
| } |
| } |
| |
| response.setContentType("text/html; charset=" + Constants.ENCODING); |
| byte [] bytes = content.getBytes(Constants.ENCODING); |
| response.setContentLength(bytes.length); |
| |
| ByteArrayInputStream is = new ByteArrayInputStream(bytes); |
| sendContent(response, JGitUtils.getCommitDate(commit), is); |
| return; |
| } |
| } |
| |
| // no content, document list or 404 page |
| if (pathEntries.isEmpty()) { |
| // default 404 page |
| notFound(response, requestedPath, branch); |
| return; |
| } else { |
| // |
| // directory list |
| // |
| response.setContentType("text/html"); |
| response.getWriter().append("<style>table th, table td { min-width: 150px; text-align: left; }</style>"); |
| response.getWriter().append("<table>"); |
| response.getWriter().append("<thead><tr><th>path</th><th>mode</th><th>size</th></tr>"); |
| response.getWriter().append("</thead>"); |
| response.getWriter().append("<tbody>"); |
| String pattern = "<tr><td><a href=\"{0}/{1}\">{1}</a></td><td>{2}</td><td>{3}</td></tr>"; |
| final ByteFormat byteFormat = new ByteFormat(); |
| if (!pathEntries.isEmpty()) { |
| if (pathEntries.get(0).path.indexOf('/') > -1) { |
| // we are in a subdirectory, add parent directory link |
| String pp = URLEncoder.encode(requestedPath, Constants.ENCODING); |
| pathEntries.add(0, new PathModel("..", pp + "/..", null, 0, FileMode.TREE.getBits(), null, null)); |
| } |
| } |
| |
| String basePath = request.getServletPath() + request.getPathInfo(); |
| if (basePath.charAt(basePath.length() - 1) == '/') { |
| // strip trailing slash |
| basePath = basePath.substring(0, basePath.length() - 1); |
| } |
| for (PathModel entry : pathEntries) { |
| String pp = URLEncoder.encode(entry.name, Constants.ENCODING); |
| response.getWriter().append(MessageFormat.format(pattern, basePath, pp, |
| JGitUtils.getPermissionsFromMode(entry.mode), |
| entry.isFile() ? byteFormat.format(entry.size) : "")); |
| } |
| response.getWriter().append("</tbody>"); |
| response.getWriter().append("</table>"); |
| } |
| } catch (Throwable t) { |
| logger.error("Failed to write page to client", t); |
| } finally { |
| r.close(); |
| } |
| } |
| |
| protected boolean isTextType(String contentType) { |
| if (contentType.startsWith("text/") |
| || "application/json".equals(contentType) |
| || "application/xml".equals(contentType)) { |
| return true; |
| } |
| return false; |
| } |
| |
| protected boolean isTextDataType(String contentType) { |
| if ("image/svg+xml".equals(contentType)) { |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Override all text types to be plain text. |
| * |
| * @param response |
| * @param contentType |
| */ |
| protected void setContentType(HttpServletResponse response, String contentType) { |
| if (isTextType(contentType)) { |
| response.setContentType("text/plain"); |
| } else { |
| response.setContentType(contentType); |
| } |
| } |
| |
| protected boolean streamFromRepo(HttpServletRequest request, HttpServletResponse response, Repository repository, |
| RevCommit commit, String requestedPath) throws IOException { |
| |
| boolean served = false; |
| RevWalk rw = new RevWalk(repository); |
| TreeWalk tw = new TreeWalk(repository); |
| try { |
| tw.reset(); |
| tw.addTree(commit.getTree()); |
| PathFilter f = PathFilter.create(requestedPath); |
| tw.setFilter(f); |
| tw.setRecursive(true); |
| MutableObjectId id = new MutableObjectId(); |
| ObjectReader reader = tw.getObjectReader(); |
| while (tw.next()) { |
| FileMode mode = tw.getFileMode(0); |
| if (mode == FileMode.GITLINK || mode == FileMode.TREE) { |
| continue; |
| } |
| tw.getObjectId(id, 0); |
| |
| String filename = StringUtils.getLastPathElement(requestedPath); |
| try { |
| String userAgent = request.getHeader("User-Agent"); |
| if (userAgent != null && userAgent.indexOf("MSIE 5.5") > -1) { |
| response.setHeader("Content-Disposition", "filename=\"" |
| + URLEncoder.encode(filename, Constants.ENCODING) + "\""); |
| } else if (userAgent != null && userAgent.indexOf("MSIE") > -1) { |
| response.setHeader("Content-Disposition", "attachment; filename=\"" |
| + URLEncoder.encode(filename, Constants.ENCODING) + "\""); |
| } else { |
| response.setHeader("Content-Disposition", "attachment; filename=\"" |
| + new String(filename.getBytes(Constants.ENCODING), "latin1") + "\""); |
| } |
| } |
| catch (UnsupportedEncodingException e) { |
| response.setHeader("Content-Disposition", "attachment; filename=\"" + filename + "\""); |
| } |
| |
| long len = reader.getObjectSize(id, org.eclipse.jgit.lib.Constants.OBJ_BLOB); |
| setContentType(response, "application/octet-stream"); |
| response.setIntHeader("Content-Length", (int) len); |
| ObjectLoader ldr = repository.open(id); |
| ldr.copyTo(response.getOutputStream()); |
| served = true; |
| } |
| } finally { |
| tw.close(); |
| rw.dispose(); |
| } |
| |
| response.flushBuffer(); |
| return served; |
| } |
| |
| protected void sendContent(HttpServletResponse response, Date date, InputStream is) throws ServletException, IOException { |
| |
| try { |
| byte[] tmp = new byte[8192]; |
| int len = 0; |
| while ((len = is.read(tmp)) > -1) { |
| response.getOutputStream().write(tmp, 0, len); |
| } |
| } finally { |
| is.close(); |
| } |
| response.flushBuffer(); |
| } |
| |
| protected void notFound(HttpServletResponse response, String requestedPath, String branch) |
| throws ParseException, ServletException, IOException { |
| String str = MessageFormat.format( |
| "# Error\nSorry, the requested resource **{0}** was not found in **{1}**.", |
| requestedPath, branch); |
| response.setStatus(HttpServletResponse.SC_NOT_FOUND); |
| error(response, str); |
| } |
| |
| private void error(HttpServletResponse response, String mkd) throws ServletException, |
| IOException, ParseException { |
| String content = MarkdownUtils.transformMarkdown(mkd); |
| response.setContentType("text/html; charset=" + Constants.ENCODING); |
| response.getWriter().write(content); |
| } |
| |
| @Override |
| protected void doPost(HttpServletRequest request, HttpServletResponse response) |
| throws ServletException, IOException { |
| processRequest(request, response); |
| } |
| |
| @Override |
| protected void doGet(HttpServletRequest request, HttpServletResponse response) |
| throws ServletException, IOException { |
| processRequest(request, response); |
| } |
| } |