/*
   * AppArmor security module
   *
   * This file contains AppArmor policy manipulation functions
   *
   * Copyright (C) 1998-2008 Novell/SUSE
   * Copyright 2009-2017 Canonical Ltd.
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License as
   * published by the Free Software Foundation, version 2 of the
   * License.
   *
   * AppArmor policy namespaces, allow for different sets of policies
   * to be loaded for tasks within the namespace.
   */
  
  #include <linux/list.h>
  #include <linux/mutex.h>
  #include <linux/slab.h>
  #include <linux/string.h>
  
  #include "include/apparmor.h"

  #include "include/cred.h"

  #include "include/policy_ns.h"

  #include "include/label.h"

  #include "include/policy.h"
  
  /* root profile namespace */

  struct aa_ns *root_ns;

  const char *aa_hidden_ns_name = "---";
  
  /**
   * aa_ns_visible - test if @view is visible from @curr
   * @curr: namespace to treat as the parent (NOT NULL)
   * @view: namespace to test if visible from @curr (NOT NULL)

   * @subns: whether view of a subns is allowed

   *
   * Returns: true if @view is visible from @curr else false
   */

  bool aa_ns_visible(struct aa_ns *curr, struct aa_ns *view, bool subns)

  {
  	if (curr == view)
  		return true;

  	if (!subns)
  		return false;

  	for ( ; view; view = view->parent) {
  		if (view->parent == curr)
  			return true;
  	}

  	return false;
  }
  
  /**
   * aa_na_name - Find the ns name to display for @view from @curr
   * @curr - current namespace (NOT NULL)
   * @view - namespace attempting to view (NOT NULL)

   * @subns - are subns visible

   *
   * Returns: name of @view visible from @curr
   */

  const char *aa_ns_name(struct aa_ns *curr, struct aa_ns *view, bool subns)

  {
  	/* if view == curr then the namespace name isn't displayed */
  	if (curr == view)
  		return "";

  	if (aa_ns_visible(curr, view, subns)) {

  		/* at this point if a ns is visible it is in a view ns
  		 * thus the curr ns.hname is a prefix of its name.
  		 * Only output the virtualized portion of the name
  		 * Add + 2 to skip over // separating curr hname prefix
  		 * from the visible tail of the views hname
  		 */
  		return view->base.hname + strlen(curr->base.hname) + 2;
  	}
  
  	return aa_hidden_ns_name;
  }
  
  /**

   * alloc_ns - allocate, initialize and return a new namespace

   * @prefix: parent namespace name (MAYBE NULL)
   * @name: a preallocated name  (NOT NULL)
   *
   * Returns: refcounted namespace or NULL on failure.
   */

  static struct aa_ns *alloc_ns(const char *prefix, const char *name)

  {

  	struct aa_ns *ns;

  
  	ns = kzalloc(sizeof(*ns), GFP_KERNEL);
  	AA_DEBUG("%s(%p)
  ", __func__, ns);
  	if (!ns)
  		return NULL;

  	if (!aa_policy_init(&ns->base, prefix, name, GFP_KERNEL))

  		goto fail_ns;
  
  	INIT_LIST_HEAD(&ns->sub_ns);

  	INIT_LIST_HEAD(&ns->rawdata_list);

  	mutex_init(&ns->lock);

  	init_waitqueue_head(&ns->wait);

  	/* released by aa_free_ns() */

  	ns->unconfined = aa_alloc_profile("unconfined", NULL, GFP_KERNEL);

  	if (!ns->unconfined)
  		goto fail_unconfined;

  	ns->unconfined->label.flags |= FLAG_IX_ON_NAME_ERROR |
  		FLAG_IMMUTIBLE | FLAG_NS_COUNT | FLAG_UNCONFINED;

  	ns->unconfined->mode = APPARMOR_UNCONFINED;

  	ns->unconfined->file.dfa = aa_get_dfa(nulldfa);
  	ns->unconfined->policy.dfa = aa_get_dfa(nulldfa);

  
  	/* ns and ns->unconfined share ns->unconfined refcount */
  	ns->unconfined->ns = ns;
  
  	atomic_set(&ns->uniq_null, 0);

  	aa_labelset_init(&ns->labels);

  	return ns;
  
  fail_unconfined:
  	kzfree(ns->base.hname);
  fail_ns:
  	kzfree(ns);
  	return NULL;
  }
  
  /**

   * aa_free_ns - free a profile namespace

   * @ns: the namespace to free  (MAYBE NULL)
   *
   * Requires: All references to the namespace must have been put, if the
   *           namespace was referenced by a profile confining a task,
   */

  void aa_free_ns(struct aa_ns *ns)

  {
  	if (!ns)
  		return;
  
  	aa_policy_destroy(&ns->base);

  	aa_labelset_destroy(&ns->labels);

  	aa_put_ns(ns->parent);

  
  	ns->unconfined->ns = NULL;
  	aa_free_profile(ns->unconfined);
  	kzfree(ns);
  }
  
  /**

   * aa_findn_ns  -  look up a profile namespace on the namespace list

   * @root: namespace to search in  (NOT NULL)
   * @name: name of namespace to find  (NOT NULL)

   * @n: length of @name

   *
   * Returns: a refcounted namespace on the list, or NULL if no namespace
   *          called @name exists.
   *
   * refcount released by caller
   */

  struct aa_ns *aa_findn_ns(struct aa_ns *root, const char *name, size_t n)

  {

  	struct aa_ns *ns = NULL;

  
  	rcu_read_lock();

  	ns = aa_get_ns(__aa_findn_ns(&root->sub_ns, name, n));

  	rcu_read_unlock();
  
  	return ns;
  }
  
  /**

   * aa_find_ns  -  look up a profile namespace on the namespace list
   * @root: namespace to search in  (NOT NULL)
   * @name: name of namespace to find  (NOT NULL)
   *
   * Returns: a refcounted namespace on the list, or NULL if no namespace
   *          called @name exists.
   *
   * refcount released by caller
   */
  struct aa_ns *aa_find_ns(struct aa_ns *root, const char *name)
  {
  	return aa_findn_ns(root, name, strlen(name));
  }

  /**
   * __aa_lookupn_ns - lookup the namespace matching @hname
   * @base: base list to start looking up profile name from  (NOT NULL)
   * @hname: hierarchical ns name  (NOT NULL)
   * @n: length of @hname
   *
   * Requires: rcu_read_lock be held
   *
   * Returns: unrefcounted ns pointer or NULL if not found
   *
   * Do a relative name lookup, recursing through profile tree.
   */
  struct aa_ns *__aa_lookupn_ns(struct aa_ns *view, const char *hname, size_t n)
  {
  	struct aa_ns *ns = view;
  	const char *split;
  
  	for (split = strnstr(hname, "//", n); split;
  	     split = strnstr(hname, "//", n)) {
  		ns = __aa_findn_ns(&ns->sub_ns, hname, split - hname);
  		if (!ns)
  			return NULL;
  
  		n -= split + 2 - hname;
  		hname = split + 2;
  	}
  
  	if (n)
  		return __aa_findn_ns(&ns->sub_ns, hname, n);
  	return NULL;
  }
  
  /**
   * aa_lookupn_ns  -  look up a policy namespace relative to @view
   * @view: namespace to search in  (NOT NULL)
   * @name: name of namespace to find  (NOT NULL)
   * @n: length of @name
   *
   * Returns: a refcounted namespace on the list, or NULL if no namespace
   *          called @name exists.
   *
   * refcount released by caller
   */
  struct aa_ns *aa_lookupn_ns(struct aa_ns *view, const char *name, size_t n)
  {
  	struct aa_ns *ns = NULL;
  
  	rcu_read_lock();
  	ns = aa_get_ns(__aa_lookupn_ns(view, name, n));
  	rcu_read_unlock();
  
  	return ns;
  }

  static struct aa_ns *__aa_create_ns(struct aa_ns *parent, const char *name,
  				    struct dentry *dir)
  {
  	struct aa_ns *ns;
  	int error;
  
  	AA_BUG(!parent);
  	AA_BUG(!name);
  	AA_BUG(!mutex_is_locked(&parent->lock));
  
  	ns = alloc_ns(parent->base.hname, name);
  	if (!ns)

  		return ERR_PTR(-ENOMEM);

  	ns->level = parent->level + 1;
  	mutex_lock_nested(&ns->lock, ns->level);

  	error = __aafs_ns_mkdir(ns, ns_subns_dir(parent), name, dir);

  	if (error) {
  		AA_ERROR("Failed to create interface for ns %s
  ",
  			 ns->base.name);
  		mutex_unlock(&ns->lock);
  		aa_free_ns(ns);
  		return ERR_PTR(error);
  	}
  	ns->parent = aa_get_ns(parent);
  	list_add_rcu(&ns->base.list, &parent->sub_ns);
  	/* add list ref */
  	aa_get_ns(ns);
  	mutex_unlock(&ns->lock);
  
  	return ns;
  }

  /**

   * aa_create_ns - create an ns, fail if it already exists
   * @parent: the parent of the namespace being created
   * @name: the name of the namespace
   * @dir: if not null the dir to put the ns entries in

   *

   * Returns: the a refcounted ns that has been add or an ERR_PTR

   */

  struct aa_ns *__aa_find_or_create_ns(struct aa_ns *parent, const char *name,
  				     struct dentry *dir)

  {

  	struct aa_ns *ns;

  	AA_BUG(!mutex_is_locked(&parent->lock));

  	/* try and find the specified ns */
  	/* released by caller */
  	ns = aa_get_ns(__aa_find_ns(&parent->sub_ns, name));
  	if (!ns)
  		ns = __aa_create_ns(parent, name, dir);
  	else
  		ns = ERR_PTR(-EEXIST);

  	/* return ref */
  	return ns;
  }

  /**
   * aa_prepare_ns - find an existing or create a new namespace of @name
   * @parent: ns to treat as parent
   * @name: the namespace to find or add  (NOT NULL)
   *
   * Returns: refcounted namespace or PTR_ERR if failed to create one
   */
  struct aa_ns *aa_prepare_ns(struct aa_ns *parent, const char *name)
  {
  	struct aa_ns *ns;

  	mutex_lock_nested(&parent->lock, parent->level);

  	/* try and find the specified ns and if it doesn't exist create it */
  	/* released by caller */

  	ns = aa_get_ns(__aa_find_ns(&parent->sub_ns, name));
  	if (!ns)
  		ns = __aa_create_ns(parent, name, NULL);
  	mutex_unlock(&parent->lock);

  
  	/* return ref */
  	return ns;
  }
  
  static void __ns_list_release(struct list_head *head);
  
  /**

   * destroy_ns - remove everything contained by @ns

   * @ns: namespace to have it contents removed  (NOT NULL)

   */

  static void destroy_ns(struct aa_ns *ns)

  {
  	if (!ns)
  		return;

  	mutex_lock_nested(&ns->lock, ns->level);

  	/* release all profiles in this namespace */
  	__aa_profile_list_release(&ns->base.profiles);
  
  	/* release all sub namespaces */
  	__ns_list_release(&ns->sub_ns);

  	if (ns->parent) {
  		unsigned long flags;
  
  		write_lock_irqsave(&ns->labels.lock, flags);
  		__aa_proxy_redirect(ns_unconfined(ns),
  				    ns_unconfined(ns->parent));
  		write_unlock_irqrestore(&ns->labels.lock, flags);
  	}

  	__aafs_ns_rmdir(ns);

  	mutex_unlock(&ns->lock);
  }
  
  /**

   * __aa_remove_ns - remove a namespace and all its children

   * @ns: namespace to be removed  (NOT NULL)
   *
   * Requires: ns->parent->lock be held and ns removed from parent.
   */

  void __aa_remove_ns(struct aa_ns *ns)

  {
  	/* remove ns from namespace list */
  	list_del_rcu(&ns->base.list);

  	destroy_ns(ns);
  	aa_put_ns(ns);

  }
  
  /**
   * __ns_list_release - remove all profile namespaces on the list put refs
   * @head: list of profile namespaces  (NOT NULL)
   *
   * Requires: namespace lock be held
   */
  static void __ns_list_release(struct list_head *head)
  {

  	struct aa_ns *ns, *tmp;

  
  	list_for_each_entry_safe(ns, tmp, head, base.list)

  		__aa_remove_ns(ns);

  
  }
  
  /**

   * aa_alloc_root_ns - allocate the root profile namespace

   *
   * Returns: %0 on success else error
   *
   */
  int __init aa_alloc_root_ns(void)
  {
  	/* released by aa_free_root_ns - used as list ref*/

  	root_ns = alloc_ns(NULL, "root");

  	if (!root_ns)
  		return -ENOMEM;
  
  	return 0;
  }
  
   /**
    * aa_free_root_ns - free the root profile namespace
    */
  void __init aa_free_root_ns(void)
  {

  	 struct aa_ns *ns = root_ns;

  
  	 root_ns = NULL;

  	 destroy_ns(ns);
  	 aa_put_ns(ns);

  }