ctdb-scripts: Update statd-callout to try several configuration files
[vlendec/samba-autobuild/.git] / ctdb / common / line.c
1 /*
2    Line based I/O over fds
3
4    Copyright (C) Amitay Isaacs  2018
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "replace.h"
21
22 #include <talloc.h>
23
24 #include "lib/util/sys_rw.h"
25
26 #include "common/line.h"
27
28 struct line_read_state {
29         line_process_fn_t callback;
30         void *private_data;
31         char *buf;
32         size_t hint, len, offset;
33         int num_lines;
34 };
35
36 static bool line_read_one(char *buf, size_t start, size_t len, size_t *pos)
37 {
38         size_t i;
39
40         for (i=start; i<len; i++) {
41                 if (buf[i] == '\n' || buf[i] == '\0') {
42                         *pos = i;
43                         return true;
44                 }
45         }
46
47         return false;
48 }
49
50 static int line_read_process(struct line_read_state *state)
51 {
52         size_t start = 0;
53         size_t pos = 0;
54
55         while (1) {
56                 int ret;
57                 bool ok;
58
59                 ok = line_read_one(state->buf, start, state->offset, &pos);
60                 if (! ok) {
61                         break;
62                 }
63
64                 state->buf[pos] = '\0';
65                 state->num_lines += 1;
66
67                 ret = state->callback(state->buf + start, state->private_data);
68                 if (ret != 0) {
69                         return ret;
70                 }
71
72                 start = pos+1;
73         }
74
75         if (pos > 0) {
76                 if (pos+1 < state->offset) {
77                         memmove(state->buf,
78                                 state->buf + pos+1,
79                                 state->offset - (pos+1));
80                 }
81                 state->offset -= (pos+1);
82         }
83
84         return 0;
85 }
86
87 int line_read(int fd,
88               size_t length,
89               TALLOC_CTX *mem_ctx,
90               line_process_fn_t callback,
91               void *private_data,
92               int *num_lines)
93 {
94         struct line_read_state state;
95
96         if (length < 32) {
97                 length = 32;
98         }
99
100         state = (struct line_read_state) {
101                 .callback = callback,
102                 .private_data = private_data,
103                 .hint = length,
104         };
105
106         while (1) {
107                 ssize_t n;
108                 int ret;
109
110                 if (state.offset == state.len) {
111                         state.len += state.hint;
112                         state.buf = talloc_realloc_size(mem_ctx,
113                                                         state.buf,
114                                                         state.len);
115                         if (state.buf == NULL) {
116                                 return ENOMEM;
117                         }
118                 }
119
120                 n = sys_read(fd,
121                              state.buf + state.offset,
122                              state.len - state.offset);
123                 if (n < 0) {
124                         return errno;
125                 }
126                 if (n == 0) {
127                         break;
128                 }
129
130                 state.offset += n;
131
132                 ret = line_read_process(&state);
133                 if (ret != 0) {
134                         if (num_lines != NULL) {
135                                 *num_lines = state.num_lines;
136                         }
137                         return ret;
138                 }
139         }
140
141         if (num_lines != NULL) {
142                 *num_lines = state.num_lines;
143         }
144         return 0;
145 }