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); }