One Hat Cyber Team

Edit File: Kolab.php

<?php
/**
 * Horde_Share_Kolab:: provides the Kolab backend for the horde share driver.
 *
 * PHP version 5
 *
 * @category Horde
 * @package  Share
 * @author   Stuart Binge <omicron@mighty.co.za>
 * @author   Gunnar Wrobel <wrobel@pardus.de>
 * @license  http://www.horde.org/licenses/lgpl21 LGPL 2.1
 * @link     http://pear.horde.org/index.php?package=Share
 */

/**
 * Horde_Share_Kolab:: provides the Kolab backend for the horde share driver.
 *
 * Copyright 2004-2017 Horde LLC (http://www.horde.org/)
 *
 * See the enclosed file COPYING for license information (LGPL). If you
 * did not receive this file, see http://www.horde.org/licenses/lgpl21.
 *
 * @category Horde
 * @package  Share
 * @author   Stuart Binge <omicron@mighty.co.za>
 * @author   Gunnar Wrobel <wrobel@pardus.de>
 * @license  http://www.horde.org/licenses/lgpl21 LGPL 2.1
 * @link     http://pear.horde.org/index.php?package=Share
 */
class Horde_Share_Kolab extends Horde_Share_Base
{
    const VERSION = 1;

/**
     * The Kolab storage handler
     *
     * @var Horde_Kolab_Storage
     */
    private $_storage;

/**
     * The folder type in the storage backend.
     *
     * @var string
     */
    private $_type;

/**
     * A map of IDs to folder names.
     *
     * @var array
     */
    private $_id_map = array();

/**
     * Constructor.
     *
     * @param string $app               The application that the shares belong
     *                                  to
     * @param string $user              The current user
     * @param Horde_Perms_Base $perms   The permissions object
     * @param Horde_Group_Base $groups  The Horde_Group driver.
     *
     */
    public function __construct($app, $user, Horde_Perms_Base $perms,
                                Horde_Group_Base $groups)
    {
        switch ($app) {
        case 'mnemo':
        case 'jonah':
            $this->_type = 'note';
            break;
        case 'kronolith':
            $this->_type = 'event';
            break;
        case 'turba':
            $this->_type = 'contact';
            break;
        case 'nag':
            $this->_type = 'task';
            break;
        default:
            throw new Horde_Share_Exception(sprintf(Horde_Share_Translation::t("The Horde/Kolab integration engine does not support \"%s\""), $app));
        }
        parent::__construct($app, $user, $perms, $groups);
    }

/**
     * Set the Kolab storage backend.
     *
     * @param Horde_Kolab_Storage $storage The Kolab storage handler.
     *
     * @return NULL
     */
    public function setStorage(Horde_Kolab_Storage $storage)
    {
        $this->_storage = $storage;
    }

/**
     * Return the Kolab storage backend associated with this driver.
     *
     * @return Horde_Kolab_Storage The Kolab storage driver.
     */
    public function getStorage()
    {
        if ($this->_storage === null) {
            throw new Horde_Share_Exception('The storage backend has not yet been set!');
        }
        return $this->_storage;
    }

/**
     * Return the Kolab storage folder list handler.
     *
     * @return Horde_Kolab_Storage_List The folder list handler.
     */
    public function getList()
    {
        try {
            return $this->getStorage()->getList();
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
    }

/**
     * Return the type of folder this share driver will access in the Kolab
     * storage backend (depends on the application calling the share driver).
     *
     * @return string
     */
    public function getType()
    {
        return $this->_type;
    }
    
    /**
     * Encode a share ID.
     *
     * @todo: In Horde3 share IDs were not properly escaped everywhere and it
     * made sense to escape them here just in case they are placed in a
     * URL. Needs checking in Horde4.
     *
     * @param string $id The ID to be encoded.
     *
     * @return string The encoded ID.
     */
    private function _idEncode($id)
    {
        try {
            $folder = $this->getStorage()->getFolder($id);
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
        return $this->constructId($folder->getOwner(), $folder->getSubpath(), $folder->getPrefix());
    }

/**
     * Construct the ID from the owner name and the folder subpath.
     *
     * @param string $owner  The share owner.
     * @param string $name   The name of the folder without the namespace prefix.
     * @param string $prefix The namespace prefix.
     *
     * @return string The encoded ID.
     */
    public function constructId($owner, $name, $prefix = null)
    {
        return Horde_Url::uriB64Encode(serialize(array($owner, $name, $prefix)));
    }

/**
     * Construct the Kolab storage folder name based on the share name and owner
     * attributes.
     *
     * @param string $owner   The owner of the share.
     * @param string $subpath The folder subpath.
     * @param string $prefix  The namespace prefix.
     *
     * @return string The folder name for the Kolab backend.
     */
    public function constructFolderName($owner, $subpath, $prefix = null)
    {
        try {
            return $this->getList()
                ->getNamespace()
                ->constructFolderName($owner, $subpath, $prefix);
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
    }

/**
     * Retrieve namespace information for a folder name.
     *
     * @param string $folder The folder name.
     *
     * @return array A list of namespace prefix, the delimiter and the folder
     *               subpath.
     */
    public function getFolderNameElements($folder)
    {
        try {
            $ns = $this->getList()->getNamespace()->matchNamespace($folder);
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
        return array(
            $ns->getName(), $ns->getDelimiter(), $ns->getSubpath($folder)
        );
    }

/**
     * Decode a share ID.
     *
     * @param string $id The ID to be decoded.
     *
     * @return string The decoded ID.
     */
    private function _idDecode($id)
    {
        if (!isset($this->_id_map[$id])) {
            $result = $this->_idDeconstruct($id);
            $this->_id_map[$id] = $this->constructFolderName(
                $result[0],
                $result[1],
                isset($result[2]) ? $result[2] : null
            );
        }
        return $this->_id_map[$id];
    }

/**
     * Deconstruct the ID elements from the ID string
     *
     * @param string $id The ID to be deconstructed.
     *
     * @return array A tuple of (owner, folder subpath).
     */
    private function _idDeconstruct($id)
    {
        if (!$decoded_id = Horde_Url::uriB64Decode($id)) {
            $msg = sprintf('Share id %s is invalid.', $id);
            $this->_logger->err($msg);
            throw new Horde_Exception_NotFound($msg);
        }
        if (!$sid = @unserialize($decoded_id)) {
            $msg = sprintf('Share id %s is invalid.', $decoded_id);
            $this->_logger->err($msg);
            throw new Horde_Exception_NotFound($msg);
        }
        return $sid;
    }

/**
     * Returns a Horde_Share_Object_Kolab object corresponding to the given
     * share name, with the details retrieved appropriately.
     *
     * @param string $id    The id of the share to retrieve.
     * @param array  $data  The share data.
     *
     * @return Horde_Share_Object  The requested share.
     */
    private function _createObject($id, array $data = array())
    {
        $object = new Horde_Share_Object_Kolab($id, $this->_groups, $data);
        $this->initShareObject($object);
        return $object;
    }

/**
     * Returns a Horde_Share_Object_Kolab object corresponding to the given
     * share name, with the details retrieved appropriately.
     *
     * @param string $name  The name of the share to retrieve.
     *
     * @return Horde_Share_Object  The requested share.
     * @throws Horde_Exception_NotFound
     * @throws Horde_Share_Exception
     */
    protected function _getShare($name)
    {
        try {
            $list = $this->getList()
                ->getQuery()
                ->dataByType($this->_type);

$query = $this->getList()
                ->getQuery(Horde_Kolab_Storage_List_Tools::QUERY_SHARE);

foreach ($list as $folder => $folder_data) {
                $data = $query->getParameters($folder);
                if (isset($data['share_name']) && $data['share_name'] == $name) {
                    return $this->getShareById(
                        $this->constructId(
                            $folder_data['owner'],
                            $folder_data['subpath'],
                            isset($folder_data['prefix']) ? $folder_data['prefix'] : null
                        )
                    );
                }
            }
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }

throw new Horde_Exception_NotFound(sprintf('Share name %s not found', $name));
    }

/**
     * Returns a Horde_Share_Object_sql object corresponding to the given
     * unique ID, with the details retrieved appropriately.
     *
     * @param integer $id  The id of the share to retrieve.
     *
     * @return Horde_Share_Object_sql  The requested share.
     * @throws Horde_Share_Exception, Horde_Exception_NotFound
     */
    protected function _getShareById($id)
    {
        try {
            $list = $this->getList()
                ->getQuery()
                ->dataByType($this->_type);
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }

if (!isset($list[$this->_idDecode($id)])) {
            throw new Horde_Exception_NotFound(sprintf('Share id %s not found', $id));
        }

try {
            $query = $this->getList()
                ->getQuery(Horde_Kolab_Storage_List_Tools::QUERY_SHARE);

$data = array_merge(
                $query->getParameters($this->_idDecode($id)),
                $list[$this->_idDecode($id)]
            );
            $data['desc'] = $query->getDescription($this->_idDecode($id));
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
        if (isset($data['parent'])) {
            try {
                $data['parent'] = $this->_idEncode($data['parent']);
            } catch (Horde_Kolab_Storage_Exception $e) {
                unset($data['parent']);
            }
        }
        return $this->_createObject($id, $data);
    }

/**
     * Returns an array of Horde_Share_Object_kolab objects corresponding to
     * the requested folders.
     *
     * @param string $ids  The ids of the shares to fetch.
     *
     * @return array  An array of Horde_Share_Object_kolab objects.
     */
    protected function _getShares(array $ids)
    {
        $objects = array();
        foreach ($ids as $id) {
            $share = $this->_getShareById($id);
            $objects[$share->getName()] = $share;
        }
        return $objects;
    }

/**
     * Checks if a share exists in the system.
     *
     * @param string $share  The share to check.
     *
     * @return boolean  True if the share exists.
     * @throws Horde_Share_Exception
     */
    protected function _exists($share)
    {
        try {
            $this->getShare($share);
            return true;
        } catch (Horde_Exception_NotFound $e) {
            return false;
        }
    }

/**
     * Check that a share id exists in the system.
     *
     * @param integer $id  The share id
     *
     * @return boolean True if the share exists.
     */
    protected function _idExists($id)
    {
        try {
            return in_array(
                $this->_idDecode($id),
                $this->getList()->getQuery()->listByType($this->_type)
            );
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
    }

/**
     * Returns an array of all shares that $userid has access to.
     *
     * @param string $userid     The userid of the user to check access for.
     * @param array  $params     See listShares().
     *
     * @return array  The shares the user has access to.
     */
    protected function _listShares($userid, array $params = array())
    {
        try {
            $stamp = $this->getList()->getQuery()->getStamp();
            $key = md5(serialize(array($userid, $params, $stamp)));

if (isset($this->_listcache[$key])) {
                return $this->_listcache[$key];
            }

$shares = array_map(
                array($this, '_idEncode'),
                $this->getList()->getQuery()->listByType($this->_type)
            );
            $remove = array();
            if ($params['perm'] != Horde_Perms::SHOW || empty($userid)) {
                foreach ($shares as $share) {
                    $object = $this->_getShareById($share);
                    if (!$object->hasPermission($userid, $params['perm'], $object->get('owner'))) {
                        $remove[] = $share;
                    }
                }
            }
            if (isset($params['parent'])) {
                foreach ($shares as $share) {
                    $object = $this->getShareById($share);
                    if ($params['parent'] instanceof Horde_Share_Object) {
                        $parent = $params['parent'];
                    } else {
                        $parent = $this->getShare($params['parent']);
                    }
                    if (!$object->getParent() || $object->getParent()->getId() != $parent->getId()) {
                        $remove[] = $share;
                    }
                }
            }
            if (isset($params['all_levels']) && empty($params['all_levels'])) {
                foreach ($shares as $share) {
                    $object = $this->getShareById($share);
                    $parent = $object->get('parent');
                    if (!empty($parent) && in_array($parent, $shares)) {
                        $remove[] = $share;
                    }
                }
            }
            if (isset($params['attributes'])) {
                if (!is_array($params['attributes'])) {
                    $attributes = array('owner' => $params['attributes']);
                } else {
                    $attributes = $params['attributes'];
                }
                foreach ($shares as $share) {
                    $object = $this->getShareById($share);
                    foreach ($attributes as $key => $value) {
                        if ($object->get($key) != $value) {
                            $remove[] = $share;
                        }
                    }
                }
            }
            if (!empty($remove)) {
                $shares = array_diff($shares, $remove);
            }
            if (isset($params['sort_by'])) {
                if ($params['sort_by'] == 'id') {
                    sort($shares);
                } else {
                    $sorted = array();
                    foreach ($shares as $share) {
                        $object = $this->getShareById($share);
                        $sorted[$object->getId()] = $object->get($params['sort_by']);
                    }
                    asort($sorted);
                    $shares = array_keys($sorted);
                }
            }
            if (!empty($params['direction'])) {
                $shares = array_reverse($shares);
            }
            if (isset($params['from']) && !empty($params['from'])) {
                $shares = array_slice($shares, $params['from']);
            }
            if (isset($params['count']) && !empty($params['count'])) {
                $shares = array_slice($shares, 0, $params['count']);
            }
            $this->_listcache[$key] = $shares;
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }

return $this->_listcache[$key];
    }

/**
     * Returns the count of all shares that $userid has access to.
     *
     * @param string  $userid      The userid of the user to check access for.
     * @param integer $perm        The level of permissions required.
     * @param mixed   $attributes  Restrict the shares counted to those
     *                             matching $attributes. An array of
     *                             attribute/values pairs or a share owner
     *                             username.
     * @param mixed  $parent      The share to start searching from
     *                            (Horde_Share_Object, share_id, or null)
     * @param boolean $allLevels  Return all levels, or just the direct
     *                            children of $parent?
     *
     * @return integer  Number of shares the user has access to.
     * @throws Horde_Share_Exception
     */
    public function countShares($userid, $perm = Horde_Perms::SHOW,
        $attributes = null, $parent = null, $allLevels = true)
    {
        return count(
            $this->listShares(
                $userid,
                array(
                    'perm' => $perm,
                    'attributes' => $attributes,
                    'parent' => $parent,
                    'all_levels' => $allLevels
                )
            )
        );
    }

/**
     * Returns an array of all system shares.
     *
     * @return array  All system shares.
     */
    public function listSystemShares()
    {
        try {
            $shares = array_map(
                array($this, '_idEncode'),
                $this->getList()->getQuery()->listByType($this->_type)
            );
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }

$result = array();
        foreach ($shares as $share) {
            $object = $this->_getShareById($share);
            //@todo: Remove "null" check as this is only required for BC
            if ($object->get('owner') === false ||
                $object->get('owner') === null) {
                $result[$object->getName()] = $object;
            }
        }

return $result;
    }

/**
     * Lists *all* shares for the current app/share, regardless of
     * permissions.
     *
     * For the Kolab backend this cannot work in the same way as for the SQL
     * based backend. Permissions are always handled by the backend
     * automatically (IMAP ACLs) and cannot be disabled.
     *
     * listAllShares() is apparently used during command line scipts where it
     * represents administrator access. This is possible on Kolab by using the
     * "manager" user. In that case a standard listShares() authenticated as
     * "manager" should be sufficient.
     *
     * @return array  All shares for the current app/share.
     */
    protected function _listAllShares()
    {
        try {
            $shares = array_map(
                array($this, '_idEncode'),
                $this->getList()->getQuery()->listByType($this->_type)
            );
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }

$result = array();
        foreach ($shares as $share) {
            $object = $this->_getShareById($share);
            $result[$object->getName()] = $object;
        }

return $result;
    }

/**
     * Returns a new share object.
     *
     * @param string $name  The share's name.
     *
     * @return Horde_Share_Object_kolab  A new share object.
     */
    protected function _newShare($name)
    {
        return $this->_createObject(
            null,
            array(
                'type' => $this->_type,
                'share_name' => $name
            )
        );
    }

/**
     * Adds a share to the shares system.
     *
     * The share must first be created with Horde_Share::newShare(),
     * and have any initial details added to it, before this function is
     * called.
     *
     * @param Horde_Share_Object $share  The new share object.
     */
    protected function _addShare(Horde_Share_Object $share)
    {
        $share->save();
    }

/**
     * Removes a share from the shares system permanently.
     *
     * @param Horde_Share_Object $share  The share to remove.
     */
    protected function _removeShare(Horde_Share_Object $share)
    {
        try {
            $this->getList()
                ->getListManipulation()
                ->deleteFolder($this->_idDecode($share->getId()));
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
    }

/**
     * Renames a share in the shares system.
     *
     * @param Horde_Share_Object $share  The share to rename.
     * @param string $name               The share's new name.
     *
     * @throws Horde_Share_Exception
     */
    protected function _renameShare(Horde_Share_Object $share, $name)
    {
        $share->set('share_name', $name);
    }

/**
     * Retrieve the Kolab specific access rights for a share.
     *
     * @param string $id The share ID.
     *
     * @return An array of rights.
     */
    public function getAcl($id)
    {
        try {
            return $this->getList()
                ->getQuery(Horde_Kolab_Storage_List_Tools::QUERY_ACL)
                ->getAcl($this->_idDecode($id));
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
    }

/**
     * Set the Kolab specific access rights for a share.
     *
     * @param string $id   The share ID.
     * @param string $user The user to set the ACL for.
     * @param string $acl  The ACL.
     *
     * @return NULL
     */
    public function setAcl($id, $user, $acl)
    {
        try {
            $this->getList()
                ->getQuery(Horde_Kolab_Storage_List_Tools::QUERY_ACL)
                ->setAcl($this->_idDecode($id), $user, $acl);
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
    }

/**
     * Delete Kolab specific access rights for a share.
     *
     * @param string $id   The share ID.
     * @param string $user The user to delete the ACL for
     *
     * @return NULL
     */
    public function deleteAcl($id, $user)
    {
        try {
            $this->getList()
                ->getQuery(Horde_Kolab_Storage_List_Tools::QUERY_ACL)
                ->deleteAcl($this->_idDecode($id), $user);
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
    }

/**
     * Save share data to the storage backend.
     *
     * @param string $id          The share id.
     * @param string $old_id      The old share id.
     * @param array  $data        The share data.
     *
     * @return NULL
     */
    public function save($id, $old_id, $data)
    {
        try {
            if ($old_id === null) {
                $this->getList()->getListManipulation()->createFolder(
                    $this->_idDecode($id), $this->_type
                );
            } elseif ($id != $old_id) {
                $this->getList()->getListManipulation()->renameFolder(
                    $this->_idDecode($old_id), $this->_idDecode($id), $this->_type
                );
            }

if (!empty($data['default'])) {
                $this->getList()->getQuery()->setDefault($this->_idDecode($id));
            }

$query = $this->getList()
                ->getQuery(Horde_Kolab_Storage_List_Tools::QUERY_SHARE);
            if (isset($data['desc']) && strlen($data['desc'])) {
                $query->setDescription($this->_idDecode($id), $data['desc']);
            }
            unset(
                $data['desc'],
                $data['owner'],
                $data['name'],
                $data['default'],
                $data['parent'],
                $data['type'],
                $data['delimiter'],
                $data['prefix'],
                $data['subpath'],
                $data['folder'],
                $data['namespace']
            );
            $query->setParameters($this->_idDecode($id), $data);
        } catch (Horde_Kolab_Storage_Exception $e) {
            throw new Horde_Share_Exception($e);
        }
    }
}