Line data Source code
1 : /**
2 : * Copyright (C) 2013 - 2015 Advanced Driver Information Technology.
3 : * This code is developed by Advanced Driver Information Technology.
4 : * Copyright of Advanced Driver Information Technology, Bosch and DENSO.
5 : *
6 : * This file is part of COVESA Project Dlt - Diagnostic Log and Trace console apps.
7 : *
8 : *
9 : * \copyright
10 : * This Source Code Form is subject to the terms of the
11 : * Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with
12 : * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
13 : *
14 : *
15 : * \author Syed Hameed <shameed@jp.adit-jv.com> ADIT 2013 - 2015
16 : * \author Christoph Lipka <clipka@jp.adit-jv.com> ADIT 2015
17 : * \author Frederic Berat <fberat@de.adit-jv.com> ADIT 2015
18 : *
19 : * \file dlt-logstorage-common.c
20 : * For further information see http://www.covesa.org/.
21 : */
22 :
23 : /*******************************************************************************
24 : ** **
25 : ** SRC-MODULE: dlt-logstorage-common.c **
26 : ** **
27 : ** TARGET : linux **
28 : ** **
29 : ** PROJECT : DLT **
30 : ** **
31 : ** AUTHOR : Christoph Lipka clipka@jp.adit-jv.com **
32 : ** Frederic Berat fberat@de.adit-jv.com **
33 : ** PURPOSE : **
34 : ** **
35 : ** REMARKS : Code extracted from dlt-control-common.c and reworked. **
36 : ** **
37 : ** PLATFORM DEPENDANT [yes/no]: yes **
38 : ** **
39 : ** TO BE CHANGED BY USER [yes/no]: no **
40 : ** **
41 : *******************************************************************************/
42 :
43 : /*******************************************************************************
44 : ** Author Identity **
45 : ********************************************************************************
46 : ** **
47 : ** Initials Name Company **
48 : ** -------- ------------------------- ---------------------------------- **
49 : ** cl Christoph Lipka ADIT **
50 : ** fb Frederic Berat ADIT **
51 : *******************************************************************************/
52 : #define pr_fmt(fmt) "Logstorage common: "fmt
53 :
54 : #include <errno.h>
55 : #include <dirent.h>
56 : #include <stdio.h>
57 : #include <stdlib.h>
58 : #include <string.h>
59 : #include <unistd.h>
60 : #include <pthread.h>
61 : #include <sys/types.h>
62 : #include <sys/socket.h>
63 :
64 : #include "dlt_common.h"
65 : #include "dlt_protocol.h"
66 : #include "dlt_client.h"
67 :
68 : #include "dlt-control-common.h"
69 : #include "dlt-logstorage-common.h"
70 :
71 : #ifdef DLT_LOGSTORAGE_CTRL_UDEV_ENABLE
72 : # include "dlt-logstorage-udev.h"
73 : #endif
74 :
75 : #include "dlt-logstorage-prop.h"
76 :
77 : static struct LogstorageOptions {
78 : int event_type; /**< EVENT_UNMOUNTING/EVENT_MOUNTED */
79 : char device_path[DLT_MOUNT_PATH_MAX]; /**< Default Mount path */
80 : DltLogstorageHandler handler_type; /**< be controlled by udev or prop */
81 : long timeout; /**< Default timeout */
82 : } g_options = {
83 : .event_type = EVENT_MOUNTED,
84 : .handler_type = CTRL_NOHANDLER,
85 : };
86 :
87 4 : DltLogstorageHandler get_handler_type(void)
88 : {
89 4 : return g_options.handler_type;
90 : }
91 :
92 0 : void set_handler_type(char *type)
93 : {
94 0 : g_options.handler_type = CTRL_UDEV;
95 :
96 : if (type && check_proprietary_handling(type))
97 : g_options.handler_type = CTRL_PROPRIETARY;
98 0 : }
99 :
100 6 : int get_default_event_type(void)
101 : {
102 6 : return g_options.event_type;
103 : }
104 :
105 2 : void set_default_event_type(long type)
106 : {
107 2 : g_options.event_type = (int) type;
108 2 : }
109 :
110 2 : char *get_default_path(void)
111 : {
112 2 : return g_options.device_path;
113 : }
114 :
115 2 : void set_default_path(char *path)
116 : {
117 : memset(g_options.device_path, 0, DLT_MOUNT_PATH_MAX);
118 :
119 2 : if (path != NULL)
120 : strncpy(g_options.device_path, path, DLT_MOUNT_PATH_MAX - 1);
121 2 : }
122 :
123 : /* Used by the handlers */
124 : static DltLogstorageCtrl lctrl;
125 :
126 0 : DltLogstorageCtrl *get_logstorage_control(void)
127 : {
128 0 : return &lctrl;
129 : }
130 :
131 0 : void *dlt_logstorage_get_handler_cb(void)
132 : {
133 0 : return lctrl.callback;
134 : }
135 :
136 0 : int dlt_logstorage_get_handler_fd(void)
137 : {
138 0 : return lctrl.fd;
139 : }
140 :
141 : /** @brief Initialized the handler based on configuration
142 : *
143 : * @return 0 on success, -1 otherwise.
144 : */
145 0 : int dlt_logstorage_init_handler(void)
146 : {
147 0 : switch (get_handler_type()) {
148 : case CTRL_PROPRIETARY:
149 : return dlt_logstorage_prop_init();
150 0 : case CTRL_UDEV:
151 : default:
152 : #ifdef DLT_LOGSTORAGE_CTRL_UDEV_ENABLE
153 : return dlt_logstorage_udev_init();
154 : #else
155 0 : return -1;
156 : #endif
157 : }
158 : }
159 :
160 : /** @brief Clean-up the handler based on configuration
161 : *
162 : * @return 0 on success, -1 otherwise.
163 : */
164 0 : int dlt_logstorage_deinit_handler(void)
165 : {
166 0 : switch (get_handler_type()) {
167 : case CTRL_PROPRIETARY:
168 : return dlt_logstorage_prop_deinit();
169 0 : case CTRL_UDEV:
170 : default:
171 : #ifdef DLT_LOGSTORAGE_CTRL_UDEV_ENABLE
172 : return dlt_logstorage_udev_deinit();
173 : #else
174 0 : return -1;
175 : #endif
176 : }
177 : }
178 :
179 : /** @brief Search for config file in given mount point
180 : *
181 : * The file is searched at the top directory. The function exits once it
182 : * founds it.
183 : *
184 : * @param mnt_point The mount point to check
185 : *
186 : * @return 1 if the file is found, 0 otherwise.
187 : */
188 0 : int dlt_logstorage_check_config_file(char *mnt_point)
189 : {
190 : struct dirent **files;
191 : int n;
192 : int i = 0;
193 : int ret = 0;
194 :
195 0 : if ((mnt_point == NULL) || (mnt_point[0] == '\0')) {
196 0 : pr_error("Mount point missing.\n");
197 0 : return ret;
198 : }
199 :
200 0 : pr_verbose("Now scanning %s\n", mnt_point);
201 :
202 0 : n = scandir(mnt_point, &files, NULL, alphasort);
203 :
204 0 : if (n <= 0) {
205 0 : pr_error("Cannot read mounted directory\n");
206 0 : return ret;
207 : }
208 :
209 : do {
210 0 : pr_verbose("Checking %s.\n", files[i]->d_name);
211 :
212 0 : if (strncmp(files[i]->d_name, CONF_NAME, strlen(CONF_NAME)) == 0) {
213 : /* We found it ! */
214 0 : pr_verbose("File found.\n");
215 : ret = 1;
216 : break;
217 : }
218 0 : } while (++i < n);
219 :
220 0 : for (i = 0; i < n; i++)
221 0 : free(files[i]);
222 :
223 0 : free(files);
224 0 : return ret;
225 : }
226 :
227 : /** @brief Check if given mount point is writable
228 : *
229 : * @param mnt_point The mount point to check
230 : *
231 : * @return 1 if the file is writable, 0 otherwise.
232 : */
233 0 : int dlt_logstorage_check_directory_permission(char *mnt_point)
234 : {
235 0 : if (mnt_point == NULL) {
236 0 : pr_error("Given mount point is NULL\n");
237 0 : return 0;
238 : }
239 :
240 0 : if (access(mnt_point, W_OK) == 0)
241 : return 1;
242 :
243 : return 0;
244 : }
245 :
246 : /** @brief Prepares the body of the message to be send to DLT
247 : *
248 : * @param body A pointer to the MsgBody structure pointer
249 : * @param conn_type The type of the event (Mounted/Unmounting)
250 : * @param path The mount point path.
251 : *
252 : * @return The body once built or NULL.
253 : */
254 2 : static DltControlMsgBody *prepare_message_body(DltControlMsgBody **body,
255 : int conn_type,
256 : char *path)
257 : {
258 : DltServiceOfflineLogstorage *serv = NULL;
259 :
260 2 : if (path == NULL) {
261 0 : pr_error("Mount path is uninitialized.\n");
262 0 : return NULL;
263 : }
264 :
265 2 : pr_verbose("Sending event %d for %s.\n", conn_type, path);
266 :
267 2 : *body = calloc(1, sizeof(DltControlMsgBody));
268 :
269 2 : if (!*body) {
270 0 : pr_error("Not able to allocate memory for body.\n");
271 0 : return *body;
272 : }
273 :
274 2 : (*body)->data = calloc(1, sizeof(DltServiceOfflineLogstorage));
275 :
276 2 : if (!(*body)->data) {
277 0 : free(*body);
278 0 : *body = NULL;
279 0 : pr_error("Not able to allocate memory for body data.\n");
280 0 : return NULL;
281 : }
282 :
283 2 : (*body)->size = sizeof(DltServiceOfflineLogstorage);
284 :
285 : serv = (DltServiceOfflineLogstorage *)(*body)->data;
286 :
287 2 : serv->service_id = DLT_SERVICE_ID_OFFLINE_LOGSTORAGE;
288 2 : serv->connection_type = (uint8_t) conn_type;
289 : /* mount_point is DLT_MOUNT_PATH_MAX + 1 long,
290 : * and the memory is already zeroed.
291 : */
292 2 : strncpy(serv->mount_point, path, DLT_MOUNT_PATH_MAX - 1);
293 :
294 2 : pr_verbose("Body is now ready.\n");
295 :
296 2 : return *body;
297 : }
298 :
299 : /** @brief Send a logstorage event to DLT
300 : *
301 : * @param type The type of the event (Mounted/Unmounting)
302 : * @param mount_point The mount point for this event
303 : *
304 : * @return 0 On success, -1 otherwise.
305 : */
306 2 : int dlt_logstorage_send_event(int type, char *mount_point)
307 : {
308 : int ret = 0;
309 2 : DltControlMsgBody *msg_body = NULL;
310 :
311 : /* mount_point is checked against NULL in the preparation */
312 2 : if (!prepare_message_body(&msg_body, type, mount_point)) {
313 0 : pr_error("Data for Dlt Message body is NULL\n");
314 0 : return -1;
315 : }
316 :
317 2 : ret = dlt_control_send_message(msg_body, get_timeout());
318 :
319 2 : free(msg_body->data);
320 2 : free(msg_body);
321 :
322 2 : return ret;
323 : }
|
