X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=recover-src%2Fset_commands.c;h=2f659aec791bb9938c0a4489924554612a9522c7;hb=94a044f90357edefa6f4ae9f0b1d5885b0e34aee;hp=21603abb51058423705355f121e6ba579e0fa03a;hpb=3ab887b9bc819a846c75dd7f2ee5d41fac22b19f;p=debian%2Famanda

diff --git a/recover-src/set_commands.c b/recover-src/set_commands.c
index 21603ab..2f659ae 100644
--- a/recover-src/set_commands.c
+++ b/recover-src/set_commands.c
@@ -24,12 +24,13 @@
  * file named AUTHORS, in the root directory of this distribution.
  */
 /*
- * $Id: set_commands.c,v 1.11.2.3.4.2.2.7 2004/02/11 13:15:29 martinea Exp $
+ * $Id: set_commands.c,v 1.26 2006/07/05 13:14:58 martinea Exp $
  *
  * implements the "set" commands in amrecover
  */
 
 #include "amanda.h"
+#include "util.h"
 #include "amrecover.h"
 
 #ifdef SAMBA_CLIENT
@@ -37,10 +38,12 @@ extern unsigned short samba_extract_method;
 #endif /* SAMBA_CLIENT */
 
 /* sets a date, mapping given date into standard form if needed */
-int set_date(date)
-char *date;
+int
+set_date(
+    char *	date)
 {
     char *cmd = NULL;
+    char *qdisk_path;
 
     clear_dir_list();
 
@@ -52,7 +55,9 @@ char *date;
        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);
+	qdisk_path = quote_string(disk_path);
+	cmd = newstralloc2(cmd, "OISD ", qdisk_path);
+	amfree(qdisk_path);
 	if (exchange(cmd) == -1)
 	    exit(1);
 	if (server_happy())
@@ -61,74 +66,100 @@ char *date;
 	}
 	else
 	{
-	    printf("No index records for cwd on new date\n");
-	    printf("Setting cwd to mount point\n");
+	    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;
 }
 
 
-void set_host(host)
-char *host;
+void
+set_host(
+    const char *host)
 {
     char *cmd = NULL;
-    struct hostent *hp;
+    struct hostent *hp = NULL;
     char **hostp;
     int found_host = 0;
+    char *uqhost = unquote_string(host);
 
     if (is_extract_list_nonempty())
     {
-	printf("Must clear extract list before changing host\n");
+	g_printf(_("Must clear extract list before changing host\n"));
 	return;
     }
 
-    cmd = stralloc2("HOST ", host);
+    /*
+     * 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;
-    }
-    else
-    {
-	/*
-	 * Try converting the given host to a fully qualified name
-	 * and then try each of the aliases.
-	 */
-	if ((hp = gethostbyname(host)) != NULL) {
+
+    /*
+     * Try converting the given host to a fully qualified, canonical
+     * name.
+     */
+    if (!found_host) {
+	if ((hp = gethostbyname(uqhost)) != NULL) {
 	    host = hp->h_name;
-	    printf("Trying host %s ...\n", host);
+	    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
+	}
+    }
+
+    /*
+     * 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++)
 	    {
-	        for (hostp = hp->h_aliases; (host = *hostp) != NULL; hostp++)
-	        {
-		    printf("Trying host %s ...\n", host);
-		    cmd = newstralloc2(cmd, "HOST ", host);
-		    if (converse(cmd) == -1)
-		        exit(1);
-		    if(server_happy())
-		    {
-		        found_host = 1;
-		        break;
-		    }
+		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)
-    {
+
+    /* 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);
@@ -136,30 +167,51 @@ char *host;
 	clear_dir_list();
     }
     amfree(cmd);
+    amfree(uqhost);
 }
 
+void
+list_host(void)
+{
+    char *cmd = NULL;
+
+    cmd = stralloc("LISTHOST");
+    if (converse(cmd) == -1)
+        exit(1);
+    amfree(cmd);
+}
 
-void set_disk(dsk, mtpt)
-char *dsk;
-char *mtpt;
+void
+set_disk(
+    char *	dsk,
+    char *	mtpt)
 {
     char *cmd = NULL;
+    char *qdsk;
+    char *uqdsk;
+    char *uqmtpt = NULL;
 
     if (is_extract_list_nonempty())
     {
-	printf("Must clear extract list before changing disk\n");
+	g_printf(_("Must clear extract list before changing disk\n"));
 	return;
     }
 
     /* if mount point specified, check it is valid */
-    if ((mtpt != NULL) && (*mtpt != '/'))
-    {
-	printf("Mount point \"%s\" invalid - must start with /\n", mtpt);
-	return;
+    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();
-    cmd = stralloc2("DISK ", dsk);
+    uqdsk = unquote_string(dsk);
+    qdsk = quote_string(uqdsk);
+    cmd = stralloc2("DISK ", qdsk);
+    amfree(qdsk);
     if (converse(cmd) == -1)
 	exit(1);
     amfree(cmd);
@@ -167,14 +219,14 @@ char *mtpt;
     if (!server_happy())
 	return;
 
-    disk_name = newstralloc(disk_name, dsk);
+    disk_name = newstralloc(disk_name, uqdsk);
     if (mtpt == NULL)
     {
 	/* mount point not specified */
-	if (*dsk == '/')
+	if (*uqdsk == '/')
 	{
 	    /* disk specified by mount point, hence use it */
-	    mount_point = newstralloc(mount_point, dsk);
+	    mount_point = newstralloc(mount_point, uqdsk);
 	}
 	else
 	{
@@ -185,7 +237,7 @@ char *mtpt;
     else
     {
 	/* mount point specified */
-	mount_point = newstralloc(mount_point, mtpt);
+	mount_point = newstralloc(mount_point, uqmtpt);
     }
 
     /* set the working directory to the mount point */
@@ -202,20 +254,28 @@ char *mtpt;
     }
     else
     {
-	printf("No index records for disk for specified date\n");
-	printf("If date correct, notify system administrator\n");
+	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);
 }
 
-void list_disk(amdevice)
-char *amdevice;
+void
+list_disk(
+    char *	amdevice)
 {
     char *cmd = NULL;
+    char *qamdevice, *uqamdevice;
 
     if(amdevice) {
-	cmd = stralloc2("LISTDISK ", amdevice);
+	uqamdevice = unquote_string(amdevice);
+	qamdevice = quote_string(uqamdevice);
+	cmd = stralloc2("LISTDISK ", qamdevice);
+	amfree(uqamdevice);
+	amfree(qamdevice);
 	if (converse(cmd) == -1)
 	    exit(1);
 	amfree(cmd);
@@ -228,24 +288,38 @@ char *amdevice;
     }
 }
 
-void cd_glob(glob)
-char *glob;
+void
+local_cd(
+    char *dir)
+{
+    char *uqdir = unquote_string(dir);
+    if (chdir(uqdir) == -1) {
+	perror(uqdir);
+    }
+    amfree(uqdir);
+}
+
+void
+cd_glob(
+    char *	glob)
 {
     char *regex;
     char *regex_path;
     char *s;
+    char *uqglob;
 
     char *path_on_disk = NULL;
 
     if (disk_name == NULL) {
-	printf("Must select disk before changing directory\n");
+	g_printf(_("Must select disk before changing directory\n"));
 	return;
     }
 
-    regex = glob_to_regex(glob);
-    dbprintf(("cd_glob (%s) -> %s\n", glob, regex));
+    uqglob = unquote_string(glob);
+    regex = glob_to_regex(uqglob);
+    dbprintf(_("cd_glob (%s) -> %s\n"), uqglob, regex);
     if ((s = validate_regexp(regex)) != NULL) {
-        printf("\"%s\" is not a valid shell wildcard pattern: ", glob);
+        g_printf(_("\"%s\" is not a valid shell wildcard pattern: "), glob);
         puts(s);
 	amfree(regex);
         return;
@@ -272,65 +346,89 @@ char *glob;
         amfree(clean_disk_path);
     }
 
-    cd_dir(path_on_disk, glob);
+    cd_dir(path_on_disk, uqglob);
 
     amfree(regex_path);
     amfree(path_on_disk);
+    amfree(uqglob);
 }
 
-void cd_regex(regex)
-char *regex;
+void
+cd_regex(
+    char *	regex)
 {
     char *s;
+    char *uq_orig_regex;
+    char *uqregex;
+    int  len_uqregex;
 
     char *path_on_disk = NULL;
 
     if (disk_name == NULL) {
-	printf("Must select disk before changing directory\n");
+	g_printf(_("Must select disk before changing directory\n"));
 	return;
     }
 
-    if ((s = validate_regexp(regex)) != NULL) {
-	printf("\"%s\" is not a valid regular expression: ", regex);
+    uq_orig_regex = unquote_string(regex);
+    uqregex = stralloc(uq_orig_regex);
+
+    /* Add a terminating '/' if it is not there, maybe before a '$' */
+    len_uqregex = strlen(uqregex);
+    if (uqregex[len_uqregex-1] == '$') {
+	if (uqregex[len_uqregex-2] != '/') {
+	    uqregex[len_uqregex-1] = '\0';
+	    strappend(uqregex, "/$");
+	}
+    } else if (uqregex[len_uqregex-1] != '/') {
+	//uqregex[len_uqregex-1] = '\0';
+	strappend(uqregex, "/");
+    }
+    if ((s = validate_regexp(uqregex)) != NULL) {
+	g_printf(_("\"%s\" is not a valid regular expression: "), uq_orig_regex);
+	amfree(uqregex);
 	puts(s);
 	return;
     }
 
     /* convert path (assumed in cwd) to one on disk */
     if (strcmp(disk_path, "/") == 0)
-        path_on_disk = stralloc2("/", regex);
+        path_on_disk = stralloc2("/", uqregex);
     else {
         char *clean_disk_path = clean_regex(disk_path);
         path_on_disk = vstralloc(clean_disk_path, "/", regex, NULL);
         amfree(clean_disk_path);
     }
 
-    cd_dir(path_on_disk, regex);
+    cd_dir(path_on_disk, uq_orig_regex);
 
     amfree(path_on_disk);
+    amfree(uqregex);
+    amfree(uq_orig_regex);
 }
 
-void cd_dir(path_on_disk, default_dir)
-char *path_on_disk;
-char *default_dir;
+void
+cd_dir(
+    char *	path_on_disk,
+    char *	default_dir)
 {
-    char *path_on_disk_slash = NULL;
     char *dir = NULL;
-
+    char *s;
     int nb_found;
     size_t i;
 
     DIR_ITEM *ditem;
 
-    path_on_disk_slash = stralloc2(path_on_disk, "/");
+    if ((s = validate_regexp(path_on_disk)) != NULL) {
+	set_directory(default_dir);
+	return;
+    }
 
     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))
+	if (match(path_on_disk, ditem->path))
 	{
 	    i = strlen(ditem->path);
 	    if((i > 0 && ditem->path[i-1] == '/')
@@ -343,14 +441,15 @@ char *default_dir;
 		    dir[strlen(dir)-1] = '\0'; /* remove last / */
 		/* remove everything before the last / */
 		dir1 = rindex(dir,'/');
-		dir1++;
-		dir2 = stralloc(dir1);
-		amfree(dir);
-		dir = dir2;
+		if (dir1) {
+		    dir1++;
+		    dir2 = stralloc(dir1);
+		    amfree(dir);
+		    dir = dir2;
+		}
 	    }
 	}
     }
-    amfree(path_on_disk_slash);
 
     if(nb_found==0) {
 	set_directory(default_dir);
@@ -359,16 +458,18 @@ char *default_dir;
 	set_directory(dir);
     }
     else {
-	printf("Too many directory\n");
+	g_printf(_("Too many directories\n"));
     }
     amfree(dir);
 }
 
-void set_directory(dir)
-char *dir;
+void
+set_directory(
+    char *	dir)
 {
     char *cmd = NULL;
     char *new_dir = NULL;
+    char *qnew_dir;
     char *dp, *de;
     char *ldir = NULL;
 
@@ -376,11 +477,13 @@ char *dir;
     if(strcmp(dir,".")==0) {
 	show_directory();		/* say where we are */
 	return;
+	/*NOTREACHED*/
     }
 
     if (disk_name == NULL) {
-	printf("Must select disk before setting directory\n");
+	g_printf(_("Must select disk before setting directory\n"));
 	return;
+	/*NOTREACHED*/
     }
 
     ldir = stralloc(dir);
@@ -398,10 +501,11 @@ char *dir;
 	{
 	    if (strncmp(mount_point, ldir, strlen(mount_point)) != 0)
 	    {
-		printf("Invalid directory - Can't cd outside mount point \"%s\"\n",
+		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) {
@@ -433,11 +537,14 @@ char *dir;
 	if (strcmp(dp, "..") == 0) {
 	    if (strcmp(new_dir, "/") == 0) {
 		/* at top of disk */
-		printf("Invalid directory - Can't cd outside mount point \"%s\"\n",
+		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)
@@ -450,17 +557,24 @@ char *dir;
 		*de = '\0';
  	    }
 	} else {
+	    /*@ignore@*/
 	    if (strcmp(new_dir, "/") != 0) {
 		strappend(new_dir, "/");
 	    }
 	    strappend(new_dir, ldir);
+	    /*@end@*/
 	}
     }
 
-    cmd = stralloc2("OISD ", new_dir);
-    if (exchange(cmd) == -1)
+    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);
@@ -469,101 +583,139 @@ char *dir;
     }
     else
     {
-	printf("Invalid directory - %s\n", dir);
+	g_printf(_("Invalid directory - %s\n"), dir);
     }
 
+    /*@ignore@*/
     amfree(new_dir);
     amfree(ldir);
+    /*@end@*/
 }
 
 
 /* prints the current working directory */
-void show_directory P((void))
+void
+show_directory(void)
 {
     if (mount_point == NULL || disk_path == NULL)
-        printf("Must select disk first\n");
+        g_printf(_("Must select disk first\n"));
     else if (strcmp(mount_point, "/") == 0)
-	printf("%s\n", disk_path);
+	g_printf("%s\n", disk_path);
     else if (strcmp(disk_path, "/") == 0)
-	printf("%s\n", mount_point);
+	g_printf("%s\n", mount_point);
     else
-	printf("%s%s\n", mount_point, disk_path);
+	g_printf("%s%s\n", mount_point, disk_path);
 }
 
 
-/* set the tape server and device */
-void set_tape (tape)
-    char *tape;
+/* set the tape server and device (deprecated version) */
+void
+set_tape(
+    char *	tape)
 {
-    char *tapedev = strchr(tape, ':');
+    char *uqtape = unquote_string(tape);
+    char *tapedev = strchr(uqtape, ':');
+    char *host = NULL;
+
+    g_printf(_("NOTE: 'settape' is deprecated; use setdevice instead.\n"));
 
     if (tapedev)
     {
-	if (tapedev != tape) {
+	/* This command is deprecated because this parsing is going to fall 
+	 * behind the list of available device names at some point, or to shadow
+	 * an interesting hostname (wouldn't 'tape' be a good name for a 
+	 * tape server?) */
+	if (tapedev != uqtape) {
 	    if((strchr(tapedev+1, ':') == NULL) &&
-	       (strncmp(tape, "null:", 5) == 0 ||
-		strncmp(tape, "rait:", 5) == 0 ||
-		strncmp(tape, "file:", 5) == 0 ||
-		strncmp(tape, "tape:", 5) == 0)) {
-		tapedev = tape;
+	       (strncmp_const(uqtape, "null:") == 0 ||
+		strncmp_const(uqtape, "rait:") == 0 ||
+		strncmp_const(uqtape, "file:") == 0 ||
+		strncmp_const(uqtape, "s3:") == 0 ||
+		strncmp_const(uqtape, "tape:") == 0)) {
+		tapedev = uqtape;
 	    }
 	    else {
 		*tapedev = '\0';
-		tape_server_name = newstralloc(tape_server_name, tape);
+		host = stralloc(uqtape);
 		++tapedev;
 	    }
-	} else { /* reset server_name if start with : */
-	    amfree(tape_server_name);
+	} else {
 	    ++tapedev;
 	}
     } else
-	tapedev = tape;
+	tapedev = uqtape;
     
     if (tapedev[0])
     {
 	if (strcmp(tapedev, "default") == 0)
-	    amfree(tape_device_name);
-	else
-	    tape_device_name = newstralloc(tape_device_name, tapedev);
+	    tapedev = NULL;
     }
 
+    /* call out to the new version */
+    set_device(host, tapedev);
+
+    amfree(host);
+    amfree(uqtape);
+}
+
+/* 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)
-	printf ("Using tape \"%s\"", tape_device_name);
+	g_printf (_("Using tape \"%s\""), tape_device_name);
     else
-	printf ("Using default tape");
+	g_printf (_("Using default tape"));
 
     if (tape_server_name)
-	printf (" from server %s.\n", tape_server_name);
+	g_printf (_(" from server %s.\n"), tape_server_name);
     else
-	printf (".\nTape server unspecified, assumed to be %s.\n",
+	g_printf (_(".\nTape server unspecified, assumed to be %s.\n"),
 		server_name);
 }
 
-void set_mode (mode)
-int mode;
+void
+set_mode(
+    int		mode)
 {
 #ifdef SAMBA_CLIENT
   if (mode == SAMBA_SMBCLIENT) {
-    printf ("SAMBA dumps will be extracted using smbclient\n");
+    g_printf (_("SAMBA dumps will be extracted using smbclient\n"));
     samba_extract_method = SAMBA_SMBCLIENT;
   } else {
     if (mode == SAMBA_TAR) {
-      printf ("SAMBA dumps will be extracted as TAR dumps\n");
+      g_printf (_("SAMBA dumps will be extracted as TAR dumps\n"));
       samba_extract_method = SAMBA_TAR;
     }
   }
+#else
+  (void)mode;	/* Quiet unused parameter warning */
 #endif /* SAMBA_CLIENT */
 }
 
-void show_mode (void) 
+void
+show_mode(void) 
 {
 #ifdef SAMBA_CLIENT
-  printf ("SAMBA dumps are extracted ");
+  g_printf (_("SAMBA dumps are extracted "));
 
   if (samba_extract_method == SAMBA_TAR) {
-    printf (" as TAR dumps\n");
+    g_printf (_(" as TAR dumps\n"));
   } else {
-    printf ("using smbclient\n");
+    g_printf (_("using smbclient\n"));
   }
 #endif /* SAMBA_CLIENT */
 }