| /*** OLAT - Online Learning and Training<br>* http://www.olat.org* <p>* Licensed under the Apache License, Version 2.0 (the "License"); <br>* you may not use this file except in compliance with the License.<br>* You may obtain a copy of the License at* <p>* http://www.apache.org/licenses/LICENSE-2.0* <p>* Unless required by applicable law or agreed to in writing,<br>* software distributed under the License is distributed on an "AS IS" BASIS, <br>* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>* See the License for the specific language governing permissions and <br>* limitations under the License.* <p>* Copyright (c) since 2004 at Multimedia- & E-Learning Services (MELS),<br>* University of Zurich, Switzerland.* <hr>* <a href="http://www.openolat.org">* OpenOLAT - Online Learning and Training</a><br>* This file has been modified by the OpenOLAT community. Changes are licensed* under the Apache 2.0 license as the original file. * <p>*/ package org.olat.core.commons.modules.bc.commands;import java.util.ArrayList;import java.util.List;import org.olat.core.commons.modules.bc.FileSelection;import org.olat.core.commons.modules.bc.FolderEvent;import org.olat.core.commons.modules.bc.components.FolderComponent;import org.olat.core.commons.services.notifications.NotificationsManager;import org.olat.core.commons.services.notifications.SubscriptionContext;import org.olat.core.commons.services.vfs.VFSRepositoryService;import org.olat.core.gui.UserRequest;import org.olat.core.gui.components.Component;import org.olat.core.gui.components.link.Link;import org.olat.core.gui.components.link.LinkFactory;import org.olat.core.gui.components.tree.MenuTree;import org.olat.core.gui.components.velocity.VelocityContainer;import org.olat.core.gui.control.Controller;import org.olat.core.gui.control.DefaultController;import org.olat.core.gui.control.Event;import org.olat.core.gui.control.WindowControl;import org.olat.core.gui.control.generic.folder.FolderTreeModel;import org.olat.core.gui.translator.Translator;import org.olat.core.util.Util;import org.olat.core.util.vfs.VFSConstants;import org.olat.core.util.vfs.VFSContainer;import org.olat.core.util.vfs.VFSItem;import org.olat.core.util.vfs.VFSLeaf;import org.olat.core.util.vfs.VFSLockApplicationType;import org.olat.core.util.vfs.VFSLockManager;import org.olat.core.util.vfs.VFSManager;import org.olat.core.util.vfs.VFSStatus;import org.olat.core.util.vfs.callbacks.VFSSecurityCallback;import org.olat.core.util.vfs.filters.VFSItemFilter;import org.springframework.beans.factory.annotation.Autowired;public class CmdMoveCopy extends DefaultController implements FolderCommand { private static final String VELOCITY_ROOT = Util.getPackageVelocityRoot(CmdMoveCopy.class); private static int status = FolderCommandStatus.STATUS_SUCCESS; private Translator translator; private MenuTree selTree; private FileSelection fileSelection; private Link selectButton, cancelButton; private FolderComponent folderComponent; private final boolean move; @Autowired private VFSLockManager vfsLockManager; @Autowired private VFSRepositoryService vfsRepositoryService; @Autowired private NotificationsManager notificationsManager; protected CmdMoveCopy(WindowControl wControl, boolean move) { super(wControl); this.move = move; } @Override public Controller execute(FolderComponent fc, UserRequest ureq, WindowControl windowControl, Translator trans) { this.folderComponent = fc; this.translator = trans; // BUG: CWE-22 Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') // this.fileSelection = new FileSelection(ureq, fc.getCurrentContainerPath()); // FIXED: this.fileSelection = new FileSelection(ureq, fc.getCurrentContainer(), fc.getCurrentContainerPath()); VelocityContainer main = new VelocityContainer("mc", VELOCITY_ROOT + "/movecopy.html", translator, this); main.contextPut("fileselection", fileSelection); //check if command is executed on a file list containing invalid filenames or paths if(!fileSelection.getInvalidFileNames().isEmpty()) { main.contextPut("invalidFileNames", fileSelection.getInvalidFileNames()); } selTree = new MenuTree(null, "seltree", this); FolderTreeModel ftm = new FolderTreeModel(ureq.getLocale(), fc.getRootContainer(), true, false, true, fc.getRootContainer().canWrite() == VFSConstants.YES, new EditableFilter()); selTree.setTreeModel(ftm); selectButton = LinkFactory.createButton(move ? "move" : "copy", main, this); cancelButton = LinkFactory.createButton("cancel", main, this); main.put("seltree", selTree); if (move) { main.contextPut("move", Boolean.TRUE); } setInitialComponent(main); return this; } public boolean isMoved() { return move; } public FileSelection getFileSelection() { return fileSelection; } @Override public int getStatus() { return status; } @Override public boolean runsModal() { return false; } @Override public String getModalTitle() { return null; } public String getTarget() { FolderTreeModel ftm = (FolderTreeModel) selTree.getTreeModel(); return ftm.getSelectedPath(selTree.getSelectedNode()); } @Override public void event(UserRequest ureq, Component source, Event event) { if(cancelButton == source) { status = FolderCommandStatus.STATUS_CANCELED; fireEvent(ureq, FOLDERCOMMAND_FINISHED); } else if (selectButton == source) { doMove(ureq); } } private void doMove(UserRequest ureq) { FolderTreeModel ftm = (FolderTreeModel) selTree.getTreeModel(); String selectedPath = ftm.getSelectedPath(selTree.getSelectedNode()); if (selectedPath == null) { abortFailed(ureq, "failed"); return; } VFSStatus vfsStatus = VFSConstants.SUCCESS; VFSContainer rootContainer = folderComponent.getRootContainer(); VFSItem vfsItem = rootContainer.resolve(selectedPath); if (vfsItem == null || (vfsItem.canWrite() != VFSConstants.YES)) { abortFailed(ureq, "failed"); return; } // copy the files VFSContainer target = (VFSContainer)vfsItem; List<VFSItem> sources = getSanityCheckedSourceItems(target, ureq); if (sources == null) return; for (VFSItem vfsSource:sources) { VFSItem targetFile = target.resolve(vfsSource.getName()); if(vfsSource instanceof VFSLeaf && targetFile != null && targetFile.canVersion() == VFSConstants.YES) { //add a new version to the file VFSLeaf sourceLeaf = (VFSLeaf)vfsSource; vfsRepositoryService.addVersion(sourceLeaf, ureq.getIdentity(), false, "", sourceLeaf.getInputStream()); } else { vfsStatus = target.copyFrom(vfsSource, ureq.getIdentity()); } if (vfsStatus != VFSConstants.SUCCESS) { String errorKey = "failed"; if (vfsStatus == VFSConstants.ERROR_QUOTA_EXCEEDED) errorKey = "QuotaExceeded"; abortFailed(ureq, errorKey); return; } if (move) { // if move, delete the source. Note that meta source // has already been delete (i.e. moved) vfsSource.delete(); } } // after a copy or a move, notify the subscribers VFSSecurityCallback secCallback = VFSManager.findInheritedSecurityCallback(folderComponent.getCurrentContainer()); if (secCallback != null) { SubscriptionContext subsContext = secCallback.getSubscriptionContext(); if (subsContext != null) { notificationsManager.markPublisherNews(subsContext, ureq.getIdentity(), true); } } fireEvent(ureq, new FolderEvent(move ? FolderEvent.MOVE_EVENT : FolderEvent.COPY_EVENT, fileSelection.renderAsHtml())); notifyFinished(ureq); } private void notifyFinished(UserRequest ureq) { VFSContainer container = VFSManager.findInheritingSecurityCallbackContainer(folderComponent.getRootContainer()); VFSSecurityCallback secCallback = container.getLocalSecurityCallback(); if(secCallback != null) { SubscriptionContext subsContext = secCallback.getSubscriptionContext(); if (subsContext != null) { notificationsManager.markPublisherNews(subsContext, ureq.getIdentity(), true); } } fireEvent(ureq, FOLDERCOMMAND_FINISHED); } /** * Get the list of source files. Sanity check if resolveable, overlapping or * a target with the same name already exists. In such cases, set the error message, fire * the abort event and return null. * * @param target * @param ureq * @return */ private List<VFSItem> getSanityCheckedSourceItems(VFSContainer target, UserRequest ureq) { // collect all source files first List<VFSItem> sources = new ArrayList<>(); for (String sourceRelPath:fileSelection.getFiles()) { VFSItem vfsSource = folderComponent.getCurrentContainer().resolve(sourceRelPath); if (vfsSource == null) { abortFailed(ureq, "FileDoesNotExist"); return null; } if (vfsSource instanceof VFSContainer) { // if a folder... check if they are overlapping if (VFSManager.isContainerDescendantOrSelf(target, (VFSContainer)vfsSource)) { abortFailed(ureq, "OverlappingTarget"); return null; } } if (vfsLockManager.isLockedForMe(vfsSource, ureq.getIdentity(), VFSLockApplicationType.vfs, null)) { abortFailed(ureq, "lock.title"); return null; } // check for existence... this will also prevent to copy item over itself VFSItem item = target.resolve(vfsSource.getName()); if (item != null) { abortFailed(ureq, "TargetNameAlreadyUsed"); return null; } if (vfsSource.canCopy() != VFSConstants.YES) { getWindowControl().setError(translator.translate("FileMoveCopyFailed", new String[] {vfsSource.getName()})); status = FolderCommandStatus.STATUS_FAILED; fireEvent(ureq, FOLDERCOMMAND_FINISHED); return null; } sources.add(vfsSource); } return sources; } private void abortFailed(UserRequest ureq, String errorMessageKey) { getWindowControl().setError(translator.translate(errorMessageKey)); status = FolderCommandStatus.STATUS_FAILED; fireEvent(ureq, FOLDERCOMMAND_FINISHED); } @Override protected void doDispose() { // } private static final class EditableFilter implements VFSItemFilter { @Override public boolean accept(VFSItem vfsItem) { VFSSecurityCallback secCallback = vfsItem.getLocalSecurityCallback(); if(secCallback != null && !secCallback.canWrite()) { return false; } return true; } }} |