/*
* Amanda, The Advanced Maryland Automatic Network Disk Archiver
* Copyright (c) 1991-1999 University of Maryland at College Park
+ * Copyright (c) 2007-2012 Zmanda, Inc. All Rights Reserved.
* All Rights Reserved.
*
* Permission to use, copy, modify, distribute, and sell this software and its
#include "util.h"
#include "holding.h"
#include "timestamp.h"
-
-#define chunker_debug(i, ...) do { \
- if ((i) <= debug_chunker) { \
- dbprintf(__VA_ARGS__); \
- } \
-} while (0)
+#include "sockaddr-util.h"
#ifndef SEEK_SET
#define SEEK_SET 0
static void databuf_init(struct databuf *, int, char *, off_t, off_t);
static int databuf_flush(struct databuf *);
-static int startup_chunker(char *, off_t, off_t, struct databuf *, int *);
-static int do_chunk(int, struct databuf *, int);
+static int startup_chunker(char *, off_t, off_t, struct databuf *, int *, int *);
+static int do_chunk(int, struct databuf *, int, int);
+/* we use a function pointer for full_write, so that we can "shim" in
+ * full_write_with_fake_enospc for testing */
+static size_t (*db_full_write)(int fd, const void *buf, size_t count);
+static size_t full_write_with_fake_enospc(int fd, const void *buf, size_t count);
+static off_t fake_enospc_at_byte = -1;
int
main(
config_overrides_t *cfg_ovr = NULL;
char *cfg_opt = NULL;
char *m;
+ int header_socket;
int data_socket;
/*
log_add(L_INFO, "%s pid %ld", get_pname(), (long)getpid());
error(_("Didn't get START command"));
}
+ free_cmdargs(cmdargs);
+
+ /* set up a fake ENOSPC for testing purposes. Note that this counts
+ * headers as well as data written to disk. */
+ if (getenv("CHUNKER_FAKE_ENOSPC_AT")) {
+ char *env = getenv("CHUNKER_FAKE_ENOSPC_AT");
+ fake_enospc_at_byte = (off_t)atoi(env); /* these values are never > MAXINT */
+ db_full_write = full_write_with_fake_enospc;
+ g_debug("will trigger fake ENOSPC at byte %d", (int)fake_enospc_at_byte);
+ } else {
+ db_full_write = full_write;
+ }
/* do {*/
cmdargs = getcmd();
}
if ((header_fd = startup_chunker(filename, use, chunksize, &db,
- &data_socket)) < 0) {
+ &header_socket, &data_socket)) < 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 (header_fd >= 0 && do_chunk(header_fd, &db, data_socket)) {
+ if (header_fd >= 0 && do_chunk(header_fd, &db, header_socket, data_socket)) {
char kb_str[NUM_STR_SIZE];
char kps_str[NUM_STR_SIZE];
double rt;
m = vstrallocf("[%s]", errstr);
q = quote_string(m);
amfree(m);
+ free_cmdargs(cmdargs);
if(command_in_transit != NULL) {
cmdargs = command_in_transit;
command_in_transit = NULL;
off_t use,
off_t chunksize,
struct databuf * db,
+ int *headersocket,
int *datasocket)
{
int header_fd, outfd;
int header_socket, data_socket;
int result;
struct addrinfo *res;
+ struct addrinfo *res_addr;
+ sockaddr_union *addr = NULL;
+ sockaddr_union data_addr;
header_port = 0;
data_port = 0;
gai_strerror(result));
return -1;
}
- header_socket = stream_server(res->ai_family, &header_port, 0,
+ for (res_addr = res; res_addr != NULL; res_addr = res_addr->ai_next) {
+ g_debug("ra: %s\n", str_sockaddr((sockaddr_union*)res_addr->ai_addr));
+ if (res_addr->ai_family == AF_INET) {
+ addr = (sockaddr_union *)res_addr->ai_addr;
+ break;
+ }
+ }
+ if (!addr) {
+ addr = (sockaddr_union *)res->ai_addr;
+ g_debug("addr: %s\n", str_sockaddr(addr));
+ }
+
+ header_socket = stream_server(SU_GET_FAMILY(addr), &header_port, 0,
STREAM_BUFSIZE, 0);
- data_socket = stream_server(res->ai_family, &data_port, 0,
+ data_socket = stream_server(SU_GET_FAMILY(addr), &data_port, 0,
STREAM_BUFSIZE, 0);
+ copy_sockaddr(&data_addr, addr);
+
+ SU_SET_PORT(&data_addr, data_port);
+
if (res) freeaddrinfo(res);
if (header_socket < 0) {
return -1;
}
- putresult(PORT, "%d 127.0.0.1:%d\n", header_port, data_port);
+ putresult(PORT, "%d %s\n", header_port, str_sockaddr(&data_addr));
header_fd = stream_accept(header_socket, CONNECT_TIMEOUT, 0,
STREAM_BUFSIZE);
aclose(data_socket);
return -1;
}
- aclose(header_socket);
tmp_filename = vstralloc(filename, ".tmp", NULL);
pc = strrchr(tmp_filename, '/');
amfree(tmp_filename);
databuf_init(db, outfd, filename, use, chunksize);
db->filename_seq++;
+ *headersocket = header_socket;
*datasocket = data_socket;
return header_fd;
}
do_chunk(
int header_fd,
struct databuf * db,
+ int header_socket,
int data_socket)
{
size_t nread;
* chunk code will rewrite it.
*/
nread = full_read(header_fd, header_buf, SIZEOF(header_buf));
+ aclose(header_fd);
+ aclose(header_socket);
if (nread != sizeof(header_buf)) {
if(errno != 0) {
errstr = vstrallocf(_("cannot read header: %s"), strerror(errno));
aclose(data_socket);
return 0;
}
- aclose(data_socket);
/*
* We've written the file header. Now, just write data until the
db->datain += nread;
while(db->dataout < db->datain) {
if(!databuf_flush(db)) {
+ aclose(data_fd);
+ aclose(data_socket);
return 0;
}
}
}
while(db->dataout < db->datain) {
if(!databuf_flush(db)) {
+ aclose(data_fd);
+ aclose(data_socket);
return 0;
}
}
dumpsize += (off_t)1; /* count partial final KByte */
filesize += (off_t)1;
}
+ aclose(data_fd);
+ aclose(data_socket);
return 1;
}
aclose(newfd);
if(save_errno == ENOSPC) {
+ if (unlink(tmp_filename) < 0) {
+ g_debug("could not delete '%s'; ignoring", tmp_filename);
+ }
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;
+ file.type = save_type;
continue;
}
m = vstrallocf(_("write_tapeheader file %s: %s"),
* Write out the buffer
*/
size_to_write = (size_t)(db->datain - db->dataout);
- written = full_write(db->fd, db->dataout, size_to_write);
+ written = db_full_write(db->fd, db->dataout, size_to_write);
if (written > 0) {
db->dataout += written;
dumpbytes += (off_t)written;
if (!buffer) /* this shouldn't happen */
error(_("header does not fit in %zd bytes"), (size_t)DISK_BLOCK_BYTES);
- written = full_write(outfd, buffer, DISK_BLOCK_BYTES);
+ written = db_full_write(outfd, buffer, DISK_BLOCK_BYTES);
amfree(buffer);
if(written == DISK_BLOCK_BYTES) return 0;
return (ssize_t)-1;
}
+
+static size_t
+full_write_with_fake_enospc(
+ int fd,
+ const void *buf,
+ size_t count)
+{
+ size_t rc;
+
+ //g_debug("HERE %zd %zd", count, (size_t)fake_enospc_at_byte);
+
+ if (count <= (size_t)fake_enospc_at_byte) {
+ fake_enospc_at_byte -= count;
+ return full_write(fd, buf, count);
+ }
+
+ /* if we get here, the caller has requested a size that is less
+ * than fake_enospc_at_byte. */
+ count = fake_enospc_at_byte;
+ g_debug("returning fake ENOSPC");
+
+ if (fake_enospc_at_byte) {
+ rc = full_write(fd, buf, fake_enospc_at_byte);
+ if (rc == (size_t)fake_enospc_at_byte) {
+ /* full_write succeeded, so fake a failure */
+ errno = ENOSPC;
+ }
+ } else {
+ /* no bytes to write; just fake an error */
+ errno = ENOSPC;
+ rc = 0;
+ }
+
+ /* switch back to calling full_write directly */
+ fake_enospc_at_byte = -1;
+ db_full_write = full_write;
+ return rc;
+}
projects / debian / amanda / blobdiff