1 /************************************************************
2 * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
3 *
4 * Permission to use, copy, modify, and distribute this
5 * software and its documentation for any purpose and without
6 * fee is hereby granted, provided that the above copyright
7 * notice appear in all copies and that both that copyright
8 * notice and this permission notice appear in supporting
9 * documentation, and that the name of Silicon Graphics not be
10 * used in advertising or publicity pertaining to distribution
11 * of the software without specific prior written permission.
12 * Silicon Graphics makes no representation about the suitability
13 * of this software for any purpose. It is provided "as is"
14 * without any express or implied warranty.
15 *
16 * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
17 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
18 * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
19 * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
20 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
21 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
22 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
23 * THE USE OR PERFORMANCE OF THIS SOFTWARE.
24 *
25 ********************************************************/
26
27 /*
28 * Copyright © 2012 Ran Benita <ran234@gmail.com>
29 *
30 * Permission is hereby granted, free of charge, to any person obtaining a
31 * copy of this software and associated documentation files (the "Software"),
32 * to deal in the Software without restriction, including without limitation
33 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
34 * and/or sell copies of the Software, and to permit persons to whom the
35 * Software is furnished to do so, subject to the following conditions:
36 *
37 * The above copyright notice and this permission notice (including the next
38 * paragraph) shall be included in all copies or substantial portions of the
39 * Software.
40 *
41 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
42 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
43 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
44 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
45 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
46 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
47 * DEALINGS IN THE SOFTWARE.
48 */
49
50 #include "config.h"
51
52 #include <errno.h>
53 #include <limits.h>
54 #include <stdio.h>
55
56 #include "xkbcomp-priv.h"
57 #include "include.h"
58
59 /**
60 * Parse an include statement. Each call returns a file name, along with
61 * (possibly) a specific map in the file, an explicit group designator, and
62 * the separator from the next file, used to determine the merge mode.
63 *
64 * @param str_inout Input statement, modified in-place. Should be passed in
65 * repeatedly. If str_inout is NULL, the parsing has completed.
66 *
67 * @param file_rtrn Set to the name of the include file to be used. Combined
68 * with an enum xkb_file_type, this determines which file to look for in the
69 * include path.
70 *
71 * @param map_rtrn Set to the string between '(' and ')', if any. This will
72 * result in the compilation of a specific named map within the file (e.g.
73 * xkb_symbols "basic" { ... }) , as opposed to the default map of the file.
74 *
75 * @param nextop_rtrn Set to the next operation in the complete statement,
76 * which is '\0' if it's the last file or '+' or '|' if there are more.
77 * Separating the files with '+' sets the merge mode to MERGE_MODE_OVERRIDE,
78 * while '|' sets the merge mode to MERGE_MODE_AUGMENT.
79 *
80 * @param extra_data Set to the string after ':', if any. Currently the
81 * extra data is only used for setting an explicit group index for a symbols
82 * file.
83 *
84 * @return true if parsing was successful, false for an illegal string.
85 *
86 * Example: "evdev+aliases(qwerty):2"
87 * str_inout = "aliases(qwerty):2"
88 * file_rtrn = "evdev"
89 * map_rtrn = NULL
90 * nextop_retrn = "+"
91 * extra_data = NULL
92 *
93 * 2nd run with "aliases(qwerty):2"
94 * str_inout = NULL
95 * file_rtrn = "aliases"
96 * map_rtrn = "qwerty"
97 * nextop_retrn = ""
98 * extra_data = "2"
99 *
100 */
101 bool
ParseIncludeMap(char ** str_inout,char ** file_rtrn,char ** map_rtrn,char * nextop_rtrn,char ** extra_data)102 ParseIncludeMap(char **str_inout, char **file_rtrn, char **map_rtrn,
103 char *nextop_rtrn, char **extra_data)
104 {
105 char *tmp, *str, *next;
106
107 str = *str_inout;
108
109 /*
110 * Find the position in the string where the next file is included,
111 * if there is more than one left in the statement.
112 */
113 next = strpbrk(str, "|+");
114 if (next) {
115 /* Got more files, this function will be called again. */
116 *nextop_rtrn = *next;
117 /* Separate the string, for strchr etc. to work on this file only. */
118 *next++ = '\0';
119 }
120 else {
121 /* This is the last file in this statement, won't be called again. */
122 *nextop_rtrn = '\0';
123 next = NULL;
124 }
125
126 /*
127 * Search for the explicit group designator, if any. If it's there,
128 * it goes after the file name and map.
129 */
130 tmp = strchr(str, ':');
131 if (tmp != NULL) {
132 *tmp++ = '\0';
133 *extra_data = strdup(tmp);
134 }
135 else {
136 *extra_data = NULL;
137 }
138
139 /* Look for a map, if any. */
140 tmp = strchr(str, '(');
141 if (tmp == NULL) {
142 /* No map. */
143 *file_rtrn = strdup(str);
144 *map_rtrn = NULL;
145 }
146 else if (str[0] == '(') {
147 /* Map without file - invalid. */
148 free(*extra_data);
149 return false;
150 }
151 else {
152 /* Got a map; separate the file and the map for the strdup's. */
153 *tmp++ = '\0';
154 *file_rtrn = strdup(str);
155 str = tmp;
156 tmp = strchr(str, ')');
157 if (tmp == NULL || tmp[1] != '\0') {
158 free(*file_rtrn);
159 free(*extra_data);
160 return false;
161 }
162 *tmp++ = '\0';
163 *map_rtrn = strdup(str);
164 }
165
166 /* Set up the next file for the next call, if any. */
167 if (*nextop_rtrn == '\0')
168 *str_inout = NULL;
169 else if (*nextop_rtrn == '|' || *nextop_rtrn == '+')
170 *str_inout = next;
171 else
172 return false;
173
174 return true;
175 }
176
177 static const char *xkb_file_type_include_dirs[_FILE_TYPE_NUM_ENTRIES] = {
178 [FILE_TYPE_KEYCODES] = "keycodes",
179 [FILE_TYPE_TYPES] = "types",
180 [FILE_TYPE_COMPAT] = "compat",
181 [FILE_TYPE_SYMBOLS] = "symbols",
182 [FILE_TYPE_GEOMETRY] = "geometry",
183 [FILE_TYPE_KEYMAP] = "keymap",
184 [FILE_TYPE_RULES] = "rules",
185 };
186
187 /**
188 * Return the xkb directory based on the type.
189 */
190 static const char *
DirectoryForInclude(enum xkb_file_type type)191 DirectoryForInclude(enum xkb_file_type type)
192 {
193 if (type >= _FILE_TYPE_NUM_ENTRIES)
194 return "";
195 return xkb_file_type_include_dirs[type];
196 }
197
198 static void
LogIncludePaths(struct xkb_context * ctx)199 LogIncludePaths(struct xkb_context *ctx)
200 {
201 unsigned int i;
202
203 if (xkb_context_num_include_paths(ctx) > 0) {
204 log_err(ctx, "%d include paths searched:\n",
205 xkb_context_num_include_paths(ctx));
206 for (i = 0; i < xkb_context_num_include_paths(ctx); i++)
207 log_err(ctx, "\t%s\n",
208 xkb_context_include_path_get(ctx, i));
209 }
210 else {
211 log_err(ctx, "There are no include paths to search\n");
212 }
213
214 if (xkb_context_num_failed_include_paths(ctx) > 0) {
215 log_err(ctx, "%d include paths could not be added:\n",
216 xkb_context_num_failed_include_paths(ctx));
217 for (i = 0; i < xkb_context_num_failed_include_paths(ctx); i++)
218 log_err(ctx, "\t%s\n",
219 xkb_context_failed_include_path_get(ctx, i));
220 }
221 }
222
223 /**
224 * Return an open file handle to the first file (counting from offset) with the
225 * given name in the include paths, starting at the offset.
226 *
227 * offset must be zero the first time this is called and is set to the index the
228 * file was found. Call again with offset+1 to keep searching through the
229 * include paths.
230 *
231 * If this function returns NULL, no more files are available.
232 */
233 FILE *
FindFileInXkbPath(struct xkb_context * ctx,const char * name,enum xkb_file_type type,char ** pathRtrn,unsigned int * offset)234 FindFileInXkbPath(struct xkb_context *ctx, const char *name,
235 enum xkb_file_type type, char **pathRtrn,
236 unsigned int *offset)
237 {
238 unsigned int i;
239 FILE *file = NULL;
240 char *buf = NULL;
241 const char *typeDir;
242
243 typeDir = DirectoryForInclude(type);
244
245 for (i = *offset; i < xkb_context_num_include_paths(ctx); i++) {
246 buf = asprintf_safe("%s/%s/%s", xkb_context_include_path_get(ctx, i),
247 typeDir, name);
248 if (!buf) {
249 log_err(ctx, "Failed to alloc buffer for (%s/%s/%s)\n",
250 xkb_context_include_path_get(ctx, i), typeDir, name);
251 continue;
252 }
253
254 file = fopen(buf, "rb");
255 if (file) {
256 if (pathRtrn) {
257 *pathRtrn = buf;
258 buf = NULL;
259 }
260 *offset = i;
261 goto out;
262 }
263 }
264
265 /* We only print warnings if we can't find the file on the first lookup */
266 if (*offset == 0) {
267 log_err(ctx, "Couldn't find file \"%s/%s\" in include paths\n",
268 typeDir, name);
269 LogIncludePaths(ctx);
270 }
271
272 out:
273 free(buf);
274 return file;
275 }
276
277 XkbFile *
ProcessIncludeFile(struct xkb_context * ctx,IncludeStmt * stmt,enum xkb_file_type file_type)278 ProcessIncludeFile(struct xkb_context *ctx, IncludeStmt *stmt,
279 enum xkb_file_type file_type)
280 {
281 FILE *file;
282 XkbFile *xkb_file = NULL;
283 unsigned int offset = 0;
284
285 file = FindFileInXkbPath(ctx, stmt->file, file_type, NULL, &offset);
286 if (!file)
287 return NULL;
288
289 while (file) {
290 xkb_file = XkbParseFile(ctx, file, stmt->file, stmt->map);
291 fclose(file);
292
293 if (xkb_file) {
294 if (xkb_file->file_type != file_type) {
295 log_err(ctx,
296 "Include file of wrong type (expected %s, got %s); "
297 "Include file \"%s\" ignored\n",
298 xkb_file_type_to_string(file_type),
299 xkb_file_type_to_string(xkb_file->file_type), stmt->file);
300 FreeXkbFile(xkb_file);
301 xkb_file = NULL;
302 } else {
303 break;
304 }
305 }
306
307 offset++;
308 file = FindFileInXkbPath(ctx, stmt->file, file_type, NULL, &offset);
309 }
310
311 if (!xkb_file) {
312 if (stmt->map)
313 log_err(ctx, "Couldn't process include statement for '%s(%s)'\n",
314 stmt->file, stmt->map);
315 else
316 log_err(ctx, "Couldn't process include statement for '%s'\n",
317 stmt->file);
318 }
319
320 /* FIXME: we have to check recursive includes here (or somewhere) */
321
322 return xkb_file;
323 }
324