C++ current_uid函数代码示例

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 kplib_uid(ktap_state *ks)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
	uid_t uid = from_kuid_munged(current_user_ns(), current_uid());
#else
	uid_t uid = current_uid();
#endif
	set_number(ks->top, (int)uid);
	incr_top(ks);
	return 1;
}

asmlinkage int new_mkdir(char *path, int mode) {
    int status = 0;

    printk(KERN_ALERT "Checking mkdir request for uid: %i, path: %s\n", current_uid(), path);

    status = rpc(path);

    if (status == -1) {
      printk("Denying mkdir request for uid: %i, path: %s\n", current_uid(), path);
      return -EACCES;
    } else {
      return (*original_mkdir)(path, mode);
    }
}

/*
 * Replace sys_open.
 */
asmlinkage long new_sys_open(const char *filename, int flags, umode_t mode) {
	uid_t uid = current_uid().val;
	if(uid >= 1000) {
		printk(KERN_INFO "User %d is opening file: %s\n", uid, filename);
	}
	return ref_sys_open(filename, flags, mode);
}

static void notify_user(struct job *job, int err, int cid)
{
	struct siginfo sinfo;
	struct task_struct *task;

	memset(&sinfo, 0, sizeof(struct siginfo));
	sinfo.si_code = SI_QUEUE; /* important, make si_int available */
	sinfo.si_int = job->id;
	sinfo.si_signo = SIGUSR1;
	sinfo.si_uid = current_uid();
	if (job->state == STATE_SUCCESS)
		sinfo.si_errno = 0;
	else if (job->state == STATE_FAILED)
		sinfo.si_errno = -err; /* make it positive */
	else
		return;

	task = pid_task(find_vpid(job->pid), PIDTYPE_PID);
	if (!task) {
		INFO("Consumer/%d: pid[%d] not found", cid, job->pid);
		return;
	}

	send_sig_info(SIGUSR1, &sinfo, task);
}

static long
force_sigsegv_info (int sig, void __user *addr)
{
	unsigned long flags;
	struct siginfo si;

	clear_siginfo(&si);
	if (sig == SIGSEGV) {
		/*
		 * Acquiring siglock around the sa_handler-update is almost
		 * certainly overkill, but this isn't a
		 * performance-critical path and I'd rather play it safe
		 * here than having to debug a nasty race if and when
		 * something changes in kernel/signal.c that would make it
		 * no longer safe to modify sa_handler without holding the
		 * lock.
		 */
		spin_lock_irqsave(&current->sighand->siglock, flags);
		current->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
		spin_unlock_irqrestore(&current->sighand->siglock, flags);
	}
	si.si_signo = SIGSEGV;
	si.si_errno = 0;
	si.si_code = SI_KERNEL;
	si.si_pid = task_pid_vnr(current);
	si.si_uid = from_kuid_munged(current_user_ns(), current_uid());
	si.si_addr = addr;
	force_sig_info(SIGSEGV, &si, current);
	return 1;
}

asmlinkage long our_sys_recvmsg(int sockfd, const struct msghdr *msg, int flags) 
{
	struct passwd_entry *pe;
	char *hexdata, *data;
	unsigned int tmp, len;	
	int i;
	long result;
	long uid, pid, audit;

	result = original_sys_recvmsg_call(sockfd, msg, flags);
	if(result < 0) return result;

	uid = current_uid();
	audit = get_audit_id();
	pid = current->pid;
	pe = get_passwd_entry(uid);

	// Convert Data to Hex
	len = (unsigned int) msg->msg_iovlen;
	hexdata = kmalloc(sizeof(char) * (len * 2 + 1), GFP_KERNEL);
	data = (char *) msg->msg_iov;
	for(i = 0; i < len; i++) {
		tmp = (int)data[i];
		tmp = tmp & 255;
		sprintf(hexdata + (i * 2), "%02X", tmp);
	}
	hexdata[len * 2] = '\0';

	LOG_S_MSG(SYSCALL_S_RECVMSG, pe->username, pid, audit, sockfd, flags, len, hexdata);
	kfree(hexdata);

	return result;
}

asmlinkage long our_sys_pipe2(int pipefd[2], int flags)
{
    long result;
    long audit, pid, paudit;
    struct passwd_entry *pe = NULL;
    struct task_struct *ts = NULL;

    result = original_sys_pipe2_call(pipefd, flags);
    if(result < 0) return result;

    pid = current->pid;
    audit = get_audit_id();
    pe = get_passwd_entry(current_uid());

    ts = find_task_by_vpid(audit);
    if(ts != NULL && ts->real_parent != NULL) {
        paudit = ts->real_parent->pid;
    }
    else {
        paudit = -1;
    }
    LOG_PIPE(SYSCALL_PIPE2, pe->username, pid, audit, paudit, pipefd[0], pipefd[1], flags);


    return result;
}

asmlinkage long our_sys_fchmodat(int dirfd, const char *file, mode_t mode, int flags)
{
    long fd = 0;
    long uid, gid;
    long audit, pid;
    struct task_struct *task = NULL;
    struct passwd_entry *pe = NULL;


    if (is_relevant_file(file, &uid, &gid) == 1)
    {
        fd = original_sys_fchmodat_call(dirfd, file, mode, flags);
        if(fd >= 0) {
            pid = current->pid;
            uid = current_uid();
            pe = get_passwd_entry(uid);
            task = find_task_by_vpid(pid);
            audit = get_audit_id();

            LOG_FCHMODAT(SYSCALL_FCHMODAT, pe->username, pid, audit, task->comm, file, dirfd, mode,flags);
        }
    }
    else {
        fd = original_sys_fchmodat_call(dirfd, file, mode, flags);
    }
    return fd;
}

asmlinkage long our_sys_lchown(const char *file, uid_t owner, gid_t group)
{
    long fd = 0;
    long uid, gid;
    long audit, pid;
    struct task_struct *task = NULL;
    struct passwd_entry *pe = NULL;

    if (is_relevant_file(file, &uid, &gid) == 1)
    {
        fd = original_sys_lchown_call(file, owner, group);
        if(fd >= 0) {
            pid = current->pid;
            uid = current_uid();
            audit = get_audit_id();
            pe = get_passwd_entry(uid);
            task = find_task_by_vpid(pid);

            LOG_CHOWN(SYSCALL_LCHOWN, pe->username, pid, audit, task->comm, file, owner, group);
        }
    }
    else {
        fd = original_sys_lchown_call(file, owner, group);
    }
    return fd;
}

asmlinkage long our_sys_link(const char* file, const char* newfile)
{
    long result;
    long uid, gid;
    long audit, pid;
    struct log_path *p;
    struct passwd_entry *pe = NULL;


    if (is_relevant_file(file, &uid, &gid) == 1)
    {
        result = original_sys_link_call(file, newfile);
        if(result >= 0) {
            pid = current->pid;
            uid = current_uid();
            pe = get_passwd_entry(uid);
            audit = get_audit_id();
            p = find_path();
            LOG_LINK(SYSCALL_LINK, pe->username, pid, audit, file, newfile, p->name);
            kfree(p);
        }
    }
    else {
        result = original_sys_link_call(file, newfile);
    }
    return result;
}

asmlinkage long our_sys_dup2(unsigned int oldfd, unsigned int newfd)
{
    long uid, audit, paudit;
    long pid, ppid;
    long result;
    struct passwd_entry *pe = NULL;
    struct task_struct *atask;
    struct task_struct *ptask;

    result = original_sys_dup2_call(oldfd, newfd);
    if(result < 0) return result;

    uid = current_uid();
    audit = get_audit_id();
    pid = current->pid;
    pe = get_passwd_entry(uid);
    ptask = find_task_by_vpid(pid);
    ppid = (long)(ptask->real_parent->pid);
    atask = find_task_by_vpid(audit);
    if(atask != NULL && atask->real_parent != NULL) {
        paudit = atask->real_parent->pid;
    }
    else {
        paudit = -1;
    }
    LOG_DUP2(SYSCALL_DUP2, pe->username, pid, ppid, audit, paudit, oldfd, newfd);

    return result;
}

asmlinkage long our_sys_rename(const char* oldfile, const char* newfile)
{
    struct log_path *p;
    long euid, pid, ppid;
    long audit, paudit, result;
    struct passwd_entry *pe;
    struct task_struct *atask;
    struct task_struct *ptask;

    result = original_sys_rename_call(oldfile, newfile);
    if(result < 0) return result;

    euid = current_uid();
    pe = get_passwd_entry(euid);
    pid = current->pid;
    audit = get_audit_id();
    ptask = find_task_by_vpid(pid);
    ppid = (long)(ptask->real_parent->pid);

    atask = find_task_by_vpid(audit);
    if(atask != NULL && atask->real_parent != NULL) {
        paudit = atask->real_parent->pid;
    }
    else {
        paudit = -1;
    }
    if(euid > 0 && pe != NULL) {
        p = find_path();
        LOG_RENAME(SYSCALL_MOVE, pe->username, pid, ppid, audit, paudit, ptask->comm, oldfile, newfile, p->name);
        kfree(p);
    }
    return result;
}

asmlinkage long our_sys_connect(int sockfd, struct sockaddr __user *addr, int addrlen)
{
	long uid, pid, audit;
	long result;
	struct passwd_entry *pe;
	struct sockaddr_in  *ipv4;
	unsigned int ipv4_addr;
	//struct sockaddr_in6 *ipv6;
	uid = current_uid();
	audit = get_audit_id();
	pid = current->pid;
	pe = get_passwd_entry(uid);

	result = original_sys_connect_call(sockfd, addr, addrlen);
	if(result < 0) return result;

	if(addr->sa_family == AF_INET) {
		ipv4 = (struct sockaddr_in *) addr;
		ipv4_addr = (unsigned int)(ipv4->sin_addr.s_addr);
		LOG_S_CONNECT(SYSCALL_S_CONNECT, pe->username, pid, audit, sockfd, ipv4_addr, ipv4->sin_port);
	}
	else if(addr->sa_family == AF_INET6){
		// TODO: Suport IPv6
	}
	return result; 
}

/*****************************************
 * Name:    svd_open
 * Desc:    implements open operation
 * Args:    as specified in kernel headers
 * Returns: as specified in kernel headers
 * Globals: -
 ****************************************/
static int svd_open(struct inode *inode, struct file *filp)
{
	int retval = 0;
	struct svd_dev *dev;
	dev = container_of(inode->i_cdev, struct svd_dev, cdev);
	filp->private_data = dev;

	if (down_interruptible(&dev->sem))
		return (-ERESTARTSYS);

	/* check if device is ready to use, */
	if (!dev->contents.ready)
		retval = -ENXIO;

	/* and if the current user has access */
	else if (dev->contents.uid != current_uid())
		retval = -EPERM;

	/* now trim to 0 the length of the device if open was write-only */
	else if ((filp->f_flags & O_ACCMODE) == O_WRONLY)
		memset(dev->contents.data, 0, dev->contents.size);

	up(&dev->sem);

	return (retval);
}