int sendDir(int fd, char * dir_name)
{
DIR *source = NULL;
struct dirent *ent = NULL;
char name[FILENAME_SIZE];
source = opendir(dir_name);
if(source == NULL)
{
perror("Fail to opendir\n");
return 0;
}
while((ent = readdir(source)) != NULL)
{
if((strcmp(ent->d_name,"..") != 0) && (strcmp(ent->d_name, ".") != 0))
{
strcpy(name,"\0");
strcat(name, dir_name);
strcat(name,"/");
strcat(name,ent->d_name);
if(ent->d_type == 4)
sendDir(fd, name);
else if(ent->d_type == 8)
sendFile(fd, name);
}
}
return 0;
}
bool Processor::sendFile(const char *filepath)
{
File file;
Header header;
struct stat sbuf;
char buf[256];
char *path = getcwd(buf,256);
file.setPath(path);
file.type(filepath,&sbuf);
if(S_ISREG(sbuf.st_mode))
{
return sendRegFile(filepath,file,header);
}
if(S_ISDIR(sbuf.st_mode))
{
return sendDir(filepath,file,header);
}
return false;
}
/***********************************back up process***********************************/
int backup(int fd, char * in_file, char *out_file, int trans_flag)
{
struct msg_head msg;
unsigned char buf[MAX_BUF_SIZE];
size_t rcv_size;
/***********************store the backup name*************************/
bzero(buf, MAX_BUF_SIZE);
strncpy(buf, out_file, strlen(out_file));
printf("OUT_FILE length: %d\n", strlen(out_file));
msg.type = 0;
msg.len = strlen(out_file);
if(send(fd, &msg, sizeof(msg), 0) < 0)
{
perror("Send file name error\n");
exit(1);
}
while((rcv_size = recv(fd, buf, MAX_BUF_SIZE, 0)) < MAX_BUF_SIZE)
{
if(rcv_size < 0 )
{
perror("Recy check information error\n");
exit(1);
}
}
memcpy(&msg, buf, sizeof(msg));
if(trans_flag == 0)
{
if(sendFile(fd, in_file) == 1)
printf("Success to send file: %s\n", in_file);
else
printf("Failed to send file: %s\n", in_file);
}
else if(trans_flag == 1)
{
if(sendDir(fd, in_file) == 1)
printf("Success to send Dir: %s\n", in_file);
else
printf("Failed to send Dir: %s\n", in_file);
}
return 0;
}
void key_Tick() {
unsigned char input = GetKeypadKey();
if(input == 'A') {
input = ' ';
} else if(input == 'B') {
input = '.';
} else if(input == '#') {
photoValueL = calibrate(0x02) - 4;
photoValueR = calibrate(0x04) - 4;
photoValueD = calibrate(0x01) - 4;
photoValueU = calibrate(0x00) - 4;
photoValueD2 = calibrate(0x06) - 4;
photoValueU2 = calibrate(0x05) - 4;
}
if(input != '\0') {
sendDir(input);
}
}
void
ProtocolDataTransfer::run()
{
switch (m_SocketMode)
{
case Slave:
if (accept() == -1)
{
return;
}
break;
case Active:
if (connectTo() == -1)
{
return;
}
break;
default:
return;
}
switch (m_Protocol)
{
case DoSendFile:
sendFile();
break;
case DoRecvFile:
recvFile();
break;
case DoSendDir:
sendDir();
break;
case DoRecvDir:
recvDir();
break;
case DoSendList:
sendList();
break;
case DoRecvList:
recvList();
break;
}
}
void FileSendProgressDialog::nextFileRequested()
{
//qDebug() << "nextFileRequested : entered"<<m_writingData << (m_fileList.empty() ? "" : m_fileList[0].fileName);
if (m_socket->bytesAvailable())
{
qDebug() << "nextFileRequested : parsing header";
FileInfo next = parseIncomingFileRequest(m_socket->readAll());
if (next.fileID != -1)
m_fileList << next;
qDebug() << "nextFileRequested : header parse done";
}
if (!m_fileList.empty())
{
if (m_writingData)
{
//qDebug() << "nextFileRequested exiting";
return;
}
//qDebug() << "nextFileRequested : attempting send";
FileInfo first = m_fileList.takeFirst();
//qDebug() << first.fileName << first.type;
if (first.type == QOM_FILE_REGULAR)
sendFile(first);
else if (first.type == QOM_FILE_DIR)
sendDir(first);
else if (first.type == QOM_FILE_RETPARENT)
{
//qDebug() << fileUtils()->formatFileHeader(first).toAscii();
writeBlock(fileUtils()->formatFileHeader(first).toAscii());
}
if (m_sendBuffer.size()>0)
writeBlock("");
nextFileRequested();
}
else
{
qDebug() << "We're done sending";
accept();
}
}
void ud_Tick(){
switch(ud_state) {
case initud:
ud_state = u0;
break;
case u0:
if(checkPhotoValue(0x00) && !checkPhotoValue(0x01)) {
ud_state = u1;
}
break;
case u1:
if(!checkPhotoValue(0x00) && !checkPhotoValue(0x01)) {
ud_state = u0;
} else if(!checkPhotoValue(0x00) && checkPhotoValue(0x01)) {
ud_state = u2;
sendDir(ud);
} else {
ud_state = u1;
}
break;
case u2:
ud_state = u0;
break;
default:
ud_state = initud;
break;
}
switch(ud_state) {
case u0:
PORTC = 0x00;
break;
case u2:
PORTC = 0x08;
break;
}
}
void du_Tick(){
switch(du_state) {
case initdu:
du_state = d0;
break;
case d0:
if(checkPhotoValue(0x01) && !checkPhotoValue(0x00)) {
du_state = d1;
}
break;
case d1:
if(!checkPhotoValue(0x01) && !checkPhotoValue(0x00)) {
du_state = d0;
} else if(!checkPhotoValue(0x01) && checkPhotoValue(0x00)) {
du_state = d2;
sendDir(du);
} else {
du_state = d1;
}
break;
case d2:
du_state = d0;
break;
default:
du_state = initdu;
break;
}
switch(du_state) {
case d0:
PORTC = 0x00;
break;
case d2:
PORTC = 0x04;
break;
}
}
void rl_Tick(){
switch(rl_state) {
case initrl:
rl_state = r0;
break;
case r0:
if(checkPhotoValue(0x04) && !checkPhotoValue(0x02)) {
rl_state = r1;
}
break;
case r1:
if(!checkPhotoValue(0x04) && !checkPhotoValue(0x02)) {
rl_state = r0;
} else if((!checkPhotoValue(0x04) && checkPhotoValue(0x02))) {
rl_state = r2;
sendDir(rl);
} else {
rl_state = r1;
}
break;
case r2:
rl_state = r0;
break;
default:
rl_state = initrl;
break;
}
switch(rl_state) {
case r0:
//PORTC = 0x00;
break;
case r2:
//PORTC = 0x02;
break;
}
}
/*
void du2_Init(){
du2_state = initdu2;
}
void ud2_Init(){
ud2_state = initud2;
}
*/
void lr_Tick(){
switch(lr_state) {
case initlr:
lr_state = l0;
break;
case l0:
if(checkPhotoValue(0x02) && !checkPhotoValue(0x04)) {
lr_state = l1;
}
break;
case l1:
if(!checkPhotoValue(0x02) && !checkPhotoValue(0x04)) {
lr_state = l0;
} else if((!checkPhotoValue(0x02) && checkPhotoValue(0x04))) {
lr_state = l2;
sendDir(lr);
} else {
lr_state = l1;
}
break;
case l2:
lr_state = l0;
break;
default:
lr_state = initlr;
break;
}
switch(lr_state) {
case l0:
//PORTC = 0x00;
break;
case l2:
//PORTC = 0x01;
break;
}
}
/*
* Actually do a base backup for the specified tablespaces.
*
* This is split out mainly to avoid complaints about "variable might be
* clobbered by longjmp" from stupider versions of gcc.
*/
static void
perform_base_backup(basebackup_options *opt, DIR *tblspcdir)
{
XLogRecPtr startptr;
TimeLineID starttli;
XLogRecPtr endptr;
TimeLineID endtli;
char *labelfile;
backup_started_in_recovery = RecoveryInProgress();
startptr = do_pg_start_backup(opt->label, opt->fastcheckpoint, &starttli,
&labelfile);
SendXlogRecPtrResult(startptr, starttli);
PG_ENSURE_ERROR_CLEANUP(base_backup_cleanup, (Datum) 0);
{
List *tablespaces = NIL;
ListCell *lc;
struct dirent *de;
tablespaceinfo *ti;
/* Collect information about all tablespaces */
while ((de = ReadDir(tblspcdir, "pg_tblspc")) != NULL)
{
char fullpath[MAXPGPATH];
char linkpath[MAXPGPATH];
int rllen;
/* Skip special stuff */
if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
continue;
snprintf(fullpath, sizeof(fullpath), "pg_tblspc/%s", de->d_name);
#if defined(HAVE_READLINK) || defined(WIN32)
rllen = readlink(fullpath, linkpath, sizeof(linkpath));
if (rllen < 0)
{
ereport(WARNING,
(errmsg("could not read symbolic link \"%s\": %m",
fullpath)));
continue;
}
else if (rllen >= sizeof(linkpath))
{
ereport(WARNING,
(errmsg("symbolic link \"%s\" target is too long",
fullpath)));
continue;
}
linkpath[rllen] = '\0';
ti = palloc(sizeof(tablespaceinfo));
ti->oid = pstrdup(de->d_name);
ti->path = pstrdup(linkpath);
ti->size = opt->progress ? sendDir(linkpath, strlen(linkpath), true) : -1;
tablespaces = lappend(tablespaces, ti);
#else
/*
* If the platform does not have symbolic links, it should not be
* possible to have tablespaces - clearly somebody else created
* them. Warn about it and ignore.
*/
ereport(WARNING,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("tablespaces are not supported on this platform")));
#endif
}
/* Add a node for the base directory at the end */
ti = palloc0(sizeof(tablespaceinfo));
ti->size = opt->progress ? sendDir(".", 1, true) : -1;
tablespaces = lappend(tablespaces, ti);
/* Send tablespace header */
SendBackupHeader(tablespaces);
/* Send off our tablespaces one by one */
foreach(lc, tablespaces)
{
tablespaceinfo *ti = (tablespaceinfo *) lfirst(lc);
StringInfoData buf;
/* Send CopyOutResponse message */
pq_beginmessage(&buf, 'H');
pq_sendbyte(&buf, 0); /* overall format */
pq_sendint(&buf, 0, 2); /* natts */
pq_endmessage(&buf);
/* In the main tar, include the backup_label first. */
if (ti->path == NULL)
sendFileWithContent(BACKUP_LABEL_FILE, labelfile);
sendDir(ti->path == NULL ? "." : ti->path,
ti->path == NULL ? 1 : strlen(ti->path),
false);
/* In the main tar, include pg_control last. */
if (ti->path == NULL)
{
struct stat statbuf;
if (lstat(XLOG_CONTROL_FILE, &statbuf) != 0)
{
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not stat control file \"%s\": %m",
XLOG_CONTROL_FILE)));
}
sendFile(XLOG_CONTROL_FILE, XLOG_CONTROL_FILE, &statbuf, false);
}
/*
* If we're including WAL, and this is the main data directory we
* don't terminate the tar stream here. Instead, we will append
* the xlog files below and terminate it then. This is safe since
* the main data directory is always sent *last*.
*/
if (opt->includewal && ti->path == NULL)
{
Assert(lnext(lc) == NULL);
}
else
pq_putemptymessage('c'); /* CopyDone */
}
}
/*
* Actually do a base backup for the specified tablespaces.
*
* This is split out mainly to avoid complaints about "variable might be
* clobbered by longjmp" from stupider versions of gcc.
*/
static void
perform_base_backup(basebackup_options *opt, DIR *tblspcdir)
{
XLogRecPtr startptr;
XLogRecPtr endptr;
char *labelfile;
startptr = do_pg_start_backup(opt->label, opt->fastcheckpoint, &labelfile);
Assert(!XLogRecPtrIsInvalid(startptr));
elogif(!debug_basebackup, LOG,
"basebackup perform -- "
"Basebackup start xlog location = %X/%X",
startptr.xlogid, startptr.xrecoff);
/*
* Set xlogCleanUpTo so that checkpoint process knows
* which old xlog files should not be cleaned
*/
WalSndSetXLogCleanUpTo(startptr);
SIMPLE_FAULT_INJECTOR(BaseBackupPostCreateCheckpoint);
SendXlogRecPtrResult(startptr);
PG_ENSURE_ERROR_CLEANUP(base_backup_cleanup, (Datum) 0);
{
List *filespaces = NIL;
ListCell *lc;
/* Collect information about all filespaces, including pg_system */
filespaces = get_filespaces_to_send(opt);
/* Send filespace header */
SendBackupHeader(filespaces);
/* Send off our filespaces one by one */
foreach(lc, filespaces)
{
filespaceinfo *fi = (filespaceinfo *) lfirst(lc);
StringInfoData buf;
/* Send CopyOutResponse message */
pq_beginmessage(&buf, 'H');
pq_sendbyte(&buf, 0); /* overall format */
pq_sendint(&buf, 0, 2); /* natts */
pq_endmessage(&buf);
/* In the main tar, include the backup_label first. */
if (fi->primary_path == NULL)
sendFileWithContent(BACKUP_LABEL_FILE, labelfile);
sendDir(fi->primary_path == NULL ? "." : fi->primary_path,
fi->primary_path == NULL ? 1 : strlen(fi->primary_path),
opt->exclude, false);
/* In the main tar, include pg_control last. */
if (fi->primary_path == NULL)
{
struct stat statbuf;
if (lstat(XLOG_CONTROL_FILE, &statbuf) != 0)
{
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not stat control file \"%s\": %m",
XLOG_CONTROL_FILE)));
}
sendFile(XLOG_CONTROL_FILE, XLOG_CONTROL_FILE, &statbuf);
elogif(debug_basebackup, LOG,
"basebackup perform -- Sent file %s." , XLOG_CONTROL_FILE);
}
/*
* If we're including WAL, and this is the main data directory we
* don't terminate the tar stream here. Instead, we will append
* the xlog files below and terminate it then. This is safe since
* the main data directory is always sent *last*.
*/
if (opt->includewal && fi->xlogdir)
{
Assert(lnext(lc) == NULL);
}
else
pq_putemptymessage('c'); /* CopyDone */
}
}
/*
* Actually do a base backup for the specified tablespaces.
*
* This is split out mainly to avoid complaints about "variable might be
* clobbered by longjmp" from stupider versions of gcc.
*/
static void
perform_base_backup(basebackup_options *opt, DIR *tblspcdir)
{
XLogRecPtr startptr;
TimeLineID starttli;
XLogRecPtr endptr;
TimeLineID endtli;
StringInfo labelfile;
StringInfo tblspc_map_file = NULL;
int datadirpathlen;
List *tablespaces = NIL;
datadirpathlen = strlen(DataDir);
backup_started_in_recovery = RecoveryInProgress();
labelfile = makeStringInfo();
tblspc_map_file = makeStringInfo();
startptr = do_pg_start_backup(opt->label, opt->fastcheckpoint, &starttli,
labelfile, tblspcdir, &tablespaces,
tblspc_map_file,
opt->progress, opt->sendtblspcmapfile);
/*
* Once do_pg_start_backup has been called, ensure that any failure causes
* us to abort the backup so we don't "leak" a backup counter. For this
* reason, *all* functionality between do_pg_start_backup() and
* do_pg_stop_backup() should be inside the error cleanup block!
*/
PG_ENSURE_ERROR_CLEANUP(base_backup_cleanup, (Datum) 0);
{
ListCell *lc;
tablespaceinfo *ti;
SendXlogRecPtrResult(startptr, starttli);
/*
* Calculate the relative path of temporary statistics directory in
* order to skip the files which are located in that directory later.
*/
if (is_absolute_path(pgstat_stat_directory) &&
strncmp(pgstat_stat_directory, DataDir, datadirpathlen) == 0)
statrelpath = psprintf("./%s", pgstat_stat_directory + datadirpathlen + 1);
else if (strncmp(pgstat_stat_directory, "./", 2) != 0)
statrelpath = psprintf("./%s", pgstat_stat_directory);
else
statrelpath = pgstat_stat_directory;
/* Add a node for the base directory at the end */
ti = palloc0(sizeof(tablespaceinfo));
ti->size = opt->progress ? sendDir(".", 1, true, tablespaces, true) : -1;
tablespaces = lappend(tablespaces, ti);
/* Send tablespace header */
SendBackupHeader(tablespaces);
/* Setup and activate network throttling, if client requested it */
if (opt->maxrate > 0)
{
throttling_sample =
(int64) opt->maxrate * (int64) 1024 / THROTTLING_FREQUENCY;
/*
* The minimum amount of time for throttling_sample bytes to be
* transferred.
*/
elapsed_min_unit = USECS_PER_SEC / THROTTLING_FREQUENCY;
/* Enable throttling. */
throttling_counter = 0;
/* The 'real data' starts now (header was ignored). */
throttled_last = GetCurrentIntegerTimestamp();
}
else
{
/* Disable throttling. */
throttling_counter = -1;
}
/* Send off our tablespaces one by one */
foreach(lc, tablespaces)
{
tablespaceinfo *ti = (tablespaceinfo *) lfirst(lc);
StringInfoData buf;
/* Send CopyOutResponse message */
pq_beginmessage(&buf, 'H');
pq_sendbyte(&buf, 0); /* overall format */
pq_sendint(&buf, 0, 2); /* natts */
pq_endmessage(&buf);
if (ti->path == NULL)
{
struct stat statbuf;
/* In the main tar, include the backup_label first... */
sendFileWithContent(BACKUP_LABEL_FILE, labelfile->data);
/*
* Send tablespace_map file if required and then the bulk of
* the files.
*/
if (tblspc_map_file && opt->sendtblspcmapfile)
{
sendFileWithContent(TABLESPACE_MAP, tblspc_map_file->data);
sendDir(".", 1, false, tablespaces, false);
}
else
sendDir(".", 1, false, tablespaces, true);
/* ... and pg_control after everything else. */
if (lstat(XLOG_CONTROL_FILE, &statbuf) != 0)
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not stat control file \"%s\": %m",
XLOG_CONTROL_FILE)));
sendFile(XLOG_CONTROL_FILE, XLOG_CONTROL_FILE, &statbuf, false);
}
else
sendTablespace(ti->path, false);
/*
* If we're including WAL, and this is the main data directory we
* don't terminate the tar stream here. Instead, we will append
* the xlog files below and terminate it then. This is safe since
* the main data directory is always sent *last*.
*/
if (opt->includewal && ti->path == NULL)
{
Assert(lnext(lc) == NULL);
}
else
pq_putemptymessage('c'); /* CopyDone */
}
}
void EzFileDialog::clickEvent(){
QString dir = QFileDialog::getExistingDirectory(this, tr("Open directory"), ".", QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
if(dir != NULL)
emit sendDir(dir);
}
/*
* Actually do a base backup for the specified tablespaces.
*
* This is split out mainly to avoid complaints about "variable might be
* clobbered by longjmp" from stupider versions of gcc.
*/
static void
perform_base_backup(basebackup_options *opt, DIR *tblspcdir)
{
XLogRecPtr startptr;
XLogRecPtr endptr;
char *labelfile;
startptr = do_pg_start_backup(opt->label, opt->fastcheckpoint, &labelfile);
SendXlogRecPtrResult(startptr);
PG_ENSURE_ERROR_CLEANUP(base_backup_cleanup, (Datum) 0);
{
List *tablespaces = NIL;
ListCell *lc;
struct dirent *de;
tablespaceinfo *ti;
/* Collect information about all tablespaces */
while ((de = ReadDir(tblspcdir, "pg_tblspc")) != NULL)
{
char fullpath[MAXPGPATH];
char linkpath[MAXPGPATH];
/* Skip special stuff */
if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
continue;
snprintf(fullpath, sizeof(fullpath), "pg_tblspc/%s", de->d_name);
MemSet(linkpath, 0, sizeof(linkpath));
if (readlink(fullpath, linkpath, sizeof(linkpath) - 1) == -1)
{
ereport(WARNING,
(errmsg("unable to read symbolic link %s: %m", fullpath)));
continue;
}
ti = palloc(sizeof(tablespaceinfo));
ti->oid = pstrdup(de->d_name);
ti->path = pstrdup(linkpath);
ti->size = opt->progress ? sendDir(linkpath, strlen(linkpath), true) : -1;
tablespaces = lappend(tablespaces, ti);
}
/* Add a node for the base directory at the end */
ti = palloc0(sizeof(tablespaceinfo));
ti->size = opt->progress ? sendDir(".", 1, true) : -1;
tablespaces = lappend(tablespaces, ti);
/* Send tablespace header */
SendBackupHeader(tablespaces);
/* Send off our tablespaces one by one */
foreach(lc, tablespaces)
{
tablespaceinfo *ti = (tablespaceinfo *) lfirst(lc);
StringInfoData buf;
/* Send CopyOutResponse message */
pq_beginmessage(&buf, 'H');
pq_sendbyte(&buf, 0); /* overall format */
pq_sendint(&buf, 0, 2); /* natts */
pq_endmessage(&buf);
/* In the main tar, include the backup_label first. */
if (ti->path == NULL)
sendFileWithContent(BACKUP_LABEL_FILE, labelfile);
sendDir(ti->path == NULL ? "." : ti->path,
ti->path == NULL ? 1 : strlen(ti->path),
false);
/*
* If we're including WAL, and this is the main data directory we
* don't terminate the tar stream here. Instead, we will append
* the xlog files below and terminate it then. This is safe since
* the main data directory is always sent *last*.
*/
if (opt->includewal && ti->path == NULL)
{
Assert(lnext(lc) == NULL);
}
else
pq_putemptymessage('c'); /* CopyDone */
}
}
/*
* Actually do a base backup for the specified tablespaces.
*
* This is split out mainly to avoid complaints about "variable might be
* clobbered by longjmp" from stupider versions of gcc.
*/
static void
perform_base_backup(basebackup_options *opt, DIR *tblspcdir)
{
XLogRecPtr startptr;
TimeLineID starttli;
XLogRecPtr endptr;
TimeLineID endtli;
char *labelfile;
int datadirpathlen;
datadirpathlen = strlen(DataDir);
backup_started_in_recovery = RecoveryInProgress();
startptr = do_pg_start_backup(opt->label, opt->fastcheckpoint, &starttli,
&labelfile);
/*
* Once do_pg_start_backup has been called, ensure that any failure causes
* us to abort the backup so we don't "leak" a backup counter. For this reason,
* *all* functionality between do_pg_start_backup() and do_pg_stop_backup()
* should be inside the error cleanup block!
*/
PG_ENSURE_ERROR_CLEANUP(base_backup_cleanup, (Datum) 0);
{
List *tablespaces = NIL;
ListCell *lc;
struct dirent *de;
tablespaceinfo *ti;
SendXlogRecPtrResult(startptr, starttli);
/*
* Calculate the relative path of temporary statistics directory in order
* to skip the files which are located in that directory later.
*/
if (is_absolute_path(pgstat_stat_directory) &&
strncmp(pgstat_stat_directory, DataDir, datadirpathlen) == 0)
statrelpath = psprintf("./%s", pgstat_stat_directory + datadirpathlen + 1);
else if (strncmp(pgstat_stat_directory, "./", 2) != 0)
statrelpath = psprintf("./%s", pgstat_stat_directory);
else
statrelpath = pgstat_stat_directory;
/* Collect information about all tablespaces */
while ((de = ReadDir(tblspcdir, "pg_tblspc")) != NULL)
{
char fullpath[MAXPGPATH];
char linkpath[MAXPGPATH];
char *relpath = NULL;
int rllen;
/* Skip special stuff */
if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
continue;
snprintf(fullpath, sizeof(fullpath), "pg_tblspc/%s", de->d_name);
#if defined(HAVE_READLINK) || defined(WIN32)
rllen = readlink(fullpath, linkpath, sizeof(linkpath));
if (rllen < 0)
{
ereport(WARNING,
(errmsg("could not read symbolic link \"%s\": %m",
fullpath)));
continue;
}
else if (rllen >= sizeof(linkpath))
{
ereport(WARNING,
(errmsg("symbolic link \"%s\" target is too long",
fullpath)));
continue;
}
linkpath[rllen] = '\0';
/*
* Relpath holds the relative path of the tablespace directory
* when it's located within PGDATA, or NULL if it's located
* elsewhere.
*/
if (rllen > datadirpathlen &&
strncmp(linkpath, DataDir, datadirpathlen) == 0 &&
IS_DIR_SEP(linkpath[datadirpathlen]))
relpath = linkpath + datadirpathlen + 1;
ti = palloc(sizeof(tablespaceinfo));
ti->oid = pstrdup(de->d_name);
ti->path = pstrdup(linkpath);
ti->rpath = relpath ? pstrdup(relpath) : NULL;
ti->size = opt->progress ? sendTablespace(fullpath, true) : -1;
tablespaces = lappend(tablespaces, ti);
#else
/*
* If the platform does not have symbolic links, it should not be
* possible to have tablespaces - clearly somebody else created
* them. Warn about it and ignore.
*/
ereport(WARNING,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("tablespaces are not supported on this platform")));
#endif
}
/* Add a node for the base directory at the end */
ti = palloc0(sizeof(tablespaceinfo));
ti->size = opt->progress ? sendDir(".", 1, true, tablespaces) : -1;
tablespaces = lappend(tablespaces, ti);
/* Send tablespace header */
SendBackupHeader(tablespaces);
/* Setup and activate network throttling, if client requested it */
if (opt->maxrate > 0)
{
throttling_sample =
(int64) opt->maxrate * (int64) 1024 / THROTTLING_FREQUENCY;
/*
* The minimum amount of time for throttling_sample bytes to be
* transfered.
*/
elapsed_min_unit = USECS_PER_SEC / THROTTLING_FREQUENCY;
/* Enable throttling. */
throttling_counter = 0;
/* The 'real data' starts now (header was ignored). */
throttled_last = GetCurrentIntegerTimestamp();
}
else
{
/* Disable throttling. */
throttling_counter = -1;
}
/* Send off our tablespaces one by one */
foreach(lc, tablespaces)
{
tablespaceinfo *ti = (tablespaceinfo *) lfirst(lc);
StringInfoData buf;
/* Send CopyOutResponse message */
pq_beginmessage(&buf, 'H');
pq_sendbyte(&buf, 0); /* overall format */
pq_sendint(&buf, 0, 2); /* natts */
pq_endmessage(&buf);
if (ti->path == NULL)
{
struct stat statbuf;
/* In the main tar, include the backup_label first... */
sendFileWithContent(BACKUP_LABEL_FILE, labelfile);
/* ... then the bulk of the files ... */
sendDir(".", 1, false, tablespaces);
/* ... and pg_control after everything else. */
if (lstat(XLOG_CONTROL_FILE, &statbuf) != 0)
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not stat control file \"%s\": %m",
XLOG_CONTROL_FILE)));
sendFile(XLOG_CONTROL_FILE, XLOG_CONTROL_FILE, &statbuf, false);
}
else
sendTablespace(ti->path, false);
/*
* If we're including WAL, and this is the main data directory we
* don't terminate the tar stream here. Instead, we will append
* the xlog files below and terminate it then. This is safe since
* the main data directory is always sent *last*.
*/
if (opt->includewal && ti->path == NULL)
{
Assert(lnext(lc) == NULL);
}
else
pq_putemptymessage('c'); /* CopyDone */
}
}
