Fix: tracker: NULL pointer dereference after NULL check
[lttng-tools.git] / src / common / tracker.c
1 /*
2 * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
3 * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * SPDX-License-Identifier: LGPL-2.1-only
6 *
7 */
8
9 #include <lttng/domain.h>
10 #include <lttng/lttng-error.h>
11 #include <lttng/tracker.h>
12
13 #include <common/dynamic-array.h>
14 #include <common/error.h>
15 #include <common/hashtable/hashtable.h>
16 #include <common/hashtable/utils.h>
17 #include <common/tracker.h>
18
19 #include <stdbool.h>
20
21 struct process_attr_tracker_values_comm_header {
22 uint32_t count;
23 };
24
25 struct process_attr_tracker_value_comm {
26 /* enum lttng_process_attr_value_type */
27 int32_t type;
28 union {
29 struct process_attr_integral_value_comm integral;
30 /* Includes the '\0' terminator. */
31 uint32_t name_len;
32 } value;
33 };
34
35 #define GET_INTEGRAL_COMM_VALUE(value_ptr, as_type) \
36 ((as_type)(is_signed(as_type) ? (value_ptr)->u._signed : \
37 (value_ptr)->u._unsigned))
38
39 #define SET_INTEGRAL_COMM_VALUE(comm_value, value) \
40 if (is_signed(typeof(value))) { \
41 (comm_value)->u._signed = \
42 (typeof((comm_value)->u._signed)) value; \
43 } else { \
44 (comm_value)->u._unsigned = \
45 (typeof((comm_value)->u._unsigned)) value; \
46 }
47
48 static inline bool is_virtual_process_attr(enum lttng_process_attr process_attr)
49 {
50 return process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID ||
51 process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID ||
52 process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID;
53 }
54
55 static inline bool is_value_type_name(
56 enum lttng_process_attr_value_type value_type)
57 {
58 return value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ||
59 value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME;
60 }
61
62 LTTNG_HIDDEN
63 enum lttng_error_code process_attr_value_from_comm(
64 enum lttng_domain_type domain,
65 enum lttng_process_attr process_attr,
66 enum lttng_process_attr_value_type value_type,
67 const struct process_attr_integral_value_comm *integral_value,
68 const struct lttng_buffer_view *value_view,
69 struct process_attr_value **_value)
70 {
71 char *name = NULL;
72 enum lttng_error_code ret = LTTNG_OK;
73 struct process_attr_value *value = zmalloc(sizeof(*value));
74
75 if (!value) {
76 ret = LTTNG_ERR_NOMEM;
77 goto error;
78 }
79
80 if (value_view && value_view->size > 0) {
81 if (value_view->data[value_view->size - 1] != '\0') {
82 ret = LTTNG_ERR_INVALID;
83 goto error;
84 }
85 name = strdup(value_view->data);
86 if (!name) {
87 ret = LTTNG_ERR_NOMEM;
88 goto error;
89 }
90 }
91
92 if (domain != LTTNG_DOMAIN_UST && domain != LTTNG_DOMAIN_KERNEL) {
93 ERR("Only the user space and kernel space domains may be specified to configure process attribute trackers");
94 ret = LTTNG_ERR_UNSUPPORTED_DOMAIN;
95 goto error;
96 }
97
98 if (!is_virtual_process_attr(process_attr) &&
99 domain != LTTNG_DOMAIN_KERNEL) {
100 ERR("Non-virtual process attributes can only be used in the kernel domain");
101 ret = LTTNG_ERR_UNSUPPORTED_DOMAIN;
102 goto error;
103 }
104
105 /* Only expect a payload for name value types. */
106 if (is_value_type_name(value_type) &&
107 (!value_view || value_view->size == 0)) {
108 ret = LTTNG_ERR_INVALID_PROTOCOL;
109 goto error;
110 } else if (!is_value_type_name(value_type) && value_view &&
111 value_view->size != 0) {
112 ret = LTTNG_ERR_INVALID_PROTOCOL;
113 goto error;
114 }
115
116 value->type = value_type;
117 switch (process_attr) {
118 case LTTNG_PROCESS_ATTR_PROCESS_ID:
119 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
120 if (value_type != LTTNG_PROCESS_ATTR_VALUE_TYPE_PID) {
121 ERR("Invalid value type used for process ID process attribute");
122 ret = LTTNG_ERR_INVALID;
123 goto error;
124 }
125 value->value.pid =
126 GET_INTEGRAL_COMM_VALUE(integral_value, pid_t);
127 break;
128 case LTTNG_PROCESS_ATTR_USER_ID:
129 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
130 switch (value_type) {
131 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
132 value->value.uid = GET_INTEGRAL_COMM_VALUE(
133 integral_value, uid_t);
134 break;
135 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
136 if (!name) {
137 ret = LTTNG_ERR_INVALID;
138 goto error;
139 }
140
141 value->value.user_name = name;
142 name = NULL;
143 break;
144 default:
145 ERR("Invalid value type used for user ID process attribute");
146 ret = LTTNG_ERR_INVALID;
147 goto error;
148 }
149 break;
150 case LTTNG_PROCESS_ATTR_GROUP_ID:
151 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
152 switch (value_type) {
153 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
154 value->value.gid = GET_INTEGRAL_COMM_VALUE(
155 integral_value, gid_t);
156 break;
157 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
158 if (!name) {
159 ret = LTTNG_ERR_INVALID;
160 goto error;
161 }
162
163 value->value.group_name = name;
164 name = NULL;
165 break;
166 default:
167 ERR("Invalid value type used for group ID process attribute");
168 ret = LTTNG_ERR_INVALID;
169 goto error;
170 }
171 break;
172 default:
173 ret = LTTNG_ERR_INVALID_PROTOCOL;
174 goto error;
175 }
176
177 *_value = value;
178 value = NULL;
179 free(name);
180 return LTTNG_OK;
181 error:
182 free(name);
183 process_attr_value_destroy(value);
184 return ret;
185 }
186
187 LTTNG_HIDDEN
188 const char *lttng_process_attr_to_string(enum lttng_process_attr process_attr)
189 {
190 switch (process_attr) {
191 case LTTNG_PROCESS_ATTR_PROCESS_ID:
192 return "process ID";
193 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
194 return "virtual process ID";
195 case LTTNG_PROCESS_ATTR_USER_ID:
196 return "user ID";
197 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
198 return "virtual user ID";
199 case LTTNG_PROCESS_ATTR_GROUP_ID:
200 return "group ID";
201 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
202 return "virtual group ID";
203 default:
204 return "unknown process attribute";
205 }
206 }
207
208 static void process_attr_tracker_value_destructor(void *ptr)
209 {
210 struct process_attr_value *value = (typeof(value)) ptr;
211
212 process_attr_value_destroy(value);
213 }
214
215 LTTNG_HIDDEN
216 struct lttng_process_attr_values *lttng_process_attr_values_create(void)
217 {
218 struct lttng_process_attr_values *values = zmalloc(sizeof(*values));
219
220 if (!values) {
221 goto end;
222 }
223
224 lttng_dynamic_pointer_array_init(
225 &values->array, process_attr_tracker_value_destructor);
226 end:
227 return values;
228 }
229
230 LTTNG_HIDDEN
231 unsigned int _lttng_process_attr_values_get_count(
232 const struct lttng_process_attr_values *values)
233 {
234 return (unsigned int) lttng_dynamic_pointer_array_get_count(
235 &values->array);
236 }
237
238 LTTNG_HIDDEN
239 const struct process_attr_value *lttng_process_attr_tracker_values_get_at_index(
240 const struct lttng_process_attr_values *values,
241 unsigned int index)
242 {
243 return lttng_dynamic_pointer_array_get_pointer(&values->array, index);
244 }
245
246 static
247 int process_attr_tracker_value_serialize(const struct process_attr_value *value,
248 struct lttng_dynamic_buffer *buffer)
249 {
250 int ret;
251 struct process_attr_tracker_value_comm value_comm = {
252 .type = (int32_t) value->type,
253 };
254 const char *name = NULL;
255
256 switch (value->type) {
257 case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
258 SET_INTEGRAL_COMM_VALUE(
259 &value_comm.value.integral, value->value.pid);
260 break;
261 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
262 SET_INTEGRAL_COMM_VALUE(
263 &value_comm.value.integral, value->value.uid);
264 break;
265 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
266 SET_INTEGRAL_COMM_VALUE(
267 &value_comm.value.integral, value->value.gid);
268 break;
269 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
270 name = value->value.user_name;
271 break;
272 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
273 name = value->value.group_name;
274 break;
275 default:
276 abort();
277 }
278
279 if (name) {
280 value_comm.value.name_len = strlen(name) + 1;
281 }
282
283 ret = lttng_dynamic_buffer_append(
284 buffer, &value_comm, sizeof(value_comm));
285 if (ret) {
286 goto end;
287 }
288
289 if (name) {
290 ret = lttng_dynamic_buffer_append(
291 buffer, name, value_comm.value.name_len);
292 }
293 end:
294 return ret;
295 }
296
297 LTTNG_HIDDEN
298 int lttng_process_attr_values_serialize(
299 const struct lttng_process_attr_values *values,
300 struct lttng_dynamic_buffer *buffer)
301 {
302 int ret;
303 unsigned int count, i;
304 struct process_attr_tracker_values_comm_header header = {};
305
306 count = _lttng_process_attr_values_get_count(values);
307 header.count = (uint32_t) count;
308
309 ret = lttng_dynamic_buffer_append(buffer, &header, sizeof(header));
310 if (ret) {
311 goto end;
312 }
313
314 for (i = 0; i < count; i++) {
315 const struct process_attr_value *value =
316 lttng_process_attr_tracker_values_get_at_index(
317 values, i);
318
319 ret = process_attr_tracker_value_serialize(value, buffer);
320 if (ret) {
321 goto end;
322 }
323 }
324 end:
325 return ret;
326 }
327
328 LTTNG_HIDDEN
329 ssize_t lttng_process_attr_values_create_from_buffer(
330 enum lttng_domain_type domain,
331 enum lttng_process_attr process_attr,
332 const struct lttng_buffer_view *buffer_view,
333 struct lttng_process_attr_values **_values)
334 {
335 ssize_t offset;
336 unsigned int i;
337 struct lttng_process_attr_values *values;
338 struct lttng_buffer_view header_view;
339 const struct process_attr_tracker_values_comm_header *header;
340
341 values = lttng_process_attr_values_create();
342 if (!values) {
343 goto error;
344 }
345
346 header_view = lttng_buffer_view_from_view(
347 buffer_view, 0, sizeof(*header));
348 if (!header_view.data) {
349 goto error;
350 }
351 offset = header_view.size;
352 header = (typeof(header)) header_view.data;
353
354 /*
355 * Check that the number of values is not absurdly large with respect to
356 * the received buffer's size.
357 */
358 if (buffer_view->size <
359 header->count * sizeof(struct process_attr_tracker_value_comm)) {
360 goto error;
361 }
362 for (i = 0; i < (unsigned int) header->count; i++) {
363 int ret;
364 enum lttng_error_code ret_code;
365 const struct process_attr_tracker_value_comm *value_comm;
366 struct process_attr_value *value;
367 enum lttng_process_attr_value_type type;
368 struct lttng_buffer_view value_view;
369 struct lttng_buffer_view value_name_view = {};
370
371 value_view = lttng_buffer_view_from_view(
372 buffer_view, offset, sizeof(*value_comm));
373 if (!value_view.data) {
374 goto error;
375 }
376
377 offset += value_view.size;
378 value_comm = (typeof(value_comm)) value_view.data;
379 type = (typeof(type)) value_comm->type;
380
381 if (is_value_type_name(type)) {
382 value_name_view = lttng_buffer_view_from_view(
383 buffer_view, offset,
384 value_comm->value.name_len);
385 offset += value_name_view.size;
386 }
387 ret_code = process_attr_value_from_comm(domain, process_attr,
388 type, &value_comm->value.integral,
389 &value_name_view, &value);
390 if (ret_code != LTTNG_OK) {
391 goto error;
392 }
393
394 ret = lttng_dynamic_pointer_array_add_pointer(
395 &values->array, value);
396 if (ret) {
397 process_attr_value_destroy(value);
398 goto error;
399 }
400 }
401
402 *_values = values;
403 return offset;
404 error:
405 lttng_process_attr_values_destroy(values);
406 return -1;
407 }
408
409 LTTNG_HIDDEN
410 void lttng_process_attr_values_destroy(struct lttng_process_attr_values *values)
411 {
412 if (!values) {
413 return;
414 }
415 lttng_dynamic_pointer_array_reset(&values->array);
416 free(values);
417 }
418
419 LTTNG_HIDDEN
420 struct process_attr_value *process_attr_value_copy(
421 const struct process_attr_value *value)
422 {
423 struct process_attr_value *new_value = NULL;
424
425 if (!value) {
426 goto end;
427 }
428
429 new_value = zmalloc(sizeof(*new_value));
430 if (!new_value) {
431 goto end;
432 }
433 if (is_value_type_name(value->type)) {
434 const char *src =
435 value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
436 value->value.user_name :
437 value->value.group_name;
438 char **dst = value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
439 &new_value->value.user_name :
440 &new_value->value.group_name;
441
442 new_value->type = value->type;
443 *dst = strdup(src);
444 if (!*dst) {
445 goto error;
446 }
447 } else {
448 *new_value = *value;
449 }
450 end:
451 return new_value;
452 error:
453 free(new_value);
454 return NULL;
455 }
456
457 LTTNG_HIDDEN
458 unsigned long process_attr_value_hash(const struct process_attr_value *a)
459 {
460 unsigned long hash = hash_key_ulong((void *) a->type, lttng_ht_seed);
461
462 switch (a->type) {
463 case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
464 hash ^= hash_key_ulong((void *) (unsigned long) a->value.pid,
465 lttng_ht_seed);
466 break;
467 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
468 hash ^= hash_key_ulong((void *) (unsigned long) a->value.uid,
469 lttng_ht_seed);
470 break;
471 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
472 hash ^= hash_key_ulong((void *) (unsigned long) a->value.gid,
473 lttng_ht_seed);
474 break;
475 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
476 hash ^= hash_key_str(a->value.user_name, lttng_ht_seed);
477 break;
478 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
479 hash ^= hash_key_str(a->value.group_name, lttng_ht_seed);
480 break;
481 default:
482 abort();
483 }
484
485 return hash;
486 }
487
488 LTTNG_HIDDEN
489 bool process_attr_tracker_value_equal(const struct process_attr_value *a,
490 const struct process_attr_value *b)
491 {
492 if (a->type != b->type) {
493 return false;
494 }
495 switch (a->type) {
496 case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
497 return a->value.pid == b->value.pid;
498 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
499 return a->value.uid == b->value.uid;
500 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
501 return a->value.gid == b->value.gid;
502 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
503 return !strcmp(a->value.user_name, b->value.user_name);
504 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
505 return !strcmp(a->value.group_name, b->value.group_name);
506 default:
507 abort();
508 }
509 }
510
511 LTTNG_HIDDEN
512 void process_attr_value_destroy(struct process_attr_value *value)
513 {
514 if (!value) {
515 return;
516 }
517 if (is_value_type_name(value->type)) {
518 free(value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
519 value->value.user_name :
520 value->value.group_name);
521 }
522 free(value);
523 }
This page took 0.062111 seconds and 4 git commands to generate.