int
Http::connect(const char *host, int port)
{
int ret;
Address addr;
delete conn; conn = NULL;
log(_("Resolve address...\n"));
if(addr.resolve(host, port) < 0) return E_RESOLVE;
log(_("Connecting...\n"));
conn = TcpConnector::connect(addr, ret, timeout);
if(!conn) return ret;
#ifdef HAVE_SSL
if(useSSL){
conn->set_use_ssl(useSSL);
if(conn->ssl_connect() < 0){
delete conn; conn = NULL;
return E_SSL_CONN;
}
}
#endif
conn->get_remote_addr(remote);
set_host(host, port);
return 0;
};
AxisCam::AxisCam(string ip) : ip(ip)
{
jpeg_buf = NULL;
jpeg_buf_size = 0;
curl_global_init(0);
set_host(ip);
}
void
login_dialog::init_settings()
{
QSettings settings("Manitou-Mail", "manitou-ui");
set_login(settings.value("login").toString());
set_dbname(settings.value("dbname").toString());
set_host(settings.value("host").toString());
set_params(settings.value("params").toString());
}
void
getset_init (void)
{
set_port (1);
set_verbose (0);
set_host (0);
set_plog (0);
set_pass_plugin (0);
set_http_pass_plugin (0);
}
/*
* Finish initialization of the pocket structure.
*/
void BSOCK::fin_init(JCR * jcr, int sockfd, const char *who, const char *host, int port,
struct sockaddr *lclient_addr)
{
Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
m_fd = sockfd;
set_who(bstrdup(who));
set_host(bstrdup(host));
set_port(port);
memcpy(&client_addr, lclient_addr, sizeof(client_addr));
set_jcr(jcr);
}
//////////////////////////////////////////////////////////////////////////
// base
TaskBase::TaskBase()
: _running(FALSE)
, _id(_maxid++)
, _content_type("")
, _date("")
{
set_uri("/");
set_use_https(false);
set_host(S3_DEFAULT_HOSTNAME);
set_timeout(CMD_TASK_TIMEOUT_SECOND);
add_params("formatter", "json");
add_header("Accept-Encoding", "identity");
}
void set_string_data(std::string key, std::string value) {
if (key == "host")
set_host(value);
else if (key == "address")
set_address(value);
else if (key == "port")
address.port = to_int(value, address.port);
else if (key == "timeout")
timeout = to_int(value, address.port);
else if (key == "retry")
retry = to_int(value, address.port);
else
data[key] = value;
}
bool http_header::redirect(const char* url)
{
if (url == NULL || *url == 0)
{
logger_error("url null");
return (false);
}
size_t n = 0;
// url: http[s]://xxx.xxx.xxx/xxx or /xxx
if (strncasecmp(url, "http://", sizeof("http://") - 1) == 0)
n = sizeof("http://") - 1;
else if (strncasecmp(url, "https://", sizeof("https://") - 1) == 0)
n = sizeof("https://") - 1;
if (url_)
{
acl_myfree(url_);
url_ = NULL;
}
if (n > 0)
{
url += n;
char* ptr = acl_mystrdup(url);
char* p = strchr(ptr, '/');
if (p)
*p = 0;
if (*ptr == 0)
{
logger_error("invalid url(%s)", url);
acl_myfree(ptr);
return (false);
}
set_host(ptr);
if (*(p + 1))
{
*p = '/';
url_ = acl_mystrdup(p);
}
else
url_ = acl_mystrdup("/");
acl_myfree(ptr);
}
else
url_ = acl_mystrdup(url);
return (true);
}
int
DoLogin( char *user, char *passwd, char *host )
{
ios_$id_t logid;
login_$opt_set_t opts;
status_$t status;
error_$string_t subsystem, module, error;
short sslen, modlen, errlen;
char buf[BUFSIZ];
Debug("DoLogin(): for %s\n", user);
login_$set_host(host, strlen(host));
opts = login_$no_prompt_name_sm |
login_$no_prompt_pass_sm |
login_$addut_sm |
login_$chown_tty_sm;
Debug("DoLogin(): before calling login_$chk_login()\n");
if ((!login_$chk_login(opts, STRING(user), STRING(passwd),
(login_$open_log_p) NULL, STRING(""),
&logid, &status))
&& (status.all != status_$ok)) {
Debug("DoLogin(): login_$chk_login() failed\n");
error_$get_text(status, subsystem, &sslen, module, &modlen,
error, &errlen);
STRNULL(error, errlen);
STRNULL(module, modlen);
STRNULL(subsystem, sslen);
sprintf(buf,ReadCatalog(MC_LOG_SET,MC_LOG_DOMAIN,MC_DEF_LOG_DOMAIN),
error, subsystem, module);
LogError (buf);
bzero (passwd, strlen(passwd));
return (false);
}
Debug("DoLogin(): login_$chk_login() succeeded\n");
/*
* clear password...
*/
bzero (passwd, strlen(passwd));
return (true);
}
ret_t
cherokee_source_configure (cherokee_source_t *src, cherokee_config_node_t *conf)
{
cherokee_list_t *i;
cherokee_config_node_t *child;
cherokee_config_node_foreach (i, conf) {
child = CONFIG_NODE(i);
if (equal_buf_str (&child->key, "host")) {
set_host (src, &child->val);
}
/* Base class: do not display error here
*/
}
void uri_builder::set_authority(string_type authority) {
boost::optional<uri::string_type> user_info, host, port;
detail::parse_authority(std::begin(authority), std::end(authority),
user_info, host, port);
if (user_info) {
set_user_info(*user_info);
}
if (host) {
set_host(*host);
}
if (port) {
set_port(*port);
}
}
result_t Url::format(v8::Local<v8::Object> args)
{
clear();
Isolate* isolate = holder();
exlib::string str;
v8::Local<v8::Value> v;
if (getString(isolate, args, "protocol", str))
set_protocol(str);
if (getString(isolate, args, "username", str))
set_username(str);
if (getString(isolate, args, "password", str))
set_password(str);
if (getString(isolate, args, "host", str))
set_host(str);
if (getString(isolate, args, "port", str))
set_port(str);
if (getString(isolate, args, "hostname", str))
set_hostname(str);
if (getString(isolate, args, "pathname", str))
set_pathname(str);
v = args->Get(holder()->NewString("query"));
if (!IsEmpty(v))
set_query(v);
if (getString(isolate, args, "hash", str))
set_hash(str);
if (m_slashes && m_protocol.compare("file:") && m_hostname.length() == 0)
m_slashes = false;
v = args->Get(holder()->NewString("slashes"));
if (!IsEmpty(v))
set_slashes(v->BooleanValue());
return 0;
}
static void submit (const char *type, const char *type_instance,
value_t *values, size_t values_len, mysql_database_t *db)
{
value_list_t vl = VALUE_LIST_INIT;
vl.values = values;
vl.values_len = values_len;
set_host (db, vl.host, sizeof (vl.host));
sstrncpy (vl.plugin, "mysql", sizeof (vl.plugin));
set_plugin_instance (db, vl.plugin_instance, sizeof (vl.plugin_instance));
sstrncpy (vl.type, type, sizeof (vl.type));
if (type_instance != NULL)
sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
plugin_dispatch_values (&vl);
} /* submit */
int
main(
int argc,
char ** argv)
{
in_port_t my_port;
struct servent *sp;
int i;
time_t timer;
char *lineread = NULL;
struct sigaction act, oact;
extern char *optarg;
extern int optind;
char cwd[STR_SIZE], *dn_guess = NULL, *mpt_guess = NULL;
char *service_name;
char *line = NULL;
struct tm *tm;
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
safe_fd(-1, 0);
set_pname("amoldrecover");
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
dbopen(DBG_SUBDIR_CLIENT);
localhost = g_malloc(MAX_HOSTNAME_LENGTH+1);
if (gethostname(localhost, MAX_HOSTNAME_LENGTH) != 0) {
error(_("cannot determine local host name\n"));
/*NOTREACHED*/
}
localhost[MAX_HOSTNAME_LENGTH] = '\0';
g_free(config);
config = g_strdup(DEFAULT_CONFIG);
dbrename(config, DBG_SUBDIR_CLIENT);
check_running_as(RUNNING_AS_ROOT);
amfree(server_name);
server_name = getenv("AMANDA_SERVER");
if(!server_name) server_name = DEFAULT_SERVER;
server_name = g_strdup(server_name);
amfree(tape_server_name);
tape_server_name = getenv("AMANDA_TAPESERVER");
if(!tape_server_name) tape_server_name = DEFAULT_TAPE_SERVER;
tape_server_name = g_strdup(tape_server_name);
config_init(CONFIG_INIT_CLIENT, NULL);
if (config_errors(NULL) >= CFGERR_WARNINGS) {
config_print_errors();
if (config_errors(NULL) >= CFGERR_ERRORS) {
g_critical(_("errors processing config file"));
}
}
if (argc > 1 && argv[1][0] != '-')
{
/*
* If the first argument is not an option flag, then we assume
* it is a configuration name to match the syntax of the other
* Amanda utilities.
*/
char **new_argv;
new_argv = (char **) g_malloc((size_t)((argc + 1 + 1) * sizeof(*new_argv)));
new_argv[0] = argv[0];
new_argv[1] = "-C";
for (i = 1; i < argc; i++)
{
new_argv[i + 1] = argv[i];
}
new_argv[i + 1] = NULL;
argc++;
argv = new_argv;
}
while ((i = getopt(argc, argv, "C:s:t:d:U")) != EOF)
{
switch (i)
{
case 'C':
g_free(config);
config = g_strdup(optarg);
break;
case 's':
g_free(server_name);
server_name = g_strdup(optarg);
break;
case 't':
g_free(tape_server_name);
tape_server_name = g_strdup(optarg);
break;
case 'd':
g_free(tape_device_name);
tape_device_name = g_strdup(optarg);
break;
case 'U':
case '?':
(void)g_printf(USAGE);
return 0;
}
}
if (optind != argc)
{
(void)g_fprintf(stderr, USAGE);
exit(1);
}
amfree(disk_name);
amfree(mount_point);
amfree(disk_path);
dump_date[0] = '\0';
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
/* set up signal handler */
act.sa_handler = sigint_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
#ifdef SA_RESTORER
act.sa_restorer = NULL;
#endif
if (sigaction(SIGINT, &act, &oact) != 0) {
error(_("error setting signal handler: %s"), strerror(errno));
/*NOTREACHED*/
}
service_name = "amandaidx";
g_printf(_("AMRECOVER Version %s. Contacting server on %s ...\n"),
VERSION, server_name);
if ((sp = getservbyname(service_name, "tcp")) == NULL) {
error(_("%s/tcp unknown protocol"), service_name);
/*NOTREACHED*/
}
server_socket = stream_client_privileged(server_name,
(in_port_t)ntohs((in_port_t)sp->s_port),
0,
0,
&my_port,
0);
if (server_socket < 0) {
error(_("cannot connect to %s: %s"), server_name, strerror(errno));
/*NOTREACHED*/
}
if (my_port >= IPPORT_RESERVED) {
aclose(server_socket);
error(_("did not get a reserved port: %d"), my_port);
/*NOTREACHED*/
}
/* get server's banner */
if (grab_reply(1) == -1) {
aclose(server_socket);
exit(1);
}
if (!server_happy())
{
dbclose();
aclose(server_socket);
exit(1);
}
/* do the security thing */
line = get_security();
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
if (!server_happy()) {
aclose(server_socket);
exit(1);
}
memset(line, '\0', strlen(line));
amfree(line);
/* try to get the features from the server */
{
char *our_feature_string = NULL;
char *their_feature_string = NULL;
our_features = am_init_feature_set();
our_feature_string = am_feature_to_string(our_features);
line = g_strconcat("FEATURES ", our_feature_string, NULL);
if(exchange(line) == 0) {
their_feature_string = g_strdup(server_line+13);
indexsrv_features = am_string_to_feature(their_feature_string);
}
else {
indexsrv_features = am_set_default_feature_set();
}
amfree(our_feature_string);
amfree(their_feature_string);
amfree(line);
}
/* set the date of extraction to be today */
(void)time(&timer);
tm = localtime(&timer);
if (tm)
strftime(dump_date, sizeof(dump_date), "%Y-%m-%d", tm);
else
error(_("BAD DATE"));
g_printf(_("Setting restore date to today (%s)\n"), dump_date);
line = g_strconcat("DATE ", dump_date, NULL);
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
amfree(line);
line = g_strconcat("SCNF ", config, NULL);
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
amfree(line);
if (server_happy())
{
/* set host we are restoring to this host by default */
amfree(dump_hostname);
set_host(localhost);
if (dump_hostname)
{
/* get a starting disk and directory based on where
we currently are */
switch (guess_disk(cwd, sizeof(cwd), &dn_guess, &mpt_guess))
{
case 1:
/* okay, got a guess. Set disk accordingly */
g_printf(_("$CWD '%s' is on disk '%s' mounted at '%s'.\n"),
cwd, dn_guess, mpt_guess);
set_disk(dn_guess, mpt_guess);
set_directory(cwd);
if (server_happy() && !g_str_equal(cwd, mpt_guess))
g_printf(_("WARNING: not on root of selected filesystem, check man-page!\n"));
amfree(dn_guess);
amfree(mpt_guess);
break;
case 0:
g_printf(_("$CWD '%s' is on a network mounted disk\n"),
cwd);
g_printf(_("so you must 'sethost' to the server\n"));
/* fake an unhappy server */
server_line[0] = '5';
break;
case 2:
case -1:
default:
g_printf(_("Use the setdisk command to choose dump disk to recover\n"));
/* fake an unhappy server */
server_line[0] = '5';
break;
}
}
}
quit_prog = 0;
do
{
if ((lineread = readline("amrecover> ")) == NULL) {
clearerr(stdin);
putchar('\n');
break;
}
if (lineread[0] != '\0')
{
add_history(lineread);
process_line(lineread); /* act on line's content */
}
amfree(lineread);
} while (!quit_prog);
dbclose();
aclose(server_socket);
return 0;
}
ip_address::ip_address(std::string host, unsigned port)
{
set_host(host);
set_port(port);
}
ip_address::ip_address(std::string host, std::string port)
{
set_host(host);
set_port(port);
}
builder &host(const asio::ip::address_v6 &host) { return set_host(host); }
int
Dump_Restore::handle_input (ACE_HANDLE)
{
char option[BUFSIZ];
char buf1[BUFSIZ];
u_short port;
if (::scanf ("%s", option) <= 0)
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("try again\n")));
return 0;
}
switch (option[0])
{
case 'P' :
case 'p' :
set_proc_local ();
break;
case 'N' :
case 'n' :
set_node_local ();
break;
case 'H' :
case 'h' :
if (::scanf ("%s %hu", buf1, &port) <= 0)
break;
set_host (ACE_TEXT_CHAR_TO_TCHAR (buf1), port);
break;
case 'F':
case 'f':
if (::scanf ("%s", filename_) <= 0)
break;
if (this->infile_)
ACE_OS::fclose (this->infile_);
this->infile_ = ACE_OS::fopen(filename_, ACE_TEXT("r"));
break;
case 'B' :
case 'b' :
populate (Dump_Restore::BIND);
break;
case 'U' :
case 'u' :
populate (Dump_Restore::UNBIND);
break;
case 'R' :
case 'r' :
populate (Dump_Restore::REBIND);
break;
case 'D':
case 'd':
if (::scanf ("%s", dump_filename_) <= 0)
break;
this->dump ();
break;
case 'Q' :
case 'q' :
quit ();
break;
default :
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Unrecognized command.\n")));
}
display_menu ();
return 0;
}
builder &host(const string_type &host) { return set_host(host); }
int
waitchar(void)
{
Event e;
int c;
char c2;
int newmouse;
int wasblocked;
int kbdchar = -1;
char echobuf[3*BSIZE];
static int lastc = -1;
for(;;) {
if(resize_flag)
resize();
wasblocked = blocked;
if(backp)
return(0);
if(ecanmouse() && (button2() || button3()))
readmenu();
if(snarffp) {
if((c = Bgetc(snarffp)) < 0) {
if(lastc != '\n')
write(outfd,"\n",1);
Bterm(snarffp);
snarffp = 0;
if(lastc != '\n') {
lastc = -1;
return('\n');
}
lastc = -1;
continue;
}
lastc = c;
c2 = c;
write(outfd, &c2, 1);
return(c);
}
if(!blocked && host_avail())
return(rcvchar());
if(kbdchar > 0) {
if(blocked)
resize();
if(cs->raw) {
switch(kbdchar){
case Kup:
sendfk("up key");
break;
case Kdown:
sendfk("down key");
break;
case Kleft:
sendfk("left key");
break;
case Kright:
sendfk("right key");
break;
case Kpgup:
sendfk("page up");
break;
case Kpgdown:
sendfk("page down");
break;
case KF|1:
sendfk("F1");
break;
case KF|2:
sendfk("F2");
break;
case KF|3:
sendfk("F3");
break;
case KF|4:
sendfk("F4");
break;
case KF|5:
sendfk("F5");
break;
case KF|6:
sendfk("F6");
break;
case KF|7:
sendfk("F7");
break;
case KF|8:
sendfk("F8");
break;
case KF|9:
sendfk("F9");
break;
case KF|10:
sendfk("F10");
break;
case KF|11:
sendfk("F11");
break;
case KF|12:
sendfk("F12");
break;
case '\n':
echobuf[0] = '\r';
sendnchars(1, echobuf);
break;
case '\r':
echobuf[0] = '\n';
sendnchars(1, echobuf);
break;
default:
echobuf[0] = kbdchar;
sendnchars(1, echobuf);
break;
}
} else if(canon(echobuf,kbdchar) == SCROLL) {
if(!blocked)
bigscroll();
} else
strcat(echo_input,echobuf);
blocked = 0;
kbdchar = -1;
continue;
}
curson(wasblocked); /* turn on cursor while we're waiting */
do {
newmouse = 0;
switch(eread(blocked ? Emouse|Ekeyboard :
Emouse|Ekeyboard|Ehost, &e)) {
case Emouse:
mouse = e.mouse;
if(button2() || button3())
readmenu();
else if(resize_flag == 0) {
/* eresized() is triggered by special mouse event */
newmouse = 1;
}
break;
case Ekeyboard:
kbdchar = e.kbdc;
break;
case Ehost:
set_host(&e);
break;
default:
perror("protocol violation");
exits("protocol violation");
}
} while(newmouse == 1);
cursoff(); /* turn cursor back off */
}
}
uri_builder &host(const Source &host) {
detail::host_converter<Source> convert;
set_host(convert(host));
return *this;
}
void set_string_data(std::string key, std::string value) {
if (key == "host")
set_host(value);
else
data[key] = value;
}
//------------------------------------------------------------------------------
void IpAddress::set_host(unsigned char a, unsigned char b, unsigned char c, unsigned char d)
{
unsigned long host = (a << 24) | (b << 16) | (c << 8) | d;
set_host(host);
}
void set_property_string(std::string key, std::string value) {
if (key == "host") {
set_host(value);
} else
options[key] = value;
}
static int mysql_read_slave_stats (mysql_database_t *db, MYSQL *con)
{
MYSQL_RES *res;
MYSQL_ROW row;
char *query;
int field_num;
/* WTF? libmysqlclient does not seem to provide any means to
* translate a column name to a column index ... :-/ */
const int READ_MASTER_LOG_POS_IDX = 6;
const int SLAVE_IO_RUNNING_IDX = 10;
const int SLAVE_SQL_RUNNING_IDX = 11;
const int EXEC_MASTER_LOG_POS_IDX = 21;
const int SECONDS_BEHIND_MASTER_IDX = 32;
query = "SHOW SLAVE STATUS";
res = exec_query (con, query);
if (res == NULL)
return (-1);
row = mysql_fetch_row (res);
if (row == NULL)
{
ERROR ("mysql plugin: Failed to get slave statistics: "
"`%s' did not return any rows.", query);
mysql_free_result (res);
return (-1);
}
field_num = mysql_num_fields (res);
if (field_num < 33)
{
ERROR ("mysql plugin: Failed to get slave statistics: "
"`%s' returned less than 33 columns.", query);
mysql_free_result (res);
return (-1);
}
if (db->slave_stats)
{
unsigned long long counter;
double gauge;
counter = atoll (row[READ_MASTER_LOG_POS_IDX]);
counter_submit ("mysql_log_position", "slave-read", counter, db);
counter = atoll (row[EXEC_MASTER_LOG_POS_IDX]);
counter_submit ("mysql_log_position", "slave-exec", counter, db);
if (row[SECONDS_BEHIND_MASTER_IDX] != NULL)
{
gauge = atof (row[SECONDS_BEHIND_MASTER_IDX]);
gauge_submit ("time_offset", NULL, gauge, db);
}
}
if (db->slave_notif)
{
notification_t n = { 0, cdtime (), "", "",
"mysql", "", "time_offset", "", NULL };
char *io, *sql;
io = row[SLAVE_IO_RUNNING_IDX];
sql = row[SLAVE_SQL_RUNNING_IDX];
set_host (db, n.host, sizeof (n.host));
/* Assured by "mysql_config_database" */
assert (db->instance != NULL);
sstrncpy (n.plugin_instance, db->instance, sizeof (n.plugin_instance));
if (((io == NULL) || (strcasecmp (io, "yes") != 0))
&& (db->slave_io_running))
{
n.severity = NOTIF_WARNING;
ssnprintf (n.message, sizeof (n.message),
"slave I/O thread not started or not connected to master");
plugin_dispatch_notification (&n);
db->slave_io_running = 0;
}
else if (((io != NULL) && (strcasecmp (io, "yes") == 0))
&& (! db->slave_io_running))
{
n.severity = NOTIF_OKAY;
ssnprintf (n.message, sizeof (n.message),
"slave I/O thread started and connected to master");
plugin_dispatch_notification (&n);
db->slave_io_running = 1;
}
if (((sql == NULL) || (strcasecmp (sql, "yes") != 0))
&& (db->slave_sql_running))
{
n.severity = NOTIF_WARNING;
ssnprintf (n.message, sizeof (n.message),
"slave SQL thread not started");
plugin_dispatch_notification (&n);
db->slave_sql_running = 0;
}
else if (((sql != NULL) && (strcasecmp (sql, "yes") == 0))
&& (! db->slave_sql_running))
{
n.severity = NOTIF_OKAY;
ssnprintf (n.message, sizeof (n.message),
"slave SQL thread started");
plugin_dispatch_notification (&n);
db->slave_sql_running = 0;
}
}
row = mysql_fetch_row (res);
if (row != NULL)
WARNING ("mysql plugin: `%s' returned more than one row - "
"ignoring further results.", query);
mysql_free_result (res);
return (0);
} /* mysql_read_slave_stats */
int
main(
int argc,
char ** argv)
{
int i;
time_t timer;
char *lineread = NULL;
struct sigaction act, oact;
extern char *optarg;
extern int optind;
char *line = NULL;
const security_driver_t *secdrv;
char *req = NULL;
int response_error;
struct tm *tm;
config_overrides_t *cfg_ovr;
char *starting_hostname = NULL;
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
safe_fd(-1, 0);
set_pname("amrecover");
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
dbopen(DBG_SUBDIR_CLIENT);
/* treat amrecover-specific command line options as the equivalent
* -o command-line options to set configuration values */
cfg_ovr = new_config_overrides(argc/2);
/* If the first argument is not an option flag, then we assume
* it is a configuration name to match the syntax of the other
* Amanda utilities. */
if (argc > 1 && argv[1][0] != '-') {
add_config_override(cfg_ovr, "conf", argv[1]);
/* remove that option from the command line */
argv[1] = argv[0];
argv++; argc--;
}
/* now parse regular command-line '-' options */
while ((i = getopt(argc, argv, "o:C:s:t:d:Uh:")) != EOF) {
switch (i) {
case 'C':
add_config_override(cfg_ovr, "conf", optarg);
break;
case 's':
add_config_override(cfg_ovr, "index_server", optarg);
break;
case 't':
add_config_override(cfg_ovr, "tape_server", optarg);
break;
case 'd':
add_config_override(cfg_ovr, "tapedev", optarg);
break;
case 'o':
add_config_override_opt(cfg_ovr, optarg);
break;
case 'h':
starting_hostname = g_strdup(optarg);
break;
case 'U':
case '?':
(void)g_printf(USAGE);
return 0;
}
}
if (optind != argc) {
(void)g_fprintf(stderr, USAGE);
exit(1);
}
/* load the base client configuration */
set_config_overrides(cfg_ovr);
config_init(CONFIG_INIT_CLIENT, NULL);
if (config_errors(NULL) >= CFGERR_WARNINGS) {
config_print_errors();
if (config_errors(NULL) >= CFGERR_ERRORS) {
g_critical(_("errors processing config file"));
}
}
/* and now try to load the configuration named in that file */
config_init(CONFIG_INIT_CLIENT | CONFIG_INIT_EXPLICIT_NAME | CONFIG_INIT_OVERLAY,
getconf_str(CNF_CONF));
check_running_as(RUNNING_AS_ROOT);
dbrename(get_config_name(), DBG_SUBDIR_CLIENT);
our_features = am_init_feature_set();
our_features_string = am_feature_to_string(our_features);
if (!starting_hostname) {
starting_hostname = g_malloc(MAX_HOSTNAME_LENGTH+1);
if (gethostname(starting_hostname, MAX_HOSTNAME_LENGTH) != 0) {
error(_("cannot determine local host name\n"));
/*NOTREACHED*/
}
starting_hostname[MAX_HOSTNAME_LENGTH] = '\0';
}
server_name = NULL;
if (getconf_seen(CNF_INDEX_SERVER) == -2) { /* command line argument */
server_name = getconf_str(CNF_INDEX_SERVER);
}
if (!server_name) {
server_name = getenv("AMANDA_SERVER");
if (server_name) {
g_printf(_("Using index server from environment AMANDA_SERVER (%s)\n"), server_name);
}
}
if (!server_name) {
server_name = getconf_str(CNF_INDEX_SERVER);
}
if (!server_name) {
error(_("No index server set"));
/*NOTREACHED*/
}
server_name = g_strdup(server_name);
tape_server_name = NULL;
if (getconf_seen(CNF_TAPE_SERVER) == -2) { /* command line argument */
tape_server_name = getconf_str(CNF_TAPE_SERVER);
}
if (!tape_server_name) {
tape_server_name = getenv("AMANDA_TAPE_SERVER");
if (!tape_server_name) {
tape_server_name = getenv("AMANDA_TAPESERVER");
if (tape_server_name) {
g_printf(_("Using tape server from environment AMANDA_TAPESERVER (%s)\n"), tape_server_name);
}
} else {
g_printf(_("Using tape server from environment AMANDA_TAPE_SERVER (%s)\n"), tape_server_name);
}
}
if (!tape_server_name) {
tape_server_name = getconf_str(CNF_TAPE_SERVER);
}
if (!tape_server_name) {
error(_("No tape server set"));
/*NOTREACHED*/
}
tape_server_name = g_strdup(tape_server_name);
amfree(tape_device_name);
tape_device_name = getconf_str(CNF_TAPEDEV);
if (!tape_device_name ||
strlen(tape_device_name) == 0 ||
!getconf_seen(CNF_TAPEDEV)) {
tape_device_name = NULL;
} else {
tape_device_name = g_strdup(tape_device_name);
}
authopt = g_strdup(getconf_str(CNF_AUTH));
amfree(disk_name);
amfree(mount_point);
amfree(disk_path);
dump_date[0] = '\0';
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
/* set up signal handler */
act.sa_handler = sigint_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
if (sigaction(SIGINT, &act, &oact) != 0) {
error(_("error setting signal handler: %s"), strerror(errno));
/*NOTREACHED*/
}
proplist = g_hash_table_new_full(g_str_hash, g_str_equal, &g_free, &free_property_t);
protocol_init();
/* We assume that amindexd support fe_amindexd_options_features */
/* and fe_amindexd_options_auth */
/* We should send a noop to really know */
req = g_strdup_printf("SERVICE amindexd\n"
"OPTIONS features=%s;auth=%s;\n",
our_features_string, authopt);
secdrv = security_getdriver(authopt);
if (secdrv == NULL) {
error(_("no '%s' security driver available for host '%s'"),
authopt, server_name);
/*NOTREACHED*/
}
protocol_sendreq(server_name, secdrv, generic_client_get_security_conf,
req, STARTUP_TIMEOUT, amindexd_response, &response_error);
amfree(req);
protocol_run();
g_printf(_("AMRECOVER Version %s. Contacting server on %s ...\n"),
VERSION, server_name);
if(response_error != 0) {
g_fprintf(stderr,"%s\n",errstr);
exit(1);
}
/* get server's banner */
if (grab_reply(1) == -1) {
aclose(server_socket);
exit(1);
}
if (!server_happy()) {
dbclose();
aclose(server_socket);
exit(1);
}
/* try to get the features from the server */
{
char *their_feature_string = NULL;
indexsrv_features = NULL;
line = g_strdup_printf("FEATURES %s", our_features_string);
if(exchange(line) == 0) {
their_feature_string = g_strdup(server_line+13);
indexsrv_features = am_string_to_feature(their_feature_string);
if (!indexsrv_features)
g_printf(_("Bad feature string from server: %s"), their_feature_string);
}
if (!indexsrv_features)
indexsrv_features = am_set_default_feature_set();
amfree(their_feature_string);
amfree(line);
}
/* set the date of extraction to be today */
(void)time(&timer);
tm = localtime(&timer);
if (tm)
strftime(dump_date, sizeof(dump_date), "%Y-%m-%d", tm);
else
error(_("BAD DATE"));
g_printf(_("Setting restore date to today (%s)\n"), dump_date);
line = g_strdup_printf("DATE %s", dump_date);
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
amfree(line);
line = g_strdup_printf("SCNF %s", get_config_name());
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
amfree(line);
if (server_happy()) {
/* set host we are restoring to this host by default */
amfree(dump_hostname);
set_host(starting_hostname);
if (dump_hostname)
g_printf(_("Use the setdisk command to choose dump disk to recover\n"));
else
g_printf(_("Use the sethost command to choose a host to recover\n"));
}
quit_prog = 0;
do {
if ((lineread = readline("amrecover> ")) == NULL) {
clearerr(stdin);
putchar('\n');
break;
}
if (lineread[0] != '\0')
{
add_history(lineread);
dbprintf(_("user command: '%s'\n"), lineread);
process_line(lineread); /* act on line's content */
}
amfree(lineread);
} while (!quit_prog);
dbclose();
aclose(server_socket);
return 0;
}
