relation_t *
relation_load(char *name)
{
relation_t *rel;
rel = relation_find(name);
if(rel != NULL) {
rel->references++;
goto end;
}
rel = relation_allocate();
if(rel == NULL) {
return NULL;
}
if(DB_ERROR(storage_get_relation(rel, name))) {
memb_free(&relations_memb, rel);
return NULL;
}
memcpy(rel->name, name, sizeof(rel->name));
rel->name[sizeof(rel->name) - 1] = '\0';
rel->references = 1;
list_add(relations, rel);
end:
if(rel->dir == DB_STORAGE && DB_ERROR(storage_load(rel))) {
relation_release(rel);
return NULL;
}
return rel;
}
void Trie::StorageAssociated(const Location& location, std::vector<std::string>& result){
protocol::Node info;
if (!storage_load(location, info)){
return;
}
if (info.children(16).childtype() == protocol::CHILDTYPE::LEAF){
std::string v;
StorageGetLeaf(location, v);
result.push_back(v);
}
for (int i = 0; i < 16; i++){
protocol::Child chd = info.children(i);
protocol::CHILDTYPE type = chd.childtype();
switch (type)
{
case protocol::NONE:
break;
case protocol::INNER:
StorageAssociated(chd.sublocation(), result);
break;
case protocol::LEAF:
std::string value;
StorageGetLeaf(chd.sublocation(), value);
result.push_back(value);
break;
}
}
}
GKeyFile *connman_storage_load_service(const char *service_id)
{
gchar *pathname;
GKeyFile *keyfile = NULL;
pathname = g_strdup_printf("%s/%s/%s", STORAGEDIR, service_id, SETTINGS);
if (!pathname)
return NULL;
keyfile = storage_load(pathname);
g_free(pathname);
return keyfile;
}
GKeyFile *__connman_storage_load_global(void)
{
gchar *pathname;
GKeyFile *keyfile = NULL;
pathname = g_strdup_printf("%s/%s", STORAGEDIR, SETTINGS);
if (!pathname)
return NULL;
keyfile = storage_load(pathname);
g_free(pathname);
return keyfile;
}
GKeyFile *__connman_storage_load_provider(const char *identifier)
{
gchar *pathname;
GKeyFile *keyfile;
pathname = g_strdup_printf("%s/%s_%s/%s", STORAGEDIR, "provider",
identifier, SETTINGS);
if (!pathname)
return NULL;
keyfile = storage_load(pathname);
g_free(pathname);
return keyfile;
}
GKeyFile *__connman_storage_load_provider_config(const char *ident)
{
gchar *pathname;
GKeyFile *keyfile = NULL;
pathname = g_strdup_printf("%s/%s.config", VPN_STORAGEDIR, ident);
if (!pathname)
return NULL;
keyfile = storage_load(pathname);
g_free(pathname);
return keyfile;
}
static void storage_serialize(at **pp, int code)
{
storage_t *st;
int type, kind;
size_t size;
if (code != SRZ_READ) {
st = Mptr(*pp);
type = (int)st->type;
kind = (int)st->kind;
size = st->size;
}
// Read/write basic info
serialize_int(&type, code);
serialize_int(&kind, code);
serialize_size(&size, code);
// Create storage if needed
if (code == SRZ_READ) {
st = new_storage_managed((storage_type_t)type, size, NIL);
*pp = st->backptr;
}
// Read/write storage data
st = Mptr(*pp);
if (type == ST_AT) {
at **data = st->data;
for (int i=0; i<size; i++)
serialize_atstar( &data[i], code);
} else {
FILE *f = serialization_file_descriptor(code);
if (code == SRZ_WRITE) {
extern int in_bwrite;
in_bwrite += sizeof(int) + size * storage_sizeof[type];
write4(f, STORAGE_NORMAL);
storage_save(st, f);
} else if (code == SRZ_READ) {
int magic = read4(f);
storage_load(st, f);
if (magic == STORAGE_SWAPPED)
swap_buffer(st->data, size, storage_sizeof[type]);
else if (magic != STORAGE_NORMAL)
RAISEF("Corrupted binary file",NIL);
}
}
}
void Trie::GetAllItem(const Location& node, const Location& location, std::vector<std::string>& result){
protocol::Node info;
if (!storage_load(node, info)){
return;
}
Location common = CommonPrefix(node, location);
if (common == location){
StorageAssociated(node, result);
return;
}
if (common == node){
int nextbranch = NextBranch(common, location);
Location location2 = info.children(nextbranch).sublocation();
GetAllItem(location2, location, result);
}
}
GKeyFile *__connman_storage_open_service(const char *service_id)
{
gchar *pathname;
GKeyFile *keyfile = NULL;
pathname = g_strdup_printf("%s/%s/%s", STORAGEDIR, service_id, SETTINGS);
if(pathname == NULL)
return NULL;
keyfile = storage_load(pathname);
if (keyfile) {
g_free(pathname);
return keyfile;
}
g_free(pathname);
keyfile = g_key_file_new();
return keyfile;
}
storage_status_t storage_rename (const char *onick, const char *nnick, const char *password)
{
storage_status_t status;
GList *gl = global.storage;
storage_t *primary_storage = gl->data;
irc_t *irc;
/* First, try to rename in the current write backend, assuming onick
* is stored there */
status = primary_storage->rename(onick, nnick, password);
if (status != STORAGE_NO_SUCH_USER)
return status;
/* Try to load from a migration backend and save to the current backend.
* Explicitly remove the account from the migration backend as otherwise
* it'd still be usable under the old name */
irc = g_new0(irc_t, 1);
status = storage_load(onick, password, irc);
if (status != STORAGE_OK) {
irc_free(irc);
return status;
}
g_free(irc->nick);
irc->nick = g_strdup(nnick);
status = storage_save(irc, FALSE);
if (status != STORAGE_OK) {
irc_free(irc);
return status;
}
irc_free(irc);
storage_remove(onick, password);
return STORAGE_OK;
}
NodeFrm::POINTER Trie::ChildMayFromDB(NodeFrm::POINTER node, int branch) {
if (node->children_[branch] == nullptr){
NodeFrm::POINTER frm = nullptr;
const protocol::Child& chd = node->info_.children(branch);
if (chd.childtype() == protocol::NONE){
return nullptr;
}
frm = std::make_shared<NodeFrm>(chd.sublocation());
frm->modified_ = false;
if (chd.childtype() == protocol::LEAF){
frm->info_.mutable_children(16)->CopyFrom(node->info_.children(branch));
}
else if (chd.childtype() == protocol::INNER){
if (!storage_load(chd.sublocation(), frm->info_)){
PROCESS_EXIT("load:%s failed", utils::String::BinToHexString(chd.sublocation()).c_str());
}
}
node->children_[branch] = frm;
}
return node->children_[branch];
}
static void cmd_identify(irc_t *irc, char **cmd)
{
storage_status_t status;
gboolean load = TRUE;
char *password = cmd[1];
if (irc->status & USTATUS_IDENTIFIED) {
irc_rootmsg(irc, "You're already logged in.");
return;
}
if (cmd[1] == NULL) {
} else if (strncmp(cmd[1], "-no", 3) == 0) {
load = FALSE;
password = cmd[2];
if (password == NULL) {
irc->status |= OPER_HACK_IDENTIFY_NOLOAD;
}
} else if (strncmp(cmd[1], "-force", 6) == 0) {
password = cmd[2];
if (password == NULL) {
irc->status |= OPER_HACK_IDENTIFY_FORCE;
}
} else if (irc->b->accounts != NULL) {
irc_rootmsg(irc,
"You're trying to identify yourself, but already have "
"at least one IM account set up. "
"Use \x02identify -noload\x02 or \x02identify -force\x02 "
"instead (see \x02help identify\x02).");
return;
}
if (password == NULL) {
irc_rootmsg(irc, "About to identify, use /OPER to enter the password");
irc->status |= OPER_HACK_IDENTIFY;
return;
}
status = auth_check_pass(irc, irc->user->nick, password);
if (load && (status == STORAGE_OK)) {
status = storage_load(irc, password);
}
switch (status) {
case STORAGE_INVALID_PASSWORD:
irc_rootmsg(irc, "Incorrect password");
break;
case STORAGE_NO_SUCH_USER:
irc_rootmsg(irc, "The nick is (probably) not registered");
break;
case STORAGE_OK:
irc_rootmsg(irc, "Password accepted%s",
load ? ", settings and accounts loaded" : "");
irc->status |= USTATUS_IDENTIFIED;
irc_umode_set(irc, "+R", 1);
if (irc->caps & CAP_SASL) {
irc_user_t *iu = irc->user;
irc_send_num(irc, 900, "%s!%s@%s %s :You are now logged in as %s",
iu->nick, iu->user, iu->host, iu->nick, iu->nick);
}
bitlbee_whatsnew(irc);
/* The following code is a bit hairy now. With takeover
support, we shouldn't immediately auto_connect in case
we're going to offer taking over an existing session.
Do it in 200ms since that should give the parent process
enough time to come back to us. */
if (load) {
irc_channel_auto_joins(irc, NULL);
if (!set_getbool(&irc->default_channel->set, "auto_join")) {
irc_channel_del_user(irc->default_channel, irc->user,
IRC_CDU_PART, "auto_join disabled "
"for this channel.");
}
if (set_getbool(&irc->b->set, "auto_connect")) {
irc->login_source_id = b_timeout_add(200,
cmd_identify_finish, irc);
}
}
/* If ipc_child_identify() returns FALSE, it means we're
already sure that there's no takeover target (only
possible in 1-process daemon mode). Start auto_connect
immediately. */
if (!ipc_child_identify(irc) && load) {
cmd_identify_finish(irc, 0, 0);
}
break;
case STORAGE_OTHER_ERROR:
default:
irc_rootmsg(irc, "Unknown error while loading configuration");
break;
}
}
void timers_init() {
APP_LOG(APP_LOG_LEVEL_INFO,"timers_init()");
count=count_create();
storage_load();
scheduler_init(handleAlarm,&nearest);
}
