1/* 2 * Copyright © 2012 Intel Corporation 3 * Copyright © 2012 Ran Benita 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 * 24 * Author: Daniel Stone <daniel@fooishbar.org> 25 */ 26 27#include <sys/types.h> 28#include <sys/stat.h> 29#include <errno.h> 30#include <unistd.h> 31 32#include "xkbcommon/xkbcommon.h" 33#include "utils.h" 34#include "context.h" 35 36unsigned int 37xkb_context_num_failed_include_paths(struct xkb_context *ctx) 38{ 39 return darray_size(ctx->failed_includes); 40} 41 42const char * 43xkb_context_failed_include_path_get(struct xkb_context *ctx, 44 unsigned int idx) 45{ 46 if (idx >= xkb_context_num_failed_include_paths(ctx)) 47 return NULL; 48 49 return darray_item(ctx->failed_includes, idx); 50} 51 52xkb_atom_t 53xkb_atom_lookup(struct xkb_context *ctx, const char *string) 54{ 55 return atom_lookup(ctx->atom_table, string, strlen(string)); 56} 57 58xkb_atom_t 59xkb_atom_intern(struct xkb_context *ctx, const char *string, size_t len) 60{ 61 return atom_intern(ctx->atom_table, string, len, false); 62} 63 64xkb_atom_t 65xkb_atom_steal(struct xkb_context *ctx, char *string) 66{ 67 return atom_intern(ctx->atom_table, string, strlen(string), true); 68} 69 70const char * 71xkb_atom_text(struct xkb_context *ctx, xkb_atom_t atom) 72{ 73 return atom_text(ctx->atom_table, atom); 74} 75 76void 77xkb_log(struct xkb_context *ctx, enum xkb_log_level level, int verbosity, 78 const char *fmt, ...) 79{ 80 va_list args; 81 82 if (ctx->log_level < level || ctx->log_verbosity < verbosity) 83 return; 84 85 va_start(args, fmt); 86 ctx->log_fn(ctx, level, fmt, args); 87 va_end(args); 88} 89 90char * 91xkb_context_get_buffer(struct xkb_context *ctx, size_t size) 92{ 93 char *rtrn; 94 95 if (size >= sizeof(ctx->text_buffer)) 96 return NULL; 97 98 if (sizeof(ctx->text_buffer) - ctx->text_next <= size) 99 ctx->text_next = 0; 100 101 rtrn = &ctx->text_buffer[ctx->text_next]; 102 ctx->text_next += size; 103 104 return rtrn; 105} 106 107#ifndef DEFAULT_XKB_VARIANT 108#define DEFAULT_XKB_VARIANT NULL 109#endif 110 111#ifndef DEFAULT_XKB_OPTIONS 112#define DEFAULT_XKB_OPTIONS NULL 113#endif 114 115static const char * 116xkb_context_get_default_rules(struct xkb_context *ctx) 117{ 118 const char *env = NULL; 119 120 if (ctx->use_environment_names) 121 env = secure_getenv("XKB_DEFAULT_RULES"); 122 123 return env ? env : DEFAULT_XKB_RULES; 124} 125 126static const char * 127xkb_context_get_default_model(struct xkb_context *ctx) 128{ 129 const char *env = NULL; 130 131 if (ctx->use_environment_names) 132 env = secure_getenv("XKB_DEFAULT_MODEL"); 133 134 return env ? env : DEFAULT_XKB_MODEL; 135} 136 137static const char * 138xkb_context_get_default_layout(struct xkb_context *ctx) 139{ 140 const char *env = NULL; 141 142 if (ctx->use_environment_names) 143 env = secure_getenv("XKB_DEFAULT_LAYOUT"); 144 145 return env ? env : DEFAULT_XKB_LAYOUT; 146} 147 148static const char * 149xkb_context_get_default_variant(struct xkb_context *ctx) 150{ 151 const char *env = NULL; 152 const char *layout = secure_getenv("XKB_DEFAULT_LAYOUT"); 153 154 /* We don't want to inherit the variant if they haven't also set a 155 * layout, since they're so closely paired. */ 156 if (layout && ctx->use_environment_names) 157 env = secure_getenv("XKB_DEFAULT_VARIANT"); 158 159 return env ? env : DEFAULT_XKB_VARIANT; 160} 161 162static const char * 163xkb_context_get_default_options(struct xkb_context *ctx) 164{ 165 const char *env = NULL; 166 167 if (ctx->use_environment_names) 168 env = secure_getenv("XKB_DEFAULT_OPTIONS"); 169 170 return env ? env : DEFAULT_XKB_OPTIONS; 171} 172 173void 174xkb_context_sanitize_rule_names(struct xkb_context *ctx, 175 struct xkb_rule_names *rmlvo) 176{ 177 if (isempty(rmlvo->rules)) 178 rmlvo->rules = xkb_context_get_default_rules(ctx); 179 if (isempty(rmlvo->model)) 180 rmlvo->model = xkb_context_get_default_model(ctx); 181 /* Layout and variant are tied together, so don't try to use one from 182 * the caller and one from the environment. */ 183 if (isempty(rmlvo->layout)) { 184 rmlvo->layout = xkb_context_get_default_layout(ctx); 185 rmlvo->variant = xkb_context_get_default_variant(ctx); 186 } 187 /* Options can be empty, so respect that if passed in. */ 188 if (rmlvo->options == NULL) 189 rmlvo->options = xkb_context_get_default_options(ctx); 190} 191