int main(int argc, char **argv)
{
fix_lbuffer(0);
cmd_parser(argc, argv);
return 0;
}
/*
* Parse input arguments
*/
dd::CmdParser parse_input(int argc, char** argv){
std::vector<std::string> new_args;
if (argc < 2) {
new_args.push_back(std::string(argv[0]) + " " + "gibbs");
new_args.push_back("-h");
} else {
new_args.push_back(std::string(argv[0]) + " " + std::string(argv[1]));
for(int i=2;i<argc;i++){
new_args.push_back(std::string(argv[i]));
}
}
char ** new_argv = new char*[new_args.size()];
for(size_t i=0;i<new_args.size();i++){
new_argv[i] = new char[new_args[i].length() + 1];
std::copy(new_args[i].begin(), new_args[i].end(), new_argv[i]);
new_argv[i][new_args[i].length()] = '\0';
}
std::string final_app_name;
if (argc >= 2)
final_app_name = argv[1];
else
final_app_name = "gibbs";
dd::CmdParser cmd_parser(final_app_name);
cmd_parser.parse(new_args.size(), new_argv);
return cmd_parser;
}
int
main (int argc, char **argv)
{
set_program_name (argv[0]);
cmd_parser (argc, argv);
return 0;
}
int get_new_command(char *mes)
{
term_def_t *term;
if (debug_flag) printf("get_new_command:\n");
term = get_next_term();
if ((term != NULL) && (term->term_type == CMD_TERM))
unget_term();
else
cmd_parser(mes, 0, 1);
return(run_command());
}
int get_string_param(char *mes, char *val, int len)
{
term_def_t *term;
int i;
term = get_next_term();
if (term == NULL) {
cmd_parser(mes, 1, 0, &i);
term = get_next_term();
};
if (term == NULL) {
return(HPI_SHELL_CMD_ERROR);
};
memset(val, 0, len);
strncpy(val, term->term, len);
for (i = 0; i < len; i++)
if (val[i] == '\n') val[i] = 0;
return(0);
}
int get_new_command(char *mes)
{
int redir = 0, i, res;
char *name;
term_def_t *term;
if (debug_flag) printf("get_new_command:\n");
term = get_next_term();
if ((term == NULL) || (term->term_type != CMD_TERM))
cmd_parser(mes, 0, 1, &redir);
else {
unget_term();
redir = check_cmd_for_redirect();
};
if (redir != 0) {
for (i = 0; i < term_count; i++) {
if (terms[i].term_type == CMD_REDIR_TERM)
break;
};
if (i >= term_count - 1) {
printf("Syntax error:\n%s\n", cmd_line);
go_to_dialog();
return(3);
};
if (terms[i + 1].term_type != ITEM_TERM) {
printf("Syntax error:\n%s\n", cmd_line);
go_to_dialog();
return(3);
};
name = terms[i + 1].term;
res = set_redirection(name, redir);
if (res != 0) {
printf("Command failed:\n%s\n", cmd_line);
go_to_dialog();
return(3);
};
res = run_command();
remove_reditection();
return(res);
};
res = run_command();
return(res);
}
int main(int argc, char **argv)
{
out_bgorlit();
test_hex2pro();
test_pro2hex();
cmd_parser(argc,argv,&glb_cfg);
if(glb_cfg.daemon)
run_as_daemon();
/*
* Make sure only one copy of the daemon is running.
*/
if (already_running()) {
debug(LOG_ERR, "daemon already running\n");
exit(1);
}
pthread_mutex_init(&(glb_cfg.lock), NULL);
pthread_cond_init(&(glb_cfg.cond), NULL);
// init_log(argv[0]);
init_signals();
alarm(WT_SDCARD_PRIOD);
pthread_t sorpid;
pthread_create(&sorpid,NULL,handle_uart,NULL);
pthread_t cmdpid;
pthread_create(&cmdpid,NULL,handle_socket_machine,NULL);
pthread_join(sorpid,NULL);
pthread_join(cmdpid,NULL);
debug(LOG_NOTICE,"<==========Process exit!\n");
// close_log();
return 0;
}
int get_hex_int_param(char *mes, int *val)
{
char *str, buf[32];
term_def_t *term;
term = get_next_term();
if (term == NULL) {
cmd_parser(mes, 1, 0);
term = get_next_term();
};
if (term == NULL) {
go_to_dialog();
return(HPI_SHELL_CMD_ERROR);
};
str = term->term;
if (strncmp(str, "0x", 2) == 0)
snprintf(buf, 31, "%s", str);
else
snprintf(buf, 31, "0x%s", str);
*val = strtol(buf, (char **)NULL, 16);
return(1);
}
int get_int_param(char *mes, int *val)
{
int res, redir;
char *str;
term_def_t *term;
term = get_next_term();
if (term == NULL) {
cmd_parser(mes, 1, 0, &redir);
term = get_next_term();
};
if (term == NULL) {
go_to_dialog();
return(HPI_SHELL_CMD_ERROR);
};
str = term->term;
if (isdigit(*str) || *str == '-' ) {
res = sscanf(str, "%d", val);
return(res);
};
return(0);
}
int get_hex_string_param(char *mes, char *res, int max_length)
{
char *str, buf[32];
int redir, i, val;
term_def_t *term;
for (i = 0; i < max_length; i++) {
term = get_next_term();
if (term == NULL) {
cmd_parser(mes, 1, 0, &redir);
term = get_next_term();
};
if (term == NULL) return(i);
str = term->term;
if (strncmp(str, "0x", 2) == 0)
snprintf(buf, 31, "%s", str);
else
snprintf(buf, 31, "0x%s", str);
val = strtol(buf, (char **)NULL, 16);
res[i] = val;
};
return(i);
}
/* end by xin.yao: 2011-11-14 */
if(-1 == getOrigDomainConf(fp)) {
addInfoLog(2, "getOriginDomainConf error[there are errors in conf file]");
}
fclose(fp);
}
fp = fopen(config.origDomainIPHistoryFileName, "r");
if (NULL == fp)
addInfoLog(2, "can not open origin_domain_ip");
else
{
g_pstOrigDomainHistory_init();
if (-1 == getOrigDomainHistory(fp))
addInfoLog(2, "getOriginDomainHistory error[here are errors in conf file]");
fclose(fp);
}
return 0;
}
#ifndef FRAMEWORK
int main(int argc, char **argv)
#else /* not FRAMEWORK */
int mod_main(int argc, char **argv)
#endif /* not FRAMEWORK */
{
/* parse command line param */
cmd_parser(argc, argv);
/* open log file first,
* because of we need write log in the following handled
*/
open_log();
/* initialize the config variable,
* using default configuration or value
*/
load_default_conf();
detectGlobalInit();
check_conf_file_valid();
/* fork for detect, parent process will wait for child process */
#ifndef FRAMEWORK
pid_t pid = fork();
if (pid < 0) {
perror("fork()");
kill(0, SIGTERM);
exit(1);
}
if (!pid)
#else /* not FRAMEWORK */
{
/* 复制自下部分代码，关于fork后主进程的工作 */
struct sigaction sa;
struct itimerval itv;
sa.sa_handler = alarmTimeoutHandler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGALRM, &sa, NULL);
itv.it_interval.tv_sec = 1;
itv.it_interval.tv_usec = 0;
itv.it_value.tv_sec = custom_cfg.detect_timeout;//g_detect_timeout;
//printf("detect_timeout: %ld\n", custom_cfg.detect_timeout);
itv.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &itv, NULL);
}
#endif /* not FRAMEWORK */
{
int rtn = 0;
#ifndef FRAMEWORK
int sleep_time;
/* set current process resource limit
* Limits on resources crontab, and the process is the child process crontab,
* inherited this limit, so in order to the stability of the program to modify resource constraints
*/
if (set_process_rlimit() < 0) {
return -1;
}
/* delayed time: [10, 30)s,
* in order to try to spread more FC and upper detection
*/
if(!delay_start) {
srand((unsigned)time(NULL)); //??ʼ????????
sleep_time = rand() % 20 + 10;
fprintf(stdout, "sleep %d\n", sleep_time);
sleep(sleep_time);
}
/* core task */
detect_epoll_init();
fd_table_init();
rtn = process_core_task();
if (rtn < 0) {
rtn = -1;
}
fd_table_dest();
eventFreeMemory();
clean_detect_mem();
close_log();
return rtn;
#else /* not FRAMEWORK */
if (set_process_rlimit() < 0) {
module_enable = 0;
return 1;
}
rtn = process_core_task_before();
if (rtn < 0)
{
module_enable = 0;
return 1;
}
return 0;
#endif /* not FRAMEWORK */
}
#ifndef FRAMEWORK
else
{
int main(int argc, char **argv) {
wxInitializer wx_initializer;
if ( !wx_initializer ) {
fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
return -1;
}
wxCmdLineParser cmd_parser(cmdLineDesc, argc, argv);
long run_count = 10;
wxString grid_path, dict_path;
bool is_rand = false;
bool is_verbose = false;
switch ( cmd_parser.Parse() ) {
case -1:
return 0;
case 0:
cmd_parser.Found(wxT("count"), &run_count);
is_rand = cmd_parser.Found(wxT("rand"));
is_verbose = cmd_parser.Found(wxT("verbose"));
grid_path = cmd_parser.GetParam(0);
dict_path = cmd_parser.GetParam(1);
wxLogDebug(wxT("grid_path = ") + grid_path + wxT("\n"));
wxLogDebug(wxT("dict_path = ") + dict_path + wxT("\n"));
wxLogDebug(wxT("run_count = %d\n"), run_count);
break;
default:
return 0;
}
std::vector< wxLongLong > durs(run_count); // durations
std::vector< wxString > words_out;
DictType dict;
GridType grid;
AllWordsType all_words;
CharsTransType trans_type;
readDict(dict_path, dict);
generateAllWords(dict, all_words, trans_type);
readGrid(grid_path, grid);
if ( is_rand )
srand(time(NULL));
for (long i = 0; i < run_count; ++i) {
if ( !is_rand )
srand(42);
words_out.clear();
durs.at(i) = wxGetLocalTimeMillis();
generateCross(grid,all_words,trans_type,words_out);
if ( words_out.size() == 0 )
wxPrintf(wxT("Error in creating #%-2i!\n"),i+1);
durs.at(i) = wxGetLocalTimeMillis() - durs.at(i);
if ( is_verbose )
wxPrintf(wxT("Time to generate #%-2i is ")
+ durs.at(i).ToString() + wxT(" ms\n"), i+1);
}
wxLongLong tm_total = std::accumulate(durs.begin(),durs.end(), wxLongLong(0,0));
wxLongLong tm_mean = (tm_total + run_count/2) / run_count;
wxPrintf(wxT("Total time = ") + tm_total.ToString() + wxT(" ms.\nMean time = ")
+ tm_mean.ToString() + wxT(" ms.\n"));
return 0;
}
int
main (int argc, char **argv)
{
int err, ret;
int sd, i;
gnutls_session_t state;
char buffer[MAX_BUF + 1];
char portname[6];
struct addrinfo hints, *res, *ptr;
cmd_parser(argc, argv);
#ifndef _WIN32
signal (SIGPIPE, SIG_IGN);
#endif
sockets_init ();
if (gnutls_global_init () < 0)
{
fprintf (stderr, "global state initialization error\n");
exit (1);
}
gnutls_global_set_log_function (tls_log_func);
gnutls_global_set_log_level (debug);
printf ("Resolving '%s'...\n", hostname);
/* get server name */
memset (&hints, 0, sizeof (hints));
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = 0;
snprintf (portname, sizeof (portname), "%d", port);
if ((err = getaddrinfo (hostname, portname, &hints, &res)) != 0)
{
fprintf (stderr, "Cannot resolve %s: %s\n", hostname,
gai_strerror (err));
exit (1);
}
/* X509 stuff */
if (gnutls_certificate_allocate_credentials (&xcred) < 0)
{ /* space for 2 certificates */
fprintf (stderr, "memory error\n");
exit (1);
}
/* SRP stuff */
#ifdef ENABLE_SRP
if (gnutls_srp_allocate_client_credentials (&srp_cred) < 0)
{
fprintf (stderr, "memory error\n");
exit (1);
}
#endif
#ifdef ENABLE_ANON
/* ANON stuff */
if (gnutls_anon_allocate_client_credentials (&anon_cred) < 0)
{
fprintf (stderr, "memory error\n");
exit (1);
}
#endif
i = 0;
do
{
if (tls_tests[i].test_name == NULL)
break; /* finished */
/* if neither of SSL3 and TLSv1 are supported, exit
*/
if (i > 6 && tls1_1_ok == 0 && tls1_ok == 0 && ssl3_ok == 0)
{
fprintf (stderr,
"\nServer does not support any of SSL 3.0, TLS 1.0 and TLS 1.1\n");
break;
}
sd = -1;
for (ptr = res; ptr != NULL; ptr = ptr->ai_next)
{
sd = socket (ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
if (sd == -1)
{
continue;
}
getnameinfo (ptr->ai_addr, ptr->ai_addrlen, buffer, MAX_BUF,
NULL, 0, NI_NUMERICHOST);
if (tt == 0)
{
printf ("Connecting to '%s:%d'...\n", buffer, port);
tt = 1;
}
if ((err = connect (sd, ptr->ai_addr, ptr->ai_addrlen)) != 0)
{
close (sd);
sd = -1;
continue;
}
else
break;
}
ERR (err, "connect");
gnutls_init (&state, GNUTLS_CLIENT|GNUTLS_NO_EXTENSIONS);
gnutls_transport_set_ptr (state, (gnutls_transport_ptr_t)
gl_fd_to_handle (sd));
if (hostname && !isdigit(hostname[0]) && strchr(hostname, ':') == 0)
gnutls_server_name_set (state, GNUTLS_NAME_DNS, hostname,
strlen (hostname));
do
{
printf ("Checking %s...", tls_tests[i].test_name);
fflush(stdout);
ret = tls_tests[i].func (state);
if (ret == TEST_SUCCEED)
printf (" %s\n", tls_tests[i].suc_str);
else if (ret == TEST_FAILED)
printf (" %s\n", tls_tests[i].fail_str);
else if (ret == TEST_UNSURE)
printf (" %s\n", tls_tests[i].unsure_str);
else if (ret == TEST_IGNORE)
{
printf (" N/A\n");
i++;
}
}
while (ret == TEST_IGNORE && tls_tests[i].test_name != NULL);
gnutls_deinit (state);
shutdown (sd, SHUT_RDWR); /* no more receptions */
close (sd);
i++;
}
while (1);
freeaddrinfo (res);
#ifdef ENABLE_SRP
gnutls_srp_free_client_credentials (srp_cred);
#endif
gnutls_certificate_free_credentials (xcred);
#ifdef ENABLE_ANON
gnutls_anon_free_client_credentials (anon_cred);
#endif
gnutls_global_deinit ();
return 0;
}
void watch_socket()
{
int sockfd, new_fd; /* listen on sock_fd, new connection on new_fd*/
int numbytes;
char buf[MAXDATASIZE];
int yes = 1;
struct sockaddr_in my_addr; /* my address information */
struct sockaddr_in their_addr; /* connector's address information */
int sin_size;
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
{
perror("Server-setsockopt() error lol!");
exit(1);
}
my_addr.sin_family = AF_INET; /* host byte order */
my_addr.sin_port = htons(MYPORT); /* short, network byte order */
my_addr.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */
bzero(&(my_addr.sin_zero), sizeof(my_addr.sin_zero)); /* zero the rest of the struct */
if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct
sockaddr))== -1) {
perror("bind");
exit(1);
}
if (listen(sockfd, BACKLOG) == -1) {
perror("listen");
exit(1);
}
while(1) { /* main accept() loop */
//if( keep_running == 0 )
//pthread_exit(0);
sin_size = sizeof(struct sockaddr_in);
if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, \
&sin_size)) == -1) {
perror("accept");
continue;
}
//printf("server: got connection from %s\n", \
//inet_ntoa(their_addr.sin_addr));
memset(buf, 0, sizeof(buf));
if ((numbytes=recv(new_fd, buf, MAXDATASIZE, 0)) == -1) {
perror("recv");
continue;
///exit(1);
}
//else
//printf("recv command is %s \n",buf);
cmd_parser(buf);
/*
memset(buf, 0, sizeof(buf));
strcpy(buf, "rev cmd");
if (send(new_fd, buf, strlen(buf), 0) == -1) {
perror("send");
exit(1);
}
*/
close(new_fd);
//while(waitpid(-1,NULL,WNOHANG) > 0);
}
}
void watch_socket()
{
fd_set read_fds;
fd_set master;
int fdmax;
struct timeval timeout;
FD_ZERO(&read_fds);
FD_ZERO(&master);
int sockfd, new_fd; /* listen on sock_fd, new connection on new_fd*/
int numbytes;
char buf[MAXDATASIZE];
int yes = 1;
int ret;
struct sockaddr_in my_addr; /* my address information */
struct sockaddr_in their_addr; /* connector's address information */
int sin_size;
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
{
perror("Server-setsockopt() error lol!");
exit(1);
}
my_addr.sin_family = AF_INET; /* host byte order */
my_addr.sin_port = htons(MYPORT); /* short, network byte order */
my_addr.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */
bzero(&(my_addr.sin_zero), sizeof(my_addr.sin_zero)); /* zero the rest of the struct */
if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct
sockaddr))== -1) {
perror("bind");
exit(1);
}
if (listen(sockfd, BACKLOG) == -1) {
perror("listen");
exit(1);
}
FD_SET(sockfd,&master);
fdmax = sockfd;
sin_size = sizeof(struct sockaddr_in);
while(!exit_loop) { /* main accept() loop */
timeout.tv_sec = 0;
timeout.tv_usec = 100;
read_fds = master;
ret = select(fdmax+1,&read_fds,NULL,NULL,&timeout);
switch(ret)
{
case 0:
continue;
break;
case -1:
perror("select");
continue;
break;
default:
if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, \
&sin_size)) == -1) {
perror("accept");
continue;
}
memset(buf, 0, sizeof(buf));
if ((numbytes=recv(new_fd, buf, MAXDATASIZE, 0)) == -1) {
perror("recv");
continue;
}
cmd_parser(buf);
}
close(new_fd);
}
}
int main(int argc, char **argv)
{
int ret;
int i;
gnutls_session_t state;
char portname[6];
socket_st hd;
char app_proto[32] = "";
cmd_parser(argc, argv);
#ifndef _WIN32
signal(SIGPIPE, SIG_IGN);
#endif
sockets_init();
if (gnutls_global_init() < 0) {
fprintf(stderr, "global state initialization error\n");
exit(1);
}
gnutls_global_set_log_function(tls_log_func);
gnutls_global_set_log_level(debug);
/* get server name */
snprintf(portname, sizeof(portname), "%d", port);
/* X509 stuff */
if (gnutls_certificate_allocate_credentials(&xcred) < 0) { /* space for 2 certificates */
fprintf(stderr, "memory error\n");
exit(1);
}
/* SRP stuff */
#ifdef ENABLE_SRP
if (gnutls_srp_allocate_client_credentials(&srp_cred) < 0) {
fprintf(stderr, "memory error\n");
exit(1);
}
#endif
#ifdef ENABLE_ANON
/* ANON stuff */
if (gnutls_anon_allocate_client_credentials(&anon_cred) < 0) {
fprintf(stderr, "memory error\n");
exit(1);
}
#endif
if (HAVE_OPT(STARTTLS_PROTO)) {
snprintf(app_proto, sizeof(app_proto), "%s", OPT_ARG(STARTTLS_PROTO));
}
if (app_proto[0] == 0) {
snprintf(app_proto, sizeof(app_proto), "%s", port_to_service(portname, "tcp"));
}
sockets_init();
i = 0;
printf("GnuTLS debug client %s\n", gnutls_check_version(NULL));
printf("Checking %s:%s\n", hostname, portname);
do {
if (tls_tests[i].test_name == NULL)
break; /* finished */
/* if neither of SSL3 and TLSv1 are supported, exit
*/
if (i > 6 && tls1_2_ok == 0 && tls1_1_ok == 0 && tls1_ok == 0
&& ssl3_ok == 0) {
fprintf(stderr,
"\nServer does not support any of SSL 3.0, TLS 1.0 and TLS 1.1 and TLS 1.2\n");
break;
}
socket_open(&hd, hostname, portname, 0, NULL);
hd.verbose = verbose;
socket_starttls(&hd, app_proto);
gnutls_init(&state, GNUTLS_CLIENT | GNUTLS_NO_EXTENSIONS);
gnutls_transport_set_ptr(state, (gnutls_transport_ptr_t)
gl_fd_to_handle(hd.fd));
set_read_funcs(state);
if (hostname && is_ip(hostname) == 0)
gnutls_server_name_set(state, GNUTLS_NAME_DNS,
hostname, strlen(hostname));
do {
if (strcmp(app_proto, "https") != 0 && tls_tests[i].https_only != 0) {
i++;
break;
}
ret = tls_tests[i].func(state);
if (ret != TEST_IGNORE) {
printf("%58s...", tls_tests[i].test_name);
fflush(stdout);
}
if (ret == TEST_SUCCEED) {
if (tls_tests[i].suc_str == NULL)
printf(" %s\n", ext_text);
else
printf(" %s\n", tls_tests[i].suc_str);
} else if (ret == TEST_FAILED)
printf(" %s\n", tls_tests[i].fail_str);
else if (ret == TEST_UNSURE)
printf(" %s\n", tls_tests[i].unsure_str);
else if (ret == TEST_IGNORE) {
if (tls_tests[i+1].test_name)
i++;
else
break;
}
}
while (ret == TEST_IGNORE
&& tls_tests[i].test_name != NULL);
gnutls_deinit(state);
socket_bye(&hd);
i++;
}
while (1);
#ifdef ENABLE_SRP
gnutls_srp_free_client_credentials(srp_cred);
#endif
gnutls_certificate_free_credentials(xcred);
#ifdef ENABLE_ANON
gnutls_anon_free_client_credentials(anon_cred);
#endif
gnutls_global_deinit();
return 0;
}
int main(int argc, char **argv)
{
cmd_parser(argc, argv);
return 0;
}
void Client_cmd_options::parse(int argc, char *argv[])
{
bool show_version = false;
Glib::OptionContext cmd_parser(_("torrent_path"));
if(is_gui_mode())
{
// Добавляем опции GTK
Gtk::Main::add_gtk_option_group(cmd_parser);
}
// Добавляем свои опции -->
Glib::OptionGroup entries_group("main", _("Main options"));
// only_pass -->
Glib::OptionEntry version_entry;
version_entry.set_long_name("version");
version_entry.set_flags( version_entry.get_flags() | Glib::OptionEntry::FLAG_NO_ARG );
version_entry.set_description(_("Show program version"));
entries_group.add_entry(version_entry, show_version);
// only_pass <--
// config_path -->
// TODO:
// Когда путь передается как --config ~/dir, то все нормально -
// ~ раскрывается оболочкой. Но если путь передается как
// --config=~/dir, то ~ не раскрывается, и не понятно, что с
// ней делать - раскрывать самому - а вдруг пользователь
// действительно захотел использовать директорию, содержащую ~
// в имени. Вообщем на досуге надо подумать, как лучше это
// обойти.
Glib::OptionEntry config_path_entry;
config_path_entry.set_long_name("config");
config_path_entry.set_flags(Glib::OptionEntry::FLAG_FILENAME);
config_path_entry.set_description(__("Configuration directory path (default: ~/%1)", DEFAULT_CONFIG_DIR_NAME));
config_path_entry.set_arg_description(_("DIRECTORY"));
entries_group.add_entry_filename(config_path_entry, this->config_path);
// config_path <--
// download_rate_limit -->
Glib::OptionEntry download_rate_limit_entry;
download_rate_limit_entry.set_long_name("download-rate-limit");
download_rate_limit_entry.set_description(_("Set download rate limit (KB/s)"));
download_rate_limit_entry.set_arg_description(_("SPEED"));
entries_group.add_entry(download_rate_limit_entry, this->download_rate_limit);
// download_rate_limit <--
// upload_rate_limit -->
Glib::OptionEntry upload_rate_limit_entry;
upload_rate_limit_entry.set_long_name("upload-rate-limit");
upload_rate_limit_entry.set_description(_("Set upload rate limit (KB/s)"));
upload_rate_limit_entry.set_arg_description(_("SPEED"));
entries_group.add_entry(upload_rate_limit_entry, this->upload_rate_limit);
// upload_rate_limit <--
// max_uploads -->
Glib::OptionEntry max_uploads_entry;
max_uploads_entry.set_long_name("max-uploads");
max_uploads_entry.set_description(_("Set maximum uploads"));
max_uploads_entry.set_arg_description(_("NUMBER"));
entries_group.add_entry(max_uploads_entry, this->max_uploads);
// max_uploads <--
// max_connections -->
Glib::OptionEntry max_connections_entry;
max_connections_entry.set_long_name("max-connections");
max_connections_entry.set_description(_("Set maximum connections"));
max_connections_entry.set_arg_description(_("NUMBER"));
entries_group.add_entry(max_connections_entry, this->max_connections);
// max_connections <--
// start -->
Glib::ustring start_string;
Glib::OptionEntry start_entry;
start_entry.set_long_name("start");
start_entry.set_description(_("Start torrents"));
start_entry.set_arg_description(_("{all,downloads,uploads}"));
entries_group.add_entry(start_entry, start_string);
// start <--
// stop -->
Glib::ustring stop_string;
Glib::OptionEntry stop_entry;
stop_entry.set_long_name("stop");
stop_entry.set_description(_("Stop torrents"));
stop_entry.set_arg_description(_("{all,downloads,uploads}"));
entries_group.add_entry(stop_entry, stop_string);
// start <--
// only_pass -->
Glib::OptionEntry only_pass_entry;
only_pass_entry.set_short_name('o');
only_pass_entry.set_long_name("only-pass");
only_pass_entry.set_flags( only_pass_entry.get_flags() | Glib::OptionEntry::FLAG_NO_ARG );
only_pass_entry.set_description(__("Only pass commands to already running %1 instance. Does not start new instance if it is not running yet", APP_NAME));
entries_group.add_entry(only_pass_entry, this->only_pass);
// only_pass <--
// Шаблон
// -->
//Glib::OptionEntry _entry;
//_entry.set_long_name("");
//_entry.set_description(_(""));
//entries_group.add_entry(_entry, this->);
// <--
cmd_parser.set_main_group(entries_group);
// Добавляем свои опции <--
// Парсим полученные опции -->
try
{
cmd_parser.parse(argc, argv);
}
catch(Glib::OptionError& e)
{
M_THROW(EE(e));
}
// Парсим полученные опции <--
// Если необходимо отобразить версию программы -->
if(show_version)
{
std::cout << APP_NAME << " " << APP_VERSION_STRING << std::endl;
std::cout << m::get_copyright_string(_("Dmitry Konishchev"), APP_YEAR) << std::endl;
exit(EXIT_SUCCESS);
}
// Если необходимо отобразить версию программы <--
// Проверяем полученные значения -->
// download_rate_limit
this->greater_or_equal_check("download_rate_limit", this->invalid_speed_value, this->download_rate_limit);
// upload_rate_limit
this->greater_or_equal_check("upload_rate_limit", this->invalid_speed_value, this->upload_rate_limit);
// max_uploads
this->greater_or_equal_check("max_uploads", this->invalid_number_value, this->max_uploads);
// max_connections
this->greater_or_equal_check("max_connections", this->invalid_number_value, this->max_connections);
// start
this->start_stop_check("start", start_string, &this->start);
// stop
this->start_stop_check("stop", stop_string, &this->stop);
// Проверяем полученные значения <--
// Все оставшиеся аргументы - файлы торрентов
for(int i = 1; i < argc; i++)
{
std::string arg = L2U(argv[i]);
if(m::lt::is_magnet_uri(arg))
this->torrents_paths.push_back(arg);
else
{
try
{
this->torrents_paths.push_back(Path(arg).absolute());
}
catch(m::Exception& e)
{
MLIB_W(
__("Error while processing torrent '%1'", L2U(argv[i])),
__("Can't get '%1' absolute path: %2.", L2U(argv[i]), EE(e))
);
}
}
}
}
int
main (int argc, char **argv)
{
int ret;
int ii, i, inp;
char buffer[MAX_BUF + 1];
char *session_data = NULL;
char *session_id = NULL;
size_t session_data_size;
size_t session_id_size = 0;
int user_term = 0, retval = 0;
socket_st hd;
ssize_t bytes;
set_program_name (argv[0]);
cmd_parser (argc, argv);
gnutls_global_set_log_function (tls_log_func);
gnutls_global_set_log_level (OPT_VALUE_DEBUG);
if ((ret = gnutls_global_init ()) < 0)
{
fprintf (stderr, "global_init: %s\n", gnutls_strerror (ret));
exit (1);
}
#ifdef ENABLE_PKCS11
pkcs11_common ();
#endif
if (hostname == NULL)
{
fprintf (stderr, "No hostname given\n");
exit (1);
}
sockets_init ();
init_global_tls_stuff ();
socket_open (&hd, hostname, service, udp);
socket_connect (&hd);
hd.session = init_tls_session (hostname);
if (starttls)
goto after_handshake;
for (i = 0; i < 2; i++)
{
if (i == 1)
{
hd.session = init_tls_session (hostname);
gnutls_session_set_data (hd.session, session_data,
session_data_size);
free (session_data);
}
ret = do_handshake (&hd);
if (ret < 0)
{
fprintf (stderr, "*** Handshake has failed\n");
gnutls_perror (ret);
gnutls_deinit (hd.session);
return 1;
}
else
{
printf ("- Handshake was completed\n");
if (gnutls_session_is_resumed (hd.session) != 0)
printf ("*** This is a resumed session\n");
}
if (resume != 0 && i == 0)
{
gnutls_session_get_data (hd.session, NULL, &session_data_size);
session_data = malloc (session_data_size);
gnutls_session_get_data (hd.session, session_data,
&session_data_size);
gnutls_session_get_id (hd.session, NULL, &session_id_size);
session_id = malloc (session_id_size);
gnutls_session_get_id (hd.session, session_id, &session_id_size);
printf ("- Disconnecting\n");
socket_bye (&hd);
printf
("\n\n- Connecting again- trying to resume previous session\n");
socket_open (&hd, hostname, service, udp);
socket_connect (&hd);
}
else
{
break;
}
}
after_handshake:
/* Warning! Do not touch this text string, it is used by external
programs to search for when gnutls-cli has reached this point. */
printf ("\n- Simple Client Mode:\n\n");
if (rehandshake)
{
ret = do_handshake (&hd);
if (ret < 0)
{
fprintf (stderr, "*** ReHandshake has failed\n");
gnutls_perror (ret);
gnutls_deinit (hd.session);
return 1;
}
else
{
printf ("- ReHandshake was completed\n");
}
}
#ifndef _WIN32
signal (SIGALRM, &starttls_alarm);
#endif
fflush (stdout);
fflush (stderr);
/* do not buffer */
#if !(defined _WIN32 || defined __WIN32__)
setbuf (stdin, NULL);
#endif
setbuf (stdout, NULL);
setbuf (stderr, NULL);
for (;;)
{
if (starttls_alarmed && !hd.secure)
{
/* Warning! Do not touch this text string, it is used by
external programs to search for when gnutls-cli has
reached this point. */
fprintf (stderr, "*** Starting TLS handshake\n");
ret = do_handshake (&hd);
if (ret < 0)
{
fprintf (stderr, "*** Handshake has failed\n");
user_term = 1;
retval = 1;
break;
}
}
inp = check_net_or_keyboard_input(&hd);
if (inp == IN_NET)
{
memset (buffer, 0, MAX_BUF + 1);
ret = socket_recv (&hd, buffer, MAX_BUF);
if (ret == 0)
{
printf ("- Peer has closed the GnuTLS connection\n");
break;
}
else if (handle_error (&hd, ret) < 0 && user_term == 0)
{
fprintf (stderr,
"*** Server has terminated the connection abnormally.\n");
retval = 1;
break;
}
else if (ret > 0)
{
if (verbose != 0)
printf ("- Received[%d]: ", ret);
for (ii = 0; ii < ret; ii++)
{
fputc (buffer[ii], stdout);
}
fflush (stdout);
}
if (user_term != 0)
break;
}
if (inp == IN_KEYBOARD)
{
if ((bytes = read (fileno (stdin), buffer, MAX_BUF - 1)) <= 0)
{
if (hd.secure == 0)
{
/* Warning! Do not touch this text string, it is
used by external programs to search for when
gnutls-cli has reached this point. */
fprintf (stderr, "*** Starting TLS handshake\n");
ret = do_handshake (&hd);
clearerr (stdin);
if (ret < 0)
{
fprintf (stderr, "*** Handshake has failed\n");
user_term = 1;
retval = 1;
break;
}
}
else
{
user_term = 1;
break;
}
continue;
}
buffer[bytes] = 0;
if (crlf != 0)
{
char *b = strchr (buffer, '\n');
if (b != NULL)
{
strcpy (b, "\r\n");
bytes++;
}
}
ret = socket_send (&hd, buffer, bytes);
if (ret > 0)
{
if (verbose != 0)
printf ("- Sent: %d bytes\n", ret);
}
else
handle_error (&hd, ret);
}
}
if (user_term != 0)
socket_bye (&hd);
else
gnutls_deinit (hd.session);
#ifdef ENABLE_SRP
if (srp_cred)
gnutls_srp_free_client_credentials (srp_cred);
#endif
#ifdef ENABLE_PSK
if (psk_cred)
gnutls_psk_free_client_credentials (psk_cred);
#endif
gnutls_certificate_free_credentials (xcred);
#ifdef ENABLE_ANON
gnutls_anon_free_client_credentials (anon_cred);
#endif
gnutls_global_deinit ();
return retval;
}
