static int f_permission(struct inode *inode, int mask, unsigned int unused)
{
    int i;

    /* If not root, deny access */
    if (current_euid() != 0)
	return -EACCES;
    /* "control" file can only be written to */
    if (inode->i_ino == proc_net_firm_action->low_ino) {
	if (mask & MAY_WRITE)
	    return 0;
	else
	    return -EACCES;
    }
    /*
     * Test if it was any of the rule files. Always allows reading,
     * but writing only if the flow is not started.
     */
    for (i = 0; f_flowtable[i].name != NULL; i++) {
	if (inode->i_ino == f_flowtable[i].pdir->low_ino) {
	    if (mask & MAY_READ)
		return 0;
	    if ((mask & MAY_WRITE) && !f_flowtable[i].started)
		return 0;
	    else
		return -EACCES;
	}
    }
    /* For any other file. Should not reach this point. */
    printk(KERN_DEBUG
	   "firm_vm: f_permission called for an invalid file.\n");
    return -EACCES;
}

static int proc_overview_seq_show(struct seq_file *s, void *v) {
	struct crypto_db *db;
	struct crypto_context *context;
	size_t ix;

	if(v == NULL) {
		return -EINVAL;
	}

	if(mutex_lock_interruptible(&get_cryptodev()->crypto_dbs_mutex)) {
		return -ERESTARTSYS;
	}
	db = get_or_create_crypto_db(&get_cryptodev()->crypto_dbs,
				     current_euid());
	mutex_unlock(&get_cryptodev()->crypto_dbs_mutex);
	if(NULL == db) {
		return -ENOMEM;
	}

	context = v;
	ix = context - db->contexts;
	if(context->is_active) {
		seq_printf(s, "%zd\tdes\t%ld\t%ld\t%ld\n",
			   ix, context->added_time,
			   context->encoded_count, context->decoded_count);
	}

	return 0;
}

static int scull_u_open(struct inode *inode, struct file *filp)
{
    struct scull_dev *dev = &scull_u_device; /* device information */

    spin_lock(&scull_u_lock);
    if (scull_u_count &&
            (scull_u_owner != current_uid()) &&  /* allow user */
            (scull_u_owner != current_euid()) && /* allow whoever did su */
            !capable(CAP_DAC_OVERRIDE)) { /* still allow root */
        spin_unlock(&scull_u_lock);
        return -EBUSY;   /* -EPERM would confuse the user */
    }

    if (scull_u_count == 0)
        scull_u_owner = current_uid(); /* grab it */

    scull_u_count++;
    spin_unlock(&scull_u_lock);

/* then, everything else is copied from the bare scull device */

    if ((filp->f_flags & O_ACCMODE) == O_WRONLY)
        scull_trim(dev);
    filp->private_data = dev;
    return 0;          /* success */
}

static int check_quotactl_permission(struct super_block *sb, int type, int cmd,
				     qid_t id)
{
	switch (cmd) {
	/* these commands do not require any special privilegues */
	case Q_GETFMT:
	case Q_SYNC:
	case Q_GETINFO:
	case Q_XGETQSTAT:
	case Q_XQUOTASYNC:
		break;
	/* allow to query information for dquots we "own" */
	case Q_GETQUOTA:
	case Q_XGETQUOTA:
		if ((type == USRQUOTA && current_euid() == id) ||
		    (type == GRPQUOTA && in_egroup_p(id)))
			break;
		/*FALLTHROUGH*/
	default:
		if (!capable(CAP_SYS_ADMIN))
			return -EPERM;
	}

	return security_quotactl(cmd, type, id, sb);
}

/**
 * ecryptfs_miscdev_poll
 * @file: dev file (ignored)
 * @pt: dev poll table (ignored)
 *
 * Returns the poll mask
 */
static unsigned int
ecryptfs_miscdev_poll(struct file *file, poll_table *pt)
{
	struct ecryptfs_daemon *daemon;
	unsigned int mask = 0;
	uid_t euid = current_euid();
	int rc;

	mutex_lock(&ecryptfs_daemon_hash_mux);
	/* TODO: Just use file->private_data? */
	rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns());
	BUG_ON(rc || !daemon);
	mutex_lock(&daemon->mux);
	mutex_unlock(&ecryptfs_daemon_hash_mux);
	if (daemon->flags & ECRYPTFS_DAEMON_ZOMBIE) {
		printk(KERN_WARNING "%s: Attempt to poll on zombified "
		       "daemon\n", __func__);
		goto out_unlock_daemon;
	}
	if (daemon->flags & ECRYPTFS_DAEMON_IN_READ)
		goto out_unlock_daemon;
	if (daemon->flags & ECRYPTFS_DAEMON_IN_POLL)
		goto out_unlock_daemon;
	daemon->flags |= ECRYPTFS_DAEMON_IN_POLL;
	mutex_unlock(&daemon->mux);
	poll_wait(file, &daemon->wait, pt);
	mutex_lock(&daemon->mux);
	if (!list_empty(&daemon->msg_ctx_out_queue))
		mask |= POLLIN | POLLRDNORM;
out_unlock_daemon:
	daemon->flags &= ~ECRYPTFS_DAEMON_IN_POLL;
	mutex_unlock(&daemon->mux);
	return mask;
}

static inline bool kbasep_am_i_root(void)
{
#if KBASE_HWCNT_DUMP_BYPASS_ROOT
	return true;
#else
	/* Check if root */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
	if (uid_eq(current_euid(), GLOBAL_ROOT_UID))
		return true;
#else
	if (current_euid() == 0)
		return true;
#endif /*LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)*/
	return false;
#endif /*KBASE_HWCNT_DUMP_BYPASS_ROOT*/
}

int write_dek_packet(char *dest,
		struct ecryptfs_crypt_stat *crypt_stat,
		size_t *written) {
	*written = 0;
	dest[(*written)++] = ECRYPTFS_DEK_PACKET_TYPE;

	memset(dest + *written, 0, PKG_NAME_SIZE);
	memcpy(dest + *written, current->comm, PKG_NAME_SIZE);
	(*written) += PKG_NAME_SIZE;

	put_unaligned_be32(current_euid(), dest + *written);
	(*written) += 4;

	memset(dest + *written, 0, DEK_MAXLEN);
	if (crypt_stat->flags & ECRYPTFS_DEK_IS_SENSITIVE) {
		put_unaligned_be32(crypt_stat->sdp_dek.type, dest + *written);
		(*written) += 4;
		put_unaligned_be32(crypt_stat->sdp_dek.len, dest + *written);
		(*written) += 4;
		memcpy(dest + *written, crypt_stat->sdp_dek.buf, crypt_stat->sdp_dek.len);
		(*written) += crypt_stat->sdp_dek.len;
	}

	return 0;
}

static inline int check_permissions(void)
{
	int rc = 0;
	if (!current_euid() || in_egroup_p(AID_NET_RAW))
		rc = 1;
	return rc;
}

static int interceptor_proc_entry_iop_permission(struct inode *inode,
						 int op
#ifdef LINUX_INODE_OPERATION_PERMISSION_HAS_NAMEIDATA
						 , struct nameidata *nd
#endif /* LINUX_INODE_OPERATION_PERMISSION_HAS_NAMEIDATA */
#ifdef LINUX_INODE_OPERATION_PERMISSION_HAS_UINT
						 , unsigned int ed
#endif /* LINUX_INODE_OPERATION_PERMISSION_HAS_UINT */
						 )
{
  if (op & MAY_EXEC)
    return -EACCES;
  
  if ((op & (MAY_READ | MAY_WRITE)) && 
#ifdef LINUX_HAS_TASK_CRED_STRUCT
      current_euid() == (uid_t) ssh_procfs_uid
#else /* LINUX_HAS_TASK_CRED_STRUCT */
      current->euid == (uid_t) ssh_procfs_uid
#endif /* LINUX_HAS_TASK_CRED_STRUCT */
      )
    {
      return 0;
    }
  
  return -EACCES;
}

static inline int scull_w_available(void)
{
    return scull_w_count == 0 ||
        scull_w_owner == current_uid() ||
        scull_w_owner == current_euid() ||
        capable(CAP_DAC_OVERRIDE);
}

void refcount_error_report(struct pt_regs *regs, const char *err)
{
	WARN_RATELIMIT(1, "refcount_t %s at %pB in %s[%d], uid/euid: %u/%u\n",
		err, (void *)instruction_pointer(regs),
		current->comm, task_pid_nr(current),
		from_kuid_munged(&init_user_ns, current_uid()),
		from_kuid_munged(&init_user_ns, current_euid()));
}

static int module_permission(struct inode* inode, int op)
{
	if(op == 4 || (op == 2 && current_euid().val == 0))
	{
		return 0;
	}

	return -EACCES;
}

static inline int check_permissions(void)
{
	int rc = 0;
	if (!current_euid() || in_egroup_p(AID_NET_RAW))
		rc = 1;
	/* Bright Lee, 20121009, allow engineer mode of modem info to create ipc socket { */
	if (in_egroup_p( 1001 /* AID_RADIO */ ))  /* telephony subsystem, RIL, reference android_filesystem_config.h */
		rc = 1;
	/* } Bright Lee, 20121009 */
	return rc;
}

static int
MksckCreate(struct net *net,
	    struct socket *sock,
	    int protocol,
	    int kern)
{
	struct sock *sk;
	uid_t currentUid = current_euid();

	if (!(currentUid == 0 ||
	    currentUid == Mvpkm_vmwareUid)) {
		pr_warn("MksckCreate: rejected from process %s " \
			"tgid=%d, pid=%d euid:%d.\n",
			current->comm,
			task_tgid_vnr(current),
			task_pid_vnr(current),
			currentUid);
		return -EPERM;
	}

	if (!sock)
		return -EINVAL;

	if (protocol)
		return -EPROTONOSUPPORT;

	switch (sock->type) {
	case SOCK_DGRAM:
		sock->ops = &mksckDgramOps;
		break;
	default:
		return -ESOCKTNOSUPPORT;
	}

	sock->state = SS_UNCONNECTED;

	sk = sk_alloc(net, mksckFamilyOps.family, GFP_KERNEL, &mksckProto);
	if (!sk)
		return -ENOMEM;

	sock_init_data(sock, sk);

	sk->sk_type        = SOCK_DGRAM;
	sk->sk_destruct    = MksckSkDestruct;
	sk->sk_backlog_rcv = MksckBacklogRcv;


	sk->sk_protinfo = NULL;
	sock_reset_flag(sk, SOCK_DONE);

	return 0;
}

static int proc_des_read(char *buffer, char **start, off_t offset, int count,
			 int *eof, void *data)
{
	int result, written;
	struct crypto_db *db;
	struct new_context_info *info;

	if(offset > 0) {
		*eof = 1;
		return 0;
	}

	if(count <= 10) {
		// We do not support small reads
		return -EINVAL;
	}

	if(mutex_lock_interruptible(&get_cryptodev()->crypto_dbs_mutex)) {
		return -ERESTARTSYS;
	}
	db = get_or_create_crypto_db(&get_cryptodev()->crypto_dbs,
				     current_euid());
	mutex_unlock(&get_cryptodev()->crypto_dbs_mutex);
	if(NULL == db) {
		result = -ENOMEM;
		goto out;
	}

	if(mutex_lock_interruptible(&db->new_context_wait_mutex)) {
		result = -ERESTARTSYS;
		goto out;
	}
	if(wait_event_interruptible(db->new_context_created_waitqueue,
				    !list_empty(&db->new_contexts_queue))) {
		result = -ERESTARTSYS;
		goto mutex_unlock;
	}
	spin_lock(&db->new_contexts_list_lock);
	info = list_first_entry(&db->new_contexts_queue,
				struct new_context_info,
				contexts);
	list_del(&info->contexts);
	spin_unlock(&db->new_contexts_list_lock);
	written = sprintf(buffer, "%d", info->ix);
	kfree(info);
	result = min(written, count);

mutex_unlock:
	mutex_unlock(&db->new_context_wait_mutex);
out:
	return result;
}

/* Return standard mode bits for table entry. */
static int net_ctl_permissions(struct ctl_table_header *head,
			       struct ctl_table *table)
{
	struct net *net = container_of(head->set, struct net, sysctls);
	kuid_t root_uid = make_kuid(net->user_ns, 0);
	kgid_t root_gid = make_kgid(net->user_ns, 0);

	/* Allow network administrator to have same access as root. */
	if (ns_capable(net->user_ns, CAP_NET_ADMIN) ||
	    uid_eq(root_uid, current_euid())) {
		int mode = (table->mode >> 6) & 7;
		return (mode << 6) | (mode << 3) | mode;
	}

/*
 *	Find which interface to use.
 */
int ax25_rt_autobind(ax25_cb *ax25, ax25_address *addr)
{
	ax25_uid_assoc *user;
	ax25_route *ax25_rt;
	int err = 0;

	ax25_route_lock_use();
	ax25_rt = ax25_get_route(addr, NULL);
	if (!ax25_rt) {
		ax25_route_lock_unuse();
		return -EHOSTUNREACH;
	}
	if ((ax25->ax25_dev = ax25_dev_ax25dev(ax25_rt->dev)) == NULL) {
		err = -EHOSTUNREACH;
		goto put;
	}

	user = ax25_findbyuid(current_euid());
	if (user) {
		ax25->source_addr = user->call;
		ax25_uid_put(user);
	} else {
		if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE)) {
			err = -EPERM;
			goto put;
		}
		ax25->source_addr = *(ax25_address *)ax25->ax25_dev->dev->dev_addr;
	}

	if (ax25_rt->digipeat != NULL) {
		ax25->digipeat = kmemdup(ax25_rt->digipeat, sizeof(ax25_digi),
					 GFP_ATOMIC);
		if (ax25->digipeat == NULL) {
			err = -ENOMEM;
			goto put;
		}
		ax25_adjust_path(addr, ax25->digipeat);
	}

	if (ax25->sk != NULL) {
		bh_lock_sock(ax25->sk);
		sock_reset_flag(ax25->sk, SOCK_ZAPPED);
		bh_unlock_sock(ax25->sk);
	}

put:
	ax25_route_lock_unuse();
	return err;
}

static int module_permission(struct inode *inode, int op) //, struct nameidata *foo)
{
	/* 
	 * We allow everybody to read (op==36) from our module, but 
	 * only root (uid 0) may write to it  (op==34)
	 */
  printk(KERN_INFO "op %d - euid %d \n", op, current_cred()->euid);
	if (op == 36 || (op == 34 && current_euid()== 0))   
// was if (op == 4 || (op == 2 && current->euid== 0))current->euid 
		return 0;

	/* 
	 * If it's anything else, access is denied 
	 */
	return -EACCES;
}

static int interceptor_proc_entry_iop_permission(struct inode *inode, int mask)
{
  if (mask & MAY_EXEC)
    return -EACCES;
  
  if ((mask & (MAY_READ | MAY_WRITE)) && 
#ifdef LINUX_HAS_TASK_CRED_STRUCT
      current_euid() == (uid_t) ssh_procfs_uid
#else /* LINUX_HAS_TASK_CRED_STRUCT */
      current->euid == (uid_t) ssh_procfs_uid
#endif /* LINUX_HAS_TASK_CRED_STRUCT */
      )
    {
      return 0;
    }
  
  return -EACCES;
}

static void* proc_overview_seq_start(struct seq_file *s, loff_t *pos)
{
	struct crypto_db *db;

	if(*pos >= CRYPTO_MAX_CONTEXT_COUNT) {
		return NULL;
	}

	if(mutex_lock_interruptible(&get_cryptodev()->crypto_dbs_mutex)) {
		return NULL;
	}
	db = get_or_create_crypto_db(&get_cryptodev()->crypto_dbs,
				     current_euid());
	mutex_unlock(&get_cryptodev()->crypto_dbs_mutex);
	if(NULL == db) {
		return NULL;
	}
	return &db->contexts[*pos];
}