TEST(Base64Tests, ToBase64)
{
EXPECT_EQ("", to_base64(""));
EXPECT_EQ("YQ==", to_base64("a"));
EXPECT_EQ("YWI=", to_base64("ab"));
EXPECT_EQ("YWJj", to_base64("abc"));
EXPECT_EQ("YWJjZA==", to_base64("abcd"));
}
int sc_base64_encode(const u8 *in, size_t len, u8 *out, size_t outlen, size_t linelength)
{
unsigned int chars = 0;
size_t i, c;
linelength -= linelength & 0x03;
while (len >= 3) {
i = in[2] + (in[1] << 8) + (in[0] << 16);
in += 3;
len -= 3;
if (outlen < 4)
return SC_ERROR_BUFFER_TOO_SMALL;
to_base64(i, out, 0);
out += 4;
outlen -= 4;
chars += 4;
if (chars >= linelength && linelength > 0) {
if (outlen < 1)
return SC_ERROR_BUFFER_TOO_SMALL;
*out = '\n';
out++;
outlen--;
chars = 0;
}
}
i = c = 0;
while (c < len)
i |= *in++ << ((2 - c++) << 3);
if (len) {
if (outlen < 4)
return SC_ERROR_BUFFER_TOO_SMALL;
to_base64(i, out, 3-len);
out += 4;
outlen -= 4;
chars += 4;
}
if (chars && linelength > 0) {
if (outlen < 1)
return SC_ERROR_BUFFER_TOO_SMALL;
*out = '\n';
out++;
outlen--;
}
if (outlen < 1)
return SC_ERROR_BUFFER_TOO_SMALL;
*out = 0;
return 0;
}
void send_stdin_once(xmpp_conn_t * const conn, xmpp_ctx_t *ctx, char *jid_to)
{
int n;
char buf[1024], *stdin_b64;
xmpp_stanza_t *message, *body, *text;
while (n = fread(buf, sizeof(char), sizeof buf, stdin)){
stdin_b64 = to_base64(buf, n);
message = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(message, "message");
xmpp_stanza_set_type(message, "chat");
xmpp_stanza_set_attribute(message, "to", jid_to);
body = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(body, "body");
text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text, stdin_b64);
xmpp_stanza_add_child(body, text);
xmpp_stanza_add_child(message, body);
xmpp_send(conn, message);
xmpp_stanza_release(message);
free(stdin_b64);
}
}
static int encode_req(struct blk *blk, char *req)
{
char *p=req;
p+=to_base64(blk->index, p);
*p=0;
return 0;
}
static void get_wbuf_from_index(struct iobuf *wbuf, uint64_t index)
{
static char *p;
static char tmp[32];
p=tmp;
p+=to_base64(index, tmp);
*p='\0';
iobuf_from_str(wbuf, CMD_WRAP_UP, tmp);
}
/**
* Delete a key and its value from the DB
*
*
* @param db Open DB handle
* @param key Key
* @param error Output error object
*
* @return 0 on success, system error otherwise
*
* @addtogroup heimbase
*/
int
heim_db_delete_key(heim_db_t db, heim_string_t table, heim_data_t key,
heim_error_t *error)
{
heim_string_t key64 = NULL;
int ret;
if (error != NULL)
*error = NULL;
if (table == NULL)
table = HSTR("");
if (heim_get_tid(db) != HEIM_TID_DB)
return EINVAL;
if (db->plug->delf == NULL)
return EBADF;
if (!db->in_transaction) {
ret = heim_db_begin(db, 0, error);
if (ret)
goto err;
heim_assert(db->in_transaction, "Internal error");
ret = heim_db_delete_key(db, table, key, error);
if (ret) {
(void) heim_db_rollback(db, NULL);
return ret;
}
return heim_db_commit(db, error);
}
/* Transaction emulation */
heim_assert(db->set_keys != NULL, "Internal error");
key64 = to_base64(key, error);
if (key64 == NULL)
return HEIM_ENOMEM(error);
if (db->ro_tx) {
ret = heim_db_begin(db, 0, error);
if (ret)
goto err;
}
ret = heim_path_create(db->del_keys, 29, heim_number_create(1), error, table, key64, NULL);
if (ret)
goto err;
heim_path_delete(db->set_keys, error, table, key64, NULL);
heim_release(key64);
return 0;
err:
heim_release(key64);
return HEIM_ERROR(error, ret,
(ret, N_("Could not set a dict value while while "
"deleting a DB value", "")));
}
// FIX THIS: this function is now named strangely.
static void get_wbuf_from_wrap_up(struct iobuf *wbuf, uint64_t wrap_up)
{
static char *p;
static char tmp[32];
//printf("get_wbuf_from_wrap_up: %d\n", wrap_up);
p=tmp;
p+=to_base64(wrap_up, tmp);
*p='\0';
iobuf_from_str(wbuf, CMD_WRAP_UP, tmp);
}
static void get_wbuf_from_index(struct iobuf *wbuf, uint64_t index)
{
static char *p;
static char tmp[32];
//printf("%s: %d\n", __func__, index);
p=tmp;
p+=to_base64(index, tmp);
*p='\0';
iobuf_from_str(wbuf, CMD_WRAP_UP, tmp);
}
std::string create_command(std::string const &login, std::string const &password)
{
std::string command(login_command_prefix);
command.push_back(' ');
command.append(login);
command.append(" \"");
std::string password_base64 = to_base64(password);
command.append(password_base64);
command.push_back('\"');
return command;
}
int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt)
{
char *p = attribsEx;
WIN32_FILE_ATTRIBUTE_DATA atts;
ULARGE_INTEGER li;
attribsEx[0] = 0; /* no extended attributes */
if (jcr->cmd_plugin || ff_pkt->type == FT_DELETED) {
return STREAM_UNIX_ATTRIBUTES;
}
unix_name_to_win32(&ff_pkt->sys_fname, ff_pkt->fname);
/** try unicode version */
if (p_GetFileAttributesExW) {
POOLMEM* pwszBuf = get_pool_memory(PM_FNAME);
make_win32_path_UTF8_2_wchar(&pwszBuf, ff_pkt->fname);
BOOL b=p_GetFileAttributesExW((LPCWSTR)pwszBuf, GetFileExInfoStandard,
(LPVOID)&atts);
free_pool_memory(pwszBuf);
if (!b) {
win_error(jcr, "GetFileAttributesExW:", ff_pkt->sys_fname);
return STREAM_UNIX_ATTRIBUTES;
}
}
else {
if (!p_GetFileAttributesExA)
return STREAM_UNIX_ATTRIBUTES;
if (!p_GetFileAttributesExA(ff_pkt->sys_fname, GetFileExInfoStandard,
(LPVOID)&atts)) {
win_error(jcr, "GetFileAttributesExA:", ff_pkt->sys_fname);
return STREAM_UNIX_ATTRIBUTES;
}
}
p += to_base64((uint64_t)atts.dwFileAttributes, p);
*p++ = ' '; /* separate fields with a space */
li.LowPart = atts.ftCreationTime.dwLowDateTime;
li.HighPart = atts.ftCreationTime.dwHighDateTime;
p += to_base64((uint64_t)li.QuadPart, p);
*p++ = ' ';
li.LowPart = atts.ftLastAccessTime.dwLowDateTime;
li.HighPart = atts.ftLastAccessTime.dwHighDateTime;
p += to_base64((uint64_t)li.QuadPart, p);
*p++ = ' ';
li.LowPart = atts.ftLastWriteTime.dwLowDateTime;
li.HighPart = atts.ftLastWriteTime.dwHighDateTime;
p += to_base64((uint64_t)li.QuadPart, p);
*p++ = ' ';
p += to_base64((uint64_t)atts.nFileSizeHigh, p);
*p++ = ' ';
p += to_base64((uint64_t)atts.nFileSizeLow, p);
*p = 0;
return STREAM_UNIX_ATTRIBUTES_EX;
}
int main(int argc, char *argv[])
{
/* You can modify this file as needed, for example to test different
* files. If you run on command line, this function optionally reads
* the filename from command line, if one is given. */
char *filename = "testi.txt";
if (argc > 1) {
filename = argv[1];
}
// Write encoded file to 'testi.enc'
int n = to_base64("testi.enc", filename);
printf("to_base64 returned: %d\n", n);
// Follow with reverse operation -- 'testi.ver' should be same as
// your original source file
n = from_base64("testi.ver", "testi.enc");
printf("from_base64 returned: %d\n", n);
}
/**
* Lookup a key's value in the DB.
*
* Returns 0 on success, -1 if the key does not exist in the DB, or a
* system error number on failure.
*
* @param db Open DB handle
* @param key Key
* @param error Output error object
*
* @return the value (retained), if there is one for the given key
*
* @addtogroup heimbase
*/
heim_data_t
heim_db_copy_value(heim_db_t db, heim_string_t table, heim_data_t key,
heim_error_t *error)
{
heim_object_t v;
heim_data_t result;
if (heim_get_tid(db) != HEIM_TID_DB)
return NULL;
if (error != NULL)
*error = NULL;
if (table == NULL)
table = HSTR("");
if (db->in_transaction) {
heim_string_t key64;
key64 = to_base64(key, error);
if (key64 == NULL) {
if (error)
*error = heim_error_create_enomem();
return NULL;
}
v = heim_path_copy(db->set_keys, error, table, key64, NULL);
if (v != NULL) {
heim_release(key64);
return v;
}
v = heim_path_copy(db->del_keys, error, table, key64, NULL); /* can't be NULL */
heim_release(key64);
if (v != NULL)
return NULL;
}
result = db->plug->copyf(db->db_data, table, key, error);
return result;
}
void web_crawler::job_cache(const size_t id)
{
while (!urls.empty())
{
std::unique_lock<std::mutex> lck(mutex_);
std::cout<< id << "waiting..."<< num_memory_items_ - pages.size() <<std::endl;
this->cv.wait(lck, [this] {return this->pages.size() > this->num_memory_items_;});
auto item = *pages.begin();
pages.erase(pages.begin());
lck.unlock();
const auto addr = to_base64(item.first.string());
boost::filesystem::create_directory(authority(item.first));
const auto& page = item.second;
std::cout<< id << " saving to " << "cache/" + addr <<std::endl;
std::ofstream ofs("cache/" + addr);
std::copy(page.begin(), page.end(), std::ostreambuf_iterator<char>(ofs));
}
}
/**
* It is possible to piggyback additional data e.g. ACLs on
* the encode_stat() data by returning the extended attributes
* here. They must be "self-contained" (i.e. you keep track
* of your own length), and they must be in ASCII string
* format. Using this feature is not recommended.
* The code below shows how to return nothing. See the Win32
* code below for returning something in the attributes.
*/
int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt)
{
#ifdef HAVE_DARWIN_OS
/**
* We save the Mac resource fork length so that on a
* restore, we can be sure we put back the whole resource.
*/
char *p;
*attribsEx = 0; /* no extended attributes (yet) */
if (jcr->cmd_plugin || ff_pkt->type == FT_DELETED) {
return STREAM_UNIX_ATTRIBUTES;
}
p = attribsEx;
if (ff_pkt->flags & FO_HFSPLUS) {
p += to_base64((uint64_t)(ff_pkt->hfsinfo.rsrclength), p);
}
*p = 0;
#else
*attribsEx = 0; /* no extended attributes */
#endif
return STREAM_UNIX_ATTRIBUTES;
}
int www_authenticate(int sd, rr_data_t request, rr_data_t response, struct auth_s *creds) {
char *tmp, *buf, *challenge;
rr_data_t auth;
int len;
int rc = 0;
buf = new(BUFSIZE);
strcpy(buf, "NTLM ");
len = ntlm_request(&tmp, creds);
if (len) {
to_base64(MEM(buf, uint8_t, 5), MEM(tmp, uint8_t, 0), len, BUFSIZE-5);
free(tmp);
}
auth = dup_rr_data(request);
auth->headers = hlist_mod(auth->headers, "Connection", "keep-alive", 1);
auth->headers = hlist_mod(auth->headers, "Authorization", buf, 1);
auth->headers = hlist_mod(auth->headers, "Content-Length", "0", 1);
auth->headers = hlist_del(auth->headers, "Transfer-Encoding");
/*
* Drop whatever error page server returned
*/
if (!http_body_drop(sd, response))
goto bailout;
if (debug) {
printf("\nSending WWW auth request...\n");
hlist_dump(auth->headers);
}
if (!headers_send(sd, auth))
goto bailout;
if (debug)
printf("\nReading WWW auth response...\n");
/*
* Get NTLM challenge
*/
reset_rr_data(auth);
if (!headers_recv(sd, auth)) {
goto bailout;
}
if (debug)
hlist_dump(auth->headers);
/*
* Auth required?
*/
if (auth->code == 401) {
if (!http_body_drop(sd, auth))
goto bailout;
tmp = hlist_get(auth->headers, "WWW-Authenticate");
if (tmp && strlen(tmp) > 6 + 8) {
challenge = new(strlen(tmp) + 5 + 1);
len = from_base64(challenge, tmp + 5);
if (len > NTLM_CHALLENGE_MIN) {
len = ntlm_response(&tmp, challenge, len, creds);
if (len > 0) {
strcpy(buf, "NTLM ");
to_base64(MEM(buf, uint8_t, 5), MEM(tmp, uint8_t, 0), len, BUFSIZE-5);
request->headers = hlist_mod(request->headers, "Authorization", buf, 1);
free(tmp);
} else {
syslog(LOG_ERR, "No target info block. Cannot do NTLMv2!\n");
response->errmsg = "Invalid NTLM challenge from web server";
free(challenge);
goto bailout;
}
} else {
syslog(LOG_ERR, "Server returning invalid challenge!\n");
response->errmsg = "Invalid NTLM challenge from web server";
free(challenge);
goto bailout;
}
free(challenge);
} else {
/**
* Encode a stat structure into a base64 character string
* All systems must create such a structure.
* In addition, we tack on the LinkFI, which is non-zero in
* the case of a hard linked file that has no data. This
* is a File Index pointing to the link that does have the
* data (always the first one encountered in a save).
* You may piggyback attributes on this packet by encoding
* them in the encode_attribsEx() subroutine, but this is
* not recommended.
*/
void encode_stat(char *buf, struct stat *statp, int stat_size, int32_t LinkFI, int data_stream)
{
char *p = buf;
/*
* We read the stat packet so make sure the caller's conception
* is the same as ours. They can be different if LARGEFILE is not
* the same when compiling this library and the calling program.
*/
ASSERT(stat_size == (int)sizeof(struct stat));
/**
* Encode a stat packet. I should have done this more intelligently
* with a length so that it could be easily expanded.
*/
p += to_base64((int64_t)statp->st_dev, p);
*p++ = ' '; /* separate fields with a space */
p += to_base64((int64_t)statp->st_ino, p);
*p++ = ' ';
p += to_base64((int64_t)statp->st_mode, p);
*p++ = ' ';
p += to_base64((int64_t)statp->st_nlink, p);
*p++ = ' ';
p += to_base64((int64_t)statp->st_uid, p);
*p++ = ' ';
p += to_base64((int64_t)statp->st_gid, p);
*p++ = ' ';
p += to_base64((int64_t)statp->st_rdev, p);
*p++ = ' ';
p += to_base64((int64_t)statp->st_size, p);
*p++ = ' ';
#ifndef HAVE_MINGW
p += to_base64((int64_t)statp->st_blksize, p);
*p++ = ' ';
p += to_base64((int64_t)statp->st_blocks, p);
*p++ = ' ';
#else
p += to_base64((int64_t)0, p); /* output place holder */
*p++ = ' ';
p += to_base64((int64_t)0, p); /* output place holder */
*p++ = ' ';
#endif
p += to_base64((int64_t)statp->st_atime, p);
*p++ = ' ';
p += to_base64((int64_t)statp->st_mtime, p);
*p++ = ' ';
p += to_base64((int64_t)statp->st_ctime, p);
*p++ = ' ';
p += to_base64((int64_t)LinkFI, p);
*p++ = ' ';
#ifdef HAVE_CHFLAGS
/* FreeBSD function */
p += to_base64((int64_t)statp->st_flags, p); /* output st_flags */
#else
p += to_base64((int64_t)0, p); /* output place holder */
#endif
*p++ = ' ';
p += to_base64((int64_t)data_stream, p);
*p = 0;
return;
}
/*
* Restore all file attributes like owner, mode and file times.
*/
static inline bool restore_file_attributes(JCR *jcr, ATTR *attr, BFILE *ofd)
{
bool ok = true;
bool suppress_errors;
#if defined(HAVE_FCHOWN) || defined(HAVE_FCHMOD) || defined(HAVE_FUTIMES) || defined(FUTIMENS)
bool file_is_open;
/*
* Save if we are working on an open file.
*/
file_is_open = is_bopen(ofd);
#endif
/*
* See if we want to print errors.
*/
suppress_errors = (debug_level >= 100 || my_uid != 0);
/*
* Restore owner and group.
*/
#ifdef HAVE_FCHOWN
if (file_is_open) {
if (fchown(ofd->fid, attr->statp.st_uid, attr->statp.st_gid) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file owner %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
} else {
#else
{
#endif
if (lchown(attr->ofname, attr->statp.st_uid, attr->statp.st_gid) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file owner %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
}
/*
* Restore filemode.
*/
#ifdef HAVE_FCHMOD
if (file_is_open) {
if (fchmod(ofd->fid, attr->statp.st_mode) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file modes %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
} else {
#else
{
#endif
#if defined(HAVE_WIN32)
if (win32_chmod(attr->ofname, attr->statp.st_mode, attr->statp.st_rdev) < 0 && !suppress_errors) {
#else
if (lchmod(attr->ofname, attr->statp.st_mode) < 0 && !suppress_errors) {
#endif
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file modes %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
}
/*
* Reset file times.
*/
#if defined(HAVE_FUTIMES)
if (file_is_open) {
struct timeval restore_times[2];
restore_times[0].tv_sec = attr->statp.st_atime;
restore_times[0].tv_usec = 0;
restore_times[1].tv_sec = attr->statp.st_mtime;
restore_times[1].tv_usec = 0;
if (futimes(ofd->fid, restore_times) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file times %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
} else {
#elif defined(HAVE_FUTIMENS)
if (file_is_open) {
struct timespec restore_times[2];
restore_times[0].tv_sec = attr->statp.st_atime;
restore_times[0].tv_nsec = 0;
restore_times[1].tv_sec = attr->statp.st_mtime;
restore_times[1].tv_nsec = 0;
if (futimens(ofd->fid, restore_times) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file times %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
} else {
#else
{
#endif
#if defined(HAVE_LUTIMES)
struct timeval restore_times[2];
restore_times[0].tv_sec = attr->statp.st_atime;
restore_times[0].tv_usec = 0;
restore_times[1].tv_sec = attr->statp.st_mtime;
restore_times[1].tv_usec = 0;
if (lutimes(attr->ofname, restore_times) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file times %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
#elif defined(HAVE_UTIMES)
struct timeval restore_times[2];
restore_times[0].tv_sec = attr->statp.st_atime;
restore_times[0].tv_usec = 0;
restore_times[1].tv_sec = attr->statp.st_mtime;
restore_times[1].tv_usec = 0;
if (utimes(attr->ofname, restore_times) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file times %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
#else
struct utimbuf restore_times;
restore_times.actime = attr->statp.st_atime;
restore_times.modtime = attr->statp.st_mtime;
if (utime(attr->ofname, &restore_times) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file times %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
#endif /* HAVE_LUTIMES */
}
return ok;
}
/**
* Set file modes, permissions and times
*
* fname is the original filename
* ofile is the output filename (may be in a different directory)
*
* Returns: true on success
* false on failure
*/
bool set_attributes(JCR *jcr, ATTR *attr, BFILE *ofd)
{
mode_t old_mask;
bool ok = true;
bool suppress_errors;
if (uid_set) {
my_uid = getuid();
my_gid = getgid();
uid_set = true;
}
/*
* See if we want to print errors.
*/
suppress_errors = (debug_level >= 100 || my_uid != 0);
#if defined(HAVE_WIN32)
if (attr->stream == STREAM_UNIX_ATTRIBUTES_EX &&
set_win32_attributes(jcr, attr, ofd)) {
if (is_bopen(ofd)) {
bclose(ofd);
}
pm_strcpy(attr->ofname, "*None*");
return true;
}
if (attr->data_stream == STREAM_WIN32_DATA ||
attr->data_stream == STREAM_WIN32_GZIP_DATA ||
attr->data_stream == STREAM_WIN32_COMPRESSED_DATA) {
if (is_bopen(ofd)) {
bclose(ofd);
}
pm_strcpy(attr->ofname, "*None*");
return true;
}
/**
* If Windows stuff failed, e.g. attempt to restore Unix file to Windows, simply fall
* through and we will do it the universal way.
*/
#endif
old_mask = umask(0);
if (is_bopen(ofd)) {
boffset_t fsize;
char ec1[50], ec2[50];
fsize = blseek(ofd, 0, SEEK_END);
if (attr->type == FT_REG &&
fsize > 0 &&
attr->statp.st_size > 0 &&
fsize != (boffset_t)attr->statp.st_size) {
Jmsg3(jcr, M_ERROR, 0, _("File size of restored file %s not correct. Original %s, restored %s.\n"),
attr->ofname, edit_uint64(attr->statp.st_size, ec1), edit_uint64(fsize, ec2));
}
} else {
struct stat st;
char ec1[50], ec2[50];
if (lstat(attr->ofname, &st) == 0) {
if (attr->type == FT_REG &&
st.st_size > 0 &&
attr->statp.st_size > 0 &&
st.st_size != attr->statp.st_size) {
Jmsg3(jcr, M_ERROR, 0, _("File size of restored file %s not correct. Original %s, restored %s.\n"),
attr->ofname, edit_uint64(attr->statp.st_size, ec1), edit_uint64(st.st_size, ec2));
}
}
}
/**
* We do not restore sockets, so skip trying to restore their attributes.
*/
if (attr->type == FT_SPEC && S_ISSOCK(attr->statp.st_mode)) {
goto bail_out;
}
/* ***FIXME**** optimize -- don't do if already correct */
/**
* For link, change owner of link using lchown, but don't try to do a chmod as that will update the file behind it.
*/
if (attr->type == FT_LNK) {
/*
* Change owner of link, not of real file
*/
if (lchown(attr->ofname, attr->statp.st_uid, attr->statp.st_gid) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file owner %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
#ifdef HAVE_LCHMOD
if (lchmod(attr->ofname, attr->statp.st_mode) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file modes %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
#endif
} else {
if (!ofd->cmd_plugin) {
ok = restore_file_attributes(jcr, attr, ofd);
#ifdef HAVE_CHFLAGS
/**
* FreeBSD user flags
*
* Note, this should really be done before the utime() above,
* but if the immutable bit is set, it will make the utimes()
* fail.
*/
if (chflags(attr->ofname, attr->statp.st_flags) < 0 && !suppress_errors) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to set file flags %s: ERR=%s\n"), attr->ofname, be.bstrerror());
ok = false;
}
#endif
}
}
bail_out:
if (is_bopen(ofd)) {
bclose(ofd);
}
pm_strcpy(attr->ofname, "*None*");
umask(old_mask);
return ok;
}
#if !defined(HAVE_WIN32)
/*=============================================================*/
/* */
/* * * * U n i x * * * * */
/* */
/*=============================================================*/
/**
* It is possible to piggyback additional data e.g. ACLs on
* the encode_stat() data by returning the extended attributes
* here. They must be "self-contained" (i.e. you keep track
* of your own length), and they must be in ASCII string
* format. Using this feature is not recommended.
* The code below shows how to return nothing. See the Win32
* code below for returning something in the attributes.
*/
int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt)
{
#ifdef HAVE_DARWIN_OS
/**
* We save the Mac resource fork length so that on a
* restore, we can be sure we put back the whole resource.
*/
char *p;
*attribsEx = 0; /* no extended attributes (yet) */
if (jcr->cmd_plugin || ff_pkt->type == FT_DELETED) {
return STREAM_UNIX_ATTRIBUTES;
}
p = attribsEx;
if (bit_is_set(FO_HFSPLUS, ff_pkt->flags)) {
p += to_base64((uint64_t)(ff_pkt->hfsinfo.rsrclength), p);
}
*p = 0;
#else
*attribsEx = 0; /* no extended attributes */
#endif
return STREAM_UNIX_ATTRIBUTES;
}
#else
/*=============================================================*/
/* */
/* * * * W i n 3 2 * * * * */
/* */
/*=============================================================*/
int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt)
{
char *p = attribsEx;
WIN32_FILE_ATTRIBUTE_DATA atts;
ULARGE_INTEGER li;
attribsEx[0] = 0; /* no extended attributes */
if (jcr->cmd_plugin || ff_pkt->type == FT_DELETED) {
return STREAM_UNIX_ATTRIBUTES;
}
unix_name_to_win32(ff_pkt->sys_fname, ff_pkt->fname);
if (p_GetFileAttributesExW) {
/**
* Try unicode version
*/
POOLMEM* pwszBuf = get_pool_memory(PM_FNAME);
make_win32_path_UTF8_2_wchar(pwszBuf, ff_pkt->fname);
BOOL b=p_GetFileAttributesExW((LPCWSTR)pwszBuf, GetFileExInfoStandard,
(LPVOID)&atts);
free_pool_memory(pwszBuf);
if (!b) {
win_error(jcr, "GetFileAttributesExW:", ff_pkt->sys_fname);
return STREAM_UNIX_ATTRIBUTES;
}
} else {
if (!p_GetFileAttributesExA)
return STREAM_UNIX_ATTRIBUTES;
if (!p_GetFileAttributesExA(ff_pkt->sys_fname, GetFileExInfoStandard,
(LPVOID)&atts)) {
win_error(jcr, "GetFileAttributesExA:", ff_pkt->sys_fname);
return STREAM_UNIX_ATTRIBUTES;
}
}
/*
* Instead of using the current dwFileAttributes use the
* ff_pkt->statp.st_rdev which contains the actual fileattributes we
* want to save for this file.
*/
atts.dwFileAttributes = ff_pkt->statp.st_rdev;
p += to_base64((uint64_t)atts.dwFileAttributes, p);
*p++ = ' '; /* separate fields with a space */
li.LowPart = atts.ftCreationTime.dwLowDateTime;
li.HighPart = atts.ftCreationTime.dwHighDateTime;
p += to_base64((uint64_t)li.QuadPart, p);
*p++ = ' ';
li.LowPart = atts.ftLastAccessTime.dwLowDateTime;
li.HighPart = atts.ftLastAccessTime.dwHighDateTime;
p += to_base64((uint64_t)li.QuadPart, p);
*p++ = ' ';
li.LowPart = atts.ftLastWriteTime.dwLowDateTime;
li.HighPart = atts.ftLastWriteTime.dwHighDateTime;
p += to_base64((uint64_t)li.QuadPart, p);
*p++ = ' ';
p += to_base64((uint64_t)atts.nFileSizeHigh, p);
*p++ = ' ';
p += to_base64((uint64_t)atts.nFileSizeLow, p);
*p = 0;
return STREAM_UNIX_ATTRIBUTES_EX;
}
/*
* Encode a stat structure into a base64 character string
* All systems must create such a structure.
*/
void encode_stat(char *buf, struct stat *statp, int64_t winattr, int compression)
{
char *p = buf;
p += to_base64(statp->st_dev, p);
*p++ = ' '; /* separate fields with a space */
p += to_base64(statp->st_ino, p);
*p++ = ' ';
p += to_base64(statp->st_mode, p);
*p++ = ' ';
p += to_base64(statp->st_nlink, p);
*p++ = ' ';
p += to_base64(statp->st_uid, p);
*p++ = ' ';
p += to_base64(statp->st_gid, p);
*p++ = ' ';
p += to_base64(statp->st_rdev, p);
*p++ = ' ';
p += to_base64(statp->st_size, p);
*p++ = ' ';
#ifdef HAVE_WIN32
p += to_base64(0, p); /* output place holder */
*p++ = ' ';
p += to_base64(0, p); /* output place holder */
#else
p += to_base64(statp->st_blksize, p);
*p++ = ' ';
p += to_base64(statp->st_blocks, p);
#endif
*p++ = ' ';
p += to_base64(statp->st_atime, p);
*p++ = ' ';
p += to_base64(statp->st_mtime, p);
*p++ = ' ';
p += to_base64(statp->st_ctime, p);
*p++ = ' ';
#ifdef HAVE_CHFLAGS
/* FreeBSD function */
p += to_base64(statp->st_flags, p); /* output st_flags */
#else
p += to_base64(0, p); /* output place holder */
#endif
*p++ = ' ';
#ifdef HAVE_WIN32
p += to_base64(winattr, p);
#else
p += to_base64(0, p); /* output place holder */
#endif
*p++ = ' ';
p += to_base64(compression, p);
*p = 0;
return;
}
// Encode a stat structure into a base64 character string.
int attribs_encode(struct sbuf *sb)
{
static char *p;
static struct stat *statp;
if(!sb->attr.buf)
{
sb->attr.cmd=CMD_ATTRIBS; // should not be needed
if(!(sb->attr.buf=(char *)malloc_w(128, __func__)))
return -1;
}
p=sb->attr.buf;
statp=&sb->statp;
if(sb->burp2)
{
// Burp1 does not have this field.
p += to_base64(sb->burp2->index, p);
*p++ = ' ';
// Burp2 puts compression near the beginning.
p += to_base64(sb->compression, p);
*p++ = ' ';
// Burp1 does not have this field.
p += to_base64(sb->burp2->encryption, p);
*p++ = ' ';
}
p += to_base64(statp->st_dev, p);
*p++ = ' ';
p += to_base64(statp->st_ino, p);
*p++ = ' ';
p += to_base64(statp->st_mode, p);
*p++ = ' ';
p += to_base64(statp->st_nlink, p);
*p++ = ' ';
p += to_base64(statp->st_uid, p);
*p++ = ' ';
p += to_base64(statp->st_gid, p);
*p++ = ' ';
p += to_base64(statp->st_rdev, p);
*p++ = ' ';
p += to_base64(statp->st_size, p);
*p++ = ' ';
#ifdef HAVE_WIN32
p += to_base64(0, p); // place holder
*p++ = ' ';
p += to_base64(0, p); // place holder
#else
p += to_base64(statp->st_blksize, p);
*p++ = ' ';
p += to_base64(statp->st_blocks, p);
#endif
*p++ = ' ';
p += to_base64(statp->st_atime, p);
*p++ = ' ';
p += to_base64(statp->st_mtime, p);
*p++ = ' ';
p += to_base64(statp->st_ctime, p);
*p++ = ' ';
#ifdef HAVE_CHFLAGS
// chflags is a FreeBSD function.
p += to_base64(statp->st_flags, p);
#else
p += to_base64(0, p); // place holder
#endif
*p++ = ' ';
#ifdef HAVE_WIN32
p += to_base64(sb->winattr, p);
#else
p += to_base64(0, p); // place holder
#endif
if(sb->burp1)
{
// Burp1 puts compression at the end.
*p++ = ' ';
p += to_base64(sb->compression, p);
}
*p = 0;
sb->attr.len=p-sb->attr.buf;
return 0;
}
void test_base64(void **state) {
(void) state; /* unused */
/*
* Test the base64 routines by encoding and decoding
* lstat() packets.
*/
char where[500];
int i;
char *fname;
struct stat statp;
struct stat statn;
int debug_level = 0;
char *p;
int32_t j;
time_t t = 1028712799;
fname = BINARYNAME;
base64_init();
if (lstat(fname, &statp) < 0) {
berrno be;
printf("Cannot stat %s: %s\n", fname, be.bstrerror(errno));
}
encode_stat(where, &statp, sizeof(statp), 0, 0);
//printf("Encoded stat=%s\n", where);
#ifdef xxx
p = where;
p += to_base64((int64_t)(statp.st_atime), p);
*p++ = ' ';
p += to_base64((int64_t)t, p);
printf("%s %s\n", fname, where);
printf("%s %lld\n", "st_dev", (int64_t)statp.st_dev);
printf("%s %lld\n", "st_ino", (int64_t)statp.st_ino);
printf("%s %lld\n", "st_mode", (int64_t)statp.st_mode);
printf("%s %lld\n", "st_nlink", (int64_t)statp.st_nlink);
printf("%s %lld\n", "st_uid", (int64_t)statp.st_uid);
printf("%s %lld\n", "st_gid", (int64_t)statp.st_gid);
printf("%s %lld\n", "st_rdev", (int64_t)statp.st_rdev);
printf("%s %lld\n", "st_size", (int64_t)statp.st_size);
printf("%s %lld\n", "st_blksize", (int64_t)statp.st_blksize);
printf("%s %lld\n", "st_blocks", (int64_t)statp.st_blocks);
printf("%s %lld\n", "st_atime", (int64_t)statp.st_atime);
printf("%s %lld\n", "st_mtime", (int64_t)statp.st_mtime);
printf("%s %lld\n", "st_ctime", (int64_t)statp.st_ctime);
#endif
//printf("%s: len=%d val=%s\n", fname, strlen(where), where);
decode_stat(where, &statn, sizeof(statn), &j);
assert_false(statp.st_dev != statn.st_dev ||
statp.st_ino != statn.st_ino ||
statp.st_mode != statn.st_mode ||
statp.st_nlink != statn.st_nlink ||
statp.st_uid != statn.st_uid ||
statp.st_gid != statn.st_gid ||
statp.st_rdev != statn.st_rdev ||
statp.st_size != statn.st_size ||
statp.st_blksize != statn.st_blksize ||
statp.st_blocks != statn.st_blocks ||
statp.st_atime != statn.st_atime ||
statp.st_mtime != statn.st_mtime ||
statp.st_ctime != statn.st_ctime);
/*
{ printf("%s: %s\n", fname, where);
encode_stat(where, &statn, sizeof(statn), 0, 0);
printf("%s: %s\n", fname, where);
printf("NOT EQAL\n");
}
*/
//printf("%d files examined\n", i);
to_base64(UINT32_MAX, where);
//printf("UINT32_MAX=%s\n", where);
int xx = 0;
int len;
char buf[100];
char junk[100];
// int i;
#ifdef xxxx
for (i=0; i < 1000; i++) {
bin_to_base64(buf, sizeof(buf), (char *)&xx, 4, true);
printf("xx=%s\n", buf);
xx++;
}
#endif
junk[0] = 0xFF;
for (i=1; i<100; i++) {
junk[i] = junk[i-1]-1;
}
len = bin_to_base64(buf, sizeof(buf), junk, 16, true);
//printf("len=%d junk=%s\n", len, buf);
strcpy(junk, "This is a sample string");
len = bin_to_base64(buf, sizeof(buf), junk, strlen(junk), true);
buf[len] = 0;
base64_to_bin(junk, sizeof(junk), buf, len);
//printf("buf=<%s>\n", junk);
}
