X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Ftrigger.c;h=f77a321295d4c10a9c7d67ce51071bc649854a19;hp=2ef77b2360a2bf8ab1ea80cdf513da2b9d46ce2b;hb=e6887944f09a8985efb521ea638b4dfe557ff4ed;hpb=f01d28b41fb941aee87aaf70ed42a5928c784ba6 diff --git a/src/common/trigger.c b/src/common/trigger.c index 2ef77b236..f77a32129 100644 --- a/src/common/trigger.c +++ b/src/common/trigger.c @@ -14,6 +14,7 @@ #include #include #include +#include LTTNG_HIDDEN bool lttng_trigger_validate(struct lttng_trigger *trigger) @@ -25,6 +26,11 @@ bool lttng_trigger_validate(struct lttng_trigger *trigger) goto end; } + if (!trigger->creds.uid.is_set) { + valid = false; + goto end; + } + valid = lttng_condition_validate(trigger->condition) && lttng_action_validate(trigger->action); end: @@ -110,6 +116,7 @@ static void trigger_destroy_ref(struct urcu_ref *ref) lttng_action_put(action); lttng_condition_put(condition); + free(trigger->name); free(trigger); } @@ -123,10 +130,15 @@ ssize_t lttng_trigger_create_from_payload( struct lttng_payload_view *src_view, struct lttng_trigger **trigger) { - ssize_t ret, offset = 0, condition_size, action_size; + ssize_t ret, offset = 0, condition_size, action_size, name_size = 0; struct lttng_condition *condition = NULL; struct lttng_action *action = NULL; const struct lttng_trigger_comm *trigger_comm; + const char *name = NULL; + struct lttng_credentials creds = { + .uid = LTTNG_OPTIONAL_INIT_UNSET, + .gid = LTTNG_OPTIONAL_INIT_UNSET, + }; if (!src_view || !trigger) { ret = -1; @@ -135,7 +147,35 @@ ssize_t lttng_trigger_create_from_payload( /* lttng_trigger_comm header */ trigger_comm = (typeof(trigger_comm)) src_view->buffer.data; + + /* Set the trigger's creds. */ + if (trigger_comm->uid > (uint64_t) ((uid_t) -1)) { + /* UID out of range for this platform. */ + ret = -1; + goto end; + } + + LTTNG_OPTIONAL_SET(&creds.uid, trigger_comm->uid); + offset += sizeof(*trigger_comm); + + if (trigger_comm->name_length != 0) { + /* Name. */ + const struct lttng_payload_view name_view = + lttng_payload_view_from_view( + src_view, offset, trigger_comm->name_length); + + name = name_view.buffer.data; + if (!lttng_buffer_view_contains_string(&name_view.buffer, name, + trigger_comm->name_length)) { + ret = -1; + goto end; + } + + offset += trigger_comm->name_length; + name_size = trigger_comm->name_length; + } + { /* struct lttng_condition */ struct lttng_payload_view condition_view = @@ -168,7 +208,7 @@ ssize_t lttng_trigger_create_from_payload( offset += action_size; /* Unexpected size of inner-elements; the buffer is corrupted. */ - if ((ssize_t) trigger_comm->length != condition_size + action_size) { + if ((ssize_t) trigger_comm->length != condition_size + action_size + name_size) { ret = -1; goto error; } @@ -179,6 +219,8 @@ ssize_t lttng_trigger_create_from_payload( goto error; } + lttng_trigger_set_credentials(*trigger, &creds); + /* * The trigger object owns references to the action and condition * objects. @@ -189,6 +231,16 @@ ssize_t lttng_trigger_create_from_payload( lttng_action_put(action); action = NULL; + if (name) { + const enum lttng_trigger_status status = + lttng_trigger_set_name(*trigger, name); + + if (status != LTTNG_TRIGGER_STATUS_OK) { + ret = -1; + goto end; + } + } + ret = offset; error: @@ -207,9 +259,23 @@ int lttng_trigger_serialize(struct lttng_trigger *trigger, struct lttng_payload *payload) { int ret; - size_t header_offset, size_before_payload; + size_t header_offset, size_before_payload, size_name; struct lttng_trigger_comm trigger_comm = {}; struct lttng_trigger_comm *header; + const struct lttng_credentials *creds = NULL; + + creds = lttng_trigger_get_credentials(trigger); + assert(creds); + + trigger_comm.uid = LTTNG_OPTIONAL_GET(creds->uid); + + if (trigger->name != NULL) { + size_name = strlen(trigger->name) + 1; + } else { + size_name = 0; + } + + trigger_comm.name_length = size_name; header_offset = payload->buffer.size; ret = lttng_dynamic_buffer_append(&payload->buffer, &trigger_comm, @@ -219,6 +285,14 @@ int lttng_trigger_serialize(struct lttng_trigger *trigger, } size_before_payload = payload->buffer.size; + + /* Trigger name. */ + ret = lttng_dynamic_buffer_append( + &payload->buffer, trigger->name, size_name); + if (ret) { + goto end; + } + ret = lttng_condition_serialize(trigger->condition, payload); if (ret) { goto end; @@ -236,6 +310,128 @@ end: return ret; } +LTTNG_HIDDEN +bool lttng_trigger_is_equal( + const struct lttng_trigger *a, const struct lttng_trigger *b) +{ + /* + * Name is not taken into account since it is cosmetic only. + */ + if (!lttng_condition_is_equal(a->condition, b->condition)) { + return false; + } + + if (!lttng_action_is_equal(a->action, b->action)) { + return false; + } + + if (!lttng_credentials_is_equal(lttng_trigger_get_credentials(a), + lttng_trigger_get_credentials(b))) { + return false; + } + + return true; +} + +enum lttng_trigger_status lttng_trigger_set_name(struct lttng_trigger *trigger, + const char* name) +{ + char *name_copy = NULL; + enum lttng_trigger_status status = LTTNG_TRIGGER_STATUS_OK; + + if (!trigger || !name || + strlen(name) == 0) { + status = LTTNG_TRIGGER_STATUS_INVALID; + goto end; + } + + name_copy = strdup(name); + if (!name_copy) { + status = LTTNG_TRIGGER_STATUS_ERROR; + goto end; + } + + free(trigger->name); + + trigger->name = name_copy; + name_copy = NULL; +end: + return status; +} + +enum lttng_trigger_status lttng_trigger_get_name( + const struct lttng_trigger *trigger, const char **name) +{ + enum lttng_trigger_status status = LTTNG_TRIGGER_STATUS_OK; + + if (!trigger || !name) { + status = LTTNG_TRIGGER_STATUS_INVALID; + goto end; + } + + if (!trigger->name) { + status = LTTNG_TRIGGER_STATUS_UNSET; + } + + *name = trigger->name; +end: + return status; +} + +LTTNG_HIDDEN +int lttng_trigger_assign_name(struct lttng_trigger *dst, + const struct lttng_trigger *src) +{ + int ret = 0; + enum lttng_trigger_status status; + + status = lttng_trigger_set_name(dst, src->name); + if (status != LTTNG_TRIGGER_STATUS_OK) { + ret = -1; + ERR("Failed to set name for trigger"); + goto end; + } +end: + return ret; +} + +LTTNG_HIDDEN +void lttng_trigger_set_tracer_token(struct lttng_trigger *trigger, + uint64_t token) +{ + assert(trigger); + LTTNG_OPTIONAL_SET(&trigger->tracer_token, token); +} + +LTTNG_HIDDEN +uint64_t lttng_trigger_get_tracer_token(const struct lttng_trigger *trigger) +{ + assert(trigger); + + return LTTNG_OPTIONAL_GET(trigger->tracer_token); +} + +LTTNG_HIDDEN +int lttng_trigger_generate_name(struct lttng_trigger *trigger, + uint64_t unique_id) +{ + int ret = 0; + char *generated_name = NULL; + + ret = asprintf(&generated_name, "T%" PRIu64 "", unique_id); + if (ret < 0) { + ERR("Failed to generate trigger name"); + ret = -1; + goto end; + } + + ret = 0; + free(trigger->name); + trigger->name = generated_name; +end: + return ret; +} + LTTNG_HIDDEN void lttng_trigger_get(struct lttng_trigger *trigger) { @@ -256,14 +452,62 @@ LTTNG_HIDDEN const struct lttng_credentials *lttng_trigger_get_credentials( const struct lttng_trigger *trigger) { - return LTTNG_OPTIONAL_GET_PTR(trigger->creds); + return &trigger->creds; } LTTNG_HIDDEN -void lttng_trigger_set_credentials( - struct lttng_trigger *trigger, +void lttng_trigger_set_credentials(struct lttng_trigger *trigger, const struct lttng_credentials *creds) { assert(creds); - LTTNG_OPTIONAL_SET(&trigger->creds, *creds); + trigger->creds = *creds; +} + +enum lttng_trigger_status lttng_trigger_set_owner_uid( + struct lttng_trigger *trigger, uid_t uid) +{ + enum lttng_trigger_status ret = LTTNG_TRIGGER_STATUS_OK; + const struct lttng_credentials creds = { + .uid = LTTNG_OPTIONAL_INIT_VALUE(uid), + .gid = LTTNG_OPTIONAL_INIT_UNSET, + }; + + if (!trigger) { + ret = LTTNG_TRIGGER_STATUS_INVALID; + goto end; + } + + /* Client-side validation only to report a clearer error. */ + if (geteuid() != 0) { + ret = LTTNG_TRIGGER_STATUS_PERMISSION_DENIED; + goto end; + } + + lttng_trigger_set_credentials(trigger, &creds); + +end: + return ret; +} + +enum lttng_trigger_status lttng_trigger_get_owner_uid( + const struct lttng_trigger *trigger, uid_t *uid) +{ + enum lttng_trigger_status ret = LTTNG_TRIGGER_STATUS_OK; + const struct lttng_credentials *creds = NULL; + + if (!trigger || !uid ) { + ret = LTTNG_TRIGGER_STATUS_INVALID; + goto end; + } + + if (!trigger->creds.uid.is_set ) { + ret = LTTNG_TRIGGER_STATUS_UNSET; + goto end; + } + + creds = lttng_trigger_get_credentials(trigger); + *uid = lttng_credentials_get_uid(creds); + +end: + return ret; }