Bignum::Bignum(const char * number) {
init();
bool symbol = false;
if (number[0] == '-') {
number += 1;
symbol = true;
}
int len = strlen(number), tmp_i = 0;
for (int i = bignum_len - 1; len > 0 && i >= 0; i--) {
tmp_i++;
if (len >= LONG_LEN) {
bignum[i] += str_to_int64(number + (len - LONG_LEN), LONG_LEN);
carry(i);
} else {
bignum[i] += str_to_int64(number, len);
break;
}
len -= LONG_LEN;
}
if (symbol) { bignum[bignum_len - tmp_i] *= -1; }
}
static bool bvfs_parse_arg(UAContext *ua,
DBId_t *pathid,
char **path,
char **jobid,
char **username,
int *limit,
int *offset)
{
*pathid = 0;
*limit = 2000;
*offset = 0;
*path = NULL;
*jobid = NULL;
*username = NULL;
for (int i=1; i<ua->argc; i++) {
if (bstrcasecmp(ua->argk[i], NT_("pathid"))) {
if (is_a_number(ua->argv[i])) {
*pathid = str_to_int64(ua->argv[i]);
}
}
if (bstrcasecmp(ua->argk[i], NT_("path"))) {
*path = ua->argv[i];
}
if (bstrcasecmp(ua->argk[i], NT_("username"))) {
*username = ua->argv[i];
}
if (bstrcasecmp(ua->argk[i], NT_("jobid"))) {
if (is_a_number_list(ua->argv[i])) {
*jobid = ua->argv[i];
}
}
if (bstrcasecmp(ua->argk[i], NT_("limit"))) {
if (is_a_number(ua->argv[i])) {
*limit = str_to_int64(ua->argv[i]);
}
}
if (bstrcasecmp(ua->argk[i], NT_("offset"))) {
if (is_a_number(ua->argv[i])) {
*offset = str_to_int64(ua->argv[i]);
}
}
}
if (!((*pathid || *path) && *jobid)) {
return false;
}
if (!open_client_db(ua, true)) {
return false;
}
return true;
}
/*
* This callback routine is responsible for inserting the
* items it gets into the bootstrap structure. For each JobId selected
* this routine is called once for each file. We do not allow
* duplicate filenames, but instead keep the info from the most
* recent file entered (i.e. the JobIds are assumed to be sorted)
*
* See uar_sel_files in sql_cmds.c for query that calls us.
* row[0]=Path, row[1]=Filename, row[2]=FileIndex
* row[3]=JobId row[4]=LStat
*/
static int insert_bootstrap_handler(void *ctx, int num_fields, char **row)
{
JobId_t JobId;
int FileIndex;
RBSR *bsr = (RBSR *)ctx;
JobId = str_to_int64(row[3]);
FileIndex = str_to_int64(row[2]);
add_findex(bsr, JobId, FileIndex);
return 0;
}
/*
* Called here to make in memory list of JobIds to be
* deleted and the associated PurgedFiles flag.
* The in memory list will then be transversed
* to issue the SQL DELETE commands. Note, the list
* is allowed to get to MAX_DEL_LIST_LEN to limit the
* maximum malloc'ed memory.
*/
int job_delete_handler(void *ctx, int num_fields, char **row)
{
struct del_ctx *del = (struct del_ctx *)ctx;
if (!grow_del_list(del)) {
return 1;
}
del->JobId[del->num_ids] = (JobId_t)str_to_int64(row[0]);
Dmsg2(60, "job_delete_handler row=%d val=%d\n", del->num_ids, del->JobId[del->num_ids]);
del->PurgedFiles[del->num_ids++] = (char)str_to_int64(row[1]);
return 0;
}
/*
* Return next JobId from comma separated list
*
* Returns:
* 1 if next JobId returned
* 0 if no more JobIds are in list
* -1 there is an error
*/
int get_next_jobid_from_list(char **p, uint32_t *JobId)
{
const int maxlen = 30;
char jobid[maxlen+1];
char *q = *p;
jobid[0] = 0;
for (int i=0; i<maxlen; i++) {
if (*q == 0) {
break;
} else if (*q == ',') {
q++;
break;
}
jobid[i] = *q++;
jobid[i+1] = 0;
}
if (jobid[0] == 0) {
return 0;
} else if (!is_a_number(jobid)) {
return -1; /* error */
}
*p = q;
*JobId = str_to_int64(jobid);
return 1;
}
int64_t Config::get_int64(const char *key) const{
const Config *c = this->get(key);
if(!c){
return 0;
}
return str_to_int64(c->val);
}
int SSDB::zincr(const Bytes &name, const Bytes &key, int64_t by, std::string *new_val, char log_type){
Transaction trans(binlogs);
int64_t val;
std::string old;
int ret = this->zget(name, key, &old);
if(ret == -1){
return -1;
}else if(ret == 0){
val = by;
}else{
val = str_to_int64(old.data(), old.size()) + by;
}
*new_val = int64_to_str(val);
ret = zset_one(this, name, key, *new_val, log_type);
if(ret >= 0){
if(ret > 0){
if(incr_zsize(this, name, ret) == -1){
return -1;
}
}
leveldb::Status s = binlogs->commit();
if(!s.ok()){
log_error("zset error: %s", s.ToString().c_str());
return -1;
}
}
return ret;
}
static bool bvfs_parse_arg_version(UAContext *ua, char **client, DBId_t *fnid, bool *versions, bool *copies)
{
*fnid = 0;
*client = NULL;
*versions = false;
*copies = false;
for (int i = 1; i < ua->argc; i++) {
if (bstrcasecmp(ua->argk[i], NT_("fnid")) ||
bstrcasecmp(ua->argk[i], NT_("filenameid"))) {
if (is_a_number(ua->argv[i])) {
*fnid = str_to_int64(ua->argv[i]);
}
}
if (bstrcasecmp(ua->argk[i], NT_("client"))) {
*client = ua->argv[i];
}
if (copies && bstrcasecmp(ua->argk[i], NT_("copies"))) {
*copies = true;
}
if (versions && bstrcasecmp(ua->argk[i], NT_("versions"))) {
*versions = true;
}
}
return (*client && *fnid > 0);
}
int SSDBImpl::hincr(const Bytes &name, const Bytes &key, int64_t by, int64_t *new_val, char log_type){
Transaction trans(binlogs);
std::string old;
int ret = this->hget(name, key, &old);
if(ret == -1){
return -1;
}else if(ret == 0){
*new_val = by;
}else{
*new_val = str_to_int64(old) + by;
if(errno != 0){
return 0;
}
}
ret = hset_one(this, name, key, str(*new_val), log_type);
if(ret == -1){
return -1;
}
if(ret >= 0){
if(ret > 0){
if(incr_hsize(this, name, ret) == -1){
return -1;
}
}
leveldb::Status s = binlogs->commit();
if(!s.ok()){
return -1;
}
}
return 1;
}
static void fill_attr(ATTR_DBR *ar, char *data)
{
char *p;
char *b;
int index=0;
ar->Stream = STREAM_UNIX_ATTRIBUTES;
ar->JobId = getpid();
for(p = b = data; *p; p++) {
if (*p == ';') {
*p = '\0';
switch (index) {
case 0:
ar->FileIndex = str_to_int64(b);
break;
case 1:
ar->fname = b;
break;
case 2:
ar->attr = b;
break;
case 3:
ar->Digest = b;
break;
}
index++;
b = ++p;
}
}
}
static int result_handler(void *ctx, int fields, char **row)
{
Bvfs *vfs = (Bvfs *)ctx;
ATTR *attr = vfs->get_attr();
char empty[] = "A A A A A A A A A A A A A A";
memset(&attr->statp, 0, sizeof(struct stat));
decode_stat((row[BVFS_LStat] && row[BVFS_LStat][0])?row[BVFS_LStat]:empty,
&attr->statp, sizeof(attr->statp), &attr->LinkFI);
if (bvfs_is_dir(row) || bvfs_is_file(row)) {
/* display clean stuffs */
if (bvfs_is_dir(row)) {
pm_strcpy(attr->ofname, bvfs_basename_dir(row[BVFS_Name]));
} else {
/* if we see the requested file, note his filenameid */
if (bstrcmp(row[BVFS_Name], file)) {
fnid = str_to_int64(row[BVFS_FilenameId]);
}
pm_strcpy(attr->ofname, row[BVFS_Name]);
}
print_ls_output(vfs->get_jcr(), attr);
} else {
Pmsg5(0, "JobId=%s FileId=%s\tMd5=%s\tVolName=%s\tVolInChanger=%s\n",
row[BVFS_JobId], row[BVFS_FileId], row[BVFS_Md5], row[BVFS_VolName],
row[BVFS_VolInchanger]);
pm_strcpy(attr->ofname, file);
print_ls_output(vfs->get_jcr(), attr);
}
return 0;
}
int SSDB::incr(const Bytes &key, int64_t by, std::string *new_val, char log_type){
Transaction trans(binlogs);
int64_t val;
std::string old;
int ret = this->get(key, &old);
if(ret == -1){
return -1;
}else if(ret == 0){
val = by;
}else{
val = str_to_int64(old.data(), old.size()) + by;
}
*new_val = int64_to_str(val);
std::string buf = encode_kv_key(key);
binlogs->Put(buf, *new_val);
binlogs->add_log(log_type, BinlogCommand::KSET, buf);
leveldb::Status s = binlogs->commit();
if(!s.ok()){
log_error("del error: %s", s.ToString().c_str());
return -1;
}
return 1;
}
/*
* Find JobId of last job that ran. E.g. for
* VERIFY_CATALOG we want the JobId of the last INIT.
* For VERIFY_VOLUME_TO_CATALOG, we want the JobId of the last Job.
*
* Returns: true on success
* false on failure
*/
bool
db_find_last_jobid(JCR *jcr, B_DB *mdb, const char *Name, JOB_DBR *jr)
{
SQL_ROW row;
char ed1[50];
/* Find last full */
db_lock(mdb);
Dmsg2(100, "JobLevel=%d JobType=%d\n", jr->JobLevel, jr->JobType);
if (jr->JobLevel == L_VERIFY_CATALOG) {
Mmsg(mdb->cmd,
"SELECT JobId FROM Job WHERE Type='V' AND Level='%c' AND "
" JobStatus IN ('T','W') AND Name='%s' AND "
"ClientId=%s ORDER BY StartTime DESC LIMIT 1",
L_VERIFY_INIT, jr->Name,
edit_int64(jr->ClientId, ed1));
} else if (jr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG ||
jr->JobLevel == L_VERIFY_DISK_TO_CATALOG ||
jr->JobType == JT_BACKUP) {
if (Name) {
Mmsg(mdb->cmd,
"SELECT JobId FROM Job WHERE Type='B' AND JobStatus IN ('T','W') AND "
"Name='%s' ORDER BY StartTime DESC LIMIT 1", Name);
} else {
Mmsg(mdb->cmd,
"SELECT JobId FROM Job WHERE Type='B' AND JobStatus IN ('T','W') AND "
"ClientId=%s ORDER BY StartTime DESC LIMIT 1",
edit_int64(jr->ClientId, ed1));
}
} else {
Mmsg1(&mdb->errmsg, _("Unknown Job level=%d\n"), jr->JobLevel);
db_unlock(mdb);
return false;
}
Dmsg1(100, "Query: %s\n", mdb->cmd);
if (!QUERY_DB(jcr, mdb, mdb->cmd)) {
db_unlock(mdb);
return false;
}
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg1(&mdb->errmsg, _("No Job found for: %s.\n"), mdb->cmd);
sql_free_result(mdb);
db_unlock(mdb);
return false;
}
jr->JobId = str_to_int64(row[0]);
sql_free_result(mdb);
Dmsg1(100, "db_get_last_jobid: got JobId=%d\n", jr->JobId);
if (jr->JobId <= 0) {
Mmsg1(&mdb->errmsg, _("No Job found for: %s\n"), mdb->cmd);
db_unlock(mdb);
return false;
}
db_unlock(mdb);
return true;
}
int64_t ExpirationHandler::get_ttl(const Bytes &key){
std::string score;
if(ssdb->zget(this->list_name, key, &score) == 1){
int64_t ex = str_to_int64(score);
return (ex - time_ms())/1000;
}
return -1;
}
/*
* Called here to make in memory list of JobIds to be
* deleted and the associated PurgedFiles flag.
* The in memory list will then be transversed
* to issue the SQL DELETE commands. Note, the list
* is allowed to get to MAX_DEL_LIST_LEN to limit the
* maximum malloc'ed memory.
*/
int job_delete_handler(void *ctx, int num_fields, char **row)
{
struct del_ctx *del = (struct del_ctx *)ctx;
if (del->num_ids == MAX_DEL_LIST_LEN) {
return 1;
}
if (del->num_ids == del->max_ids) {
del->max_ids = (del->max_ids * 3) / 2;
del->JobId = (JobId_t *)brealloc(del->JobId, sizeof(JobId_t) * del->max_ids);
del->PurgedFiles = (char *)brealloc(del->PurgedFiles, del->max_ids);
}
del->JobId[del->num_ids] = (JobId_t)str_to_int64(row[0]);
// Dmsg2(60, "row=%d val=%d\n", del->num_ids, del->JobId[del->num_ids]);
del->PurgedFiles[del->num_ids++] = (char)str_to_int64(row[1]);
return 0;
}
int main(int argc, char **argv[])
{
char *s;
int error;
int64_t i;
uint64_t u;
//s = "-128";
//s = "-32768";
//s = "-2147483648";
//s = "-9223372036854775808";
//s = "128";
//s = "32768";
//s = "2147483648";
//s = "9223372036854775808";
//s = "255";
//s = "65535";
//s = "4294967295";
s = "18446744073709551615";
//s = "256";
//s = "65536";
//s = "4294967296";
//s = "18446744073709551616";
printf("s = '%s'\n\n", s);
i = str_to_int64(s, INT8_MIN, INT8_MAX, &error);
printf(" 8: i = %lld error = %d\n", i, error);
i = str_to_int64(s, INT16_MIN, INT16_MAX, &error);
printf("16: i = %lld error = %d\n", i, error);
i = str_to_int64(s, INT32_MIN, INT32_MAX, &error);
printf("32: i = %lld error = %d\n", i, error);
i = str_to_int64(s, INT64_MIN, INT64_MAX, &error);
printf("64: i = %lld error = %d\n", i, error);
printf("\n");
u = str_to_uint64(s, UINT8_MAX, &error);
printf(" 8: u = %llu error = %d\n", u, error);
u = str_to_uint64(s, UINT16_MAX, &error);
printf("16: u = %llu error = %d\n", u, error);
u = str_to_uint64(s, UINT32_MAX, &error);
printf("32: u = %llu error = %d\n", u, error);
u = str_to_uint64(s, UINT64_MAX, &error);
printf("64: u = %llu error = %d\n", u, error);
return 0;
}
int64_t config_get_default_int(const config_t *config, const char *section,
const char *name)
{
const char *value = config_get_default_string(config, section, name);
if (value)
return str_to_int64(value);
return 0;
}
/*
* Called here to retrieve a 32/64 bit integer from the database.
* The returned integer will be extended to 64 bit.
*/
int db_int64_handler(void *ctx, int num_fields, char **row)
{
db_int64_ctx *lctx = (db_int64_ctx *)ctx;
if (row[0]) {
lctx->value = str_to_int64(row[0]);
lctx->count++;
}
return 0;
}
int file_delete_handler(void *ctx, int num_fields, char **row)
{
struct del_ctx *del = (struct del_ctx *)ctx;
if (!grow_del_list(del)) {
return 1;
}
del->JobId[del->num_ids++] = (JobId_t)str_to_int64(row[0]);
// Dmsg2(150, "row=%d val=%d\n", del->num_ids-1, del->JobId[del->num_ids-1]);
return 0;
}
/*
* Called here to count entries to be deleted
*/
int del_count_handler(void *ctx, int num_fields, char **row)
{
struct s_count_ctx *cnt = (struct s_count_ctx *)ctx;
if (row[0]) {
cnt->count = str_to_int64(row[0]);
} else {
cnt->count = 0;
}
return 0;
}
inline static
Status _read_int64(const std::vector<std::string> *resp, int64_t *ret){
Status s(resp);
if(s.ok()){
if(resp->size() >= 2){
*ret = str_to_int64(resp->at(1));
}else{
return Status("server_error");
}
}
return s;
}
long long SSDBClient::TTL(const std::string& key)
{
Base::Mutex::ScopedLock scopedLock(m_oMutex);
long long ttl = 0;
const std::vector<std::string>* rsp = m_Client->request("ttl", RealKey(key));
ssdb::Status status(rsp);
if (status.ok() && rsp->size() >= 2)
{
ttl = str_to_int64(rsp->at(1));
}
return ttl;
}
/*
* Delete Pool record, must also delete all associated
* Media records.
*
* Returns: false on error
* true on success
* PoolId = number of Pools deleted (should be 1)
* NumVols = number of Media records deleted
*/
bool db_delete_pool_record(JCR *jcr, B_DB *mdb, POOL_DBR *pr)
{
bool retval = false;
SQL_ROW row;
int num_rows;
char esc[MAX_ESCAPE_NAME_LENGTH];
db_lock(mdb);
mdb->db_escape_string(jcr, esc, pr->Name, strlen(pr->Name));
Mmsg(mdb->cmd, "SELECT PoolId FROM Pool WHERE Name='%s'", esc);
Dmsg1(10, "selectpool: %s\n", mdb->cmd);
pr->PoolId = pr->NumVols = 0;
if (QUERY_DB(jcr, mdb, mdb->cmd)) {
num_rows = sql_num_rows(mdb);
if (num_rows == 0) {
Mmsg(mdb->errmsg, _("No pool record %s exists\n"), pr->Name);
sql_free_result(mdb);
goto bail_out;
} else if (num_rows != 1) {
Mmsg(mdb->errmsg, _("Expecting one pool record, got %d\n"), num_rows);
sql_free_result(mdb);
goto bail_out;
}
if ((row = sql_fetch_row(mdb)) == NULL) {
Mmsg1(mdb->errmsg, _("Error fetching row %s\n"), sql_strerror(mdb));
goto bail_out;
}
pr->PoolId = str_to_int64(row[0]);
sql_free_result(mdb);
}
/* Delete Media owned by this pool */
Mmsg(mdb->cmd,
"DELETE FROM Media WHERE Media.PoolId = %d", pr->PoolId);
pr->NumVols = DELETE_DB(jcr, mdb, mdb->cmd);
Dmsg1(200, "Deleted %d Media records\n", pr->NumVols);
/* Delete Pool */
Mmsg(mdb->cmd,
"DELETE FROM Pool WHERE Pool.PoolId = %d", pr->PoolId);
pr->PoolId = DELETE_DB(jcr, mdb, mdb->cmd);
Dmsg1(200, "Deleted %d Pool records\n", pr->PoolId);
retval = true;
bail_out:
db_unlock(mdb);
return retval;
}
Status ClientImpl::qpush(const std::string &name, const std::vector<std::string> &items, int64_t *ret_size){
const std::vector<std::string> *resp;
resp = this->request("qpush", name, items);
Status s(resp);
if(ret_size != NULL && s.ok()){
if(resp->size() > 1){
*ret_size = str_to_int64(resp->at(1));
}else{
return Status("error");
}
}
return s;
}
/* row: Job.Name, FileSet, Client.Name, FileSetId, ClientId, Type */
static int job_select_handler(void *ctx, int num_fields, char **row)
{
alist *lst = (alist *)ctx;
struct accurate_check_ctx *res;
ASSERT(num_fields == 6);
/* Quick fix for #5507, avoid locking res_head after db_lock() */
#ifdef bug5507
/* If this job doesn't exist anymore in the configuration, delete it */
if (GetResWithName(R_JOB, row[0]) == NULL) {
return 0;
}
/* If this fileset doesn't exist anymore in the configuration, delete it */
if (GetResWithName(R_FILESET, row[1]) == NULL) {
return 0;
}
/* If this client doesn't exist anymore in the configuration, delete it */
if (GetResWithName(R_CLIENT, row[2]) == NULL) {
return 0;
}
#endif
/* Don't compute accurate things for Verify jobs */
if (*row[5] == 'V') {
return 0;
}
res = (struct accurate_check_ctx*) malloc(sizeof(struct accurate_check_ctx));
res->FileSetId = str_to_int64(row[3]);
res->ClientId = str_to_int64(row[4]);
lst->append(res);
// Dmsg2(150, "row=%d val=%d\n", del->num_ids-1, del->JobId[del->num_ids-1]);
return 0;
}
int proc_zsum(NetworkServer *net, Link *link, const Request &req, Response *resp){
SSDBServer *serv = (SSDBServer *)net->data;
CHECK_NUM_PARAMS(4);
int64_t sum = 0;
ZIterator *it = serv->ssdb->zscan(req[1], "", req[2], req[3], -1);
while(it->next()){
sum += str_to_int64(it->score);
}
delete it;
resp->reply_int(0, sum);
return 0;
}
/*
* Called here to make in memory list of JobIds to be
* deleted. The in memory list will then be transversed
* to issue the SQL DELETE commands. Note, the list
* is allowed to get to MAX_DEL_LIST_LEN to limit the
* maximum malloc'ed memory.
*/
static int delete_handler(void *ctx, int num_fields, char **row)
{
struct s_del_ctx *del = (struct s_del_ctx *)ctx;
if (del->num_ids == MAX_DEL_LIST_LEN) {
return 1;
}
if (del->num_ids == del->max_ids) {
del->max_ids = (del->max_ids * 3) / 2;
del->JobId = (JobId_t *)brealloc(del->JobId, sizeof(JobId_t) *
del->max_ids);
}
del->JobId[del->num_ids++] = (JobId_t)str_to_int64(row[0]);
return 0;
}
int SSDB::zincr(const Bytes &name, const Bytes &key, int64_t by, std::string *new_val) const{
int64_t val;
std::string old;
int ret = this->zget(name, key, &old);
if(ret == -1){
return -1;
}else if(ret == 0){
val = by;
}else{
val = str_to_int64(old.data(), old.size()) + by;
}
*new_val = int64_to_str(val);
return this->zset(name, key, *new_val);
}
/*
* Called here to retrieve an integer from the database
*/
int db_int_handler(void *ctx, int num_fields, char **row)
{
uint32_t *val = (uint32_t *)ctx;
Dmsg1(800, "int_handler starts with row pointing at %x\n", row);
if (row[0]) {
Dmsg1(800, "int_handler finds '%s'\n", row[0]);
*val = str_to_int64(row[0]);
} else {
Dmsg0(800, "int_handler finds zero\n");
*val = 0;
}
Dmsg0(800, "int_handler finishes\n");
return 0;
}
Status ClientImpl::zsize(const std::string &name, int64_t *ret){
std::vector<std::string> req;
const std::vector<std::string> *resp;
req.push_back("zsize");
req.push_back(name);
resp = request(req);
Status s(resp);
if(s.ok()){
if(resp->size() >= 2){
*ret = str_to_int64(resp->at(1));
}else{
return Status("server_error");
}
}
return s;
}
