/* Combine directory and filename to create a full path */
char * path_from_dir_base(char *dir, char *base) {
#if defined(__WIN32)
char sep = '\\';
#else
char sep = '/';
#endif
GString *path = NULL;
char *result;
if ((base != NULL) && (is_separator(base[0]))) {
path = g_string_new(base);
} else {
path = g_string_new(dir);
/* Ensure that folder ends in "/" */
if (!is_separator(path->str[strlen(path->str)-1]) ) {
g_string_append_c(path, sep);
}
g_string_append_printf(path, "%s", base);
}
result = path->str;
g_string_free(path, false);
return result;
}
// Check whether LINE is a valid PS line. Exclude occurrences of PS_COMMAND.
static bool valid_ps_line(const string& line, const string& ps_command)
{
int pid = ps_pid(line);
if (pid == 0)
return false; // No PID
// You don't want to debug DDD, don't you?
if (!remote_gdb() && pid == getpid())
return false;
// Neither should you debug GDB by itself.
if (pid == gdb->pid())
return false;
// Don't issue lines containing `ps' (or whatever the first word
// in PS_COMMAND is).
string ps = ps_command;
if (ps.contains(' '))
ps = ps.before(' ');
ps = basename(ps.chars());
int index = line.index(ps);
if (index > 0
&& (line[index - 1] == '/' || is_separator(line[index - 1]))
&& (line.length() == index + ps.length()
|| is_separator(line[index + ps.length()])))
return false;
// Okay, just leave it
return true;
}
static const char *get_token(const char *s, const char **e)
{
const char *p;
while (isspace(*s)) /* Skip spaces */
s++;
if (*s == '\0') {
p = s;
goto end;
}
p = s + 1;
if (!is_separator(*s)) {
/* End search */
retry:
while (*p && !is_separator(*p) && !isspace(*p))
p++;
/* Escape and special case: '!' is also used in glob pattern */
if (*(p - 1) == '\\' || (*p == '!' && *(p - 1) == '[')) {
p++;
goto retry;
}
}
end:
*e = p;
return s;
}
static const char *get_token(const char *s, const char **e)
{
const char *p;
while (isspace(*s)) /* */
s++;
if (*s == '\0') {
p = s;
goto end;
}
p = s + 1;
if (!is_separator(*s)) {
/* */
retry:
while (*p && !is_separator(*p) && !isspace(*p))
p++;
/* */
if (*(p - 1) == '\\' || (*p == '!' && *(p - 1) == '[')) {
p++;
goto retry;
}
}
end:
*e = p;
return s;
}
char *
parser_get_next_word(char **sp)
{
static char buffer[512];
char *s = *sp, *p = buffer;
while (is_separator(*s))
++s;
if (*s == '\0')
goto done;
if (is_punctuation(*s)) {
*p++ = *s++;
goto done;
}
while (*s && !is_separator(*s) && !is_punctuation(*s))
*p++ = *s++;
done:
*p++ = '\0';
*sp = s;
return buffer[0]? buffer : NULL;
}
void path::m_path_iterator_decrement(path::iterator & it)
{
BOOST_ASSERT(it.m_pos && "path::iterator decrement past begin()");
size_type end_pos(it.m_pos);
// if at end and there was a trailing non-root '/', return "."
if (it.m_pos == it.m_path_ptr->m_pathname.size()
&& it.m_path_ptr->m_pathname.size() > 1
&& is_separator(it.m_path_ptr->m_pathname[it.m_pos-1])
&& is_non_root_separator(it.m_path_ptr->m_pathname, it.m_pos-1)
)
{
--it.m_pos;
it.m_element = dot_path;
return;
}
size_type root_dir_pos(root_directory_start(it.m_path_ptr->m_pathname, end_pos));
// skip separators unless root directory
for (
;
end_pos > 0
&& (end_pos-1) != root_dir_pos
&& is_separator(it.m_path_ptr->m_pathname[end_pos-1])
;
--end_pos) {}
it.m_pos = filename_pos(it.m_path_ptr->m_pathname, end_pos);
it.m_element = it.m_path_ptr->m_pathname.substr(it.m_pos, end_pos - it.m_pos);
if (it.m_element.m_pathname == preferred_separator_string)
it.m_element.m_pathname = separator_string; // needed for Windows, harmless on POSIX
}
//------------------------------------------------------------------------
bool path_tokenizer::next()
{
if(m_path == 0) return false;
// Skip all white spaces and other garbage
while(*m_path && !is_command(*m_path) && !is_numeric(*m_path))
{
if(!is_separator(*m_path))
{
char buf[100];
sprintf(buf, "path_tokenizer::next : Invalid Character %c", *m_path);
throw exception(buf);
}
m_path++;
}
if(*m_path == 0) return false;
if(is_command(*m_path))
{
// Check if the command is a numeric sign character
if(*m_path == '-' || *m_path == '+')
{
return parse_number();
}
m_last_command = *m_path++;
while(*m_path && is_separator(*m_path)) m_path++;
if(*m_path == 0) return true;
}
return parse_number();
}
static C_RESULT parse_string(FILE* f, char* str, int32_t maxlen)
{
int32_t i = 0;
bool_t is_quoted = is_quote(current_c);
if( is_quoted )
{
while( SUCCEED(fetch_char(f)) && ! ( is_separator(current_c) && is_quote(current_c) ) ) {
str[i] = current_c;
i++;
}
}
else
{
while( SUCCEED(fetch_char(f)) && !is_separator(current_c) ) {
str[i] = current_c;
i++;
}
}
str[i] = '\0';
// PRINT("parse_string: %s\n", str);
return is_eol( current_c ) ? C_FAIL : C_OK;
}
void path::m_path_iterator_increment(path::iterator & it)
{
BOOST_ASSERT(it.m_pos < it.m_path_ptr->m_pathname.size() && "path::basic_iterator increment past end()");
// increment to position past current element
it.m_pos += it.m_element.m_pathname.size();
// if end reached, create end basic_iterator
if (it.m_pos == it.m_path_ptr->m_pathname.size())
{
it.m_element.clear();
return;
}
// both POSIX and Windows treat paths that begin with exactly two separators specially
bool was_net(it.m_element.m_pathname.size() > 2
&& is_separator(it.m_element.m_pathname[0])
&& is_separator(it.m_element.m_pathname[1])
&& !is_separator(it.m_element.m_pathname[2]));
// process separator (Windows drive spec is only case not a separator)
if (is_separator(it.m_path_ptr->m_pathname[it.m_pos]))
{
// detect root directory
if (was_net
# ifdef BOOST_WINDOWS_API
// case "c:/"
|| it.m_element.m_pathname[it.m_element.m_pathname.size()-1] == colon
# endif
)
{
it.m_element.m_pathname = separator;
return;
}
// bypass separators
while (it.m_pos != it.m_path_ptr->m_pathname.size()
&& is_separator(it.m_path_ptr->m_pathname[it.m_pos]))
{
++it.m_pos;
}
// detect trailing separator, and treat it as ".", per POSIX spec
if (it.m_pos == it.m_path_ptr->m_pathname.size()
&& is_non_root_separator(it.m_path_ptr->m_pathname, it.m_pos-1))
{
--it.m_pos;
it.m_element = dot_path;
return;
}
}
// get next element
size_type end_pos(it.m_path_ptr->m_pathname.find_first_of(separators, it.m_pos));
if (end_pos == string_type::npos) end_pos = it.m_path_ptr->m_pathname.size();
it.m_element = it.m_path_ptr->m_pathname.substr(it.m_pos, end_pos - it.m_pos);
}
/* return 1 if attrs match, 0 otherwise */
static int
match_attrs(char *nas_arg, char *server_arg)
{
while (*nas_arg && *server_arg) {
if (is_separator(*nas_arg) && is_separator(*server_arg)) {
return(1);
}
if (*nas_arg != *server_arg)
return(0);
nas_arg++;
server_arg++;
}
return(0);
}
static int l_split( lua_State* L )
{
size_t length;
const char* path = luaL_checklstring( L, 1, &length );
const char* ext = path + length;
while ( ext >= path && *ext != '.' && !is_separator( *ext ) )
{
ext--;
}
const char* name = ext;
if ( *ext != '.' )
{
ext = NULL;
}
while ( name >= path && !is_separator( *name ) )
{
name--;
}
if ( is_separator( *name ) )
{
name++;
}
if ( name - path - 1 > 0 )
{
lua_pushlstring( L, path, name - path - 1 );
}
else
{
lua_pushliteral( L, "" );
}
if ( ext != NULL )
{
lua_pushlstring( L, name, ext - name );
lua_pushstring( L, ext );
}
else
{
lua_pushstring( L, name );
lua_pushliteral( L, "" );
}
return 3;
}
/**
* Gets token from expression and writes it to buffer
* If no more tokens then buffer will be empty string
*
* @param *expression Expression with tokens
* @param *buffer Buffer for token
* @param *position Next token starts here
*/
static void get_token(const char *expression, char *buffer, unsigned int *position)
{
if (is_separator(expression[*position])) {
*buffer++ = expression[*position];
++(*position);
}
else {
while (expression[*position] && !is_separator(expression[*position])) {
*buffer++ = expression[*position];
++(*position);
}
}
*buffer = '\0';
}
gint gtk_text_buffer_get_word_count (GtkTextBuffer *buffer){
GtkTextIter start, end;
gchar *cstring=NULL;
gint i, leng, icount;
gtk_text_buffer_get_bounds (buffer, &start, &end);
cstring = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
leng = strlen (cstring);
for ( i = (icount = 1) - 1; i < leng; i++ ){
if ( is_separator (cstring[i]) && !is_separator (i ? cstring[i - 1] : 'h') )icount++;
}
if ( is_separator (cstring[i - 1]) ) icount--;
g_free (cstring);
return icount;
}
int token_get_string(struct finsh_token* self, u_char* str)
{
unsigned char *p=str;
char ch;
ch = token_next_char(self);
if (is_eof(self)) return -1;
str[0] = '\0';
if ( is_digit(ch) ) { /*the first character of identifier is not a digit.*/
token_prev_char(self);
return -1;
}
while (!is_separator(ch) && !is_eof(self)) {
*p++ = ch;
ch = token_next_char(self);
}
self->eof = 0;
token_prev_char(self);
*p = '\0';
return 0;
}
extern int lexeme_is_word(t_lex **lex, char *line,
char *str, int *i)
{
int j;
char c;
j = 0;
while (line[*i] && !is_separator(line[*i]))
{
if (((c = line[*i] == '"') &&
(*i != 0 && line[*i - 1] != '\\')) || (c = line[*i]) == '\'')
{
str[j++] = line[(*i)++];
while (line[(*i)] != '\0' && line[(*i)] != c)
str[j++] = line[(*i)++];
if (line[(*i)] != '\0')
str[j++] = line[(*i)++];
}
if (line[(*i)] != '\0')
str[j++] = line[(*i)++];
}
if (!my_count_printable(str))
return (1);
*lex = add_lexeme(*lex, COMMAND, str);
return (0);
}
static int check_muli_redirections(char **command)
{
int left;
int right;
left = 0;
right = 0;
while (*command)
{
if (!strcmp(">", *command) || !strcmp(">>", *command))
{
if (right || !(right = 1))
return (fprintf(stderr, "Ambiguous output redirect.\n") || 1);
}
if (!strcmp("<", *command) || !strcmp("<<", *command))
if (left || !(left = 1))
return (fprintf(stderr, "Ambiguous input redirect.\n") || 1);
if (is_separator(*command))
{
left = 0;
right = 0;
}
command++;
}
return (0);
}
static BOOL is_integer(parse_buffer* buf)
{
char tmp[50];
DWORD pos = 0;
char c;
DWORD integer;
while (!is_separator(c = *(buf->buffer+pos)))
{
if (!((c >= '0') && (c <= '9')))
return FALSE;
tmp[pos++] = c;
}
tmp[pos] = 0;
buf->buffer += pos;
buf->rem_bytes -= pos;
sscanf(tmp, "%d", &integer);
TRACE("Found integer %s - %d\n", tmp, integer);
*(DWORD*)buf->value = integer;
return TRUE;
}
std::string folder_append_separator(const std::string& folder)
{
std::string result = folder;
if (!is_separator(result[result.size()-1]))
result += preferred_separator;
return result;
}
static BOOL is_string(parse_buffer* buf)
{
char tmp[100];
DWORD pos = 0;
char c;
BOOL ok = 0;
if (*buf->buffer != '"')
return FALSE;
while (!is_separator(c = *(buf->buffer+pos+1)) && (pos < 99))
{
if (c == '"')
{
ok = 1;
break;
}
tmp[pos++] = c;
}
tmp[pos] = 0;
if (!ok)
{
TRACE("Wrong string %s\n", tmp);
return FALSE;
}
buf->buffer += pos + 2;
buf->rem_bytes -= pos + 2;
TRACE("Found string %s\n", tmp);
strcpy((char*)buf->value, tmp);
return TRUE;
}
/* Return 1 if arg is mandatory, 0 otherwise */
static int
mandatory(char *arg)
{
char *p = arg;
while (*p && !is_separator(*p))
p++;
/* if we're not at the end, this must be the separator */
if (*p && !is_separator(*p)) {
report(LOG_ERR, "%s: Error on arg %s cannot find separator",
session.peer, arg);
return(0);
}
return(*p == '=');
}
static BOOL is_name(parse_buffer* buf)
{
char tmp[50];
DWORD pos = 0;
char c;
BOOL error = 0;
while (!is_separator(c = *(buf->buffer+pos)))
{
if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) || ((c >= '0') && (c <= '9')) || (c == '_') || (c == '-')))
error = 1;
tmp[pos++] = c;
}
tmp[pos] = 0;
if (error)
{
TRACE("Wrong name %s\n", tmp);
return FALSE;
}
buf->buffer += pos;
buf->rem_bytes -= pos;
TRACE("Found name %s\n", tmp);
strcpy((char*)buf->value, tmp);
return TRUE;
}
/**
* 文字列が余分なセパレータで終わっているかどうかを返します。
*/
bool isTerminatedByRedundantSeparator(const PathString &s)
{
// 完全修飾パス
// \\Server\a\ => true?
// \\Server\ => true?
// \\?\C:\ => false
// \\?\ => false
// C:\a\ => true
// C:\ => false
//
// 非完全修飾パス
// \ => false
// C:a\ => true
// .\ => true
// a\ => true
std::size_t lastSepPos = s.size();
NativeChar prevChar = AUSH_NATIVE_L('\0');
NativeChar lastSepPrevChar = AUSH_NATIVE_L('\0');
for(std::size_t pos = 0; pos < s.size(); pos = next_char_pos(s, pos)){
NativeChar currChar = s[pos];
if(is_separator()(currChar)){
lastSepPos = pos;
lastSepPrevChar = prevChar;
}
prevChar = currChar;
}
return (lastSepPos + 1 == s.size()
&& lastSepPrevChar != AUSH_NATIVE_L(':')
&& lastSepPrevChar != AUSH_NATIVE_L('?')
&& lastSepPrevChar != AUSH_NATIVE_L('\0'));
}
static int check_redirection(char **command)
{
int pipe;
int right;
pipe = 0;
right = 0;
while (*command)
{
if (!strcmp("|", *command) && (pipe = 1))
if (right)
return (fprintf(stderr, "Ambiguous output redirect.\n") || 1);
if (!strcmp(">", *command) || !strcmp(">>", *command))
right = 1;
if (!strcmp("<", *command) || !strcmp("<<", *command))
if (pipe)
return (fprintf(stderr, "Ambiguous input redirect.\n") || 1);
if (is_separator(*command))
{
pipe = 0;
right = 0;
}
command++;
}
return (0);
}
static BOOL is_float(parse_buffer* buf)
{
char tmp[50];
DWORD pos = 0;
char c;
float decimal;
BOOL dot = 0;
while (!is_separator(c = *(buf->buffer+pos)))
{
if (!((!pos && (c == '-')) || ((c >= '0') && (c <= '9')) || (!dot && (c == '.'))))
return FALSE;
if (c == '.')
dot = TRUE;
tmp[pos++] = c;
}
tmp[pos] = 0;
buf->buffer += pos;
buf->rem_bytes -= pos;
sscanf(tmp, "%f", &decimal);
TRACE("Found float %s - %f\n", tmp, decimal);
*(float*)buf->value = decimal;
return TRUE;
}
/**
* Scans the token list from the beginning and moves to the token that covers the given
* caret position. Line is one-based and offset is the zero-based offset in that line.
*/
void MySQLScanner::seek(size_t line, size_t offset)
{
// When scanning keep in mind a token can span more than one line (think of multi-line comments).
// A simple pos + length computation doesn't cut it.
d->_token_index = 0;
if ( d->_tokens[d->_token_index]->type == ANTLR3_TOKEN_EOF)
return;
while (true)
{
// When we reach the input end check if the current token can alone separate from the next token.
// Some tokens require a whitespace for separation, some do not.
pANTLR3_COMMON_TOKEN token = d->_tokens[d->_token_index + 1];
if (token->type == ANTLR3_TOKEN_EOF)
{
// At the end of the input. We have no more tokens to make the lookahead work (nothing after EOF).
// Instead we define: if the last good token is a separator and the caret is at its end
// we consider the EOF as the current token (a separator is always only 1 char long).
if (is_separator() && (size_t)d->_tokens[d->_token_index]->charPosition < offset)
++d->_token_index;
break;
}
if (token->line > line)
break;
if (token->line == line && (size_t)token->charPosition > offset)
break;
++d->_token_index;
};
}
bool is_separator(const std::string K) {
for (auto cit = K.begin(); cit != K.end(); cit++) {
if (!is_separator(*cit)) {
return false;
}
}
return true;
}
/**
* Remove trailinig path separator.
*/
string
remove_trailing_path_separator(const string& in_path)
{
string new_string = in_path;
if (!new_string.empty() && is_separator(new_string[new_string.size() - 1]))
new_string.erase(new_string.size() - 1);
return new_string;
}
path path::root_name() const
{
iterator itr(begin());
return (itr.m_pos != m_pathname.size()
&& (
(itr.m_element.m_pathname.size() > 1
&& is_separator(itr.m_element.m_pathname[0])
&& is_separator(itr.m_element.m_pathname[1])
)
# ifdef BOOST_WINDOWS_API
|| itr.m_element.m_pathname[itr.m_element.m_pathname.size()-1] == colon
# endif
))
? itr.m_element
: path();
}
static unsigned long long __get_mult_bytes(const char *p, void *data,
int *percent)
{
unsigned int kb_base = fio_get_kb_base(data);
unsigned long long ret = 1;
unsigned int i, pow = 0, mult = kb_base;
char *c;
if (!p)
return 1;
c = strdup(p);
for (i = 0; i < strlen(c); i++) {
c[i] = tolower(c[i]);
if (is_separator(c[i])) {
c[i] = '\0';
break;
}
}
if (!strncmp("pib", c, 3)) {
pow = 5;
mult = 1000;
} else if (!strncmp("tib", c, 3)) {
pow = 4;
mult = 1000;
} else if (!strncmp("gib", c, 3)) {
pow = 3;
mult = 1000;
} else if (!strncmp("mib", c, 3)) {
pow = 2;
mult = 1000;
} else if (!strncmp("kib", c, 3)) {
pow = 1;
mult = 1000;
} else if (!strncmp("p", c, 1) || !strncmp("pb", c, 2))
pow = 5;
else if (!strncmp("t", c, 1) || !strncmp("tb", c, 2))
pow = 4;
else if (!strncmp("g", c, 1) || !strncmp("gb", c, 2))
pow = 3;
else if (!strncmp("m", c, 1) || !strncmp("mb", c, 2))
pow = 2;
else if (!strncmp("k", c, 1) || !strncmp("kb", c, 2))
pow = 1;
else if (!strncmp("%", c, 1)) {
*percent = 1;
free(c);
return ret;
}
while (pow--)
ret *= (unsigned long long) mult;
free(c);
return ret;
}
path & path::operator/=(const path & p)
{
if (p.empty())
return *this;
if (!is_separator(*p.m_pathname.begin()))
m_append_separator_if_needed();
m_pathname += p.m_pathname;
return *this;
}
