Remove some warnings that were introduced by commit 6ca440c
[nfs-utils.git] / support / nfs / cacheio.c
1 /*
2  * support/nfs/cacheio.c
3  * support IO on the cache channel files in 2.5 and beyond.
4  * These use 'qwords' which are like words, but with a little quoting.
5  *
6  */
7
8
9 /*
10  * Support routines for text-based upcalls.
11  * Fields are separated by spaces.
12  * Fields are either mangled to quote space tab newline slosh with slosh
13  * or a hexified with a leading \x
14  * Record is terminated with newline.
15  *
16  */
17
18 #include <nfslib.h>
19 #include <stdio.h>
20 #include <stdio_ext.h>
21 #include <ctype.h>
22 #include <unistd.h>
23 #include <sys/types.h>
24 #include <sys/stat.h>
25 #include <fcntl.h>
26 #include <time.h>
27 #include <errno.h>
28
29 void qword_add(char **bpp, int *lp, char *str)
30 {
31         char *bp = *bpp;
32         int len = *lp;
33         char c;
34
35         if (len < 0) return;
36
37         while ((c=*str++) && len)
38                 switch(c) {
39                 case ' ':
40                 case '\t':
41                 case '\n':
42                 case '\\':
43                         if (len >= 4) {
44                                 *bp++ = '\\';
45                                 *bp++ = '0' + ((c & 0300)>>6);
46                                 *bp++ = '0' + ((c & 0070)>>3);
47                                 *bp++ = '0' + ((c & 0007)>>0);
48                         }
49                         len -= 4;
50                         break;
51                 default:
52                         *bp++ = c;
53                         len--;
54                 }
55         if (c || len <1) len = -1;
56         else {
57                 *bp++ = ' ';
58                 len--;
59         }
60         *bpp = bp;
61         *lp = len;
62 }
63
64 void qword_addhex(char **bpp, int *lp, char *buf, int blen)
65 {
66         char *bp = *bpp;
67         int len = *lp;
68
69         if (len < 0) return;
70
71         if (len > 2) {
72                 *bp++ = '\\';
73                 *bp++ = 'x';
74                 len -= 2;
75                 while (blen && len >= 2) {
76                         unsigned char c = *buf++;
77                         *bp++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1);
78                         *bp++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1);
79                         len -= 2;
80                         blen--;
81                 }
82         }
83         if (blen || len<1) len = -1;
84         else {
85                 *bp++ = ' ';
86                 len--;
87         }
88         *bpp = bp;
89         *lp = len;
90 }
91
92 void qword_addint(char **bpp, int *lp, int n)
93 {
94         int len;
95
96         len = snprintf(*bpp, *lp, "%d ", n);
97         if (len > *lp)
98                 len = *lp;
99         *bpp += len;
100         *lp -= len;
101 }
102
103 void qword_adduint(char **bpp, int *lp, unsigned int n)
104 {
105         int len;
106
107         len = snprintf(*bpp, *lp, "%u ", n);
108         if (len > *lp)
109                 len = *lp;
110         *bpp += len;
111         *lp -= len;
112 }
113
114 void qword_addeol(char **bpp, int *lp)
115 {
116         if (*lp <= 0)
117                 return;
118         **bpp = '\n';
119         (*bpp)++;
120         (*lp)--;
121 }
122
123 static char qword_buf[8192];
124 void qword_print(FILE *f, char *str)
125 {
126         char *bp = qword_buf;
127         int len = sizeof(qword_buf);
128         qword_add(&bp, &len, str);
129         if (fwrite(qword_buf, bp-qword_buf, 1, f) != 1) {
130                 xlog_warn("qword_print: fwrite failed: errno %d (%s)",
131                         errno, strerror(errno));
132         }
133 }
134
135 void qword_printhex(FILE *f, char *str, int slen)
136 {
137         char *bp = qword_buf;
138         int len = sizeof(qword_buf);
139         qword_addhex(&bp, &len, str, slen);
140         if (fwrite(qword_buf, bp-qword_buf, 1, f) != 1) {
141                 xlog_warn("qword_printhex: fwrite failed: errno %d (%s)",
142                         errno, strerror(errno));
143         }
144 }
145
146 void qword_printint(FILE *f, int num)
147 {
148         fprintf(f, "%d ", num);
149 }
150
151 void qword_printuint(FILE *f, unsigned int num)
152 {
153         fprintf(f, "%u ", num);
154 }
155
156 int qword_eol(FILE *f)
157 {
158         int err;
159
160         fprintf(f,"\n");
161         err = fflush(f);
162         if (err) {
163                 xlog_warn("qword_eol: fflush failed: errno %d (%s)",
164                             errno, strerror(errno));
165         }
166         /*
167          * We must send one line (and one line only) in a single write
168          * call.  In case of a write error, libc may accumulate the
169          * unwritten data and try to write it again later, resulting in a
170          * multi-line write.  So we must explicitly ask it to throw away
171          * any such cached data.  But we return any original error
172          * indication to the caller.
173          */
174         __fpurge(f);
175         fflush(f);
176         return err;
177 }
178
179
180
181 #define isodigit(c) (isdigit(c) && c <= '7')
182 int qword_get(char **bpp, char *dest, int bufsize)
183 {
184         /* return bytes copied, or -1 on error */
185         char *bp = *bpp;
186         int len = 0;
187
188         while (*bp == ' ') bp++;
189
190         if (bp[0] == '\\' && bp[1] == 'x') {
191                 /* HEX STRING */
192                 bp += 2;
193                 while (isxdigit(bp[0]) && isxdigit(bp[1]) && len < bufsize) {
194                         int byte = isdigit(*bp) ? *bp-'0' : toupper(*bp)-'A'+10;
195                         bp++;
196                         byte <<= 4;
197                         byte |= isdigit(*bp) ? *bp-'0' : toupper(*bp)-'A'+10;
198                         *dest++ = byte;
199                         bp++;
200                         len++;
201                 }
202         } else {
203                 /* text with \nnn octal quoting */
204                 while (*bp != ' ' && *bp != '\n' && *bp && len < bufsize-1) {
205                         if (*bp == '\\' &&
206                             isodigit(bp[1]) && (bp[1] <= '3') &&
207                             isodigit(bp[2]) &&
208                             isodigit(bp[3])) {
209                                 int byte = (*++bp -'0');
210                                 bp++;
211                                 byte = (byte << 3) | (*bp++ - '0');
212                                 byte = (byte << 3) | (*bp++ - '0');
213                                 *dest++ = byte;
214                                 len++;
215                         } else {
216                                 *dest++ = *bp++;
217                                 len++;
218                         }
219                 }
220         }
221
222         if (*bp != ' ' && *bp != '\n' && *bp != '\0')
223                 return -1;
224         while (*bp == ' ') bp++;
225         *bpp = bp;
226         *dest = '\0';
227         return len;
228 }
229
230 int qword_get_int(char **bpp, int *anint)
231 {
232         char buf[50];
233         char *ep;
234         int rv;
235         int len = qword_get(bpp, buf, 50);
236         if (len < 0) return -1;
237         if (len ==0) return -1;
238         rv = strtol(buf, &ep, 0);
239         if (*ep) return -1;
240         *anint = rv;
241         return 0;
242 }
243
244 int qword_get_uint(char **bpp, unsigned int *anint)
245 {
246         char buf[50];
247         char *ep;
248         unsigned int rv;
249         int len = qword_get(bpp, buf, 50);
250         if (len < 0) return -1;
251         if (len ==0) return -1;
252         rv = strtoul(buf, &ep, 0);
253         if (*ep) return -1;
254         *anint = rv;
255         return 0;
256 }
257
258 #define READLINE_BUFFER_INCREMENT 2048
259
260 int readline(int fd, char **buf, int *lenp)
261 {
262         /* read a line into *buf, which is malloced *len long
263          * realloc if needed until we find a \n
264          * nul out the \n and return
265          * 0 on eof, 1 on success
266          */
267         int len;
268
269         if (*lenp == 0) {
270                 char *b = malloc(READLINE_BUFFER_INCREMENT);
271                 if (b == NULL)
272                         return 0;
273                 *buf = b;
274                 *lenp = READLINE_BUFFER_INCREMENT;
275         }
276         len = read(fd, *buf, *lenp);
277         if (len <= 0)
278                 return 0;
279         while ((*buf)[len-1] != '\n') {
280         /* now the less common case.  There was no newline,
281          * so we have to keep reading after re-alloc
282          */
283                 char *new;
284                 int nl;
285                 *lenp += READLINE_BUFFER_INCREMENT;
286                 new = realloc(*buf, *lenp);
287                 if (new == NULL)
288                         return 0;
289                 *buf = new;
290                 nl = read(fd, *buf + len, *lenp - len);
291                 if (nl <= 0)
292                         return 0;
293                 len += nl;
294         }
295         (*buf)[len-1] = '\0';
296         return 1;
297 }
298
299
300 /* Check if we should use the new caching interface
301  * This succeeds iff the "nfsd" filesystem is mounted on
302  * /proc/fs/nfs
303  */
304 int
305 check_new_cache(void)
306 {
307         return  (access("/proc/fs/nfs/filehandle", F_OK) == 0) ||
308                 (access("/proc/fs/nfsd/filehandle", F_OK) == 0);
309 }       
310
311
312 /* flush the kNFSd caches.
313  * Set the flush time to the mtime of _PATH_ETAB or
314  * if force, to now.
315  * the caches to flush are:
316  *  auth.unix.ip nfsd.export nfsd.fh
317  */
318
319 void
320 cache_flush(int force)
321 {
322         struct stat stb;
323         int c;
324         char stime[20];
325         char path[200];
326         time_t now;
327         /* Note: the order of these caches is important.
328          * They need to be flushed in dependancy order. So
329          * a cache that references items in another cache,
330          * as nfsd.fh entries reference items in nfsd.export,
331          * must be flushed before the cache that it references.
332          */
333         static char *cachelist[] = {
334                 "auth.unix.ip",
335                 "auth.unix.gid",
336                 "nfsd.fh",
337                 "nfsd.export",
338                 NULL
339         };
340         now = time(0);
341         if (force ||
342             stat(_PATH_ETAB, &stb) != 0 ||
343             stb.st_mtime > now)
344                 stb.st_mtime = time(0);
345         
346         sprintf(stime, "%ld\n", stb.st_mtime);
347         for (c=0; cachelist[c]; c++) {
348                 int fd;
349                 sprintf(path, "/proc/net/rpc/%s/flush", cachelist[c]);
350                 fd = open(path, O_RDWR);
351                 if (fd >= 0) {
352                         if (write(fd, stime, strlen(stime)) != strlen(stime)) {
353                                 xlog_warn("Writing to '%s' failed: errno %d (%s)",
354                                 path, errno, strerror(errno));
355                         }
356                         close(fd);
357                 }
358         }
359 }