public function switchAction($action, $httpVars, $fileVars)
{
$errorMessage = "This is a demo, all 'write' actions are disabled!";
switch ($action) {
//------------------------------------
// WRITE ACTIONS
//------------------------------------
case "put_content":
case "copy":
case "move":
case "rename":
case "delete":
case "mkdir":
case "mkfile":
case "chmod":
case "compress":
return AJXP_XMLWriter::sendMessage(null, $errorMessage, false);
break;
//------------------------------------
// UPLOAD
//------------------------------------
//------------------------------------
// UPLOAD
//------------------------------------
case "upload":
return array("ERROR" => array("CODE" => "", "MESSAGE" => $errorMessage));
break;
default:
break;
}
return parent::switchAction($action, $httpVars, $fileVars);
}
function catchError($code, $message, $fichier, $ligne, $context)
{
if (error_reporting() == 0) {
return;
}
$message = "{$code} : {$message} in {$fichier} (l.{$ligne})";
AJXP_Logger::logAction("error", array("message" => $message));
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $message, true);
AJXP_XMLWriter::close();
exit(1);
}
function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->actions[$action])) {
return;
}
$errorMessage = "This is a demo, all 'write' actions are disabled!";
switch ($action) {
//------------------------------------
// ONLINE EDIT
//------------------------------------
case "public_url":
if ($httpVars["sub_action"] == "delegate_repo") {
return AJXP_XMLWriter::sendMessage(null, $errorMessage, false);
} else {
print $errorMessage;
}
exit(0);
break;
//------------------------------------
// WRITE ACTIONS
//------------------------------------
//------------------------------------
// WRITE ACTIONS
//------------------------------------
case "put_content":
case "copy":
case "move":
case "rename":
case "delete":
case "mkdir":
case "mkfile":
case "chmod":
case "compress":
return AJXP_XMLWriter::sendMessage(null, $errorMessage, false);
break;
//------------------------------------
// UPLOAD
//------------------------------------
//------------------------------------
// UPLOAD
//------------------------------------
case "upload":
return array("ERROR" => array("CODE" => "", "MESSAGE" => $errorMessage));
break;
default:
break;
}
return parent::switchAction($action, $httpVars, $fileVars);
}
function errorToXml($mixed)
{
if (is_a($mixed, "AJXP_Exception")) {
$messages = ConfService::getMessages();
$error = "Unkown Error";
if (isset($mixed->messageId) && array_key_exists($mixed->messageId, $messages)) {
$error = $messages[$mixed->messageId];
} else {
$error = $mixed->messageId;
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $error);
AJXP_XMLWriter::close();
exit(1);
}
}
public function deleteSelection($actionName, &$httpVars, $filesVars)
{
$init = $this->initDirAndSelection($httpVars, array(), true);
if (isset($init["RECYCLE"]) && isset($init["RECYCLE"]["action"]) && $init["RECYCLE"]["action"] != "delete") {
$httpVars["dest"] = SystemTextEncoding::fromUTF8($init["RECYCLE"]["dest"]);
$this->copyOrMoveSelection("move", $httpVars, $filesVars);
$userSelection = $init["ORIGINAL_SELECTION"];
$files = $userSelection->getFiles();
if ($actionName == "delete") {
foreach ($files as $file) {
RecycleBinManager::fileToRecycle($file);
}
} else {
if ($actionName == "restore") {
foreach ($files as $file) {
RecycleBinManager::deleteFromRecycle($file);
}
}
}
$this->commitChanges($actionName, array("dir" => RecycleBinManager::getRelativeRecycle()), $filesVars);
return;
}
foreach ($init["SELECTION"] as $selectedFile) {
$res = ExecSvnCmd('svn delete', $selectedFile, '--force');
}
$this->commitMessageParams = "[" . implode(",", $init["SELECTION"]) . "]";
$this->commitChanges($actionName, $httpVars, $filesVars);
$this->logInfo("Delete (svn delegate)", array("files" => $init["SELECTION"]));
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage("The selected files/folders have been deleted (by SVN)", null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
}
/**
* Error Catcher for PHP errors. Depending on the SERVER_DEBUG config
* shows the file/line info or not.
* @static
* @param $code
* @param $message
* @param $fichier
* @param $ligne
* @param $context
*/
public static function catchError($code, $message, $fichier, $ligne, $context)
{
if (error_reporting() == 0) {
return;
}
AJXP_Logger::error(basename($fichier), "error l.{$ligne}", array("message" => $message));
if (ConfService::getConf("SERVER_DEBUG")) {
$stack = debug_backtrace();
$stackLen = count($stack);
for ($i = 1; $i < $stackLen; $i++) {
$entry = $stack[$i];
$func = $entry['function'] . '(';
$argsLen = count($entry['args']);
for ($j = 0; $j < $argsLen; $j++) {
$s = $entry['args'][$j];
if (is_string($s)) {
$func .= $s;
} else {
if (is_object($s)) {
$func .= get_class($s);
}
}
if ($j < $argsLen - 1) {
$func .= ', ';
}
}
$func .= ')';
$message .= "\n" . str_replace(dirname(__FILE__), '', $entry['file']) . ':' . $entry['line'] . ' - ' . $func . PHP_EOL;
}
}
if (!headers_sent()) {
AJXP_XMLWriter::header();
}
if (!empty($context) && is_object($context) && is_a($context, "AJXP_PromptException")) {
AJXP_XMLWriter::write("<prompt type=\"" . $context->getPromptType() . "\"><message>" . $message . "</message><data><![CDATA[" . json_encode($context->getPromptData()) . "]]></data></prompt>", true);
} else {
AJXP_XMLWriter::sendMessage(null, SystemTextEncoding::toUTF8($message), true);
}
AJXP_XMLWriter::close();
exit(1);
}
function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->actions[$action])) {
return;
}
$xmlBuffer = "";
foreach ($httpVars as $getName => $getValue) {
${$getName} = Utils::securePath(SystemTextEncoding::magicDequote($getValue));
}
$selection = new UserSelection();
$selection->initFromHttpVars($httpVars);
if (isset($dir) && $action != "upload") {
$safeDir = $dir;
$dir = SystemTextEncoding::fromUTF8($dir);
}
if (isset($dest)) {
$dest = SystemTextEncoding::fromUTF8($dest);
}
$mess = ConfService::getMessages();
$newArgs = RecycleBinManager::filterActions($action, $selection, $dir);
foreach ($newArgs as $argName => $argValue) {
${$argName} = $argValue;
}
// FILTER DIR PAGINATION ANCHOR
if (isset($dir) && strstr($dir, "#") !== false) {
$parts = explode("#", $dir);
$dir = $parts[0];
$page = $parts[1];
}
switch ($action) {
//------------------------------------
// DOWNLOAD, IMAGE & MP3 PROXYS
//------------------------------------
case "download":
AJXP_Logger::logAction("Download", array("files" => $selection));
set_error_handler(array("HTMLWriter", "javascriptErrorHandler"), E_ALL & ~E_NOTICE);
register_shutdown_function("restore_error_handler");
if ($selection->inZip) {
$tmpDir = dirname($selection->getZipPath()) . "/.tmpExtractDownload";
$delDir = $this->getPath() . "/" . $tmpDir;
@mkdir($delDir);
register_shutdown_function(array($this, "deldir"), $delDir);
$this->convertSelectionToTmpFiles($tmpDir, $selection);
}
$zip = false;
if ($selection->isUnique()) {
if (is_dir($this->getPath() . "/" . $selection->getUniqueFile())) {
$zip = true;
$dir .= "/" . basename($selection->getUniqueFile());
}
} else {
$zip = true;
}
if ($zip) {
// Make a temp zip and send it as download
$loggedUser = AuthService::getLoggedUser();
$file = USERS_DIR . "/" . ($loggedUser ? $loggedUser->getId() : "shared") . "/" . time() . "tmpDownload.zip";
$zipFile = $this->makeZip($selection->getFiles(), $file, $dir);
if (!$zipFile) {
AJXP_Exception::errorToXml("Error while compressing");
}
register_shutdown_function("unlink", $file);
$localName = (basename($dir) == "" ? "Files" : basename($dir)) . ".zip";
$this->readFile($file, "force-download", $localName, false, false);
} else {
$this->readFile($this->getPath() . "/" . $selection->getUniqueFile(), "force-download");
}
exit(0);
break;
case "compress":
// Make a temp zip and send it as download
if (isset($archive_name)) {
$localName = SystemTextEncoding::fromUTF8($archive_name);
} else {
$localName = (basename($dir) == "" ? "Files" : basename($dir)) . ".zip";
}
$file = $this->getPath() . "/" . $dir . "/" . $localName;
$zipFile = $this->makeZip($selection->getFiles(), $file, $dir);
if (!$zipFile) {
AJXP_Exception::errorToXml("Error while compressing file {$localName}");
}
$reload_current_node = true;
$reload_file_list = $localName;
break;
case "image_proxy":
if ($split = UserSelection::detectZip(SystemTextEncoding::fromUTF8($file))) {
require_once "server/classes/pclzip.lib.php";
$zip = new PclZip($this->getPath() . $split[0]);
$data = $zip->extract(PCLZIP_OPT_BY_NAME, substr($split[1], 1), PCLZIP_OPT_EXTRACT_AS_STRING);
header("Content-Type: " . Utils::getImageMimeType(basename($split[1])) . "; name=\"" . basename($split[1]) . "\"");
header("Content-Length: " . strlen($data[0]["content"]));
header('Cache-Control: public');
print $data[0]["content"];
} else {
if (isset($get_thumb) && $get_thumb == "true" && $this->driverConf["GENERATE_THUMBNAIL"]) {
require_once "server/classes/PThumb.lib.php";
$pThumb = new PThumb($this->driverConf["THUMBNAIL_QUALITY"]);
if (!$pThumb->isError()) {
$pThumb->use_cache = $this->driverConf["USE_THUMBNAIL_CACHE"];
$pThumb->cache_dir = $this->driverConf["THUMBNAIL_CACHE_DIR"];
$pThumb->fit_thumbnail($this->getPath() . "/" . SystemTextEncoding::fromUTF8($file), 200);
if ($pThumb->isError()) {
print_r($pThumb->error_array);
}
exit(0);
}
}
$this->readFile($this->getPath() . "/" . SystemTextEncoding::fromUTF8($file), "image");
}
exit(0);
break;
case "mp3_proxy":
if ($split = UserSelection::detectZip(SystemTextEncoding::fromUTF8($file))) {
require_once "server/classes/pclzip.lib.php";
$zip = new PclZip($this->getPath() . $split[0]);
$data = $zip->extract(PCLZIP_OPT_BY_NAME, substr($split[1], 1), PCLZIP_OPT_EXTRACT_AS_STRING);
header("Content-Type: audio/mp3; name=\"" . basename($split[1]) . "\"");
header("Content-Length: " . strlen($data[0]["content"]));
print $data[0]["content"];
} else {
$this->readFile($this->getPath() . "/" . SystemTextEncoding::fromUTF8($file), "mp3");
}
exit(0);
break;
//------------------------------------
// ONLINE EDIT
//------------------------------------
//------------------------------------
// ONLINE EDIT
//------------------------------------
case "edit":
if (isset($save) && $save == 1 && isset($code)) {
// Reload "code" variable directly from POST array, do not "securePath"...
$code = $_POST["code"];
AJXP_Logger::logAction("Online Edition", array("file" => SystemTextEncoding::fromUTF8($file)));
$code = stripslashes($code);
$code = str_replace("<", "<", $code);
$fileName = $this->getPath() . SystemTextEncoding::fromUTF8("/{$file}");
if (!is_file($fileName) || !is_writable($fileName)) {
header("Content-Type:text/plain");
print !is_writable($fileName) ? "1001" : "1002";
exit(1);
}
$fp = fopen($fileName, "w");
fputs($fp, $code);
fclose($fp);
header("Content-Type:text/plain");
print $mess[115];
} else {
$this->readFile($this->getPath() . "/" . SystemTextEncoding::fromUTF8($file), "plain");
}
exit(0);
break;
//------------------------------------
// COPY / MOVE
//------------------------------------
//------------------------------------
// COPY / MOVE
//------------------------------------
case "copy":
case "move":
if ($selection->isEmpty()) {
$errorMessage = $mess[113];
break;
}
if ($selection->inZip()) {
$tmpDir = dirname($selection->getZipPath()) . "/.tmpExtractDownload";
@mkdir($this->getPath() . "/" . $tmpDir);
$this->convertSelectionToTmpFiles($tmpDir, $selection);
if (is_dir($tmpDir)) {
$this->deldir($this->getPath() . "/" . $tmpDir);
}
}
$success = $error = array();
$this->copyOrMove($dest, $selection->getFiles(), $error, $success, $action == "move" ? true : false);
if (count($error)) {
$errorMessage = join("\n", $error);
} else {
$logMessage = join("\n", $success);
AJXP_Logger::logAction($action == "move" ? "Move" : "Copy", array("files" => $selection, "destination" => $dest));
}
$reload_current_node = true;
if (isset($dest_node)) {
$reload_dest_node = $dest_node;
}
$reload_file_list = true;
break;
//------------------------------------
// SUPPRIMER / DELETE
//------------------------------------
//------------------------------------
// SUPPRIMER / DELETE
//------------------------------------
case "delete":
if ($selection->isEmpty()) {
$errorMessage = $mess[113];
break;
}
$logMessages = array();
$errorMessage = $this->delete($selection->getFiles(), $logMessages);
if (count($logMessages)) {
$logMessage = join("\n", $logMessages);
}
AJXP_Logger::logAction("Delete", array("files" => $selection));
$reload_current_node = true;
$reload_file_list = true;
break;
//------------------------------------
// RENOMMER / RENAME
//------------------------------------
//------------------------------------
// RENOMMER / RENAME
//------------------------------------
case "rename":
$file = SystemTextEncoding::fromUTF8($file);
$filename_new = SystemTextEncoding::fromUTF8($filename_new);
$error = $this->rename($file, $filename_new);
if ($error != null) {
$errorMessage = $error;
break;
}
$logMessage = SystemTextEncoding::toUTF8($file) . " {$mess['41']} " . SystemTextEncoding::toUTF8($filename_new);
$reload_current_node = true;
$reload_file_list = basename($filename_new);
AJXP_Logger::logAction("Rename", array("original" => $file, "new" => $filename_new));
break;
//------------------------------------
// CREER UN REPERTOIRE / CREATE DIR
//------------------------------------
//------------------------------------
// CREER UN REPERTOIRE / CREATE DIR
//------------------------------------
case "mkdir":
$messtmp = "";
$dirname = Utils::processFileName(SystemTextEncoding::fromUTF8($dirname));
$error = $this->mkDir($dir, $dirname);
if (isset($error)) {
$errorMessage = $error;
break;
}
$reload_file_list = $dirname;
$messtmp .= "{$mess['38']} " . SystemTextEncoding::toUTF8($dirname) . " {$mess['39']} ";
if ($dir == "") {
$messtmp .= "/";
} else {
$messtmp .= SystemTextEncoding::toUTF8($dir);
}
$logMessage = $messtmp;
$reload_current_node = true;
AJXP_Logger::logAction("Create Dir", array("dir" => $dir . "/" . $dirname));
break;
//------------------------------------
// CREER UN FICHIER / CREATE FILE
//------------------------------------
//------------------------------------
// CREER UN FICHIER / CREATE FILE
//------------------------------------
case "mkfile":
$messtmp = "";
$filename = Utils::processFileName(SystemTextEncoding::fromUTF8($filename));
$error = $this->createEmptyFile($dir, $filename);
if (isset($error)) {
$errorMessage = $error;
break;
}
$messtmp .= "{$mess['34']} " . SystemTextEncoding::toUTF8($filename) . " {$mess['39']} ";
if ($dir == "") {
$messtmp .= "/";
} else {
$messtmp .= SystemTextEncoding::toUTF8($dir);
}
$logMessage = $messtmp;
$reload_file_list = $filename;
AJXP_Logger::logAction("Create File", array("file" => $dir . "/" . $filename));
break;
//------------------------------------
// CHANGE FILE PERMISSION
//------------------------------------
//------------------------------------
// CHANGE FILE PERMISSION
//------------------------------------
case "chmod":
$messtmp = "";
$files = $selection->getFiles();
$changedFiles = array();
foreach ($files as $fileName) {
$error = $this->chmod($this->getPath() . $fileName, $chmod_value, $recursive == "on", $recursive == "on" ? $recur_apply_to : "both", $changedFiles);
}
if (isset($error)) {
$errorMessage = $error;
break;
}
//$messtmp.="$mess[34] ".SystemTextEncoding::toUTF8($filename)." $mess[39] ";
$logMessage = "Successfully changed permission to " . $chmod_value . " for " . count($changedFiles) . " files or folders";
$reload_file_list = $dir;
AJXP_Logger::logAction("Chmod", array("dir" => $dir, "filesCount" => count($changedFiles)));
break;
//------------------------------------
// UPLOAD
//------------------------------------
//------------------------------------
// UPLOAD
//------------------------------------
case "upload":
$fancyLoader = false;
if (isset($fileVars["Filedata"])) {
$fancyLoader = true;
if ($dir != "") {
$dir = "/" . base64_decode($dir);
}
}
if ($dir != "") {
$rep_source = "/{$dir}";
} else {
$rep_source = "";
}
$destination = SystemTextEncoding::fromUTF8($this->getPath() . $rep_source);
if (!$this->isWriteable($destination)) {
global $_GET;
$errorMessage = "{$mess['38']} " . SystemTextEncoding::toUTF8($dir) . " {$mess['99']}.";
if ($fancyLoader || isset($_GET["ajxp_sessid"])) {
header('HTTP/1.0 412 ' . $errorMessage);
die('Error 412 ' . $errorMessage);
} else {
print "\n if(parent.ajaxplorer.actionBar.multi_selector)parent.ajaxplorer.actionBar.multi_selector.submitNext('" . str_replace("'", "\\'", $errorMessage) . "');";
break;
}
}
$logMessage = "";
foreach ($fileVars as $boxName => $boxData) {
if ($boxName != "Filedata" && substr($boxName, 0, 9) != "userfile_") {
continue;
}
if ($boxName == "Filedata") {
$fancyLoader = true;
}
$err = Utils::parseFileDataErrors($boxData, $fancyLoader);
if ($err != null) {
$errorMessage = $err;
break;
}
$userfile_name = $boxData["name"];
if ($fancyLoader) {
$userfile_name = SystemTextEncoding::fromUTF8($userfile_name);
}
$userfile_name = Utils::processFileName($userfile_name);
if (isset($auto_rename)) {
$userfile_name = fsDriver::autoRenameForDest($destination, $userfile_name);
}
if (!move_uploaded_file($boxData["tmp_name"], "{$destination}/" . $userfile_name)) {
$errorMessage = ($fancyLoader ? "411 " : "") . "{$mess['33']} " . $userfile_name;
break;
}
$this->changeMode($destination . "/" . $userfile_name);
$logMessage .= "{$mess['34']} " . SystemTextEncoding::toUTF8($userfile_name) . " {$mess['35']} {$dir}";
AJXP_Logger::logAction("Upload File", array("file" => SystemTextEncoding::fromUTF8($dir) . "/" . $userfile_name));
}
if ($fancyLoader) {
if (isset($errorMessage)) {
header('HTTP/1.0 ' . $errorMessage);
die('Error ' . $errorMessage);
} else {
header('HTTP/1.0 200 OK');
die("200 OK");
}
} else {
print "<html><script language=\"javascript\">\n";
if (isset($errorMessage)) {
print "\n if(parent.ajaxplorer.actionBar.multi_selector)parent.ajaxplorer.actionBar.multi_selector.submitNext('" . str_replace("'", "\\'", $errorMessage) . "');";
} else {
print "\n if(parent.ajaxplorer.actionBar.multi_selector)parent.ajaxplorer.actionBar.multi_selector.submitNext();";
}
print "</script></html>";
}
exit;
break;
//------------------------------------
// Public URL
//------------------------------------
//------------------------------------
// Public URL
//------------------------------------
case "public_url":
$file = SystemTextEncoding::fromUTF8($file);
$url = $this->makePubliclet($file, $password, $expiration);
header("Content-type:text/plain");
echo $url;
exit(1);
break;
//------------------------------------
// XML LISTING
//------------------------------------
//------------------------------------
// XML LISTING
//------------------------------------
case "ls":
if (!isset($dir) || $dir == "/") {
$dir = "";
}
$searchMode = $fileListMode = $completeMode = false;
if (isset($mode)) {
if ($mode == "search") {
$searchMode = true;
} else {
if ($mode == "file_list") {
$fileListMode = true;
} else {
if ($mode == "complete") {
$completeMode = true;
}
}
}
}
if (isset($skipZip) && $skipZip == "true") {
$skipZip = true;
} else {
$skipZip = false;
}
if ($test = UserSelection::detectZip($dir)) {
$liste = array();
$zip = $this->zipListing($test[0], $test[1], $liste);
AJXP_XMLWriter::header();
$tmpDir = $this->getPath() . dirname($test[0]) . ".tmpZipExtract";
foreach ($liste as $zipEntry) {
$atts = array();
if (!$fileListMode && !$zipEntry["folder"]) {
continue;
}
$atts[] = "is_file=\"" . ($zipEntry["folder"] ? "false" : "true") . "\"";
$atts[] = "text=\"" . Utils::xmlEntities(basename(SystemTextEncoding::toUTF8($zipEntry["stored_filename"]))) . "\"";
$atts[] = "filename=\"" . Utils::xmlEntities(SystemTextEncoding::toUTF8($zipEntry["filename"])) . "\"";
if ($fileListMode) {
$atts[] = "filesize=\"" . Utils::roundSize($zipEntry["size"]) . "\"";
$atts[] = "bytesize=\"" . $zipEntry["size"] . "\"";
$atts[] = "ajxp_modiftime=\"" . $zipEntry["mtime"] . "\"";
$atts[] = "mimestring=\"" . Utils::mimetype($zipEntry["stored_filename"], "mime", $zipEntry["folder"]) . "\"";
$atts[] = "icon=\"" . Utils::mimetype($zipEntry["stored_filename"], "image", $zipEntry["folder"]) . "\"";
$is_image = Utils::is_image(basename($zipEntry["stored_filename"]));
$atts[] = "is_image=\"" . $is_image . "\"";
if ($is_image) {
if (!is_dir($tmpDir)) {
mkdir($tmpDir);
}
$currentFile = $tmpDir . "/" . basename($zipEntry["stored_filename"]);
$data = $zip->extract(PCLZIP_OPT_BY_NAME, $zipEntry["stored_filename"], PCLZIP_OPT_REMOVE_ALL_PATH, PCLZIP_OPT_PATH, $tmpDir);
list($width, $height, $type, $attr) = @getimagesize($currentFile);
$atts[] = "image_type=\"" . image_type_to_mime_type($type) . "\"";
$atts[] = "image_width=\"{$width}\"";
$atts[] = "image_height=\"{$height}\"";
unlink($currentFile);
}
} else {
$atts[] = "icon=\"client/images/foldericon.png\"";
$atts[] = "openicon=\"client/images/foldericon.png\"";
$atts[] = "src=\"content.php?dir=" . urlencode(SystemTextEncoding::toUTF8($zipEntry["filename"])) . "\"";
}
print "<tree " . join(" ", $atts) . "/>";
}
if (is_dir($tmpDir)) {
rmdir($tmpDir);
}
AJXP_XMLWriter::close();
exit(0);
}
$nom_rep = $this->initName($dir);
AJXP_Exception::errorToXml($nom_rep);
$threshold = $this->repository->getOption("PAGINATION_THRESHOLD");
if (!isset($threshold) || intval($threshold) == 0) {
$threshold = 500;
}
$limitPerPage = $this->repository->getOption("PAGINATION_NUMBER");
if (!isset($limitPerPage) || intval($limitPerPage) == 0) {
$limitPerPage = 200;
}
if ($fileListMode) {
$countFiles = $this->countFiles($nom_rep);
if ($countFiles > $threshold) {
$offset = 0;
$crtPage = 1;
if (isset($page)) {
$offset = (intval($page) - 1) * $limitPerPage;
$crtPage = $page;
}
$totalPages = floor($countFiles / $limitPerPage) + 1;
$reps = $this->listing($nom_rep, false, $offset, $limitPerPage);
} else {
$reps = $this->listing($nom_rep, $searchMode);
}
} else {
$countFolders = $this->countFiles($nom_rep, true);
if ($countFolders > $threshold) {
AJXP_XMLWriter::header();
$icon = CLIENT_RESOURCES_FOLDER . "/images/foldericon.png";
$openicon = CLIENT_RESOURCES_FOLDER . "/images/openfoldericon.png";
$attributes = "icon=\"{$icon}\" openicon=\"{$openicon}\"";
print "<tree text=\"{$mess['306']} ({$countFolders})...\" {$attributes}></tree>";
AJXP_XMLWriter::close();
exit(1);
}
$reps = $this->listing($nom_rep, !$searchMode);
}
//$reps = $result[0];
AJXP_XMLWriter::header();
if (isset($totalPages) && isset($crtPage)) {
//print '<columns switchDisplayMode="list" switchGridMode="filelist"/>';
print '<pagination count="' . $countFiles . '" total="' . $totalPages . '" current="' . $crtPage . '"/>';
}
foreach ($reps as $repIndex => $repName) {
if (preg_match("/\\.zip\$/", $repName) && $skipZip) {
continue;
}
$attributes = "";
if ($searchMode) {
if (is_file($nom_rep . "/" . $repIndex)) {
$attributes = "is_file=\"true\" icon=\"{$repName}\"";
$repName = $repIndex;
}
} else {
if ($fileListMode) {
$currentFile = $nom_rep . "/" . $repIndex;
$atts = array();
$atts[] = "is_file=\"" . (is_file($currentFile) ? "1" : "0") . "\"";
$atts[] = "is_image=\"" . Utils::is_image($currentFile) . "\"";
$fGroup = @filegroup($currentFile) || "unknown";
$atts[] = "file_group=\"" . $fGroup . "\"";
$fOwner = @fileowner($currentFile) || "unknown";
$atts[] = "file_owner=\"" . $fOwner . "\"";
$fPerms = @fileperms($currentFile);
if ($fPerms !== false) {
$fPerms = substr(decoct($fPerms), is_file($currentFile) ? 2 : 1);
} else {
$fPerms = '0000';
}
$atts[] = "file_perms=\"" . $fPerms . "\"";
if (Utils::is_image($currentFile)) {
list($width, $height, $type, $attr) = @getimagesize($currentFile);
$atts[] = "image_type=\"" . image_type_to_mime_type($type) . "\"";
$atts[] = "image_width=\"{$width}\"";
$atts[] = "image_height=\"{$height}\"";
}
$atts[] = "mimestring=\"" . Utils::mimetype($currentFile, "type", is_dir($currentFile)) . "\"";
$datemodif = $this->date_modif($currentFile);
$atts[] = "ajxp_modiftime=\"" . ($datemodif ? $datemodif : "0") . "\"";
$bytesize = @filesize($currentFile) or 0;
if ($bytesize < 0) {
$bytesize = sprintf("%u", $bytesize);
}
$atts[] = "filesize=\"" . Utils::roundSize($bytesize) . "\"";
$atts[] = "bytesize=\"" . $bytesize . "\"";
$atts[] = "filename=\"" . Utils::xmlEntities(SystemTextEncoding::toUTF8($dir . "/" . $repIndex)) . "\"";
$atts[] = "icon=\"" . (is_file($currentFile) ? SystemTextEncoding::toUTF8($repName) : (is_dir($currentFile) ? "folder.png" : "mime-empty.png")) . "\"";
$attributes = join(" ", $atts);
$repName = $repIndex;
} else {
$folderBaseName = Utils::xmlEntities($repName);
$link = SystemTextEncoding::toUTF8(SERVER_ACCESS . "?dir=" . $dir . "/" . $folderBaseName);
$link = urlencode($link);
$folderFullName = Utils::xmlEntities($dir) . "/" . $folderBaseName;
$parentFolderName = $dir;
if (!$completeMode) {
$icon = CLIENT_RESOURCES_FOLDER . "/images/foldericon.png";
$openicon = CLIENT_RESOURCES_FOLDER . "/images/openfoldericon.png";
if (preg_match("/\\.zip\$/", $repName)) {
$icon = $openicon = CLIENT_RESOURCES_FOLDER . "/images/crystal/actions/16/accessories-archiver.png";
}
$attributes = "icon=\"{$icon}\" openicon=\"{$openicon}\" filename=\"" . SystemTextEncoding::toUTF8($folderFullName) . "\" src=\"{$link}\"";
}
}
}
print "<tree text=\"" . Utils::xmlEntities(SystemTextEncoding::toUTF8($repName)) . "\" {$attributes}>";
print "</tree>";
}
// ADD RECYCLE BIN TO THE LIST
if ($nom_rep == $this->repository->getOption("PATH") && RecycleBinManager::recycleEnabled() && !$completeMode && !$skipZip) {
$recycleBinOption = $this->repository->getOption("RECYCLE_BIN");
if (is_dir($this->repository->getOption("PATH") . "/" . $recycleBinOption)) {
$recycleIcon = $this->countFiles($this->repository->getOption("PATH") . "/" . $recycleBinOption, false, true) > 0 ? "trashcan_full.png" : "trashcan.png";
if ($fileListMode) {
print "<tree text=\"" . Utils::xmlEntities($mess[122]) . "\" filesize=\"-\" is_file=\"0\" is_recycle=\"1\" mimestring=\"Trashcan\" ajxp_modiftime=\"" . $this->date_modif($this->repository->getOption("PATH") . "/" . $recycleBinOption) . "\" filename=\"/" . $recycleBinOption . "\" icon=\"{$recycleIcon}\"></tree>";
} else {
print "<tree text=\"{$mess['122']}\" is_recycle=\"true\" icon=\"" . CLIENT_RESOURCES_FOLDER . "/images/crystal/mimes/16/{$recycleIcon}\" openIcon=\"" . CLIENT_RESOURCES_FOLDER . "/images/crystal/mimes/16/{$recycleIcon}\" filename=\"/" . $recycleBinOption . "\"/>";
}
}
}
AJXP_XMLWriter::close();
exit(1);
break;
}
if (isset($logMessage) || isset($errorMessage)) {
$xmlBuffer .= AJXP_XMLWriter::sendMessage(isset($logMessage) ? $logMessage : null, isset($errorMessage) ? $errorMessage : null, false);
}
if (isset($requireAuth)) {
$xmlBuffer .= AJXP_XMLWriter::requireAuth(false);
}
if (isset($reload_current_node) && $reload_current_node == "true") {
$xmlBuffer .= AJXP_XMLWriter::reloadCurrentNode(false);
}
if (isset($reload_dest_node) && $reload_dest_node != "") {
$xmlBuffer .= AJXP_XMLWriter::reloadNode($reload_dest_node, false);
}
if (isset($reload_file_list)) {
$xmlBuffer .= AJXP_XMLWriter::reloadFileList($reload_file_list, false);
}
return $xmlBuffer;
}
public function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->actions[$action])) {
return;
}
$xmlBuffer = "";
foreach ($httpVars as $getName => $getValue) {
${$getName} = AJXP_Utils::securePath($getValue);
}
if (isset($dir) && $action != "upload") {
$dir = SystemTextEncoding::fromUTF8($dir);
}
$mess = ConfService::getMessages();
switch ($action) {
//------------------------------------
// SWITCH THE ROOT REPOSITORY
//------------------------------------
case "switch_repository":
if (!isset($repository_id)) {
break;
}
$dirList = ConfService::getRepositoriesList();
/** @var $repository_id string */
if (!isset($dirList[$repository_id])) {
$errorMessage = "Trying to switch to an unkown repository!";
break;
}
ConfService::switchRootDir($repository_id);
// Load try to init the driver now, to trigger an exception
// if it's not loading right.
ConfService::loadRepositoryDriver();
if (AuthService::usersEnabled() && AuthService::getLoggedUser() != null) {
$user = AuthService::getLoggedUser();
$activeRepId = ConfService::getCurrentRepositoryId();
$user->setArrayPref("history", "last_repository", $activeRepId);
$user->save("user");
}
//$logMessage = "Successfully Switched!";
$this->logInfo("Switch Repository", array("rep. id" => $repository_id));
break;
//------------------------------------
// SEND XML REGISTRY
//------------------------------------
//------------------------------------
// SEND XML REGISTRY
//------------------------------------
case "get_xml_registry":
case "state":
$regDoc = AJXP_PluginsService::getXmlRegistry();
$changes = AJXP_Controller::filterRegistryFromRole($regDoc);
if ($changes) {
AJXP_PluginsService::updateXmlRegistry($regDoc);
}
$clone = $regDoc->cloneNode(true);
$clonePath = new DOMXPath($clone);
$serverCallbacks = $clonePath->query("//serverCallback|hooks");
foreach ($serverCallbacks as $callback) {
$callback->parentNode->removeChild($callback);
}
$xPath = '';
if (isset($httpVars["xPath"])) {
$xPath = ltrim(AJXP_Utils::securePath($httpVars["xPath"]), "/");
}
if (!empty($xPath)) {
$nodes = $clonePath->query($xPath);
if ($httpVars["format"] == "json") {
$data = AJXP_XMLWriter::xmlToArray($nodes->item(0));
HTMLWriter::charsetHeader("application/json");
echo json_encode($data);
} else {
AJXP_XMLWriter::header("ajxp_registry_part", array("xPath" => $xPath));
if ($nodes->length) {
print AJXP_XMLWriter::replaceAjxpXmlKeywords($clone->saveXML($nodes->item(0)));
}
AJXP_XMLWriter::close("ajxp_registry_part");
}
} else {
AJXP_Utils::safeIniSet("zlib.output_compression", "4096");
if ($httpVars["format"] == "json") {
$data = AJXP_XMLWriter::xmlToArray($clone);
HTMLWriter::charsetHeader("application/json");
echo json_encode($data);
} else {
header('Content-Type: application/xml; charset=UTF-8');
print AJXP_XMLWriter::replaceAjxpXmlKeywords($clone->saveXML());
}
}
break;
//------------------------------------
// BOOKMARK BAR
//------------------------------------
//------------------------------------
// BOOKMARK BAR
//------------------------------------
case "get_bookmarks":
$bmUser = null;
if (AuthService::usersEnabled() && AuthService::getLoggedUser() != null) {
$bmUser = AuthService::getLoggedUser();
} else {
if (!AuthService::usersEnabled()) {
$confStorage = ConfService::getConfStorageImpl();
$bmUser = $confStorage->createUserObject("shared");
}
}
if ($bmUser == null) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::close();
}
$driver = ConfService::loadRepositoryDriver();
if (!is_a($driver, "AjxpWrapperProvider")) {
$driver = false;
}
if (isset($httpVars["bm_action"]) && isset($httpVars["bm_path"])) {
$bmPath = AJXP_Utils::decodeSecureMagic($httpVars["bm_path"]);
if ($httpVars["bm_action"] == "add_bookmark") {
$title = "";
if (isset($httpVars["bm_title"])) {
$title = AJXP_Utils::decodeSecureMagic($httpVars["bm_title"]);
}
if ($title == "" && $bmPath == "/") {
$title = ConfService::getCurrentRootDirDisplay();
}
$bmUser->addBookMark($bmPath, $title);
if ($driver) {
$node = new AJXP_Node($driver->getResourceUrl($bmPath));
$node->setMetadata("ajxp_bookmarked", array("ajxp_bookmarked" => "true"), true, AJXP_METADATA_SCOPE_REPOSITORY, true);
}
} else {
if ($httpVars["bm_action"] == "delete_bookmark") {
$bmUser->removeBookmark($bmPath);
if ($driver) {
$node = new AJXP_Node($driver->getResourceUrl($bmPath));
$node->removeMetadata("ajxp_bookmarked", true, AJXP_METADATA_SCOPE_REPOSITORY, true);
}
} else {
if ($httpVars["bm_action"] == "rename_bookmark" && isset($httpVars["bm_title"])) {
$title = AJXP_Utils::decodeSecureMagic($httpVars["bm_title"]);
$bmUser->renameBookmark($bmPath, $title);
}
}
}
AJXP_Controller::applyHook("msg.instant", array("<reload_bookmarks/>", ConfService::getRepository()->getId()));
if (AuthService::usersEnabled() && AuthService::getLoggedUser() != null) {
$bmUser->save("user");
AuthService::updateUser($bmUser);
} else {
if (!AuthService::usersEnabled()) {
$bmUser->save("user");
}
}
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::writeBookmarks($bmUser->getBookmarks(), true, isset($httpVars["format"]) ? $httpVars["format"] : "legacy");
AJXP_XMLWriter::close();
break;
//------------------------------------
// SAVE USER PREFERENCE
//------------------------------------
//------------------------------------
// SAVE USER PREFERENCE
//------------------------------------
case "save_user_pref":
$userObject = AuthService::getLoggedUser();
$i = 0;
while (isset($httpVars["pref_name_" . $i]) && isset($httpVars["pref_value_" . $i])) {
$prefName = AJXP_Utils::sanitize($httpVars["pref_name_" . $i], AJXP_SANITIZE_ALPHANUM);
$prefValue = AJXP_Utils::sanitize(SystemTextEncoding::magicDequote($httpVars["pref_value_" . $i]));
if ($prefName == "password") {
continue;
}
if ($prefName != "pending_folder" && $userObject == null) {
$i++;
continue;
}
$userObject->setPref($prefName, $prefValue);
$userObject->save("user");
AuthService::updateUser($userObject);
//setcookie("AJXP_$prefName", $prefValue);
$i++;
}
header("Content-Type:text/plain");
print "SUCCESS";
break;
//------------------------------------
// SAVE USER PREFERENCE
//------------------------------------
//------------------------------------
// SAVE USER PREFERENCE
//------------------------------------
case "custom_data_edit":
case "user_create_user":
$data = array();
if ($action == "user_create_user" && isset($httpVars["NEW_new_user_id"])) {
$updating = false;
AJXP_Utils::parseStandardFormParameters($httpVars, $data, null, "NEW_");
$original_id = AJXP_Utils::decodeSecureMagic($data["new_user_id"]);
$data["new_user_id"] = AJXP_Utils::decodeSecureMagic($data["new_user_id"], AJXP_SANITIZE_EMAILCHARS);
if ($original_id != $data["new_user_id"]) {
throw new Exception(str_replace("%s", $data["new_user_id"], $mess["ajxp_conf.127"]));
}
if (AuthService::userExists($data["new_user_id"], "w")) {
throw new Exception($mess["ajxp_conf.43"]);
}
$loggedUser = AuthService::getLoggedUser();
$limit = $loggedUser->personalRole->filterParameterValue("core.conf", "USER_SHARED_USERS_LIMIT", AJXP_REPO_SCOPE_ALL, "");
if (!empty($limit) && intval($limit) > 0) {
$count = count($this->getUserChildren($loggedUser->getId()));
if ($count >= $limit) {
throw new Exception($mess['483']);
}
}
AuthService::createUser($data["new_user_id"], $data["new_password"]);
$userObject = ConfService::getConfStorageImpl()->createUserObject($data["new_user_id"]);
$userObject->setParent($loggedUser->getId());
$userObject->save('superuser');
$userObject->personalRole->clearAcls();
$userObject->setGroupPath($loggedUser->getGroupPath());
$userObject->setProfile("shared");
} else {
if ($action == "user_create_user" && isset($httpVars["NEW_existing_user_id"])) {
$updating = true;
AJXP_Utils::parseStandardFormParameters($httpVars, $data, null, "NEW_");
$userId = $data["existing_user_id"];
if (!AuthService::userExists($userId)) {
throw new Exception("Cannot find user");
}
$userObject = ConfService::getConfStorageImpl()->createUserObject($userId);
if ($userObject->getParent() != AuthService::getLoggedUser()->getId()) {
throw new Exception("Cannot find user");
}
if (!empty($data["new_password"])) {
AuthService::updatePassword($userId, $data["new_password"]);
}
} else {
$updating = false;
$userObject = AuthService::getLoggedUser();
AJXP_Utils::parseStandardFormParameters($httpVars, $data, null, "PREFERENCES_");
}
}
$paramNodes = AJXP_PluginsService::searchAllManifests("//server_settings/param[contains(@scope,'user') and @expose='true']", "node", false, false, true);
$rChanges = false;
if (is_array($paramNodes) && count($paramNodes)) {
foreach ($paramNodes as $xmlNode) {
if ($xmlNode->getAttribute("expose") == "true") {
$parentNode = $xmlNode->parentNode->parentNode;
$pluginId = $parentNode->getAttribute("id");
if (empty($pluginId)) {
$pluginId = $parentNode->nodeName . "." . $parentNode->getAttribute("name");
}
$name = $xmlNode->getAttribute("name");
if (isset($data[$name]) || $data[$name] === "") {
if ($data[$name] == "__AJXP_VALUE_SET__") {
continue;
}
if ($data[$name] === "" || $userObject->parentRole == null || $userObject->parentRole->filterParameterValue($pluginId, $name, AJXP_REPO_SCOPE_ALL, "") != $data[$name] || $userObject->personalRole->filterParameterValue($pluginId, $name, AJXP_REPO_SCOPE_ALL, "") != $data[$name]) {
$userObject->personalRole->setParameterValue($pluginId, $name, $data[$name]);
$rChanges = true;
}
}
}
}
}
if ($rChanges) {
AuthService::updateRole($userObject->personalRole, $userObject);
$userObject->recomputeMergedRole();
if ($action == "custom_data_edit") {
AuthService::updateUser($userObject);
}
}
if ($action == "user_create_user") {
AJXP_Controller::applyHook($updating ? "user.after_update" : "user.after_create", array($userObject));
if (isset($data["send_email"]) && $data["send_email"] == true && !empty($data["email"])) {
$mailer = AJXP_PluginsService::getInstance()->getUniqueActivePluginForType("mailer");
if ($mailer !== false) {
$mess = ConfService::getMessages();
$link = AJXP_Utils::detectServerURL();
$apptitle = ConfService::getCoreConf("APPLICATION_TITLE");
$subject = str_replace("%s", $apptitle, $mess["507"]);
$body = str_replace(array("%s", "%link", "%user", "%pass"), array($apptitle, $link, $data["new_user_id"], $data["new_password"]), $mess["508"]);
$mailer->sendMail(array($data["email"]), $subject, $body);
}
}
echo "SUCCESS";
} else {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["241"], null);
AJXP_XMLWriter::close();
}
break;
case "user_update_user":
if (!isset($httpVars["user_id"])) {
throw new Exception("invalid arguments");
}
$userId = $httpVars["user_id"];
if (!AuthService::userExists($userId)) {
throw new Exception("Cannot find user");
}
$userObject = ConfService::getConfStorageImpl()->createUserObject($userId);
if ($userObject->getParent() != AuthService::getLoggedUser()->getId()) {
throw new Exception("Cannot find user");
}
$paramsString = ConfService::getCoreConf("NEWUSERS_EDIT_PARAMETERS", "conf");
$result = array();
$params = explode(",", $paramsString);
foreach ($params as $p) {
$result[$p] = $userObject->personalRole->filterParameterValue("core.conf", $p, AJXP_REPO_SCOPE_ALL, "");
}
HTMLWriter::charsetHeader("application/json");
echo json_encode($result);
break;
//------------------------------------
// WEBDAV PREFERENCES
//------------------------------------
//------------------------------------
// WEBDAV PREFERENCES
//------------------------------------
case "webdav_preferences":
$userObject = AuthService::getLoggedUser();
$webdavActive = false;
$passSet = false;
$digestSet = false;
// Detect http/https and host
if (ConfService::getCoreConf("WEBDAV_BASEHOST") != "") {
$baseURL = ConfService::getCoreConf("WEBDAV_BASEHOST");
} else {
$baseURL = AJXP_Utils::detectServerURL();
}
$webdavBaseUrl = $baseURL . ConfService::getCoreConf("WEBDAV_BASEURI") . "/";
$davData = $userObject->getPref("AJXP_WEBDAV_DATA");
$digestSet = isset($davData["HA1"]);
if (isset($httpVars["activate"]) || isset($httpVars["webdav_pass"])) {
if (!empty($httpVars["activate"])) {
$activate = $httpVars["activate"] == "true" ? true : false;
if (empty($davData)) {
$davData = array();
}
$davData["ACTIVE"] = $activate;
}
if (!empty($httpVars["webdav_pass"])) {
$password = $httpVars["webdav_pass"];
if (function_exists('mcrypt_encrypt')) {
$user = $userObject->getId();
$secret = defined("AJXP_SAFE_SECRET_KEY") ? AJXP_SAFE_SECRET_KEY : "CDAFx¨op#";
$password = base64_encode(mcrypt_encrypt(MCRYPT_RIJNDAEL_256, md5($user . $secret), $password, MCRYPT_MODE_ECB));
}
$davData["PASS"] = $password;
}
$userObject->setPref("AJXP_WEBDAV_DATA", $davData);
$userObject->save("user");
}
if (!empty($davData)) {
$webdavActive = isset($davData["ACTIVE"]) && $davData["ACTIVE"] === true;
$passSet = isset($davData["PASS"]);
}
$repoList = ConfService::getRepositoriesList();
$davRepos = array();
$loggedUser = AuthService::getLoggedUser();
foreach ($repoList as $repoIndex => $repoObject) {
$accessType = $repoObject->getAccessType();
$driver = AJXP_PluginsService::getInstance()->getPluginByTypeName("access", $accessType);
if (is_a($driver, "AjxpWrapperProvider") && !$repoObject->getOption("AJXP_WEBDAV_DISABLED") && ($loggedUser->canRead($repoIndex) || $loggedUser->canWrite($repoIndex))) {
$davRepos[$repoIndex] = $webdavBaseUrl . "" . ($repoObject->getSlug() == null ? $repoObject->getId() : $repoObject->getSlug());
}
}
$prefs = array("webdav_active" => $webdavActive, "password_set" => $passSet, "digest_set" => $digestSet, "webdav_force_basic" => ConfService::getCoreConf("WEBDAV_FORCE_BASIC") === true, "webdav_base_url" => $webdavBaseUrl, "webdav_repositories" => $davRepos);
HTMLWriter::charsetHeader("application/json");
print json_encode($prefs);
break;
case "get_user_template_logo":
$tplId = $httpVars["template_id"];
$iconFormat = $httpVars["icon_format"];
$repo = ConfService::getRepositoryById($tplId);
$logo = $repo->getOption("TPL_ICON_" . strtoupper($iconFormat));
if (isset($logo) && is_file(AJXP_DATA_PATH . "/plugins/core.conf/tpl_logos/" . $logo)) {
header("Content-Type: " . AJXP_Utils::getImageMimeType($logo) . "; name=\"" . $logo . "\"");
header("Content-Length: " . filesize(AJXP_DATA_PATH . "/plugins/core.conf/tpl_logos/" . $logo));
header('Pragma:');
header('Cache-Control: public');
header("Last-Modified: " . gmdate("D, d M Y H:i:s", time() - 10000) . " GMT");
header("Expires: " . gmdate("D, d M Y H:i:s", time() + 5 * 24 * 3600) . " GMT");
readfile(AJXP_DATA_PATH . "/plugins/core.conf/tpl_logos/" . $logo);
} else {
$logo = "default_template_logo-" . ($iconFormat == "small" ? 16 : 22) . ".png";
header("Content-Type: " . AJXP_Utils::getImageMimeType($logo) . "; name=\"" . $logo . "\"");
header("Content-Length: " . filesize(AJXP_INSTALL_PATH . "/" . AJXP_PLUGINS_FOLDER . "/core.conf/" . $logo));
header('Pragma:');
header('Cache-Control: public');
header("Last-Modified: " . gmdate("D, d M Y H:i:s", time() - 10000) . " GMT");
header("Expires: " . gmdate("D, d M Y H:i:s", time() + 5 * 24 * 3600) . " GMT");
readfile(AJXP_INSTALL_PATH . "/" . AJXP_PLUGINS_FOLDER . "/core.conf/" . $logo);
}
break;
case "get_user_templates_definition":
AJXP_XMLWriter::header("repository_templates");
$count = 0;
$repositories = ConfService::listRepositoriesWithCriteria(array("isTemplate" => 1), $count);
$pServ = AJXP_PluginsService::getInstance();
foreach ($repositories as $repo) {
if (!$repo->isTemplate) {
continue;
}
if (!$repo->getOption("TPL_USER_CAN_CREATE")) {
continue;
}
$repoId = $repo->getId();
$repoLabel = $repo->getDisplay();
$repoType = $repo->getAccessType();
print "<template repository_id=\"{$repoId}\" repository_label=\"{$repoLabel}\" repository_type=\"{$repoType}\">";
$driverPlug = $pServ->getPluginByTypeName("access", $repoType);
$params = $driverPlug->getManifestRawContent("//param", "node");
$tplDefined = $repo->getOptionsDefined();
$defaultLabel = '';
foreach ($params as $paramNode) {
$name = $paramNode->getAttribute("name");
if (strpos($name, "TPL_") === 0) {
if ($name == "TPL_DEFAULT_LABEL") {
$defaultLabel = str_replace("AJXP_USER", AuthService::getLoggedUser()->getId(), $repo->getOption($name));
}
continue;
}
if (in_array($paramNode->getAttribute("name"), $tplDefined)) {
continue;
}
if ($paramNode->getAttribute('no_templates') == 'true') {
continue;
}
print AJXP_XMLWriter::replaceAjxpXmlKeywords($paramNode->ownerDocument->saveXML($paramNode));
}
// ADD LABEL
echo '<param name="DISPLAY" type="string" label="' . $mess[359] . '" description="' . $mess[429] . '" mandatory="true" default="' . $defaultLabel . '"/>';
print "</template>";
}
AJXP_XMLWriter::close("repository_templates");
break;
case "user_create_repository":
$tplId = $httpVars["template_id"];
$tplRepo = ConfService::getRepositoryById($tplId);
$options = array();
AJXP_Utils::parseStandardFormParameters($httpVars, $options);
$loggedUser = AuthService::getLoggedUser();
$newRep = $tplRepo->createTemplateChild(AJXP_Utils::sanitize($httpVars["DISPLAY"]), $options, null, $loggedUser->getId());
$gPath = $loggedUser->getGroupPath();
if (!empty($gPath)) {
$newRep->setGroupPath($gPath);
}
$res = ConfService::addRepository($newRep);
AJXP_XMLWriter::header();
if ($res == -1) {
AJXP_XMLWriter::sendMessage(null, $mess[426]);
} else {
// Make sure we do not overwrite otherwise loaded rights.
$loggedUser->load();
$loggedUser->personalRole->setAcl($newRep->getUniqueId(), "rw");
$loggedUser->save("superuser");
$loggedUser->recomputeMergedRole();
AuthService::updateUser($loggedUser);
AJXP_XMLWriter::sendMessage($mess[425], null);
AJXP_XMLWriter::reloadDataNode("", $newRep->getUniqueId());
AJXP_XMLWriter::reloadRepositoryList();
}
AJXP_XMLWriter::close();
break;
case "user_delete_repository":
$repoId = $httpVars["repository_id"];
$repository = ConfService::getRepositoryById($repoId);
if (!$repository->getUniqueUser() || $repository->getUniqueUser() != AuthService::getLoggedUser()->getId()) {
throw new Exception("You are not allowed to perform this operation!");
}
$res = ConfService::deleteRepository($repoId);
AJXP_XMLWriter::header();
if ($res == -1) {
AJXP_XMLWriter::sendMessage(null, $mess[427]);
} else {
$loggedUser = AuthService::getLoggedUser();
// Make sure we do not override remotely set rights
$loggedUser->load();
$loggedUser->personalRole->setAcl($repoId, "");
$loggedUser->save("superuser");
AuthService::updateUser($loggedUser);
AJXP_XMLWriter::sendMessage($mess[428], null);
AJXP_XMLWriter::reloadRepositoryList();
}
AJXP_XMLWriter::close();
break;
case "user_delete_user":
$userId = $httpVars["user_id"];
$userObject = ConfService::getConfStorageImpl()->createUserObject($userId);
if ($userObject == null || !$userObject->hasParent() || $userObject->getParent() != AuthService::getLoggedUser()->getId()) {
throw new Exception("You are not allowed to edit this user");
}
AuthService::deleteUser($userId);
echo "SUCCESS";
break;
case "user_list_authorized_users":
$defaultFormat = "html";
HTMLWriter::charsetHeader();
if (!ConfService::getAuthDriverImpl()->usersEditable()) {
break;
}
$loggedUser = AuthService::getLoggedUser();
$crtValue = $httpVars["value"];
$usersOnly = isset($httpVars["users_only"]) && $httpVars["users_only"] == "true";
$existingOnly = isset($httpVars["existing_only"]) && $httpVars["existing_only"] == "true";
if (!empty($crtValue)) {
$regexp = '^' . $crtValue;
} else {
$regexp = null;
}
$skipDisplayWithoutRegexp = ConfService::getCoreConf("USERS_LIST_REGEXP_MANDATORY", "conf");
if ($skipDisplayWithoutRegexp && $regexp == null) {
print "<ul></ul>";
break;
}
$limit = intval(ConfService::getCoreConf("USERS_LIST_COMPLETE_LIMIT", "conf"));
$searchAll = ConfService::getCoreConf("CROSSUSERS_ALLGROUPS", "conf");
$displayAll = ConfService::getCoreConf("CROSSUSERS_ALLGROUPS_DISPLAY", "conf");
$baseGroup = "/";
if ($regexp == null && !$displayAll || $regexp != null && !$searchAll) {
$baseGroup = AuthService::filterBaseGroup("/");
}
AuthService::setGroupFiltering(false);
$allUsers = AuthService::listUsers($baseGroup, $regexp, 0, $limit, false);
if (!$usersOnly) {
$allGroups = array();
$roleOrGroup = ConfService::getCoreConf("GROUP_OR_ROLE", "conf");
$rolePrefix = $excludeString = $includeString = null;
if (!is_array($roleOrGroup)) {
$roleOrGroup = array("group_switch_value" => $roleOrGroup);
}
$listRoleType = false;
if (isset($roleOrGroup["PREFIX"])) {
$rolePrefix = $loggedUser->mergedRole->filterParameterValue("core.conf", "PREFIX", null, $roleOrGroup["PREFIX"]);
$excludeString = $loggedUser->mergedRole->filterParameterValue("core.conf", "EXCLUDED", null, $roleOrGroup["EXCLUDED"]);
$includeString = $loggedUser->mergedRole->filterParameterValue("core.conf", "INCLUDED", null, $roleOrGroup["INCLUDED"]);
$listUserRolesOnly = $loggedUser->mergedRole->filterParameterValue("core.conf", "LIST_ROLE_BY", null, $roleOrGroup["LIST_ROLE_BY"]);
if (is_array($listUserRolesOnly) && isset($listUserRolesOnly["group_switch_value"])) {
switch ($listUserRolesOnly["group_switch_value"]) {
case "userroles":
$listRoleType = true;
break;
case "allroles":
$listRoleType = false;
break;
default:
break;
}
}
}
switch (strtolower($roleOrGroup["group_switch_value"])) {
case 'user':
// donothing
break;
case 'group':
$authGroups = AuthService::listChildrenGroups($baseGroup);
foreach ($authGroups as $gId => $gName) {
$allGroups["AJXP_GRP_" . rtrim($baseGroup, "/") . "/" . ltrim($gId, "/")] = $gName;
}
break;
case 'role':
$allGroups = $this->getUserRoleList($loggedUser, $rolePrefix, $includeString, $excludeString, $listRoleType);
break;
case 'rolegroup':
$groups = array();
$authGroups = AuthService::listChildrenGroups($baseGroup);
foreach ($authGroups as $gId => $gName) {
$groups["AJXP_GRP_" . rtrim($baseGroup, "/") . "/" . ltrim($gId, "/")] = $gName;
}
$roles = $this->getUserRoleList($loggedUser, $rolePrefix, $includeString, $excludeString, $listRoleType);
empty($groups) ? $allGroups = $roles : (empty($roles) ? $allGroups = $groups : ($allGroups = array_merge($groups, $roles)));
//$allGroups = array_merge($groups, $roles);
break;
default:
break;
}
}
$users = "";
$index = 0;
if ($regexp != null && (!count($allUsers) || !empty($crtValue) && !array_key_exists(strtolower($crtValue), $allUsers)) && ConfService::getCoreConf("USER_CREATE_USERS", "conf") && !$existingOnly) {
$users .= "<li class='complete_user_entry_temp' data-temporary='true' data-label='{$crtValue}'><span class='user_entry_label'>{$crtValue} (" . $mess["448"] . ")</span></li>";
} else {
if ($existingOnly && !empty($crtValue)) {
$users .= "<li class='complete_user_entry_temp' data-temporary='true' data-label='{$crtValue}' data-entry_id='{$crtValue}'><span class='user_entry_label'>{$crtValue}</span></li>";
}
}
$mess = ConfService::getMessages();
if ($regexp == null && !$usersOnly) {
$users .= "<li class='complete_group_entry' data-group='AJXP_GRP_/' data-label='" . $mess["447"] . "'><span class='user_entry_label'>" . $mess["447"] . "</span></li>";
}
$indexGroup = 0;
if (!$usersOnly && is_array($allGroups)) {
foreach ($allGroups as $groupId => $groupLabel) {
if ($regexp == null || preg_match("/{$regexp}/i", $groupLabel)) {
$users .= "<li class='complete_group_entry' data-group='{$groupId}' data-label='{$groupLabel}' data-entry_id='{$groupId}'><span class='user_entry_label'>" . $groupLabel . "</span></li>";
$indexGroup++;
}
if ($indexGroup == $limit) {
break;
}
}
}
if ($regexp == null && method_exists($this, "listUserTeams")) {
$teams = $this->listUserTeams();
foreach ($teams as $tId => $tData) {
$users .= "<li class='complete_group_entry' data-group='/AJXP_TEAM/{$tId}' data-label='[team] " . $tData["LABEL"] . "'><span class='user_entry_label'>[team] " . $tData["LABEL"] . "</span></li>";
}
}
foreach ($allUsers as $userId => $userObject) {
if ($userObject->getId() == $loggedUser->getId()) {
continue;
}
if (!$userObject->hasParent() && ConfService::getCoreConf("ALLOW_CROSSUSERS_SHARING", "conf") || $userObject->getParent() == $loggedUser->getId()) {
$userLabel = $userObject->personalRole->filterParameterValue("core.conf", "USER_DISPLAY_NAME", AJXP_REPO_SCOPE_ALL, $userId);
//if($regexp != null && ! (preg_match("/$regexp/i", $userId) || preg_match("/$regexp/i", $userLabel)) ) continue;
if (empty($userLabel)) {
$userLabel = $userId;
}
$userDisplay = $userLabel == $userId ? $userId : $userLabel . " ({$userId})";
if (ConfService::getCoreConf("USERS_LIST_HIDE_LOGIN", "conf") == true && $userLabel != $userId) {
$userDisplay = $userLabel;
}
$users .= "<li class='complete_user_entry' data-label='{$userLabel}' data-entry_id='{$userId}'><span class='user_entry_label'>" . $userDisplay . "</span></li>";
$index++;
}
if ($index == $limit) {
break;
}
}
if (strlen($users)) {
print "<ul>" . $users . "</ul>";
}
AuthService::setGroupFiltering(true);
break;
case "load_repository_info":
$data = array();
$repo = ConfService::getRepository();
if ($repo != null) {
$users = AuthService::countUsersForRepository(ConfService::getRepository()->getId(), true);
$data["core.users"] = $users;
if (isset($httpVars["collect"]) && $httpVars["collect"] == "true") {
AJXP_Controller::applyHook("repository.load_info", array(&$data));
}
}
HTMLWriter::charsetHeader("application/json");
echo json_encode($data);
break;
case "get_binary_param":
if (isset($httpVars["tmp_file"])) {
$file = AJXP_Utils::getAjxpTmpDir() . "/" . AJXP_Utils::securePath($httpVars["tmp_file"]);
if (isset($file)) {
header("Content-Type:image/png");
readfile($file);
}
} else {
if (isset($httpVars["binary_id"])) {
if (isset($httpVars["user_id"]) && AuthService::getLoggedUser() != null && AuthService::getLoggedUser()->isAdmin()) {
$context = array("USER" => $httpVars["user_id"]);
} else {
$context = array("USER" => AuthService::getLoggedUser()->getId());
}
$this->loadBinary($context, $httpVars["binary_id"]);
}
}
break;
case "get_global_binary_param":
if (isset($httpVars["tmp_file"])) {
$file = AJXP_Utils::getAjxpTmpDir() . "/" . AJXP_Utils::securePath($httpVars["tmp_file"]);
if (isset($file)) {
header("Content-Type:image/png");
readfile($file);
}
} else {
if (isset($httpVars["binary_id"])) {
$this->loadBinary(array(), $httpVars["binary_id"]);
}
}
break;
case "store_binary_temp":
if (count($fileVars)) {
$keys = array_keys($fileVars);
$boxData = $fileVars[$keys[0]];
$err = AJXP_Utils::parseFileDataErrors($boxData);
if ($err != null) {
} else {
$rand = substr(md5(time()), 0, 6);
$tmp = $rand . "-" . $boxData["name"];
@move_uploaded_file($boxData["tmp_name"], AJXP_Utils::getAjxpTmpDir() . "/" . $tmp);
}
}
if (isset($tmp) && file_exists(AJXP_Utils::getAjxpTmpDir() . "/" . $tmp)) {
print '<script type="text/javascript">';
print 'parent.formManagerHiddenIFrameSubmission("' . $tmp . '");';
print '</script>';
}
break;
default:
break;
}
if (isset($logMessage) || isset($errorMessage)) {
$xmlBuffer .= AJXP_XMLWriter::sendMessage(isset($logMessage) ? $logMessage : null, isset($errorMessage) ? $errorMessage : null, false);
}
if (isset($requireAuth)) {
$xmlBuffer .= AJXP_XMLWriter::requireAuth(false);
}
return $xmlBuffer;
}
public function switchAction($action, $httpVars, $fileVars)
{
$mess = ConfService::getMessages();
$timestamp_url = $this->getFilteredOption("TIMESTAMP_URL");
$timestamp_login = $this->getFilteredOption("USER");
$timestamp_password = $this->getFilteredOption("PASS");
//Check if the configuration has been initiated
if (empty($timestamp_url) || empty($timestamp_login) || !empty($timestamp_password)) {
throw new AJXP_Exception($mess["timestamp.4"]);
$this->logError("Config", "TimeStamp : configuration is needed");
return false;
}
//Check if after being initiated, conf. fields have some values
if (strlen($timestamp_url) < 2 || strlen($timestamp_login) < 2 || strlen($timestamp_password) < 2) {
throw new AJXP_Exception($mess["timestamp.4"]);
$this->logError("Config", "TimeStamp : configuration is incorrect");
return false;
}
//Get active repository
$repository = ConfService::getRepository();
if (!$repository->detectStreamWrapper(true)) {
return false;
}
$selection = new UserSelection($repository, $httpVars);
$destStreamURL = $selection->currentBaseUrl();
$fileName = $selection->getUniqueFile();
$fileUrl = $destStreamURL . $fileName;
$file = AJXP_MetaStreamWrapper::getRealFSReference($fileUrl, true);
//Hash the file, to send it to Universign
$hashedDataToTimestamp = hash_file('sha256', $file);
//Check that a tokken is not going to be timestamped !
if (substr("{$file}", -4) != '.ers') {
if (file_exists($file . '.ers')) {
throw new AJXP_Exception($mess["timestamp.1"]);
return false;
} else {
//Prepare the query that will be sent to Universign
$dataToSend = array('hashAlgo' => 'SHA256', 'withCert' => 'true', 'hashValue' => $hashedDataToTimestamp);
$dataQuery = http_build_query($dataToSend);
//Check if allow_url_fopen is allowed on the server. If not, it will use cUrl
if (ini_get('allow_url_fopen')) {
$context_options = array('http' => array('method' => 'POST', 'header' => "Content-type: application/x-www-form-urlencoded\r\n" . "Content-Length: " . strlen($dataQuery) . "\r\n" . "Authorization: Basic " . base64_encode($timestamp_login . ':' . $timestamp_password) . "\r\n", 'content' => $dataQuery));
//Get the result from Universign
$context = stream_context_create($context_options);
$fp = fopen($timestamp_url, 'r', false, $context);
$tsp = stream_get_contents($fp);
} else {
$timestamp_header = array("Content-type: application/x-www-form-urlencoded", "Content-Length: " . strlen($dataQuery), "Authorization: Basic " . base64_encode($timestamp_login . ':' . $timestamp_password));
$timeout = 5;
$ch = curl_init($timestamp_url);
curl_setopt($ch, CURLOPT_POSTFIELDS, $dataQuery);
curl_setopt($ch, CURLOPT_HTTPHEADER, $timestamp_header);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
//Get the result from Universign
$tsp = curl_exec($ch);
curl_close($ch);
}
//Save the result to a file
file_put_contents($file . '.ers', $tsp);
//Send the succesful message
$this->logInfo("TimeStamp", array("files" => $file, "destination" => $file . '.ers'));
AJXP_XMLWriter::header();
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::sendMessage($mess["timestamp.3"] . $fileName, null);
AJXP_XMLWriter::close();
}
} else {
throw new AJXP_Exception($mess["timestamp.2"]);
return false;
}
}
function applyAction($actionName, $httpVars, $filesVar)
{
if ($actionName == "get_driver_actions") {
AJXP_XMLWriter::header();
$this->sendActionsToClient(false, null, null);
AJXP_XMLWriter::close();
exit(1);
}
if (isset($this->actions[$actionName])) {
// use callback;
$action = $this->actions[$actionName];
$callBack = $action["callback"];
try {
return call_user_func(array(&$this, $callBack), $actionName, $httpVars, $filesVar);
} catch (Exception $e) {
return AJXP_XMLWriter::sendMessage(null, SystemTextEncoding::toUTF8($e->getMessage()) . " (" . basename($e->getFile()) . " - L." . $e->getLine() . ")", false);
}
}
}
function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->actions[$action])) {
return;
}
$xmlBuffer = "";
foreach ($httpVars as $getName => $getValue) {
${$getName} = Utils::securePath($getValue);
}
if (isset($dir) && $action != "upload") {
$dir = SystemTextEncoding::fromUTF8($dir);
}
$mess = ConfService::getMessages();
switch ($action) {
//------------------------------------
// SWITCH THE ROOT REPOSITORY
//------------------------------------
case "switch_root_dir":
if (!isset($root_dir_index)) {
break;
}
$dirList = ConfService::getRootDirsList();
if (!isset($dirList[$root_dir_index])) {
$errorMessage = "Trying to switch to an unkown folder!";
break;
}
ConfService::switchRootDir($root_dir_index);
$logMessage = "Successfully Switched!";
AJXP_Logger::logAction("Switch Repository", array("rep. id" => $root_dir_index));
break;
//------------------------------------
// GET AN HTML TEMPLATE
//------------------------------------
//------------------------------------
// GET AN HTML TEMPLATE
//------------------------------------
case "get_template":
header("Content-type:text/html; charset:UTF-8");
if (isset($template_name) && is_file(CLIENT_RESOURCES_FOLDER . "/html/" . $template_name)) {
if ($template_name == "gui_tpl.html") {
include CLIENT_RESOURCES_FOLDER . "/html/usertemplate_top.html";
}
include CLIENT_RESOURCES_FOLDER . "/html/" . $template_name;
if ($template_name == "gui_tpl.html") {
include CLIENT_RESOURCES_FOLDER . "/html/usertemplate_bottom.html";
}
}
exit(0);
break;
//------------------------------------
// GET I18N MESSAGES
//------------------------------------
//------------------------------------
// GET I18N MESSAGES
//------------------------------------
case "get_i18n_messages":
header("Content-type:text/javascript");
HTMLWriter::writeI18nMessagesClass(ConfService::getMessages());
exit(0);
break;
//------------------------------------
// BOOKMARK BAR
//------------------------------------
//------------------------------------
// BOOKMARK BAR
//------------------------------------
case "get_bookmarks":
$bmUser = null;
if (AuthService::usersEnabled() && AuthService::getLoggedUser() != null) {
$bmUser = AuthService::getLoggedUser();
} else {
if (!AuthService::usersEnabled()) {
$confStorage = ConfService::getConfStorageImpl();
$bmUser = $confStorage->createUserObject("shared");
}
}
if ($bmUser == null) {
exit(1);
}
if (isset($_GET["bm_action"]) && isset($_GET["bm_path"])) {
if ($_GET["bm_action"] == "add_bookmark") {
$title = "";
if (isset($_GET["title"])) {
$title = $_GET["title"];
}
if ($title == "" && $_GET["bm_path"] == "/") {
$title = ConfService::getCurrentRootDirDisplay();
}
$bmUser->addBookMark($_GET["bm_path"], $title);
} else {
if ($_GET["bm_action"] == "delete_bookmark") {
$bmUser->removeBookmark($_GET["bm_path"]);
} else {
if ($_GET["bm_action"] == "rename_bookmark" && isset($_GET["bm_title"])) {
$bmUser->renameBookmark($_GET["bm_path"], $_GET["bm_title"]);
}
}
}
}
if (AuthService::usersEnabled() && AuthService::getLoggedUser() != null) {
$bmUser->save();
AuthService::updateUser($bmUser);
} else {
if (!AuthService::usersEnabled()) {
$bmUser->save();
}
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::writeBookmarks($bmUser->getBookmarks());
AJXP_XMLWriter::close();
exit(1);
break;
//------------------------------------
// SAVE USER PREFERENCE
//------------------------------------
//------------------------------------
// SAVE USER PREFERENCE
//------------------------------------
case "save_user_pref":
$userObject = AuthService::getLoggedUser();
if ($userObject == null) {
exit(1);
}
$i = 0;
while (isset($_GET["pref_name_" . $i]) && isset($_GET["pref_value_" . $i])) {
$prefName = $_GET["pref_name_" . $i];
$prefValue = $_GET["pref_value_" . $i];
if ($prefName != "password") {
$userObject->setPref($prefName, $prefValue);
$userObject->save();
AuthService::updateUser($userObject);
setcookie("AJXP_{$prefName}", $prefValue);
} else {
if (isset($_GET["crt"]) && AuthService::checkPassword($userObject->getId(), $_GET["crt"], false, $_GET["pass_seed"])) {
AuthService::updatePassword($userObject->getId(), $prefValue);
} else {
//$errorMessage = "Wrong password!";
header("Content-Type:text/plain");
print "PASS_ERROR";
exit(1);
}
}
$i++;
}
header("Content-Type:text/plain");
print "SUCCESS";
exit(1);
break;
//------------------------------------
// DISPLAY DOC
//------------------------------------
//------------------------------------
// DISPLAY DOC
//------------------------------------
case "display_doc":
header("Content-type:text/html; charset:UTF-8");
echo HTMLWriter::getDocFile(htmlentities($_GET["doc_file"]));
exit(1);
break;
default:
break;
}
if (isset($logMessage) || isset($errorMessage)) {
$xmlBuffer .= AJXP_XMLWriter::sendMessage(isset($logMessage) ? $logMessage : null, isset($errorMessage) ? $errorMessage : null, false);
}
if (isset($requireAuth)) {
$xmlBuffer .= AJXP_XMLWriter::requireAuth(false);
}
if (isset($reload_current_node) && $reload_current_node == "true") {
$xmlBuffer .= AJXP_XMLWriter::reloadCurrentNode(false);
}
if (isset($reload_dest_node) && $reload_dest_node != "") {
$xmlBuffer .= AJXP_XMLWriter::reloadNode($reload_dest_node, false);
}
if (isset($reload_file_list)) {
$xmlBuffer .= AJXP_XMLWriter::reloadFileList($reload_file_list, false);
}
return $xmlBuffer;
}
public function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->accessDriver)) {
throw new Exception("Cannot find access driver!");
}
if ($this->accessDriver->getId() == "access.demo") {
$errorMessage = "This is a demo, all 'write' actions are disabled!";
if ($httpVars["sub_action"] == "delegate_repo") {
return AJXP_XMLWriter::sendMessage(null, $errorMessage, false);
} else {
print $errorMessage;
}
return;
}
switch ($action) {
//------------------------------------
// SHARING FILE OR FOLDER
//------------------------------------
case "share":
$subAction = isset($httpVars["sub_action"]) ? $httpVars["sub_action"] : "";
$file = AJXP_Utils::decodeSecureMagic($httpVars["file"]);
$ajxpNode = new AJXP_Node($this->urlBase . $file);
if (!file_exists($ajxpNode->getUrl())) {
throw new Exception("Cannot share a non-existing file: " . $ajxpNode->getUrl());
}
$metadata = null;
if ($subAction == "delegate_repo") {
header("Content-type:text/plain");
$result = $this->createSharedRepository($httpVars, $this->repository, $this->accessDriver);
if (is_a($result, "Repository")) {
$metadata = array("element" => $result->getUniqueId());
$numResult = 200;
} else {
$numResult = $result;
}
print $numResult;
} else {
if ($subAction == "create_minisite") {
header("Content-type:text/plain");
$res = $this->createSharedMinisite($httpVars, $this->repository, $this->accessDriver);
if (!is_array($res)) {
$url = $res;
} else {
list($hash, $url) = $res;
$metadata = array("element" => $hash, "minisite" => isset($httpVars["create_guest_user"]) ? "public" : "private");
}
print $url;
} else {
$maxdownload = abs(intval($this->getFilteredOption("FILE_MAX_DOWNLOAD", $this->repository->getId())));
$download = isset($httpVars["downloadlimit"]) ? abs(intval($httpVars["downloadlimit"])) : 0;
if ($maxdownload == 0) {
$httpVars["downloadlimit"] = $download;
} elseif ($maxdownload > 0 && $download == 0) {
$httpVars["downloadlimit"] = $maxdownload;
} else {
$httpVars["downloadlimit"] = min($download, $maxdownload);
}
$maxexpiration = abs(intval($this->getFilteredOption("FILE_MAX_EXPIRATION", $this->repository->getId())));
$expiration = isset($httpVars["expiration"]) ? abs(intval($httpVars["expiration"])) : 0;
if ($maxexpiration == 0) {
$httpVars["expiration"] = $expiration;
} elseif ($maxexpiration > 0 && $expiration == 0) {
$httpVars["expiration"] = $maxexpiration;
} else {
$httpVars["expiration"] = min($expiration, $maxexpiration);
}
$data = $this->accessDriver->makePublicletOptions($file, $httpVars["password"], $httpVars["expiration"], $httpVars["downloadlimit"], $this->repository);
$customData = array();
foreach ($httpVars as $key => $value) {
if (substr($key, 0, strlen("PLUGINS_DATA_")) == "PLUGINS_DATA_") {
$customData[substr($key, strlen("PLUGINS_DATA_"))] = $value;
}
}
if (count($customData)) {
$data["PLUGINS_DATA"] = $customData;
}
list($hash, $url) = $this->writePubliclet($data, $this->accessDriver, $this->repository);
$metaArray = array();
if ($ajxpNode->hasMetaStore()) {
$existingMeta = $ajxpNode->retrieveMetadata("ajxp_shared", true, AJXP_METADATA_SCOPE_REPOSITORY, true);
if (isset($existingMeta) && is_array($existingMeta) && array_key_exists("element", $existingMeta)) {
if (is_string($existingMeta["element"])) {
$metaArray[$existingMeta["element"]] = array();
} else {
$metaArray = $existingMeta["element"];
}
}
}
$metaArray[$hash] = array();
$metadata = array("element" => $metaArray);
if (isset($httpVars["format"]) && $httpVars["format"] == "json") {
header("Content-type:application/json");
echo json_encode(array("element_id" => $hash, "publiclet_link" => $url));
} else {
header("Content-type:text/plain");
echo $url;
}
flush();
}
}
if ($metadata != null && $ajxpNode->hasMetaStore()) {
$ajxpNode->setMetadata("ajxp_shared", $metadata, true, AJXP_METADATA_SCOPE_REPOSITORY, true);
}
AJXP_Controller::applyHook("msg.instant", array("<reload_shared_elements/>", ConfService::getRepository()->getId()));
// as the result can be quite small (e.g error code), make sure it's output in case of OB active.
flush();
break;
case "toggle_link_watch":
$file = AJXP_Utils::decodeSecureMagic($httpVars["file"]);
$watchValue = $httpVars["set_watch"] == "true" ? true : false;
$folder = false;
if (isset($httpVars["element_type"]) && $httpVars["element_type"] == "folder") {
$folder = true;
$node = new AJXP_Node($this->baseProtocol . "://" . $httpVars["repository_id"] . "/");
} else {
$node = new AJXP_Node($this->urlBase . $file);
}
$metadata = $node->retrieveMetadata("ajxp_shared", true, AJXP_METADATA_SCOPE_REPOSITORY);
$elementId = $metadata["element"];
if (isset($httpVars["element_id"]) && is_Array($metadata["element"]) && isset($metadata["element"][$httpVars["element_id"]])) {
$elementId = $httpVars["element_id"];
}
if ($this->watcher !== false) {
if (!$folder) {
if ($watchValue) {
$this->watcher->setWatchOnFolder($node, AuthService::getLoggedUser()->getId(), MetaWatchRegister::$META_WATCH_USERS_READ, array($elementId));
} else {
$this->watcher->removeWatchFromFolder($node, AuthService::getLoggedUser()->getId(), true, $elementId);
}
} else {
if ($watchValue) {
$this->watcher->setWatchOnFolder($node, AuthService::getLoggedUser()->getId(), MetaWatchRegister::$META_WATCH_BOTH);
} else {
$this->watcher->removeWatchFromFolder($node, AuthService::getLoggedUser()->getId());
}
}
}
$mess = ConfService::getMessages();
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["share_center.47"], null);
AJXP_XMLWriter::close();
break;
case "load_shared_element_data":
$file = AJXP_Utils::decodeSecureMagic($httpVars["file"]);
$elementType = $httpVars["element_type"];
$messages = ConfService::getMessages();
$node = new AJXP_Node($this->urlBase . $file);
$metadata = $node->retrieveMetadata("ajxp_shared", true, AJXP_METADATA_SCOPE_REPOSITORY);
$elementWatch = false;
if (count($metadata)) {
header("Content-type:application/json");
if ($elementType == "file") {
$elements = $metadata["element"];
if (is_string($elements)) {
$elements = array($elements => true);
}
$jsonData = array();
foreach ($elements as $element => $elementData) {
if (!is_array($elementData)) {
$elementData = array();
}
$pData = self::loadPublicletData($element);
if (!count($pData)) {
continue;
}
if ($pData["OWNER_ID"] != AuthService::getLoggedUser()->getId()) {
throw new Exception($messages["share_center.48"]);
}
if (isset($elementData["short_form_url"])) {
$link = $elementData["short_form_url"];
} else {
$link = $this->buildPublicletLink($element);
}
if ($this->watcher != false) {
$result = array();
$elementWatch = $this->watcher->hasWatchOnNode($node, AuthService::getLoggedUser()->getId(), MetaWatchRegister::$META_WATCH_USERS_NAMESPACE, $result);
if ($elementWatch && !in_array($element, $result)) {
$elementWatch = false;
}
}
$jsonData[] = array_merge(array("element_id" => $element, "publiclet_link" => $link, "download_counter" => PublicletCounter::getCount($element), "download_limit" => $pData["DOWNLOAD_LIMIT"], "expire_time" => $pData["EXPIRE_TIME"] != 0 ? date($messages["date_format"], $pData["EXPIRE_TIME"]) : 0, "has_password" => !empty($pData["PASSWORD"]), "element_watch" => $elementWatch), $elementData);
}
} else {
if ($elementType == "repository") {
if (isset($metadata["minisite"])) {
$minisiteData = self::loadPublicletData($metadata["element"]);
$repoId = $minisiteData["REPOSITORY"];
$minisiteIsPublic = isset($minisiteData["PRELOG_USER"]);
$dlDisabled = isset($minisiteData["DOWNLOAD_DISABLED"]);
if (isset($metadata["short_form_url"])) {
$minisiteLink = $metadata["short_form_url"];
} else {
$minisiteLink = $this->buildPublicletLink($metadata["element"]);
}
} else {
$repoId = $metadata["element"];
}
$repo = ConfService::getRepositoryById($repoId);
if ($repo == null || $repo->getOwner() != AuthService::getLoggedUser()->getId()) {
//throw new Exception($messages["share_center.48"]);
$jsonData = array("repositoryId" => $repoId, "label" => "Error - Cannot find shared data", "description" => "Cannot find repository", "entries" => array(), "element_watch" => false, "repository_url" => "");
echo json_encode($jsonData);
break;
}
if ($this->watcher != false) {
$elementWatch = $this->watcher->hasWatchOnNode(new AJXP_Node($this->baseProtocol . "://" . $repoId . "/"), AuthService::getLoggedUser()->getId(), MetaWatchRegister::$META_WATCH_NAMESPACE);
}
$sharedEntries = $this->computeSharedRepositoryAccessRights($repoId, true, $this->urlBase . $file);
$jsonData = array("repositoryId" => $repoId, "label" => $repo->getDisplay(), "description" => $repo->getDescription(), "entries" => $sharedEntries, "element_watch" => $elementWatch, "repository_url" => AJXP_Utils::detectServerURL(true) . "?goto=" . $repo->getSlug() . "/");
if (isset($minisiteData)) {
$jsonData["minisite"] = array("public" => $minisiteIsPublic ? "true" : "false", "public_link" => $minisiteLink, "disable_download" => $dlDisabled);
}
}
}
echo json_encode($jsonData);
}
break;
case "unshare":
$file = AJXP_Utils::decodeSecureMagic($httpVars["file"]);
$ajxpNode = new AJXP_Node($this->urlBase . $file);
$metadata = $ajxpNode->retrieveMetadata("ajxp_shared", true, AJXP_METADATA_SCOPE_REPOSITORY);
if (count($metadata)) {
$eType = $httpVars["element_type"];
if (isset($metadata["minisite"])) {
$eType = "minisite";
}
$elementId = $metadata["element"];
$updateMeta = false;
if (isset($httpVars["element_id"])) {
if (is_array($metadata["element"]) && isset($metadata["element"][$httpVars['element_id']])) {
$elementId = $httpVars["element_id"];
unset($metadata["element"][$httpVars['element_id']]);
if (count($metadata["element"]) > 0) {
$updateMeta = true;
}
}
}
self::deleteSharedElement($eType, $elementId, AuthService::getLoggedUser());
if ($updateMeta) {
$ajxpNode->setMetadata("ajxp_shared", $metadata, true, AJXP_METADATA_SCOPE_REPOSITORY, true);
} else {
$ajxpNode->removeMetadata("ajxp_shared", true, AJXP_METADATA_SCOPE_REPOSITORY, true);
}
}
AJXP_Controller::applyHook("msg.instant", array("<reload_shared_elements/>", ConfService::getRepository()->getId()));
break;
case "reset_counter":
$file = AJXP_Utils::decodeSecureMagic($httpVars["file"]);
$ajxpNode = new AJXP_Node($this->urlBase . $file);
$metadata = $ajxpNode->retrieveMetadata("ajxp_shared", true, AJXP_METADATA_SCOPE_REPOSITORY);
if (isset($metadata["element"][$httpVars["element_id"]])) {
PublicletCounter::reset($httpVars["element_id"]);
}
break;
case "update_shared_element_data":
$file = AJXP_Utils::decodeSecureMagic($httpVars["file"]);
if (!in_array($httpVars["p_name"], array("counter", "tags"))) {
}
$ajxpNode = new AJXP_Node($this->urlBase . $file);
$metadata = $ajxpNode->retrieveMetadata("ajxp_shared", true, AJXP_METADATA_SCOPE_REPOSITORY);
if (isset($metadata["element"][$httpVars["element_id"]])) {
if (!is_array($metadata["element"][$httpVars["element_id"]])) {
$metadata["element"][$httpVars["element_id"]] = array();
}
$metadata["element"][$httpVars["element_id"]][$httpVars["p_name"]] = $httpVars["p_value"];
$ajxpNode->setMetadata("ajxp_shared", $metadata, true, AJXP_METADATA_SCOPE_REPOSITORY);
}
break;
default:
break;
}
}
public function crossRepositoryCopy($httpVars)
{
ConfService::detectRepositoryStreams(true);
$mess = ConfService::getMessages();
$selection = new UserSelection();
$selection->initFromHttpVars($httpVars);
$files = $selection->getFiles();
$accessType = $this->repository->getAccessType();
$repositoryId = $this->repository->getId();
$plugin = AJXP_PluginsService::findPlugin("access", $accessType);
$origWrapperData = $plugin->detectStreamWrapper(true);
$origStreamURL = $origWrapperData["protocol"] . "://{$repositoryId}";
$destRepoId = $httpVars["dest_repository_id"];
$destRepoObject = ConfService::getRepositoryById($destRepoId);
$destRepoAccess = $destRepoObject->getAccessType();
$plugin = AJXP_PluginsService::findPlugin("access", $destRepoAccess);
$plugin->repository = $destRepoObject;
$destWrapperData = $plugin->detectStreamWrapper(true);
$destStreamURL = $destWrapperData["protocol"] . "://{$destRepoId}";
// Check rights
if (AuthService::usersEnabled()) {
$loggedUser = AuthService::getLoggedUser();
if (!$loggedUser->canRead($repositoryId) || !$loggedUser->canWrite($destRepoId) || isset($httpVars["moving_files"]) && !$loggedUser->canWrite($repositoryId)) {
throw new Exception($mess[364]);
}
}
$srcRepoData = array('base_url' => $origStreamURL, 'wrapper_name' => $origWrapperData['classname'], 'recycle' => $this->repository->getOption("RECYCLE_BIN"));
$destRepoData = array('base_url' => $destStreamURL, 'wrapper_name' => $destWrapperData['classname'], 'chmod' => $this->repository->getOption('CHMOD'));
$messages = array();
$errorMessages = array();
foreach ($files as $file) {
$this->copyOrMoveFile(AJXP_Utils::decodeSecureMagic($httpVars["dest"]), $file, $errorMessages, $messages, isset($httpVars["moving_files"]) ? true : false, $srcRepoData, $destRepoData);
}
AJXP_XMLWriter::header();
if (count($errorMessages)) {
AJXP_XMLWriter::sendMessage(null, join("\n", $errorMessages), true);
}
AJXP_XMLWriter::sendMessage(join("\n", $messages), null, true);
AJXP_XMLWriter::close();
}
public function applyAction($actionName, $httpVars, $fileVars)
{
$messages = ConfService::getMessages();
$repoId = $this->accessDriver->repository->getId();
if ($actionName == "search") {
// TMP
if (strpos($httpVars["query"], "keyword:") === 0) {
$parts = explode(":", $httpVars["query"]);
$this->applyAction("search_by_keyword", array("field" => $parts[1]), array());
return null;
}
require_once "Zend/Search/Lucene.php";
try {
$index = $this->loadIndex($repoId, false);
} catch (Exception $ex) {
AJXP_XMLWriter::header();
if ($this->seemsCurrentlyIndexing($repoId, 3)) {
AJXP_XMLWriter::sendMessage($messages["index.lucene.11"], null);
} else {
if (ConfService::backgroundActionsSupported() && !ConfService::currentContextIsCommandLine()) {
AJXP_Controller::applyActionInBackground($repoId, "index", array());
sleep(2);
AJXP_XMLWriter::triggerBgAction("check_index_status", array("repository_id" => $repoId), sprintf($messages["index.lucene.8"], "/"), true, 5);
AJXP_XMLWriter::sendMessage($messages["index.lucene.7"], null);
} else {
AJXP_XMLWriter::sendMessage($messages["index.lucene.12"], null);
}
}
AJXP_XMLWriter::close();
return null;
}
$textQuery = $httpVars["query"];
if ($this->getFilteredOption("AUTO_WILDCARD") === true && strlen($textQuery) > 0 && ctype_alnum($textQuery)) {
if ($textQuery[0] == '"' && $textQuery[strlen($textQuery) - 1] == '"') {
$textQuery = substr($textQuery, 1, -1);
} else {
if ($textQuery[strlen($textQuery) - 1] != "*") {
$textQuery .= "*";
}
}
}
if (strpos($textQuery, ":") !== false) {
$textQuery = str_replace("ajxp_meta_ajxp_document_content:", "body:", $textQuery);
$textQuery = $this->filterSearchRangesKeywords($textQuery);
$query = "ajxp_scope:shared AND ({$textQuery})";
} else {
if ((isset($this->metaFields) || $this->indexContent) && isset($httpVars["fields"])) {
$sParts = array();
foreach (explode(",", $httpVars["fields"]) as $searchField) {
if ($searchField == "filename") {
$sParts[] = "basename:" . $textQuery;
} else {
if ($searchField == "ajxp_document_content") {
$sParts[] = $textQuery;
} else {
if (in_array($searchField, $this->metaFields)) {
$sParts[] = "ajxp_meta_" . $searchField . ":" . $textQuery;
} else {
if ($searchField == "ajxp_document_content") {
$sParts[] = "title:" . $textQuery;
$sParts[] = "body:" . $textQuery;
$sParts[] = "keywords:" . $textQuery;
}
}
}
}
}
$query = implode(" OR ", $sParts);
$query = "ajxp_scope:shared AND ({$query})";
$this->logDebug("Query : {$query}");
} else {
$index->setDefaultSearchField("basename");
$query = $this->filterSearchRangesKeywords($textQuery);
}
}
$this->setDefaultAnalyzer();
if ($query == "*") {
$index->setDefaultSearchField("ajxp_node");
$query = "yes";
$hits = $index->find($query, "node_url", SORT_STRING);
} else {
$hits = $index->find($query);
}
$commitIndex = false;
if (isset($httpVars['return_selection'])) {
$returnNodes = array();
} else {
AJXP_XMLWriter::header();
}
$cursor = 0;
if (isset($httpVars['limit'])) {
$limit = intval($httpVars['limit']);
}
foreach ($hits as $hit) {
// Backward compatibility
$hit->node_url = preg_replace("#ajxp\\.[a-z_]+://#", "pydio://", $hit->node_url);
if ($hit->serialized_metadata != null) {
$meta = unserialize(base64_decode($hit->serialized_metadata));
if (isset($meta["ajxp_modiftime"])) {
$meta["ajxp_relativetime"] = $meta["ajxp_description"] = $messages[4] . " " . AJXP_Utils::relativeDate($meta["ajxp_modiftime"], $messages);
}
$tmpNode = new AJXP_Node(SystemTextEncoding::fromUTF8($hit->node_url), $meta);
} else {
$tmpNode = new AJXP_Node(SystemTextEncoding::fromUTF8($hit->node_url), array());
$tmpNode->loadNodeInfo();
}
if ($tmpNode->getRepositoryId() != $repoId) {
$this->logDebug(__CLASS__, "Strange case, search retrieves a node from wrong repository!");
$index->delete($hit->id);
$commitIndex = true;
continue;
}
if (!file_exists($tmpNode->getUrl())) {
$index->delete($hit->id);
$commitIndex = true;
continue;
}
if (!is_readable($tmpNode->getUrl())) {
continue;
}
$basename = basename($tmpNode->getPath());
$isLeaf = $tmpNode->isLeaf();
if (!$this->accessDriver->filterNodeName($tmpNode->getPath(), $basename, $isLeaf, array("d" => true, "f" => true))) {
continue;
}
$tmpNode->search_score = sprintf("%0.2f", $hit->score);
if (isset($returnNodes)) {
$returnNodes[] = $tmpNode;
} else {
AJXP_XMLWriter::renderAjxpNode($tmpNode);
}
$cursor++;
if (isset($limit) && $cursor > $limit) {
break;
}
}
if (!isset($returnNodes)) {
AJXP_XMLWriter::close();
}
if ($commitIndex) {
$index->commit();
}
} else {
if ($actionName == "search_by_keyword") {
require_once "Zend/Search/Lucene.php";
$scope = "user";
try {
$index = $this->loadIndex($repoId, false);
} catch (Exception $ex) {
AJXP_XMLWriter::header();
if (ConfService::backgroundActionsSupported() && !ConfService::currentContextIsCommandLine()) {
AJXP_Controller::applyActionInBackground($repoId, "index", array());
AJXP_XMLWriter::triggerBgAction("check_index_status", array("repository_id" => $repoId), sprintf($messages["index.lucene.8"], "/"), true, 2);
}
AJXP_XMLWriter::sendMessage($messages["index.lucene.7"], null);
AJXP_XMLWriter::close();
return null;
}
$sParts = array();
$searchField = $httpVars["field"];
if ($searchField == "ajxp_node") {
$sParts[] = "{$searchField}:yes";
} else {
$sParts[] = "{$searchField}:true";
}
if ($scope == "user" && AuthService::usersEnabled()) {
if (AuthService::getLoggedUser() == null) {
throw new Exception("Cannot find current user");
}
$sParts[] = "ajxp_scope:user";
$sParts[] = "ajxp_user:"******"ajxp_scope:shared";
}
$query = implode(" AND ", $sParts);
$this->logDebug("Query : {$query}");
$hits = $index->find($query);
$commitIndex = false;
if (isset($httpVars['return_selection'])) {
$returnNodes = array();
} else {
AJXP_XMLWriter::header();
}
foreach ($hits as $hit) {
// Backward compat with old protocols
$hit->node_url = preg_replace("#ajxp\\.[a-z_]+://#", "pydio://", $hit->node_url);
if ($hit->serialized_metadata != null) {
$meta = unserialize(base64_decode($hit->serialized_metadata));
$tmpNode = new AJXP_Node(SystemTextEncoding::fromUTF8($hit->node_url), $meta);
} else {
$tmpNode = new AJXP_Node(SystemTextEncoding::fromUTF8($hit->node_url), array());
$tmpNode->loadNodeInfo();
}
if (!file_exists($tmpNode->getUrl())) {
$index->delete($hit->id);
$commitIndex = true;
continue;
}
if (!is_readable($tmpNode->getUrl())) {
continue;
}
$basename = basename($tmpNode->getPath());
$isLeaf = $tmpNode->isLeaf();
if (!$this->accessDriver->filterNodeName($tmpNode->getPath(), $basename, $isLeaf, array("d" => true, "f" => true))) {
continue;
}
$tmpNode->search_score = sprintf("%0.2f", $hit->score);
if (isset($returnNodes)) {
$returnNodes[] = $tmpNode;
} else {
AJXP_XMLWriter::renderAjxpNode($tmpNode);
}
}
if (!isset($returnNodes)) {
AJXP_XMLWriter::close();
}
if ($commitIndex) {
$index->commit();
}
}
}
if (isset($returnNodes)) {
return $returnNodes;
} else {
return null;
}
}
public function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->actions[$action])) {
return;
}
parent::accessPreprocess($action, $httpVars, $fileVars);
$selection = new UserSelection();
$dir = $httpVars["dir"] or "";
if ($this->wrapperClassName == "fsAccessWrapper") {
$dir = fsAccessWrapper::patchPathForBaseDir($dir);
}
$dir = AJXP_Utils::securePath($dir);
if ($action != "upload") {
$dir = AJXP_Utils::decodeSecureMagic($dir);
}
$selection->initFromHttpVars($httpVars);
if (!$selection->isEmpty()) {
$this->filterUserSelectionToHidden($selection->getFiles());
}
$mess = ConfService::getMessages();
$newArgs = RecycleBinManager::filterActions($action, $selection, $dir, $httpVars);
if (isset($newArgs["action"])) {
$action = $newArgs["action"];
}
if (isset($newArgs["dest"])) {
$httpVars["dest"] = SystemTextEncoding::toUTF8($newArgs["dest"]);
}
//Re-encode!
// FILTER DIR PAGINATION ANCHOR
$page = null;
if (isset($dir) && strstr($dir, "%23") !== false) {
$parts = explode("%23", $dir);
$dir = $parts[0];
$page = $parts[1];
}
$pendingSelection = "";
$logMessage = null;
$reloadContextNode = false;
switch ($action) {
//------------------------------------
// DOWNLOAD
//------------------------------------
case "download":
$this->logInfo("Download", array("files" => $this->addSlugToPath($selection)));
@set_error_handler(array("HTMLWriter", "javascriptErrorHandler"), E_ALL & ~E_NOTICE);
@register_shutdown_function("restore_error_handler");
$zip = false;
if ($selection->isUnique()) {
if (is_dir($this->urlBase . $selection->getUniqueFile())) {
$zip = true;
$base = basename($selection->getUniqueFile());
$uniqDir = dirname($selection->getUniqueFile());
if (!empty($uniqDir) && $uniqDir != "/") {
$dir = dirname($selection->getUniqueFile());
}
} else {
if (!file_exists($this->urlBase . $selection->getUniqueFile())) {
throw new Exception("Cannot find file!");
}
}
$node = $selection->getUniqueNode($this);
} else {
$zip = true;
}
if ($zip) {
// Make a temp zip and send it as download
$loggedUser = AuthService::getLoggedUser();
$file = AJXP_Utils::getAjxpTmpDir() . "/" . ($loggedUser ? $loggedUser->getId() : "shared") . "_" . time() . "tmpDownload.zip";
$zipFile = $this->makeZip($selection->getFiles(), $file, empty($dir) ? "/" : $dir);
if (!$zipFile) {
throw new AJXP_Exception("Error while compressing");
}
if (!$this->getFilteredOption("USE_XSENDFILE", $this->repository->getId()) && !$this->getFilteredOption("USE_XACCELREDIRECT", $this->repository->getId())) {
register_shutdown_function("unlink", $file);
}
$localName = ($base == "" ? "Files" : $base) . ".zip";
if (isset($httpVars["archive_name"])) {
$localName = AJXP_Utils::decodeSecureMagic($httpVars["archive_name"]);
}
$this->readFile($file, "force-download", $localName, false, false, true);
} else {
$localName = "";
AJXP_Controller::applyHook("dl.localname", array($this->urlBase . $selection->getUniqueFile(), &$localName, $this->wrapperClassName));
$this->readFile($this->urlBase . $selection->getUniqueFile(), "force-download", $localName);
}
if (isset($node)) {
AJXP_Controller::applyHook("node.read", array(&$node));
}
break;
case "prepare_chunk_dl":
$chunkCount = intval($httpVars["chunk_count"]);
$fileId = $this->urlBase . $selection->getUniqueFile();
$sessionKey = "chunk_file_" . md5($fileId . time());
$totalSize = $this->filesystemFileSize($fileId);
$chunkSize = intval($totalSize / $chunkCount);
$realFile = call_user_func(array($this->wrapperClassName, "getRealFSReference"), $fileId, true);
$chunkData = array("localname" => basename($fileId), "chunk_count" => $chunkCount, "chunk_size" => $chunkSize, "total_size" => $totalSize, "file_id" => $sessionKey);
$_SESSION[$sessionKey] = array_merge($chunkData, array("file" => $realFile));
HTMLWriter::charsetHeader("application/json");
print json_encode($chunkData);
$node = $selection->getUniqueNode($this);
AJXP_Controller::applyHook("node.read", array(&$node));
break;
case "download_chunk":
$chunkIndex = intval($httpVars["chunk_index"]);
$chunkKey = $httpVars["file_id"];
$sessData = $_SESSION[$chunkKey];
$realFile = $sessData["file"];
$chunkSize = $sessData["chunk_size"];
$offset = $chunkSize * $chunkIndex;
if ($chunkIndex == $sessData["chunk_count"] - 1) {
// Compute the last chunk real length
$chunkSize = $sessData["total_size"] - $chunkSize * ($sessData["chunk_count"] - 1);
if (call_user_func(array($this->wrapperClassName, "isRemote"))) {
register_shutdown_function("unlink", $realFile);
}
}
$this->readFile($realFile, "force-download", $sessData["localname"] . "." . sprintf("%03d", $chunkIndex + 1), false, false, true, $offset, $chunkSize);
break;
case "compress":
// Make a temp zip and send it as download
$loggedUser = AuthService::getLoggedUser();
if (isset($httpVars["archive_name"])) {
$localName = AJXP_Utils::decodeSecureMagic($httpVars["archive_name"]);
$this->filterUserSelectionToHidden(array($localName));
} else {
$localName = (basename($dir) == "" ? "Files" : basename($dir)) . ".zip";
}
$file = AJXP_Utils::getAjxpTmpDir() . "/" . ($loggedUser ? $loggedUser->getId() : "shared") . "_" . time() . "tmpCompression.zip";
if (isset($httpVars["compress_flat"])) {
$baseDir = "__AJXP_ZIP_FLAT__/";
} else {
$baseDir = $dir;
}
$zipFile = $this->makeZip($selection->getFiles(), $file, $baseDir);
if (!$zipFile) {
throw new AJXP_Exception("Error while compressing file {$localName}");
}
register_shutdown_function("unlink", $file);
$tmpFNAME = $this->urlBase . $dir . "/" . str_replace(".zip", ".tmp", $localName);
copy($file, $tmpFNAME);
try {
AJXP_Controller::applyHook("node.before_create", array(new AJXP_Node($tmpFNAME), filesize($tmpFNAME)));
} catch (Exception $e) {
@unlink($tmpFNAME);
throw $e;
}
@rename($tmpFNAME, $this->urlBase . $dir . "/" . $localName);
AJXP_Controller::applyHook("node.change", array(null, new AJXP_Node($this->urlBase . $dir . "/" . $localName), false));
//$reloadContextNode = true;
//$pendingSelection = $localName;
$newNode = new AJXP_Node($this->urlBase . $dir . "/" . $localName);
if (!isset($nodesDiffs)) {
$nodesDiffs = $this->getNodesDiffArray();
}
$nodesDiffs["ADD"][] = $newNode;
break;
case "stat":
clearstatcache();
header("Content-type:application/json");
if ($selection->isUnique()) {
$stat = @stat($this->urlBase . $selection->getUniqueFile());
if (!$stat) {
print '{}';
} else {
print json_encode($stat);
}
} else {
$files = $selection->getFiles();
print '{';
foreach ($files as $index => $path) {
$stat = @stat($this->urlBase . $path);
if (!$stat) {
$stat = '{}';
} else {
$stat = json_encode($stat);
}
print json_encode($path) . ':' . $stat . ($index < count($files) - 1 ? "," : "");
}
print '}';
}
break;
//------------------------------------
// ONLINE EDIT
//------------------------------------
//------------------------------------
// ONLINE EDIT
//------------------------------------
case "get_content":
$dlFile = $this->urlBase . $selection->getUniqueFile();
$this->logInfo("Get_content", array("files" => $this->addSlugToPath($selection)));
if (AJXP_Utils::getStreamingMimeType(basename($dlFile)) !== false) {
$this->readFile($this->urlBase . $selection->getUniqueFile(), "stream_content");
} else {
$this->readFile($this->urlBase . $selection->getUniqueFile(), "plain");
}
$node = $selection->getUniqueNode($this);
AJXP_Controller::applyHook("node.read", array(&$node));
break;
case "put_content":
if (!isset($httpVars["content"])) {
break;
}
// Load "code" variable directly from POST array, do not "securePath" or "sanitize"...
$code = $httpVars["content"];
$file = $selection->getUniqueFile();
$this->logInfo("Online Edition", array("file" => $this->addSlugToPath($file)));
if (isset($httpVars["encode"]) && $httpVars["encode"] == "base64") {
$code = base64_decode($code);
} else {
$code = str_replace("<", "<", SystemTextEncoding::magicDequote($code));
}
$fileName = $this->urlBase . $file;
$currentNode = new AJXP_Node($fileName);
try {
AJXP_Controller::applyHook("node.before_change", array(&$currentNode, strlen($code)));
} catch (Exception $e) {
header("Content-Type:text/plain");
print $e->getMessage();
return;
}
if (!is_file($fileName) || !$this->isWriteable($fileName, "file")) {
header("Content-Type:text/plain");
print !$this->isWriteable($fileName, "file") ? "1001" : "1002";
return;
}
$fp = fopen($fileName, "w");
fputs($fp, $code);
fclose($fp);
clearstatcache(true, $fileName);
AJXP_Controller::applyHook("node.change", array($currentNode, $currentNode, false));
header("Content-Type:text/plain");
print $mess[115];
break;
//------------------------------------
// COPY / MOVE
//------------------------------------
//------------------------------------
// COPY / MOVE
//------------------------------------
case "copy":
case "move":
//throw new AJXP_Exception("", 113);
if ($selection->isEmpty()) {
throw new AJXP_Exception("", 113);
}
$loggedUser = AuthService::getLoggedUser();
if ($loggedUser != null && !$loggedUser->canWrite(ConfService::getCurrentRepositoryId())) {
throw new AJXP_Exception("You are not allowed to write", 207);
}
$success = $error = array();
$dest = AJXP_Utils::decodeSecureMagic($httpVars["dest"]);
$this->filterUserSelectionToHidden(array($httpVars["dest"]));
if ($selection->inZip()) {
// Set action to copy anycase (cannot move from the zip).
$action = "copy";
$this->extractArchive($dest, $selection, $error, $success);
} else {
$move = $action == "move" ? true : false;
if ($move && isset($httpVars["force_copy_delete"])) {
$move = false;
}
$this->copyOrMove($dest, $selection->getFiles(), $error, $success, $move);
}
if (count($error)) {
throw new AJXP_Exception(SystemTextEncoding::toUTF8(join("\n", $error)));
} else {
if (isset($httpVars["force_copy_delete"])) {
$errorMessage = $this->delete($selection->getFiles(), $logMessages);
if ($errorMessage) {
throw new AJXP_Exception(SystemTextEncoding::toUTF8($errorMessage));
}
$this->logInfo("Copy/Delete", array("files" => $this->addSlugToPath($selection), "destination" => $this->addSlugToPath($dest)));
} else {
$this->logInfo($action == "move" ? "Move" : "Copy", array("files" => $this->addSlugToPath($selection), "destination" => $this->addSlugToPath($dest)));
}
$logMessage = join("\n", $success);
}
if (!isset($nodesDiffs)) {
$nodesDiffs = $this->getNodesDiffArray();
}
// Assume new nodes are correctly created
$selectedItems = $selection->getFiles();
foreach ($selectedItems as $selectedPath) {
$newPath = $this->urlBase . $dest . "/" . basename($selectedPath);
$newNode = new AJXP_Node($newPath);
$nodesDiffs["ADD"][] = $newNode;
if ($action == "move") {
$nodesDiffs["REMOVE"][] = $selectedPath;
}
}
if (!(RecycleBinManager::getRelativeRecycle() == $dest && $this->getFilteredOption("HIDE_RECYCLE", $this->repository->getId()) == true)) {
//$reloadDataNode = $dest;
}
break;
//------------------------------------
// DELETE
//------------------------------------
//------------------------------------
// DELETE
//------------------------------------
case "delete":
if ($selection->isEmpty()) {
throw new AJXP_Exception("", 113);
}
$logMessages = array();
$errorMessage = $this->delete($selection->getFiles(), $logMessages);
if (count($logMessages)) {
$logMessage = join("\n", $logMessages);
}
if ($errorMessage) {
throw new AJXP_Exception(SystemTextEncoding::toUTF8($errorMessage));
}
$this->logInfo("Delete", array("files" => $this->addSlugToPath($selection)));
if (!isset($nodesDiffs)) {
$nodesDiffs = $this->getNodesDiffArray();
}
$nodesDiffs["REMOVE"] = array_merge($nodesDiffs["REMOVE"], $selection->getFiles());
break;
case "purge":
$hardPurgeTime = intval($this->repository->getOption("PURGE_AFTER")) * 3600 * 24;
$softPurgeTime = intval($this->repository->getOption("PURGE_AFTER_SOFT")) * 3600 * 24;
$shareCenter = AJXP_PluginsService::findPluginById('action.share');
if (!($shareCenter && $shareCenter->isEnabled())) {
//action.share is disabled, don't look at the softPurgeTime
$softPurgeTime = 0;
}
if ($hardPurgeTime > 0 || $softPurgeTime > 0) {
$this->recursivePurge($this->urlBase, $hardPurgeTime, $softPurgeTime);
}
break;
//------------------------------------
// RENAME
//------------------------------------
//------------------------------------
// RENAME
//------------------------------------
case "rename":
$file = AJXP_Utils::decodeSecureMagic($httpVars["file"]);
$filename_new = AJXP_Utils::decodeSecureMagic($httpVars["filename_new"]);
$dest = null;
if (isset($httpVars["dest"])) {
$dest = AJXP_Utils::decodeSecureMagic($httpVars["dest"]);
$filename_new = "";
}
$this->filterUserSelectionToHidden(array($filename_new));
$this->rename($file, $filename_new, $dest);
$logMessage = SystemTextEncoding::toUTF8($file) . " {$mess['41']} " . SystemTextEncoding::toUTF8($filename_new);
//$reloadContextNode = true;
//$pendingSelection = $filename_new;
if (!isset($nodesDiffs)) {
$nodesDiffs = $this->getNodesDiffArray();
}
if ($dest == null) {
$dest = AJXP_Utils::safeDirname($file);
}
$nodesDiffs["UPDATE"][$file] = new AJXP_Node($this->urlBase . $dest . "/" . $filename_new);
$this->logInfo("Rename", array("original" => $this->addSlugToPath($file), "new" => $filename_new));
break;
//------------------------------------
// CREER UN REPERTOIRE / CREATE DIR
//------------------------------------
//------------------------------------
// CREER UN REPERTOIRE / CREATE DIR
//------------------------------------
case "mkdir":
$messtmp = "";
if (!isset($httpVars["dirname"])) {
$uniq = $selection->getUniqueFile();
$dir = AJXP_Utils::safeDirname($uniq);
$dirname = AJXP_Utils::safeBasename($uniq);
} else {
$dirname = AJXP_Utils::decodeSecureMagic($httpVars["dirname"], AJXP_SANITIZE_FILENAME);
}
$dirname = substr($dirname, 0, ConfService::getCoreConf("NODENAME_MAX_LENGTH"));
$this->filterUserSelectionToHidden(array($dirname));
AJXP_Controller::applyHook("node.before_create", array(new AJXP_Node($dir . "/" . $dirname), -2));
$error = $this->mkDir($dir, $dirname, isset($httpVars["ignore_exists"]) ? true : false);
if (isset($error)) {
throw new AJXP_Exception($error);
}
$messtmp .= "{$mess['38']} " . SystemTextEncoding::toUTF8($dirname) . " {$mess['39']} ";
if ($dir == "") {
$messtmp .= "/";
} else {
$messtmp .= SystemTextEncoding::toUTF8($dir);
}
$logMessage = $messtmp;
//$pendingSelection = $dirname;
//$reloadContextNode = true;
$newNode = new AJXP_Node($this->urlBase . $dir . "/" . $dirname);
if (!isset($nodesDiffs)) {
$nodesDiffs = $this->getNodesDiffArray();
}
array_push($nodesDiffs["ADD"], $newNode);
$this->logInfo("Create Dir", array("dir" => $this->addSlugToPath($dir) . "/" . $dirname));
break;
//------------------------------------
// CREER UN FICHIER / CREATE FILE
//------------------------------------
//------------------------------------
// CREER UN FICHIER / CREATE FILE
//------------------------------------
case "mkfile":
$messtmp = "";
if (empty($httpVars["filename"]) && isset($httpVars["node"])) {
$filename = AJXP_Utils::decodeSecureMagic($httpVars["node"], AJXP_SANITIZE_FILENAME);
} else {
$filename = AJXP_Utils::decodeSecureMagic($httpVars["filename"], AJXP_SANITIZE_FILENAME);
}
$filename = substr($filename, 0, ConfService::getCoreConf("NODENAME_MAX_LENGTH"));
$this->filterUserSelectionToHidden(array($filename));
$content = "";
if (isset($httpVars["content"])) {
$content = $httpVars["content"];
}
$error = $this->createEmptyFile($dir, $filename, $content);
if (isset($error)) {
throw new AJXP_Exception($error);
}
$messtmp .= "{$mess['34']} " . SystemTextEncoding::toUTF8($filename) . " {$mess['39']} ";
if ($dir == "") {
$messtmp .= "/";
} else {
$messtmp .= SystemTextEncoding::toUTF8($dir);
}
$logMessage = $messtmp;
//$reloadContextNode = true;
//$pendingSelection = $dir."/".$filename;
$this->logInfo("Create File", array("file" => $this->addSlugToPath($dir) . "/" . $filename));
$newNode = new AJXP_Node($this->urlBase . $dir . "/" . $filename);
if (!isset($nodesDiffs)) {
$nodesDiffs = $this->getNodesDiffArray();
}
array_push($nodesDiffs["ADD"], $newNode);
break;
//------------------------------------
// CHANGE FILE PERMISSION
//------------------------------------
//------------------------------------
// CHANGE FILE PERMISSION
//------------------------------------
case "chmod":
$files = $selection->getFiles();
$changedFiles = array();
$chmod_value = $httpVars["chmod_value"];
$recursive = $httpVars["recursive"];
$recur_apply_to = $httpVars["recur_apply_to"];
foreach ($files as $fileName) {
$this->chmod($fileName, $chmod_value, $recursive == "on", $recursive == "on" ? $recur_apply_to : "both", $changedFiles);
}
$logMessage = "Successfully changed permission to " . $chmod_value . " for " . count($changedFiles) . " files or folders";
$this->logInfo("Chmod", array("dir" => $this->addSlugToPath($dir), "filesCount" => count($changedFiles)));
if (!isset($nodesDiffs)) {
$nodesDiffs = $this->getNodesDiffArray();
}
$nodesDiffs["UPDATE"] = array_merge($nodesDiffs["UPDATE"], $selection->buildNodes($this));
break;
//------------------------------------
// UPLOAD
//------------------------------------
//------------------------------------
// UPLOAD
//------------------------------------
case "upload":
$repoData = array('base_url' => $this->urlBase, 'wrapper_name' => $this->wrapperClassName, 'chmod' => $this->repository->getOption('CHMOD_VALUE'), 'recycle' => $this->repository->getOption('RECYCLE_BIN'));
$this->logDebug("Upload Files Data", $fileVars);
$destination = $this->urlBase . AJXP_Utils::decodeSecureMagic($dir);
$this->logDebug("Upload inside", array("destination" => $this->addSlugToPath($destination)));
if (!$this->isWriteable($destination)) {
$errorCode = 412;
$errorMessage = "{$mess['38']} " . SystemTextEncoding::toUTF8($dir) . " {$mess['99']}.";
$this->logDebug("Upload error 412", array("destination" => $this->addSlugToPath($destination)));
return array("ERROR" => array("CODE" => $errorCode, "MESSAGE" => $errorMessage));
}
foreach ($fileVars as $boxName => $boxData) {
if (substr($boxName, 0, 9) != "userfile_") {
continue;
}
$err = AJXP_Utils::parseFileDataErrors($boxData);
if ($err != null) {
$errorCode = $err[0];
$errorMessage = $err[1];
break;
}
$userfile_name = $boxData["name"];
try {
$this->filterUserSelectionToHidden(array($userfile_name));
} catch (Exception $e) {
return array("ERROR" => array("CODE" => 411, "MESSAGE" => "Forbidden"));
}
$userfile_name = AJXP_Utils::sanitize(SystemTextEncoding::fromPostedFileName($userfile_name), AJXP_SANITIZE_FILENAME);
if (isset($httpVars["urlencoded_filename"])) {
$userfile_name = AJXP_Utils::sanitize(SystemTextEncoding::fromUTF8(urldecode($httpVars["urlencoded_filename"])), AJXP_SANITIZE_FILENAME);
}
$this->logDebug("User filename " . $userfile_name);
$userfile_name = substr($userfile_name, 0, ConfService::getCoreConf("NODENAME_MAX_LENGTH"));
if (isset($httpVars["auto_rename"])) {
$userfile_name = self::autoRenameForDest($destination, $userfile_name);
}
$already_existed = false;
try {
if (file_exists($destination . "/" . $userfile_name)) {
$already_existed = true;
AJXP_Controller::applyHook("node.before_change", array(new AJXP_Node($destination . "/" . $userfile_name), $boxData["size"]));
} else {
AJXP_Controller::applyHook("node.before_create", array(new AJXP_Node($destination . "/" . $userfile_name), $boxData["size"]));
}
AJXP_Controller::applyHook("node.before_change", array(new AJXP_Node($destination)));
} catch (Exception $e) {
$errorCode = 507;
$errorMessage = $e->getMessage();
break;
}
if (isset($boxData["input_upload"])) {
try {
$this->logDebug("Begining reading INPUT stream");
$input = fopen("php://input", "r");
$output = fopen("{$destination}/" . $userfile_name, "w");
$sizeRead = 0;
while ($sizeRead < intval($boxData["size"])) {
$chunk = fread($input, 4096);
$sizeRead += strlen($chunk);
fwrite($output, $chunk, strlen($chunk));
}
fclose($input);
fclose($output);
$this->logDebug("End reading INPUT stream");
} catch (Exception $e) {
$errorCode = 411;
$errorMessage = $e->getMessage();
break;
}
} else {
$result = @move_uploaded_file($boxData["tmp_name"], "{$destination}/" . $userfile_name);
if (!$result) {
$realPath = call_user_func(array($this->wrapperClassName, "getRealFSReference"), "{$destination}/" . $userfile_name);
$result = move_uploaded_file($boxData["tmp_name"], $realPath);
}
if (!$result) {
$errorCode = 411;
$errorMessage = "{$mess['33']} " . $userfile_name;
break;
}
}
if (isset($httpVars["appendto_urlencoded_part"])) {
$appendTo = AJXP_Utils::sanitize(SystemTextEncoding::fromUTF8(urldecode($httpVars["appendto_urlencoded_part"])), AJXP_SANITIZE_FILENAME);
if (file_exists($destination . "/" . $appendTo)) {
$this->logDebug("Should copy stream from {$userfile_name} to {$appendTo}");
$partO = fopen($destination . "/" . $userfile_name, "r");
$appendF = fopen($destination . "/" . $appendTo, "a+");
while (!feof($partO)) {
$buf = fread($partO, 1024);
fwrite($appendF, $buf, strlen($buf));
}
fclose($partO);
fclose($appendF);
$this->logDebug("Done, closing streams!");
}
@unlink($destination . "/" . $userfile_name);
$userfile_name = $appendTo;
}
$this->changeMode($destination . "/" . $userfile_name, $repoData);
$createdNode = new AJXP_Node($destination . "/" . $userfile_name);
//AJXP_Controller::applyHook("node.change", array(null, $createdNode, false));
$logMessage .= "{$mess['34']} " . SystemTextEncoding::toUTF8($userfile_name) . " {$mess['35']} {$dir}";
$this->logInfo("Upload File", array("file" => $this->addSlugToPath(SystemTextEncoding::fromUTF8($dir)) . "/" . $userfile_name));
}
if (isset($errorMessage)) {
$this->logDebug("Return error {$errorCode} {$errorMessage}");
return array("ERROR" => array("CODE" => $errorCode, "MESSAGE" => $errorMessage));
} else {
$this->logDebug("Return success");
if ($already_existed) {
return array("SUCCESS" => true, "UPDATED_NODE" => $createdNode);
} else {
return array("SUCCESS" => true, "CREATED_NODE" => $createdNode);
}
}
return;
break;
case "lsync":
if (!ConfService::currentContextIsCommandLine()) {
die("This command must be accessed via CLI only.");
}
$fromNode = null;
$toNode = null;
$copyOrMove = false;
if (isset($httpVars["from"])) {
$fromNode = new AJXP_Node($this->urlBase . AJXP_Utils::decodeSecureMagic($httpVars["from"]));
}
if (isset($httpVars["to"])) {
$toNode = new AJXP_Node($this->urlBase . AJXP_Utils::decodeSecureMagic($httpVars["to"]));
}
if (isset($httpVars["copy"]) && $httpVars["copy"] == "true") {
$copyOrMove = true;
}
AJXP_Controller::applyHook("node.change", array($fromNode, $toNode, $copyOrMove));
break;
//------------------------------------
// XML LISTING
//------------------------------------
//------------------------------------
// XML LISTING
//------------------------------------
case "ls":
if (!isset($dir) || $dir == "/") {
$dir = "";
}
$lsOptions = $this->parseLsOptions(isset($httpVars["options"]) ? $httpVars["options"] : "a");
$startTime = microtime();
if (isset($httpVars["file"])) {
$uniqueFile = AJXP_Utils::decodeSecureMagic($httpVars["file"]);
}
$dir = AJXP_Utils::securePath($dir);
$path = $this->urlBase . ($dir != "" ? ($dir[0] == "/" ? "" : "/") . $dir : "");
$nonPatchedPath = $path;
if ($this->wrapperClassName == "fsAccessWrapper") {
$nonPatchedPath = fsAccessWrapper::unPatchPathForBaseDir($path);
}
if ($this->getFilteredOption("REMOTE_SORTING")) {
$orderDirection = isset($httpVars["order_direction"]) ? strtolower($httpVars["order_direction"]) : "asc";
$orderField = isset($httpVars["order_column"]) ? $httpVars["order_column"] : null;
if ($orderField != null && !in_array($orderField, array("ajxp_label", "filesize", "ajxp_modiftime", "mimestring"))) {
$orderField = "ajxp_label";
}
}
if (isset($httpVars["recursive"]) && $httpVars["recursive"] == "true") {
$max_depth = isset($httpVars["max_depth"]) ? intval($httpVars["max_depth"]) : 0;
$max_nodes = isset($httpVars["max_nodes"]) ? intval($httpVars["max_nodes"]) : 0;
$crt_depth = isset($httpVars["crt_depth"]) ? intval($httpVars["crt_depth"]) + 1 : 1;
$crt_nodes = isset($httpVars["crt_nodes"]) ? intval($httpVars["crt_nodes"]) : 0;
} else {
$threshold = $this->repository->getOption("PAGINATION_THRESHOLD");
if (!isset($threshold) || intval($threshold) == 0) {
$threshold = 500;
}
$limitPerPage = $this->repository->getOption("PAGINATION_NUMBER");
if (!isset($limitPerPage) || intval($limitPerPage) == 0) {
$limitPerPage = 200;
}
}
$countFiles = $this->countFiles($path, !$lsOptions["f"]);
if (isset($crt_nodes)) {
$crt_nodes += $countFiles;
}
if (isset($threshold) && isset($limitPerPage) && $countFiles > $threshold) {
if (isset($uniqueFile)) {
$originalLimitPerPage = $limitPerPage;
$offset = $limitPerPage = 0;
} else {
$offset = 0;
$crtPage = 1;
if (isset($page)) {
$offset = (intval($page) - 1) * $limitPerPage;
$crtPage = $page;
}
$totalPages = floor($countFiles / $limitPerPage) + 1;
}
} else {
$offset = $limitPerPage = 0;
}
$metaData = array();
if (RecycleBinManager::recycleEnabled() && $dir == "") {
$metaData["repo_has_recycle"] = "true";
}
$parentAjxpNode = new AJXP_Node($nonPatchedPath, $metaData);
$parentAjxpNode->loadNodeInfo(false, true, $lsOptions["l"] ? "all" : "minimal");
AJXP_Controller::applyHook("node.read", array(&$parentAjxpNode));
if (AJXP_XMLWriter::$headerSent == "tree") {
AJXP_XMLWriter::renderAjxpNode($parentAjxpNode, false);
} else {
AJXP_XMLWriter::renderAjxpHeaderNode($parentAjxpNode);
}
if (isset($totalPages) && isset($crtPage)) {
$remoteOptions = null;
if ($this->getFilteredOption("REMOTE_SORTING")) {
$remoteOptions = array("remote_order" => "true", "currentOrderCol" => isset($orderField) ? $orderField : "ajxp_label", "currentOrderDir" => isset($orderDirection) ? $orderDirection : "asc");
}
AJXP_XMLWriter::renderPaginationData($countFiles, $crtPage, $totalPages, $this->countFiles($path, TRUE), $remoteOptions);
if (!$lsOptions["f"]) {
AJXP_XMLWriter::close();
exit(1);
}
}
$cursor = 0;
$handle = opendir($path);
if (!$handle) {
throw new AJXP_Exception("Cannot open dir " . $nonPatchedPath);
}
closedir($handle);
$fullList = array("d" => array(), "z" => array(), "f" => array());
if (isset($orderField) && isset($orderDirection) && $orderField == "ajxp_label" && $orderDirection == "desc") {
$nodes = scandir($path, 1);
} else {
$nodes = scandir($path);
}
if (!empty($this->driverConf["SCANDIR_RESULT_SORTFONC"])) {
usort($nodes, $this->driverConf["SCANDIR_RESULT_SORTFONC"]);
}
if (isset($orderField) && isset($orderDirection) && $orderField != "ajxp_label") {
$toSort = array();
foreach ($nodes as $node) {
if ($orderField == "filesize") {
$toSort[$node] = is_file($nonPatchedPath . "/" . $node) ? $this->filesystemFileSize($nonPatchedPath . "/" . $node) : 0;
} else {
if ($orderField == "ajxp_modiftime") {
$toSort[$node] = filemtime($nonPatchedPath . "/" . $node);
} else {
if ($orderField == "mimestring") {
$toSort[$node] = pathinfo($node, PATHINFO_EXTENSION);
}
}
}
}
if ($orderDirection == "asc") {
asort($toSort);
} else {
arsort($toSort);
}
$nodes = array_keys($toSort);
}
//while (strlen($nodeName = readdir($handle)) > 0) {
foreach ($nodes as $nodeName) {
if ($nodeName == "." || $nodeName == "..") {
continue;
}
if (isset($uniqueFile) && $nodeName != $uniqueFile) {
$cursor++;
continue;
}
if ($offset > 0 && $cursor < $offset) {
$cursor++;
continue;
}
$isLeaf = "";
if (!$this->filterNodeName($path, $nodeName, $isLeaf, $lsOptions)) {
continue;
}
if (RecycleBinManager::recycleEnabled() && $dir == "" && "/" . $nodeName == RecycleBinManager::getRecyclePath()) {
continue;
}
if ($limitPerPage > 0 && $cursor - $offset >= $limitPerPage) {
break;
}
$currentFile = $nonPatchedPath . "/" . $nodeName;
$meta = array();
if ($isLeaf != "") {
$meta = array("is_file" => $isLeaf ? "1" : "0");
}
$node = new AJXP_Node($currentFile, $meta);
$node->setLabel($nodeName);
$node->loadNodeInfo(false, false, $lsOptions["l"] ? "all" : "minimal");
if (!empty($node->metaData["nodeName"]) && $node->metaData["nodeName"] != $nodeName) {
$node->setUrl($nonPatchedPath . "/" . $node->metaData["nodeName"]);
}
if (!empty($node->metaData["hidden"]) && $node->metaData["hidden"] === true) {
continue;
}
if (!empty($node->metaData["mimestring_id"]) && array_key_exists($node->metaData["mimestring_id"], $mess)) {
$node->mergeMetadata(array("mimestring" => $mess[$node->metaData["mimestring_id"]]));
}
if (isset($originalLimitPerPage) && $cursor > $originalLimitPerPage) {
$node->mergeMetadata(array("page_position" => floor($cursor / $originalLimitPerPage) + 1));
}
$nodeType = "d";
if ($node->isLeaf()) {
if (AJXP_Utils::isBrowsableArchive($nodeName)) {
if ($lsOptions["f"] && $lsOptions["z"]) {
$nodeType = "f";
} else {
$nodeType = "z";
}
} else {
$nodeType = "f";
}
}
// There is a special sorting, cancel the reordering of files & folders.
if (isset($orderField) && $orderField != "ajxp_label") {
$nodeType = "f";
}
$fullList[$nodeType][$nodeName] = $node;
$cursor++;
if (isset($uniqueFile) && $nodeName != $uniqueFile) {
break;
}
}
if (isset($httpVars["recursive"]) && $httpVars["recursive"] == "true") {
$breakNow = false;
if (isset($max_depth) && $max_depth > 0 && $crt_depth >= $max_depth) {
$breakNow = true;
}
if (isset($max_nodes) && $max_nodes > 0 && $crt_nodes >= $max_nodes) {
$breakNow = true;
}
foreach ($fullList["d"] as &$nodeDir) {
if ($breakNow) {
$nodeDir->mergeMetadata(array("ajxp_has_children" => $this->countFiles($nodeDir->getUrl(), false, true) ? "true" : "false"));
AJXP_XMLWriter::renderAjxpNode($nodeDir, true);
continue;
}
$this->switchAction("ls", array("dir" => SystemTextEncoding::toUTF8($nodeDir->getPath()), "options" => $httpVars["options"], "recursive" => "true", "max_depth" => $max_depth, "max_nodes" => $max_nodes, "crt_depth" => $crt_depth, "crt_nodes" => $crt_nodes), array());
}
} else {
array_map(array("AJXP_XMLWriter", "renderAjxpNode"), $fullList["d"]);
}
array_map(array("AJXP_XMLWriter", "renderAjxpNode"), $fullList["z"]);
array_map(array("AJXP_XMLWriter", "renderAjxpNode"), $fullList["f"]);
// ADD RECYCLE BIN TO THE LIST
if ($dir == "" && !$uniqueFile && RecycleBinManager::recycleEnabled() && $this->getFilteredOption("HIDE_RECYCLE", $this->repository->getId()) !== true) {
$recycleBinOption = RecycleBinManager::getRelativeRecycle();
if (file_exists($this->urlBase . $recycleBinOption)) {
$recycleNode = new AJXP_Node($this->urlBase . $recycleBinOption);
$recycleNode->loadNodeInfo();
AJXP_XMLWriter::renderAjxpNode($recycleNode);
}
}
$this->logDebug("LS Time : " . intval((microtime() - $startTime) * 1000) . "ms");
AJXP_XMLWriter::close();
break;
}
$xmlBuffer = "";
if (isset($logMessage) || isset($errorMessage)) {
$xmlBuffer .= AJXP_XMLWriter::sendMessage(isset($logMessage) ? $logMessage : null, isset($errorMessage) ? $errorMessage : null, false);
}
if ($reloadContextNode) {
if (!isset($pendingSelection)) {
$pendingSelection = "";
}
$xmlBuffer .= AJXP_XMLWriter::reloadDataNode("", $pendingSelection, false);
}
if (isset($reloadDataNode)) {
$xmlBuffer .= AJXP_XMLWriter::reloadDataNode($reloadDataNode, "", false);
}
if (isset($nodesDiffs)) {
$xmlBuffer .= AJXP_XMLWriter::writeNodesDiff($nodesDiffs, false);
}
return $xmlBuffer;
}
public function switchAction($action, $httpVars, $filesVars)
{
if (!isset($this->actions[$action])) {
return false;
}
$repository = ConfService::getRepository();
if (!$repository->detectStreamWrapper(true)) {
return false;
}
$streamData = $repository->streamData;
$destStreamURL = $streamData["protocol"] . "://" . $repository->getId();
$wrapperClassName = $streamData["classname"];
if (empty($httpVars["file"])) {
return;
}
$file = $destStreamURL . AJXP_Utils::decodeSecureMagic($httpVars["file"]);
$mess = ConfService::getMessages();
$node = new AJXP_Node($file);
AJXP_Controller::applyHook("node.read", array($node));
switch ($action) {
case "eml_get_xml_structure":
$params = array('include_bodies' => false, 'decode_bodies' => false, 'decode_headers' => 'UTF-8');
$decoder = $this->getStructureDecoder($file, $wrapperClassName == "imapAccessWrapper");
$xml = $decoder->getXML($decoder->decode($params));
if (function_exists("imap_mime_header_decode")) {
$doc = new DOMDocument();
$doc->loadXML($xml);
$xPath = new DOMXPath($doc);
$headers = $xPath->query("//headername");
$changes = false;
foreach ($headers as $headerNode) {
if ($headerNode->firstChild->nodeValue == "Subject") {
$headerValueNode = $headerNode->nextSibling->nextSibling;
$value = $headerValueNode->nodeValue;
$elements = imap_mime_header_decode($value);
$decoded = "";
foreach ($elements as $element) {
$decoded .= $element->text;
$charset = $element->charset;
}
if ($decoded != $value) {
$value = SystemTextEncoding::changeCharset($charset, "UTF-8", $decoded);
$node = $doc->createElement("headervalue", $value);
$res = $headerNode->parentNode->replaceChild($node, $headerValueNode);
$changes = true;
}
}
}
if ($changes) {
$xml = $doc->saveXML();
}
}
print $xml;
break;
case "eml_get_bodies":
require_once "Mail/mimeDecode.php";
$params = array('include_bodies' => true, 'decode_bodies' => true, 'decode_headers' => false);
if ($wrapperClassName == "imapAccessWrapper") {
$cache = AJXP_Cache::getItem("eml_remote", $file, null, array("EmlParser", "computeCacheId"));
$content = $cache->getData();
} else {
$content = file_get_contents($file);
}
$decoder = new Mail_mimeDecode($content);
$structure = $decoder->decode($params);
$html = $this->_findPartByCType($structure, "text", "html");
$text = $this->_findPartByCType($structure, "text", "plain");
if ($html != false && isset($html->ctype_parameters) && isset($html->ctype_parameters["charset"])) {
$charset = $html->ctype_parameters["charset"];
}
if (isset($charset)) {
header('Content-Type: text/xml; charset=' . $charset);
header('Cache-Control: no-cache');
print '<?xml version="1.0" encoding="' . $charset . '"?>';
print '<email_body>';
} else {
AJXP_XMLWriter::header("email_body");
}
if ($html !== false) {
print '<mimepart type="html"><![CDATA[';
$text = $html->body;
print $text;
print "]]></mimepart>";
}
if ($text !== false) {
print '<mimepart type="plain"><![CDATA[';
print $text->body;
print "]]></mimepart>";
}
AJXP_XMLWriter::close("email_body");
break;
case "eml_dl_attachment":
$attachId = $httpVars["attachment_id"];
if (!isset($attachId)) {
break;
}
require_once "Mail/mimeDecode.php";
$params = array('include_bodies' => true, 'decode_bodies' => true, 'decode_headers' => false);
if ($wrapperClassName == "imapAccessWrapper") {
$cache = AJXP_Cache::getItem("eml_remote", $file, null, array("EmlParser", "computeCacheId"));
$content = $cache->getData();
} else {
$content = file_get_contents($file);
}
$decoder = new Mail_mimeDecode($content);
$structure = $decoder->decode($params);
$part = $this->_findAttachmentById($structure, $attachId);
if ($part !== false) {
$fake = new fsAccessDriver("fake", "");
$fake->readFile($part->body, "file", $part->d_parameters['filename'], true);
exit;
} else {
//var_dump($structure);
}
break;
case "eml_cp_attachment":
$attachId = $httpVars["attachment_id"];
$destRep = AJXP_Utils::decodeSecureMagic($httpVars["destination"]);
if (!isset($attachId)) {
AJXP_XMLWriter::sendMessage(null, "Wrong Parameters");
break;
}
require_once "Mail/mimeDecode.php";
$params = array('include_bodies' => true, 'decode_bodies' => true, 'decode_headers' => false);
if ($wrapperClassName == "imapAccessWrapper") {
$cache = AJXP_Cache::getItem("eml_remote", $file, null, array("EmlParser", "computeCacheId"));
$content = $cache->getData();
} else {
$content = file_get_contents($file);
}
$decoder = new Mail_mimeDecode($content);
$structure = $decoder->decode($params);
$part = $this->_findAttachmentById($structure, $attachId);
AJXP_XMLWriter::header();
if ($part !== false) {
if (isset($httpVars["dest_repository_id"])) {
$destRepoId = $httpVars["dest_repository_id"];
if (AuthService::usersEnabled()) {
$loggedUser = AuthService::getLoggedUser();
if (!$loggedUser->canWrite($destRepoId)) {
throw new Exception($mess[364]);
}
}
$destRepoObject = ConfService::getRepositoryById($destRepoId);
$destRepoAccess = $destRepoObject->getAccessType();
$plugin = AJXP_PluginsService::findPlugin("access", $destRepoAccess);
$destWrapperData = $plugin->detectStreamWrapper(true);
$destStreamURL = $destWrapperData["protocol"] . "://{$destRepoId}";
}
$destFile = $destStreamURL . $destRep . "/" . $part->d_parameters['filename'];
$fp = fopen($destFile, "w");
if ($fp !== false) {
fwrite($fp, $part->body, strlen($part->body));
fclose($fp);
AJXP_XMLWriter::sendMessage(sprintf($mess["editor.eml.7"], $part->d_parameters["filename"], $destRep), NULL);
} else {
AJXP_XMLWriter::sendMessage(null, $mess["editor.eml.8"]);
}
} else {
AJXP_XMLWriter::sendMessage(null, $mess["editor.eml.9"]);
}
AJXP_XMLWriter::close();
break;
default:
break;
}
}
public function handleTasks($action, $httpVars, $fileVars)
{
$tasks = AJXP_Utils::loadSerialFile($this->getDbFile(), false, "json");
switch ($action) {
case "scheduler_addTask":
if (isset($httpVars["task_id"])) {
foreach ($tasks as $index => $task) {
if ($task["task_id"] == $httpVars["task_id"]) {
$data = $task;
$theIndex = $index;
}
}
}
if (!isset($theIndex)) {
$data = array();
$data["task_id"] = substr(md5(time()), 0, 16);
}
$data["label"] = $httpVars["label"];
$data["schedule"] = $httpVars["schedule"];
$data["action_name"] = $httpVars["action_name"];
$data["repository_id"] = $httpVars["repository_id"];
$i = 1;
while (array_key_exists("repository_id_" . $i, $httpVars)) {
$data["repository_id"] .= "," . $httpVars["repository_id_" . $i];
$i++;
}
$data["user_id"] = $httpVars["user_id"];
$data["PARAMS"] = array();
if (!empty($httpVars["param_name"]) && !empty($httpVars["param_value"])) {
$data["PARAMS"][$httpVars["param_name"]] = $httpVars["param_value"];
}
foreach ($httpVars as $key => $value) {
if (preg_match('/^param_name_/', $key)) {
$paramIndex = str_replace("param_name_", "", $key);
if (preg_match('/ajxptype/', $paramIndex)) {
continue;
}
if (preg_match('/replication/', $paramIndex)) {
continue;
}
if (isset($httpVars["param_value_" . $paramIndex])) {
$data["PARAMS"][$value] = $httpVars["param_value_" . $paramIndex];
}
}
}
if (isset($theIndex)) {
$tasks[$theIndex] = $data;
} else {
$tasks[] = $data;
}
AJXP_Utils::saveSerialFile($this->getDbFile(), $tasks, true, false, "json");
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage("Successfully added/edited task", null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
break;
case "scheduler_removeTask":
$this->removeTask($httpVars["task_id"]);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage("Successfully removed task", null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
break;
case "scheduler_loadTask":
$found = false;
foreach ($tasks as $task) {
if ($task["task_id"] == $httpVars["task_id"]) {
$index = 0;
$found = true;
foreach ($task["PARAMS"] as $pName => $pValue) {
if ($index == 0) {
$task["param_name"] = $pName;
$task["param_value"] = $pValue;
} else {
$task["param_name_" . $index] = $pName;
$task["param_value_" . $index] = $pValue;
}
$index++;
}
unset($task["PARAMS"]);
if (strpos($task["repository_id"], ",") !== false) {
$ids = explode(",", $task["repository_id"]);
$task["repository_id"] = $ids[0];
for ($i = 1; $i < count($ids); $i++) {
$task["repository_id_" . $i] = $ids[$i];
}
}
break;
}
}
if ($found) {
HTMLWriter::charsetHeader("application/json");
echo json_encode($task);
}
break;
default:
break;
}
//var_dump($tasks);
}
function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->actions[$action])) {
return;
}
$xmlBuffer = "";
foreach ($httpVars as $getName => $getValue) {
${$getName} = Utils::securePath(SystemTextEncoding::magicDequote($getValue));
}
$selection = new UserSelection();
$selection->initFromHttpVars($httpVars);
if (isset($dir) && $action != "upload") {
$safeDir = $dir;
$dir = SystemTextEncoding::fromUTF8($dir);
}
if (isset($dest)) {
$dest = SystemTextEncoding::fromUTF8($dest);
}
$mess = ConfService::getMessages();
$recycleBinOption = $this->repository->getOption("RECYCLE_BIN");
// FILTER ACTION FOR DELETE
if ($recycleBinOption != "" && $action == "delete" && $dir != "/" . $recycleBinOption) {
$action = "move";
$dest = "/" . $recycleBinOption;
$dest_node = "AJAXPLORER_RECYCLE_NODE";
}
// FILTER ACTION FOR RESTORE
if ($recycleBinOption != "" && $action == "restore" && $dir == "/" . $recycleBinOption) {
$originalRep = RecycleBinManager::getFileOrigin($selection->getUniqueFile());
if ($originalRep != "") {
$action = "move";
$dest = $originalRep;
}
}
switch ($action) {
//------------------------------------
// DOWNLOAD, IMAGE & MP3 PROXYS
//------------------------------------
case "download":
AJXP_Logger::logAction("Download", array("files" => $selection));
$zip = false;
if ($selection->isUnique()) {
if (is_dir($this->getPath() . "/" . $selection->getUniqueFile())) {
$zip = true;
$dir .= "/" . basename($selection->getUniqueFile());
}
} else {
$zip = true;
}
if ($zip) {
// Make a temp zip and send it as download
$this->downFile($this->makeName($selection->getFiles()), "force-download", "archive.zip");
} else {
$this->downFile($this->makeName($selection->getUniqueFile()), "force-download", $selection->getUniqueFile());
}
exit(0);
break;
case "image_proxy":
$this->downFile($this->makeName($file), "image", $file);
exit(0);
break;
case "mp3_proxy":
$this->downFile($this->makeName($file), "mp3", $file);
exit(0);
break;
//------------------------------------
// ONLINE EDIT
//------------------------------------
//------------------------------------
// ONLINE EDIT
//------------------------------------
case "edit":
if (isset($save) && $save == 1) {
AJXP_Logger::logAction("Online Edition", array("file" => SystemTextEncoding::fromUTF8($file)));
$code = stripslashes($code);
$code = str_replace("<", "<", $code);
$this->SSHOperation->setRemoteContent($this->makeName($file), $code);
echo $mess[115];
} else {
$this->sendFile($this->SSHOperation->getRemoteContent($this->makeName($file)), "plain", $file);
}
exit(0);
break;
//------------------------------------
// COPY / MOVE
//------------------------------------
//------------------------------------
// COPY / MOVE
//------------------------------------
case "copy":
case "move":
if ($selection->isEmpty()) {
$errorMessage = $mess[113];
break;
}
$result = "";
if ($action == "move") {
$result = $this->SSHOperation->moveFile($this->makeName($selection->getFiles()), $this->makeName($dest));
} else {
$result = $this->SSHOperation->copyFile($this->makeName($selection->getFiles()), $this->makeName($dest));
}
$mess = ConfService::getMessages();
if (strlen($result)) {
$errorMessage = $mess[114];
} else {
foreach ($selection->getFiles() as $files) {
$logMessage .= $mess[34] . " " . SystemTextEncoding::toUTF8(basename($file)) . " " . $mess[$action == "move" ? 74 : 73] . " " . SystemTextEncoding::toUTF8($dest) . "\n";
}
AJXP_Logger::logAction($action == "move" ? "Move" : "Copy", array("files" => $selection, "destination" => $dest));
}
$reload_current_node = true;
if (isset($dest_node)) {
$reload_dest_node = $dest_node;
}
$reload_file_list = true;
break;
//------------------------------------
// CHANGE FILE PERMISSION
//------------------------------------
//------------------------------------
// CHANGE FILE PERMISSION
//------------------------------------
case "chmod":
$messtmp = "";
$changedFiles = array();
$value = "0" . decoct(octdec(ltrim($chmod_value, "0")));
// On error, the command will fail
$result = $this->SSHOperation->chmodFile($this->makeName($selection->getFiles()), $chmod_value);
$mess = ConfService::getMessages();
if (strlen($result)) {
$errorMessage = $mess[114];
} else {
$logMessage = "Successfully changed permission to " . $chmod_value . " for " . count($selection->getFiles()) . " files or folders";
AJXP_Logger::logAction("Chmod", array("dir" => $dir, "filesCount" => count($selection->getFiles())));
$reload_file_list = $dir;
}
break;
//------------------------------------
// SUPPRIMER / DELETE
//------------------------------------
//------------------------------------
// SUPPRIMER / DELETE
//------------------------------------
case "delete":
if ($selection->isEmpty()) {
$errorMessage = $mess[113];
break;
}
$logMessages = array();
$result = $this->SSHOperation->deleteFile($this->makeName($selection->getFiles()));
if (strlen($result)) {
$mess = ConfService::getMessages();
$errorMessage = $mess[120];
} else {
$mess = ConfService::getMessages();
foreach ($selection->getFiles() as $file) {
$logMessages[] = "{$mess['34']} " . SystemTextEncoding::toUTF8($file) . " {$mess['44']}.";
}
$logMessage = join("\n", $logMessages);
}
AJXP_Logger::logAction("Delete", array("files" => $selection));
$reload_current_node = true;
$reload_file_list = true;
break;
//------------------------------------
// RENOMMER / RENAME
//------------------------------------
//------------------------------------
// RENOMMER / RENAME
//------------------------------------
case "rename":
$filename_new = $dir . "/" . $filename_new;
$error = $this->SSHOperation->moveFile($this->makeName($file), $this->makeName($filename_new));
if ($error != null) {
$errorMessage = $error;
break;
}
$logMessage = SystemTextEncoding::toUTF8($file) . " {$mess['41']} " . SystemTextEncoding::toUTF8($filename_new);
$reload_current_node = true;
$reload_file_list = basename($filename_new);
AJXP_Logger::logAction("Rename", array("original" => $file, "new" => $filename_new));
break;
//------------------------------------
// CREER UN REPERTOIRE / CREATE DIR
//------------------------------------
//------------------------------------
// CREER UN REPERTOIRE / CREATE DIR
//------------------------------------
case "mkdir":
$messtmp = "";
$dirname = Utils::processFileName($dirname);
$error = $this->SSHOperation->createRemoteDirectory($this->makeName($dir . "/" . $dirname));
if (isset($error)) {
$errorMessage = $error;
break;
}
$reload_file_list = $dirname;
$messtmp .= "{$mess['38']} " . SystemTextEncoding::toUTF8($dirname) . " {$mess['39']} ";
if ($dir == "") {
$messtmp .= "/";
} else {
$messtmp .= SystemTextEncoding::toUTF8($dir);
}
$logMessage = $messtmp;
$reload_current_node = true;
AJXP_Logger::logAction("Create Dir", array("dir" => $dir . "/" . $dirname));
break;
//------------------------------------
// CREER UN FICHIER / CREATE FILE
//------------------------------------
//------------------------------------
// CREER UN FICHIER / CREATE FILE
//------------------------------------
case "mkfile":
$messtmp = "";
$filename = Utils::processFileName($filename);
$error = $this->SSHOperation->setRemoteContent($this->makeName($dir . "/" . $filename), "");
if (isset($error)) {
$errorMessage = $error;
break;
}
$messtmp .= "{$mess['34']} " . SystemTextEncoding::toUTF8($filename) . " {$mess['39']} ";
if ($dir == "") {
$messtmp .= "/";
} else {
$messtmp .= SystemTextEncoding::toUTF8($dir);
}
$logMessage = $messtmp;
$reload_file_list = $filename;
AJXP_Logger::logAction("Create File", array("file" => $dir . "/" . $filename));
break;
//------------------------------------
// UPLOAD
//------------------------------------
//------------------------------------
// UPLOAD
//------------------------------------
case "upload":
$fancyLoader = false;
if (isset($fileVars["Filedata"])) {
$fancyLoader = true;
if ($dir != "") {
$dir = "/" . base64_decode($dir);
}
}
if ($dir != "") {
$rep_source = "/{$dir}";
} else {
$rep_source = "";
}
$destination = $rep_source;
$logMessage = "";
//$fancyLoader = false;
foreach ($fileVars as $boxName => $boxData) {
if ($boxName != "Filedata" && substr($boxName, 0, 9) != "userfile_") {
continue;
}
if ($boxName == "Filedata") {
$fancyLoader = true;
}
$err = Utils::parseFileDataErrors($boxData, $fancyLoader);
if ($err != null) {
$errorMessage = $err;
break;
}
$userfile_name = $boxData["name"];
$userfile_name = Utils::processFileName($userfile_name);
if (!$this->SSHOperation->uploadFile($boxData["tmp_name"], $this->makeName($destination . "/" . $userfile_name))) {
$errorMessage = ($fancyLoader ? "411 " : "") . "{$mess['33']} " . $userfile_name;
break;
}
$logMessage .= "{$mess['34']} " . SystemTextEncoding::toUTF8($userfile_name) . " {$mess['35']} {$dir}";
AJXP_Logger::logAction("Upload File", array("file" => $dir . "/" . $userfile_name));
}
if ($fancyLoader) {
if (isset($errorMessage)) {
header('HTTP/1.0 ' . $errorMessage);
die('Error ' . $errorMessage);
} else {
header('HTTP/1.0 200 OK');
die("200 OK");
}
} else {
print "<html><script language=\"javascript\">\n";
if (isset($errorMessage)) {
print "\n if(parent.ajaxplorer.actionBar.multi_selector)parent.ajaxplorer.actionBar.multi_selector.submitNext('" . str_replace("'", "\\'", $errorMessage) . "');";
} else {
print "\n if(parent.ajaxplorer.actionBar.multi_selector)parent.ajaxplorer.actionBar.multi_selector.submitNext();";
}
print "</script></html>";
}
exit;
break;
//------------------------------------
// Public URL
//------------------------------------
//------------------------------------
// Public URL
//------------------------------------
case "public_url":
$file = SystemTextEncoding::fromUTF8($file);
$url = $this->makePubliclet($file, $password, $expiration);
header("Content-type:text/plain");
echo $url;
exit(1);
break;
//------------------------------------
// XML LISTING
//------------------------------------
//------------------------------------
// XML LISTING
//------------------------------------
case "ls":
if (!isset($dir) || $dir == "/") {
$dir = "";
}
$searchMode = $fileListMode = $completeMode = false;
if (isset($mode)) {
if ($mode == "search") {
$searchMode = true;
} else {
if ($mode == "file_list") {
$fileListMode = true;
} else {
if ($mode == "complete") {
$completeMode = true;
}
}
}
}
$nom_rep = $dir;
AJXP_Exception::errorToXml($nom_rep);
$result = $this->SSHOperation->listFilesIn($nom_rep);
AJXP_XMLWriter::header();
foreach ($result as $file) {
$attributes = "";
$fileName = SystemTextEncoding::toUTF8($file["name"]);
$icon = Utils::mimetype($fileName, "image", $file["isDir"] == 1);
if ($searchMode) {
if ($file["isDir"] == 0) {
$attributes = "is_file=\"true\" icon=\"" . SystemTextEncoding::toUTF8($icon) . "\"";
}
} else {
if ($fileListMode) {
$atts = array();
$atts[] = "is_file=\"" . (1 - $file["isDir"]) . "\"";
$atts[] = "is_image=\"" . Utils::is_image($fileName) . "\"";
$atts[] = "mimestring=\"" . Utils::mimetype($fileName, "type", $file["isDir"] == 1) . "\"";
$atts[] = "ajxp_modiftime=\"" . $this->dateModif($file["time"]) . "\"";
$atts[] = "filesize=\"" . Utils::roundSize($file["size"]) . "\"";
$atts[] = "bytesize=\"" . $file["size"] . "\"";
$atts[] = "filename=\"" . str_replace("&", "&", $dir . "/" . $fileName) . "\"";
$atts[] = "icon=\"" . ($file["isDir"] == 1 ? "folder.png" : SystemTextEncoding::toUTF8($icon)) . "\"";
$attributes = join(" ", $atts);
} else {
if ($file["isDir"] == 1) {
$link = SERVER_ACCESS . "?dir=" . $dir . "/" . $fileName;
$link = urlencode($link);
$folderBaseName = str_replace("&", "&", $fileName);
$folderFullName = "{$dir}/" . $folderBaseName;
$parentFolderName = $dir;
if (!$completeMode) {
$icon = CLIENT_RESOURCES_FOLDER . "/images/foldericon.png";
$openicon = CLIENT_RESOURCES_FOLDER . "/images/openfoldericon.png";
if (preg_match("/\\.zip\$/", $file["name"])) {
$icon = $openicon = CLIENT_RESOURCES_FOLDER . "/images/crystal/actions/16/accessories-archiver.png";
}
$attributes = "icon=\"{$icon}\" openicon=\"{$openicon}\" filename=\"" . $folderFullName . "\" src=\"{$link}\"";
}
}
}
}
if (strlen($attributes) > 0) {
print "<tree text=\"" . str_replace("&", "&", SystemTextEncoding::toUTF8($this->SSHOperation->unescapeFileName($file["name"]))) . "\" {$attributes}>";
print "</tree>";
}
}
AJXP_XMLWriter::close();
exit(1);
break;
}
if (isset($logMessage) || isset($errorMessage)) {
$xmlBuffer .= AJXP_XMLWriter::sendMessage(isset($logMessage) ? $logMessage : null, isset($errorMessage) ? $errorMessage : null, false);
}
if (isset($requireAuth)) {
$xmlBuffer .= AJXP_XMLWriter::requireAuth(false);
}
if (isset($reload_current_node) && $reload_current_node == "true") {
$xmlBuffer .= AJXP_XMLWriter::reloadCurrentNode(false);
}
if (isset($reload_dest_node) && $reload_dest_node != "") {
$xmlBuffer .= AJXP_XMLWriter::reloadNode($reload_dest_node, false);
}
if (isset($reload_file_list)) {
$xmlBuffer .= AJXP_XMLWriter::reloadFileList($reload_file_list, false);
}
return $xmlBuffer;
}
AJXP_XMLWriter::requireAuth();
AJXP_XMLWriter::close();
exit(1);
}
}
$xmlResult = $Driver->applyAction($action, array_merge($_GET, $_POST), $_FILES);
if ($xmlResult != "") {
AJXP_XMLWriter::header();
print $xmlResult;
AJXP_XMLWriter::close();
exit(1);
}
}
AJXP_XMLWriter::header();
if (isset($logMessage) || isset($errorMessage)) {
AJXP_XMLWriter::sendMessage(isset($logMessage) ? $logMessage : null, isset($errorMessage) ? $errorMessage : null);
}
if (isset($requireAuth)) {
AJXP_XMLWriter::requireAuth();
}
if (isset($reload_current_node) && $reload_current_node == "true") {
AJXP_XMLWriter::reloadCurrentNode();
}
if (isset($reload_dest_node) && $reload_dest_node != "") {
AJXP_XMLWriter::reloadNode($reload_dest_node);
}
if (isset($reload_file_list)) {
AJXP_XMLWriter::reloadFileList($reload_file_list);
}
AJXP_XMLWriter::close();
session_write_close();
/**
* Main method for querying the XML registry, find an action and all its associated processors,
* and apply all the callbacks.
* @static
* @param String $actionName
* @param array $httpVars
* @param array $fileVars
* @param DOMNode $action
* @return mixed
*/
public static function findActionAndApply($actionName, $httpVars, $fileVars, &$action = null)
{
$actionName = AJXP_Utils::sanitize($actionName, AJXP_SANITIZE_EMAILCHARS);
if ($actionName == "cross_copy") {
$pService = AJXP_PluginsService::getInstance();
$actives = $pService->getActivePlugins();
$accessPlug = $pService->getPluginsByType("access");
if (count($accessPlug)) {
foreach ($accessPlug as $key => $objbect) {
if ($actives[$objbect->getId()] === true) {
call_user_func(array($pService->getPluginById($objbect->getId()), "crossRepositoryCopy"), $httpVars);
break;
}
}
}
self::$lastActionNeedsAuth = true;
return null;
}
$xPath = self::initXPath();
if ($action == null) {
$actions = $xPath->query("actions/action[@name='{$actionName}']");
if (!$actions->length) {
self::$lastActionNeedsAuth = true;
return false;
}
$action = $actions->item(0);
}
//Check Rights
if (AuthService::usersEnabled()) {
$loggedUser = AuthService::getLoggedUser();
if (AJXP_Controller::actionNeedsRight($action, $xPath, "adminOnly") && ($loggedUser == null || !$loggedUser->isAdmin())) {
$mess = ConfService::getMessages();
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess[207]);
AJXP_XMLWriter::requireAuth();
AJXP_XMLWriter::close();
exit(1);
}
if (AJXP_Controller::actionNeedsRight($action, $xPath, "read") && ($loggedUser == null || !$loggedUser->canRead(ConfService::getCurrentRepositoryId() . ""))) {
AJXP_XMLWriter::header();
if ($actionName == "ls" & $loggedUser != null && $loggedUser->canWrite(ConfService::getCurrentRepositoryId() . "")) {
// Special case of "write only" right : return empty listing, no auth error.
AJXP_XMLWriter::close();
exit(1);
}
$mess = ConfService::getMessages();
AJXP_XMLWriter::sendMessage(null, $mess[208]);
AJXP_XMLWriter::requireAuth();
AJXP_XMLWriter::close();
exit(1);
}
if (AJXP_Controller::actionNeedsRight($action, $xPath, "write") && ($loggedUser == null || !$loggedUser->canWrite(ConfService::getCurrentRepositoryId() . ""))) {
$mess = ConfService::getMessages();
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess[207]);
AJXP_XMLWriter::requireAuth();
AJXP_XMLWriter::close();
exit(1);
}
}
$preCalls = self::getCallbackNode($xPath, $action, 'pre_processing/serverCallback', $actionName, $httpVars, $fileVars, true);
$postCalls = self::getCallbackNode($xPath, $action, 'post_processing/serverCallback[not(@capture="true")]', $actionName, $httpVars, $fileVars, true);
$captureCalls = self::getCallbackNode($xPath, $action, 'post_processing/serverCallback[@capture="true"]', $actionName, $httpVars, $fileVars, true);
$mainCall = self::getCallbackNode($xPath, $action, "processing/serverCallback", $actionName, $httpVars, $fileVars, false);
if ($mainCall != null) {
self::checkParams($httpVars, $mainCall, $xPath);
}
if ($captureCalls !== false) {
// Make sure the ShutdownScheduler has its own OB started BEFORE, as it will presumabily be
// executed AFTER the end of this one.
AJXP_ShutdownScheduler::getInstance();
ob_start();
$params = array("pre_processor_results" => array(), "post_processor_results" => array());
}
if ($preCalls !== false) {
foreach ($preCalls as $preCall) {
// A Preprocessing callback can modify its input arguments (passed by ref)
$preResult = self::applyCallback($preCall, $actionName, $httpVars, $fileVars);
if (isset($params)) {
$params["pre_processor_results"][$preCall->getAttribute("pluginId")] = $preResult;
}
}
}
if ($mainCall) {
$result = self::applyCallback($mainCall, $actionName, $httpVars, $fileVars);
if (isset($params)) {
$params["processor_result"] = $result;
}
}
if ($postCalls !== false) {
foreach ($postCalls as $postCall) {
// A Preprocessing callback can modify its input arguments (passed by ref)
$postResult = self::applyCallback($postCall, $actionName, $httpVars, $fileVars);
if (isset($params)) {
$params["post_processor_results"][$postCall->getAttribute("pluginId")] = $postResult;
}
}
}
if ($captureCalls !== false) {
$params["ob_output"] = ob_get_contents();
ob_end_clean();
foreach ($captureCalls as $captureCall) {
self::applyCallback($captureCall, $actionName, $httpVars, $params);
}
} else {
if (isset($result)) {
return $result;
}
}
return null;
}
function crossRepositoryCopy($httpVars)
{
ConfService::detectRepositoryStreams(true);
$mess = ConfService::getMessages();
$selection = new UserSelection();
$selection->initFromHttpVars($httpVars);
$files = $selection->getFiles();
$accessType = $this->repository->getAccessType();
$repositoryId = $this->repository->getId();
$origStreamURL = "ajxp.{$accessType}://{$repositoryId}";
$destRepoId = $httpVars["dest_repository_id"];
$destRepoObject = ConfService::getRepositoryById($destRepoId);
$destRepoAccess = $destRepoObject->getAccessType();
$destStreamURL = "ajxp.{$destRepoAccess}://{$destRepoId}";
// Check rights
if (AuthService::usersEnabled()) {
$loggedUser = AuthService::getLoggedUser();
if (!$loggedUser->canRead($repositoryId) || !$loggedUser->canWrite($destRepoId)) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, "You do not have the right to access one of the repositories!");
AJXP_XMLWriter::close();
exit(1);
}
}
$messages = array();
foreach ($files as $file) {
$origFile = $origStreamURL . $file;
$destFile = $destStreamURL . $httpVars["dest"] . "/" . basename($file);
$origHandler = fopen($origFile, "r");
$destHandler = fopen($destFile, "w");
if ($origHandler === false || $destHandler === false) {
$errorMessages[] = AJXP_XMLWriter::sendMessage(null, $mess[114] . " ({$origFile} to {$destFile})", false);
continue;
}
while (!feof($origHandler)) {
fwrite($destHandler, fread($origHandler, 4096));
}
fflush($destHandler);
fclose($origHandler);
fclose($destHandler);
$messages[] = $mess[34] . " " . SystemTextEncoding::toUTF8(basename($origFile)) . " " . $mess[73] . " " . SystemTextEncoding::toUTF8($destFile);
}
AJXP_XMLWriter::header();
if (count($errorMessages)) {
AJXP_XMLWriter::sendMessage(null, join("\n", $errorMessages), true);
}
AJXP_XMLWriter::sendMessage(join("\n", $messages), null, true);
AJXP_XMLWriter::close();
exit(0);
}
public static function findActionAndApply($actionName, $httpVars, $fileVars)
{
if ($actionName == "cross_copy") {
$pService = AJXP_PluginsService::getInstance();
$actives = $pService->getActivePlugins();
$accessPlug = $pService->getPluginsByType("access");
if (count($accessPlug)) {
foreach ($accessPlug as $key => $objbect) {
if ($actives[$objbect->getId()] === true) {
call_user_func(array($pService->getPluginById($objbect->getId()), "crossRepositoryCopy"), $httpVars);
break;
}
}
}
return;
}
$xPath = self::initXPath();
$actions = $xPath->query("actions/action[@name='{$actionName}']");
if (!$actions->length) {
return false;
}
$action = $actions->item(0);
//Check Rights
$mess = ConfService::getMessages();
if (AuthService::usersEnabled()) {
$loggedUser = AuthService::getLoggedUser();
if (AJXP_Controller::actionNeedsRight($action, $xPath, "adminOnly") && ($loggedUser == null || !$loggedUser->isAdmin())) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess[207]);
AJXP_XMLWriter::requireAuth();
AJXP_XMLWriter::close();
exit(1);
}
if (AJXP_Controller::actionNeedsRight($action, $xPath, "read") && ($loggedUser == null || !$loggedUser->canRead(ConfService::getCurrentRootDirIndex() . ""))) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess[208]);
AJXP_XMLWriter::requireAuth();
AJXP_XMLWriter::close();
exit(1);
}
if (AJXP_Controller::actionNeedsRight($action, $xPath, "write") && ($loggedUser == null || !$loggedUser->canWrite(ConfService::getCurrentRootDirIndex() . ""))) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess[207]);
AJXP_XMLWriter::requireAuth();
AJXP_XMLWriter::close();
exit(1);
}
}
$preCalls = self::getCallbackNode($xPath, $action, 'pre_processing/serverCallback', $actionName, $httpVars, $fileVars, true);
$postCalls = self::getCallbackNode($xPath, $action, 'post_processing/serverCallback[not(@capture="true")]', $actionName, $httpVars, $fileVars, true);
$captureCalls = self::getCallbackNode($xPath, $action, 'post_processing/serverCallback[@capture="true"]', $actionName, $httpVars, $fileVars, true);
$mainCall = self::getCallbackNode($xPath, $action, "processing/serverCallback", $actionName, $httpVars, $fileVars, false);
if ($captureCalls !== false) {
ob_start();
$params = array("pre_processor_results" => array(), "post_processor_results" => array());
}
if ($preCalls !== false) {
foreach ($preCalls as $preCall) {
// A Preprocessing callback can modify its input arguments (passed by ref)
$preResult = self::applyCallback($xPath, $preCall, $actionName, $httpVars, $fileVars);
if (isset($params)) {
$params["pre_processor_results"][$preCall->getAttribute("pluginId")] = $preResult;
}
}
}
if ($mainCall) {
$result = self::applyCallback($xPath, $mainCall, $actionName, $httpVars, $fileVars);
if (isset($params)) {
$params["processor_result"] = $result;
}
}
if ($postCalls !== false) {
foreach ($postCalls as $postCall) {
// A Preprocessing callback can modify its input arguments (passed by ref)
$postResult = self::applyCallback($xPath, $postCall, $actionName, $httpVars, $fileVars);
if (isset($params)) {
$params["post_processor_results"][$postCall->getAttribute("pluginId")] = $postResult;
}
}
}
if ($captureCalls !== false) {
$params["ob_output"] = ob_get_contents();
ob_end_clean();
foreach ($captureCalls as $captureCall) {
self::applyCallback($xPath, $captureCall, $actionName, $httpVars, $params);
}
} else {
if (isset($result)) {
return $result;
}
}
}
function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->actions[$action])) {
return;
}
parent::accessPreprocess($action, $httpVars, $fileVars);
$loggedUser = AuthService::getLoggedUser();
if (!ENABLE_USERS) {
return;
}
if ($action == "edit") {
if (isset($httpVars["sub_action"])) {
$action = $httpVars["sub_action"];
}
}
$mess = ConfService::getMessages();
switch ($action) {
//------------------------------------
// BASIC LISTING
//------------------------------------
case "ls":
$rootNodes = array("files" => array("LABEL" => $mess["ajxp_shared.3"], "ICON" => "html.png", "DESCRIPTION" => $mess["ajxp_shared.28"]), "repositories" => array("LABEL" => $mess["ajxp_shared.2"], "ICON" => "document_open_remote.png", "DESCRIPTION" => $mess["ajxp_shared.29"]), "users" => array("LABEL" => $mess["ajxp_shared.1"], "ICON" => "user_shared.png", "DESCRIPTION" => $mess["ajxp_shared.30"]));
$dir = isset($httpVars["dir"]) ? $httpVars["dir"] : "";
$splits = explode("/", $dir);
if (count($splits)) {
if ($splits[0] == "") {
array_shift($splits);
}
if (count($splits)) {
$strippedDir = strtolower(urldecode($splits[0]));
} else {
$strippedDir = "";
}
}
if (array_key_exists($strippedDir, $rootNodes)) {
AJXP_XMLWriter::header();
if ($strippedDir == "users") {
$this->listUsers();
} else {
if ($strippedDir == "repositories") {
$this->listRepositories();
} else {
if ($strippedDir == "files") {
$this->listSharedFiles();
}
}
}
AJXP_XMLWriter::close();
exit(1);
} else {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendFilesListComponentConfig('<columns switchGridMode="filelist"><column messageId="ajxp_shared.8" attributeName="ajxp_label" sortType="String"/><column messageId="ajxp_shared.31" attributeName="description" sortType="String"/></columns>');
foreach ($rootNodes as $key => $data) {
print '<tree text="' . $data["LABEL"] . '" icon="' . $data["ICON"] . '" filename="/' . $key . '" parentname="/" description="' . $data["DESCRIPTION"] . '" />';
}
AJXP_XMLWriter::close();
}
break;
case "stat":
header("Content-type:application/json");
print '{"mode":true}';
break;
case "delete":
$mime = $httpVars["ajxp_mime"];
$selection = new UserSelection();
$selection->initFromHttpVars();
$files = $selection->getFiles();
AJXP_XMLWriter::header();
foreach ($files as $index => $element) {
$element = basename($element);
if ($mime == "shared_repository") {
$repo = ConfService::getRepositoryById($element);
if (!$repo->hasOwner() || $repo->getOwner() != $loggedUser->getId()) {
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_shared.12"]);
break;
} else {
$res = ConfService::deleteRepository($element);
if ($res == -1) {
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.51"]);
break;
} else {
if ($index == count($files) - 1) {
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.59"], null);
AJXP_XMLWriter::reloadDataNode();
}
}
}
} else {
if ($mime == "shared_user") {
$confDriver = ConfService::getConfStorageImpl();
$object = $confDriver->createUserObject($element);
if (!$object->hasParent() || $object->getParent() != $loggedUser->getId()) {
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_shared.12"]);
break;
} else {
$res = AuthService::deleteUser($element);
if ($index == count($files) - 1) {
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.60"], null);
AJXP_XMLWriter::reloadDataNode();
}
}
} else {
if ($mime == "shared_file") {
$publicletData = $this->loadPublicletData(PUBLIC_DOWNLOAD_FOLDER . "/" . $element . ".php");
if (isset($publicletData["OWNER_ID"]) && $publicletData["OWNER_ID"] == $loggedUser->getId()) {
require_once INSTALL_PATH . "/server/classes/class.PublicletCounter.php";
PublicletCounter::delete($element);
unlink(PUBLIC_DOWNLOAD_FOLDER . "/" . $element . ".php");
if ($index == count($files) - 1) {
AJXP_XMLWriter::sendMessage($mess["ajxp_shared.13"], null);
AJXP_XMLWriter::reloadDataNode();
}
} else {
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_shared.12"]);
break;
}
}
}
}
}
AJXP_XMLWriter::close();
break;
case "clear_expired":
$deleted = $this->clearExpiredFiles();
AJXP_XMLWriter::header();
if (count($deleted)) {
AJXP_XMLWriter::sendMessage(sprintf($mess["ajxp_shared.23"], count($deleted) . ""), null);
AJXP_XMLWriter::reloadDataNode();
} else {
AJXP_XMLWriter::sendMessage($mess["ajxp_shared.24"], null);
}
AJXP_XMLWriter::close();
break;
case "reset_download_counter":
$selection = new UserSelection();
$selection->initFromHttpVars();
$elements = $selection->getFiles();
require_once INSTALL_PATH . "/server/classes/class.PublicletCounter.php";
foreach ($elements as $element) {
PublicletCounter::reset(str_replace(".php", "", basename($element)));
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
break;
default:
break;
}
return;
}
public function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->actions[$action])) {
return;
}
parent::accessPreprocess($action, $httpVars, $fileVars);
$loggedUser = AuthService::getLoggedUser();
if (!AuthService::usersEnabled()) {
return;
}
if ($action == "edit") {
if (isset($httpVars["sub_action"])) {
$action = $httpVars["sub_action"];
}
}
$mess = ConfService::getMessages();
switch ($action) {
//------------------------------------
// BASIC LISTING
//------------------------------------
case "ls":
$rootNodes = array("files" => array("LABEL" => $mess["ajxp_shared.3"], "ICON" => "html.png", "DESCRIPTION" => $mess["ajxp_shared.28"]), "repositories" => array("LABEL" => $mess["ajxp_shared.2"], "ICON" => "document_open_remote.png", "DESCRIPTION" => $mess["ajxp_shared.29"]), "users" => array("LABEL" => $mess["ajxp_shared.1"], "ICON" => "user_shared.png", "DESCRIPTION" => $mess["ajxp_shared.30"]));
$dir = isset($httpVars["dir"]) ? $httpVars["dir"] : "";
$splits = explode("/", $dir);
if (count($splits)) {
if ($splits[0] == "") {
array_shift($splits);
}
if (count($splits)) {
$strippedDir = strtolower(urldecode($splits[0]));
} else {
$strippedDir = "";
}
}
if (array_key_exists($strippedDir, $rootNodes)) {
AJXP_XMLWriter::header();
if ($strippedDir == "users") {
$this->listUsers();
} else {
if ($strippedDir == "repositories") {
$this->listRepositories();
} else {
if ($strippedDir == "files") {
$this->listSharedFiles();
}
}
}
AJXP_XMLWriter::close();
} else {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendFilesListComponentConfig('<columns switchGridMode="filelist"><column messageId="ajxp_shared.8" attributeName="ajxp_label" sortType="String"/><column messageId="ajxp_shared.31" attributeName="description" sortType="String"/></columns>');
foreach ($rootNodes as $key => $data) {
print '<tree text="' . $data["LABEL"] . '" icon="' . $data["ICON"] . '" filename="/' . $key . '" parentname="/" description="' . $data["DESCRIPTION"] . '" />';
}
AJXP_XMLWriter::close();
}
break;
case "stat":
header("Content-type:application/json");
print '{"mode":true}';
break;
case "delete":
$mime = $httpVars["ajxp_mime"];
$selection = new UserSelection();
$selection->initFromHttpVars($httpVars);
$files = $selection->getFiles();
AJXP_XMLWriter::header();
foreach ($files as $index => $element) {
$element = basename($element);
$ar = explode("shared_", $mime);
$mime = array_pop($ar);
ShareCenter::deleteSharedElement($mime, $element, $loggedUser);
if ($mime == "repository") {
$out = $mess["ajxp_conf.59"];
} else {
if ($mime == "user") {
$out = $mess["ajxp_conf.60"];
} else {
if ($mime == "file") {
$out = $mess["ajxp_shared.13"];
}
}
}
}
AJXP_XMLWriter::sendMessage($out, null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
break;
case "clear_expired":
$deleted = $this->clearExpiredFiles();
AJXP_XMLWriter::header();
if (count($deleted)) {
AJXP_XMLWriter::sendMessage(sprintf($mess["ajxp_shared.23"], count($deleted) . ""), null);
AJXP_XMLWriter::reloadDataNode();
} else {
AJXP_XMLWriter::sendMessage($mess["ajxp_shared.24"], null);
}
AJXP_XMLWriter::close();
break;
case "reset_download_counter":
$selection = new UserSelection();
$selection->initFromHttpVars($httpVars);
$elements = $selection->getFiles();
foreach ($elements as $element) {
PublicletCounter::reset(str_replace(".php", "", basename($element)));
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
break;
default:
break;
}
return;
}
public function uploadActions($action, $httpVars, $filesVars)
{
switch ($action) {
case "trigger_remote_copy":
if (!$this->hasFilesToCopy()) {
break;
}
$toCopy = $this->getFileNameToCopy();
$this->logDebug("trigger_remote", $toCopy);
AJXP_XMLWriter::header();
AJXP_XMLWriter::triggerBgAction("next_to_remote", array(), "Copying file " . $toCopy . " to remote server");
AJXP_XMLWriter::close();
exit(1);
break;
case "next_to_remote":
if (!$this->hasFilesToCopy()) {
break;
}
$fData = $this->getNextFileToCopy();
$nextFile = '';
if ($this->hasFilesToCopy()) {
$nextFile = $this->getFileNameToCopy();
}
$crtRep = ConfService::getRepository();
session_write_close();
$secureToken = "";
$httpClient = $this->getRemoteConnexion($secureToken);
//$httpClient->setDebug(true);
$postData = array("get_action" => "upload", "dir" => base64_encode($fData["destination"]), "secure_token" => $secureToken);
$httpClient->postFile($crtRep->getOption("URI") . "?", $postData, "Filedata", $fData);
if (strpos($httpClient->getHeader("content-type"), "text/xml") !== false && strpos($httpClient->getContent(), "require_auth") != false) {
$httpClient = $this->getRemoteConnexion($secureToken, true);
$postData["secure_token"] = $secureToken;
$httpClient->postFile($crtRep->getOption("URI"), $postData, "Filedata", $fData);
}
unlink($fData["tmp_name"]);
$response = $httpClient->getContent();
AJXP_XMLWriter::header();
$this->logDebug("next_to_remote", $nextFile);
if (intval($response) >= 400) {
AJXP_XMLWriter::sendMessage(null, "Error : " . intval($response));
} else {
if ($nextFile != '') {
AJXP_XMLWriter::triggerBgAction("next_to_remote", array(), "Copying file " . SystemTextEncoding::toUTF8($nextFile) . " to remote server");
} else {
AJXP_XMLWriter::triggerBgAction("reload_node", array(), "Upload done, reloading client.");
}
}
AJXP_XMLWriter::close();
exit(1);
break;
case "upload":
$rep_source = AJXP_Utils::securePath("/" . $httpVars['dir']);
$this->logDebug("Upload : rep_source ", array($rep_source));
$logMessage = "";
foreach ($filesVars as $boxName => $boxData) {
if (substr($boxName, 0, 9) != "userfile_") {
continue;
}
$this->logDebug("Upload : rep_source ", array($rep_source));
$err = AJXP_Utils::parseFileDataErrors($boxData);
if ($err != null) {
$errorCode = $err[0];
$errorMessage = $err[1];
break;
}
$boxData["destination"] = $rep_source;
$destCopy = AJXP_XMLWriter::replaceAjxpXmlKeywords($this->repository->getOption("TMP_UPLOAD"));
$this->logDebug("Upload : tmp upload folder", array($destCopy));
if (!is_dir($destCopy)) {
if (!@mkdir($destCopy)) {
$this->logDebug("Upload error : cannot create temporary folder", array($destCopy));
$errorCode = 413;
$errorMessage = "Warning, cannot create folder for temporary copy.";
break;
}
}
if (!is_writeable($destCopy)) {
$this->logDebug("Upload error: cannot write into temporary folder");
$errorCode = 414;
$errorMessage = "Warning, cannot write into temporary folder.";
break;
}
$this->logDebug("Upload : tmp upload folder", array($destCopy));
if (isset($boxData["input_upload"])) {
try {
$destName = tempnam($destCopy, "");
$this->logDebug("Begining reading INPUT stream");
$input = fopen("php://input", "r");
$output = fopen($destName, "w");
$sizeRead = 0;
while ($sizeRead < intval($boxData["size"])) {
$chunk = fread($input, 4096);
$sizeRead += strlen($chunk);
fwrite($output, $chunk, strlen($chunk));
}
fclose($input);
fclose($output);
$boxData["tmp_name"] = $destName;
$this->storeFileToCopy($boxData);
$this->logDebug("End reading INPUT stream");
} catch (Exception $e) {
$errorCode = 411;
$errorMessage = $e->getMessage();
break;
}
} else {
$destName = $destCopy . "/" . basename($boxData["tmp_name"]);
if ($destName == $boxData["tmp_name"]) {
$destName .= "1";
}
if (move_uploaded_file($boxData["tmp_name"], $destName)) {
$boxData["tmp_name"] = $destName;
$this->storeFileToCopy($boxData);
} else {
$mess = ConfService::getMessages();
$errorCode = 411;
$errorMessage = "{$mess['33']} " . $boxData["name"];
break;
}
}
}
if (isset($errorMessage)) {
$this->logDebug("Return error {$errorCode} {$errorMessage}");
return array("ERROR" => array("CODE" => $errorCode, "MESSAGE" => $errorMessage));
} else {
$this->logDebug("Return success");
return array("SUCCESS" => true);
}
session_write_close();
break;
default:
break;
}
}
/**
* Main callback for all share- actions.
* @param string $action
* @param array $httpVars
* @param array $fileVars
* @return null
* @throws Exception
*/
public function switchAction($action, $httpVars, $fileVars)
{
if (strpos($action, "sharelist") === false && !isset($this->accessDriver)) {
throw new Exception("Cannot find access driver!");
}
if (strpos($action, "sharelist") === false && $this->accessDriver->getId() == "access.demo") {
$errorMessage = "This is a demo, all 'write' actions are disabled!";
if ($httpVars["sub_action"] == "delegate_repo") {
return AJXP_XMLWriter::sendMessage(null, $errorMessage, false);
} else {
print $errorMessage;
}
return null;
}
switch ($action) {
//------------------------------------
// SHARING FILE OR FOLDER
//------------------------------------
case "share":
$subAction = isset($httpVars["sub_action"]) ? $httpVars["sub_action"] : "";
// REST API COMPATIBILITY
if (empty($subAction) && isset($httpVars["simple_share_type"])) {
$subAction = "create_minisite";
if (!isset($httpVars["simple_right_read"]) && !isset($httpVars["simple_right_download"])) {
$httpVars["simple_right_read"] = $httpVars["simple_right_download"] = "true";
}
$httpVars["create_guest_user"] = "******";
if ($httpVars["simple_share_type"] == "private" && !isset($httpVars["guest_user_pass"])) {
throw new Exception("Please provide a guest_user_pass for private link");
}
}
$userSelection = new UserSelection(ConfService::getRepository(), $httpVars);
$ajxpNode = $userSelection->getUniqueNode();
if (!file_exists($ajxpNode->getUrl())) {
throw new Exception("Cannot share a non-existing file: " . $ajxpNode->getUrl());
}
$this->updateToMaxAllowedValue($httpVars, "downloadlimit", "FILE_MAX_DOWNLOAD");
$this->updateToMaxAllowedValue($httpVars, "expiration", "FILE_MAX_EXPIRATION");
$httpHash = null;
$originalHash = null;
if (!isset($httpVars["share_scope"]) || !in_array($httpVars["share_scope"], array("public", "private"))) {
$httpVars["share_scope"] = "private";
}
$shareScope = $httpVars["share_scope"];
$plainResult = 'unknown sub_action';
if ($subAction == "delegate_repo") {
$auth = $this->getAuthorization("folder", "workspace");
if (!$auth) {
$mess = ConfService::getMessages();
throw new Exception($mess["351"]);
}
$users = array();
$groups = array();
$this->getRightsManager()->createUsersFromParameters($httpVars, $users, $groups);
$result = $this->createSharedRepository($httpVars, $isUpdate, $users, $groups);
if (is_a($result, "Repository")) {
if (!$isUpdate) {
$this->getShareStore()->storeShare($this->repository->getId(), array("REPOSITORY" => $result->getUniqueId(), "OWNER_ID" => AuthService::getLoggedUser()->getId()), "repository");
}
AJXP_Controller::applyHook($isUpdate ? "node.share.update" : "node.share.create", array('type' => 'repository', 'repository' => &$this->repository, 'accessDriver' => &$this->accessDriver, 'new_repository' => &$result));
if ($ajxpNode->hasMetaStore() && !$ajxpNode->isRoot()) {
$this->getShareStore()->getMetaManager()->addShareInMeta($ajxpNode, "repository", $result->getUniqueId(), $shareScope == "public", $originalHash);
}
$plainResult = 200;
} else {
$plainResult = $result;
}
} else {
if ($subAction == "create_minisite") {
if (isset($httpVars["hash"]) && !empty($httpVars["hash"])) {
$httpHash = $httpVars["hash"];
}
$result = $this->createSharedMinisite($httpVars, $isUpdate);
if (!is_array($result)) {
$url = $result;
} else {
list($hash, $url) = $result;
if ($ajxpNode->hasMetaStore() && !$ajxpNode->isRoot()) {
$this->getShareStore()->getMetaManager()->addShareInMeta($ajxpNode, "minisite", $hash, $shareScope == "public", $httpHash != null && $hash != $httpHash ? $httpHash : null);
}
}
$plainResult = $url;
} else {
if ($subAction == "share_node") {
$httpVars["return_json"] = true;
if (isset($httpVars["hash"]) && !empty($httpVars["hash"])) {
$httpHash = $httpVars["hash"];
}
$ajxpNode->loadNodeInfo();
$results = $this->shareNode($ajxpNode, $httpVars, $isUpdate);
if (is_array($results) && $ajxpNode->hasMetaStore() && !$ajxpNode->isRoot()) {
foreach ($results as $shareObject) {
if ($shareObject instanceof \Pydio\OCS\Model\TargettedLink) {
$hash = $shareObject->getHash();
$this->getShareStore()->getMetaManager()->addShareInMeta($ajxpNode, "ocs_remote", $hash, $shareScope == "public", $hash);
} else {
if (is_a($shareObject, "ShareLink")) {
$hash = $shareObject->getHash();
$this->getShareStore()->getMetaManager()->addShareInMeta($ajxpNode, "minisite", $hash, $shareScope == "public", $httpHash != null && $hash != $httpHash ? $httpHash : null);
} else {
if (is_a($shareObject, "Repository")) {
$this->getShareStore()->getMetaManager()->addShareInMeta($ajxpNode, "repository", $shareObject->getUniqueId(), $shareScope == "public", null);
}
}
}
}
}
}
}
}
AJXP_Controller::applyHook("msg.instant", array("<reload_shared_elements/>", ConfService::getRepository()->getId()));
/*
* Send IM to inform that node has been shared or unshared.
* Should be done only if share scope is public.
*/
if ($shareScope == "public") {
$ajxpNode->loadNodeInfo();
$content = AJXP_XMLWriter::writeNodesDiff(["UPDATE" => array($ajxpNode->getPath() => $ajxpNode)]);
AJXP_Controller::applyHook("msg.instant", array($content, $ajxpNode->getRepositoryId(), null, null, [$ajxpNode->getPath()]));
}
if (!isset($httpVars["return_json"])) {
header("Content-Type: text/plain");
print $plainResult;
} else {
$compositeShare = $this->getShareStore()->getMetaManager()->getCompositeShareForNode($ajxpNode);
header("Content-type:application/json");
if (!empty($compositeShare)) {
echo json_encode($this->compositeShareToJson($compositeShare));
} else {
echo json_encode(array());
}
}
// as the result can be quite small (e.g error code), make sure it's output in case of OB active.
flush();
break;
case "toggle_link_watch":
$userSelection = new UserSelection($this->repository, $httpVars);
$shareNode = $selectedNode = $userSelection->getUniqueNode();
$watchValue = $httpVars["set_watch"] == "true" ? true : false;
$folder = false;
if (isset($httpVars["element_type"]) && $httpVars["element_type"] == "folder") {
$folder = true;
$selectedNode = new AJXP_Node("pydio://" . AJXP_Utils::sanitize($httpVars["repository_id"], AJXP_SANITIZE_ALPHANUM) . "/");
}
$shares = array();
$this->getShareStore()->getMetaManager()->getSharesFromMeta($shareNode, $shares, false);
if (!count($shares)) {
break;
}
if (isset($httpVars["element_id"]) && isset($shares[$httpVars["element_id"]])) {
$elementId = $httpVars["element_id"];
} else {
$sKeys = array_keys($shares);
$elementId = $sKeys[0];
}
if ($this->watcher !== false) {
if (!$folder) {
if ($watchValue) {
$this->watcher->setWatchOnFolder($selectedNode, AuthService::getLoggedUser()->getId(), MetaWatchRegister::$META_WATCH_USERS_READ, array($elementId));
} else {
$this->watcher->removeWatchFromFolder($selectedNode, AuthService::getLoggedUser()->getId(), true, $elementId);
}
} else {
if ($watchValue) {
$this->watcher->setWatchOnFolder($selectedNode, AuthService::getLoggedUser()->getId(), MetaWatchRegister::$META_WATCH_BOTH);
} else {
$this->watcher->removeWatchFromFolder($selectedNode, AuthService::getLoggedUser()->getId());
}
}
}
$mess = ConfService::getMessages();
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["share_center.47"], null);
AJXP_XMLWriter::close();
break;
case "load_shared_element_data":
$node = null;
if (isset($httpVars["hash"]) && $httpVars["element_type"] == "file") {
// LEGACY LINKS
$parsedMeta = array($httpVars["hash"] => array("type" => "file"));
$jsonData = array();
foreach ($parsedMeta as $shareId => $shareMeta) {
$jsonData[] = $this->shareToJson($shareId, $shareMeta, $node);
}
header("Content-type:application/json");
echo json_encode($jsonData);
} else {
$file = AJXP_Utils::decodeSecureMagic($httpVars["file"]);
$node = new AJXP_Node($this->urlBase . $file);
$loggedUser = AuthService::getLoggedUser();
if (isset($httpVars["owner"]) && $loggedUser->isAdmin() && $loggedUser->getGroupPath() == "/" && $loggedUser->getId() != AJXP_Utils::sanitize($httpVars["owner"], AJXP_SANITIZE_EMAILCHARS)) {
// Impersonate the current user
$node->setUser(AJXP_Utils::sanitize($httpVars["owner"], AJXP_SANITIZE_EMAILCHARS));
}
if (!file_exists($node->getUrl())) {
$mess = ConfService::getMessages();
throw new Exception(str_replace('%s', "Cannot find file " . $file, $mess["share_center.219"]));
}
if (isset($httpVars["tmp_repository_id"]) && AuthService::getLoggedUser()->isAdmin()) {
$compositeShare = $this->getShareStore()->getMetaManager()->getCompositeShareForNode($node, true);
} else {
$compositeShare = $this->getShareStore()->getMetaManager()->getCompositeShareForNode($node);
}
if (empty($compositeShare)) {
$mess = ConfService::getMessages();
throw new Exception(str_replace('%s', "Cannot find share for node " . $file, $mess["share_center.219"]));
}
header("Content-type:application/json");
$json = $this->compositeShareToJson($compositeShare);
echo json_encode($json);
}
break;
case "unshare":
$mess = ConfService::getMessages();
$userSelection = new UserSelection($this->repository, $httpVars);
if (isset($httpVars["hash"])) {
$sanitizedHash = AJXP_Utils::sanitize($httpVars["hash"], AJXP_SANITIZE_ALPHANUM);
$ajxpNode = $userSelection->isEmpty() ? null : $userSelection->getUniqueNode();
$result = $this->getShareStore()->deleteShare($httpVars["element_type"], $sanitizedHash, false, false, $ajxpNode);
if ($result !== false) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["share_center.216"], null);
AJXP_XMLWriter::close();
}
} else {
$userSelection = new UserSelection($this->repository, $httpVars);
$ajxpNode = $userSelection->getUniqueNode();
$shares = array();
$this->getShareStore()->getMetaManager()->getSharesFromMeta($ajxpNode, $shares, false);
if (isset($httpVars["element_id"]) && isset($shares[$httpVars["element_id"]])) {
$elementId = $httpVars["element_id"];
if (isset($shares[$elementId])) {
$shares = array($elementId => $shares[$elementId]);
}
}
if (count($shares)) {
$res = true;
foreach ($shares as $shareId => $share) {
$t = isset($share["type"]) ? $share["type"] : "file";
try {
$result = $this->getShareStore()->deleteShare($t, $shareId, false, true);
} catch (Exception $e) {
if ($e->getMessage() == "repo-not-found") {
$result = true;
} else {
throw $e;
}
}
$this->getShareStore()->getMetaManager()->removeShareFromMeta($ajxpNode, $shareId);
$res = $result && $res;
}
if ($res !== false) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["share_center.216"], null);
AJXP_XMLWriter::close();
AJXP_Controller::applyHook("msg.instant", array("<reload_shared_elements/>", ConfService::getRepository()->getId()));
if (isset($httpVars["share_scope"]) && $httpVars["share_scope"] == "public") {
$ajxpNode->loadNodeInfo();
$content = AJXP_XMLWriter::writeNodesDiff(["UPDATE" => [$ajxpNode->getPath() => $ajxpNode]]);
AJXP_Controller::applyHook("msg.instant", array($content, $ajxpNode->getRepositoryId(), null, null, [$ajxpNode->getPath()]));
}
}
}
}
break;
case "reset_counter":
if (isset($httpVars["hash"])) {
$userId = AuthService::getLoggedUser()->getId();
if (isset($httpVars["owner_id"]) && $httpVars["owner_id"] != $userId) {
if (!AuthService::getLoggedUser()->isAdmin()) {
throw new Exception("You are not allowed to access this resource");
}
$userId = $httpVars["owner_id"];
}
$this->getShareStore()->resetDownloadCounter($httpVars["hash"], $userId);
} else {
$userSelection = new UserSelection($this->repository, $httpVars);
$ajxpNode = $userSelection->getUniqueNode();
$metadata = $this->getShareStore()->getMetaManager()->getNodeMeta($ajxpNode);
if (!isset($metadata["shares"]) || !is_array($metadata["shares"])) {
return null;
}
if (isset($httpVars["element_id"]) && isset($metadata["shares"][$httpVars["element_id"]])) {
$this->getShareStore()->resetDownloadCounter($httpVars["element_id"], $httpVars["owner_id"]);
} else {
$keys = array_keys($metadata["shares"]);
foreach ($keys as $key) {
$this->getShareStore()->resetDownloadCounter($key, null);
}
}
}
break;
case "update_shared_element_data":
if (!in_array($httpVars["p_name"], array("counter", "tags"))) {
return null;
}
$hash = AJXP_Utils::decodeSecureMagic($httpVars["element_id"]);
$userSelection = new UserSelection($this->repository, $httpVars);
$ajxpNode = $userSelection->getUniqueNode();
if ($this->getShareStore()->shareIsLegacy($hash)) {
// Store in metadata
$metadata = $this->getShareStore()->getMetaManager()->getNodeMeta($ajxpNode);
if (isset($metadata["shares"][$httpVars["element_id"]])) {
if (!is_array($metadata["shares"][$httpVars["element_id"]])) {
$metadata["shares"][$httpVars["element_id"]] = array();
}
$metadata["shares"][$httpVars["element_id"]][$httpVars["p_name"]] = $httpVars["p_value"];
// Set Private=true by default.
$this->getShareStore()->getMetaManager()->setNodeMeta($ajxpNode, $metadata, true);
}
} else {
// TODO: testUserCanEditShare ?
$this->getShareStore()->updateShareProperty($hash, $httpVars["p_name"], $httpVars["p_value"]);
}
break;
case "sharelist-load":
$parentRepoId = isset($httpVars["parent_repository_id"]) ? $httpVars["parent_repository_id"] : "";
$userContext = $httpVars["user_context"];
$currentUser = true;
if ($userContext == "global" && AuthService::getLoggedUser()->isAdmin()) {
$currentUser = false;
} else {
if ($userContext == "user" && AuthService::getLoggedUser()->isAdmin() && !empty($httpVars["user_id"])) {
$currentUser = AJXP_Utils::sanitize($httpVars["user_id"], AJXP_SANITIZE_EMAILCHARS);
}
}
$nodes = $this->listSharesAsNodes("/data/repositories/{$parentRepoId}/shares", $currentUser, $parentRepoId);
AJXP_XMLWriter::header();
if ($userContext == "current") {
AJXP_XMLWriter::sendFilesListComponentConfig('<columns template_name="ajxp_user.shares">
<column messageId="ajxp_conf.8" attributeName="ajxp_label" sortType="String"/>
<column messageId="share_center.132" attributeName="shared_element_parent_repository_label" sortType="String"/>
<column messageId="3" attributeName="share_type_readable" sortType="String"/>
</columns>');
} else {
AJXP_XMLWriter::sendFilesListComponentConfig('<columns switchDisplayMode="list" switchGridMode="filelist" template_name="ajxp_conf.repositories">
<column messageId="ajxp_conf.8" attributeName="ajxp_label" sortType="String"/>
<column messageId="share_center.159" attributeName="owner" sortType="String"/>
<column messageId="3" attributeName="share_type_readable" sortType="String"/>
<column messageId="share_center.52" attributeName="share_data" sortType="String"/>
</columns>');
}
foreach ($nodes as $node) {
AJXP_XMLWriter::renderAjxpNode($node);
}
AJXP_XMLWriter::close();
break;
case "sharelist-clearExpired":
$accessType = ConfService::getRepository()->getAccessType();
$currentUser = $accessType != "ajxp_conf" && $accessType != "ajxp_admin";
$count = $this->getShareStore()->clearExpiredFiles($currentUser);
AJXP_XMLWriter::header();
if ($count) {
AJXP_XMLWriter::sendMessage("Removed " . count($count) . " expired links", null);
} else {
AJXP_XMLWriter::sendMessage("Nothing to do", null);
}
AJXP_XMLWriter::close();
break;
default:
break;
}
return null;
}
/**
* @param String $action
* @param Array $httpVars
* @param Array $fileVars
* @throws Exception
*/
public function receiveAction($action, $httpVars, $fileVars)
{
//VAR CREATION OUTSIDE OF ALL CONDITIONS, THEY ARE "MUST HAVE" VAR !!
$messages = ConfService::getMessages();
$repository = ConfService::getRepository();
$userSelection = new UserSelection($repository, $httpVars);
$nodes = $userSelection->buildNodes();
$currentDirPath = AJXP_Utils::safeDirname($userSelection->getUniqueNode()->getPath());
$currentDirPath = rtrim($currentDirPath, "/") . "/";
$currentDirUrl = $userSelection->currentBaseUrl() . $currentDirPath;
if (empty($httpVars["compression_id"])) {
$compressionId = sha1(rand());
$httpVars["compression_id"] = $compressionId;
} else {
$compressionId = $httpVars["compression_id"];
}
$progressCompressionFileName = $this->getPluginCacheDir(false, true) . DIRECTORY_SEPARATOR . "progressCompressionID-" . $compressionId . ".txt";
if (empty($httpVars["extraction_id"])) {
$extractId = sha1(rand());
$httpVars["extraction_id"] = $extractId;
} else {
$extractId = $httpVars["extraction_id"];
}
$progressExtractFileName = $this->getPluginCacheDir(false, true) . DIRECTORY_SEPARATOR . "progressExtractID-" . $extractId . ".txt";
if ($action == "compression") {
$archiveName = AJXP_Utils::sanitize(AJXP_Utils::decodeSecureMagic($httpVars["archive_name"]), AJXP_SANITIZE_FILENAME);
$archiveFormat = $httpVars["type_archive"];
$tabTypeArchive = array(".tar", ".tar.gz", ".tar.bz2");
$acceptedExtension = false;
foreach ($tabTypeArchive as $extensionArchive) {
if ($extensionArchive == $archiveFormat) {
$acceptedExtension = true;
break;
}
}
if ($acceptedExtension == false) {
file_put_contents($progressCompressionFileName, "Error : " . $messages["compression.16"]);
throw new AJXP_Exception($messages["compression.16"]);
}
$typeArchive = $httpVars["type_archive"];
//if we can run in background we do it
if (ConfService::backgroundActionsSupported() && !ConfService::currentContextIsCommandLine()) {
$archivePath = $currentDirPath . $archiveName;
file_put_contents($progressCompressionFileName, $messages["compression.5"]);
AJXP_Controller::applyActionInBackground($repository->getId(), "compression", $httpVars);
AJXP_XMLWriter::header();
AJXP_XMLWriter::triggerBgAction("check_compression_status", array("repository_id" => $repository->getId(), "compression_id" => $compressionId, "archive_path" => SystemTextEncoding::toUTF8($archivePath)), $messages["compression.5"], true, 2);
AJXP_XMLWriter::close();
return null;
} else {
$maxAuthorizedSize = 4294967296;
$currentDirUrlLength = strlen($currentDirUrl);
$tabFolders = array();
$tabAllRecursiveFiles = array();
$tabFilesNames = array();
foreach ($nodes as $node) {
$nodeUrl = $node->getUrl();
if (is_file($nodeUrl) && filesize($nodeUrl) < $maxAuthorizedSize) {
array_push($tabAllRecursiveFiles, $nodeUrl);
array_push($tabFilesNames, substr($nodeUrl, $currentDirUrlLength));
}
if (is_dir($nodeUrl)) {
array_push($tabFolders, $nodeUrl);
}
}
//DO A FOREACH OR IT'S GONNA HAVE SOME SAMES FILES NAMES
foreach ($tabFolders as $value) {
$dossiers = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($value));
foreach ($dossiers as $file) {
if ($file->isDir()) {
continue;
}
array_push($tabAllRecursiveFiles, $file->getPathname());
array_push($tabFilesNames, substr($file->getPathname(), $currentDirUrlLength));
}
}
//WE STOP IF IT'S JUST AN EMPTY FOLDER OR NO FILES
if (empty($tabFilesNames)) {
file_put_contents($progressCompressionFileName, "Error : " . $messages["compression.17"]);
throw new AJXP_Exception($messages["compression.17"]);
}
try {
$tmpArchiveName = tempnam(AJXP_Utils::getAjxpTmpDir(), "tar-compression") . ".tar";
$archive = new PharData($tmpArchiveName);
} catch (Exception $e) {
file_put_contents($progressCompressionFileName, "Error : " . $e->getMessage());
throw $e;
}
$counterCompression = 0;
//THE TWO ARRAY ARE MERGED FOR THE FOREACH LOOP
$tabAllFiles = array_combine($tabAllRecursiveFiles, $tabFilesNames);
foreach ($tabAllFiles as $fullPath => $fileName) {
try {
$archive->addFile(AJXP_MetaStreamWrapper::getRealFSReference($fullPath), $fileName);
$counterCompression++;
file_put_contents($progressCompressionFileName, sprintf($messages["compression.6"], round($counterCompression / count($tabAllFiles) * 100, 0, PHP_ROUND_HALF_DOWN) . " %"));
} catch (Exception $e) {
unlink($tmpArchiveName);
file_put_contents($progressCompressionFileName, "Error : " . $e->getMessage());
throw $e;
}
}
$finalArchive = $tmpArchiveName;
if ($typeArchive != ".tar") {
$archiveTypeCompress = substr(strrchr($typeArchive, "."), 1);
file_put_contents($progressCompressionFileName, sprintf($messages["compression.7"], strtoupper($archiveTypeCompress)));
if ($archiveTypeCompress == "gz") {
$archive->compress(Phar::GZ);
} elseif ($archiveTypeCompress == "bz2") {
$archive->compress(Phar::BZ2);
}
$finalArchive = $tmpArchiveName . "." . $archiveTypeCompress;
}
$destArchive = AJXP_MetaStreamWrapper::getRealFSReference($currentDirUrl . $archiveName);
rename($finalArchive, $destArchive);
AJXP_Controller::applyHook("node.before_create", array($destArchive, filesize($destArchive)));
if (file_exists($tmpArchiveName)) {
unlink($tmpArchiveName);
unlink(substr($tmpArchiveName, 0, -4));
}
$newNode = new AJXP_Node($currentDirUrl . $archiveName);
AJXP_Controller::applyHook("node.change", array(null, $newNode, false));
file_put_contents($progressCompressionFileName, "SUCCESS");
}
} elseif ($action == "check_compression_status") {
$archivePath = AJXP_Utils::decodeSecureMagic($httpVars["archive_path"]);
$progressCompression = file_get_contents($progressCompressionFileName);
$substrProgressCompression = substr($progressCompression, 0, 5);
if ($progressCompression != "SUCCESS" && $substrProgressCompression != "Error") {
AJXP_XMLWriter::header();
AJXP_XMLWriter::triggerBgAction("check_compression_status", array("repository_id" => $repository->getId(), "compression_id" => $compressionId, "archive_path" => SystemTextEncoding::toUTF8($archivePath)), $progressCompression, true, 5);
AJXP_XMLWriter::close();
} elseif ($progressCompression == "SUCCESS") {
$newNode = new AJXP_Node($userSelection->currentBaseUrl() . $archivePath);
$nodesDiffs = array("ADD" => array($newNode), "REMOVE" => array(), "UPDATE" => array());
AJXP_Controller::applyHook("node.change", array(null, $newNode, false));
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($messages["compression.8"], null);
AJXP_XMLWriter::writeNodesDiff($nodesDiffs, true);
AJXP_XMLWriter::close();
if (file_exists($progressCompressionFileName)) {
unlink($progressCompressionFileName);
}
} elseif ($substrProgressCompression == "Error") {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $progressCompression);
AJXP_XMLWriter::close();
if (file_exists($progressCompressionFileName)) {
unlink($progressCompressionFileName);
}
}
} elseif ($action == "extraction") {
$fileArchive = AJXP_Utils::sanitize(AJXP_Utils::decodeSecureMagic($httpVars["file"]), AJXP_SANITIZE_DIRNAME);
$fileArchive = substr(strrchr($fileArchive, DIRECTORY_SEPARATOR), 1);
$authorizedExtension = array("tar" => 4, "gz" => 7, "bz2" => 8);
$acceptedArchive = false;
$extensionLength = 0;
$counterExtract = 0;
$currentAllPydioPath = $currentDirUrl . $fileArchive;
$pharCurrentAllPydioPath = "phar://" . AJXP_MetaStreamWrapper::getRealFSReference($currentAllPydioPath);
$pathInfoCurrentAllPydioPath = pathinfo($currentAllPydioPath, PATHINFO_EXTENSION);
//WE TAKE ONLY TAR, TAR.GZ AND TAR.BZ2 ARCHIVES
foreach ($authorizedExtension as $extension => $strlenExtension) {
if ($pathInfoCurrentAllPydioPath == $extension) {
$acceptedArchive = true;
$extensionLength = $strlenExtension;
break;
}
}
if ($acceptedArchive == false) {
file_put_contents($progressExtractFileName, "Error : " . $messages["compression.15"]);
throw new AJXP_Exception($messages["compression.15"]);
}
$onlyFileName = substr($fileArchive, 0, -$extensionLength);
$lastPosOnlyFileName = strrpos($onlyFileName, "-");
$tmpOnlyFileName = substr($onlyFileName, 0, $lastPosOnlyFileName);
$counterDuplicate = substr($onlyFileName, $lastPosOnlyFileName + 1);
if (!is_int($lastPosOnlyFileName) || !is_int($counterDuplicate)) {
$tmpOnlyFileName = $onlyFileName;
$counterDuplicate = 1;
}
while (file_exists($currentDirUrl . $onlyFileName)) {
$onlyFileName = $tmpOnlyFileName . "-" . $counterDuplicate;
$counterDuplicate++;
}
if (ConfService::backgroundActionsSupported() && !ConfService::currentContextIsCommandLine()) {
file_put_contents($progressExtractFileName, $messages["compression.12"]);
AJXP_Controller::applyActionInBackground($repository->getId(), "extraction", $httpVars);
AJXP_XMLWriter::header();
AJXP_XMLWriter::triggerBgAction("check_extraction_status", array("repository_id" => $repository->getId(), "extraction_id" => $extractId, "currentDirUrl" => $currentDirUrl, "onlyFileName" => $onlyFileName), $messages["compression.12"], true, 2);
AJXP_XMLWriter::close();
return null;
}
mkdir($currentDirUrl . $onlyFileName, 0777, true);
chmod(AJXP_MetaStreamWrapper::getRealFSReference($currentDirUrl . $onlyFileName), 0777);
try {
$archive = new PharData(AJXP_MetaStreamWrapper::getRealFSReference($currentAllPydioPath));
$fichiersArchive = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($pharCurrentAllPydioPath));
foreach ($fichiersArchive as $file) {
$fileGetPathName = $file->getPathname();
if ($file->isDir()) {
continue;
}
$fileNameInArchive = substr(strstr($fileGetPathName, $fileArchive), strlen($fileArchive) + 1);
try {
$archive->extractTo(AJXP_MetaStreamWrapper::getRealFSReference($currentDirUrl . $onlyFileName), $fileNameInArchive, false);
} catch (Exception $e) {
file_put_contents($progressExtractFileName, "Error : " . $e->getMessage());
throw new AJXP_Exception($e);
}
$counterExtract++;
file_put_contents($progressExtractFileName, sprintf($messages["compression.13"], round($counterExtract / $archive->count() * 100, 0, PHP_ROUND_HALF_DOWN) . " %"));
}
} catch (Exception $e) {
file_put_contents($progressExtractFileName, "Error : " . $e->getMessage());
throw new AJXP_Exception($e);
}
file_put_contents($progressExtractFileName, "SUCCESS");
$newNode = new AJXP_Node($currentDirUrl . $onlyFileName);
AJXP_Controller::findActionAndApply("index", array("file" => $newNode->getPath()), array());
} elseif ($action == "check_extraction_status") {
$currentDirUrl = $httpVars["currentDirUrl"];
$onlyFileName = $httpVars["onlyFileName"];
$progressExtract = file_get_contents($progressExtractFileName);
$substrProgressExtract = substr($progressExtract, 0, 5);
if ($progressExtract != "SUCCESS" && $progressExtract != "INDEX" && $substrProgressExtract != "Error") {
AJXP_XMLWriter::header();
AJXP_XMLWriter::triggerBgAction("check_extraction_status", array("repository_id" => $repository->getId(), "extraction_id" => $extractId, "currentDirUrl" => $currentDirUrl, "onlyFileName" => $onlyFileName), $progressExtract, true, 4);
AJXP_XMLWriter::close();
} elseif ($progressExtract == "SUCCESS") {
$newNode = new AJXP_Node($currentDirUrl . $onlyFileName);
$nodesDiffs = array("ADD" => array($newNode), "REMOVE" => array(), "UPDATE" => array());
AJXP_Controller::applyHook("node.change", array(null, $newNode, false));
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(sprintf($messages["compression.14"], $onlyFileName), null);
AJXP_XMLWriter::triggerBgAction("check_index_status", array("repository_id" => $newNode->getRepositoryId()), "starting indexation", true, 5);
AJXP_XMLWriter::writeNodesDiff($nodesDiffs, true);
AJXP_XMLWriter::close();
if (file_exists($progressExtractFileName)) {
unlink($progressExtractFileName);
}
} elseif ($substrProgressExtract == "Error") {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $progressExtract);
AJXP_XMLWriter::close();
if (file_exists($progressExtractFileName)) {
unlink($progressExtractFileName);
}
}
}
}
public function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->actions[$action])) {
return;
}
parent::accessPreprocess($action, $httpVars, $fileVars);
$loggedUser = AuthService::getLoggedUser();
if (AuthService::usersEnabled() && !$loggedUser->isAdmin()) {
return;
}
if (AuthService::usersEnabled()) {
$currentBookmarks = AuthService::getLoggedUser()->getBookmarks();
// FLATTEN
foreach ($currentBookmarks as $bm) {
$this->currentBookmarks[] = $bm["PATH"];
}
}
if ($action == "edit") {
if (isset($httpVars["sub_action"])) {
$action = $httpVars["sub_action"];
}
}
$mess = ConfService::getMessages();
$currentUserIsGroupAdmin = AuthService::getLoggedUser() != null && AuthService::getLoggedUser()->getGroupPath() != "/";
if ($currentUserIsGroupAdmin && ConfService::getAuthDriverImpl()->isAjxpAdmin(AuthService::getLoggedUser()->getId())) {
$currentUserIsGroupAdmin = false;
}
switch ($action) {
//------------------------------------
// BASIC LISTING
//------------------------------------
case "ls":
$rootNodes = array("data" => array("LABEL" => $mess["ajxp_conf.110"], "ICON" => "user.png", "DESCRIPTION" => $mess["ajxp_conf.137"], "CHILDREN" => array("repositories" => array("AJXP_MIME" => "workspaces_zone", "LABEL" => $mess["ajxp_conf.3"], "DESCRIPTION" => $mess["ajxp_conf.138"], "ICON" => "hdd_external_unmount.png", "LIST" => "listRepositories"), "users" => array("AJXP_MIME" => "users_zone", "LABEL" => $mess["ajxp_conf.2"], "DESCRIPTION" => $mess["ajxp_conf.139"], "ICON" => "users-folder.png", "LIST" => "listUsers"), "roles" => array("AJXP_MIME" => "roles_zone", "LABEL" => $mess["ajxp_conf.69"], "DESCRIPTION" => $mess["ajxp_conf.140"], "ICON" => "user-acl.png", "LIST" => "listRoles"))), "config" => array("AJXP_MIME" => "plugins_zone", "LABEL" => $mess["ajxp_conf.109"], "ICON" => "preferences_desktop.png", "DESCRIPTION" => $mess["ajxp_conf.136"], "CHILDREN" => array("core" => array("AJXP_MIME" => "plugins_zone", "LABEL" => $mess["ajxp_conf.98"], "DESCRIPTION" => $mess["ajxp_conf.133"], "ICON" => "preferences_desktop.png", "LIST" => "listPlugins"), "plugins" => array("AJXP_MIME" => "plugins_zone", "LABEL" => $mess["ajxp_conf.99"], "DESCRIPTION" => $mess["ajxp_conf.134"], "ICON" => "folder_development.png", "LIST" => "listPlugins"), "core_plugins" => array("AJXP_MIME" => "plugins_zone", "LABEL" => $mess["ajxp_conf.123"], "DESCRIPTION" => $mess["ajxp_conf.135"], "ICON" => "folder_development.png", "LIST" => "listPlugins"))), "admin" => array("LABEL" => $mess["ajxp_conf.111"], "ICON" => "toggle_log.png", "DESCRIPTION" => $mess["ajxp_conf.141"], "CHILDREN" => array("logs" => array("LABEL" => $mess["ajxp_conf.4"], "DESCRIPTION" => $mess["ajxp_conf.142"], "ICON" => "toggle_log.png", "LIST" => "listLogFiles"), "diagnostic" => array("LABEL" => $mess["ajxp_conf.5"], "DESCRIPTION" => $mess["ajxp_conf.143"], "ICON" => "susehelpcenter.png", "LIST" => "printDiagnostic"))), "developer" => array("LABEL" => $mess["ajxp_conf.144"], "ICON" => "applications_engineering.png", "DESCRIPTION" => $mess["ajxp_conf.145"], "CHILDREN" => array("actions" => array("LABEL" => $mess["ajxp_conf.146"], "DESCRIPTION" => $mess["ajxp_conf.147"], "ICON" => "book.png", "LIST" => "listActions"), "hooks" => array("LABEL" => $mess["ajxp_conf.148"], "DESCRIPTION" => $mess["ajxp_conf.149"], "ICON" => "book.png", "LIST" => "listHooks"))));
if ($currentUserIsGroupAdmin) {
unset($rootNodes["config"]);
unset($rootNodes["admin"]);
unset($rootNodes["developer"]);
}
AJXP_Controller::applyHook("ajxp_conf.list_config_nodes", array(&$rootNodes));
$parentName = "";
$dir = trim(AJXP_Utils::decodeSecureMagic(isset($httpVars["dir"]) ? $httpVars["dir"] : ""), " /");
if ($dir != "") {
$hash = null;
if (strstr(urldecode($dir), "#") !== false) {
list($dir, $hash) = explode("#", urldecode($dir));
}
$splits = explode("/", $dir);
$root = array_shift($splits);
if (count($splits)) {
$returnNodes = false;
if (isset($httpVars["file"])) {
$returnNodes = true;
}
$child = $splits[0];
if (isset($rootNodes[$root]["CHILDREN"][$child])) {
$atts = array();
if ($child == "users") {
$atts["remote_indexation"] = "admin_search";
}
$callback = $rootNodes[$root]["CHILDREN"][$child]["LIST"];
if (is_string($callback) && method_exists($this, $callback)) {
if (!$returnNodes) {
AJXP_XMLWriter::header("tree", $atts);
}
$res = call_user_func(array($this, $callback), implode("/", $splits), $root, $hash, $returnNodes, isset($httpVars["file"]) ? $httpVars["file"] : '');
if (!$returnNodes) {
AJXP_XMLWriter::close();
}
} else {
if (is_array($callback)) {
$res = call_user_func($callback, implode("/", $splits), $root, $hash, $returnNodes, isset($httpVars["file"]) ? $httpVars["file"] : '');
}
}
if ($returnNodes) {
AJXP_XMLWriter::header("tree", $atts);
if (isset($res["/" . $dir . "/" . $httpVars["file"]])) {
print $res["/" . $dir . "/" . $httpVars["file"]];
}
AJXP_XMLWriter::close();
}
return;
}
} else {
$parentName = "/" . $root . "/";
$nodes = $rootNodes[$root]["CHILDREN"];
}
} else {
$parentName = "/";
$nodes = $rootNodes;
}
if (isset($httpVars["file"])) {
$parentName = $httpVars["dir"] . "/";
$nodes = array(basename($httpVars["file"]) => array("LABEL" => basename($httpVars["file"])));
}
if (isset($nodes)) {
AJXP_XMLWriter::header();
if (!isset($httpVars["file"])) {
AJXP_XMLWriter::sendFilesListComponentConfig('<columns switchDisplayMode="detail"><column messageId="ajxp_conf.1" attributeName="ajxp_label" sortType="String"/><column messageId="ajxp_conf.102" attributeName="description" sortType="String"/></columns>');
}
foreach ($nodes as $key => $data) {
$bmString = '';
if (in_array($parentName . $key, $this->currentBookmarks)) {
$bmString = ' ajxp_bookmarked="true" overlay_icon="bookmark.png" ';
}
if ($key == "users") {
$bmString .= ' remote_indexation="admin_search"';
}
if (isset($data["AJXP_MIME"])) {
$bmString .= ' ajxp_mime="' . $data["AJXP_MIME"] . '"';
}
if (empty($data["CHILDREN"])) {
print '<tree text="' . AJXP_Utils::xmlEntities($data["LABEL"]) . '" description="' . AJXP_Utils::xmlEntities($data["DESCRIPTION"]) . '" icon="' . $data["ICON"] . '" filename="' . $parentName . $key . '" ' . $bmString . '/>';
} else {
print '<tree text="' . AJXP_Utils::xmlEntities($data["LABEL"]) . '" description="' . AJXP_Utils::xmlEntities($data["DESCRIPTION"]) . '" icon="' . $data["ICON"] . '" filename="' . $parentName . $key . '" ' . $bmString . '>';
foreach ($data["CHILDREN"] as $cKey => $cData) {
$bmString = '';
if (in_array($parentName . $key . "/" . $cKey, $this->currentBookmarks)) {
$bmString = ' ajxp_bookmarked="true" overlay_icon="bookmark.png" ';
}
if ($cKey == "users") {
$bmString .= ' remote_indexation="admin_search"';
}
if (isset($cData["AJXP_MIME"])) {
$bmString .= ' ajxp_mime="' . $cData["AJXP_MIME"] . '"';
}
print '<tree text="' . AJXP_Utils::xmlEntities($cData["LABEL"]) . '" description="' . AJXP_Utils::xmlEntities($cData["DESCRIPTION"]) . '" icon="' . $cData["ICON"] . '" filename="' . $parentName . $key . '/' . $cKey . '" ' . $bmString . '/>';
}
print '</tree>';
}
}
AJXP_XMLWriter::close();
}
break;
case "stat":
header("Content-type:application/json");
print '{"mode":true}';
return;
break;
case "clear_plugins_cache":
AJXP_XMLWriter::header();
// Clear plugins cache if they exist
AJXP_PluginsService::clearPluginsCache();
ConfService::clearMessagesCache();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf." . (AJXP_SKIP_CACHE ? "132" : "131")], null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
break;
case "create_group":
if (isset($httpVars["group_path"])) {
$basePath = AJXP_Utils::forwardSlashDirname($httpVars["group_path"]);
if (empty($basePath)) {
$basePath = "/";
}
$gName = AJXP_Utils::sanitize(AJXP_Utils::decodeSecureMagic(basename($httpVars["group_path"])), AJXP_SANITIZE_ALPHANUM);
} else {
$basePath = substr($httpVars["dir"], strlen("/data/users"));
$gName = AJXP_Utils::sanitize(SystemTextEncoding::magicDequote($httpVars["group_name"]), AJXP_SANITIZE_ALPHANUM);
}
$gLabel = AJXP_Utils::decodeSecureMagic($httpVars["group_label"]);
AuthService::createGroup($basePath, $gName, $gLabel);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.124"], null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
break;
case "create_role":
$roleId = AJXP_Utils::sanitize(SystemTextEncoding::magicDequote($httpVars["role_id"]), AJXP_SANITIZE_HTML_STRICT);
if (!strlen($roleId)) {
throw new Exception($mess[349]);
}
if (AuthService::getRole($roleId) !== false) {
throw new Exception($mess["ajxp_conf.65"]);
}
$r = new AJXP_Role($roleId);
if (AuthService::getLoggedUser() != null && AuthService::getLoggedUser()->getGroupPath() != null) {
$r->setGroupPath(AuthService::getLoggedUser()->getGroupPath());
}
AuthService::updateRole($r);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.66"], null);
AJXP_XMLWriter::reloadDataNode("", $httpVars["role_id"]);
AJXP_XMLWriter::close();
break;
case "edit_role":
$roleId = SystemTextEncoding::magicDequote($httpVars["role_id"]);
$roleGroup = false;
$userObject = null;
$groupLabel = null;
if (strpos($roleId, "AJXP_GRP_") === 0) {
$groupPath = substr($roleId, strlen("AJXP_GRP_"));
$filteredGroupPath = AuthService::filterBaseGroup($groupPath);
$groups = AuthService::listChildrenGroups(AJXP_Utils::forwardSlashDirname($groupPath));
$key = "/" . basename($groupPath);
if (!array_key_exists($key, $groups)) {
throw new Exception("Cannot find group with this id!");
}
$roleId = "AJXP_GRP_" . $filteredGroupPath;
$groupLabel = $groups[$key];
$roleGroup = true;
}
if (strpos($roleId, "AJXP_USR_") === 0) {
$usrId = str_replace("AJXP_USR_/", "", $roleId);
$userObject = ConfService::getConfStorageImpl()->createUserObject($usrId);
if (!AuthService::canAdministrate($userObject)) {
throw new Exception("Cant find user!");
}
$role = $userObject->personalRole;
} else {
$role = AuthService::getRole($roleId, $roleGroup);
}
if ($role === false) {
throw new Exception("Cant find role! ");
}
if (isset($httpVars["format"]) && $httpVars["format"] == "json") {
HTMLWriter::charsetHeader("application/json");
$roleData = $role->getDataArray(true);
$allReps = ConfService::getRepositoriesList("all", false);
$repos = array();
if (!empty($userObject)) {
// USER
foreach ($allReps as $repositoryId => $repositoryObject) {
if (!AuthService::canAssign($repositoryObject, $userObject) || $repositoryObject->isTemplate || $repositoryObject->getAccessType() == "ajxp_conf" && !$userObject->isAdmin() || $repositoryObject->getUniqueUser() != null && $repositoryObject->getUniqueUser() != $userObject->getId()) {
continue;
}
$repos[$repositoryId] = SystemTextEncoding::toUTF8($repositoryObject->getDisplay());
}
} else {
foreach ($allReps as $repositoryId => $repositoryObject) {
if (!AuthService::canAdministrate($repositoryObject)) {
continue;
}
$repos[$repositoryId] = SystemTextEncoding::toUTF8($repositoryObject->getDisplay());
}
}
// Make sure it's utf8
$data = array("ROLE" => $roleData, "ALL" => array("REPOSITORIES" => $repos));
if (isset($userObject)) {
$data["USER"] = array();
$data["USER"]["LOCK"] = $userObject->getLock();
$data["USER"]["PROFILE"] = $userObject->getProfile();
$data["ALL"]["PROFILES"] = array("standard|Standard", "admin|Administrator", "shared|Shared", "guest|Guest");
$data["USER"]["ROLES"] = array_keys($userObject->getRoles());
$data["ALL"]["ROLES"] = array_keys(AuthService::getRolesList(array(), true));
if (isset($userObject->parentRole)) {
$data["PARENT_ROLE"] = $userObject->parentRole->getDataArray();
}
} else {
if (isset($groupPath)) {
$data["GROUP"] = array("PATH" => $groupPath, "LABEL" => $groupLabel);
}
}
$scope = "role";
if ($roleGroup) {
$scope = "group";
} else {
if (isset($userObject)) {
$scope = "user";
}
}
$data["SCOPE_PARAMS"] = array();
$nodes = AJXP_PluginsService::getInstance()->searchAllManifests("//param[contains(@scope,'" . $scope . "')]|//global_param[contains(@scope,'" . $scope . "')]", "node", false, true, true);
foreach ($nodes as $node) {
$pId = $node->parentNode->parentNode->attributes->getNamedItem("id")->nodeValue;
$origName = $node->attributes->getNamedItem("name")->nodeValue;
$node->attributes->getNamedItem("name")->nodeValue = "AJXP_REPO_SCOPE_ALL/" . $pId . "/" . $origName;
$nArr = array();
foreach ($node->attributes as $attrib) {
$nArr[$attrib->nodeName] = AJXP_XMLWriter::replaceAjxpXmlKeywords($attrib->nodeValue);
}
$data["SCOPE_PARAMS"][] = $nArr;
}
echo json_encode($data);
}
break;
case "post_json_role":
$roleId = SystemTextEncoding::magicDequote($httpVars["role_id"]);
$roleGroup = false;
$userObject = $usrId = $filteredGroupPath = null;
if (strpos($roleId, "AJXP_GRP_") === 0) {
$groupPath = substr($roleId, strlen("AJXP_GRP_"));
$filteredGroupPath = AuthService::filterBaseGroup($groupPath);
$roleId = "AJXP_GRP_" . $filteredGroupPath;
$groups = AuthService::listChildrenGroups(AJXP_Utils::forwardSlashDirname($groupPath));
$key = "/" . basename($groupPath);
if (!array_key_exists($key, $groups)) {
throw new Exception("Cannot find group with this id!");
}
$groupLabel = $groups[$key];
$roleGroup = true;
}
if (strpos($roleId, "AJXP_USR_") === 0) {
$usrId = str_replace("AJXP_USR_/", "", $roleId);
$userObject = ConfService::getConfStorageImpl()->createUserObject($usrId);
if (!AuthService::canAdministrate($userObject)) {
throw new Exception("Cannot post role for user " . $usrId);
}
$originalRole = $userObject->personalRole;
} else {
// second param = create if not exists.
$originalRole = AuthService::getRole($roleId, $roleGroup);
}
if ($originalRole === false) {
throw new Exception("Cant find role! ");
}
$jsonData = SystemTextEncoding::magicDequote($httpVars["json_data"]);
$data = json_decode($jsonData, true);
$roleData = $data["ROLE"];
$forms = $data["FORMS"];
$binariesContext = array();
if (isset($userObject)) {
$binariesContext = array("USER" => $userObject->getId());
}
foreach ($forms as $repoScope => $plugData) {
foreach ($plugData as $plugId => $formsData) {
$parsed = array();
AJXP_Utils::parseStandardFormParameters($formsData, $parsed, $userObject != null ? $usrId : null, "ROLE_PARAM_", $binariesContext, AJXP_Role::$cypheredPassPrefix);
$roleData["PARAMETERS"][$repoScope][$plugId] = $parsed;
}
}
$existingParameters = $originalRole->listParameters(true);
$this->mergeExistingParameters($roleData["PARAMETERS"], $existingParameters);
if (isset($userObject) && isset($data["USER"]) && isset($data["USER"]["PROFILE"])) {
$userObject->setAdmin($data["USER"]["PROFILE"] == "admin");
$userObject->setProfile($data["USER"]["PROFILE"]);
}
if (isset($data["GROUP_LABEL"]) && isset($groupLabel) && $groupLabel != $data["GROUP_LABEL"]) {
ConfService::getConfStorageImpl()->relabelGroup($filteredGroupPath, $data["GROUP_LABEL"]);
}
if ($currentUserIsGroupAdmin) {
// FILTER DATA FOR GROUP ADMINS
$params = $this->getEditableParameters(false);
foreach ($roleData["PARAMETERS"] as $scope => &$plugsParameters) {
foreach ($plugsParameters as $paramPlugin => &$parameters) {
foreach ($parameters as $pName => $pValue) {
if (!isset($params[$paramPlugin]) || !in_array($pName, $params[$paramPlugin])) {
unset($parameters[$pName]);
}
}
if (!count($parameters)) {
unset($plugsParameters[$paramPlugin]);
}
}
if (!count($plugsParameters)) {
unset($roleData["PARAMETERS"][$scope]);
}
}
// Remerge from parent
$roleData["PARAMETERS"] = $originalRole->array_merge_recursive2($originalRole->listParameters(), $roleData["PARAMETERS"]);
// Changing Actions is not allowed
$roleData["ACTIONS"] = $originalRole->listActionsStates();
}
try {
$originalRole->bunchUpdate($roleData);
if (isset($userObject)) {
$userObject->personalRole = $originalRole;
$userObject->save("superuser");
} else {
AuthService::updateRole($originalRole);
}
$output = array("ROLE" => $originalRole->getDataArray(true), "SUCCESS" => true);
} catch (Exception $e) {
$output = array("ERROR" => $e->getMessage());
}
HTMLWriter::charsetHeader("application/json");
echo json_encode($output);
break;
case "user_set_lock":
$userId = AJXP_Utils::decodeSecureMagic($httpVars["user_id"]);
$lock = $httpVars["lock"] == "true" ? true : false;
$lockType = $httpVars["lock_type"];
if (AuthService::userExists($userId)) {
$userObject = ConfService::getConfStorageImpl()->createUserObject($userId);
if (!AuthService::canAdministrate($userObject)) {
throw new Exception("Cannot update user data for " . $userId);
}
if ($lock) {
$userObject->setLock($lockType);
} else {
$userObject->removeLock();
}
$userObject->save("superuser");
}
break;
case "create_user":
if (!isset($httpVars["new_user_login"]) || $httpVars["new_user_login"] == "" || !isset($httpVars["new_user_pwd"]) || $httpVars["new_user_pwd"] == "") {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.61"]);
AJXP_XMLWriter::close();
return;
}
$original_login = SystemTextEncoding::magicDequote($httpVars["new_user_login"]);
$new_user_login = AJXP_Utils::sanitize($original_login, AJXP_SANITIZE_EMAILCHARS);
if ($original_login != $new_user_login) {
throw new Exception(str_replace("%s", $new_user_login, $mess["ajxp_conf.127"]));
}
if (AuthService::userExists($new_user_login, "w") || AuthService::isReservedUserId($new_user_login)) {
throw new Exception($mess["ajxp_conf.43"]);
}
AuthService::createUser($new_user_login, $httpVars["new_user_pwd"]);
$confStorage = ConfService::getConfStorageImpl();
$newUser = $confStorage->createUserObject($new_user_login);
$basePath = AuthService::getLoggedUser()->getGroupPath();
if (empty($basePath)) {
$basePath = "/";
}
if (!empty($httpVars["group_path"])) {
$newUser->setGroupPath(rtrim($basePath, "/") . "/" . ltrim($httpVars["group_path"], "/"));
} else {
$newUser->setGroupPath($basePath);
}
$newUser->save("superuser");
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.44"], null);
AJXP_XMLWriter::reloadDataNode("", $new_user_login);
AJXP_XMLWriter::close();
break;
case "change_admin_right":
$userId = $httpVars["user_id"];
if (!AuthService::userExists($userId)) {
throw new Exception("Invalid user id!");
}
$confStorage = ConfService::getConfStorageImpl();
$user = $confStorage->createUserObject($userId);
if (!AuthService::canAdministrate($user)) {
throw new Exception("Cannot update user with id " . $userId);
}
$user->setAdmin($httpVars["right_value"] == "1" ? true : false);
$user->save("superuser");
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.45"] . $httpVars["user_id"], null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
break;
case "role_update_right":
if (!isset($httpVars["role_id"]) || !isset($httpVars["repository_id"]) || !isset($httpVars["right"])) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.61"]);
AJXP_XMLWriter::close();
break;
}
$rId = AJXP_Utils::sanitize($httpVars["role_id"]);
$role = AuthService::getRole($rId);
if ($role === false) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.61"] . "(" . $rId . ")");
AJXP_XMLWriter::close();
break;
}
$role->setAcl(AJXP_Utils::sanitize($httpVars["repository_id"], AJXP_SANITIZE_ALPHANUM), AJXP_Utils::sanitize($httpVars["right"], AJXP_SANITIZE_ALPHANUM));
AuthService::updateRole($role);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.46"] . $httpVars["role_id"], null);
AJXP_XMLWriter::close();
break;
case "user_update_right":
if (!isset($httpVars["user_id"]) || !isset($httpVars["repository_id"]) || !isset($httpVars["right"]) || !AuthService::userExists($httpVars["user_id"])) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.61"]);
print "<update_checkboxes user_id=\"" . $httpVars["user_id"] . "\" repository_id=\"" . $httpVars["repository_id"] . "\" read=\"old\" write=\"old\"/>";
AJXP_XMLWriter::close();
return;
}
$confStorage = ConfService::getConfStorageImpl();
$userId = AJXP_Utils::sanitize($httpVars["user_id"], AJXP_SANITIZE_EMAILCHARS);
$user = $confStorage->createUserObject($userId);
if (!AuthService::canAdministrate($user)) {
throw new Exception("Cannot update user with id " . $userId);
}
$user->personalRole->setAcl(AJXP_Utils::sanitize($httpVars["repository_id"], AJXP_SANITIZE_ALPHANUM), AJXP_Utils::sanitize($httpVars["right"], AJXP_SANITIZE_ALPHANUM));
$user->save();
$loggedUser = AuthService::getLoggedUser();
if ($loggedUser->getId() == $user->getId()) {
AuthService::updateUser($user);
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.46"] . $httpVars["user_id"], null);
print "<update_checkboxes user_id=\"" . $httpVars["user_id"] . "\" repository_id=\"" . $httpVars["repository_id"] . "\" read=\"" . $user->canRead($httpVars["repository_id"]) . "\" write=\"" . $user->canWrite($httpVars["repository_id"]) . "\"/>";
AJXP_XMLWriter::reloadRepositoryList();
AJXP_XMLWriter::close();
return;
break;
case "user_update_group":
$userSelection = new UserSelection();
$userSelection->initFromHttpVars($httpVars);
$dir = $httpVars["dir"];
$dest = $httpVars["dest"];
if (isset($httpVars["group_path"])) {
// API Case
$groupPath = $httpVars["group_path"];
} else {
if (strpos($dir, "/data/users", 0) !== 0 || strpos($dest, "/data/users", 0) !== 0) {
break;
}
$groupPath = substr($dest, strlen("/data/users"));
}
$confStorage = ConfService::getConfStorageImpl();
$userId = null;
$usersMoved = array();
$basePath = AuthService::getLoggedUser() != null ? AuthService::getLoggedUser()->getGroupPath() : "/";
if (empty($basePath)) {
$basePath = "/";
}
if (!empty($groupPath)) {
$targetPath = rtrim($basePath, "/") . "/" . ltrim($groupPath, "/");
} else {
$targetPath = $basePath;
}
foreach ($userSelection->getFiles() as $selectedUser) {
$userId = basename($selectedUser);
if (!AuthService::userExists($userId)) {
continue;
}
$user = $confStorage->createUserObject($userId);
if (!AuthService::canAdministrate($user)) {
continue;
}
$user->setGroupPath($targetPath, true);
$user->save("superuser");
$usersMoved[] = $user->getId();
}
AJXP_XMLWriter::header();
if (count($usersMoved)) {
AJXP_XMLWriter::sendMessage(count($usersMoved) . " user(s) successfully moved to " . $targetPath, null);
AJXP_XMLWriter::reloadDataNode($dest, $userId);
AJXP_XMLWriter::reloadDataNode();
} else {
AJXP_XMLWriter::sendMessage(null, "No users moved, there must have been something wrong.");
}
AJXP_XMLWriter::close();
break;
case "user_add_role":
case "user_delete_role":
if (!isset($httpVars["user_id"]) || !isset($httpVars["role_id"]) || !AuthService::userExists($httpVars["user_id"]) || !AuthService::getRole($httpVars["role_id"])) {
throw new Exception($mess["ajxp_conf.61"]);
}
if ($action == "user_add_role") {
$act = "add";
$messId = "73";
} else {
$act = "remove";
$messId = "74";
}
$this->updateUserRole(AJXP_Utils::sanitize($httpVars["user_id"], AJXP_SANITIZE_EMAILCHARS), $httpVars["role_id"], $act);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf." . $messId] . $httpVars["user_id"], null);
AJXP_XMLWriter::close();
return;
break;
case "user_update_role":
$confStorage = ConfService::getConfStorageImpl();
$selection = new UserSelection();
$selection->initFromHttpVars($httpVars);
$files = $selection->getFiles();
$detectedRoles = array();
$roleId = null;
if (isset($httpVars["role_id"]) && isset($httpVars["update_role_action"])) {
$update = $httpVars["update_role_action"];
$roleId = $httpVars["role_id"];
if (AuthService::getRole($roleId) === false) {
throw new Exception("Invalid role id");
}
}
foreach ($files as $index => $file) {
$userId = basename($file);
if (isset($update)) {
$userObject = $this->updateUserRole($userId, $roleId, $update);
} else {
$userObject = $confStorage->createUserObject($userId);
if (!AuthService::canAdministrate($userObject)) {
continue;
}
}
if ($userObject->hasParent()) {
unset($files[$index]);
continue;
}
$userRoles = $userObject->getRoles();
foreach ($userRoles as $roleIndex => $bool) {
if (!isset($detectedRoles[$roleIndex])) {
$detectedRoles[$roleIndex] = 0;
}
if ($bool === true) {
$detectedRoles[$roleIndex]++;
}
}
}
$count = count($files);
AJXP_XMLWriter::header("admin_data");
print "<user><ajxp_roles>";
foreach ($detectedRoles as $roleId => $roleCount) {
if ($roleCount < $count) {
continue;
}
print "<role id=\"{$roleId}\"/>";
}
print "</ajxp_roles></user>";
print "<ajxp_roles>";
foreach (AuthService::getRolesList(array(), !$this->listSpecialRoles) as $roleId => $roleObject) {
print "<role id=\"{$roleId}\"/>";
}
print "</ajxp_roles>";
AJXP_XMLWriter::close("admin_data");
break;
case "save_custom_user_params":
$userId = AJXP_Utils::sanitize($httpVars["user_id"], AJXP_SANITIZE_EMAILCHARS);
if ($userId == $loggedUser->getId()) {
$user = $loggedUser;
} else {
$confStorage = ConfService::getConfStorageImpl();
$user = $confStorage->createUserObject($userId);
}
if (!AuthService::canAdministrate($user)) {
throw new Exception("Cannot update user with id " . $userId);
}
$custom = $user->getPref("CUSTOM_PARAMS");
if (!is_array($custom)) {
$custom = array();
}
$options = $custom;
$this->parseParameters($httpVars, $options, $userId, false, $custom);
$custom = $options;
$user->setPref("CUSTOM_PARAMS", $custom);
$user->save();
if ($loggedUser->getId() == $user->getId()) {
AuthService::updateUser($user);
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.47"] . $httpVars["user_id"], null);
AJXP_XMLWriter::close();
break;
case "save_repository_user_params":
$userId = AJXP_Utils::sanitize($httpVars["user_id"], AJXP_SANITIZE_EMAILCHARS);
if ($userId == $loggedUser->getId()) {
$user = $loggedUser;
} else {
$confStorage = ConfService::getConfStorageImpl();
$user = $confStorage->createUserObject($userId);
}
if (!AuthService::canAdministrate($user)) {
throw new Exception("Cannot update user with id " . $userId);
}
$wallet = $user->getPref("AJXP_WALLET");
if (!is_array($wallet)) {
$wallet = array();
}
$repoID = $httpVars["repository_id"];
if (!array_key_exists($repoID, $wallet)) {
$wallet[$repoID] = array();
}
$options = $wallet[$repoID];
$existing = $options;
$this->parseParameters($httpVars, $options, $userId, false, $existing);
$wallet[$repoID] = $options;
$user->setPref("AJXP_WALLET", $wallet);
$user->save();
if ($loggedUser->getId() == $user->getId()) {
AuthService::updateUser($user);
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.47"] . $httpVars["user_id"], null);
AJXP_XMLWriter::close();
break;
case "update_user_pwd":
if (!isset($httpVars["user_id"]) || !isset($httpVars["user_pwd"]) || !AuthService::userExists($httpVars["user_id"]) || trim($httpVars["user_pwd"]) == "") {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.61"]);
AJXP_XMLWriter::close();
return;
}
$userId = AJXP_Utils::sanitize($httpVars["user_id"], AJXP_SANITIZE_EMAILCHARS);
$user = ConfService::getConfStorageImpl()->createUserObject($userId);
if (!AuthService::canAdministrate($user)) {
throw new Exception("Cannot update user data for " . $userId);
}
$res = AuthService::updatePassword($userId, $httpVars["user_pwd"]);
AJXP_XMLWriter::header();
if ($res === true) {
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.48"] . $userId, null);
} else {
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.49"] . " : {$res}");
}
AJXP_XMLWriter::close();
break;
case "save_user_preference":
if (!isset($httpVars["user_id"]) || !AuthService::userExists($httpVars["user_id"])) {
throw new Exception($mess["ajxp_conf.61"]);
}
$userId = AJXP_Utils::sanitize($httpVars["user_id"], AJXP_SANITIZE_EMAILCHARS);
if ($userId == $loggedUser->getId()) {
$userObject = $loggedUser;
} else {
$confStorage = ConfService::getConfStorageImpl();
$userObject = $confStorage->createUserObject($userId);
}
if (!AuthService::canAdministrate($userObject)) {
throw new Exception("Cannot update user data for " . $userId);
}
$i = 0;
while (isset($httpVars["pref_name_" . $i]) && isset($httpVars["pref_value_" . $i])) {
$prefName = AJXP_Utils::sanitize($httpVars["pref_name_" . $i], AJXP_SANITIZE_ALPHANUM);
$prefValue = AJXP_Utils::sanitize(SystemTextEncoding::magicDequote($httpVars["pref_value_" . $i]));
if ($prefName == "password") {
continue;
}
if ($prefName != "pending_folder" && $userObject == null) {
$i++;
continue;
}
$userObject->setPref($prefName, $prefValue);
$userObject->save("user");
$i++;
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage("Succesfully saved user preference", null);
AJXP_XMLWriter::close();
break;
case "get_drivers_definition":
AJXP_XMLWriter::header("drivers", array("allowed" => $currentUserIsGroupAdmin ? "false" : "true"));
print AJXP_XMLWriter::replaceAjxpXmlKeywords(ConfService::availableDriversToXML("param", "", true));
AJXP_XMLWriter::close("drivers");
break;
case "get_templates_definition":
AJXP_XMLWriter::header("repository_templates");
$count = 0;
$repositories = ConfService::listRepositoriesWithCriteria(array("isTemplate" => '1'), $count);
foreach ($repositories as $repo) {
if (!$repo->isTemplate) {
continue;
}
$repoId = $repo->getUniqueId();
$repoLabel = SystemTextEncoding::toUTF8($repo->getDisplay());
$repoType = $repo->getAccessType();
print "<template repository_id=\"{$repoId}\" repository_label=\"{$repoLabel}\" repository_type=\"{$repoType}\">";
foreach ($repo->getOptionsDefined() as $optionName) {
print "<option name=\"{$optionName}\"/>";
}
print "</template>";
}
AJXP_XMLWriter::close("repository_templates");
break;
case "create_repository":
$repDef = $httpVars;
$isTemplate = isset($httpVars["sf_checkboxes_active"]);
unset($repDef["get_action"]);
unset($repDef["sf_checkboxes_active"]);
if (isset($httpVars["json_data"])) {
$repDef = json_decode(SystemTextEncoding::magicDequote($httpVars["json_data"]), true);
$options = $repDef["DRIVER_OPTIONS"];
} else {
$options = array();
$this->parseParameters($repDef, $options, null, true);
}
if (count($options)) {
$repDef["DRIVER_OPTIONS"] = $options;
unset($repDef["DRIVER_OPTIONS"]["AJXP_GROUP_PATH_PARAMETER"]);
}
if (strstr($repDef["DRIVER"], "ajxp_template_") !== false) {
$templateId = substr($repDef["DRIVER"], 14);
$templateRepo = ConfService::getRepositoryById($templateId);
$newRep = $templateRepo->createTemplateChild($repDef["DISPLAY"], $repDef["DRIVER_OPTIONS"]);
if (isset($repDef["AJXP_SLUG"])) {
$newRep->setSlug($repDef["AJXP_SLUG"]);
}
} else {
if ($currentUserIsGroupAdmin) {
throw new Exception("You are not allowed to create a workspace from a driver. Use a template instead.");
}
$pServ = AJXP_PluginsService::getInstance();
$driver = $pServ->getPluginByTypeName("access", $repDef["DRIVER"]);
$newRep = ConfService::createRepositoryFromArray(0, $repDef);
$testFile = $driver->getBaseDir() . "/test." . $newRep->getAccessType() . "Access.php";
if (!$isTemplate && is_file($testFile)) {
//chdir(AJXP_TESTS_FOLDER."/plugins");
$className = $newRep->getAccessType() . "AccessTest";
if (!class_exists($className)) {
include $testFile;
}
$class = new $className();
$result = $class->doRepositoryTest($newRep);
if (!$result) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $class->failedInfo);
AJXP_XMLWriter::close();
return;
}
}
// Apply default metasource if any
if ($driver != null && $driver->getConfigs() != null) {
$confs = $driver->getConfigs();
if (!empty($confs["DEFAULT_METASOURCES"])) {
$metaIds = AJXP_Utils::parseCSL($confs["DEFAULT_METASOURCES"]);
$metaSourceOptions = array();
foreach ($metaIds as $metaID) {
$metaPlug = $pServ->getPluginById($metaID);
if ($metaPlug == null) {
continue;
}
$pNodes = $metaPlug->getManifestRawContent("//param[@default]", "nodes");
$defaultParams = array();
foreach ($pNodes as $domNode) {
$defaultParams[$domNode->getAttribute("name")] = $domNode->getAttribute("default");
}
$metaSourceOptions[$metaID] = $defaultParams;
}
$newRep->addOption("META_SOURCES", $metaSourceOptions);
}
}
}
if ($this->repositoryExists($newRep->getDisplay())) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.50"]);
AJXP_XMLWriter::close();
return;
}
if ($isTemplate) {
$newRep->isTemplate = true;
}
if ($currentUserIsGroupAdmin) {
$newRep->setGroupPath(AuthService::getLoggedUser()->getGroupPath());
} else {
if (!empty($options["AJXP_GROUP_PATH_PARAMETER"])) {
$basePath = "/";
if (AuthService::getLoggedUser() != null && AuthService::getLoggedUser()->getGroupPath() != null) {
$basePath = AuthService::getLoggedUser()->getGroupPath();
}
$value = AJXP_Utils::securePath(rtrim($basePath, "/") . "/" . ltrim($options["AJXP_GROUP_PATH_PARAMETER"], "/"));
$newRep->setGroupPath($value);
}
}
$res = ConfService::addRepository($newRep);
AJXP_XMLWriter::header();
if ($res == -1) {
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.51"]);
} else {
$loggedUser = AuthService::getLoggedUser();
$loggedUser->personalRole->setAcl($newRep->getUniqueId(), "rw");
$loggedUser->recomputeMergedRole();
$loggedUser->save("superuser");
AuthService::updateUser($loggedUser);
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.52"], null);
AJXP_XMLWriter::reloadDataNode("", $newRep->getUniqueId());
AJXP_XMLWriter::reloadRepositoryList();
}
AJXP_XMLWriter::close();
break;
case "edit_repository":
$repId = $httpVars["repository_id"];
$repository = ConfService::getRepositoryById($repId);
if ($repository == null) {
throw new Exception("Cannot find workspace with id {$repId}");
}
if (!AuthService::canAdministrate($repository)) {
throw new Exception("You are not allowed to edit this workspace!");
}
$pServ = AJXP_PluginsService::getInstance();
$plug = $pServ->getPluginById("access." . $repository->accessType);
if ($plug == null) {
throw new Exception("Cannot find access driver (" . $repository->accessType . ") for workspace!");
}
AJXP_XMLWriter::header("admin_data");
$slug = $repository->getSlug();
if ($slug == "" && $repository->isWriteable()) {
$repository->setSlug();
ConfService::replaceRepository($repId, $repository);
}
if (AuthService::getLoggedUser() != null && AuthService::getLoggedUser()->getGroupPath() != null) {
$rgp = $repository->getGroupPath();
if ($rgp == null) {
$rgp = "/";
}
if (strlen($rgp) < strlen(AuthService::getLoggedUser()->getGroupPath())) {
$repository->setWriteable(false);
}
}
$nested = array();
$definitions = $plug->getConfigsDefinitions();
print "<repository index=\"{$repId}\"";
foreach ($repository as $name => $option) {
if (strstr($name, " ") > -1) {
continue;
}
if (!is_array($option)) {
if (is_bool($option)) {
$option = $option ? "true" : "false";
}
print " {$name}=\"" . SystemTextEncoding::toUTF8(AJXP_Utils::xmlEntities($option)) . "\" ";
} else {
if (is_array($option)) {
$nested[] = $option;
}
}
}
if (count($nested)) {
print ">";
foreach ($nested as $option) {
foreach ($option as $key => $optValue) {
if (is_array($optValue) && count($optValue)) {
print "<param name=\"{$key}\"><![CDATA[" . json_encode($optValue) . "]]></param>";
} else {
if (is_object($optValue)) {
print "<param name=\"{$key}\"><![CDATA[" . json_encode($optValue) . "]]></param>";
} else {
if (is_bool($optValue)) {
$optValue = $optValue ? "true" : "false";
} else {
if (isset($definitions[$key]) && $definitions[$key]["type"] == "password" && !empty($optValue)) {
$optValue = "__AJXP_VALUE_SET__";
}
}
$optValue = AJXP_Utils::xmlEntities($optValue, true);
print "<param name=\"{$key}\" value=\"{$optValue}\"/>";
}
}
}
}
// Add SLUG
if (!$repository->isTemplate) {
print "<param name=\"AJXP_SLUG\" value=\"" . $repository->getSlug() . "\"/>";
}
if ($repository->getGroupPath() != null) {
$basePath = "/";
if (AuthService::getLoggedUser() != null && AuthService::getLoggedUser()->getGroupPath() != null) {
$basePath = AuthService::getLoggedUser()->getGroupPath();
}
$groupPath = $repository->getGroupPath();
if ($basePath != "/") {
$groupPath = substr($repository->getGroupPath(), strlen($basePath));
}
print "<param name=\"AJXP_GROUP_PATH_PARAMETER\" value=\"" . $groupPath . "\"/>";
}
print "</repository>";
} else {
print "/>";
}
if ($repository->hasParent()) {
$parent = ConfService::getRepositoryById($repository->getParentId());
if (isset($parent) && $parent->isTemplate) {
$parentLabel = $parent->getDisplay();
$parentType = $parent->getAccessType();
print "<template repository_id=\"" . $repository->getParentId() . "\" repository_label=\"{$parentLabel}\" repository_type=\"{$parentType}\">";
foreach ($parent->getOptionsDefined() as $parentOptionName) {
print "<option name=\"{$parentOptionName}\"/>";
}
print "</template>";
}
}
$manifest = $plug->getManifestRawContent("server_settings/param");
$manifest = AJXP_XMLWriter::replaceAjxpXmlKeywords($manifest);
print "<ajxpdriver name=\"" . $repository->accessType . "\">{$manifest}</ajxpdriver>";
print "<metasources>";
$metas = $pServ->getPluginsByType("metastore");
$metas = array_merge($metas, $pServ->getPluginsByType("meta"));
$metas = array_merge($metas, $pServ->getPluginsByType("index"));
foreach ($metas as $metaPlug) {
print "<meta id=\"" . $metaPlug->getId() . "\" label=\"" . AJXP_Utils::xmlEntities($metaPlug->getManifestLabel()) . "\">";
$manifest = $metaPlug->getManifestRawContent("server_settings/param");
$manifest = AJXP_XMLWriter::replaceAjxpXmlKeywords($manifest);
print $manifest;
print "</meta>";
}
print "</metasources>";
AJXP_XMLWriter::close("admin_data");
return;
break;
case "edit_repository_label":
case "edit_repository_data":
$repId = $httpVars["repository_id"];
$repo = ConfService::getRepositoryById($repId);
if (!$repo->isWriteable()) {
throw new Exception("This workspace is not writeable. Please edit directly the conf/bootstrap_repositories.php file.");
}
$res = 0;
if (isset($httpVars["newLabel"])) {
$newLabel = AJXP_Utils::sanitize(AJXP_Utils::securePath($httpVars["newLabel"]), AJXP_SANITIZE_HTML);
if ($this->repositoryExists($newLabel)) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.50"]);
AJXP_XMLWriter::close();
return;
}
$repo->setDisplay($newLabel);
$res = ConfService::replaceRepository($repId, $repo);
} else {
$options = array();
$existing = $repo->getOptionsDefined();
$existingValues = array();
foreach ($existing as $exK) {
$existingValues[$exK] = $repo->getOption($exK, true);
}
$this->parseParameters($httpVars, $options, null, true, $existingValues);
if (count($options)) {
foreach ($options as $key => $value) {
if ($key == "AJXP_SLUG") {
$repo->setSlug($value);
continue;
} elseif ($key == "AJXP_GROUP_PATH_PARAMETER") {
$basePath = "/";
if (AuthService::getLoggedUser() != null && AuthService::getLoggedUser()->getGroupPath() != null) {
$basePath = AuthService::getLoggedUser()->getGroupPath();
}
$value = AJXP_Utils::securePath(rtrim($basePath, "/") . "/" . ltrim($value, "/"));
$repo->setGroupPath($value);
continue;
}
$repo->addOption($key, $value);
}
}
if ($repo->getOption("DEFAULT_RIGHTS")) {
$gp = $repo->getGroupPath();
if (empty($gp) || $gp == "/") {
$defRole = AuthService::getRole("ROOT_ROLE");
} else {
$defRole = AuthService::getRole("AJXP_GRP_" . $gp, true);
}
if ($defRole !== false) {
$defRole->setAcl($repId, $repo->getOption("DEFAULT_RIGHTS"));
AuthService::updateRole($defRole);
}
}
if (is_file(AJXP_TESTS_FOLDER . "/plugins/test.ajxp_" . $repo->getAccessType() . ".php")) {
chdir(AJXP_TESTS_FOLDER . "/plugins");
include AJXP_TESTS_FOLDER . "/plugins/test.ajxp_" . $repo->getAccessType() . ".php";
$className = "ajxp_" . $repo->getAccessType();
$class = new $className();
$result = $class->doRepositoryTest($repo);
if (!$result) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $class->failedInfo);
AJXP_XMLWriter::close();
return;
}
}
ConfService::replaceRepository($repId, $repo);
}
AJXP_XMLWriter::header();
if ($res == -1) {
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.53"]);
} else {
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.54"], null);
if (isset($httpVars["newLabel"])) {
AJXP_XMLWriter::reloadDataNode("", $repId);
}
AJXP_XMLWriter::reloadRepositoryList();
}
AJXP_XMLWriter::close();
break;
case "meta_source_add":
$repId = $httpVars["repository_id"];
$repo = ConfService::getRepositoryById($repId);
if (!is_object($repo)) {
throw new Exception("Invalid workspace id! {$repId}");
}
$metaSourceType = AJXP_Utils::sanitize($httpVars["new_meta_source"], AJXP_SANITIZE_ALPHANUM);
if (isset($httpVars["json_data"])) {
$options = json_decode(SystemTextEncoding::magicDequote($httpVars["json_data"]), true);
} else {
$options = array();
$this->parseParameters($httpVars, $options, null, true);
}
$repoOptions = $repo->getOption("META_SOURCES");
if (is_array($repoOptions) && isset($repoOptions[$metaSourceType])) {
throw new Exception($mess["ajxp_conf.55"]);
}
if (!is_array($repoOptions)) {
$repoOptions = array();
}
$repoOptions[$metaSourceType] = $options;
uksort($repoOptions, array($this, "metaSourceOrderingFunction"));
$repo->addOption("META_SOURCES", $repoOptions);
ConfService::replaceRepository($repId, $repo);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.56"], null);
AJXP_XMLWriter::close();
break;
case "meta_source_delete":
$repId = $httpVars["repository_id"];
$repo = ConfService::getRepositoryById($repId);
if (!is_object($repo)) {
throw new Exception("Invalid workspace id! {$repId}");
}
$metaSourceId = $httpVars["plugId"];
$repoOptions = $repo->getOption("META_SOURCES");
if (is_array($repoOptions) && array_key_exists($metaSourceId, $repoOptions)) {
unset($repoOptions[$metaSourceId]);
uksort($repoOptions, array($this, "metaSourceOrderingFunction"));
$repo->addOption("META_SOURCES", $repoOptions);
ConfService::replaceRepository($repId, $repo);
} else {
throw new Exception("Cannot find meta source " . $metaSourceId);
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.57"], null);
AJXP_XMLWriter::close();
break;
case "meta_source_edit":
$repId = $httpVars["repository_id"];
$repo = ConfService::getRepositoryById($repId);
if (!is_object($repo)) {
throw new Exception("Invalid workspace id! {$repId}");
}
$metaSourceId = $httpVars["plugId"];
$repoOptions = $repo->getOption("META_SOURCES");
if (!is_array($repoOptions)) {
$repoOptions = array();
}
if (isset($httpVars["json_data"])) {
$options = json_decode(SystemTextEncoding::magicDequote($httpVars["json_data"]), true);
} else {
$options = array();
$this->parseParameters($httpVars, $options, null, true);
}
if (isset($repoOptions[$metaSourceId])) {
$this->mergeExistingParameters($options, $repoOptions[$metaSourceId]);
}
$repoOptions[$metaSourceId] = $options;
uksort($repoOptions, array($this, "metaSourceOrderingFunction"));
$repo->addOption("META_SOURCES", $repoOptions);
ConfService::replaceRepository($repId, $repo);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.58"], null);
AJXP_XMLWriter::close();
break;
case "delete":
// REST API mapping
if (isset($httpVars["data_type"])) {
switch ($httpVars["data_type"]) {
case "repository":
$httpVars["repository_id"] = basename($httpVars["data_id"]);
break;
case "role":
$httpVars["role_id"] = basename($httpVars["data_id"]);
break;
case "user":
$httpVars["user_id"] = basename($httpVars["data_id"]);
break;
case "group":
$httpVars["group"] = "/data/users" . $httpVars["data_id"];
break;
default:
break;
}
unset($httpVars["data_type"]);
unset($httpVars["data_id"]);
}
if (isset($httpVars["repository_id"])) {
$repId = $httpVars["repository_id"];
$repo = ConfService::getRepositoryById($repId);
if (!is_object($repo)) {
$res = -1;
} else {
$res = ConfService::deleteRepository($repId);
}
AJXP_XMLWriter::header();
if ($res == -1) {
AJXP_XMLWriter::sendMessage(null, $mess[427]);
} else {
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.59"], null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::reloadRepositoryList();
}
AJXP_XMLWriter::close();
return;
} else {
if (isset($httpVars["role_id"])) {
$roleId = $httpVars["role_id"];
if (AuthService::getRole($roleId) === false) {
throw new Exception($mess["ajxp_conf.67"]);
}
AuthService::deleteRole($roleId);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.68"], null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
} else {
if (isset($httpVars["group"])) {
$groupPath = $httpVars["group"];
$basePath = substr(AJXP_Utils::forwardSlashDirname($groupPath), strlen("/data/users"));
$gName = basename($groupPath);
AuthService::deleteGroup($basePath, $gName);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.128"], null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
} else {
if (!isset($httpVars["user_id"]) || $httpVars["user_id"] == "" || AuthService::isReservedUserId($httpVars["user_id"]) || $loggedUser->getId() == $httpVars["user_id"]) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $mess["ajxp_conf.61"]);
AJXP_XMLWriter::close();
}
AuthService::deleteUser($httpVars["user_id"]);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.60"], null);
AJXP_XMLWriter::reloadDataNode();
AJXP_XMLWriter::close();
}
}
}
break;
case "get_plugin_manifest":
$ajxpPlugin = AJXP_PluginsService::getInstance()->getPluginById($httpVars["plugin_id"]);
AJXP_XMLWriter::header("admin_data");
$fullManifest = $ajxpPlugin->getManifestRawContent("", "xml");
$xPath = new DOMXPath($fullManifest->ownerDocument);
$addParams = "";
$instancesDefinitions = array();
$pInstNodes = $xPath->query("server_settings/global_param[contains(@type, 'plugin_instance:')]");
foreach ($pInstNodes as $pInstNode) {
$type = $pInstNode->getAttribute("type");
$instType = str_replace("plugin_instance:", "", $type);
$fieldName = $pInstNode->getAttribute("name");
$pInstNode->setAttribute("type", "group_switch:" . $fieldName);
$typePlugs = AJXP_PluginsService::getInstance()->getPluginsByType($instType);
foreach ($typePlugs as $typePlug) {
if ($typePlug->getId() == "auth.multi") {
continue;
}
$checkErrorMessage = "";
try {
$typePlug->performChecks();
} catch (Exception $e) {
$checkErrorMessage = " (Warning : " . $e->getMessage() . ")";
}
$tParams = AJXP_XMLWriter::replaceAjxpXmlKeywords($typePlug->getManifestRawContent("server_settings/param[not(@group_switch_name)]"));
$addParams .= '<global_param group_switch_name="' . $fieldName . '" name="instance_name" group_switch_label="' . $typePlug->getManifestLabel() . $checkErrorMessage . '" group_switch_value="' . $typePlug->getId() . '" default="' . $typePlug->getId() . '" type="hidden"/>';
$addParams .= str_replace("<param", "<global_param group_switch_name=\"{$fieldName}\" group_switch_label=\"" . $typePlug->getManifestLabel() . $checkErrorMessage . "\" group_switch_value=\"" . $typePlug->getId() . "\" ", $tParams);
$addParams .= str_replace("<param", "<global_param", AJXP_XMLWriter::replaceAjxpXmlKeywords($typePlug->getManifestRawContent("server_settings/param[@group_switch_name]")));
$addParams .= AJXP_XMLWriter::replaceAjxpXmlKeywords($typePlug->getManifestRawContent("server_settings/global_param"));
$instancesDefs = $typePlug->getConfigsDefinitions();
if (!empty($instancesDefs) && is_array($instancesDefs)) {
foreach ($instancesDefs as $defKey => $defData) {
$instancesDefinitions[$fieldName . "/" . $defKey] = $defData;
}
}
}
}
$allParams = AJXP_XMLWriter::replaceAjxpXmlKeywords($fullManifest->ownerDocument->saveXML($fullManifest));
$allParams = str_replace('type="plugin_instance:', 'type="group_switch:', $allParams);
$allParams = str_replace("</server_settings>", $addParams . "</server_settings>", $allParams);
echo $allParams;
$definitions = $instancesDefinitions;
$configsDefs = $ajxpPlugin->getConfigsDefinitions();
if (is_array($configsDefs)) {
$definitions = array_merge($configsDefs, $instancesDefinitions);
}
$values = $ajxpPlugin->getConfigs();
if (!is_array($values)) {
$values = array();
}
echo "<plugin_settings_values>";
// First flatten keys
$flattenedKeys = array();
foreach ($values as $key => $value) {
$type = $definitions[$key]["type"];
if ((strpos($type, "group_switch:") === 0 || strpos($type, "plugin_instance:") === 0) && is_array($value)) {
$res = array();
$this->flattenKeyValues($res, $definitions, $value, $key);
$flattenedKeys += $res;
// Replace parent key by new flat value
$values[$key] = $flattenedKeys[$key];
}
}
$values += $flattenedKeys;
foreach ($values as $key => $value) {
$attribute = true;
$type = $definitions[$key]["type"];
if ($type == "array" && is_array($value)) {
$value = implode(",", $value);
} else {
if ($type == "boolean") {
$value = $value === true || $value === "true" || $value == 1 ? "true" : "false";
} else {
if ($type == "textarea") {
$attribute = false;
} else {
if ($type == "password" && !empty($value)) {
$value = "__AJXP_VALUE_SET__";
}
}
}
}
if ($attribute) {
echo "<param name=\"{$key}\" value=\"" . AJXP_Utils::xmlEntities($value) . "\"/>";
} else {
echo "<param name=\"{$key}\" cdatavalue=\"true\"><![CDATA[" . $value . "]]></param>";
}
}
if ($ajxpPlugin->getType() != "core") {
echo "<param name=\"AJXP_PLUGIN_ENABLED\" value=\"" . ($ajxpPlugin->isEnabled() ? "true" : "false") . "\"/>";
}
echo "</plugin_settings_values>";
echo "<plugin_doc><![CDATA[<p>" . $ajxpPlugin->getPluginInformationHTML("Charles du Jeu", "http://pyd.io/plugins/") . "</p>";
if (file_exists($ajxpPlugin->getBaseDir() . "/plugin_doc.html")) {
echo file_get_contents($ajxpPlugin->getBaseDir() . "/plugin_doc.html");
}
echo "]]></plugin_doc>";
AJXP_XMLWriter::close("admin_data");
break;
case "run_plugin_action":
$options = array();
$this->parseParameters($httpVars, $options, null, true);
$pluginId = $httpVars["action_plugin_id"];
if (isset($httpVars["button_key"])) {
$options = $options[$httpVars["button_key"]];
}
$plugin = AJXP_PluginsService::getInstance()->softLoad($pluginId, $options);
if (method_exists($plugin, $httpVars["action_plugin_method"])) {
try {
$res = call_user_func(array($plugin, $httpVars["action_plugin_method"]), $options);
} catch (Exception $e) {
echo "ERROR:" . $e->getMessage();
break;
}
echo $res;
} else {
echo 'ERROR: Plugin ' . $httpVars["action_plugin_id"] . ' does not implement ' . $httpVars["action_plugin_method"] . ' method!';
}
break;
case "edit_plugin_options":
$options = array();
$this->parseParameters($httpVars, $options, null, true);
$confStorage = ConfService::getConfStorageImpl();
list($pType, $pName) = explode(".", $httpVars["plugin_id"]);
$existing = $confStorage->loadPluginConfig($pType, $pName);
$this->mergeExistingParameters($options, $existing);
$confStorage->savePluginConfig($httpVars["plugin_id"], $options);
AJXP_PluginsService::clearPluginsCache();
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage($mess["ajxp_conf.97"], null);
AJXP_XMLWriter::close();
break;
case "generate_api_docs":
PydioSdkGenerator::analyzeRegistry(isset($httpVars["version"]) ? $httpVars["version"] : AJXP_VERSION);
break;
// Action for update all Pydio's user from ldap in CLI mode
// Action for update all Pydio's user from ldap in CLI mode
case "cli_update_user_list":
if (php_sapi_name() == "cli") {
$progressBar = new AJXP_ProgressBarCLI();
$countCallback = array($progressBar, "init");
$loopCallback = array($progressBar, "update");
AuthService::listUsers("/", null, -1, -1, true, true, $countCallback, $loopCallback);
}
break;
default:
break;
}
return;
}
function switchAction($action, $httpVars, $fileVars)
{
if (!isset($this->actions[$action])) {
return;
}
$loggedUser = AuthService::getLoggedUser();
if (ENABLE_USERS && !$loggedUser->isAdmin()) {
return;
}
if ($action == "edit") {
if (isset($httpVars["sub_action"])) {
$action = $httpVars["sub_action"];
}
}
switch ($action) {
//------------------------------------
// BASIC LISTING
//------------------------------------
case "ls":
$rootNodes = array("users" => array("LABEL" => "Users", "ICON" => "yast_kuser.png"), "repositories" => array("LABEL" => "Repositories", "ICON" => "folder_red.png"), "logs" => array("LABEL" => "Logs", "ICON" => "toggle_log.png"), "diagnostic" => array("LABEL" => "Diagnostic", "ICON" => "susehelpcenter.png"));
$dir = isset($httpVars["dir"]) ? $httpVars["dir"] : "";
$splits = explode("/", $dir);
if (count($splits)) {
if ($splits[0] == "") {
array_shift($splits);
}
if (count($splits)) {
$strippedDir = strtolower(urldecode($splits[0]));
} else {
$strippedDir = "";
}
}
if (array_key_exists($strippedDir, $rootNodes)) {
AJXP_XMLWriter::header();
if ($strippedDir == "users") {
$this->listUsers();
} else {
if ($strippedDir == "repositories") {
$this->listRepositories();
} else {
if ($strippedDir == "logs") {
$this->listLogFiles($dir);
} else {
if ($strippedDir == "diagnostic") {
$this->printDiagnostic();
}
}
}
}
AJXP_XMLWriter::close();
exit(1);
} else {
AJXP_XMLWriter::header();
print '<columns switchGridMode="filelist"><column messageString="Configuration Data" attributeName="ajxp_label" sortType="String"/></columns>';
foreach ($rootNodes as $key => $data) {
$src = '';
if ($key == "logs") {
$src = 'src="content.php?dir=' . $key . '"';
}
print '<tree text="' . $data["LABEL"] . '" icon="' . $data["ICON"] . '" filename="/' . $key . '" parentname="/" ' . $src . ' />';
}
AJXP_XMLWriter::close();
exit(1);
}
break;
case "edit_user":
$confStorage = ConfService::getConfStorageImpl();
$userId = $httpVars["user_id"];
$userObject = $confStorage->createUserObject($userId);
//print_r($userObject);
AJXP_XMLWriter::header("admin_data");
AJXP_XMLWriter::sendUserData($userObject, true);
// Add WALLET DATA : DEFINITIONS AND VALUES
print "<drivers>";
print ConfService::availableDriversToXML("user_param");
print "</drivers>";
$wallet = $userObject->getPref("AJXP_WALLET");
if (is_array($wallet) && count($wallet) > 0) {
print "<user_wallet>";
foreach ($wallet as $repoId => $options) {
foreach ($options as $optName => $optValue) {
print "<wallet_data repo_id=\"{$repoId}\" option_name=\"{$optName}\" option_value=\"{$optValue}\"/>";
}
}
print "</user_wallet>";
}
$editPass = $userId != "guest" ? "1" : "0";
$authDriver = ConfService::getAuthDriverImpl();
if (!$authDriver->passwordsEditable()) {
$editPass = "******";
}
print "<edit_options edit_pass=\"" . $editPass . "\" edit_admin_right=\"" . ($userId != "guest" && $userId != $loggedUser->getId() ? "1" : "0") . "\" edit_delete=\"" . ($userId != "guest" && $userId != $loggedUser->getId() && $authDriver->usersEditable() ? "1" : "0") . "\"/>";
AJXP_XMLWriter::close("admin_data");
exit(1);
break;
case "create_user":
if (!isset($_GET["new_user_login"]) || $_GET["new_user_login"] == "" || !isset($_GET["new_user_pwd"]) || $_GET["new_user_pwd"] == "") {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, "Wrong Arguments!");
AJXP_XMLWriter::close();
exit(1);
}
$forbidden = array("guest", "share");
if (AuthService::userExists($_GET["new_user_login"]) || in_array($_GET["new_user_login"], $forbidden)) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, "User already exists, please choose another login!");
AJXP_XMLWriter::close();
exit(1);
}
if (get_magic_quotes_gpc()) {
$_GET["new_user_login"] = stripslashes($_GET["new_user_login"]);
}
$_GET["new_user_login"] = str_replace("'", "", $_GET["new_user_login"]);
$confStorage = ConfService::getConfStorageImpl();
$newUser = $confStorage->createUserObject($_GET["new_user_login"]);
$newUser->save();
AuthService::createUser($_GET["new_user_login"], $_GET["new_user_pwd"]);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage("User created successfully", null);
AJXP_XMLWriter::reloadFileList($_GET["new_user_login"]);
AJXP_XMLWriter::close();
exit(1);
break;
case "change_admin_right":
$userId = $_GET["user_id"];
$confStorage = ConfService::getConfStorageImpl();
$user = $confStorage->createUserObject($userId);
$user->setAdmin($_GET["right_value"] == "1" ? true : false);
$user->save();
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage("Changed admin right for user " . $_GET["user_id"], null);
AJXP_XMLWriter::reloadFileList(false);
AJXP_XMLWriter::close();
exit(1);
break;
case "update_user_right":
if (!isset($_GET["user_id"]) || !isset($_GET["repository_id"]) || !isset($_GET["right"]) || !AuthService::userExists($_GET["user_id"])) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, "Wrong arguments");
print "<update_checkboxes user_id=\"" . $_GET["user_id"] . "\" repository_id=\"" . $_GET["repository_id"] . "\" read=\"old\" write=\"old\"/>";
AJXP_XMLWriter::close();
exit(1);
}
$confStorage = ConfService::getConfStorageImpl();
$user = $confStorage->createUserObject($_GET["user_id"]);
$user->setRight($_GET["repository_id"], $_GET["right"]);
$user->save();
$loggedUser = AuthService::getLoggedUser();
if ($loggedUser->getId() == $user->getId()) {
AuthService::updateUser($user);
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage("Changed right for user " . $_GET["user_id"], null);
print "<update_checkboxes user_id=\"" . $_GET["user_id"] . "\" repository_id=\"" . $_GET["repository_id"] . "\" read=\"" . $user->canRead($_GET["repository_id"]) . "\" write=\"" . $user->canWrite($_GET["repository_id"]) . "\"/>";
AJXP_XMLWriter::reloadRepositoryList();
AJXP_XMLWriter::close();
exit(1);
break;
case "save_repository_user_params":
$userId = $_GET["user_id"];
if ($userId == $loggedUser->getId()) {
$user = $loggedUser;
} else {
$confStorage = ConfService::getConfStorageImpl();
$user = $confStorage->createUserObject($userId);
}
$wallet = $user->getPref("AJXP_WALLET");
if (!is_array($wallet)) {
$wallet = array();
}
$repoID = $_GET["repository_id"];
if (!array_key_exists($repoID, $wallet)) {
$wallet[$repoID] = array();
}
$options = $wallet[$repoID];
$this->parseParameters($_GET, $options, $userId);
$wallet[$repoID] = $options;
$user->setPref("AJXP_WALLET", $wallet);
$user->save();
if ($loggedUser->getId() == $user->getId()) {
AuthService::updateUser($user);
}
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage("Saved data for user " . $_GET["user_id"], null);
AJXP_XMLWriter::close();
exit(1);
break;
case "update_user_pwd":
if (!isset($_GET["user_id"]) || !isset($_GET["user_pwd"]) || !AuthService::userExists($_GET["user_id"]) || trim($_GET["user_pwd"]) == "") {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, "Wrong Arguments!");
AJXP_XMLWriter::close();
exit(1);
}
$res = AuthService::updatePassword($_GET["user_id"], $_GET["user_pwd"]);
AJXP_XMLWriter::header();
if ($res === true) {
AJXP_XMLWriter::sendMessage("Password changed successfully for user " . $_GET["user_id"], null);
} else {
AJXP_XMLWriter::sendMessage(null, "Cannot update password : {$res}");
}
AJXP_XMLWriter::close();
exit(1);
break;
case "get_drivers_definition":
AJXP_XMLWriter::header("drivers");
print ConfService::availableDriversToXML("param");
AJXP_XMLWriter::close("drivers");
exit(1);
break;
case "create_repository":
$options = array();
$repDef = $_GET;
unset($repDef["get_action"]);
$this->parseParameters($repDef, $options);
if (count($options)) {
$repDef["DRIVER_OPTIONS"] = $options;
}
// NOW SAVE THIS REPOSITORY!
$newRep = ConfService::createRepositoryFromArray(0, $repDef);
if (is_file(INSTALL_PATH . "/server/tests/plugins/test.ajxp_" . $newRep->getAccessType() . ".php")) {
chdir(INSTALL_PATH . "/server/tests/plugins");
include INSTALL_PATH . "/server/tests/plugins/test.ajxp_" . $newRep->getAccessType() . ".php";
$className = "ajxp_" . $newRep->getAccessType();
$class = new $className();
$result = $class->doRepositoryTest($newRep);
if (!$result) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $class->failedInfo);
AJXP_XMLWriter::close();
exit(1);
}
}
$res = ConfService::addRepository($newRep);
AJXP_XMLWriter::header();
if ($res == -1) {
AJXP_XMLWriter::sendMessage(null, "The conf directory is not writeable");
} else {
AJXP_XMLWriter::sendMessage("Successfully created repository", null);
AJXP_XMLWriter::reloadFileList($newRep->getDisplay());
AJXP_XMLWriter::reloadRepositoryList();
}
AJXP_XMLWriter::close();
exit(1);
break;
case "edit_repository":
$repId = $httpVars["repository_id"];
$repList = ConfService::getRootDirsList();
//print_r($repList);
AJXP_XMLWriter::header("admin_data");
if (!isset($repList[$repId])) {
AJXP_XMLWriter::close("admin_data");
exit(1);
}
$repository = $repList[$repId];
$nested = array();
print "<repository index=\"{$repId}\"";
foreach ($repository as $name => $option) {
if (!is_array($option)) {
if (is_bool($option)) {
$option = $option ? "true" : "false";
}
print " {$name}=\"" . SystemTextEncoding::toUTF8(Utils::xmlEntities($option)) . "\" ";
} else {
if (is_array($option)) {
$nested[] = $option;
}
}
}
if (count($nested)) {
print ">";
foreach ($nested as $option) {
foreach ($option as $key => $optValue) {
if (is_bool($optValue)) {
$optValue = $optValue ? "true" : "false";
}
print "<param name=\"{$key}\" value=\"{$optValue}\"/>";
}
}
print "</repository>";
} else {
print "/>";
}
print ConfService::availableDriversToXML("param", $repository->accessType);
AJXP_XMLWriter::close("admin_data");
exit(1);
break;
case "edit_repository_label":
case "edit_repository_data":
$repId = $_GET["repository_id"];
$repo = ConfService::getRepositoryById($repId);
$res = 0;
if (isset($_GET["newLabel"])) {
$repo->setDisplay(SystemTextEncoding::fromPostedFileName($_GET["newLabel"]));
$res = ConfService::replaceRepository($repId, $repo);
} else {
$options = array();
$this->parseParameters($_GET, $options);
if (count($options)) {
foreach ($options as $key => $value) {
$repo->addOption($key, $value);
}
}
if (is_file(INSTALL_PATH . "/server/tests/plugins/test.ajxp_" . $repo->getAccessType() . ".php")) {
chdir(INSTALL_PATH . "/server/tests/plugins");
include INSTALL_PATH . "/server/tests/plugins/test.ajxp_" . $repo->getAccessType() . ".php";
$className = "ajxp_" . $repo->getAccessType();
$class = new $className();
$result = $class->doRepositoryTest($repo);
if (!$result) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, $class->failedInfo);
AJXP_XMLWriter::close();
exit(1);
}
}
ConfService::replaceRepository($repId, $repo);
}
AJXP_XMLWriter::header();
if ($res == -1) {
AJXP_XMLWriter::sendMessage(null, "Error while trying to edit repository");
} else {
AJXP_XMLWriter::sendMessage("Successfully edited repository", null);
AJXP_XMLWriter::reloadFileList(isset($_GET["newLabel"]) ? SystemTextEncoding::fromPostedFileName($_GET["newLabel"]) : false);
AJXP_XMLWriter::reloadRepositoryList();
}
AJXP_XMLWriter::close();
exit(1);
case "delete":
if (isset($httpVars["repository_id"])) {
$repId = $httpVars["repository_id"];
//if(get_magic_quotes_gpc()) $repLabel = stripslashes($repLabel);
$res = ConfService::deleteRepository($repId);
AJXP_XMLWriter::header();
if ($res == -1) {
AJXP_XMLWriter::sendMessage(null, "The conf directory is not writeable");
} else {
AJXP_XMLWriter::sendMessage("Successfully deleted repository", null);
AJXP_XMLWriter::reloadFileList(false);
AJXP_XMLWriter::reloadRepositoryList();
}
AJXP_XMLWriter::close();
exit(1);
} else {
$forbidden = array("guest", "share");
if (!isset($httpVars["user_id"]) || $httpVars["user_id"] == "" || in_array($_GET["user_id"], $forbidden) || $loggedUser->getId() == $httpVars["user_id"]) {
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage(null, "Wrong Arguments!");
AJXP_XMLWriter::close();
exit(1);
}
$res = AuthService::deleteUser($httpVars["user_id"]);
AJXP_XMLWriter::header();
AJXP_XMLWriter::sendMessage("User successfully erased", null);
AJXP_XMLWriter::reloadFileList($httpVars["user_id"]);
AJXP_XMLWriter::close();
exit(1);
}
break;
default:
break;
}
return;
}
function uploadActions($action, $httpVars, $filesVars)
{
switch ($action) {
case "trigger_remote_copy":
if (!$this->hasFilesToCopy()) {
break;
}
$toCopy = $this->getFileNameToCopy();
AJXP_XMLWriter::header();
AJXP_XMLWriter::triggerBgAction("next_to_remote", array(), "Copying file " . $toCopy . " to remote server");
AJXP_XMLWriter::close();
exit(1);
break;
case "next_to_remote":
if (!$this->hasFilesToCopy()) {
break;
}
$fData = $this->getNextFileToCopy();
$nextFile = '';
if ($this->hasFilesToCopy()) {
$nextFile = $this->getFileNameToCopy();
}
$crtRep = ConfService::getRepository();
session_write_close();
$sessionId = "";
$httpClient = $this->getRemoteConnexion($sessionId);
//$httpClient->setDebug(true);
$postData = array("get_action" => "upload", "dir" => base64_encode($fData["destination"]));
$httpClient->postFile($crtRep->getOption("URI") . "?ajxp_sessid={$sessionId}", $postData, "Filedata", $fData);
if (strpos($httpClient->getHeader("content-type"), "text/xml") !== false && strpos($httpClient->getContent(), "require_auth") != false) {
$httpClient = $this->getRemoteConnexion($sessionId, true);
$postData["ajxp_sessid"] = $sessionId;
$httpClient->postFile($crtRep->getOption("URI"), $postData, "Filedata", $fData);
}
unlink($fData["tmp_name"]);
$response = $httpClient->getContent();
AJXP_XMLWriter::header();
if (intval($response) >= 400) {
AJXP_XMLWriter::sendMessage(null, "Error : " . intval($response));
} else {
if ($nextFile != '') {
AJXP_XMLWriter::triggerBgAction("next_to_remote", array(), "Copying file " . $nextFile . " to remote server");
} else {
AJXP_XMLWriter::sendMessage("Done", null);
}
}
AJXP_XMLWriter::close();
exit(1);
break;
case "upload":
$fancyLoader = false;
if (isset($fileVars["Filedata"])) {
$fancyLoader = true;
if ($httpVars['dir'] != "") {
$httpVars['dir'] = "/" . base64_decode($httpVars['dir']);
}
}
if (isset($httpVars['dir']) && $httpVars['dir'] != "") {
$rep_source = $httpVars['dir'];
} else {
$rep_source = "/";
}
$logMessage = "";
//$fancyLoader = false;
foreach ($filesVars as $boxName => $boxData) {
if ($boxName != "Filedata" && substr($boxName, 0, 9) != "userfile_") {
continue;
}
if ($boxName == "Filedata") {
$fancyLoader = true;
}
$err = Utils::parseFileDataErrors($boxData, $fancyLoader);
if ($err != null) {
$errorMessage = $err;
break;
}
$boxData["destination"] = $rep_source;
$destCopy = INSTALL_PATH . "/" . $this->repository->getOption("TMP_UPLOAD");
if (!is_dir($destCopy)) {
if (!@mkdir($destCopy)) {
$errorMessage = "Warning, cannot create folder for temporary copy.";
break;
}
}
if (!is_writeable($destCopy)) {
$errorMessage = "Warning, cannot write into temporary folder.";
break;
}
$destName = $destCopy . "/" . basename($boxData["tmp_name"]);
if (move_uploaded_file($boxData["tmp_name"], $destName)) {
$boxData["tmp_name"] = $destName;
$this->storeFileToCopy($boxData);
} else {
$mess = ConfService::getMessages();
$errorMessage = ($fancyLoader ? "411 " : "") . "{$mess['33']} " . $boxData["name"];
}
}
if ($fancyLoader) {
session_write_close();
if (isset($errorMessage)) {
header('HTTP/1.0 ' . $errorMessage);
die('Error ' . $errorMessage);
} else {
header('HTTP/1.0 200 OK');
die("200 OK");
}
} else {
print "<html><script language=\"javascript\">\n";
if (isset($errorMessage)) {
print "\n if(parent.ajaxplorer.actionBar.multi_selector)parent.ajaxplorer.actionBar.multi_selector.submitNext('" . str_replace("'", "\\'", $errorMessage) . "');";
} else {
print "\n if(parent.ajaxplorer.actionBar.multi_selector)parent.ajaxplorer.actionBar.multi_selector.submitNext();";
}
print "</script></html>";
}
session_write_close();
exit;
break;
default:
break;
}
}
