Don't cast returns from malloc()
[openafs.git] / src / config / mc.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include "afsconfig.h"
11
12 #define MAXLINELEN      1024
13 #define MAXTOKLEN       100
14 #include <sys/param.h>
15 #include <sys/types.h>
16 #include <sys/file.h>
17 #include <stdio.h>
18 #include <stdlib.h>
19
20 #include <string.h>
21
22 #define TOK_DONTUSE 1           /* Don't copy if match and this flag is set. */
23 struct token {
24     struct token *next;
25     char *key;
26     int flags;
27 };
28
29 /* free token list returned by parseLine */
30 static int
31 FreeTokens(struct token *alist)
32 {
33     struct token *nlist;
34     for (; alist; alist = nlist) {
35         nlist = alist->next;
36         free(alist->key);
37         free(alist);
38     }
39     return 0;
40 }
41
42 #define space(x)    ((x) == ' ' || (x) == '\t' || (x) == '<' || (x) == '>')
43 static int
44 ParseLine(char *aline, struct token **alist)
45 {
46     char tbuffer[MAXTOKLEN + 1];
47     char *tptr = NULL;
48     int inToken;
49     struct token *first, *last;
50     struct token *ttok;
51     int tc;
52     int dontUse = 0;
53
54     inToken = 0;                /* not copying token chars at start */
55     first = NULL;
56     last = NULL;
57     while (1) {
58         tc = *aline++;
59         if (tc == 0 || space(tc)) {     /* terminating null gets us in here, too */
60             if (inToken) {
61                 inToken = 0;    /* end of this token */
62                 if (!tptr)
63                     return -1;  /* should never get here */
64                 else
65                     *tptr++ = 0;
66                 ttok = malloc(sizeof(struct token));
67                 ttok->next = NULL;
68                 if (dontUse) {
69                     ttok->key = strdup(tbuffer + 1); /* Skip first char */
70                     ttok->flags = TOK_DONTUSE;
71                     dontUse = 0;
72                 } else {
73                     ttok->key = strdup(tbuffer);
74                     ttok->flags = 0;
75                 }
76                 if (last) {
77                     last->next = ttok;
78                     last = ttok;
79                 } else
80                     last = ttok;
81                 if (!first)
82                     first = ttok;
83             }
84         } else {
85             /* an alpha character */
86             if (!inToken) {
87                 if (tc == '-') {
88                     dontUse = 1;
89                 }
90                 tptr = tbuffer;
91                 inToken = 1;
92             }
93             if (tptr - tbuffer >= MAXTOKLEN)
94                 return -1;      /* token too long */
95             *tptr++ = tc;
96         }
97         if (tc == 0) {
98             /* last token flushed 'cause space(0) --> true */
99             if (last)
100                 last->next = NULL;
101             *alist = first;
102             return 0;
103         }
104     }
105 }
106
107 /* read a line into a buffer, putting in null termination and stopping on appropriate
108     end of line char.  Returns 0 at eof, > 0 at normal line end, and < 0 on error */
109 static int
110 GetLine(FILE * afile, char *abuffer, int amax)
111 {
112     int tc;
113     int first;
114
115     first = 1;
116     while (1) {
117         tc = getc(afile);
118         if (first && tc < 0)
119             return 0;
120         first = 0;
121         if (tc <= 0 || tc == '\012') {
122             if (amax > 0)
123                 *abuffer++ = 0;
124             return (amax > 0 ? 1 : -1);
125         }
126         if (amax > 0) {
127             /* keep reading to end of line so next one isn't bogus */
128             *abuffer++ = tc;
129             amax--;
130         }
131     }
132 }
133
134 int
135 mc_copy(FILE * ain, FILE * aout, char *alist[])
136 {
137     char tbuffer[MAXLINELEN];
138     struct token *tokens;
139     char **tp;
140     struct token *tt;
141     int code;
142     int copying;
143     int done;
144
145     copying = 1;                /* start off copying data */
146     while (1) {
147         /* copy lines, handling modes appropriately */
148         code = GetLine(ain, tbuffer, MAXLINELEN);
149         if (code <= 0)
150             break;
151         /* otherwise process the line */
152         if (tbuffer[0] == '<') {
153             /* interpret the line as a set of options, any one of which will cause us
154              * to start copying the data again. */
155             code = ParseLine(tbuffer, &tokens);
156             if (code != 0)
157                 return -1;
158             copying = 0;
159             done = 0;
160             for (tp = alist; (!done) && (*tp != NULL); tp++) {
161                 for (tt = tokens; tt; tt = tt->next) {
162                     if (!strcmp(*tp, tt->key)) {
163                         /* Need to search all tokens in case a dont use
164                          * flag is set. But we can stop on the first
165                          * don't use.
166                          */
167                         if (tt->flags & TOK_DONTUSE) {
168                             copying = 0;
169                             done = 1;
170                             break;
171                         } else {
172                             copying = 1;
173                         }
174                     }
175                 }
176             }
177             FreeTokens(tokens);
178         } else {
179             /* just copy the line */
180             if (copying) {
181                 fwrite(tbuffer, 1, strlen(tbuffer), aout);
182                 putc('\n', aout);
183             }
184         }
185     }
186     return 0;
187 }