src/graph_list.c: Sort the instances of all graphs.
[collection4.git] / src / filesystem.c
1 /**
2  * collection4 - filesystem.c
3  * Copyright (C) 2010  Florian octo Forster
4  * 
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  * 
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  * 
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA  02110-1301  USA
19  *
20  * Authors:
21  *   Florian octo Forster <ff at octo.it>
22  **/
23
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <errno.h>
29 #include <limits.h>
30 #include <sys/types.h>
31 #include <sys/stat.h>
32 #include <dirent.h>
33
34 #include "filesystem.h"
35
36 struct fs_scan_dir_data_s /* {{{ */
37 {
38   fs_ident_cb_t callback;
39   void *user_data;
40
41   char *host;
42   char *plugin;
43   char *plugin_instance;
44   char *type;
45   char *type_instance;
46 }; /* }}} */
47 typedef struct fs_scan_dir_data_s fs_scan_dir_data_t;
48
49 typedef int (*callback_type_t)   (const char *type,   void *user_data);
50 typedef int (*callback_plugin_t) (const char *plugin, void *user_data);
51 typedef int (*callback_host_t)   (const char *host,   void *user_data);
52
53 /*
54  * Directory and file walking functions
55  */
56 static int foreach_rrd_file (const char *dir, /* {{{ */
57     int (*callback) (const char *, void *),
58     void *user_data)
59 {
60   DIR *dh;
61   struct dirent *entry;
62   int status;
63
64   if (callback == NULL)
65     return (EINVAL);
66
67   dh = opendir (dir);
68   if (dh == NULL)
69     return (errno);
70
71   while ((entry = readdir (dh)) != NULL)
72   {
73     struct stat statbuf;
74     char abspath[PATH_MAX + 1];
75     size_t d_name_len;
76
77     if (entry->d_name[0] == '.')
78       continue;
79
80     d_name_len = strlen (entry->d_name);
81     if (d_name_len <= 4)
82       continue;
83
84     if (strcasecmp (".rrd", entry->d_name + (d_name_len - 4)) != 0)
85       continue;
86
87     snprintf (abspath, sizeof (abspath), "%s/%s", dir, entry->d_name);
88     abspath[sizeof (abspath) - 1] = 0;
89
90     memset (&statbuf, 0, sizeof (statbuf));
91
92     status = stat (abspath, &statbuf);
93     if (status != 0)
94       continue;
95
96     if (!S_ISREG (statbuf.st_mode))
97       continue;
98
99     entry->d_name[d_name_len - 4] = 0;
100
101     status = (*callback) (entry->d_name, user_data);
102     if (status != 0)
103       break;
104   } /* while (readdir) */
105
106   closedir (dh);
107   return (status);
108 } /* }}} int foreach_rrd_file */
109
110 static int foreach_dir (const char *dir, /* {{{ */
111     int (*callback) (const char *, void *),
112     void *user_data)
113 {
114   DIR *dh;
115   struct dirent *entry;
116   int status = 0;
117
118   if (callback == NULL)
119     return (EINVAL);
120
121   dh = opendir (dir);
122   if (dh == NULL)
123     return (errno);
124
125   while ((entry = readdir (dh)) != NULL)
126   {
127     struct stat statbuf;
128     char abspath[PATH_MAX + 1];
129
130     if (entry->d_name[0] == '.')
131       continue;
132
133     snprintf (abspath, sizeof (abspath), "%s/%s", dir, entry->d_name);
134     abspath[sizeof (abspath) - 1] = 0;
135
136     memset (&statbuf, 0, sizeof (statbuf));
137
138     status = stat (abspath, &statbuf);
139     if (status != 0)
140       continue;
141
142     if (!S_ISDIR (statbuf.st_mode))
143       continue;
144
145     status = (*callback) (entry->d_name, user_data);
146     if (status != 0)
147       break;
148   } /* while (readdir) */
149
150   closedir (dh);
151   return (status);
152 } /* }}} int foreach_dir */
153
154 static int foreach_type (const char *host, const char *plugin, /* {{{ */
155     callback_type_t callback, void *user_data)
156 {
157   char abspath[PATH_MAX + 1];
158
159   if ((host == NULL) || (plugin == NULL))
160     return (EINVAL);
161
162   snprintf (abspath, sizeof (abspath), "%s/%s/%s", DATA_DIR, host, plugin);
163   abspath[sizeof (abspath) - 1] = 0;
164
165   return (foreach_rrd_file (abspath, callback, user_data));
166 } /* }}} int foreach_type */
167
168 static int foreach_plugin (const char *host, /* {{{ */
169     callback_plugin_t callback,
170     void *user_data)
171 {
172   char abspath[PATH_MAX + 1];
173
174   if (host == NULL)
175     return (EINVAL);
176
177   snprintf (abspath, sizeof (abspath), "%s/%s", DATA_DIR, host);
178   abspath[sizeof (abspath) - 1] = 0;
179
180   return (foreach_dir (abspath, callback, user_data));
181 } /* }}} int foreach_plugin */
182
183 static int foreach_host (callback_host_t callback, /* {{{ */
184     void *user_data)
185 {
186   return (foreach_dir (DATA_DIR, callback, user_data));
187 } /* }}} int foreach_host */
188
189 /*
190  * Functions building "fs_scan_dir_data_t" and calling the user-supplied
191  * callback eventually.
192  */
193 static int scan_type (const char *type, void *user_data) /* {{{ */
194 {
195   fs_scan_dir_data_t *data = user_data;
196   graph_ident_t *ident;
197   int status;
198
199   if ((type == NULL) || (data == NULL))
200     return (EINVAL);
201
202   if ((data->type != NULL) || (data->type_instance != NULL))
203     return (EINVAL);
204
205   data->type = strdup (type);
206   if (data->type == NULL)
207     return (ENOMEM);
208
209   data->type_instance = strchr (data->type, '-');
210   if (data->type_instance != NULL)
211   {
212     *data->type_instance = 0;
213     data->type_instance++;
214   }
215   else
216   {
217     data->type_instance = data->type + strlen (data->type);
218   }
219
220   ident = ident_create (data->host,
221       data->plugin, data->plugin_instance,
222       data->type, data->type_instance);
223   if (ident == NULL)
224   {
225     status = -1;
226   }
227   else
228   {
229     status = (*data->callback) (ident, data->user_data);
230     ident_destroy (ident);
231   }
232
233   free (data->type);
234   data->type = NULL;
235   data->type_instance = NULL;
236
237   return (status);
238 } /* }}} int scan_type */
239
240 static int scan_plugin (const char *plugin, void *user_data) /* {{{ */
241 {
242   fs_scan_dir_data_t *data = user_data;
243   int status;
244
245   if ((plugin == NULL) || (data == NULL))
246     return (EINVAL);
247
248   if ((data->plugin != NULL) || (data->plugin_instance != NULL))
249     return (EINVAL);
250
251   data->plugin = strdup (plugin);
252   if (data->plugin == NULL)
253     return (ENOMEM);
254
255   data->plugin_instance = strchr (data->plugin, '-');
256   if (data->plugin_instance != NULL)
257   {
258     *data->plugin_instance = 0;
259     data->plugin_instance++;
260   }
261   else
262   {
263     data->plugin_instance = data->plugin + strlen (data->plugin);
264   }
265
266   status = foreach_type (data->host, plugin, scan_type, data);
267
268   free (data->plugin);
269   data->plugin = NULL;
270   data->plugin_instance = NULL;
271
272   return (status);
273 } /* }}} int scan_plugin */
274
275 static int scan_host (const char *host, void *user_data) /* {{{ */
276 {
277   fs_scan_dir_data_t *data = user_data;
278   int status;
279
280   if ((host == NULL) || (data == NULL))
281     return (EINVAL);
282
283   if (data->host != NULL)
284     return (EINVAL);
285
286   data->host = strdup (host);
287   if (data->host == NULL)
288     return (ENOMEM);
289
290   status =  foreach_plugin (host, scan_plugin, data);
291
292   free (data->host);
293   data->host = NULL;
294
295   return (status);
296 } /* }}} int scan_host */
297
298 /*
299  * Public function
300  */
301 int fs_scan (fs_ident_cb_t callback, void *user_data) /* {{{ */
302 {
303   fs_scan_dir_data_t data;
304
305   memset (&data, 0, sizeof (data));
306   data.callback = callback;
307   data.user_data = user_data;
308
309   data.host = NULL;
310   data.plugin = NULL;
311   data.plugin_instance = NULL;
312   data.type = NULL;
313   data.type_instance = NULL;
314
315   foreach_host (scan_host, &data);
316
317   return (0);
318 } /* }}} int fs_scan */
319
320 /* vim: set sw=2 sts=2 et fdm=marker : */