Line data Source code
1 : /*
2 : * SPDX license identifier: MPL-2.0
3 : *
4 : * Copyright (C) 2011-2015, BMW AG
5 : *
6 : * This file is part of COVESA Project DLT - Diagnostic Log and Trace.
7 : *
8 : * This Source Code Form is subject to the terms of the
9 : * Mozilla Public License (MPL), v. 2.0.
10 : * If a copy of the MPL was not distributed with this file,
11 : * You can obtain one at http://mozilla.org/MPL/2.0/.
12 : *
13 : * For further information see http://www.covesa.org/.
14 : */
15 :
16 : /*!
17 : * \author Alexander Wenzel <alexander.aw.wenzel@bmw.de>
18 : *
19 : * \copyright Copyright © 2011-2015 BMW AG. \n
20 : * License MPL-2.0: Mozilla Public License version 2.0 http://mozilla.org/MPL/2.0/.
21 : *
22 : * \file dlt_client.c
23 : */
24 :
25 : /*******************************************************************************
26 : ** **
27 : ** SRC-MODULE: dlt_client.c **
28 : ** **
29 : ** TARGET : linux **
30 : ** **
31 : ** PROJECT : DLT **
32 : ** **
33 : ** AUTHOR : Alexander Wenzel Alexander.AW.Wenzel@bmw.de **
34 : ** Markus Klein **
35 : ** **
36 : ** PURPOSE : **
37 : ** **
38 : ** REMARKS : **
39 : ** **
40 : ** PLATFORM DEPENDANT [yes/no]: yes **
41 : ** **
42 : ** TO BE CHANGED BY USER [yes/no]: no **
43 : ** **
44 : *******************************************************************************/
45 :
46 : /*******************************************************************************
47 : ** Author Identity **
48 : ********************************************************************************
49 : ** **
50 : ** Initials Name Company **
51 : ** -------- ------------------------- ---------------------------------- **
52 : ** aw Alexander Wenzel BMW **
53 : ** mk Markus Klein Fraunhofer ESK **
54 : *******************************************************************************/
55 :
56 : /*******************************************************************************
57 : ** Revision Control History **
58 : *******************************************************************************/
59 :
60 : /*
61 : * $LastChangedRevision$
62 : * $LastChangedDate$
63 : * $LastChangedBy$
64 : * Initials Date Comment
65 : * aw 12.07.2010 initial
66 : */
67 :
68 : #include <stdio.h>
69 :
70 : #if defined (__WIN32__) || defined (_MSC_VER)
71 : # pragma warning(disable : 4996) /* Switch off C4996 warnings */
72 : # include <winsock2.h> /* for socket(), connect(), send(), and recv() */
73 : #else
74 : # include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
75 :
76 : #pragma GCC diagnostic ignored "-Wconversion"
77 : # include <arpa/inet.h> /* for sockaddr_in and inet_addr() */
78 : #pragma GCC diagnostic push
79 : #pragma GCC diagnostic pop
80 :
81 : # include <netdb.h>
82 : # include <sys/stat.h>
83 : # include <sys/un.h>
84 : #endif
85 :
86 : #if defined(_MSC_VER)
87 : # include <io.h>
88 : #else
89 : # include <unistd.h>
90 : # include <syslog.h>
91 : #endif
92 :
93 : #include <fcntl.h>
94 :
95 : #include <stdlib.h> /* for malloc(), free() */
96 : #include <string.h> /* for strlen(), memcmp(), memmove() */
97 : #include <errno.h>
98 : #include <limits.h>
99 : #include <poll.h>
100 :
101 : #include "dlt_types.h"
102 : #include "dlt_log.h"
103 : #include "dlt_client.h"
104 : #include "dlt_client_cfg.h"
105 :
106 : // DLTv2 - DLT Version flag for multiplexing v1 and v2 messages
107 : uint8_t dlt_client_dlt_version = DLTProtocolV1;
108 :
109 : static int (*message_callback_function)(DltMessage *message, void *data) = NULL;
110 : static int (*message_callback_function_v2)(DltMessageV2 *message, void *data) = NULL;
111 : static bool (*fetch_next_message_callback_function)(void *data) = NULL;
112 :
113 2 : void dlt_client_register_message_callback(int (*registerd_callback)(DltMessage *message, void *data))
114 : {
115 2 : message_callback_function = registerd_callback;
116 2 : }
117 :
118 0 : void dlt_client_register_message_callback_v2(int (*registerd_callback)(DltMessageV2 *message, void *data))
119 : {
120 0 : message_callback_function_v2 = registerd_callback;
121 0 : }
122 :
123 0 : void dlt_client_register_fetch_next_message_callback(bool (*registerd_callback)(void *data))
124 : {
125 0 : fetch_next_message_callback_function = registerd_callback;
126 0 : }
127 :
128 6 : DltReturnValue dlt_client_init_port(DltClient *client, int port, int verbose)
129 : {
130 6 : if (verbose && (port != DLT_DAEMON_TCP_PORT))
131 1 : dlt_vlog(LOG_INFO,
132 : "%s: Init dlt client struct with port %d\n",
133 : __func__,
134 : port);
135 :
136 6 : if (client == NULL)
137 : return DLT_RETURN_ERROR;
138 :
139 6 : client->sock = -1;
140 6 : client->servIP = NULL;
141 6 : client->serialDevice = NULL;
142 6 : client->baudrate = DLT_CLIENT_INITIAL_BAUDRATE;
143 6 : client->port = (uint16_t)port;
144 6 : client->socketPath = NULL;
145 6 : client->mode = DLT_CLIENT_MODE_TCP;
146 6 : client->receiver.buffer = NULL;
147 6 : client->receiver.buf = NULL;
148 6 : client->receiver.backup_buf = NULL;
149 6 : client->hostip = NULL;
150 :
151 6 : return DLT_RETURN_OK;
152 : }
153 :
154 2 : DltReturnValue dlt_client_init(DltClient *client, int verbose)
155 : {
156 : char *env_daemon_port;
157 : int tmp_port;
158 2 : client->ecuid2 = NULL;
159 : /* the port may be specified by an environment variable, defaults to DLT_DAEMON_TCP_PORT */
160 : unsigned short servPort = DLT_DAEMON_TCP_PORT;
161 :
162 : /* the port may be specified by an environment variable */
163 2 : env_daemon_port = getenv(DLT_CLIENT_ENV_DAEMON_TCP_PORT);
164 :
165 2 : if (env_daemon_port != NULL) {
166 : tmp_port = atoi(env_daemon_port);
167 :
168 0 : if ((tmp_port < IPPORT_RESERVED) || ((unsigned)tmp_port > USHRT_MAX)) {
169 0 : dlt_vlog(LOG_ERR,
170 : "%s: Specified port is out of possible range: %d.\n",
171 : __func__,
172 : tmp_port);
173 0 : return DLT_RETURN_ERROR;
174 : }
175 : else {
176 0 : servPort = (unsigned short)tmp_port;
177 : }
178 : }
179 :
180 2 : if (verbose)
181 0 : dlt_vlog(LOG_INFO,
182 : "%s: Init dlt client struct with default port: %hu.\n",
183 : __func__,
184 : servPort);
185 2 : return dlt_client_init_port(client, servPort, verbose);
186 : }
187 :
188 7 : DltReturnValue dlt_client_connect(DltClient *client, int verbose)
189 : {
190 7 : const int yes = 1;
191 7 : char portnumbuffer[33] = {0};
192 : struct addrinfo hints, *servinfo, *p;
193 : struct sockaddr_un addr;
194 : int rv;
195 : struct ip_mreq mreq;
196 : DltReceiverType receiver_type = DLT_RECEIVE_FD;
197 :
198 : struct pollfd pfds[1];
199 : int ret;
200 : int n;
201 7 : socklen_t m = sizeof(n);
202 : int connect_errno = 0;
203 :
204 : memset(&hints, 0, sizeof(hints));
205 7 : hints.ai_socktype = SOCK_STREAM;
206 :
207 7 : if (client == 0)
208 : return DLT_RETURN_ERROR;
209 :
210 7 : switch (client->mode) {
211 6 : case DLT_CLIENT_MODE_TCP:
212 6 : snprintf(portnumbuffer, 32, "%d", client->port);
213 :
214 6 : if ((rv = getaddrinfo(client->servIP, portnumbuffer, &hints, &servinfo)) != 0) {
215 0 : dlt_vlog(LOG_ERR,
216 : "%s: getaddrinfo: %s\n",
217 : __func__,
218 : gai_strerror(rv));
219 3 : return DLT_RETURN_ERROR;
220 : }
221 :
222 10 : for (p = servinfo; p != NULL; p = p->ai_next) {
223 7 : if ((client->sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) {
224 0 : dlt_vlog(LOG_WARNING,
225 : "%s: socket() failed! %s\n",
226 : __func__,
227 0 : strerror(errno));
228 0 : continue;
229 : }
230 :
231 : /* Set socket to Non-blocking mode */
232 7 : if(fcntl(client->sock, F_SETFL, fcntl(client->sock,F_GETFL,0) | O_NONBLOCK) < 0)
233 : {
234 0 : dlt_vlog(LOG_WARNING,
235 : "%s: Socket cannot be changed to NON BLOCK: %s\n",
236 0 : __func__, strerror(errno));
237 0 : close(client->sock);
238 0 : continue;
239 : }
240 :
241 7 : if (connect(client->sock, p->ai_addr, p->ai_addrlen) < 0) {
242 7 : if (errno == EINPROGRESS) {
243 7 : pfds[0].fd = client->sock;
244 7 : pfds[0].events = POLLOUT;
245 : ret = poll(pfds, 1, 500);
246 7 : if (ret < 0) {
247 0 : dlt_vlog(LOG_ERR, "%s: Failed to poll with err [%s]\n",
248 : __func__, strerror(errno));
249 0 : close(client->sock);
250 0 : continue;
251 : }
252 14 : else if ((pfds[0].revents & POLLOUT) &&
253 7 : getsockopt(client->sock, SOL_SOCKET,
254 : SO_ERROR, (void*)&n, &m) == 0) {
255 7 : if (n == 0) {
256 3 : dlt_vlog(LOG_DEBUG, "%s: Already connect\n", __func__);
257 3 : if(fcntl(client->sock, F_SETFL,
258 3 : fcntl(client->sock,F_GETFL,0) & ~O_NONBLOCK) < 0) {
259 0 : dlt_vlog(LOG_WARNING,
260 : "%s: Socket cannot be changed to BLOCK with err [%s]\n",
261 : __func__, strerror(errno));
262 0 : close(client->sock);
263 0 : continue;
264 : }
265 : }
266 : else {
267 : connect_errno = n;
268 4 : close(client->sock);
269 4 : continue;
270 : }
271 : }
272 : else {
273 0 : connect_errno = errno;
274 0 : close(client->sock);
275 0 : continue;
276 : }
277 : }
278 : else {
279 : connect_errno = errno;
280 0 : close(client->sock);
281 0 : continue;
282 : }
283 : }
284 :
285 : break;
286 : }
287 :
288 6 : freeaddrinfo(servinfo);
289 :
290 6 : if (p == NULL) {
291 3 : dlt_vlog(LOG_ERR,
292 : "%s: ERROR: failed to connect! %s\n",
293 : __func__,
294 : strerror(connect_errno));
295 3 : return DLT_RETURN_ERROR;
296 : }
297 :
298 3 : if (verbose) {
299 1 : dlt_vlog(LOG_INFO,
300 : "%s: Connected to DLT daemon (%s)\n",
301 : __func__,
302 : client->servIP);
303 : }
304 :
305 : receiver_type = DLT_RECEIVE_SOCKET;
306 :
307 4 : break;
308 0 : case DLT_CLIENT_MODE_SERIAL:
309 : /* open serial connection */
310 0 : client->sock = open(client->serialDevice, O_RDWR);
311 :
312 0 : if (client->sock < 0) {
313 0 : dlt_vlog(LOG_ERR,
314 : "%s: ERROR: Failed to open device %s\n",
315 : __func__,
316 : client->serialDevice);
317 0 : return DLT_RETURN_ERROR;
318 : }
319 :
320 0 : if (isatty(client->sock)) {
321 : #if !defined (__WIN32__)
322 :
323 0 : if (dlt_setup_serial(client->sock, client->baudrate) < DLT_RETURN_OK) {
324 0 : dlt_vlog(LOG_ERR,
325 : "%s: ERROR: Failed to configure serial device %s (%s) \n",
326 : __func__,
327 : client->serialDevice,
328 0 : strerror(errno));
329 0 : return DLT_RETURN_ERROR;
330 : }
331 :
332 : #else
333 : return DLT_RETURN_ERROR;
334 : #endif
335 : }
336 : else {
337 0 : if (verbose)
338 0 : dlt_vlog(LOG_ERR,
339 : "%s: ERROR: Device is not a serial device, device = %s (%s) \n",
340 : __func__,
341 : client->serialDevice,
342 0 : strerror(errno));
343 :
344 0 : return DLT_RETURN_ERROR;
345 : }
346 :
347 0 : if (verbose)
348 0 : dlt_vlog(LOG_INFO,
349 : "%s: Connected to %s\n",
350 : __func__,
351 : client->serialDevice);
352 :
353 : receiver_type = DLT_RECEIVE_FD;
354 :
355 : break;
356 1 : case DLT_CLIENT_MODE_UNIX:
357 :
358 1 : if ((client->sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
359 0 : dlt_vlog(LOG_ERR,
360 : "%s: ERROR: (unix) socket error: %s\n",
361 : __func__,
362 0 : strerror(errno));
363 :
364 0 : return DLT_RETURN_ERROR;
365 : }
366 :
367 : memset(&addr, 0, sizeof(addr));
368 1 : addr.sun_family = AF_UNIX;
369 1 : strncpy(addr.sun_path, client->socketPath, sizeof(addr.sun_path) - 1);
370 :
371 1 : if (connect(client->sock,
372 : (struct sockaddr *) &addr,
373 : sizeof(addr)) == -1) {
374 0 : dlt_vlog(LOG_ERR,
375 : "%s: ERROR: (unix) connect error: %s\n",
376 : __func__,
377 0 : strerror(errno));
378 :
379 0 : return DLT_RETURN_ERROR;
380 : }
381 :
382 1 : if (client->sock < 0) {
383 0 : dlt_vlog(LOG_ERR,
384 : "%s: ERROR: Failed to open device %s\n",
385 : __func__,
386 : client->socketPath);
387 :
388 0 : return DLT_RETURN_ERROR;
389 : }
390 :
391 : receiver_type = DLT_RECEIVE_SOCKET;
392 :
393 : break;
394 0 : case DLT_CLIENT_MODE_UDP_MULTICAST:
395 :
396 0 : if ((client->sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
397 : {
398 0 : dlt_vlog(LOG_ERR,
399 : "%s: ERROR: socket error: %s\n",
400 : __func__,
401 0 : strerror(errno));
402 :
403 0 : return DLT_RETURN_ERROR;
404 : }
405 :
406 : /* allow multiple sockets to use the same PORT number */
407 0 : if (setsockopt(client->sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0)
408 : {
409 0 : dlt_vlog(LOG_ERR,
410 : "%s: ERROR: Reusing address failed: %s\n",
411 : __func__,
412 0 : strerror(errno));
413 :
414 0 : return DLT_RETURN_ERROR;
415 : }
416 :
417 0 : memset(&client->receiver.addr, 0, sizeof(client->receiver.addr));
418 0 : client->receiver.addr.sin_family = AF_INET;
419 : client->receiver.addr.sin_addr.s_addr = htonl(INADDR_ANY);
420 0 : client->receiver.addr.sin_port = htons(client->port);
421 :
422 : /* bind to receive address */
423 0 : if (bind(client->sock, (struct sockaddr*) &client->receiver.addr, sizeof(client->receiver.addr)) < 0)
424 : {
425 0 : dlt_vlog(LOG_ERR,
426 : "%s: ERROR: bind failed: %s\n",
427 : __func__,
428 0 : strerror(errno));
429 :
430 0 : return DLT_RETURN_ERROR;
431 : }
432 :
433 0 : mreq.imr_interface.s_addr = htonl(INADDR_ANY);
434 0 : if (client->hostip)
435 : {
436 0 : mreq.imr_interface.s_addr = inet_addr(client->hostip);
437 : }
438 0 : if (client->servIP == NULL)
439 : {
440 0 : dlt_vlog(LOG_ERR,
441 : "%s: ERROR: server address not set\n",
442 : __func__);
443 :
444 0 : return DLT_RETURN_ERROR;
445 : }
446 :
447 0 : char delimiter[] = ",";
448 0 : char* servIP = strtok(client->servIP, delimiter);
449 :
450 0 : while(servIP != NULL) {
451 0 : mreq.imr_multiaddr.s_addr = inet_addr(servIP);
452 0 : if (mreq.imr_multiaddr.s_addr == (in_addr_t)-1)
453 : {
454 0 : dlt_vlog(LOG_ERR,
455 : "%s: ERROR: server address not not valid %s\n",
456 : __func__,
457 : servIP);
458 :
459 0 : return DLT_RETURN_ERROR;
460 : }
461 :
462 0 : if (setsockopt(client->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&mreq, sizeof(mreq)) < 0)
463 : {
464 0 : dlt_vlog(LOG_ERR,
465 : "%s: ERROR: setsockopt add membership failed: %s\n",
466 : __func__,
467 0 : strerror(errno));
468 :
469 0 : return DLT_RETURN_ERROR;
470 : }
471 0 : servIP = strtok(NULL, delimiter);
472 : }
473 : receiver_type = DLT_RECEIVE_UDP_SOCKET;
474 :
475 : break;
476 0 : default:
477 0 : dlt_vlog(LOG_ERR,
478 : "%s: ERROR: Mode not supported: %d\n",
479 : __func__,
480 : client->mode);
481 :
482 0 : return DLT_RETURN_ERROR;
483 : }
484 :
485 4 : if (dlt_receiver_init(&(client->receiver), client->sock, receiver_type, DLT_RECEIVE_BUFSIZE) != DLT_RETURN_OK) {
486 0 : dlt_vlog(LOG_ERR, "%s: ERROR initializing receiver\n", __func__);
487 0 : return DLT_RETURN_ERROR;
488 : }
489 :
490 : return DLT_RETURN_OK;
491 : }
492 :
493 3 : DltReturnValue dlt_client_cleanup(DltClient *client, int verbose)
494 : {
495 : int ret = DLT_RETURN_OK;
496 :
497 3 : if (verbose)
498 0 : dlt_vlog(LOG_INFO, "%s: Cleanup dlt client\n", __func__);
499 :
500 3 : if (client == NULL)
501 : return DLT_RETURN_WRONG_PARAMETER;
502 :
503 3 : if (client->sock != -1)
504 3 : close(client->sock);
505 :
506 3 : if (dlt_receiver_free(&(client->receiver)) != DLT_RETURN_OK) {
507 0 : dlt_vlog(LOG_WARNING, "%s: Failed to free receiver\n", __func__);
508 : ret = DLT_RETURN_ERROR;
509 : }
510 :
511 3 : if (client->serialDevice) {
512 0 : free(client->serialDevice);
513 0 : client->serialDevice = NULL;
514 : }
515 :
516 3 : if (client->servIP) {
517 2 : free(client->servIP);
518 2 : client->servIP = NULL;
519 : }
520 :
521 3 : if (client->socketPath) {
522 1 : free(client->socketPath);
523 1 : client->socketPath = NULL;
524 : }
525 :
526 3 : if (client->hostip) {
527 0 : free(client->hostip);
528 0 : client->hostip = NULL;
529 : }
530 :
531 3 : if (client->ecuid2 != NULL) {
532 0 : free(client->ecuid2);
533 0 : client->ecuid2 = NULL;
534 : }
535 : return ret;
536 : }
537 :
538 2 : DltReturnValue dlt_client_main_loop(DltClient *client, void *data, int verbose)
539 : {
540 : DltMessage msg;
541 : int ret;
542 :
543 2 : if (client == 0)
544 : return DLT_RETURN_ERROR;
545 :
546 2 : if (dlt_message_init(&msg, verbose) == DLT_RETURN_ERROR)
547 : return DLT_RETURN_ERROR;
548 :
549 : bool fetch_next_message = true;
550 345 : while (fetch_next_message) {
551 : /* wait for data from socket or serial connection */
552 345 : ret = dlt_receiver_receive(&(client->receiver));
553 :
554 345 : if (ret <= 0) {
555 : /* No more data to be received */
556 2 : if (dlt_message_free(&msg, verbose) == DLT_RETURN_ERROR)
557 : return DLT_RETURN_ERROR;
558 :
559 : return DLT_RETURN_TRUE;
560 : }
561 :
562 518 : while (dlt_message_read(&msg, (unsigned char *)(client->receiver.buf),
563 518 : (unsigned int)client->receiver.bytesRcvd,
564 : client->resync_serial_header,
565 518 : verbose) == DLT_MESSAGE_ERROR_OK)
566 : {
567 : /* Call callback function */
568 175 : if (message_callback_function)
569 175 : (*message_callback_function)(&msg, data);
570 :
571 175 : int total_size = (int)((size_t)msg.headersize
572 175 : + (size_t)msg.datasize
573 175 : - sizeof(DltStorageHeader));
574 :
575 175 : if (msg.found_serialheader) {
576 : total_size += (int)sizeof(dltSerialHeader);
577 : }
578 :
579 175 : if (dlt_receiver_remove(&(client->receiver),
580 : total_size) == DLT_RETURN_ERROR) {
581 : /* Return value ignored */
582 0 : dlt_message_free(&msg, verbose);
583 0 : return DLT_RETURN_ERROR;
584 : }
585 : }
586 :
587 343 : if (dlt_receiver_move_to_begin(&(client->receiver)) == DLT_RETURN_ERROR) {
588 : /* Return value ignored */
589 0 : dlt_message_free(&msg, verbose);
590 0 : return DLT_RETURN_ERROR;
591 : }
592 343 : if (fetch_next_message_callback_function)
593 0 : fetch_next_message = (*fetch_next_message_callback_function)(data);
594 : }
595 :
596 0 : if (dlt_message_free(&msg, verbose) == DLT_RETURN_ERROR)
597 : return DLT_RETURN_ERROR;
598 :
599 : return DLT_RETURN_OK;
600 : }
601 :
602 0 : DltReturnValue dlt_client_main_loop_v2(DltClient *client, void *data, int verbose)
603 : {
604 : DltMessageV2 msg;
605 : int ret;
606 0 : if (client == 0)
607 : return DLT_RETURN_ERROR;
608 0 : if (dlt_message_init_v2(&msg, verbose) == DLT_RETURN_ERROR)
609 : return DLT_RETURN_ERROR;
610 :
611 : bool fetch_next_message = true;
612 0 : while (fetch_next_message) {
613 :
614 : /* wait for data from socket or serial connection */
615 0 : ret = dlt_receiver_receive(&(client->receiver));
616 :
617 0 : if (ret <= 0) {
618 : /* No more data to be received */
619 0 : if (dlt_message_free_v2(&msg, verbose) == DLT_RETURN_ERROR)
620 : return DLT_RETURN_ERROR;
621 :
622 : return DLT_RETURN_TRUE;
623 : }
624 :
625 0 : while (dlt_message_read_v2(&msg, (unsigned char *)(client->receiver.buf),
626 0 : (unsigned int)client->receiver.bytesRcvd,
627 : client->resync_serial_header,
628 0 : verbose) == DLT_MESSAGE_ERROR_OK)
629 : {
630 : /* Call callback function */
631 0 : if (message_callback_function_v2) {
632 0 : (*message_callback_function_v2)(&msg, data);
633 : }
634 :
635 0 : if (msg.found_serialheader) {
636 0 : int64_t temp_remove_size = (int64_t)msg.headersizev2 + (int64_t)msg.datasize - (int64_t)msg.storageheadersizev2 + (int64_t)sizeof(dltSerialHeader);
637 0 : if (temp_remove_size < 0 || temp_remove_size > UINT32_MAX) {
638 0 : dlt_message_free_v2(&msg, verbose);
639 0 : return DLT_RETURN_ERROR;
640 : }
641 : uint32_t remove_size = (uint32_t)temp_remove_size;
642 0 : if (dlt_receiver_remove(&(client->receiver), (int)remove_size) == DLT_RETURN_ERROR) {
643 : /* Return value ignored */
644 0 : dlt_message_free_v2(&msg, verbose);
645 0 : return DLT_RETURN_ERROR;
646 : }
647 : }
648 0 : else if (dlt_receiver_remove(&(client->receiver),
649 0 : (int) ((uint32_t)msg.headersizev2 + (uint32_t)msg.datasize - msg.storageheadersizev2)) ==
650 : DLT_RETURN_ERROR) {
651 : /* Return value ignored */
652 0 : dlt_message_free_v2(&msg, verbose);
653 0 : return DLT_RETURN_ERROR;
654 : }
655 0 : dlt_message_free_v2(&msg, verbose);
656 : }
657 :
658 0 : if (dlt_receiver_move_to_begin(&(client->receiver)) == DLT_RETURN_ERROR) {
659 : /* Return value ignored */
660 0 : dlt_message_free_v2(&msg, verbose);
661 0 : return DLT_RETURN_ERROR;
662 : }
663 0 : if (fetch_next_message_callback_function)
664 0 : fetch_next_message = (*fetch_next_message_callback_function)(data);
665 : }
666 :
667 0 : if (dlt_message_free_v2(&msg, verbose) == DLT_RETURN_ERROR)
668 : return DLT_RETURN_ERROR;
669 :
670 : return DLT_RETURN_OK;
671 : }
672 :
673 1 : DltReturnValue dlt_client_send_message_to_socket(DltClient *client, DltMessage *msg)
674 : {
675 : int ret = 0;
676 :
677 1 : if ((client == NULL) || (client->sock < 0)
678 1 : || (msg == NULL) || (msg->databuffer == NULL))
679 : {
680 0 : dlt_log(LOG_ERR, "Invalid parameters\n");
681 0 : return DLT_RETURN_ERROR;
682 : }
683 :
684 1 : if (client->send_serial_header)
685 : {
686 0 : ret = (int)send(client->sock, (const char *)dltSerialHeader,
687 : sizeof(dltSerialHeader), 0);
688 0 : if (ret < 0)
689 : {
690 0 : dlt_vlog(LOG_ERR, "Sending serial header failed: %s\n",
691 0 : strerror(errno));
692 0 : return DLT_RETURN_ERROR;
693 : }
694 : }
695 :
696 2 : ret = (int)send(client->sock,
697 : (const char *)(msg->headerbuffer + sizeof(DltStorageHeader)),
698 1 : (size_t)((int32_t)msg->headersize - (int32_t)sizeof(DltStorageHeader)), 0);
699 1 : if (ret < 0)
700 : {
701 0 : dlt_vlog(LOG_ERR, "Sending message header failed: %s\n", strerror(errno));
702 0 : return DLT_RETURN_ERROR;
703 : }
704 :
705 1 : ret = (int)send(client->sock, (const char *)msg->databuffer, (size_t)msg->datasize, 0);
706 1 : if ( ret < 0)
707 : {
708 0 : dlt_vlog(LOG_ERR, "Sending message failed: %s\n", strerror(errno));
709 0 : return DLT_RETURN_ERROR;
710 : }
711 :
712 : return DLT_RETURN_OK;
713 : }
714 :
715 0 : DltReturnValue dlt_client_send_message_to_socket_v2(DltClient *client, DltMessageV2 *msg)
716 : {
717 : int ret = 0;
718 :
719 0 : if ((client == NULL) || (client->sock < 0)
720 0 : || (msg == NULL) || (msg->databuffer == NULL))
721 : {
722 0 : dlt_log(LOG_ERR, "Invalid parameters\n");
723 0 : return DLT_RETURN_ERROR;
724 : }
725 :
726 0 : if (client->send_serial_header)
727 : {
728 0 : ret = send(client->sock, (const char *)dltSerialHeader,
729 : sizeof(dltSerialHeader), 0);
730 0 : if (ret < 0)
731 : {
732 0 : dlt_vlog(LOG_ERR, "Sending serial header failed: %s\n",
733 0 : strerror(errno));
734 0 : return DLT_RETURN_ERROR;
735 : }
736 : }
737 :
738 0 : ret = send(client->sock,
739 0 : (const char *)(msg->headerbufferv2 + msg->storageheadersizev2),
740 0 : (uint32_t)msg->headersizev2 - msg->storageheadersizev2, 0);
741 0 : if (ret < 0)
742 : {
743 0 : dlt_vlog(LOG_ERR, "Sending message header failed: %s\n", strerror(errno));
744 0 : return DLT_RETURN_ERROR;
745 : }
746 :
747 0 : ret = send(client->sock, (const char *)msg->databuffer, (size_t)msg->datasize, 0);
748 0 : if ( ret < 0)
749 : {
750 0 : dlt_vlog(LOG_ERR, "Sending message failed: %s\n", strerror(errno));
751 0 : return DLT_RETURN_ERROR;
752 : }
753 :
754 : return DLT_RETURN_OK;
755 : }
756 :
757 8 : DltReturnValue dlt_client_send_ctrl_msg(DltClient *client, char *apid, char *ctid, uint8_t *payload, uint32_t size)
758 : {
759 : DltMessage msg;
760 : int ret;
761 :
762 : int32_t len;
763 : uint32_t id_tmp;
764 : uint32_t id;
765 :
766 8 : if ((client == 0) || (client->sock < 0) || (apid == 0) || (ctid == 0))
767 : return DLT_RETURN_ERROR;
768 :
769 : /* initialise new message */
770 8 : if (dlt_message_init(&msg, 0) == DLT_RETURN_ERROR)
771 : return DLT_RETURN_ERROR;
772 :
773 : /* prepare payload of data */
774 8 : msg.datasize = (int32_t)size;
775 :
776 8 : if (msg.databuffer && (msg.databuffersize < msg.datasize)) {
777 0 : free(msg.databuffer);
778 0 : msg.databuffer = 0;
779 : }
780 :
781 8 : if (msg.databuffer == 0) {
782 8 : msg.databuffer = (uint8_t *)malloc((size_t)msg.datasize);
783 8 : msg.databuffersize = msg.datasize;
784 : }
785 :
786 8 : if (msg.databuffer == 0) {
787 0 : dlt_message_free(&msg, 0);
788 0 : return DLT_RETURN_ERROR;
789 : }
790 :
791 : /* copy data */
792 8 : memcpy(msg.databuffer, payload, size);
793 :
794 : /* prepare storage header */
795 8 : msg.storageheader = (DltStorageHeader *)msg.headerbuffer;
796 :
797 8 : if (dlt_set_storageheader(msg.storageheader, "") == DLT_RETURN_ERROR) {
798 0 : dlt_message_free(&msg, 0);
799 0 : return DLT_RETURN_ERROR;
800 : }
801 :
802 : /* prepare standard header */
803 8 : msg.standardheader = (DltStandardHeader *)(msg.headerbuffer + sizeof(DltStorageHeader));
804 8 : msg.standardheader->htyp = DLT_HTYP_WEID | DLT_HTYP_WTMS | DLT_HTYP_UEH | DLT_HTYP_PROTOCOL_VERSION1;
805 :
806 : #if (BYTE_ORDER == BIG_ENDIAN)
807 : msg.standardheader->htyp = (msg.standardheader->htyp | DLT_HTYP_MSBF);
808 : #endif
809 :
810 8 : msg.standardheader->mcnt = 0;
811 :
812 : /* Set header extra parameters */
813 8 : dlt_set_id(msg.headerextra.ecu, client->ecuid);
814 : /*msg.headerextra.seid = 0; */
815 8 : msg.headerextra.tmsp = dlt_uptime();
816 :
817 : /* Copy header extra parameters to headerbuffer */
818 8 : if (dlt_message_set_extraparameters(&msg, 0) == DLT_RETURN_ERROR) {
819 0 : dlt_message_free(&msg, 0);
820 0 : return DLT_RETURN_ERROR;
821 : }
822 :
823 : /* prepare extended header */
824 8 : msg.extendedheader = (DltExtendedHeader *)(msg.headerbuffer +
825 : sizeof(DltStorageHeader) +
826 8 : sizeof(DltStandardHeader) +
827 8 : DLT_STANDARD_HEADER_EXTRA_SIZE(msg.standardheader->htyp));
828 :
829 8 : msg.extendedheader->msin = DLT_MSIN_CONTROL_REQUEST;
830 :
831 8 : msg.extendedheader->noar = 1; /* number of arguments */
832 :
833 15 : dlt_set_id(msg.extendedheader->apid, (apid[0] == '\0') ? DLT_CLIENT_DUMMY_APP_ID : apid);
834 15 : dlt_set_id(msg.extendedheader->ctid, (ctid[0] == '\0') ? DLT_CLIENT_DUMMY_CON_ID : ctid);
835 :
836 : /* prepare length information */
837 8 : msg.headersize = (int32_t)(sizeof(DltStorageHeader) +
838 : sizeof(DltStandardHeader) +
839 8 : sizeof(DltExtendedHeader) +
840 8 : DLT_STANDARD_HEADER_EXTRA_SIZE(msg.standardheader->htyp));
841 :
842 8 : len = (int32_t)((size_t)msg.headersize - sizeof(DltStorageHeader) + (size_t)msg.datasize);
843 :
844 :
845 8 : if (len > UINT16_MAX) {
846 0 : dlt_vlog(LOG_ERR,
847 : "%s: Critical: Huge injection message discarded!\n",
848 : __func__);
849 :
850 0 : dlt_message_free(&msg, 0);
851 :
852 0 : return DLT_RETURN_ERROR;
853 : }
854 :
855 8 : msg.standardheader->len = (uint16_t)DLT_HTOBE_16((uint16_t)len);
856 :
857 : /* Send data (without storage header) */
858 8 : if ((client->mode == DLT_CLIENT_MODE_TCP) || (client->mode == DLT_CLIENT_MODE_SERIAL)) {
859 : /* via FileDescriptor */
860 8 : if (client->send_serial_header)
861 : {
862 0 : ret = write(client->sock, dltSerialHeader, sizeof(dltSerialHeader));
863 0 : if (ret < 0)
864 : {
865 0 : dlt_log(LOG_ERR, "Sending message failed\n");
866 0 : dlt_message_free(&msg, 0);
867 0 : return DLT_RETURN_ERROR;
868 : }
869 : }
870 :
871 16 : ret = (int) write(client->sock,
872 : msg.headerbuffer + sizeof(DltStorageHeader),
873 8 : (size_t)((int32_t)msg.headersize - (int32_t)sizeof(DltStorageHeader)));
874 :
875 8 : if (0 > ret) {
876 0 : dlt_vlog(LOG_ERR, "%s: Sending message failed\n", __func__);
877 0 : dlt_message_free(&msg, 0);
878 0 : return DLT_RETURN_ERROR;
879 : }
880 :
881 16 : ret = (int) write(client->sock,
882 8 : msg.databuffer,
883 8 : (size_t)msg.datasize);
884 :
885 8 : if (0 > ret) {
886 0 : dlt_vlog(LOG_ERR, "%s: Sending message failed\n", __func__);
887 0 : dlt_message_free(&msg, 0);
888 0 : return DLT_RETURN_ERROR;
889 : }
890 :
891 8 : id_tmp = *((uint32_t *)(msg.databuffer));
892 8 : id = DLT_ENDIAN_GET_32(msg.standardheader->htyp, id_tmp);
893 :
894 8 : dlt_vlog(LOG_INFO,
895 : "%s: Control message forwarded : %s\n",
896 : __func__,
897 : dlt_get_service_name(id));
898 : }
899 : else {
900 : /* via Socket */
901 0 : if (dlt_client_send_message_to_socket(client, &msg) == DLT_RETURN_ERROR)
902 : {
903 0 : dlt_log(LOG_ERR, "Sending message to socket failed\n");
904 0 : dlt_message_free(&msg, 0);
905 0 : return DLT_RETURN_ERROR;
906 : }
907 : }
908 :
909 : /* free message */
910 8 : if (dlt_message_free(&msg, 0) == DLT_RETURN_ERROR)
911 : return DLT_RETURN_ERROR;
912 :
913 : return DLT_RETURN_OK;
914 : }
915 :
916 0 : DltReturnValue dlt_client_send_ctrl_msg_v2(DltClient *client, char *apid, char *ctid, uint8_t *payload, uint32_t size)
917 : {
918 : DltMessageV2 msg;
919 : int ret;
920 : int32_t len;
921 : uint32_t id_tmp;
922 : uint32_t id;
923 : uint8_t appidlen;
924 : uint8_t ctxidlen;
925 : char ecid_buf[DLT_V2_ID_SIZE];
926 : char apid_buf[DLT_V2_ID_SIZE];
927 : char ctid_buf[DLT_V2_ID_SIZE];
928 :
929 0 : if ((client == 0) || (client->sock < 0) || (apid == NULL) || (ctid == NULL))
930 : return DLT_RETURN_ERROR;
931 :
932 : /* initialise new message */
933 0 : if (dlt_message_init_v2(&msg, 0) == DLT_RETURN_ERROR)
934 : return DLT_RETURN_ERROR;
935 :
936 : /* prepare payload of data */
937 0 : msg.datasize = (int32_t)size;
938 :
939 0 : if (msg.databuffer && (msg.databuffersize < msg.datasize)) {
940 0 : free(msg.databuffer);
941 0 : msg.databuffer = 0;
942 : }
943 :
944 0 : if (msg.databuffer == 0) {
945 0 : msg.databuffer = (uint8_t *)malloc((size_t)msg.datasize);
946 0 : msg.databuffersize = msg.datasize;
947 : }
948 :
949 0 : if (msg.databuffer == 0) {
950 0 : dlt_message_free_v2(&msg, 0);
951 0 : return DLT_RETURN_ERROR;
952 : }
953 :
954 : /* copy data */
955 0 : memcpy(msg.databuffer, payload, size);
956 :
957 0 : if (strcmp(apid, "") == 0){
958 : appidlen = strlen(DLT_CLIENT_DUMMY_APP_ID);
959 : }else {
960 0 : appidlen = strlen(apid);
961 : }
962 :
963 0 : if (strcmp(ctid, "") == 0){
964 : ctxidlen = strlen(DLT_CLIENT_DUMMY_CON_ID);
965 : }else {
966 0 : ctxidlen = strlen(ctid);
967 : }
968 :
969 0 : msg.storageheadersizev2 = STORAGE_HEADER_V2_FIXED_SIZE;
970 0 : msg.baseheadersizev2 = BASE_HEADER_V2_FIXED_SIZE;
971 0 : msg.baseheaderextrasizev2 = (int32_t)dlt_message_get_extraparameters_size_v2(DLT_CONTROL_MSG);
972 0 : msg.extendedheadersizev2 = (uint32_t)(client->ecuid2len) + 1 + appidlen + 1 + ctxidlen + 1;
973 :
974 0 : msg.headersizev2 = (int32_t) (msg.storageheadersizev2 + msg.baseheadersizev2 +
975 0 : msg.baseheaderextrasizev2 + msg.extendedheadersizev2);
976 :
977 0 : if (msg.headerbufferv2 != NULL) {
978 0 : free(msg.headerbufferv2);
979 : msg.headerbufferv2 = NULL;
980 : }
981 :
982 0 : msg.headerbufferv2 = (uint8_t*)malloc((size_t)msg.headersizev2);
983 :
984 0 : if (dlt_set_storageheader_v2(&(msg.storageheaderv2), 0, NULL) == DLT_RETURN_ERROR) {
985 0 : dlt_message_free_v2(&msg, 0);
986 0 : return DLT_RETURN_ERROR;
987 : }
988 :
989 0 : if (dlt_message_set_storageparameters_v2(&msg, 0) != DLT_RETURN_OK) {
990 0 : dlt_message_free_v2(&msg, 0);
991 0 : return DLT_RETURN_ERROR;
992 : }
993 :
994 : /* prepare base header */
995 0 : msg.baseheaderv2 = (DltBaseHeaderV2 *)(msg.headerbufferv2 + msg.storageheadersizev2);
996 :
997 : msg.baseheaderv2->htyp2 = DLT_HTYP2_PROTOCOL_VERSION2;
998 : msg.baseheaderv2->htyp2 |= DLT_CONTROL_MSG;
999 : msg.baseheaderv2->htyp2 |= DLT_HTYP2_WEID;
1000 0 : msg.baseheaderv2->htyp2 |= DLT_HTYP2_WACID;
1001 0 : msg.baseheaderv2->mcnt = 0;
1002 :
1003 : /* Fill base header conditional parameters */
1004 0 : msg.headerextrav2.msin = DLT_MSIN_CONTROL_REQUEST;
1005 0 : msg.headerextrav2.noar = 1; /* number of arguments */
1006 : memset(msg.headerextrav2.seconds, 0, 5);
1007 0 : msg.headerextrav2.nanoseconds = 0;
1008 : #if defined (__WIN32__) || defined(_MSC_VER)
1009 : time_t t = time(NULL);
1010 : if (t==-1){
1011 : uint32_t tcnt = (uint32_t)(GetTickCount()); /* GetTickCount() in 10 ms resolution */
1012 : tcnt_seconds = tcnt / 100;
1013 : tcnt_ns = (tcnt - (tcnt*100)) * 10000;
1014 : msg.headerextrav2.seconds[0]=(tcnt_seconds >> 32) & 0xFF;
1015 : msg.headerextrav2.seconds[1]=(tcnt_seconds >> 24) & 0xFF;
1016 : msg.headerextrav2.seconds[2]=(tcnt_seconds >> 16) & 0xFF;
1017 : msg.headerextrav2.seconds[3]=(tcnt_seconds >> 8) & 0xFF;
1018 : msg.headerextrav2.seconds[4]= tcnt_seconds & 0xFF;
1019 : if (ts.tv_nsec < 0x3B9ACA00) {
1020 : msg.headerextrav2.nanoseconds = tcnt_ns;
1021 : }
1022 : }else{
1023 : msg.headerextrav2.seconds[0]=(t >> 32) & 0xFF;
1024 : msg.headerextrav2.seconds[1]=(t >> 24) & 0xFF;
1025 : msg.headerextrav2.seconds[2]=(t >> 16) & 0xFF;
1026 : msg.headerextrav2.seconds[3]=(t >> 8) & 0xFF;
1027 : msg.headerextrav2.seconds[4]= t & 0xFF;
1028 : msg.headerextrav2.nanoseconds |= 0x8000;
1029 : }
1030 : #else
1031 : struct timespec ts;
1032 0 : if(clock_gettime(CLOCK_REALTIME, &ts) == 0) {
1033 0 : msg.headerextrav2.seconds[0]=(ts.tv_sec >> 32) & 0xFF;
1034 0 : msg.headerextrav2.seconds[1]=(ts.tv_sec >> 24) & 0xFF;
1035 0 : msg.headerextrav2.seconds[2]=(ts.tv_sec >> 16) & 0xFF;
1036 0 : msg.headerextrav2.seconds[3]=(ts.tv_sec >> 8) & 0xFF;
1037 0 : msg.headerextrav2.seconds[4]= ts.tv_sec & 0xFF;
1038 0 : if (ts.tv_nsec < 0x3B9ACA00) {
1039 0 : msg.headerextrav2.nanoseconds = (uint32_t) ts.tv_nsec; /* value is long */
1040 : }
1041 0 : }else if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
1042 0 : msg.headerextrav2.seconds[0]=(ts.tv_sec >> 32) & 0xFF;
1043 0 : msg.headerextrav2.seconds[1]=(ts.tv_sec >> 24) & 0xFF;
1044 0 : msg.headerextrav2.seconds[2]=(ts.tv_sec >> 16) & 0xFF;
1045 0 : msg.headerextrav2.seconds[3]=(ts.tv_sec >> 8) & 0xFF;
1046 0 : msg.headerextrav2.seconds[4]= ts.tv_sec & 0xFF;
1047 0 : if (ts.tv_nsec < 0x3B9ACA00) {
1048 0 : msg.headerextrav2.nanoseconds = (uint32_t) ts.tv_nsec; /* value is long */
1049 : }
1050 0 : msg.headerextrav2.nanoseconds |= 0x8000;
1051 : }
1052 : #endif
1053 :
1054 : /* Copy header extra parameters to headerbuffer */
1055 0 : if (dlt_message_set_extraparameters_v2(&msg, 0) == DLT_RETURN_ERROR) {
1056 0 : dlt_message_free_v2(&msg, 0);
1057 0 : return DLT_RETURN_ERROR;
1058 : }
1059 :
1060 : /* Fill out extended header */
1061 0 : if (DLT_IS_HTYP2_WEID(msg.baseheaderv2->htyp2)) {
1062 0 : msg.extendedheaderv2.ecidlen = client->ecuid2len;
1063 0 : if (msg.extendedheaderv2.ecidlen > 0) {
1064 0 : dlt_set_id_v2(ecid_buf, client->ecuid2, msg.extendedheaderv2.ecidlen);
1065 0 : msg.extendedheaderv2.ecid = ecid_buf;
1066 : } else {
1067 0 : msg.extendedheaderv2.ecid = NULL;
1068 : }
1069 : }
1070 :
1071 0 : if (DLT_IS_HTYP2_WACID(msg.baseheaderv2->htyp2)) {
1072 0 : msg.extendedheaderv2.apidlen = appidlen;
1073 0 : if (msg.extendedheaderv2.apidlen > 0) {
1074 0 : if (strcmp(apid, "") == 0) {
1075 0 : dlt_set_id_v2(apid_buf, DLT_CLIENT_DUMMY_APP_ID, msg.extendedheaderv2.apidlen);
1076 : } else {
1077 0 : dlt_set_id_v2(apid_buf, apid, msg.extendedheaderv2.apidlen);
1078 : }
1079 0 : msg.extendedheaderv2.apid = apid_buf;
1080 : } else {
1081 0 : msg.extendedheaderv2.apid = NULL;
1082 : }
1083 0 : msg.extendedheaderv2.apidlen = appidlen;
1084 0 : msg.extendedheaderv2.ctidlen = ctxidlen;
1085 0 : if (msg.extendedheaderv2.ctidlen > 0) {
1086 0 : if (strcmp(ctid, "") == 0) {
1087 0 : dlt_set_id_v2(ctid_buf, DLT_CLIENT_DUMMY_CON_ID, msg.extendedheaderv2.ctidlen);
1088 : } else {
1089 0 : dlt_set_id_v2(ctid_buf, ctid, msg.extendedheaderv2.ctidlen);
1090 : }
1091 0 : msg.extendedheaderv2.ctid = ctid_buf;
1092 : } else {
1093 0 : msg.extendedheaderv2.ctid = NULL;
1094 : }
1095 : }
1096 :
1097 0 : if (dlt_message_set_extendedparameters_v2(&msg) != DLT_RETURN_OK) {
1098 0 : dlt_message_free_v2(&msg, 0);
1099 0 : return DLT_RETURN_ERROR;
1100 : }
1101 :
1102 0 : len = msg.headersizev2 - (int32_t) msg.storageheadersizev2 + msg.datasize;
1103 :
1104 0 : if (len > UINT16_MAX) {
1105 0 : dlt_vlog(LOG_ERR,
1106 : "%s: Critical: Huge injection message discarded!\n",
1107 : __func__);
1108 0 : dlt_message_free_v2(&msg, 0);
1109 0 : return DLT_RETURN_ERROR;
1110 : }
1111 0 : msg.baseheaderv2->len = (uint16_t)len;
1112 :
1113 : /* Send data (without storage header) */
1114 0 : if ((client->mode == DLT_CLIENT_MODE_TCP) || (client->mode == DLT_CLIENT_MODE_SERIAL)) {
1115 : /* via FileDescriptor */
1116 0 : if (client->send_serial_header)
1117 : {
1118 0 : ret = write(client->sock, dltSerialHeader, sizeof(dltSerialHeader));
1119 0 : if (ret < 0)
1120 : {
1121 0 : dlt_log(LOG_ERR, "Sending message failed\n");
1122 0 : dlt_message_free_v2(&msg, 0);
1123 0 : return DLT_RETURN_ERROR;
1124 : }
1125 : }
1126 0 : ret =
1127 0 : (int) write(client->sock, msg.headerbufferv2 + msg.storageheadersizev2 , (uint32_t)msg.headersizev2 - msg.storageheadersizev2);
1128 :
1129 0 : if (0 > ret) {
1130 0 : dlt_vlog(LOG_ERR, "%s: Sending message failed\n", __func__);
1131 0 : dlt_message_free_v2(&msg, 0);
1132 0 : return DLT_RETURN_ERROR;
1133 : }
1134 :
1135 0 : ret = (int) write(client->sock, msg.databuffer, (uint32_t)msg.datasize);
1136 :
1137 0 : if (0 > ret) {
1138 0 : dlt_vlog(LOG_ERR, "%s: Sending message failed\n", __func__);
1139 0 : dlt_message_free_v2(&msg, 0);
1140 0 : return DLT_RETURN_ERROR;
1141 : }
1142 :
1143 0 : id_tmp = *((uint32_t *)(msg.databuffer));
1144 : id = DLT_LETOH_32(id_tmp);
1145 :
1146 0 : dlt_vlog(LOG_INFO,
1147 : "%s: Control message forwarded : %s\n",
1148 : __func__,
1149 : dlt_get_service_name(id));
1150 : }
1151 : else {
1152 : /* via Socket */
1153 0 : if (dlt_client_send_message_to_socket_v2(client, &msg) == DLT_RETURN_ERROR)
1154 : {
1155 0 : dlt_log(LOG_ERR, "Sending message to socket failed\n");
1156 0 : dlt_message_free_v2(&msg, 0);
1157 0 : return DLT_RETURN_ERROR;
1158 : }
1159 : }
1160 :
1161 : /* free message */
1162 0 : if (dlt_message_free_v2(&msg, 0) == DLT_RETURN_ERROR)
1163 : return DLT_RETURN_ERROR;
1164 :
1165 :
1166 : return DLT_RETURN_OK;
1167 : }
1168 :
1169 0 : DltReturnValue dlt_client_send_inject_msg(DltClient *client,
1170 : char *apid,
1171 : char *ctid,
1172 : uint32_t serviceID,
1173 : uint8_t *buffer,
1174 : uint32_t size)
1175 : {
1176 : uint8_t *payload;
1177 : int offset;
1178 :
1179 0 : payload = (uint8_t *)malloc(sizeof(uint32_t) + sizeof(uint32_t) + size);
1180 :
1181 0 : if (payload == 0)
1182 : return DLT_RETURN_ERROR;
1183 :
1184 : offset = 0;
1185 : memcpy(payload, &serviceID, sizeof(serviceID));
1186 : offset += (int) sizeof(uint32_t);
1187 0 : memcpy(payload + offset, &size, sizeof(size));
1188 : offset += (int) sizeof(uint32_t);
1189 0 : memcpy(payload + offset, buffer, size);
1190 :
1191 : /* free message */
1192 0 : if (dlt_client_send_ctrl_msg(client, apid, ctid, payload,
1193 : (uint32_t) (sizeof(uint32_t) + sizeof(uint32_t) + size)) == DLT_RETURN_ERROR) {
1194 0 : free(payload);
1195 0 : return DLT_RETURN_ERROR;
1196 : }
1197 :
1198 0 : free(payload);
1199 :
1200 0 : return DLT_RETURN_OK;
1201 :
1202 : }
1203 :
1204 0 : DltReturnValue dlt_client_send_inject_msg_v2(DltClient *client,
1205 : char *apid,
1206 : char *ctid,
1207 : uint32_t serviceID,
1208 : uint8_t *buffer,
1209 : uint32_t size)
1210 : {
1211 : uint8_t *payload;
1212 : int offset;
1213 :
1214 0 : payload = (uint8_t *)malloc(sizeof(uint32_t) + sizeof(uint32_t) + size);
1215 :
1216 0 : if (payload == 0)
1217 : return DLT_RETURN_ERROR;
1218 :
1219 : offset = 0;
1220 : memcpy(payload, &serviceID, sizeof(serviceID));
1221 : offset += (int) sizeof(uint32_t);
1222 0 : memcpy(payload + offset, &size, sizeof(size));
1223 : offset += (int) sizeof(uint32_t);
1224 0 : memcpy(payload + offset, buffer, size);
1225 :
1226 : /* free message */
1227 0 : if (dlt_client_send_ctrl_msg_v2(client, apid, ctid, payload,
1228 : (uint32_t) (sizeof(uint32_t) + sizeof(uint32_t) + size)) == DLT_RETURN_ERROR) {
1229 0 : free(payload);
1230 0 : return DLT_RETURN_ERROR;
1231 : }
1232 :
1233 0 : free(payload);
1234 :
1235 0 : return DLT_RETURN_OK;
1236 :
1237 : }
1238 :
1239 1 : DltReturnValue dlt_client_send_log_level(DltClient *client, char *apid, char *ctid, uint8_t logLevel)
1240 : {
1241 : DltServiceSetLogLevel *req;
1242 : int ret = DLT_RETURN_ERROR;
1243 :
1244 1 : if (client == NULL)
1245 : return ret;
1246 :
1247 1 : req = calloc(1, sizeof(DltServiceSetLogLevel));
1248 :
1249 1 : if (req == NULL)
1250 : return ret;
1251 :
1252 1 : req->service_id = DLT_SERVICE_ID_SET_LOG_LEVEL;
1253 1 : dlt_set_id(req->apid, apid);
1254 1 : dlt_set_id(req->ctid, ctid);
1255 1 : req->log_level = logLevel;
1256 1 : dlt_set_id(req->com, "remo");
1257 :
1258 : /* free message */
1259 1 : ret = dlt_client_send_ctrl_msg(client,
1260 : "APP",
1261 : "CON",
1262 : (uint8_t *)req,
1263 : sizeof(DltServiceSetLogLevel));
1264 :
1265 :
1266 1 : free(req);
1267 :
1268 1 : return ret;
1269 : }
1270 :
1271 0 : DltReturnValue dlt_client_send_log_level_v2(DltClient *client, char *apid, char *ctid, uint8_t logLevel)
1272 : {
1273 : DltServiceSetLogLevelV2 req;
1274 : int ret = DLT_RETURN_ERROR;
1275 : uint8_t *buffer;
1276 : uint16_t buffersize;
1277 : uint16_t offset = 0;
1278 :
1279 0 : if (client == NULL)
1280 : return ret;
1281 :
1282 0 : req.service_id = DLT_SERVICE_ID_SET_LOG_LEVEL;
1283 0 : req.apidlen = strlen(apid);
1284 0 : req.apid = apid;
1285 0 : req.ctidlen = strlen(ctid);
1286 0 : req.ctid = ctid;
1287 0 : req.log_level = logLevel;
1288 0 : dlt_set_id(req.com, "remo");
1289 :
1290 0 : buffersize = DLT_SERVICE_SET_LOG_LEVEL_FIXED_SIZE_V2 + req.apidlen + req.ctidlen;
1291 :
1292 0 : buffer = (uint8_t *)malloc(buffersize);
1293 0 : if (buffer == NULL)
1294 : return ret;
1295 :
1296 : memcpy(buffer + offset, &(req.service_id), 4);
1297 : offset = offset + 4;
1298 0 : memcpy(buffer + offset, &(req.apidlen), 1);
1299 : offset = offset + 1;
1300 0 : memcpy(buffer + offset, req.apid, req.apidlen);
1301 0 : offset = offset + req.apidlen;
1302 0 : memcpy(buffer + offset, &(req.ctidlen), 1);
1303 0 : offset = offset + 1;
1304 0 : memcpy(buffer + offset, req.ctid, req.ctidlen);
1305 0 : offset = offset + req.ctidlen;
1306 0 : memcpy(buffer + offset, &(req.log_level), 1);
1307 0 : offset = offset + 1;
1308 0 : memcpy(buffer + offset, req.com, 4);
1309 :
1310 0 : ret = dlt_client_send_ctrl_msg_v2(client,
1311 : "APP",
1312 : "CON",
1313 : (uint8_t *)buffer,
1314 : buffersize);
1315 :
1316 :
1317 0 : free(buffer);
1318 :
1319 0 : return ret;
1320 : }
1321 :
1322 3 : DltReturnValue dlt_client_get_log_info(DltClient *client)
1323 : {
1324 : DltServiceGetLogInfoRequest *req;
1325 : int ret = DLT_RETURN_ERROR;
1326 :
1327 3 : if (client == NULL)
1328 : return ret;
1329 :
1330 3 : req = (DltServiceGetLogInfoRequest *)malloc(sizeof(DltServiceGetLogInfoRequest));
1331 :
1332 3 : if (req == NULL)
1333 : return ret;
1334 :
1335 3 : req->service_id = DLT_SERVICE_ID_GET_LOG_INFO;
1336 3 : req->options = 7;
1337 3 : dlt_set_id(req->apid, "");
1338 3 : dlt_set_id(req->ctid, "");
1339 3 : dlt_set_id(req->com, "remo");
1340 :
1341 : /* send control message to daemon*/
1342 3 : ret = dlt_client_send_ctrl_msg(client,
1343 : "",
1344 : "",
1345 : (uint8_t *)req,
1346 : sizeof(DltServiceGetLogInfoRequest));
1347 :
1348 3 : free(req);
1349 :
1350 3 : return ret;
1351 : }
1352 :
1353 0 : int dlt_client_get_log_info_v2(DltClient *client)
1354 : {
1355 : DltServiceGetLogInfoRequestV2 req;
1356 : int ret = DLT_RETURN_ERROR;
1357 : uint8_t *buffer;
1358 : uint16_t buffersize;
1359 : uint16_t offset = 0;
1360 :
1361 0 : if (client == NULL)
1362 : return ret;
1363 :
1364 0 : req.service_id = DLT_SERVICE_ID_GET_LOG_INFO;
1365 0 : req.options = 7;
1366 0 : req.apidlen = 0;
1367 0 : req.apid = NULL;
1368 0 : req.ctidlen = 0;
1369 0 : req.ctid = NULL;
1370 0 : dlt_set_id(req.com, "remo");
1371 :
1372 0 : buffersize = DLT_SERVICE_GET_LOG_INFO_REQUEST_FIXED_SIZE_V2 + req.apidlen + req.ctidlen;
1373 :
1374 0 : buffer = (uint8_t *)malloc(buffersize);
1375 0 : if (buffer == NULL)
1376 : return ret;
1377 :
1378 : memcpy(buffer + offset, &(req.service_id), 4);
1379 : offset = offset + 4;
1380 0 : memcpy(buffer + offset, &(req.options), 1);
1381 : offset = offset + 1;
1382 0 : memcpy(buffer + offset, &(req.apidlen), 1);
1383 : offset = offset + 1;
1384 : // Since App Id is null, not copying it into buffer
1385 0 : memcpy(buffer + offset, &(req.ctidlen), 1);
1386 : offset = offset + 1;
1387 : // Since Context Id is null, not copying it into buffer
1388 0 : memcpy(buffer + offset, req.com, 4);
1389 :
1390 : /* send control message to daemon*/
1391 0 : ret = dlt_client_send_ctrl_msg_v2(client,
1392 : "",
1393 : "",
1394 : (uint8_t *)buffer,
1395 : buffersize);
1396 :
1397 0 : free(buffer);
1398 :
1399 0 : return ret;
1400 : }
1401 :
1402 1 : DltReturnValue dlt_client_get_default_log_level(DltClient *client)
1403 : {
1404 : DltServiceGetDefaultLogLevelRequest *req;
1405 : int ret = DLT_RETURN_ERROR;
1406 :
1407 1 : if (client == NULL)
1408 : return ret;
1409 :
1410 : req = (DltServiceGetDefaultLogLevelRequest *)
1411 1 : malloc(sizeof(DltServiceGetDefaultLogLevelRequest));
1412 :
1413 1 : if (req == NULL)
1414 : return ret;
1415 :
1416 1 : req->service_id = DLT_SERVICE_ID_GET_DEFAULT_LOG_LEVEL;
1417 :
1418 : /* send control message to daemon*/
1419 1 : ret = dlt_client_send_ctrl_msg(client,
1420 : "",
1421 : "",
1422 : (uint8_t *)req,
1423 : sizeof(DltServiceGetDefaultLogLevelRequest));
1424 :
1425 1 : free(req);
1426 :
1427 1 : return ret;
1428 : }
1429 :
1430 0 : DltReturnValue dlt_client_get_default_log_level_v2(DltClient *client)
1431 : {
1432 : DltServiceGetDefaultLogLevelRequest *req;
1433 : int ret = DLT_RETURN_ERROR;
1434 :
1435 0 : if (client == NULL)
1436 : return ret;
1437 :
1438 : req = (DltServiceGetDefaultLogLevelRequest *)
1439 0 : malloc(sizeof(DltServiceGetDefaultLogLevelRequest));
1440 :
1441 0 : if (req == NULL)
1442 : return ret;
1443 :
1444 0 : req->service_id = DLT_SERVICE_ID_GET_DEFAULT_LOG_LEVEL;
1445 :
1446 : /* send control message to daemon*/
1447 0 : ret = dlt_client_send_ctrl_msg_v2(client,
1448 : "",
1449 : "",
1450 : (uint8_t *)req,
1451 : sizeof(DltServiceGetDefaultLogLevelRequest));
1452 :
1453 0 : free(req);
1454 :
1455 0 : return ret;
1456 : }
1457 :
1458 3 : DltReturnValue dlt_client_get_software_version(DltClient *client)
1459 : {
1460 : DltServiceGetSoftwareVersion *req;
1461 : int ret = DLT_RETURN_ERROR;
1462 :
1463 3 : if (client == NULL)
1464 : return ret;
1465 :
1466 3 : req = (DltServiceGetSoftwareVersion *)malloc(sizeof(DltServiceGetSoftwareVersion));
1467 :
1468 3 : req->service_id = DLT_SERVICE_ID_GET_SOFTWARE_VERSION;
1469 :
1470 : /* send control message to daemon*/
1471 3 : ret = dlt_client_send_ctrl_msg(client,
1472 : "",
1473 : "",
1474 : (uint8_t *)req,
1475 : sizeof(DltServiceGetSoftwareVersion));
1476 :
1477 3 : free(req);
1478 :
1479 3 : return ret;
1480 : }
1481 :
1482 0 : int dlt_client_get_software_version_v2(DltClient *client)
1483 : {
1484 : DltServiceGetSoftwareVersion *req;
1485 : int ret = DLT_RETURN_ERROR;
1486 :
1487 0 : if (client == NULL)
1488 : return ret;
1489 :
1490 0 : req = (DltServiceGetSoftwareVersion *)malloc(sizeof(DltServiceGetSoftwareVersion));
1491 :
1492 0 : req->service_id = DLT_SERVICE_ID_GET_SOFTWARE_VERSION;
1493 :
1494 : /* send control message to daemon*/
1495 0 : ret = dlt_client_send_ctrl_msg_v2(client,
1496 : "",
1497 : "",
1498 : (uint8_t *)req,
1499 : sizeof(DltServiceGetSoftwareVersion));
1500 :
1501 0 : free(req);
1502 :
1503 0 : return ret;
1504 : }
1505 :
1506 0 : DltReturnValue dlt_client_send_trace_status(DltClient *client, char *apid, char *ctid, uint8_t traceStatus)
1507 : {
1508 : DltServiceSetLogLevel *req;
1509 :
1510 0 : req = calloc(1,sizeof(DltServiceSetLogLevel));
1511 :
1512 0 : if (req == 0)
1513 : return DLT_RETURN_ERROR;
1514 :
1515 0 : req->service_id = DLT_SERVICE_ID_SET_TRACE_STATUS;
1516 0 : dlt_set_id(req->apid, apid);
1517 0 : dlt_set_id(req->ctid, ctid);
1518 0 : req->log_level = traceStatus;
1519 0 : dlt_set_id(req->com, "remo");
1520 :
1521 : /* free message */
1522 0 : if (dlt_client_send_ctrl_msg(client, "APP", "CON", (uint8_t*) req,
1523 : sizeof(DltServiceSetLogLevel)) == DLT_RETURN_ERROR) {
1524 0 : free(req);
1525 0 : return DLT_RETURN_ERROR;
1526 : }
1527 :
1528 0 : free(req);
1529 :
1530 0 : return DLT_RETURN_OK;
1531 : }
1532 :
1533 0 : DltReturnValue dlt_client_send_trace_status_v2(DltClient *client, char *apid, char *ctid, uint8_t traceStatus)
1534 : {
1535 : DltServiceSetLogLevelV2 req;
1536 : int ret = DLT_RETURN_ERROR;
1537 : uint8_t *buffer;
1538 : uint16_t buffersize;
1539 : uint16_t offset = 0;
1540 :
1541 0 : if (client == NULL)
1542 : return ret;
1543 :
1544 0 : req.service_id = DLT_SERVICE_ID_SET_TRACE_STATUS;
1545 0 : req.apidlen = strlen(apid);
1546 0 : req.apid = apid;
1547 0 : req.ctidlen = strlen(ctid);
1548 0 : req.ctid = ctid;
1549 0 : req.log_level = traceStatus;
1550 0 : dlt_set_id(req.com, "remo");
1551 :
1552 0 : buffersize = DLT_SERVICE_SET_LOG_LEVEL_FIXED_SIZE_V2 + req.apidlen + req.ctidlen;
1553 :
1554 0 : buffer = (uint8_t *)malloc(buffersize);
1555 0 : if (buffer == NULL)
1556 : return ret;
1557 :
1558 : memcpy(buffer + offset, &(req.service_id), 4);
1559 : offset = offset + 4;
1560 0 : memcpy(buffer + offset, &(req.apidlen), 1);
1561 : offset = offset + 1;
1562 0 : memcpy(buffer + offset, req.apid, req.apidlen);
1563 0 : offset = offset + req.apidlen;
1564 0 : memcpy(buffer + offset, &(req.ctidlen), 1);
1565 0 : offset = offset + 1;
1566 0 : memcpy(buffer + offset, req.ctid, req.ctidlen);
1567 0 : offset = offset + req.ctidlen;
1568 0 : memcpy(buffer + offset, &(req.log_level), 1);
1569 : offset = offset + 1;
1570 : memcpy(buffer, req.com, 4);
1571 :
1572 : /* free message */
1573 0 : ret = dlt_client_send_ctrl_msg_v2(client,
1574 : "APP",
1575 : "CON",
1576 : (uint8_t *)buffer,
1577 : buffersize);
1578 :
1579 :
1580 0 : free(buffer);
1581 :
1582 0 : return ret;
1583 : }
1584 :
1585 0 : DltReturnValue dlt_client_send_default_log_level(DltClient *client, uint8_t defaultLogLevel)
1586 : {
1587 : DltServiceSetDefaultLogLevel *req;
1588 :
1589 0 : req = calloc(1, sizeof(DltServiceSetDefaultLogLevel));
1590 :
1591 0 : if (req == 0)
1592 : return DLT_RETURN_ERROR;
1593 :
1594 0 : req->service_id = DLT_SERVICE_ID_SET_DEFAULT_LOG_LEVEL;
1595 0 : req->log_level = defaultLogLevel;
1596 0 : dlt_set_id(req->com, "remo");
1597 :
1598 : /* free message */
1599 0 : if (dlt_client_send_ctrl_msg(client, "APP", "CON", (uint8_t*) req,
1600 : sizeof(DltServiceSetDefaultLogLevel)) == DLT_RETURN_ERROR) {
1601 0 : free(req);
1602 0 : return DLT_RETURN_ERROR;
1603 : }
1604 :
1605 0 : free(req);
1606 :
1607 0 : return DLT_RETURN_OK;
1608 : }
1609 :
1610 0 : DltReturnValue dlt_client_send_default_log_level_v2(DltClient *client, uint8_t defaultLogLevel)
1611 : {
1612 : DltServiceSetDefaultLogLevel *req;
1613 :
1614 0 : req = calloc(1, sizeof(DltServiceSetDefaultLogLevel));
1615 :
1616 0 : if (req == 0)
1617 : return DLT_RETURN_ERROR;
1618 :
1619 0 : req->service_id = DLT_SERVICE_ID_SET_DEFAULT_LOG_LEVEL;
1620 0 : req->log_level = defaultLogLevel;
1621 0 : dlt_set_id(req->com, "remo");
1622 :
1623 : /* free message */
1624 0 : if (dlt_client_send_ctrl_msg_v2(client, "APP", "CON", (uint8_t*) req,
1625 : sizeof(DltServiceSetDefaultLogLevel)) == DLT_RETURN_ERROR) {
1626 0 : free(req);
1627 0 : return DLT_RETURN_ERROR;
1628 : }
1629 :
1630 0 : free(req);
1631 :
1632 0 : return DLT_RETURN_OK;
1633 : }
1634 :
1635 0 : DltReturnValue dlt_client_send_all_log_level(DltClient *client, uint8_t LogLevel)
1636 : {
1637 : DltServiceSetDefaultLogLevel *req;
1638 :
1639 0 : req = calloc(1, sizeof(DltServiceSetDefaultLogLevel));
1640 :
1641 0 : if (req == 0)
1642 : return DLT_RETURN_ERROR;
1643 :
1644 0 : req->service_id = DLT_SERVICE_ID_SET_ALL_LOG_LEVEL;
1645 0 : req->log_level = LogLevel;
1646 0 : dlt_set_id(req->com, "remo");
1647 :
1648 : /* free message */
1649 0 : if (dlt_client_send_ctrl_msg(client, "APP", "CON", (uint8_t*) req,
1650 : sizeof(DltServiceSetDefaultLogLevel)) == -1) {
1651 0 : free(req);
1652 0 : return DLT_RETURN_ERROR;
1653 : }
1654 :
1655 0 : free(req);
1656 :
1657 0 : return DLT_RETURN_OK;
1658 : }
1659 :
1660 0 : DltReturnValue dlt_client_send_all_log_level_v2(DltClient *client, uint8_t LogLevel)
1661 : {
1662 : DltServiceSetDefaultLogLevel *req;
1663 :
1664 0 : req = calloc(1, sizeof(DltServiceSetDefaultLogLevel));
1665 :
1666 0 : if (req == 0)
1667 : return DLT_RETURN_ERROR;
1668 :
1669 0 : req->service_id = DLT_SERVICE_ID_SET_ALL_LOG_LEVEL;
1670 0 : req->log_level = LogLevel;
1671 0 : dlt_set_id(req->com, "remo");
1672 :
1673 : /* free message */
1674 0 : if (dlt_client_send_ctrl_msg_v2(client, "APP", "CON", (uint8_t*) req,
1675 : sizeof(DltServiceSetDefaultLogLevel)) == -1) {
1676 0 : free(req);
1677 0 : return DLT_RETURN_ERROR;
1678 : }
1679 :
1680 0 : free(req);
1681 :
1682 0 : return DLT_RETURN_OK;
1683 : }
1684 :
1685 0 : DltReturnValue dlt_client_send_default_trace_status(DltClient *client, uint8_t defaultTraceStatus)
1686 : {
1687 : DltServiceSetDefaultLogLevel *req;
1688 :
1689 0 : req = calloc(1, sizeof(DltServiceSetDefaultLogLevel));
1690 :
1691 0 : if (req == 0)
1692 : return DLT_RETURN_ERROR;
1693 :
1694 0 : req->service_id = DLT_SERVICE_ID_SET_DEFAULT_TRACE_STATUS;
1695 0 : req->log_level = defaultTraceStatus;
1696 0 : dlt_set_id(req->com, "remo");
1697 :
1698 : /* free message */
1699 0 : if (dlt_client_send_ctrl_msg(client, "APP", "CON", (uint8_t*) req,
1700 : sizeof(DltServiceSetDefaultLogLevel)) == DLT_RETURN_ERROR) {
1701 0 : free(req);
1702 0 : return DLT_RETURN_ERROR;
1703 : }
1704 :
1705 0 : free(req);
1706 :
1707 0 : return DLT_RETURN_OK;
1708 : }
1709 :
1710 0 : DltReturnValue dlt_client_send_default_trace_status_v2(DltClient *client, uint8_t defaultTraceStatus)
1711 : {
1712 : DltServiceSetDefaultLogLevel *req;
1713 :
1714 0 : req = calloc(1, sizeof(DltServiceSetDefaultLogLevel));
1715 :
1716 0 : if (req == 0)
1717 : return DLT_RETURN_ERROR;
1718 :
1719 0 : req->service_id = DLT_SERVICE_ID_SET_DEFAULT_TRACE_STATUS;
1720 0 : req->log_level = defaultTraceStatus;
1721 0 : dlt_set_id(req->com, "remo");
1722 :
1723 : /* free message */
1724 0 : if (dlt_client_send_ctrl_msg_v2(client, "APP", "CON", (uint8_t*) req,
1725 : sizeof(DltServiceSetDefaultLogLevel)) == DLT_RETURN_ERROR) {
1726 0 : free(req);
1727 0 : return DLT_RETURN_ERROR;
1728 : }
1729 :
1730 0 : free(req);
1731 :
1732 0 : return DLT_RETURN_OK;
1733 : }
1734 :
1735 0 : DltReturnValue dlt_client_send_all_trace_status(DltClient *client, uint8_t traceStatus)
1736 : {
1737 : DltServiceSetDefaultLogLevel *req;
1738 :
1739 0 : if (client == NULL) {
1740 0 : dlt_vlog(LOG_ERR, "%s: Invalid parameters\n", __func__);
1741 0 : return DLT_RETURN_ERROR;
1742 : }
1743 :
1744 0 : req = calloc(1, sizeof(DltServiceSetDefaultLogLevel));
1745 :
1746 0 : if (req == 0) {
1747 0 : dlt_vlog(LOG_ERR, "%s: Could not allocate memory %zu\n", __func__, sizeof(DltServiceSetDefaultLogLevel));
1748 0 : return DLT_RETURN_ERROR;
1749 : }
1750 :
1751 0 : req->service_id = DLT_SERVICE_ID_SET_ALL_TRACE_STATUS;
1752 0 : req->log_level = traceStatus;
1753 0 : dlt_set_id(req->com, "remo");
1754 :
1755 : /* free message */
1756 0 : if (dlt_client_send_ctrl_msg(client, "APP", "CON", (uint8_t*) req,
1757 : sizeof(DltServiceSetDefaultLogLevel)) == -1) {
1758 0 : free(req);;
1759 0 : return DLT_RETURN_ERROR;
1760 : }
1761 :
1762 0 : free(req);
1763 :
1764 0 : return DLT_RETURN_OK;
1765 : }
1766 :
1767 0 : DltReturnValue dlt_client_send_all_trace_status_v2(DltClient *client, uint8_t traceStatus)
1768 : {
1769 : DltServiceSetDefaultLogLevel *req;
1770 :
1771 0 : if (client == NULL) {
1772 0 : dlt_vlog(LOG_ERR, "%s: Invalid parameters\n", __func__);
1773 0 : return DLT_RETURN_ERROR;
1774 : }
1775 :
1776 0 : req = calloc(1, sizeof(DltServiceSetDefaultLogLevel));
1777 :
1778 0 : if (req == 0) {
1779 0 : dlt_vlog(LOG_ERR, "%s: Could not allocate memory %zu\n", __func__, sizeof(DltServiceSetDefaultLogLevel));
1780 0 : return DLT_RETURN_ERROR;
1781 : }
1782 :
1783 0 : req->service_id = DLT_SERVICE_ID_SET_ALL_TRACE_STATUS;
1784 0 : req->log_level = traceStatus;
1785 0 : dlt_set_id(req->com, "remo");
1786 :
1787 : /* free message */
1788 0 : if (dlt_client_send_ctrl_msg_v2(client, "APP", "CON", (uint8_t*) req,
1789 : sizeof(DltServiceSetDefaultLogLevel)) == -1) {
1790 0 : free(req);;
1791 0 : return DLT_RETURN_ERROR;
1792 : }
1793 :
1794 0 : free(req);
1795 :
1796 0 : return DLT_RETURN_OK;
1797 : }
1798 :
1799 0 : DltReturnValue dlt_client_send_timing_pakets(DltClient *client, uint8_t timingPakets)
1800 : {
1801 : DltServiceSetVerboseMode *req;
1802 :
1803 0 : req = calloc(1, sizeof(DltServiceSetVerboseMode));
1804 :
1805 0 : if (req == 0)
1806 : return DLT_RETURN_ERROR;
1807 :
1808 0 : req->service_id = DLT_SERVICE_ID_SET_TIMING_PACKETS;
1809 0 : req->new_status = timingPakets;
1810 :
1811 : /* free message */
1812 0 : if (dlt_client_send_ctrl_msg(client, "APP", "CON", (uint8_t*) req,
1813 : sizeof(DltServiceSetVerboseMode)) == DLT_RETURN_ERROR) {
1814 0 : free(req);
1815 0 : return DLT_RETURN_ERROR;
1816 : }
1817 :
1818 0 : free(req);
1819 :
1820 0 : return DLT_RETURN_OK;
1821 : }
1822 :
1823 0 : DltReturnValue dlt_client_send_timing_pakets_v2(DltClient *client, uint8_t timingPakets)
1824 : {
1825 : DltServiceSetVerboseMode *req;
1826 :
1827 0 : req = calloc(1, sizeof(DltServiceSetVerboseMode));
1828 :
1829 0 : if (req == 0)
1830 : return DLT_RETURN_ERROR;
1831 :
1832 0 : req->service_id = DLT_SERVICE_ID_SET_TIMING_PACKETS;
1833 0 : req->new_status = timingPakets;
1834 :
1835 : /* free message */
1836 0 : if (dlt_client_send_ctrl_msg_v2(client, "APP", "CON", (uint8_t*) req,
1837 : sizeof(DltServiceSetVerboseMode)) == DLT_RETURN_ERROR) {
1838 0 : free(req);
1839 0 : return DLT_RETURN_ERROR;
1840 : }
1841 :
1842 0 : free(req);
1843 :
1844 0 : return DLT_RETURN_OK;
1845 : }
1846 :
1847 0 : DltReturnValue dlt_client_send_store_config(DltClient *client)
1848 : {
1849 : uint32_t service_id;
1850 :
1851 0 : service_id = DLT_SERVICE_ID_STORE_CONFIG;
1852 :
1853 : /* free message */
1854 0 : if (dlt_client_send_ctrl_msg(client, "APP", "CON", (uint8_t *)&service_id, sizeof(uint32_t)) == DLT_RETURN_ERROR)
1855 0 : return DLT_RETURN_ERROR;
1856 :
1857 : return DLT_RETURN_OK;
1858 : }
1859 :
1860 0 : DltReturnValue dlt_client_send_store_config_v2(DltClient *client)
1861 : {
1862 : uint32_t service_id;
1863 :
1864 0 : service_id = DLT_SERVICE_ID_STORE_CONFIG;
1865 :
1866 : /* free message */
1867 0 : if (dlt_client_send_ctrl_msg_v2(client, "APP", "CON", (uint8_t *)&service_id, sizeof(uint32_t)) == DLT_RETURN_ERROR)
1868 0 : return DLT_RETURN_ERROR;
1869 :
1870 : return DLT_RETURN_OK;
1871 : }
1872 :
1873 0 : DltReturnValue dlt_client_send_reset_to_factory_default(DltClient *client)
1874 : {
1875 : uint32_t service_id;
1876 :
1877 0 : service_id = DLT_SERVICE_ID_RESET_TO_FACTORY_DEFAULT;
1878 :
1879 : /* free message */
1880 0 : if (dlt_client_send_ctrl_msg(client, "APP", "CON", (uint8_t *)&service_id, sizeof(uint32_t)) == DLT_RETURN_ERROR)
1881 0 : return DLT_RETURN_ERROR;
1882 :
1883 : return DLT_RETURN_OK;
1884 : }
1885 :
1886 0 : DltReturnValue dlt_client_send_reset_to_factory_default_v2(DltClient *client)
1887 : {
1888 : uint32_t service_id;
1889 :
1890 0 : service_id = DLT_SERVICE_ID_RESET_TO_FACTORY_DEFAULT;
1891 :
1892 : /* free message */
1893 0 : if (dlt_client_send_ctrl_msg_v2(client, "APP", "CON", (uint8_t *)&service_id, sizeof(uint32_t)) == DLT_RETURN_ERROR)
1894 0 : return DLT_RETURN_ERROR;
1895 :
1896 : return DLT_RETURN_OK;
1897 : }
1898 :
1899 0 : DltReturnValue dlt_client_setbaudrate(DltClient *client, int baudrate)
1900 : {
1901 0 : if (client == 0)
1902 : return DLT_RETURN_ERROR;
1903 :
1904 0 : client->baudrate = dlt_convert_serial_speed(baudrate);
1905 :
1906 0 : return DLT_RETURN_OK;
1907 : }
1908 :
1909 0 : DltReturnValue dlt_client_set_mode(DltClient *client, DltClientMode mode)
1910 : {
1911 0 : if (client == 0)
1912 : return DLT_RETURN_ERROR;
1913 :
1914 0 : client->mode = mode;
1915 0 : return DLT_RETURN_OK;
1916 :
1917 : }
1918 :
1919 5 : int dlt_client_set_server_ip(DltClient *client, char *ipaddr)
1920 : {
1921 5 : client->servIP = strdup(ipaddr);
1922 :
1923 5 : if (client->servIP == NULL) {
1924 0 : dlt_vlog(LOG_ERR, "%s: ERROR: failed to duplicate server IP\n", __func__);
1925 0 : return DLT_RETURN_ERROR;
1926 : }
1927 :
1928 : return DLT_RETURN_OK;
1929 : }
1930 :
1931 0 : int dlt_client_set_host_if_address(DltClient *client, char *hostip)
1932 : {
1933 0 : client->hostip = strdup(hostip);
1934 :
1935 0 : if (client->hostip == NULL) {
1936 0 : dlt_vlog(LOG_ERR, "%s: ERROR: failed to duplicate UDP interface address\n", __func__);
1937 0 : return DLT_RETURN_ERROR;
1938 : }
1939 :
1940 : return DLT_RETURN_OK;
1941 : }
1942 :
1943 0 : int dlt_client_set_serial_device(DltClient *client, char *serial_device)
1944 : {
1945 0 : client->serialDevice = strdup(serial_device);
1946 :
1947 0 : if (client->serialDevice == NULL) {
1948 0 : dlt_vlog(LOG_ERR, "%s: ERROR: failed to duplicate serial device\n", __func__);
1949 0 : return DLT_RETURN_ERROR;
1950 : }
1951 :
1952 : return DLT_RETURN_OK;
1953 : }
1954 :
1955 0 : int dlt_client_set_socket_path(DltClient *client, char *socket_path)
1956 : {
1957 0 : client->socketPath = strdup(socket_path);
1958 :
1959 0 : if (client->socketPath == NULL) {
1960 0 : dlt_vlog(LOG_ERR, "%s: ERROR: failed to duplicate socket path\n", __func__);
1961 0 : return DLT_RETURN_ERROR;
1962 : }
1963 :
1964 : return DLT_RETURN_OK;
1965 : }
1966 : /**
1967 : * free allocation when calloc failed get log info
1968 : *
1969 : * @param resp DltServiceGetLogInfoResponse
1970 : * @param count_app_ids number of app_ids which needs to be freed
1971 : */
1972 0 : DLT_STATIC void dlt_client_free_calloc_failed_get_log_info(DltServiceGetLogInfoResponse *resp,
1973 : int count_app_ids)
1974 : {
1975 : AppIDsType *app = NULL;
1976 : ContextIDsInfoType *con = NULL;
1977 : int i = 0;
1978 : int j = 0;
1979 :
1980 0 : for (i = 0; i < count_app_ids; i++) {
1981 0 : app = &(resp->log_info_type.app_ids[i]);
1982 :
1983 0 : for (j = 0; j < app->count_context_ids; j++) {
1984 0 : con = &(app->context_id_info[j]);
1985 :
1986 0 : free(con->context_description);
1987 0 : con->context_description = NULL;
1988 : }
1989 :
1990 0 : free(app->app_description);
1991 0 : app->app_description = NULL;
1992 :
1993 0 : free(app->context_id_info);
1994 0 : app->context_id_info = NULL;
1995 : }
1996 :
1997 0 : free(resp->log_info_type.app_ids);
1998 0 : resp->log_info_type.app_ids = NULL;
1999 0 : resp->log_info_type.count_app_ids = 0;
2000 :
2001 0 : return;
2002 : }
2003 :
2004 : /**
2005 : * free allocation when calloc failed get log info v2
2006 : *
2007 : * @param resp DltServiceGetLogInfoResponse
2008 : * @param count_app_ids number of app_ids which needs to be freed
2009 : */
2010 0 : DLT_STATIC void dlt_client_free_calloc_failed_get_log_info_v2(DltServiceGetLogInfoResponse *resp,
2011 : int count_app_ids)
2012 : {
2013 : AppIDsType *app = NULL;
2014 : ContextIDsInfoType *con = NULL;
2015 : int i = 0;
2016 : int j = 0;
2017 :
2018 0 : for (i = 0; i < count_app_ids; i++) {
2019 0 : app = &(resp->log_info_type.app_ids[i]);
2020 :
2021 0 : for (j = 0; j < app->count_context_ids; j++) {
2022 0 : con = &(app->context_id_info[j]);
2023 0 : free(con->context_id2);
2024 0 : free(con->context_description);
2025 0 : con->context_id2 = NULL;
2026 0 : con->context_description = NULL;
2027 : }
2028 :
2029 0 : free(app->app_id2);
2030 0 : free(app->app_description);
2031 0 : app->app_id2 = NULL;
2032 0 : app->app_description = NULL;
2033 :
2034 0 : free(app->context_id_info);
2035 0 : app->context_id_info = NULL;
2036 : }
2037 :
2038 0 : free(resp->log_info_type.app_ids);
2039 0 : resp->log_info_type.app_ids = NULL;
2040 0 : resp->log_info_type.count_app_ids = 0;
2041 :
2042 0 : return;
2043 : }
2044 :
2045 2 : DltReturnValue dlt_client_parse_get_log_info_resp_text(DltServiceGetLogInfoResponse *resp,
2046 : char *resp_text)
2047 : {
2048 : AppIDsType *app = NULL;
2049 : ContextIDsInfoType *con = NULL;
2050 : int i = 0;
2051 : int j = 0;
2052 : char *rp = NULL;
2053 2 : int rp_count = 0;
2054 :
2055 2 : if ((resp == NULL) || (resp_text == NULL))
2056 : return DLT_RETURN_WRONG_PARAMETER;
2057 :
2058 : /* ------------------------------------------------------
2059 : * get_log_info data structure(all data is ascii)
2060 : *
2061 : * get_log_info, aa, bb bb cc cc cc cc dd dd ee ee ee ee ff gg hh hh ii ii ii .. ..
2062 : * ~~ ~~~~~ ~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~~~~~
2063 : * cc cc cc cc dd dd ee ee ee ee ff gg hh hh ii ii ii .. ..
2064 : * jj jj kk kk kk .. ..
2065 : * ~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~~~~~
2066 : * aa : get mode (fix value at 0x07)
2067 : * bb bb : list num of apid (little endian)
2068 : * cc cc cc cc: apid
2069 : * dd dd : list num of ctid (little endian)
2070 : * ee ee ee ee: ctid
2071 : * ff : log level
2072 : * gg : trace status
2073 : * hh hh : description length of ctid
2074 : * ii ii .. : description text of ctid
2075 : * jj jj : description length of apid
2076 : * kk kk .. : description text of apid
2077 : * ------------------------------------------------------ */
2078 :
2079 2 : rp = resp_text + DLT_GET_LOG_INFO_HEADER;
2080 : rp_count = 0;
2081 :
2082 : /* check if status is acceptable */
2083 2 : if ((resp->status < GET_LOG_INFO_STATUS_MIN) ||
2084 : (resp->status > GET_LOG_INFO_STATUS_MAX)) {
2085 0 : if (resp->status == GET_LOG_INFO_STATUS_NO_MATCHING_CTX)
2086 0 : dlt_vlog(LOG_WARNING,
2087 : "%s: The status(%d) is invalid: NO matching Context IDs\n",
2088 : __func__,
2089 : resp->status);
2090 0 : else if (resp->status == GET_LOG_INFO_STATUS_RESP_DATA_OVERFLOW)
2091 0 : dlt_vlog(LOG_WARNING,
2092 : "%s: The status(%d) is invalid: Response data over flow\n",
2093 : __func__,
2094 : resp->status);
2095 : else
2096 0 : dlt_vlog(LOG_WARNING,
2097 : "%s: The status(%d) is invalid\n",
2098 : __func__,
2099 : resp->status);
2100 :
2101 0 : return DLT_RETURN_ERROR;
2102 : }
2103 :
2104 : /* count_app_ids */
2105 2 : resp->log_info_type.count_app_ids = (uint16_t) dlt_getloginfo_conv_ascii_to_uint16_t(rp,
2106 : &rp_count);
2107 :
2108 2 : resp->log_info_type.app_ids = (AppIDsType *)calloc
2109 : (resp->log_info_type.count_app_ids, sizeof(AppIDsType));
2110 :
2111 2 : if (resp->log_info_type.app_ids == NULL) {
2112 0 : dlt_vlog(LOG_ERR, "%s: calloc failed for app_ids\n", __func__);
2113 0 : dlt_client_free_calloc_failed_get_log_info(resp, 0);
2114 0 : return DLT_RETURN_ERROR;
2115 : }
2116 :
2117 5 : for (i = 0; i < resp->log_info_type.count_app_ids; i++) {
2118 3 : app = &(resp->log_info_type.app_ids[i]);
2119 : /* get app id */
2120 3 : dlt_getloginfo_conv_ascii_to_id(rp, &rp_count, app->app_id, DLT_ID_SIZE);
2121 :
2122 : /* count_con_ids */
2123 3 : app->count_context_ids = (uint16_t) dlt_getloginfo_conv_ascii_to_uint16_t(rp,
2124 : &rp_count);
2125 :
2126 3 : app->context_id_info = (ContextIDsInfoType *)calloc
2127 : (app->count_context_ids, sizeof(ContextIDsInfoType));
2128 :
2129 3 : if (app->context_id_info == NULL) {
2130 0 : dlt_vlog(LOG_ERR,
2131 : "%s: calloc failed for context_id_info\n", __func__);
2132 0 : dlt_client_free_calloc_failed_get_log_info(resp, i);
2133 0 : return DLT_RETURN_ERROR;
2134 : }
2135 :
2136 9 : for (j = 0; j < app->count_context_ids; j++) {
2137 6 : con = &(app->context_id_info[j]);
2138 : /* get con id */
2139 6 : dlt_getloginfo_conv_ascii_to_id(rp,
2140 : &rp_count,
2141 6 : con->context_id,
2142 : DLT_ID_SIZE);
2143 :
2144 : /* log_level */
2145 6 : if ((resp->status == 4) || (resp->status == 6) || (resp->status == 7))
2146 6 : con->log_level = dlt_getloginfo_conv_ascii_to_int16_t(rp,
2147 : &rp_count);
2148 :
2149 : /* trace status */
2150 6 : if ((resp->status == 5) || (resp->status == 6) || (resp->status == 7))
2151 6 : con->trace_status = dlt_getloginfo_conv_ascii_to_int16_t(rp,
2152 : &rp_count);
2153 :
2154 : /* context desc */
2155 6 : if (resp->status == 7) {
2156 6 : con->len_context_description = (uint16_t) dlt_getloginfo_conv_ascii_to_uint16_t(rp,
2157 : &rp_count);
2158 6 : con->context_description = (char *)calloc
2159 6 : ((size_t) (con->len_context_description + 1), sizeof(char));
2160 :
2161 6 : if (con->context_description == NULL) {
2162 0 : dlt_vlog(LOG_ERR, "%s: calloc failed for context description\n", __func__);
2163 0 : dlt_client_free_calloc_failed_get_log_info(resp, i);
2164 0 : return DLT_RETURN_ERROR;
2165 : }
2166 :
2167 6 : dlt_getloginfo_conv_ascii_to_string(rp,
2168 : &rp_count,
2169 : con->context_description,
2170 : con->len_context_description);
2171 : }
2172 : }
2173 :
2174 : /* application desc */
2175 3 : if (resp->status == 7) {
2176 3 : app->len_app_description = (uint16_t) dlt_getloginfo_conv_ascii_to_uint16_t(rp,
2177 : &rp_count);
2178 3 : app->app_description = (char *)calloc
2179 3 : ((size_t) (app->len_app_description + 1), sizeof(char));
2180 :
2181 3 : if (app->app_description == NULL) {
2182 0 : dlt_vlog(LOG_ERR, "%s: calloc failed for application description\n", __func__);
2183 0 : dlt_client_free_calloc_failed_get_log_info(resp, i);
2184 0 : return DLT_RETURN_ERROR;
2185 : }
2186 :
2187 3 : dlt_getloginfo_conv_ascii_to_string(rp,
2188 : &rp_count,
2189 : app->app_description,
2190 : app->len_app_description);
2191 : }
2192 : }
2193 :
2194 : return DLT_RETURN_OK;
2195 : }
2196 :
2197 0 : DltReturnValue dlt_client_parse_get_log_info_resp_text_v2(DltServiceGetLogInfoResponse *resp,
2198 : char *resp_text)
2199 : {
2200 : AppIDsType *app = NULL;
2201 : ContextIDsInfoType *con = NULL;
2202 : int i = 0;
2203 : int j = 0;
2204 : char *rp = NULL;
2205 0 : int rp_count = 0;
2206 :
2207 0 : if ((resp == NULL) || (resp_text == NULL))
2208 : return DLT_RETURN_WRONG_PARAMETER;
2209 :
2210 : /* ------------------------------------------------------
2211 : * get_log_info data structure(all data is ascii)
2212 : *
2213 : * get_log_info, aa, bb bb cc1 cc cc cc.... dd dd ee1 ee ee ee.... ff gg hh hh ii ii ii .. ..
2214 : * ~~ ~~~~~ ~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~~~~~
2215 : * cc1 cc cc cc.... dd dd ee1 ee ee ee.... ff gg hh hh ii ii ii .. ..
2216 : * jj jj kk kk kk .. ..
2217 : * ~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~~~~~
2218 : * aa : get mode (fix value at 0x07)
2219 : * bb bb : list num of apid (little endian)
2220 : * cc1 : length of apid
2221 : * cc cc cc cc: apid
2222 : * dd dd : list num of ctid (little endian)
2223 : * ee1 : length of ctid
2224 : * ee ee ee ee: ctid
2225 : * ff : log level
2226 : * gg : trace status
2227 : * hh hh : description length of ctid
2228 : * ii ii .. : description text of ctid
2229 : * jj jj : description length of apid
2230 : * kk kk .. : description text of apid
2231 : * ------------------------------------------------------ */
2232 :
2233 0 : rp = resp_text + DLT_GET_LOG_INFO_HEADER;
2234 : rp_count = 0;
2235 :
2236 : /* check if status is acceptable */
2237 0 : if ((resp->status < GET_LOG_INFO_STATUS_MIN) ||
2238 : (resp->status > GET_LOG_INFO_STATUS_MAX)) {
2239 0 : if (resp->status == GET_LOG_INFO_STATUS_NO_MATCHING_CTX)
2240 0 : dlt_vlog(LOG_WARNING,
2241 : "%s: The status(%d) is invalid: NO matching Context IDs\n",
2242 : __func__,
2243 : resp->status);
2244 0 : else if (resp->status == GET_LOG_INFO_STATUS_RESP_DATA_OVERFLOW)
2245 0 : dlt_vlog(LOG_WARNING,
2246 : "%s: The status(%d) is invalid: Response data over flow\n",
2247 : __func__,
2248 : resp->status);
2249 : else
2250 0 : dlt_vlog(LOG_WARNING,
2251 : "%s: The status(%d) is invalid\n",
2252 : __func__,
2253 : resp->status);
2254 :
2255 0 : return DLT_RETURN_ERROR;
2256 : }
2257 :
2258 : /* count_app_ids */
2259 0 : uint16_t ret = dlt_getloginfo_conv_ascii_to_uint16_t(rp, &rp_count);
2260 0 : resp->log_info_type.count_app_ids = ret;
2261 :
2262 0 : resp->log_info_type.app_ids = (AppIDsType *)calloc
2263 : (resp->log_info_type.count_app_ids, sizeof(AppIDsType));
2264 :
2265 0 : if (resp->log_info_type.app_ids == NULL) {
2266 0 : dlt_vlog(LOG_ERR, "%s: calloc failed for app_ids\n", __func__);
2267 0 : dlt_client_free_calloc_failed_get_log_info_v2(resp, 0);
2268 0 : return DLT_RETURN_ERROR;
2269 : }
2270 :
2271 0 : for (i = 0; i < resp->log_info_type.count_app_ids; i++) {
2272 0 : app = &(resp->log_info_type.app_ids[i]);
2273 0 : app->app_id2len = dlt_getloginfo_conv_ascii_to_uint8_t(rp, &rp_count);
2274 :
2275 0 : app->app_id2 = (char *)calloc((size_t) (app->app_id2len + 1), sizeof(char));
2276 :
2277 0 : if (app->app_id2 == NULL) {
2278 0 : dlt_vlog(LOG_ERR, "%s: calloc failed for App Id\n", __func__);
2279 0 : dlt_client_free_calloc_failed_get_log_info_v2(resp, i);
2280 0 : return DLT_RETURN_ERROR;
2281 : }
2282 : /* get app id */
2283 0 : dlt_getloginfo_conv_ascii_to_id(rp, &rp_count, app->app_id2, app->app_id2len);
2284 :
2285 : /* count_con_ids */
2286 0 : ret = dlt_getloginfo_conv_ascii_to_uint16_t(rp, &rp_count);
2287 0 : app->count_context_ids = ret;
2288 0 : app->context_id_info = (ContextIDsInfoType *)calloc(app->count_context_ids, sizeof(ContextIDsInfoType));
2289 :
2290 0 : if (app->context_id_info == NULL) {
2291 0 : dlt_vlog(LOG_ERR,
2292 : "%s: calloc failed for context_id_info\n", __func__);
2293 0 : dlt_client_free_calloc_failed_get_log_info_v2(resp, i);
2294 0 : return DLT_RETURN_ERROR;
2295 : }
2296 :
2297 0 : for (j = 0; j < app->count_context_ids; j++) {
2298 0 : con = &(app->context_id_info[j]);
2299 0 : con->context_id2len = dlt_getloginfo_conv_ascii_to_uint8_t(rp, &rp_count);
2300 0 : con->context_id2 = (char *)calloc((size_t) (con->context_id2len + 1), sizeof(char));
2301 :
2302 0 : if (con->context_id2 == NULL) {
2303 0 : dlt_vlog(LOG_ERR, "%s: calloc failed for Context Id\n", __func__);
2304 0 : dlt_client_free_calloc_failed_get_log_info_v2(resp, i);
2305 0 : return DLT_RETURN_ERROR;
2306 : }
2307 : /* get con id */
2308 0 : dlt_getloginfo_conv_ascii_to_id(rp,
2309 : &rp_count,
2310 : con->context_id2,
2311 : con->context_id2len);
2312 :
2313 : /* log_level */
2314 0 : if ((resp->status == 4) || (resp->status == 6) || (resp->status == 7))
2315 0 : con->log_level = dlt_getloginfo_conv_ascii_to_int16_t(rp,
2316 : &rp_count);
2317 :
2318 : /* trace status */
2319 0 : if ((resp->status == 5) || (resp->status == 6) || (resp->status == 7))
2320 0 : con->trace_status = dlt_getloginfo_conv_ascii_to_int16_t(rp,
2321 : &rp_count);
2322 :
2323 : /* context desc */
2324 0 : if (resp->status == 7) {
2325 0 : con->len_context_description = (uint16_t) dlt_getloginfo_conv_ascii_to_uint16_t(rp,
2326 : &rp_count);
2327 0 : con->context_description = (char *)calloc
2328 0 : ((size_t) (con->len_context_description + 1), sizeof(char));
2329 :
2330 0 : if (con->context_description == NULL) {
2331 0 : dlt_vlog(LOG_ERR, "%s: calloc failed for context description\n", __func__);
2332 0 : dlt_client_free_calloc_failed_get_log_info_v2(resp, i);
2333 0 : return DLT_RETURN_ERROR;
2334 : }
2335 :
2336 0 : dlt_getloginfo_conv_ascii_to_string(rp,
2337 : &rp_count,
2338 : con->context_description,
2339 : con->len_context_description);
2340 : }
2341 : }
2342 :
2343 : /* application desc */
2344 0 : if (resp->status == 7) {
2345 0 : app->len_app_description = (uint16_t) dlt_getloginfo_conv_ascii_to_uint16_t(rp,
2346 : &rp_count);
2347 0 : app->app_description = (char *)calloc
2348 0 : ((size_t) (app->len_app_description + 1), sizeof(char));
2349 :
2350 0 : if (app->app_description == NULL) {
2351 0 : dlt_vlog(LOG_ERR, "%s: calloc failed for application description\n", __func__);
2352 0 : dlt_client_free_calloc_failed_get_log_info_v2(resp, i);
2353 0 : return DLT_RETURN_ERROR;
2354 : }
2355 :
2356 0 : dlt_getloginfo_conv_ascii_to_string(rp,
2357 : &rp_count,
2358 : app->app_description,
2359 : app->len_app_description);
2360 : }
2361 : }
2362 :
2363 : return DLT_RETURN_OK;
2364 : }
2365 :
2366 2 : int dlt_client_cleanup_get_log_info(DltServiceGetLogInfoResponse *resp)
2367 : {
2368 : AppIDsType app;
2369 : int i = 0;
2370 : int j = 0;
2371 :
2372 2 : if (resp == NULL)
2373 : return DLT_RETURN_OK;
2374 :
2375 5 : for (i = 0; i < resp->log_info_type.count_app_ids; i++) {
2376 3 : app = resp->log_info_type.app_ids[i];
2377 :
2378 9 : for (j = 0; j < app.count_context_ids; j++) {
2379 6 : free(app.context_id_info[j].context_description);
2380 6 : app.context_id_info[j].context_description = NULL;
2381 : }
2382 :
2383 3 : free(app.context_id_info);
2384 : app.context_id_info = NULL;
2385 3 : free(app.app_description);
2386 : app.app_description = NULL;
2387 : }
2388 :
2389 2 : free(resp->log_info_type.app_ids);
2390 : resp->log_info_type.app_ids = NULL;
2391 :
2392 2 : free(resp);
2393 : resp = NULL;
2394 :
2395 2 : return DLT_RETURN_OK;
2396 : }
2397 :
2398 0 : int dlt_client_cleanup_get_log_info_v2(DltServiceGetLogInfoResponse *resp)
2399 : {
2400 : AppIDsType app;
2401 : int i = 0;
2402 : int j = 0;
2403 :
2404 0 : if (resp == NULL)
2405 : return DLT_RETURN_OK;
2406 :
2407 0 : for (i = 0; i < resp->log_info_type.count_app_ids; i++) {
2408 0 : app = resp->log_info_type.app_ids[i];
2409 :
2410 0 : for (j = 0; j < app.count_context_ids; j++) {
2411 0 : free(app.context_id_info[j].context_id2);
2412 0 : app.context_id_info[j].context_id2 = NULL;
2413 0 : free(app.context_id_info[j].context_description);
2414 0 : app.context_id_info[j].context_description = NULL;
2415 : }
2416 :
2417 0 : free(app.context_id_info);
2418 : app.context_id_info = NULL;
2419 0 : free(app.app_id2);
2420 : app.app_id2 = NULL;
2421 0 : free(app.app_description);
2422 : app.app_description = NULL;
2423 : }
2424 :
2425 0 : free(resp->log_info_type.app_ids);
2426 : resp->log_info_type.app_ids = NULL;
2427 :
2428 0 : free(resp);
2429 : resp = NULL;
2430 :
2431 0 : return DLT_RETURN_OK;
2432 : }
|
