]> arthur.barton.de Git - netdata.git/blob - src/procfile.c
netdata way of logging in procfile
[netdata.git] / src / procfile.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include <errno.h>
5 #include <fcntl.h>
6 #include <string.h>
7 #include <malloc.h>
8 #include <inttypes.h>
9 #include <ctype.h>
10 #include <time.h>
11 #include <sys/time.h>
12 #include <sys/wait.h>
13
14 #include <sys/types.h>
15 #include <sys/stat.h>
16 #include <sys/mman.h>
17
18 #include "log.h"
19 #include "procfile.h"
20
21 #define PF_PREFIX "PROCFILE"
22
23 // ----------------------------------------------------------------------------
24 // An array of words
25
26 #define PFWORDS_INCREASE_STEP 200
27
28 pfwords *pfwords_add(pfwords *fw, char *str) {
29         debug(D_PROCFILE, PF_PREFIX ":  adding word No %d: '%s'\n", fw->len, str);
30
31         if(fw->len == fw->size) {
32                 debug(D_PROCFILE, PF_PREFIX ":  expanding words\n");
33
34                 pfwords *new = realloc(fw, sizeof(pfwords) + (fw->size + PFWORDS_INCREASE_STEP) * sizeof(char *));
35                 if(!new) {
36                         error(PF_PREFIX ":      failed to expand words\n");
37                         free(fw);
38                         return NULL;
39                 }
40                 fw = new;
41                 fw->size += PFWORDS_INCREASE_STEP;
42         }
43
44         fw->words[fw->len++] = str;
45
46         return fw;
47 }
48
49 pfwords *pfwords_new(void) {
50         debug(D_PROCFILE, PF_PREFIX ":  initializing words\n");
51
52         pfwords *new = malloc(sizeof(pfwords) + PFWORDS_INCREASE_STEP * sizeof(char *));
53         if(!new) return NULL;
54
55         new->len = 0;
56         new->size = PFWORDS_INCREASE_STEP;
57         return new;
58 }
59
60 void pfwords_reset(pfwords *fw) {
61         debug(D_PROCFILE, PF_PREFIX ":  reseting words\n");
62         fw->len = 0;
63 }
64
65 void pfwords_free(pfwords *fw) {
66         debug(D_PROCFILE, PF_PREFIX ":  freeing words\n");
67
68         free(fw);
69 }
70
71
72 // ----------------------------------------------------------------------------
73 // An array of lines
74
75 #define PFLINES_INCREASE_STEP 10
76
77 pflines *pflines_add(pflines *fl, uint32_t first_word) {
78         debug(D_PROCFILE, PF_PREFIX ":  adding line %d at word %d\n", fl->len, first_word);
79
80         if(fl->len == fl->size) {
81                 debug(D_PROCFILE, PF_PREFIX ":  expanding lines\n");
82
83                 pflines *new = realloc(fl, sizeof(pflines) + (fl->size + PFLINES_INCREASE_STEP) * sizeof(ffline));
84                 if(!new) {
85                         error(PF_PREFIX ":      failed to expand lines\n");
86                         free(fl);
87                         return NULL;
88                 }
89                 fl = new;
90                 fl->size += PFLINES_INCREASE_STEP;
91         }
92
93         fl->lines[fl->len].words = 0;
94         fl->lines[fl->len++].first = first_word;
95
96         return fl;
97 }
98
99 pflines *pflines_new(void) {
100         debug(D_PROCFILE, PF_PREFIX ":  initializing lines\n");
101
102         pflines *new = malloc(sizeof(pflines) + PFLINES_INCREASE_STEP * sizeof(ffline));
103         if(!new) return NULL;
104
105         new->len = 0;
106         new->size = PFLINES_INCREASE_STEP;
107         return new;
108 }
109
110 void pflines_reset(pflines *fl) {
111         debug(D_PROCFILE, PF_PREFIX ":  reseting lines\n");
112
113         fl->len = 0;
114 }
115
116 void pflines_free(pflines *fl) {
117         debug(D_PROCFILE, PF_PREFIX ":  freeing lines\n");
118
119         free(fl);
120 }
121
122
123 // ----------------------------------------------------------------------------
124 // The procfile
125
126 #define PROCFILE_INITIAL_BUFFER 256
127 #define PROCFILE_INCREMENT_BUFFER 512
128
129 #define PF_CHAR_IS_SEPARATOR    0
130 #define PF_CHAR_IS_NEWLINE      1
131 #define PF_CHAR_IS_WORD         2
132
133 void procfile_close(procfile *ff) {
134         debug(D_PROCFILE, PF_PREFIX ": Closing file '%s'. Reason: %s\n", ff->filename, strerror(errno));
135
136         if(ff->lines) pflines_free(ff->lines);
137         if(ff->words) pfwords_free(ff->words);
138
139         if(ff->fd != -1) close(ff->fd);
140         free(ff);
141 }
142
143 procfile *procfile_parser(procfile *ff) {
144         debug(D_PROCFILE, PF_PREFIX ": Parsing file '%s'\n", ff->filename);
145
146         char *s = ff->data, *e = ff->data, *t = ff->data;
147         uint32_t l = 0, w = 0;
148         e += ff->len;
149         
150         ff->lines = pflines_add(ff->lines, w);
151         if(!ff->lines) goto cleanup;
152
153         while(s < e) {
154                 switch(ff->separators[(int)(*s)]) {
155                         case PF_CHAR_IS_SEPARATOR:
156                                 if(s == t) {
157                                         // skip all leading white spaces
158                                         t = ++s;
159                                         continue;
160                                 }
161
162                                 // end of word
163                                 *s = '\0';
164
165                                 ff->words = pfwords_add(ff->words, t);
166                                 if(!ff->words) goto cleanup;
167
168                                 ff->lines->lines[l].words++;
169                                 w++;
170
171                                 t = ++s;
172                                 continue;
173
174                         case PF_CHAR_IS_NEWLINE:
175                                 // end of line
176                                 *s = '\0';
177
178                                 ff->words = pfwords_add(ff->words, t);
179                                 if(!ff->words) goto cleanup;
180
181                                 ff->lines->lines[l].words++;
182                                 w++;
183
184                                 debug(D_PROCFILE, PF_PREFIX ":  ended line %d with %d words\n", l, ff->lines->lines[l].words);
185
186                                 ff->lines = pflines_add(ff->lines, w);
187                                 if(!ff->lines) goto cleanup;
188                                 l++;
189
190                                 t = ++s;
191                                 continue;
192
193                         default:
194                                 s++;
195                                 continue;
196                 }
197         }
198
199         if(s != t) {
200                 // the last word
201                 if(ff->len < ff->size) *s = '\0';
202                 else {
203                         // we are going to loose the last byte
204                         ff->data[ff->size - 1] = '\0';
205                 }
206
207                 ff->words = pfwords_add(ff->words, t);
208                 if(!ff->words) goto cleanup;
209
210                 ff->lines->lines[l].words++;
211                 w++;
212         }
213
214         return ff;
215
216 cleanup:
217         error(PF_PREFIX ": Failed to parse file '%s'. Reason: %s\n", ff->filename, strerror(errno));
218         procfile_close(ff);
219         return NULL;
220 }
221
222 procfile *procfile_readall(procfile *ff) {
223         debug(D_PROCFILE, PF_PREFIX ": Reading file '%s'.\n", ff->filename);
224
225         ssize_t s = 0, r = ff->size, x = ff->size;
226         ff->len = 0;
227
228         while(r == x) {
229                 if(s) {
230                         debug(D_PROCFILE, PF_PREFIX ": Expanding data buffer for file '%s'.\n", ff->filename);
231
232                         procfile *new = realloc(ff, sizeof(procfile) + ff->size + PROCFILE_INCREMENT_BUFFER);
233                         if(!new) {
234                                 error(PF_PREFIX ": Cannot allocate memory for file '%s'. Reason: %s\n", ff->filename, strerror(errno));
235                                 procfile_close(ff);
236                                 return NULL;
237                         }
238                         ff = new;
239                         ff->size += PROCFILE_INCREMENT_BUFFER;
240                         x = PROCFILE_INCREMENT_BUFFER;
241                 }
242
243                 r = read(ff->fd, &ff->data[s], ff->size - s);
244                 if(r == -1) {
245                         error(PF_PREFIX ": Cannot read from file '%s'. Reason: %s\n", ff->filename, strerror(errno));
246                         procfile_close(ff);
247                         return NULL;
248                 }
249
250                 ff->len += r;
251                 s = ff->len;
252         }
253
254         if(lseek(ff->fd, 0, SEEK_SET) == -1) {
255                 error(PF_PREFIX ": Cannot rewind on file '%s'.\n", ff->filename);
256                 procfile_close(ff);
257                 return NULL;
258         }
259
260         pflines_reset(ff->lines);
261         pfwords_reset(ff->words);
262
263         ff = procfile_parser(ff);
264
265         return ff;
266 }
267
268 procfile *procfile_open(const char *filename, const char *separators) {
269         debug(D_PROCFILE, PF_PREFIX ": Opening file '%s'\n", filename);
270
271         int fd = open(filename, O_RDONLY, 0666);
272         if(fd == -1) {
273                 error(PF_PREFIX ": Cannot open file '%s'. Reason: %s\n", filename, strerror(errno));
274                 return NULL;
275         }
276
277         procfile *ff = malloc(sizeof(procfile) + PROCFILE_INITIAL_BUFFER);
278         if(!ff) {
279                 error(PF_PREFIX ": Cannot allocate memory for file '%s'. Reason: %s\n", ff->filename, strerror(errno));
280                 close(fd);
281                 return NULL;
282         }
283
284         strncpy(ff->filename, filename, FILENAME_MAX);
285         ff->filename[FILENAME_MAX] = '\0';
286
287         ff->fd = fd;
288         ff->size = PROCFILE_INITIAL_BUFFER;
289         ff->len = 0;
290
291         ff->lines = pflines_new();
292         ff->words = pfwords_new();
293
294         if(!ff->lines || !ff->words) {
295                 error(PF_PREFIX ": Cannot initialize parser for file '%s'. Reason: %s\n", ff->filename, strerror(errno));
296                 procfile_close(ff);
297                 return NULL;
298         }
299
300         int i;
301         for(i = 0; i < 256 ;i++) {
302                 if(i == '\n' || i == '\r') ff->separators[i] = PF_CHAR_IS_NEWLINE;
303                 else if(isspace(i) || !isprint(i)) ff->separators[i] = PF_CHAR_IS_SEPARATOR;
304                 else ff->separators[i] = PF_CHAR_IS_WORD;
305         }
306
307         if(!separators) separators = " \t=|";
308         const char *s = separators;
309         while(*s) ff->separators[(int)*s++] = PF_CHAR_IS_SEPARATOR;
310
311         return ff;
312 }
313
314
315 // ----------------------------------------------------------------------------
316 // example parsing of procfile data
317
318 void procfile_print(procfile *ff) {
319         uint32_t lines = procfile_lines(ff), l;
320         uint32_t words, w;
321         char *s;
322
323         debug(D_PROCFILE, "File '%s' with %d lines and %d words\n", ff->filename, ff->lines->len, ff->words->len);
324
325         for(l = 0; l < lines ;l++) {
326                 words = procfile_linewords(ff, l);
327
328                 debug(D_PROCFILE, "     line %d starts at word %d and has %d words\n", l, ff->lines->lines[l].first, ff->lines->lines[l].words);
329
330                 for(w = 0; w < words ;w++) {
331                         s = procfile_lineword(ff, l, w);
332                         debug(D_PROCFILE, "             [%d.%d] '%s'\n", l, w, s);
333                 }
334         }
335 }