static gboolean
add_scale_mark (const gchar *option_name,
const gchar *value,
gpointer data, GError **err)
{
YadScaleMark *mark;
gchar **mstr = split_arg (value);
mark = g_new0 (YadScaleMark, 1);
mark->name = g_strdup (mstr[0]);
if (mstr[1])
{
mark->value = g_ascii_strtoll (mstr[1], NULL, 10);
options.scale_data.marks = g_slist_append (options.scale_data.marks, mark);
}
else
{
g_printerr (_("Mark %s doesn't have a value\n"), mark->name);
g_free (mark->name);
g_free (mark);
}
g_strfreev (mstr);
return TRUE;
}
int percent(const char *format, t_dbllist *lst_arg, t_dbllist *lst_str,
int *i)
{
int percent;
percent = 1;
while (format[*i + 1] == '%')
{
percent++;
*i = *i + 1;
}
if (percent > 1)
{
display_percent((percent / 2), lst_str);
if (percent % 2 == 0)
return (0);
}
*i = *i + 1;
if (format[*i] != '\0')
{
if (split_arg(format, lst_arg, lst_str, i) == -1)
{
recover_arg(format, lst_arg, lst_str, i);
return (1);
}
}
return (1);
}
int main(int ac, char **av)
{
t_opt opt;
int index;
t_list *lst_f;
t_list *lst_d;
t_sort pt_arg;
lst_f = NULL;
lst_d = NULL;
index = check_opt(ac, av, &opt);
if (index == ac)
ft_ls(".", opt);
else
{
split_arg(&lst_f, &lst_d, av + index, ac - index);
pt_arg = select_sort(opt);
sort(&lst_f, pt_arg, opt);
sort(&lst_d, pt_arg, opt);
print(lst_f, opt);
if (lst_f && lst_d)
ft_putchar('\n');
opt.lf_dir = 1;
deal_dir(lst_d, opt, ac, index);
free_arg(&lst_f, &lst_d);
}
return (0);
}
static gboolean
add_field (const gchar *option_name,
const gchar *value,
gpointer data, GError **err)
{
YadField *fld;
gchar **fstr = split_arg (value);
fld = g_new0 (YadField, 1);
fld->name = g_strdup (fstr[0]);
if (fstr[1])
{
if (g_ascii_strcasecmp (fstr[1], "H") == 0)
fld->type = YAD_FIELD_HIDDEN;
else if (g_ascii_strcasecmp (fstr[1], "RO") == 0)
fld->type = YAD_FIELD_READ_ONLY;
else if (g_ascii_strcasecmp (fstr[1], "NUM") == 0)
fld->type = YAD_FIELD_NUM;
else if (g_ascii_strcasecmp (fstr[1], "CHK") == 0)
fld->type = YAD_FIELD_CHECK;
else if (g_ascii_strcasecmp (fstr[1], "CB") == 0)
fld->type = YAD_FIELD_COMBO;
else if (g_ascii_strcasecmp (fstr[1], "CBE") == 0)
fld->type = YAD_FIELD_COMBO_ENTRY;
else if (g_ascii_strcasecmp (fstr[1], "FL") == 0)
fld->type = YAD_FIELD_FILE;
else if (g_ascii_strcasecmp (fstr[1], "DIR") == 0)
fld->type = YAD_FIELD_DIR;
else if (g_ascii_strcasecmp (fstr[1], "FN") == 0)
fld->type = YAD_FIELD_FONT;
else if (g_ascii_strcasecmp (fstr[1], "CLR") == 0)
fld->type = YAD_FIELD_COLOR;
else if (g_ascii_strcasecmp (fstr[1], "MFL") == 0)
fld->type = YAD_FIELD_MFILE;
else if (g_ascii_strcasecmp (fstr[1], "DT") == 0)
fld->type = YAD_FIELD_DATE;
else if (g_ascii_strcasecmp (fstr[1], "BTN") == 0)
fld->type = YAD_FIELD_BUTTON;
else if (g_ascii_strcasecmp (fstr[1], "LBL") == 0)
fld->type = YAD_FIELD_LABEL;
else
fld->type = YAD_FIELD_SIMPLE;
}
else
fld->type = YAD_FIELD_SIMPLE;
options.form_data.fields =
g_slist_append (options.form_data.fields, fld);
g_strfreev (fstr);
return TRUE;
}
bool parse_args(std::vector<std::string>& args,
stan::callbacks::writer& info,
stan::callbacks::writer& err,
bool& help_flag) {
if (args.size() == 0)
return true;
std::string name;
std::string value;
split_arg(args.back(), name, value);
if (_name == "help") {
print_help(info, 0, false);
help_flag |= true;
args.clear();
return false;
} else if (_name == "help-all") {
print_help(info, 0, true);
help_flag |= true;
args.clear();
return false;
} else if (_name == name) {
args.pop_back();
bool good_arg = false;
bool valid_arg = true;
for (size_t i = 0; i < _values.size(); ++i) {
if ( _values.at(i)->name() != value) continue;
_cursor = i;
valid_arg
&= _values.at(_cursor)->parse_args(args, info, err, help_flag);
good_arg = true;
break;
}
if (!good_arg) {
std::stringstream message;
message << value << " is not a valid value for \""
<< _name << "\"";
err(message.str());
err(std::string(indent_width, ' ')
+ "Valid values:"
+ print_valid());
args.clear();
}
return valid_arg && good_arg;
}
return true;
}
bool parse_args(std::vector<std::string>& args, std::ostream* out,
std::ostream* err, bool& help_flag) {
if (args.size() == 0)
return true;
std::string name;
std::string value;
split_arg(args.back(), name, value);
if (_name == "help") {
print_help(out, 0, false);
help_flag |= true;
args.clear();
return false;
} else if (_name == "help-all") {
print_help(out, 0, true);
help_flag |= true;
args.clear();
return false;
} else if (_name == name) {
args.pop_back();
bool good_arg = false;
bool valid_arg = true;
for (size_t i = 0; i < _values.size(); ++i) {
if ( _values.at(i)->name() != value) continue;
_cursor = i;
valid_arg
&= _values.at(_cursor)->parse_args(args, out, err, help_flag);
good_arg = true;
break;
}
if (!good_arg) {
if (err) {
*err << value << " is not a valid value for \""
<< _name << "\"" << std::endl;
*err << std::string(indent_width, ' ')
<< "Valid values:" << print_valid() << std::endl;
}
args.clear();
}
return valid_arg && good_arg;
}
return true;
}
static gboolean
add_column (const gchar *option_name,
const gchar *value,
gpointer data, GError **err)
{
YadColumn *col;
gchar **cstr = split_arg (value);
col = g_new0 (YadColumn, 1);
col->name = g_strdup (cstr[0]);
if (g_ascii_strcasecmp (cstr[0], "@fore@") == 0)
col->type = YAD_COLUMN_ATTR_FORE;
else if (g_ascii_strcasecmp (cstr[0], "@back@") == 0)
col->type = YAD_COLUMN_ATTR_BACK;
else if (g_ascii_strcasecmp (cstr[0], "@font@") == 0)
col->type = YAD_COLUMN_ATTR_FONT;
else
{
if (cstr[1])
{
if (g_ascii_strcasecmp (cstr[1], "NUM") == 0)
col->type = YAD_COLUMN_NUM ;
else if (g_ascii_strcasecmp (cstr[1], "CHK") == 0)
col->type = YAD_COLUMN_CHECK;
else if (g_ascii_strcasecmp (cstr[1], "FLT") == 0)
col->type = YAD_COLUMN_FLOAT;
else if (g_ascii_strcasecmp (cstr[1], "IMG") == 0)
col->type = YAD_COLUMN_IMAGE;
else if (g_ascii_strcasecmp (cstr[1], "TIP") == 0)
col->type = YAD_COLUMN_TOOLTIP;
else
col->type = YAD_COLUMN_TEXT;
}
else
col->type = YAD_COLUMN_TEXT;
}
options.list_data.columns =
g_slist_append (options.list_data.columns, col);
g_strfreev (cstr);
return TRUE;
}
static gboolean
add_button (const gchar *option_name,
const gchar *value,
gpointer data, GError **err)
{
YadButton *btn;
gchar **bstr = split_arg (value);
btn = g_new0 (YadButton, 1);
btn->name = g_strdup (bstr[0]);
if (bstr[1])
btn->response = g_ascii_strtoll (bstr[1], NULL, 10);
else
btn->response = g_slist_length (options.data.buttons);
options.data.buttons = g_slist_append (options.data.buttons, btn);
g_strfreev (bstr);
return TRUE;
}
bool parse_args(std::vector<std::string>& args,
interface_callbacks::writer::base_writer& info,
interface_callbacks::writer::base_writer& err,
bool& help_flag) {
if (args.size() == 0)
return true;
if ( (args.back() == "help") || (args.back() == "help-all") ) {
print_help(info, 0);
help_flag |= true;
args.clear();
return true;
}
std::string name;
std::string value;
split_arg(args.back(), name, value);
if (_name == name) {
args.pop_back();
T proposed_value = boost::lexical_cast<T>(value);
if (!set_value(proposed_value)) {
std::stringstream message;
message << proposed_value
<< " is not a valid value for "
<< "\"" << _name << "\"";
err(message.str());
err(std::string(indent_width, ' ')
+ "Valid values:" + print_valid());
args.clear();
return false;
}
}
return true;
}
bool parse_args(std::vector<std::string>& args, std::ostream* out,
std::ostream* err, bool& help_flag) {
if (args.size() == 0)
return true;
if ( (args.back() == "help") || (args.back() == "help-all") ) {
print_help(out, 0);
help_flag |= true;
args.clear();
return true;
}
std::string name;
std::string value;
split_arg(args.back(), name, value);
if (_name == name) {
args.pop_back();
T proposed_value = boost::lexical_cast<T>(value);
if (!set_value(proposed_value)) {
if (err) {
*err << proposed_value << " is not a valid value for "
<< "\"" << _name << "\"" << std::endl;
*err << std::string(indent_width, ' ')
<< "Valid values:" << print_valid() << std::endl;
}
args.clear();
return false;
}
}
return true;
}
int main(int argc, char *argv[])
{
const char *cmdd = " 1 2 3 asd 34 23 !@ 1 1 ";
std::vector<std::string> vec_cmdd;
split_arg(vec_cmdd, cmdd, " ");
for(auto &s: vec_cmdd) {
std::cout << s << std::endl;
}
PerfCollector pppa(getpid(), 1);
for(auto i = 0; i < 3; ++i) {
pppa.collect();
for(auto &pd: pppa.m_sample_data) {
printf("PerfCollector test cpu:%f RES:%lu\n", std::get<0>(pd), std::get<1>(pd));
}
printf("------\n");
sleep(1);
}
Procc pp(PROCC_STDOUT_PIPE, PROCC_STDERR_PIPE);
std::vector<const char *> vec_cmd;
vec_cmd.push_back("/sbin/ifconfig");
vec_cmd.push_back("/sbin/ifconfig -a");
vec_cmd.push_back("/bin/ls -a -l");
vec_cmd.push_back("svn indo");
vec_cmd.push_back("/bin/notexists -a -l");
vec_cmd.push_back("/usr/bin/python -u sleep.py");
vec_cmd.push_back("/usr/bin/python -u busy.py");
size_t collect_size = 0;
for (auto it = vec_cmd.begin(); it != vec_cmd.end(); ++it) {
pp.run(*it, false, "./");
char *stdoutbuf = NULL;
char *stderrbuf = NULL;
int ret = pp.communicate(&stdoutbuf, &stderrbuf, 5, collect_size++);
if ( ret == 9) {
printf("call %s timeout\n", *it);
}
if ( ret < 0) {
printf("call %s error\n", *it);
}
printf("stdout %s\n", stdoutbuf);
printf("stderr %s\n", stderrbuf);
std::shared_ptr<PerfCollector> pr = pp.getCollector();
for(auto &pd: pr->m_sample_data) {
printf("PerfCollector test cpu:%f RES:%lu\n", std::get<0>(pd), std::get<1>(pd));
}
printf("------\n");
}
std::vector<const char *> vec_cmd_shell;
vec_cmd_shell.push_back("cd Util; /sbin/ifconfig");
vec_cmd_shell.push_back("cd ~/ && /sbin/ifconfig -a");
vec_cmd_shell.push_back("ls");
vec_cmd_shell.push_back("svn indo");
vec_cmd_shell.push_back("ls -a -l");
vec_cmd_shell.push_back("unkonw -a -l");
vec_cmd_shell.push_back("python ./largeout.py");
collect_size = 10;
for (auto it = vec_cmd_shell.begin(); it != vec_cmd_shell.end(); ++it) {
pp.run(*it, true, "");
char *stdoutbuf = NULL;
char *stderrbuf = NULL;
int ret = pp.communicate(&stdoutbuf, &stderrbuf, 2, collect_size--);
if ( ret == 9) {
printf("call %s timeout\n", *it);
}
if ( ret < 0) {
printf("call %s error\n", *it);
}
printf("stdout %s\n", stdoutbuf);
printf("stderr %s\n", stderrbuf);
std::shared_ptr<PerfCollector> pr = pp.getCollector();
for(auto &pd: pr->m_sample_data) {
printf("PerfCollector test cpu:%f RES:%lu\n", std::get<0>(pd), std::get<1>(pd));
}
printf("------\n");
}
Procc pp_none(PROCC_STDOUT_NONE, PROCC_STDERR_NONE);
std::vector<const char *> vec_cmdn;
vec_cmdn.push_back("/sbin/ifconfig");
vec_cmdn.push_back("/sbin/ifconfig -a");
vec_cmdn.push_back("/bin/ls -a -l");
vec_cmdn.push_back("svn indo");
vec_cmdn.push_back("/bin/notexists -a -l");
for (auto it = vec_cmdn.begin(); it != vec_cmdn.end(); ++it) {
pp_none.run(*it, false, "./include");
int ret = 0;
if ( (ret = pp_none.communicate(NULL, NULL)) != 0) {
printf("call %s error \n", *it);
}
}
for (auto it = vec_cmdn.begin(); it != vec_cmdn.end(); ++it) {
pp_none.run(*it, true, "./include");
int ret = 0;
if ( (ret = pp_none.communicate(NULL, NULL)) != 0) {
printf("call %s error \n", *it);
}
}
int out_fd = open("./outout", O_WRONLY|O_CREAT, 0644);
Procc pp_fd(out_fd, out_fd);
for (auto it = vec_cmdn.begin(); it != vec_cmdn.end(); ++it) {
pp_fd.run(*it, false, "./include");
int ret = 0;
if ( (ret = pp_fd.communicate(NULL, NULL)) != 0) {
printf("call %s error \n", *it);
}
}
int err_fd = open("./erer", O_WRONLY|O_CREAT, 0644);
Procc pp_errfd(PROCC_STDOUT_NONE, err_fd);
for (auto it = vec_cmdn.begin(); it != vec_cmdn.end(); ++it) {
pp_errfd.run(*it, false, "./include");
int ret = 0;
if ( (ret = pp_errfd.communicate(NULL, NULL)) != 0) {
printf("call %s error \n", *it);
}
}
pp.run("sleep 5", false, "");
while(pp.is_alive(pp.pid())) {
printf("%d alive\n", pp.pid());
sleep(1);
}
pp.communicate(NULL, NULL);
time_t begin_t = time(NULL);
pp.run("sleep 1", false, "");
pp.communicate(NULL, NULL, 5);
assert(time(NULL) - begin_t == 1);
assert(Procc::system("echo \"hello\"") == 0);
assert(Procc::system("exit 15") == 3840);
return 0;
}
FTPCMD parse_command(const char * read_buf, char * arg_buf){
if (read_buf == nullptr || strlen(read_buf) < 3){
myftp_log(MYFTP_LOG_ERROR, "Error in parsing command buffer.\n");
return FTPCMD::ERROR;
}
// Find the first space and convert command character to UPPERCASE
const char * c = read_buf;
for (; *c != '\0' && *c != ' ' && *c != '\r' && *c != '\n'; c++);
int cmd_len = c - read_buf;
if (cmd_len < 3 || cmd_len > 4){
myftp_log(MYFTP_LOG_WARNING, "Invalid command.\n");
return FTPCMD::UNKNOWN;
}
split_arg(c, arg_buf);
if (cmd_len == 3){
if (strncasecmp(read_buf, "PWD", 3) == 0){
return FTPCMD::PWD;
}
if (strncasecmp(read_buf, "CWD", 3) == 0){
return FTPCMD::CWD;
}
}
if (cmd_len == 4){
if (strncasecmp(read_buf, "USER", 4) == 0){
return FTPCMD::USER;
}
if (strncasecmp(read_buf, "PASS", 4) == 0){
return FTPCMD::PASS;
}
if (strncasecmp(read_buf, "CDUP", 4) == 0){
return FTPCMD::CDUP;
}
if (strncasecmp(read_buf, "QUIT", 4) == 0){
return FTPCMD::QUIT;
}
if (strncasecmp(read_buf, "PORT", 4) == 0){
return FTPCMD::PORT;
}
if (strncasecmp(read_buf, "PASV", 4) == 0){
// FIXME: Needed by Safari/Chrome
return FTPCMD::PASV;
}
if (strncasecmp(read_buf, "TYPE", 4) == 0){
return FTPCMD::TYPE;
}
if (strncasecmp(read_buf, "MODE", 4) == 0){
return FTPCMD::MODE;
}
if (strncasecmp(read_buf, "STRU", 4) == 0){
return FTPCMD::STRU;
}
if (strncasecmp(read_buf, "RETR", 4) == 0){
return FTPCMD::RETR;
}
if (strncasecmp(read_buf, "STOR", 4) == 0){
return FTPCMD::STOR;
}
if (strncasecmp(read_buf, "SYST", 4) == 0){
return FTPCMD::SYST;
}
if (strncasecmp(read_buf, "NOOP", 4) == 0){
return FTPCMD::NOOP;
}
if (strncasecmp(read_buf, "SIZE", 4) == 0){
return FTPCMD::SIZE;
}
if (strncasecmp(read_buf, "LIST", 4) == 0){
return FTPCMD::LIST;
}
if (strncasecmp(read_buf, "NLST", 4) == 0){
return FTPCMD::NLST;
}
if (strncasecmp(read_buf, "HELP", 4) == 0){
return FTPCMD::HELP;
}
}
return FTPCMD::UNKNOWN;
}
