ubusd_acl.h File Reference

Go to the source code of this file.

Enumerations
enum	ubusd_acl_type {   UBUS_ACL_PUBLISH , UBUS_ACL_SUBSCRIBE , UBUS_ACL_ACCESS , UBUS_ACL_LISTEN ,   UBUS_ACL_SEND }

Functions
int	ubusd_acl_check (struct ubus_client *cl, const char *obj, const char *method, enum ubusd_acl_type type)
int	ubusd_acl_init_client (struct ubus_client *cl, int fd)
void	ubusd_acl_free_client (struct ubus_client *cl)
void	ubusd_acl_load (void)

Enumeration Type Documentation

ubusd_acl_type

enum ubusd_acl_type

Enumerator
UBUS_ACL_PUBLISH
UBUS_ACL_SUBSCRIBE
UBUS_ACL_ACCESS
UBUS_ACL_LISTEN
UBUS_ACL_SEND

Definition at line 17 of file ubusd_acl.h.

                    {
        UBUS_ACL_PUBLISH,
        UBUS_ACL_SUBSCRIBE,
        UBUS_ACL_ACCESS,
        UBUS_ACL_LISTEN,
        UBUS_ACL_SEND,
};

Function Documentation

ubusd_acl_check()

int ubusd_acl_check	(	struct ubus_client *	cl,
		const char *	obj,
		const char *	method,
		enum ubusd_acl_type	type
	)

Definition at line 90 of file ubusd_acl.c.

{
        struct ubusd_acl_obj *acl;
        int match_len = 0;
 
        if (!cl || !cl->uid || !obj)
                return 0;
 
        /*
         * Since this tree is sorted alphabetically, we can only expect
         * to find matching entries as long as the number of matching
         * characters between the access list string and the object path
         * is monotonically increasing.
         */
        avl_for_each_element(&ubusd_acls, acl, avl) {
                const char *key = acl->avl.key;
                int cur_match_len;
                bool full_match;
 
                full_match = ubus_strmatch_len(obj, key, &cur_match_len);
                if (cur_match_len < match_len)
                        break;
 
                match_len = cur_match_len;
 
                if (!full_match) {
                        if (!acl->partial)
                                continue;
 
                        if (match_len != (int) strlen(key))
                                continue;
                }
 
                if (ubusd_acl_match_cred(cl, acl))
                        continue;
 
                switch (type) {
                case UBUS_ACL_PUBLISH:
                        if (acl->publish)
                                return 0;
                        break;
 
                case UBUS_ACL_SUBSCRIBE:
                        if (acl->subscribe)
                                return 0;
                        break;
 
                case UBUS_ACL_LISTEN:
                        if (acl->listen)
                                return 0;
                        break;
 
                case UBUS_ACL_SEND:
                        if (acl->send)
                                return 0;
                        break;
 
                case UBUS_ACL_ACCESS:
                        if (acl->methods) {
                                struct blob_attr *cur;
                                char *cur_method;
                                size_t rem;
 
                                blobmsg_for_each_attr(cur, acl->methods, rem)
                                        if (blobmsg_type(cur) == BLOBMSG_TYPE_STRING) {
                                                cur_method = blobmsg_get_string(cur);
 
                                                if (!strcmp(method, cur_method) || !strcmp("*", cur_method))
                                                        return 0;
                                        }
                        }
                        break;
                }
        }
 
        return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubusd_acl_free_client()

void ubusd_acl_free_client

(

struct ubus_client *

cl

)

Definition at line 209 of file ubusd_acl.c.

{
        free(cl->group);
        free(cl->user);
}

Here is the caller graph for this function:

ubusd_acl_init_client()

int ubusd_acl_init_client	(	struct ubus_client *	cl,
		int	fd
	)

Definition at line 170 of file ubusd_acl.c.

{
        struct ucred cred;
        struct passwd *pwd;
        struct group *group;
 
#ifdef SO_PEERCRED
        unsigned int len = sizeof(struct ucred);
 
        if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cred, &len) == -1) {
                ULOG_ERR("Failed getsockopt(): %m\n");
                return -1;
        }
#else
        memset(&cred, 0, sizeof(cred));
#endif
 
        pwd = getpwuid(cred.uid);
        if (!pwd) {
                ULOG_ERR("Failed getpwuid(): %m\n");
                return -1;
        }
 
        group = getgrgid(cred.gid);
        if (!group) {
                ULOG_ERR("Failed getgrgid(): %m\n");
                return -1;
        }
 
        cl->uid = cred.uid;
        cl->gid = cred.gid;
 
        cl->group = strdup(group->gr_name);
        cl->user = strdup(pwd->pw_name);
 
        return 0;
}

Here is the caller graph for this function:

ubusd_acl_load()

void ubusd_acl_load

(

void

)

Definition at line 445 of file ubusd_acl.c.

{
        struct stat st;
        glob_t gl;
        size_t j;
        const char *suffix = "/*.json";
        char *path = alloca(strlen(ubusd_acl_dir) + strlen(suffix) + 1);
 
        sprintf(path, "%s%s", ubusd_acl_dir, suffix);
        if (glob(path, GLOB_NOESCAPE | GLOB_MARK, NULL, &gl))
                return;
 
        vlist_update(&ubusd_acl_files);
        for (j = 0; j < gl.gl_pathc; j++) {
                if (stat(gl.gl_pathv[j], &st) || !S_ISREG(st.st_mode))
                        continue;
 
                if (st.st_uid || st.st_gid) {
                        syslog(LOG_ERR, "%s has wrong owner\n", gl.gl_pathv[j]);
                        continue;
                }
                if (st.st_mode & (S_IWOTH | S_IWGRP | S_IXOTH)) {
                        syslog(LOG_ERR, "%s has wrong permissions\n", gl.gl_pathv[j]);
                        continue;
                }
                ubusd_acl_load_file(gl.gl_pathv[j]);
        }
 
        globfree(&gl);
        vlist_flush(&ubusd_acl_files);
        ubusd_acl_seq++;
        ubusd_send_event(NULL, "ubus.acl.sequence", ubusd_create_sequence_event_msg, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function: