2015-12-19 06:39:27 +00:00
|
|
|
/**
|
|
|
|
* Copyright (c) 2015, Timothy Stack
|
|
|
|
*
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
|
|
|
* * Redistributions of source code must retain the above copyright notice, this
|
|
|
|
* list of conditions and the following disclaimer.
|
|
|
|
* * Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
|
|
* and/or other materials provided with the distribution.
|
|
|
|
* * Neither the name of Timothy Stack nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
|
|
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
|
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @file shlex.hh
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef LNAV_SHLEX_HH_H
|
|
|
|
#define LNAV_SHLEX_HH_H
|
|
|
|
|
2020-09-11 04:19:23 +00:00
|
|
|
#include <pwd.h>
|
|
|
|
|
2015-12-19 06:39:27 +00:00
|
|
|
#include <map>
|
2017-03-01 16:44:16 +00:00
|
|
|
#include <vector>
|
|
|
|
#include <string>
|
2015-12-19 06:39:27 +00:00
|
|
|
|
2020-11-17 18:04:23 +00:00
|
|
|
#include "base/opt_util.hh"
|
2019-05-08 12:30:59 +00:00
|
|
|
#include "pcrepp/pcrepp.hh"
|
2015-12-19 06:39:27 +00:00
|
|
|
|
2020-09-11 04:19:23 +00:00
|
|
|
enum class shlex_token_t {
|
2015-12-19 06:39:27 +00:00
|
|
|
ST_ERROR,
|
2015-12-25 20:03:44 +00:00
|
|
|
ST_WHITESPACE,
|
2015-12-19 06:39:27 +00:00
|
|
|
ST_ESCAPE,
|
|
|
|
ST_DOUBLE_QUOTE_START,
|
|
|
|
ST_DOUBLE_QUOTE_END,
|
|
|
|
ST_SINGLE_QUOTE_START,
|
|
|
|
ST_SINGLE_QUOTE_END,
|
|
|
|
ST_VARIABLE_REF,
|
2015-12-24 11:35:02 +00:00
|
|
|
ST_QUOTED_VARIABLE_REF,
|
2015-12-25 20:03:44 +00:00
|
|
|
ST_TILDE,
|
2015-12-19 06:39:27 +00:00
|
|
|
};
|
|
|
|
|
2017-03-01 16:44:16 +00:00
|
|
|
class scoped_resolver {
|
|
|
|
public:
|
|
|
|
scoped_resolver(std::initializer_list<std::map<std::string, std::string> *> l) {
|
|
|
|
this->sr_stack.insert(this->sr_stack.end(), l.begin(), l.end());
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef std::map<std::string, std::string>::const_iterator const_iterator;
|
|
|
|
|
|
|
|
const_iterator find(const std::string &str) const {
|
|
|
|
const_iterator retval;
|
|
|
|
|
|
|
|
for (auto scope : this->sr_stack) {
|
|
|
|
if ((retval = scope->find(str)) != scope->end()) {
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return this->end();
|
|
|
|
};
|
|
|
|
|
|
|
|
const_iterator end() const {
|
|
|
|
return this->sr_stack.back()->end();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<const std::map<std::string, std::string> *> sr_stack;
|
|
|
|
};
|
|
|
|
|
2015-12-19 06:39:27 +00:00
|
|
|
class shlex {
|
|
|
|
public:
|
|
|
|
shlex(const char *str, size_t len)
|
2017-04-15 05:49:36 +00:00
|
|
|
: s_str(str),
|
2020-09-11 04:19:23 +00:00
|
|
|
s_len(len) {
|
2015-12-19 06:39:27 +00:00
|
|
|
};
|
|
|
|
|
2020-12-30 21:49:29 +00:00
|
|
|
explicit shlex(const string_fragment &sf)
|
|
|
|
: s_str(sf.data()), s_len(sf.length()) {
|
|
|
|
}
|
|
|
|
|
2020-09-11 04:19:23 +00:00
|
|
|
explicit shlex(const std::string &str)
|
2017-04-15 05:49:36 +00:00
|
|
|
: s_str(str.c_str()),
|
2020-09-11 04:19:23 +00:00
|
|
|
s_len(str.size()) {
|
2015-12-24 11:35:02 +00:00
|
|
|
};
|
|
|
|
|
2017-04-15 05:49:36 +00:00
|
|
|
shlex &with_ignore_quotes(bool val) {
|
|
|
|
this->s_ignore_quotes = val;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2020-09-11 04:19:23 +00:00
|
|
|
bool tokenize(pcre_context::capture_t &cap_out, shlex_token_t &token_out);
|
2015-12-19 06:39:27 +00:00
|
|
|
|
2017-03-01 16:44:16 +00:00
|
|
|
template <typename Resolver = scoped_resolver>
|
|
|
|
bool eval(std::string &result, const Resolver &vars) {
|
2015-12-19 06:39:27 +00:00
|
|
|
result.clear();
|
|
|
|
|
|
|
|
pcre_context::capture_t cap;
|
|
|
|
shlex_token_t token;
|
|
|
|
int last_index = 0;
|
|
|
|
|
|
|
|
while (this->tokenize(cap, token)) {
|
|
|
|
result.append(&this->s_str[last_index], cap.c_begin - last_index);
|
|
|
|
switch (token) {
|
2020-09-11 04:19:23 +00:00
|
|
|
case shlex_token_t::ST_ERROR:
|
2015-12-19 06:39:27 +00:00
|
|
|
return false;
|
2020-09-11 04:19:23 +00:00
|
|
|
case shlex_token_t::ST_ESCAPE:
|
2015-12-19 06:39:27 +00:00
|
|
|
result.append(1, this->s_str[cap.c_begin + 1]);
|
|
|
|
break;
|
2020-09-11 04:19:23 +00:00
|
|
|
case shlex_token_t::ST_WHITESPACE:
|
2015-12-25 20:03:44 +00:00
|
|
|
result.append(&this->s_str[cap.c_begin], cap.length());
|
|
|
|
break;
|
2020-09-11 04:19:23 +00:00
|
|
|
case shlex_token_t::ST_VARIABLE_REF:
|
|
|
|
case shlex_token_t::ST_QUOTED_VARIABLE_REF: {
|
|
|
|
int extra = token == shlex_token_t::ST_VARIABLE_REF ? 0 : 1;
|
2015-12-24 11:35:02 +00:00
|
|
|
std::string var_name(&this->s_str[cap.c_begin + 1 + extra], cap.length() - 1 - extra * 2);
|
2015-12-19 06:39:27 +00:00
|
|
|
std::map<std::string, std::string>::const_iterator local_var;
|
|
|
|
const char *var_value = getenv(var_name.c_str());
|
|
|
|
|
|
|
|
if ((local_var = vars.find(var_name)) != vars.end()) {
|
|
|
|
result.append(local_var->second);
|
|
|
|
}
|
2020-09-11 04:19:23 +00:00
|
|
|
else if (var_value != nullptr) {
|
2015-12-19 06:39:27 +00:00
|
|
|
result.append(var_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2020-09-11 04:19:23 +00:00
|
|
|
case shlex_token_t::ST_TILDE:
|
|
|
|
this->resolve_home_dir(result, cap);
|
2015-12-25 20:03:44 +00:00
|
|
|
break;
|
2015-12-19 06:39:27 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
last_index = cap.c_end;
|
|
|
|
}
|
|
|
|
|
|
|
|
result.append(&this->s_str[last_index], this->s_len - last_index);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
|
2017-03-01 16:44:16 +00:00
|
|
|
template <typename Resolver>
|
|
|
|
bool split(std::vector<std::string> &result, const Resolver &vars) {
|
2015-12-25 20:03:44 +00:00
|
|
|
result.clear();
|
|
|
|
|
|
|
|
pcre_context::capture_t cap;
|
|
|
|
shlex_token_t token;
|
|
|
|
int last_index = 0;
|
|
|
|
bool start_new = true;
|
|
|
|
|
|
|
|
while (isspace(this->s_str[this->s_index])) {
|
|
|
|
this->s_index += 1;
|
|
|
|
}
|
|
|
|
while (this->tokenize(cap, token)) {
|
|
|
|
if (start_new) {
|
2019-05-03 20:50:19 +00:00
|
|
|
result.emplace_back("");
|
2015-12-25 20:03:44 +00:00
|
|
|
start_new = false;
|
|
|
|
}
|
|
|
|
result.back().append(&this->s_str[last_index], cap.c_begin - last_index);
|
|
|
|
switch (token) {
|
2020-09-11 04:19:23 +00:00
|
|
|
case shlex_token_t::ST_ERROR:
|
2015-12-25 20:03:44 +00:00
|
|
|
return false;
|
2020-09-11 04:19:23 +00:00
|
|
|
case shlex_token_t::ST_ESCAPE:
|
2015-12-25 20:03:44 +00:00
|
|
|
result.back().append(1, this->s_str[cap.c_begin + 1]);
|
|
|
|
break;
|
2020-09-11 04:19:23 +00:00
|
|
|
case shlex_token_t::ST_WHITESPACE:
|
2015-12-25 20:03:44 +00:00
|
|
|
start_new = true;
|
|
|
|
break;
|
2020-09-11 04:19:23 +00:00
|
|
|
case shlex_token_t::ST_VARIABLE_REF:
|
|
|
|
case shlex_token_t::ST_QUOTED_VARIABLE_REF: {
|
|
|
|
int extra = token == shlex_token_t::ST_VARIABLE_REF ? 0 : 1;
|
2015-12-25 20:03:44 +00:00
|
|
|
std::string var_name(&this->s_str[cap.c_begin + 1 + extra], cap.length() - 1 - extra * 2);
|
|
|
|
std::map<std::string, std::string>::const_iterator local_var;
|
|
|
|
const char *var_value = getenv(var_name.c_str());
|
|
|
|
|
|
|
|
if ((local_var = vars.find(var_name)) != vars.end()) {
|
|
|
|
result.back().append(local_var->second);
|
|
|
|
}
|
2020-09-11 04:19:23 +00:00
|
|
|
else if (var_value != nullptr) {
|
2015-12-25 20:03:44 +00:00
|
|
|
result.back().append(var_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2020-09-11 04:19:23 +00:00
|
|
|
case shlex_token_t::ST_TILDE:
|
|
|
|
this->resolve_home_dir(result.back(), cap);
|
2015-12-25 20:03:44 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
last_index = cap.c_end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (last_index < this->s_len) {
|
|
|
|
if (start_new || result.empty()) {
|
2020-09-11 04:19:23 +00:00
|
|
|
result.emplace_back("");
|
2015-12-25 20:03:44 +00:00
|
|
|
}
|
|
|
|
result.back().append(&this->s_str[last_index], this->s_len - last_index);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-12-19 06:39:27 +00:00
|
|
|
void reset() {
|
|
|
|
this->s_index = 0;
|
2020-09-11 04:19:23 +00:00
|
|
|
this->s_state = state_t::STATE_NORMAL;
|
2015-12-19 06:39:27 +00:00
|
|
|
};
|
|
|
|
|
2020-09-11 04:19:23 +00:00
|
|
|
void scan_variable_ref(pcre_context::capture_t &cap_out, shlex_token_t &token_out);
|
2015-12-24 11:35:02 +00:00
|
|
|
|
2020-09-11 04:19:23 +00:00
|
|
|
void resolve_home_dir(std::string& result, const pcre_context::capture_t cap) const {
|
|
|
|
if (cap.length() == 1) {
|
2020-11-10 06:17:17 +00:00
|
|
|
result.append(getenv_opt("HOME").value_or("~"));
|
2020-09-11 04:19:23 +00:00
|
|
|
} else {
|
|
|
|
auto username = (char *) alloca(cap.length());
|
|
|
|
|
|
|
|
memcpy(username, &this->s_str[cap.c_begin + 1], cap.length() - 1);
|
|
|
|
username[cap.length() - 1] = '\0';
|
|
|
|
auto pw = getpwnam(username);
|
|
|
|
if (pw != nullptr) {
|
|
|
|
result.append(pw->pw_dir);
|
|
|
|
} else {
|
|
|
|
result.append(&this->s_str[cap.c_begin], cap.length());
|
2015-12-24 11:35:02 +00:00
|
|
|
}
|
|
|
|
}
|
2020-09-11 04:19:23 +00:00
|
|
|
}
|
2015-12-24 11:35:02 +00:00
|
|
|
|
2020-09-11 04:19:23 +00:00
|
|
|
enum class state_t {
|
2015-12-19 06:39:27 +00:00
|
|
|
STATE_NORMAL,
|
|
|
|
STATE_IN_DOUBLE_QUOTE,
|
|
|
|
STATE_IN_SINGLE_QUOTE,
|
|
|
|
};
|
|
|
|
|
|
|
|
const char *s_str;
|
2016-03-05 04:53:10 +00:00
|
|
|
ssize_t s_len;
|
2020-09-11 04:19:23 +00:00
|
|
|
bool s_ignore_quotes{false};
|
|
|
|
ssize_t s_index{0};
|
|
|
|
state_t s_state{state_t::STATE_NORMAL};
|
2015-12-19 06:39:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif //LNAV_SHLEX_HH_H
|