/* set the tape server and device, for real */
void
set_device(
char * host,
char * device)
{
if (host)
tape_server_name = newstralloc(tape_server_name, host);
else
amfree(tape_server_name);
if (device)
tape_device_name = newstralloc(tape_device_name, device);
else
amfree(tape_device_name);
/* print the current status */
if (tape_device_name)
g_printf (_("Using tape \"%s\""), tape_device_name);
else
g_printf (_("Using default tape"));
if (tape_server_name)
g_printf (_(" from server %s.\n"), tape_server_name);
else
g_printf (_(".\nTape server unspecified, assumed to be %s.\n"),
server_name);
}
/* set the tape server and device */
void
set_tape(
char * tape)
{
char *uqtape = unquote_string(tape);
char *tapedev = strchr(uqtape, ':');
if (tapedev)
{
if (tapedev != uqtape) {
if((strchr(tapedev+1, ':') == NULL) &&
(strncmp(uqtape, "null:", 5) == 0 ||
strncmp(uqtape, "rait:", 5) == 0 ||
strncmp(uqtape, "file:", 5) == 0 ||
strncmp(uqtape, "tape:", 5) == 0)) {
tapedev = uqtape;
}
else {
*tapedev = '\0';
tape_server_name = newstralloc(tape_server_name, uqtape);
++tapedev;
}
} else { /* reset server_name if start with : */
amfree(tape_server_name);
++tapedev;
}
} else
tapedev = uqtape;
if (tapedev[0])
{
if (strcmp(tapedev, "default") == 0)
amfree(tape_device_name);
else
tape_device_name = newstralloc(tape_device_name, tapedev);
}
if (tape_device_name)
g_printf (_("Using tape \"%s\""), tape_device_name);
else
g_printf (_("Using default tape"));
if (tape_server_name)
g_printf (_(" from server %s.\n"), tape_server_name);
else
g_printf (_(".\nTape server unspecified, assumed to be %s.\n"),
server_name);
}
/* sets a date, mapping given date into standard form if needed */
int
set_date(
char * date)
{
char *cmd = NULL;
clear_dir_list();
cmd = stralloc2("DATE ", date);
if (converse(cmd) == -1)
exit(1);
/* if a host/disk/directory is set, then check if that directory
is still valid at the new date, and if not set directory to
mount_point */
if (disk_path != NULL) {
cmd = newstralloc2(cmd, "OISD ", disk_path);
if (exchange(cmd) == -1)
exit(1);
if (server_happy())
{
suck_dir_list_from_server();
}
else
{
g_printf(_("No index records for cwd on new date\n"));
g_printf(_("Setting cwd to mount point\n"));
disk_path = newstralloc(disk_path, "/"); /* fake it */
clear_dir_list();
}
}
amfree(cmd);
return 0;
}
int
cd_dir(
char * path_on_disk,
char * default_dir,
int verbose)
{
char *dir = NULL;
char *s;
int nb_found;
int result;
size_t i;
DIR_ITEM *ditem;
if ((s = validate_regexp(path_on_disk)) != NULL) {
result = set_directory(default_dir, verbose);
return result;
}
nb_found = 0;
for (ditem=get_dir_list(); ditem!=NULL && nb_found <= 1;
ditem=get_next_dir_item(ditem))
{
if (match(path_on_disk, ditem->path))
{
i = strlen(ditem->path);
if((i > 0 && ditem->path[i-1] == '/')
|| (i > 1 && ditem->path[i-2] == '/' && ditem->path[i-1] == '.'))
{ /* It is a directory */
char *dir1, *dir2;
nb_found++;
dir = newstralloc(dir,ditem->path);
if(dir[strlen(dir)-1] == '/')
dir[strlen(dir)-1] = '\0'; /* remove last / */
/* remove everything before the last / */
dir1 = strrchr(dir,'/');
if (dir1) {
dir1++;
dir2 = stralloc(dir1);
amfree(dir);
dir = dir2;
}
}
}
}
if(nb_found==0) {
result = set_directory(default_dir, verbose);
}
else if(nb_found==1) {
result = set_directory(dir, verbose);
}
else {
g_printf(_("Too many directories matching '%s'\n"), default_dir);
result = 0;
}
amfree(dir);
return result;
}
void handle_start(void)
{
static int started = 0;
char *s, *fp;
int ch;
if(!started) {
s = curstr;
ch = *s++;
skip_whitespace(s, ch);
if(ch == '\0' || strncmp_const_skip(s - 1, "date", s, ch) != 0) {
return; /* ignore bogus line */
}
skip_whitespace(s, ch);
if(ch == '\0') {
return;
}
fp = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
datestamp = newstralloc(datestamp, fp);
s[-1] = (char)ch;
started = 1;
}
}
void
cd_dir(
char * path_on_disk,
char * default_dir)
{
char *path_on_disk_slash = NULL;
char *dir = NULL;
int nb_found;
size_t i;
DIR_ITEM *ditem;
path_on_disk_slash = stralloc2(path_on_disk, "/");
nb_found = 0;
for (ditem=get_dir_list(); ditem!=NULL && nb_found <= 1;
ditem=get_next_dir_item(ditem))
{
if (match(path_on_disk, ditem->path)
|| match(path_on_disk_slash, ditem->path))
{
i = strlen(ditem->path);
if((i > 0 && ditem->path[i-1] == '/')
|| (i > 1 && ditem->path[i-2] == '/' && ditem->path[i-1] == '.'))
{ /* It is a directory */
char *dir1, *dir2;
nb_found++;
dir = newstralloc(dir,ditem->path);
if(dir[strlen(dir)-1] == '/')
dir[strlen(dir)-1] = '\0'; /* remove last / */
/* remove everything before the last / */
dir1 = strrchr(dir,'/');
if (dir1) {
dir1++;
dir2 = stralloc(dir1);
amfree(dir);
dir = dir2;
}
}
}
}
amfree(path_on_disk_slash);
if(nb_found==0) {
set_directory(default_dir);
}
else if(nb_found==1) {
set_directory(dir);
}
else {
g_printf(_("Too many directory\n"));
}
amfree(dir);
}
int
get_line(void)
{
char *line = NULL;
char *part = NULL;
size_t len;
while(1) {
if((part = areads(server_socket)) == NULL) {
int save_errno = errno;
if(server_line) {
fputs(server_line, stderr); /* show the last line read */
fputc('\n', stderr);
}
if(save_errno != 0) {
g_fprintf(stderr, _("%s: Error reading line from server: %s\n"),
get_pname(),
strerror(save_errno));
} else {
g_fprintf(stderr, _("%s: Unexpected end of file, check amindexd*debug on server %s\n"),
get_pname(),
server_name);
}
errno = save_errno;
break; /* exit while loop */
}
if(line) {
strappend(line, part);
amfree(part);
} else {
line = part;
part = NULL;
}
if((len = strlen(line)) > 0 && line[len-1] == '\r') {
line[len-1] = '\0';
server_line = newstralloc(server_line, line);
amfree(line);
return 0;
}
/*
* Hmmm. We got a "line" from areads(), which means it saw
* a '\n' (or EOF, etc), but there was not a '\r' before it.
* Put a '\n' back in the buffer and loop for more.
*/
strappend(line, "\n");
}
amfree(line);
amfree(server_line);
return -1;
}
static int
run_changer_command(
char * cmd,
char * arg,
char ** slotstr,
char ** rest)
{
int exitcode;
char *result_copy;
char *slot;
char *s;
int ch;
if (slotstr) {
*slotstr = NULL;
}
if (rest) {
*rest = NULL;
}
exitcode = changer_command(cmd, arg);
s = changer_resultstr;
ch = *s++;
skip_whitespace(s, ch);
if(ch == '\0') return report_bad_resultstr(cmd);
slot = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
if (slotstr) {
*slotstr = newstralloc(*slotstr, slot);
}
s[-1] = (char)ch;
skip_whitespace(s, ch);
if (rest) {
*rest = s - 1;
}
if(exitcode) {
if(ch == '\0') return report_bad_resultstr(cmd);
result_copy = stralloc(s - 1);
amfree(changer_resultstr);
changer_resultstr = result_copy;
return exitcode;
}
return 0;
}
int
changer_loadslot(
char *inslotstr,
char **outslotstr,
char **devicename)
{
char *rest;
int rc;
rc = run_changer_command("-slot", inslotstr, outslotstr, &rest);
if(rc) return rc;
if(*rest == '\0') return report_bad_resultstr("-slot");
*devicename = newstralloc(*devicename, rest);
return 0;
}
int
get_line(void)
{
ssize_t size;
char *newbuf, *s;
void *buf;
if (!mesg_buffer)
mesg_buffer = g_strdup("");
while (!strstr(mesg_buffer,"\r\n")) {
buf = NULL;
size = security_stream_read_sync(streams[MESGFD].fd, &buf);
if(size < 0) {
amrecover_debug(1, "amrecover: get_line size < 0 (%zd)\n", size);
return -1;
}
else if(size == 0) {
amrecover_debug(1, "amrecover: get_line size == 0 (%zd)\n", size);
return -1;
}
else if (buf == NULL) {
amrecover_debug(1, "amrecover: get_line buf == NULL\n");
return -1;
}
amrecover_debug(1, "amrecover: get_line size = %zd\n", size);
newbuf = g_malloc(strlen(mesg_buffer)+size+1);
strncpy(newbuf, mesg_buffer, (size_t)(strlen(mesg_buffer) + size));
memcpy(newbuf+strlen(mesg_buffer), buf, (size_t)size);
newbuf[strlen(mesg_buffer)+size] = '\0';
amfree(mesg_buffer);
mesg_buffer = newbuf;
amfree(buf);
}
s = strstr(mesg_buffer,"\r\n");
*s = '\0';
newbuf = g_strdup(s+2);
server_line = newstralloc(server_line, mesg_buffer);
amfree(mesg_buffer);
mesg_buffer = newbuf;
amrecover_debug(1, "server_line: %s\n", server_line);
amrecover_debug(1, "get: %s\n", mesg_buffer);
return 0;
}
int
changer_search(
char * searchlabel,
char ** outslotstr,
char ** devicename)
{
char *rest;
int rc;
dbprintf("changer_search: %s\n",searchlabel);
rc = run_changer_command("-search", searchlabel, outslotstr, &rest);
if(rc) return rc;
if(*rest == '\0') return report_bad_resultstr("-search");
*devicename = newstralloc(*devicename, rest);
return 0;
}
/* do this by looking for the longest mount point which matches the
current directory */
int
guess_disk (
char * cwd,
size_t cwd_len,
char ** dn_guess,
char ** mpt_guess)
{
size_t longest_match = 0;
size_t current_length;
size_t cwd_length;
int local_disk = 0;
generic_fsent_t fsent;
char *fsname = NULL;
char *disk_try = NULL;
*dn_guess = NULL;
*mpt_guess = NULL;
if (getcwd(cwd, cwd_len) == NULL) {
return -1;
/*NOTREACHED*/
}
cwd_length = strlen(cwd);
dbprintf(_("guess_disk: %zu: \"%s\"\n"), cwd_length, cwd);
if (open_fstab() == 0) {
return -1;
/*NOTREACHED*/
}
while (get_fstab_nextentry(&fsent))
{
current_length = fsent.mntdir ? strlen(fsent.mntdir) : (size_t)0;
dbprintf(_("guess_disk: %zu: %zu: \"%s\": \"%s\"\n"),
longest_match,
current_length,
fsent.mntdir ? fsent.mntdir : _("(mntdir null)"),
fsent.fsname ? fsent.fsname : _("(fsname null)"));
if ((current_length > longest_match)
&& (current_length <= cwd_length)
&& (strncmp(fsent.mntdir, cwd, current_length) == 0))
{
longest_match = current_length;
*mpt_guess = newstralloc(*mpt_guess, fsent.mntdir);
if(strncmp(fsent.fsname,DEV_PREFIX,(strlen(DEV_PREFIX))))
{
fsname = newstralloc(fsname, fsent.fsname);
}
else
{
fsname = newstralloc(fsname,fsent.fsname+strlen(DEV_PREFIX));
}
local_disk = is_local_fstype(&fsent);
dbprintf(_("guess_disk: local_disk = %d, fsname = \"%s\"\n"),
local_disk,
fsname);
}
}
close_fstab();
if (longest_match == 0) {
amfree(*mpt_guess);
amfree(fsname);
return -1; /* ? at least / should match */
}
if (!local_disk) {
amfree(*mpt_guess);
amfree(fsname);
return 0;
}
/* have mount point now */
/* disk name may be specified by mount point (logical name) or
device name, have to determine */
g_printf(_("Trying disk %s ...\n"), *mpt_guess);
disk_try = stralloc2("DISK ", *mpt_guess); /* try logical name */
if (exchange(disk_try) == -1)
exit(1);
amfree(disk_try);
if (server_happy())
{
*dn_guess = stralloc(*mpt_guess); /* logical is okay */
amfree(fsname);
return 1;
}
g_printf(_("Trying disk %s ...\n"), fsname);
disk_try = stralloc2("DISK ", fsname); /* try device name */
if (exchange(disk_try) == -1)
exit(1);
amfree(disk_try);
if (server_happy())
{
*dn_guess = stralloc(fsname); /* dev name is okay */
amfree(fsname);
return 1;
}
/* neither is okay */
amfree(*mpt_guess);
amfree(fsname);
return 2;
}
void
set_host(
const char *host)
{
char *cmd = NULL;
struct hostent *hp = NULL;
char **hostp;
int found_host = 0;
char *uqhost = unquote_string(host);
if (is_extract_list_nonempty())
{
g_printf(_("Must clear extract list before changing host\n"));
amfree(uqhost);
return;
}
/*
* The idea here is to try as many permutations of the hostname
* as we can imagine. The server will reject anything it doesn't
* recognize.
*/
cmd = stralloc2("HOST ", uqhost);
if (converse(cmd) == -1)
exit(1);
if (server_happy())
found_host = 1;
/*
* Try converting the given host to a fully qualified, canonical
* name.
*/
if (!found_host) {
if ((hp = gethostbyname(uqhost)) != NULL) {
host = hp->h_name;
g_printf(_("Trying host %s ...\n"), host);
cmd = newstralloc2(cmd, "HOST ", host);
if (converse(cmd) == -1)
exit(1);
if(server_happy())
found_host = 1;
}
}
/*
* Since we have them, try any CNAMEs that were traversed from uqhost
* to the canonical name (this assumes gethostbyname was called above)
*/
if (!found_host) {
if (hp) {
for (hostp = hp->h_aliases; (host = *hostp) != NULL; hostp++)
{
g_printf(_("Trying host %s ...\n"), host);
cmd = newstralloc2(cmd, "HOST ", host);
if (converse(cmd) == -1)
exit(1);
if(server_happy())
{
found_host = 1;
break;
}
}
}
}
/* Try looking up the canonical name of the host */
if (!found_host) {
char *canonname;
int result;
result = resolve_hostname(uqhost, 0, NULL, &canonname);
if (result == 0 && canonname) {
host = canonname;
g_printf(_("Trying host %s ...\n"), host);
cmd = newstralloc2(cmd, "HOST ", host);
if (converse(cmd) == -1)
exit(1);
if(server_happy())
found_host = 1;
}
}
if(found_host) {
dump_hostname = newstralloc(dump_hostname, host);
amfree(disk_name);
amfree(mount_point);
amfree(disk_path);
clear_dir_list();
}
amfree(cmd);
amfree(uqhost);
}
void
set_host(
const char * host)
{
char *cmd = NULL;
struct hostent *hp;
char **hostp;
int found_host = 0;
char *uqhost = unquote_string(host);
if (is_extract_list_nonempty())
{
g_printf(_("Must clear extract list before changing host\n"));
return;
}
cmd = stralloc2("HOST ", uqhost);
if (converse(cmd) == -1)
exit(1);
if (server_happy())
{
found_host = 1;
}
else
{
/*
* Try converting the given host to a fully qualified name
* and then try each of the aliases.
*/
if ((hp = gethostbyname(uqhost)) != NULL) {
host = hp->h_name;
g_printf(_("Trying host %s ...\n"), host);
cmd = newstralloc2(cmd, "HOST ", host);
if (converse(cmd) == -1)
exit(1);
if(server_happy())
{
found_host = 1;
}
else
{
for (hostp = hp->h_aliases; (host = *hostp) != NULL; hostp++)
{
g_printf(_("Trying host %s ...\n"), host);
cmd = newstralloc2(cmd, "HOST ", host);
if (converse(cmd) == -1)
exit(1);
if(server_happy())
{
found_host = 1;
break;
}
}
}
}
}
if(found_host)
{
dump_hostname = newstralloc(dump_hostname, host);
amfree(disk_name);
amfree(mount_point);
amfree(disk_path);
clear_dir_list();
}
amfree(cmd);
amfree(uqhost);
}
void
set_directory(
char * dir,
int verbose)
{
char *cmd = NULL;
char *new_dir = NULL;
char *qnew_dir;
char *dp, *de;
char *ldir = NULL;
/* do nothing if "." */
if(strcmp(dir,".")==0) {
show_directory(); /* say where we are */
return;
/*NOTREACHED*/
}
if (disk_name == NULL) {
g_printf(_("Must select disk before setting directory\n"));
return;
/*NOTREACHED*/
}
ldir = stralloc(dir);
clean_pathname(ldir);
/* convert directory into absolute path relative to disk mount point */
if (ldir[0] == '/')
{
/* absolute path specified, must start with mount point */
if (strcmp(mount_point, "/") == 0)
{
new_dir = stralloc(ldir);
}
else
{
if (strncmp(mount_point, ldir, strlen(mount_point)) != 0)
{
g_printf(_("Invalid directory - Can't cd outside mount point \"%s\"\n"),
mount_point);
amfree(ldir);
return;
/*NOTREACHED*/
}
new_dir = stralloc(ldir+strlen(mount_point));
if (strlen(new_dir) == 0) {
new_dir = newstralloc(new_dir, "/");
/* i.e. ldir == mount_point */
}
}
}
else
{
new_dir = stralloc(disk_path);
dp = ldir;
/* strip any leading ..s */
while (strncmp(dp, "../", 3) == 0)
{
de = strrchr(new_dir, '/'); /* always at least 1 */
if (de == new_dir)
{
/* at top of disk */
*(de + 1) = '\0';
dp = dp + 3;
}
else
{
*de = '\0';
dp = dp + 3;
}
}
if (strcmp(dp, "..") == 0) {
if (strcmp(new_dir, "/") == 0) {
/* at top of disk */
g_printf(_("Invalid directory - Can't cd outside mount point \"%s\"\n"),
mount_point);
/*@ignore@*/
amfree(new_dir);
/*@end@*/
amfree(ldir);
return;
/*NOTREACHED*/
}
de = strrchr(new_dir, '/'); /* always at least 1 */
if (de == new_dir)
{
/* at top of disk */
*(de+1) = '\0';
}
else
{
*de = '\0';
}
} else {
/*@ignore@*/
if (strcmp(new_dir, "/") != 0) {
strappend(new_dir, "/");
}
strappend(new_dir, ldir);
/*@end@*/
}
}
qnew_dir = quote_string(new_dir);
cmd = stralloc2("OISD ", qnew_dir);
amfree(qnew_dir);
if (exchange(cmd) == -1) {
exit(1);
/*NOTREACHED*/
}
amfree(cmd);
if (server_happy())
{
disk_path = newstralloc(disk_path, new_dir);
suck_dir_list_from_server(); /* get list of directory contents */
if (verbose)
show_directory(); /* say where we moved to */
}
else
{
g_printf(_("Invalid directory - %s\n"), dir);
}
/*@ignore@*/
amfree(new_dir);
amfree(ldir);
/*@end@*/
}
void
set_disk(
char * dsk,
char * mtpt)
{
char *cmd = NULL;
char *qdsk;
char *uqdsk;
char *uqmtpt = NULL;
if (is_extract_list_nonempty())
{
g_printf(_("Must clear extract list before changing disk\n"));
return;
}
/* if mount point specified, check it is valid */
if (mtpt != NULL) {
uqmtpt = unquote_string(mtpt);
if (*mtpt != '/') {
g_printf(_("Mount point \"%s\" invalid - must start with /\n"), uqmtpt);
amfree(uqmtpt);
return;
}
}
clear_dir_list();
uqdsk = unquote_string(dsk);
qdsk = quote_string(uqdsk);
cmd = stralloc2("DISK ", qdsk);
amfree(qdsk);
if (converse(cmd) == -1)
exit(1);
amfree(cmd);
if (!server_happy()) {
amfree(uqmtpt);
amfree(uqdsk);
return;
}
disk_name = newstralloc(disk_name, uqdsk);
if (mtpt == NULL)
{
/* mount point not specified */
if (*uqdsk == '/')
{
/* disk specified by mount point, hence use it */
mount_point = newstralloc(mount_point, uqdsk);
}
else
{
/* device name given, use '/' because nothing better */
mount_point = newstralloc(mount_point, "/");
}
}
else
{
/* mount point specified */
mount_point = newstralloc(mount_point, uqmtpt);
}
/* set the working directory to the mount point */
/* there is the possibility that there are no index records for the
disk for the given date, hence setting the directory to the
mount point will fail. Preempt this by checking first so we can write
a more informative message. */
if (exchange("OISD /") == -1)
exit(1);
if (server_happy())
{
disk_path = newstralloc(disk_path, "/");
suck_dir_list_from_server(); /* get list of directory contents */
}
else
{
g_printf(_("No index records for disk for specified date\n"));
g_printf(_("If date correct, notify system administrator\n"));
disk_path = newstralloc(disk_path, "/"); /* fake it */
clear_dir_list();
}
amfree(uqmtpt);
amfree(uqdsk);
if (am_has_feature(indexsrv_features, fe_amindexd_DLE)) {
char *dle_str;
char *errmsg = NULL;
cmd = stralloc("DLE");
if (exchange(cmd) == -1)
exit(1);
amfree(cmd);
if (!server_happy())
return;
dle_str = reply_line();
if (BSTRNCMP(dle_str+4, "NODLE") == 0) {
dump_dle = NULL;
} else {
dle_str = unquote_string(dle_str+4);
dump_dle = amxml_parse_node_CHAR(dle_str, &errmsg);
amfree(dle_str);
}
}
}
static gboolean label_new_tape(taper_state_t * state, dump_info_t * dump_info) {
char *old_volume_name = NULL;
char *old_volume_time = NULL;
tape_search_request_t request;
gboolean search_result;
DeviceStatusFlags status;
/* If we got here, it means that we have found a tape to label and
* have gotten permission from the driver to write it. But we
* still can say NO-NEW-TAPE if a problem shows up, and must still
* say NEW-TAPE if one doesn't. */
amfree(state->last_errmsg);
state->device = device_open(state->next_tape_device);
g_assert(state->device != NULL);
amfree(state->next_tape_device);
if (state->device->status != DEVICE_STATUS_SUCCESS)
goto skip_volume;
if (!device_configure(state->device, TRUE))
goto skip_volume;
/* if we have an error, and are sure it isn't just an unlabeled volume,
* then skip this volume */
status = device_read_label(state->device);
if ((status & ~DEVICE_STATUS_VOLUME_UNLABELED) &&
!(status & DEVICE_STATUS_VOLUME_UNLABELED))
goto skip_volume;
old_volume_name = g_strdup(state->device->volume_label);
old_volume_time = g_strdup(state->device->volume_time);
if (!device_start(state->device, ACCESS_WRITE, state->next_tape_label,
state->driver_start_time)) {
gboolean tape_used;
/* Something broke, see if we can tell if the volume was erased or
* not. */
g_fprintf(stderr, "taper: Error writing label %s to device %s: %s.\n",
state->next_tape_label, state->device->device_name,
device_error_or_status(state->device));
if (!device_finish(state->device))
goto request_new_volume;
/* This time, if we can't read the label, assume we've overwritten
* the volume or otherwise corrupted it */
status = device_read_label(state->device);
if ((status & ~DEVICE_STATUS_VOLUME_UNLABELED) &&
!(status & DEVICE_STATUS_VOLUME_UNLABELED))
goto request_new_volume;
tape_used = check_volume_changed(state->device, old_volume_name,
old_volume_time);
if (tape_used)
goto request_new_volume;
else
goto skip_volume;
}
amfree(old_volume_name);
amfree(old_volume_time);
amfree(state->next_tape_label);
update_tapelist(state);
state->cur_tape++;
if (state->have_changer &&
changer_label("UNKNOWN", state->device->volume_label) != 0) {
error(_("couldn't update barcode database"));
/*NOTREACHED*/
}
log_add(L_START, "datestamp %s label %s tape %d",
state->driver_start_time, state->device->volume_label,
state->cur_tape);
putresult(NEW_TAPE, "%s %s\n", dump_info->handle,
state->device->volume_label);
return TRUE;
request_new_volume:
/* Tell the driver we overwrote this volume, even if it was empty, and request
* a new volume. */
if (state->device)
state->last_errmsg = newstralloc(state->last_errmsg, device_error_or_status(state->device));
else
state->last_errmsg = newstralloc(state->last_errmsg, "(unknown)");
putresult(NEW_TAPE, "%s %s\n", dump_info->handle,
state->next_tape_label);
if (old_volume_name) {
log_add(L_WARNING, "Problem writing label '%s' to volume %s "
"(volume may be erased): %s\n",
state->next_tape_label, old_volume_name,
state->last_errmsg);
} else {
log_add(L_WARNING, "Problem writing label '%s' to new volume "
"(volume may be erased): %s\n", state->next_tape_label,
state->last_errmsg);
}
if (state->device) {
g_object_unref(state->device);
state->device = NULL;
}
amfree(state->next_tape_label);
amfree(old_volume_name);
amfree(old_volume_time);
return find_and_label_new_tape(state, dump_info);
skip_volume:
/* grab a new volume without talking to the driver again -- we do this if we're
* confident we didn't overwrite the last tape we got. */
if (state->device)
state->last_errmsg = newstralloc(state->last_errmsg, device_error_or_status(state->device));
else
state->last_errmsg = newstralloc(state->last_errmsg, "(unknown)");
if (old_volume_name) {
log_add(L_WARNING, "Problem writing label '%s' to volume '%s' "
"(old volume data intact): %s\n",
state->next_tape_label, old_volume_name, state->last_errmsg);
} else {
log_add(L_WARNING, "Problem writing label '%s' to new volume "
"(old volume data intact): %s\n", state->next_tape_label,
state->last_errmsg);
}
if (state->device) {
g_object_unref(state->device);
state->device = NULL;
}
amfree(state->next_tape_label);
amfree(old_volume_name);
amfree(old_volume_time);
request.state = state;
request.prolong = TRUE;
request.errmsg = NULL;
search_result = GPOINTER_TO_INT(tape_search_thread(&request));
if (search_result) {
amfree(request.errmsg);
return label_new_tape(state, dump_info);
} else {
/* Problem finding a new tape! */
log_taper_scan_errmsg(request.errmsg);
putresult(NO_NEW_TAPE, "%s\n", dump_info->handle);
return FALSE;
}
}
/*
* doing similar to $ gtar | compression | encryption
*/
static void
start_backup(
dle_t *dle,
char *host,
int dataf,
int mesgf,
int indexf)
{
char tmppath[PATH_MAX];
int dumpin, dumpout, compout;
char *cmd = NULL;
char *indexcmd = NULL;
char *dirname = NULL;
int l;
char dumptimestr[80] = "UNUSED";
struct tm *gmtm;
amandates_t *amdates = NULL;
time_t prev_dumptime = 0;
char *error_pn = NULL;
char *compopt = NULL;
char *encryptopt = skip_argument;
char *tquoted;
char *fquoted;
char *qdisk;
int infd, outfd;
ssize_t nb;
char buf[32768];
char *amandates_file = NULL;
level_t *alevel = (level_t *)dle->levellist->data;
int level = alevel->level;
error_pn = stralloc2(get_pname(), "-smbclient");
qdisk = quote_string(dle->disk);
dbprintf(_("start: %s:%s lev %d\n"), host, qdisk, level);
g_fprintf(stderr, _("%s: start [%s:%s level %d]\n"),
get_pname(), host, qdisk, level);
/* apply client-side encryption here */
if ( dle->encrypt == ENCRYPT_CUST ) {
encpid = pipespawn(dle->clnt_encrypt, STDIN_PIPE, 0,
&compout, &dataf, &mesgf,
dle->clnt_encrypt, encryptopt, NULL);
dbprintf(_("gnutar: pid %ld: %s\n"), (long)encpid, dle->clnt_encrypt);
} else {
compout = dataf;
encpid = -1;
}
/* now do the client-side compression */
if(dle->compress == COMP_FAST || dle->compress == COMP_BEST) {
compopt = skip_argument;
#if defined(COMPRESS_BEST_OPT) && defined(COMPRESS_FAST_OPT)
if(dle->compress == COMP_BEST) {
compopt = COMPRESS_BEST_OPT;
} else {
compopt = COMPRESS_FAST_OPT;
}
#endif
comppid = pipespawn(COMPRESS_PATH, STDIN_PIPE, 0,
&dumpout, &compout, &mesgf,
COMPRESS_PATH, compopt, NULL);
dbprintf(_("gnutar: pid %ld: %s"), (long)comppid, COMPRESS_PATH);
if(compopt != skip_argument) {
dbprintf(_("pid %ld: %s %s\n"),
(long)comppid, COMPRESS_PATH, compopt);
} else {
dbprintf(_("pid %ld: %s\n"), (long)comppid, COMPRESS_PATH);
}
} else if (dle->compress == COMP_CUST) {
compopt = skip_argument;
comppid = pipespawn(dle->compprog, STDIN_PIPE, 0,
&dumpout, &compout, &mesgf,
dle->compprog, compopt, NULL);
if(compopt != skip_argument) {
dbprintf(_("pid %ld: %s %s\n"),
(long)comppid, dle->compprog, compopt);
} else {
dbprintf(_("pid %ld: %s\n"), (long)comppid, dle->compprog);
}
} else {
dumpout = compout;
comppid = -1;
}
gnutar_list_dir = getconf_str(CNF_GNUTAR_LIST_DIR);
if (strlen(gnutar_list_dir) == 0)
gnutar_list_dir = NULL;
#ifdef SAMBA_CLIENT /* { */
if (dle->device[0] == '/' && dle->device[1]=='/')
amfree(incrname);
else
#endif /* } */
if (gnutar_list_dir) {
char *basename = NULL;
char number[NUM_STR_SIZE];
char *inputname = NULL;
int baselevel;
char *sdisk = sanitise_filename(dle->disk);
basename = g_strjoin(NULL, gnutar_list_dir,
"/",
host,
sdisk,
NULL);
amfree(sdisk);
g_snprintf(number, sizeof(number), "%d", level);
incrname = g_strjoin(NULL, basename, "_", number, ".new", NULL);
unlink(incrname);
/*
* Open the listed incremental file from the previous level. Search
* backward until one is found. If none are found (which will also
* be true for a level 0), arrange to read from /dev/null.
*/
baselevel = level;
infd = -1;
while (infd == -1) {
if (--baselevel >= 0) {
g_snprintf(number, sizeof(number), "%d", baselevel);
inputname = newvstralloc(inputname,
basename, "_", number, NULL);
} else {
inputname = newstralloc(inputname, "/dev/null");
}
if ((infd = open(inputname, O_RDONLY)) == -1) {
int save_errno = errno;
char *qname = quote_string(inputname);
dbprintf(_("gnutar: error opening '%s': %s\n"),
qname,
strerror(save_errno));
if (baselevel < 0) {
error(_("error [opening '%s': %s]"), qname, strerror(save_errno));
/*NOTREACHED*/
}
amfree(qname);
}
}
/*
* Copy the previous listed incremental file to the new one.
*/
if ((outfd = open(incrname, O_WRONLY|O_CREAT, 0600)) == -1) {
error(_("error [opening '%s': %s]"), incrname, strerror(errno));
/*NOTREACHED*/
}
while ((nb = read(infd, &buf, sizeof(buf))) > 0) {
if (full_write(outfd, &buf, (size_t)nb) < (size_t)nb) {
error(_("error [writing to '%s': %s]"), incrname,
strerror(errno));
/*NOTREACHED*/
}
}
if (nb < 0) {
error(_("error [reading from '%s': %s]"), inputname, strerror(errno));
/*NOTREACHED*/
}
if (close(infd) != 0) {
error(_("error [closing '%s': %s]"), inputname, strerror(errno));
/*NOTREACHED*/
}
if (close(outfd) != 0) {
error(_("error [closing '%s': %s]"), incrname, strerror(errno));
/*NOTREACHED*/
}
tquoted = quote_string(incrname);
if(baselevel >= 0) {
fquoted = quote_string(inputname);
dbprintf(_("doing level %d dump as listed-incremental from '%s' to '%s'\n"),
level, fquoted, tquoted);
amfree(fquoted);
} else {
dbprintf(_("doing level %d dump as listed-incremental to '%s'\n"),
level, tquoted);
}
amfree(tquoted);
amfree(inputname);
amfree(basename);
} else {
/* no gnutar-listdir, so we're using amandates */
/* find previous dump time, failing completely if there's a problem */
amandates_file = getconf_str(CNF_AMANDATES);
if(!start_amandates(amandates_file, 0)) {
error(_("error [opening %s: %s]"), amandates_file, strerror(errno));
/*NOTREACHED*/
}
amdates = amandates_lookup(dle->disk);
prev_dumptime = EPOCH;
for(l = 0; l < level; l++) {
if(amdates->dates[l] > prev_dumptime)
prev_dumptime = amdates->dates[l];
}
finish_amandates();
free_amandates();
gmtm = gmtime(&prev_dumptime);
g_snprintf(dumptimestr, sizeof(dumptimestr),
"%04d-%02d-%02d %2d:%02d:%02d GMT",
gmtm->tm_year + 1900, gmtm->tm_mon+1, gmtm->tm_mday,
gmtm->tm_hour, gmtm->tm_min, gmtm->tm_sec);
dbprintf(_("gnutar: doing level %d dump from amandates-derived date: %s\n"),
level, dumptimestr);
}
dirname = amname_to_dirname(dle->device);
cur_dumptime = time(0);
cur_level = level;
cur_disk = g_strdup(dle->disk);
#ifdef GNUTAR
# define PROGRAM_GNUTAR GNUTAR
#else
# define PROGRAM_GNUTAR "tar"
#endif
indexcmd = g_strjoin(NULL,
PROGRAM_GNUTAR,
" -tf", " -",
" 2>/dev/null",
" | sed", " -e",
" \'s/^\\.//\'",
NULL);
#ifdef SAMBA_CLIENT /* { */
/* Use sambatar if the disk to back up is a PC disk */
if (dle->device[0] == '/' && dle->device[1]=='/') {
char *sharename = NULL, *user_and_password = NULL, *domain = NULL;
char *share = NULL, *subdir = NULL;
char *pwtext = NULL;
char *taropt;
int passwdf = -1;
size_t lpass;
size_t pwtext_len;
char *pw_fd_env;
parsesharename(dle->device, &share, &subdir);
if (!share) {
amfree(share);
amfree(subdir);
set_pname(error_pn);
amfree(error_pn);
error(_("cannot parse disk entry %s for share/subdir"), qdisk);
/*NOTREACHED*/
}
if ((subdir) && (SAMBA_VERSION < 2)) {
amfree(share);
amfree(subdir);
set_pname(error_pn);
amfree(error_pn);
error(_("subdirectory specified for share %s but samba not v2 or better"), qdisk);
/*NOTREACHED*/
}
if ((user_and_password = findpass(share, &domain)) == NULL) {
if(domain) {
memset(domain, '\0', strlen(domain));
amfree(domain);
}
set_pname(error_pn);
amfree(error_pn);
error(_("error [invalid samba host or password not found?]"));
/*NOTREACHED*/
}
lpass = strlen(user_and_password);
if ((pwtext = strchr(user_and_password, '%')) == NULL) {
memset(user_and_password, '\0', lpass);
amfree(user_and_password);
if(domain) {
memset(domain, '\0', strlen(domain));
amfree(domain);
}
set_pname(error_pn);
amfree(error_pn);
error(_("password field not \'user%%pass\' for %s"), qdisk);
/*NOTREACHED*/
}
*pwtext++ = '\0';
pwtext_len = strlen(pwtext);
if ((sharename = makesharename(share, 0)) == 0) {
memset(user_and_password, '\0', lpass);
amfree(user_and_password);
if(domain) {
memset(domain, '\0', strlen(domain));
amfree(domain);
}
set_pname(error_pn);
amfree(error_pn);
error(_("error [can't make share name of %s]"), share);
/*NOTREACHED*/
}
taropt = g_strdup("-T");
if(dle->exclude_file && dle->exclude_file->nb_element == 1) {
strappend(taropt, "X");
}
#if SAMBA_VERSION >= 2
strappend(taropt, "q");
#endif
strappend(taropt, "c");
if (level != 0) {
strappend(taropt, "g");
} else if (dle->record) {
strappend(taropt, "a");
}
if (subdir) {
dbprintf(_("gnutar: backup of %s/%s\n"), sharename, subdir);
} else {
dbprintf(_("gnutar: backup of %s\n"), sharename);
}
program->backup_name = program->restore_name = SAMBA_CLIENT;
cmd = g_strdup(program->backup_name);
info_tapeheader(dle);
start_index(dle->create_index, dumpout, mesgf, indexf, indexcmd);
if (pwtext_len > 0) {
pw_fd_env = "PASSWD_FD";
} else {
pw_fd_env = "dummy_PASSWD_FD";
}
dumppid = pipespawn(cmd, STDIN_PIPE|PASSWD_PIPE, 0,
&dumpin, &dumpout, &mesgf,
pw_fd_env, &passwdf,
"smbclient",
sharename,
*user_and_password ? "-U" : skip_argument,
*user_and_password ? user_and_password : skip_argument,
"-E",
domain ? "-W" : skip_argument,
domain ? domain : skip_argument,
#if SAMBA_VERSION >= 2
subdir ? "-D" : skip_argument,
subdir ? subdir : skip_argument,
#endif
"-d0",
taropt,
"-",
dle->exclude_file && dle->exclude_file->nb_element == 1 ? dle->exclude_file->first->name : skip_argument,
NULL);
if(domain) {
memset(domain, '\0', strlen(domain));
amfree(domain);
}
if(pwtext_len > 0 && full_write(passwdf, pwtext, pwtext_len) < pwtext_len) {
int save_errno = errno;
aclose(passwdf);
memset(user_and_password, '\0', lpass);
amfree(user_and_password);
set_pname(error_pn);
amfree(error_pn);
error(_("error [password write failed: %s]"), strerror(save_errno));
/*NOTREACHED*/
}
memset(user_and_password, '\0', lpass);
amfree(user_and_password);
aclose(passwdf);
amfree(sharename);
amfree(share);
amfree(subdir);
amfree(taropt);
tarpid = dumppid;
} else
#endif /*end of samba */
{
int nb_exclude = 0;
int nb_include = 0;
GPtrArray *argv_ptr = g_ptr_array_new();
char *file_exclude = NULL;
char *file_include = NULL;
if (dle->exclude_file) nb_exclude+=dle->exclude_file->nb_element;
if (dle->exclude_list) nb_exclude+=dle->exclude_list->nb_element;
if (dle->include_file) nb_include+=dle->include_file->nb_element;
if (dle->include_list) nb_include+=dle->include_list->nb_element;
if (nb_exclude > 0) file_exclude = build_exclude(dle, 0);
if (nb_include > 0) file_include = build_include(dle, 0);
cmd = g_strjoin(NULL, amlibexecdir, "/", "runtar", NULL);
info_tapeheader(dle);
start_index(dle->create_index, dumpout, mesgf, indexf, indexcmd);
g_ptr_array_add(argv_ptr, g_strdup("runtar"));
if (g_options->config)
g_ptr_array_add(argv_ptr, g_strdup(g_options->config));
else
g_ptr_array_add(argv_ptr, g_strdup("NOCONFIG"));
#ifdef GNUTAR
g_ptr_array_add(argv_ptr, g_strdup(GNUTAR));
#else
g_ptr_array_add(argv_ptr, g_strdup("tar"));
#endif
g_ptr_array_add(argv_ptr, g_strdup("--create"));
g_ptr_array_add(argv_ptr, g_strdup("--file"));
g_ptr_array_add(argv_ptr, g_strdup("-"));
g_ptr_array_add(argv_ptr, g_strdup("--directory"));
canonicalize_pathname(dirname, tmppath);
g_ptr_array_add(argv_ptr, g_strdup(tmppath));
g_ptr_array_add(argv_ptr, g_strdup("--one-file-system"));
if (gnutar_list_dir && incrname) {
g_ptr_array_add(argv_ptr, g_strdup("--listed-incremental"));
g_ptr_array_add(argv_ptr, g_strdup(incrname));
} else {
g_ptr_array_add(argv_ptr, g_strdup("--incremental"));
g_ptr_array_add(argv_ptr, g_strdup("--newer"));
g_ptr_array_add(argv_ptr, g_strdup(dumptimestr));
}
#ifdef ENABLE_GNUTAR_ATIME_PRESERVE
/* --atime-preserve causes gnutar to call
* utime() after reading files in order to
* adjust their atime. However, utime()
* updates the file's ctime, so incremental
* dumps will think the file has changed. */
g_ptr_array_add(argv_ptr, g_strdup("--atime-preserve"));
#endif
g_ptr_array_add(argv_ptr, g_strdup("--sparse"));
g_ptr_array_add(argv_ptr, g_strdup("--ignore-failed-read"));
g_ptr_array_add(argv_ptr, g_strdup("--totals"));
if(file_exclude) {
g_ptr_array_add(argv_ptr, g_strdup("--exclude-from"));
g_ptr_array_add(argv_ptr, g_strdup(file_exclude));
}
if(file_include) {
g_ptr_array_add(argv_ptr, g_strdup("--files-from"));
g_ptr_array_add(argv_ptr, g_strdup(file_include));
}
else {
g_ptr_array_add(argv_ptr, g_strdup("."));
}
g_ptr_array_add(argv_ptr, NULL);
dumppid = pipespawnv(cmd, STDIN_PIPE, 0,
&dumpin, &dumpout, &mesgf,
(char **)argv_ptr->pdata);
tarpid = dumppid;
amfree(file_exclude);
amfree(file_include);
g_ptr_array_free_full(argv_ptr);
}
dbprintf(_("gnutar: %s: pid %ld\n"), cmd, (long)dumppid);
amfree(qdisk);
amfree(dirname);
amfree(cmd);
amfree(indexcmd);
amfree(error_pn);
/* close the write ends of the pipes */
aclose(dumpin);
aclose(dumpout);
aclose(compout);
aclose(dataf);
aclose(mesgf);
if (dle->create_index)
aclose(indexf);
}
void
set_pname(char *p)
{
pname = newstralloc(pname, p);
}
/*
* Write out the buffer to the backing file
*/
static int
databuf_flush(
struct databuf * db)
{
struct cmdargs *cmdargs = NULL;
int rc = 1;
size_t size_to_write;
size_t written;
off_t left_in_chunk;
char *arg_filename = NULL;
char *new_filename = NULL;
char *tmp_filename = NULL;
char sequence[NUM_STR_SIZE];
int newfd;
filetype_t save_type;
char *q;
int a;
char *pc;
/*
* If there's no data, do nothing.
*/
if (db->dataout >= db->datain) {
goto common_exit;
}
/*
* See if we need to split this file.
*/
while (db->split_size > (off_t)0 && dumpsize >= db->split_size) {
if( db->use == (off_t)0 ) {
/*
* Probably no more space on this disk. Request some more.
*/
putresult(RQ_MORE_DISK, "%s\n", handle);
cmdargs = getcmd();
if(command_in_transit == NULL &&
(cmdargs->cmd == DONE || cmdargs->cmd == TRYAGAIN || cmdargs->cmd == FAILED)) {
command_in_transit = cmdargs;
cmdargs = getcmd();
}
if(cmdargs->cmd == CONTINUE) {
/*
* CONTINUE
* serial
* filename
* chunksize
* use
*/
a = 2; /* skip CONTINUE and serial */
if(a >= cmdargs->argc) {
error(_("error [chunker CONTINUE: not enough args: filename]"));
/*NOTREACHED*/
}
arg_filename = newstralloc(arg_filename, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker CONTINUE: not enough args: chunksize]"));
/*NOTREACHED*/
}
db->chunk_size = OFF_T_ATOI(cmdargs->argv[a++]);
db->chunk_size = am_floor(db->chunk_size, (off_t)DISK_BLOCK_KB);
if(a >= cmdargs->argc) {
error(_("error [chunker CONTINUE: not enough args: use]"));
/*NOTREACHED*/
}
db->use = OFF_T_ATOI(cmdargs->argv[a++]);
if(a != cmdargs->argc) {
error(_("error [chunker CONTINUE: too many args: %d != %d]"),
cmdargs->argc, a);
/*NOTREACHED*/
}
if(strcmp(db->filename, arg_filename) == 0) {
/*
* Same disk, so use what room is left up to the
* next chunk boundary or the amount we were given,
* whichever is less.
*/
left_in_chunk = db->chunk_size - filesize;
if(left_in_chunk > db->use) {
db->split_size += db->use;
db->use = (off_t)0;
} else {
db->split_size += left_in_chunk;
db->use -= left_in_chunk;
}
if(left_in_chunk > (off_t)0) {
/*
* We still have space in this chunk.
*/
break;
}
} else {
/*
* Different disk, so use new file.
*/
db->filename = newstralloc(db->filename, arg_filename);
}
} else if(cmdargs->cmd == ABORT) {
abort_pending = 1;
errstr = newstralloc(errstr, cmdargs->argv[1]);
putresult(ABORT_FINISHED, "%s\n", handle);
rc = 0;
goto common_exit;
} else {
if(cmdargs->argc >= 1) {
q = quote_string(cmdargs->argv[0]);
} else {
q = stralloc(_("(no input?)"));
}
error(_("error [bad command after RQ-MORE-DISK: \"%s\"]"), q);
/*NOTREACHED*/
}
}
/*
* Time to use another file.
*/
/*
* First, open the new chunk file, and give it a new header
* that has no cont_filename pointer.
*/
g_snprintf(sequence, SIZEOF(sequence), "%d", db->filename_seq);
new_filename = newvstralloc(new_filename,
db->filename,
".",
sequence,
NULL);
tmp_filename = newvstralloc(tmp_filename,
new_filename,
".tmp",
NULL);
pc = strrchr(tmp_filename, '/');
g_assert(pc != NULL); /* Only a problem if db->filename has no /. */
*pc = '\0';
mkholdingdir(tmp_filename);
*pc = '/';
newfd = open(tmp_filename, O_RDWR|O_CREAT|O_TRUNC, 0600);
if (newfd == -1) {
int save_errno = errno;
char *m;
if(save_errno == ENOSPC) {
putresult(NO_ROOM, "%s %lld\n", handle,
(long long)(db->use+db->split_size-dumpsize));
db->use = (off_t)0; /* force RQ_MORE_DISK */
db->split_size = dumpsize;
continue;
}
m = vstrallocf(_("creating chunk holding file \"%s\": %s"),
tmp_filename,
strerror(errno));
errstr = quote_string(m);
amfree(m);
aclose(db->fd);
rc = 0;
goto common_exit;
}
save_type = file.type;
file.type = F_CONT_DUMPFILE;
file.cont_filename[0] = '\0';
if(write_tapeheader(newfd, &file)) {
int save_errno = errno;
char *m;
aclose(newfd);
if(save_errno == ENOSPC) {
putresult(NO_ROOM, "%s %lld\n", handle,
(long long)(db->use+db->split_size-dumpsize));
db->use = (off_t)0; /* force RQ_MORE DISK */
db->split_size = dumpsize;
continue;
}
m = vstrallocf(_("write_tapeheader file %s: %s"),
tmp_filename,
strerror(errno));
errstr = quote_string(m);
amfree(m);
rc = 0;
goto common_exit;
}
/*
* Now, update the header of the current file to point
* to the next chunk, and then close it.
*/
if (lseek(db->fd, (off_t)0, SEEK_SET) < (off_t)0) {
char *m = vstrallocf(_("lseek holding file %s: %s"),
db->filename,
strerror(errno));
errstr = quote_string(m);
amfree(m);
aclose(newfd);
rc = 0;
goto common_exit;
}
file.type = save_type;
strncpy(file.cont_filename, new_filename, SIZEOF(file.cont_filename));
file.cont_filename[SIZEOF(file.cont_filename)-1] = '\0';
if(write_tapeheader(db->fd, &file)) {
char * m = vstrallocf(_("write_tapeheader file \"%s\": %s"),
db->filename,
strerror(errno));
errstr = quote_string(m);
amfree(m);
aclose(newfd);
unlink(tmp_filename);
rc = 0;
goto common_exit;
}
file.type = F_CONT_DUMPFILE;
/*
* Now shift the file descriptor.
*/
aclose(db->fd);
db->fd = newfd;
newfd = -1;
/*
* Update when we need to chunk again
*/
if(db->use <= (off_t)DISK_BLOCK_KB) {
/*
* Cheat and use one more block than allowed so we can make
* some progress.
*/
db->split_size += (off_t)(2 * DISK_BLOCK_KB);
db->use = (off_t)0;
} else if(db->chunk_size > db->use) {
db->split_size += db->use;
db->use = (off_t)0;
} else {
db->split_size += db->chunk_size;
db->use -= db->chunk_size;
}
amfree(tmp_filename);
amfree(new_filename);
dumpsize += (off_t)DISK_BLOCK_KB;
filesize = (off_t)DISK_BLOCK_KB;
headersize += DISK_BLOCK_KB;
db->filename_seq++;
}
/*
* Write out the buffer
*/
size_to_write = (size_t)(db->datain - db->dataout);
written = full_write(db->fd, db->dataout, size_to_write);
if (written > 0) {
db->dataout += written;
dumpbytes += (off_t)written;
}
dumpsize += (dumpbytes / (off_t)1024);
filesize += (dumpbytes / (off_t)1024);
dumpbytes %= 1024;
if (written < size_to_write) {
if (errno != ENOSPC) {
char *m = vstrallocf(_("data write: %s"), strerror(errno));
errstr = quote_string(m);
amfree(m);
rc = 0;
goto common_exit;
}
/*
* NO-ROOM is informational only. Later, RQ_MORE_DISK will be
* issued to use another holding disk.
*/
putresult(NO_ROOM, "%s %lld\n", handle,
(long long)(db->use+db->split_size-dumpsize));
db->use = (off_t)0; /* force RQ_MORE_DISK */
db->split_size = dumpsize;
goto common_exit;
}
if (db->datain == db->dataout) {
/*
* We flushed the whole buffer so reset to use it all.
*/
db->datain = db->dataout = db->buf;
}
common_exit:
if (cmdargs)
free_cmdargs(cmdargs);
amfree(new_filename);
/*@i@*/ amfree(tmp_filename);
amfree(arg_filename);
return rc;
}
int
main(
int argc,
char ** argv)
{
static struct databuf db;
struct cmdargs *cmdargs;
int infd;
char *q = NULL;
char *filename = NULL;
off_t chunksize, use;
times_t runtime;
am_feature_t *their_features = NULL;
int a;
config_overrides_t *cfg_ovr = NULL;
char *cfg_opt = NULL;
char *m;
/*
* 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("chunker");
dbopen(DBG_SUBDIR_SERVER);
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
add_amanda_log_handler(amanda_log_stderr);
add_amanda_log_handler(amanda_log_trace_log);
cfg_ovr = extract_commandline_config_overrides(&argc, &argv);
if (argc > 1)
cfg_opt = argv[1];
config_init(CONFIG_INIT_EXPLICIT_NAME | CONFIG_INIT_USE_CWD, cfg_opt);
apply_config_overrides(cfg_ovr);
if (config_errors(NULL) >= CFGERR_WARNINGS) {
config_print_errors();
if (config_errors(NULL) >= CFGERR_ERRORS) {
g_critical(_("errors processing config file"));
}
}
safe_cd(); /* do this *after* config_init() */
check_running_as(RUNNING_AS_DUMPUSER);
dbrename(get_config_name(), DBG_SUBDIR_SERVER);
log_add(L_INFO, "%s pid %ld", get_pname(), (long)getpid());
g_fprintf(stderr,
_("%s: pid %ld executable %s version %s\n"),
get_pname(), (long) getpid(),
argv[0], VERSION);
fflush(stderr);
/* now, make sure we are a valid user */
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
cmdargs = getcmd();
if(cmdargs->cmd == START) {
if(cmdargs->argc <= 1)
error(_("error [dumper START: not enough args: timestamp]"));
chunker_timestamp = newstralloc(chunker_timestamp, cmdargs->argv[1]);
}
else {
log_add(L_INFO, "%s pid %ld", get_pname(), (long)getpid());
error(_("Didn't get START command"));
}
/* do {*/
cmdargs = getcmd();
switch(cmdargs->cmd) {
case QUIT:
break;
case PORT_WRITE:
/*
* PORT-WRITE
* handle
* filename
* host
* features
* disk
* level
* dumpdate
* chunksize
* progname
* use
* options
*/
a = 1;
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: handle]"));
/*NOTREACHED*/
}
handle = newstralloc(handle, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: filename]"));
/*NOTREACHED*/
}
filename = newstralloc(filename, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: hostname]"));
/*NOTREACHED*/
}
hostname = newstralloc(hostname, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: features]"));
/*NOTREACHED*/
}
am_release_feature_set(their_features);
their_features = am_string_to_feature(cmdargs->argv[a++]);
if (!their_features) {
error(_("error [chunker PORT-WRITE: invalid feature string]"));
/*NOTREACHED*/
}
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: diskname]"));
/*NOTREACHED*/
}
diskname = newstralloc(diskname, cmdargs->argv[a++]);
if (qdiskname)
amfree(qdiskname);
qdiskname = quote_string(diskname); /* qdiskname is a global */
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: level]"));
/*NOTREACHED*/
}
level = atoi(cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: dumpdate]"));
/*NOTREACHED*/
}
dumpdate = newstralloc(dumpdate, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: chunksize]"));
/*NOTREACHED*/
}
chunksize = OFF_T_ATOI(cmdargs->argv[a++]);
chunksize = am_floor(chunksize, (off_t)DISK_BLOCK_KB);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: progname]"));
/*NOTREACHED*/
}
progname = newstralloc(progname, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: use]"));
/*NOTREACHED*/
}
use = am_floor(OFF_T_ATOI(cmdargs->argv[a++]), DISK_BLOCK_KB);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: options]"));
/*NOTREACHED*/
}
options = newstralloc(options, cmdargs->argv[a++]);
if(a != cmdargs->argc) {
error(_("error [chunker PORT-WRITE: too many args: %d != %d]"),
cmdargs->argc, a);
/*NOTREACHED*/
}
if((infd = startup_chunker(filename, use, chunksize, &db)) < 0) {
q = quote_string(vstrallocf(_("[chunker startup failed: %s]"), errstr));
putresult(TRYAGAIN, "%s %s\n", handle, q);
error("startup_chunker failed: %s", errstr);
}
command_in_transit = NULL;
if(infd >= 0 && do_chunk(infd, &db)) {
char kb_str[NUM_STR_SIZE];
char kps_str[NUM_STR_SIZE];
double rt;
runtime = stopclock();
rt = g_timeval_to_double(runtime);
g_snprintf(kb_str, SIZEOF(kb_str), "%lld",
(long long)(dumpsize - (off_t)headersize));
g_snprintf(kps_str, SIZEOF(kps_str), "%3.1lf",
isnormal(rt) ? (double)dumpsize / rt : 0.0);
errstr = newvstrallocf(errstr, "sec %s kb %s kps %s",
walltime_str(runtime), kb_str, kps_str);
m = vstrallocf("[%s]", errstr);
q = quote_string(m);
amfree(m);
if(command_in_transit != NULL) {
cmdargs = command_in_transit;
command_in_transit = NULL;
} else {
cmdargs = getcmd();
}
switch(cmdargs->cmd) {
case DONE:
putresult(DONE, "%s %lld %s\n", handle,
(long long)(dumpsize - (off_t)headersize), q);
log_add(L_SUCCESS, "%s %s %s %d [%s]",
hostname, qdiskname, chunker_timestamp, level, errstr);
break;
case BOGUS:
case TRYAGAIN:
case FAILED:
case ABORT_FINISHED:
if(dumpsize > (off_t)DISK_BLOCK_KB) {
putresult(PARTIAL, "%s %lld %s\n", handle,
(long long)(dumpsize - (off_t)headersize),
q);
log_add(L_PARTIAL, "%s %s %s %d [%s]",
hostname, qdiskname, chunker_timestamp, level, errstr);
}
else {
errstr = newvstrallocf(errstr,
_("dumper returned %s"), cmdstr[cmdargs->cmd]);
amfree(q);
m = vstrallocf("[%s]",errstr);
q = quote_string(m);
amfree(m);
putresult(FAILED, "%s %s\n", handle, q);
log_add(L_FAIL, "%s %s %s %d [%s]",
hostname, qdiskname, chunker_timestamp, level, errstr);
}
default:
break;
}
amfree(q);
} else if(infd != -2) {
if(q == NULL) {
m = vstrallocf("[%s]", errstr);
q = quote_string(m);
amfree(m);
}
if(!abort_pending) {
putresult(FAILED, "%s %s\n", handle, q);
}
log_add(L_FAIL, "%s %s %s %d [%s]",
hostname, qdiskname, chunker_timestamp, level, errstr);
amfree(q);
}
amfree(filename);
amfree(db.filename);
break;
default:
if(cmdargs->argc >= 1) {
q = quote_string(cmdargs->argv[0]);
} else {
q = stralloc(_("(no input?)"));
}
putresult(BAD_COMMAND, "%s\n", q);
amfree(q);
break;
}
/* } while(cmdargs->cmd != QUIT); */
log_add(L_INFO, "pid-done %ld", (long)getpid());
amfree(errstr);
amfree(chunker_timestamp);
amfree(handle);
amfree(hostname);
amfree(diskname);
amfree(qdiskname);
amfree(dumpdate);
amfree(progname);
amfree(options);
free_cmdargs(cmdargs);
if (command_in_transit)
free_cmdargs(command_in_transit);
am_release_feature_set(their_features);
their_features = NULL;
dbclose();
return (0); /* exit */
}
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 = alloc(MAX_HOSTNAME_LENGTH+1);
if (gethostname(localhost, MAX_HOSTNAME_LENGTH) != 0) {
error(_("cannot determine local host name\n"));
/*NOTREACHED*/
}
localhost[MAX_HOSTNAME_LENGTH] = '\0';
config = newstralloc(config, 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 = stralloc(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 = stralloc(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 **) alloc((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':
config = newstralloc(config, optarg);
break;
case 's':
server_name = newstralloc(server_name, optarg);
break;
case 't':
tape_server_name = newstralloc(tape_server_name, optarg);
break;
case 'd':
tape_device_name = newstralloc(tape_device_name, 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;
if (sigaction(SIGINT, &act, &oact) != 0) {
error(_("error setting signal handler: %s"), strerror(errno));
/*NOTREACHED*/
}
service_name = stralloc2("amandaidx", SERVICE_SUFFIX);
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*/
}
amfree(service_name);
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 = stralloc2("FEATURES ", our_feature_string);
if(exchange(line) == 0) {
their_feature_string = stralloc(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 = stralloc2("DATE ", dump_date);
if (converse(line) == -1) {
aclose(server_socket);
exit(1);
}
amfree(line);
line = stralloc2("SCNF ", config);
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() && strcmp(cwd, mpt_guess) != 0)
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;
}
void
set_ptype(char *p)
{
ptype = newstralloc(ptype, p);
}
