int cmd_list(int argc, char *argv[]) { storage_t storage; const char *elem; if (argc != 2) { int help_argc = 2; char *help_argv[] = { "help_err", "list", NULL }; return cmd_help(help_argc, help_argv); } if ((storage = storage_new(argv[1], 0)) == NULL) errx(EXIT_FAILURE, "unable to open storage: %s", argv[1]); elem = storage_list(storage, "backups"); while (elem != NULL) { printf("%s\n", elem); elem = storage_list(storage, NULL); } storage_delete(storage); return EXIT_SUCCESS; }
int cmd_purge(int argc, char *argv[]) { storage_t storage; strset_t backups; strset_t objects; const char *elem; struct mark_backup_args args; if (argc != 2) { int help_argc = 2; char *help_argv[] = { "help_err", "purge", NULL }; return cmd_help_err(help_argc, help_argv); } if ((storage = storage_new(argv[1], false, true)) == NULL) logger(LOG_ERROR, "unable to open storage: %s", argv[1]); if (!storage_lock(storage, true, options_get()->force)) logger(LOG_ERROR, "backup directory locked, use -f to force operation"); backups = strset_new(); objects = strset_new(); /* Get the list of backups. */ elem = storage_list(storage, "backups"); while (elem != NULL) { strset_add(backups, elem); elem = storage_list(storage, NULL); } /* Get the list of objects. */ elem = storage_list(storage, "objects"); while (elem != NULL) { strset_add(objects, elem); elem = storage_list(storage, NULL); } /* ** For each backup, call mark_backup, which will mark all the objects of a ** backup as used (it will actually remove them from the `objects` strset. */ args.objects = objects; args.storage = storage; strset_foreach(backups, mark_backup, &args); /* Delete every object remaining in the `objects` strset. */ strset_foreach(objects, delete_object, (void *) storage); strset_delete(backups); strset_delete(objects); storage_unlock(storage); storage_delete(storage); return EXIT_SUCCESS; }
void __connman_storage_delete_global(void) { gchar *pathname; pathname = g_strdup_printf("%s/%s", STORAGEDIR, SETTINGS); if (!pathname) return; storage_delete(pathname); g_free(pathname); }
int cmd_restore(int argc, char *argv[]) { storage_t storage; FILE *backup; char *backup_name; char *download_path; char buf[4096]; if (!(argc == 3 || (argc == 2 && options['i']))) { int help_argc = 2; char *help_argv[] = { "help_err", "restore", NULL }; return cmd_help(help_argc, help_argv); } if ((storage = storage_new(argv[1], 0)) == NULL) errx(EXIT_FAILURE, "unable to open storage: %s", argv[1]); if (argc == 3) { backup_name = estrdup(argv[2]); } else { printf("Available backups:\n"); if (cmd_list(argc, argv) == EXIT_FAILURE) return EXIT_FAILURE; backup_name = readline("Enter the backup name to restore: "); /* Cleanly exit if the user did not enter any backup to restore. */ if (backup_name == NULL || strlen(backup_name) == 0) return EXIT_SUCCESS; } download_path = path_concat("backups", backup_name); free(backup_name); if ((backup = storage_retrieve_file(storage, download_path)) == NULL) errx(EXIT_FAILURE, "unable to retrieve the backup description file"); free(download_path); while (fgets(buf, 4096, backup) != NULL) unhash_dispatch(storage, "", buf); if (ferror(backup)) errx(EXIT_FAILURE, "unable to restore the backup"); fclose(backup); storage_delete(storage); return EXIT_SUCCESS; }
static void _roster_publish_save_item(user_t user, item_t item) { os_t os; os_object_t o; char filter[4096]; int i; log_debug(ZONE, "saving roster item %s for %s", jid_full(item->jid), jid_user(user->jid)); os = os_new(); o = os_object_new(os); os_object_put(o, "jid", jid_full(item->jid), os_type_STRING); if(item->name != NULL) os_object_put(o, "name", item->name, os_type_STRING); os_object_put(o, "to", &item->to, os_type_BOOLEAN); os_object_put(o, "from", &item->from, os_type_BOOLEAN); os_object_put(o, "ask", &item->ask, os_type_INTEGER); snprintf(filter, 4096, "(jid=%s)", jid_full(item->jid)); storage_replace(user->sm->st, "roster-items", jid_user(user->jid), filter, os); os_free(os); snprintf(filter, 4096, "(jid=%s)", jid_full(item->jid)); if(item->ngroups == 0) { storage_delete(user->sm->st, "roster-groups", jid_user(user->jid), filter); return; } os = os_new(); for(i = 0; i < item->ngroups; i++) { o = os_object_new(os); os_object_put(o, "jid", jid_full(item->jid), os_type_STRING); os_object_put(o, "group", item->groups[i], os_type_STRING); } storage_replace(user->sm->st, "roster-groups", jid_user(user->jid), filter, os); os_free(os); }
int cmd_delete(int argc, char *argv[]) { storage_t storage; char *backup_name; char *unlink_path; if (!(argc == 3 || (argc == 2 && options_get()->interactive))) { int help_argc = 2; char *help_argv[] = { "help_err", "delete", NULL }; return cmd_help_err(help_argc, help_argv); } if ((storage = storage_new(argv[1], false, false)) == NULL) logger(LOG_ERROR, "unable to open storage: %s", argv[1]); if (argc == 3) { backup_name = estrdup(argv[2]); } else { printf("Available backups:\n"); if (cmd_list(argc, argv) == EXIT_FAILURE) return EXIT_FAILURE; backup_name = readline("Enter the backup name to delete: "); /* Cleanly exit if the user did not enter any backup to delete. */ if (backup_name == NULL || strlen(backup_name) == 0) return EXIT_SUCCESS; } unlink_path = path_concat("backups", backup_name); free(backup_name); if (!storage_unlink(storage, unlink_path)) logger(LOG_ERROR, "unable to delete the backup"); free(unlink_path); storage_delete(storage); return EXIT_SUCCESS; }
/* Request: MUST NOT have extras. MUST have key. MUST have value. Ignore CAS. */ ST_RES *cmd_qlist_del(ST_REQ *req, ST_RES *res) { if(req->extras_sz || !req->key_sz || !req->value_sz) return(set_error_code(res, MEMCACHE_STATUS_INVALID_ARGUMENTS)); MC_METADATA md; memset(&md, 0, sizeof(md)); uint8_t *qla = buf_a; int qla_sz = sizeof(buf_a); uint8_t *qlb = (uint8_t *)req->value; uint8_t *qlc = buf_b; int qlc_sz = sizeof(buf_b); int r = storage_get(&md, (char*)qla, qla_sz, req->key, req->key_sz); if(r < 0) goto exit_ok; if( (md.flags & FLAG_QLIST) == 0) { set_error_code(res, MEMCACHE_STATUS_ITEM_NOT_STORED); goto exit; } r = qlist_andnot(qlc, qlc_sz, qla, qlb); if(r == EMPTY_QLIST_SIZE) { storage_delete(req->key, req->key_sz); }else{ md.cas = (md.cas+1) || (md.cas+2); r = storage_set(&md, (char*)qlc, r, req->key, req->key_sz); if(r < 0) { set_error_code(res, MEMCACHE_STATUS_ITEM_NOT_STORED); goto exit; } } exit_ok: res->status = MEMCACHE_STATUS_OK; res->cas = md.cas; exit: return(res); }
/*========================================== * カプラ倉庫データの受信 *------------------------------------------ */ int storage_storageload(int account_id, struct storage *s) { struct map_session_data *sd; struct storage *stor; nullpo_retr(1, s); sd = map_id2sd(account_id); if(sd == NULL || sd->state.waitingdisconnect) { if(battle_config.error_log && sd == NULL) printf("storage_storageload: user not found %d\n", account_id); storage_delete(account_id); return 1; } // 既に倉庫を開いてないかチェック if(sd->state.storage_flag == 1) return 0; if(sd->state.storage_flag == 2) storage_guild_storageclose(sd); stor = account2storage(account_id); if(battle_config.save_log) printf("storageload: %d\n", account_id); memcpy(stor, s, sizeof(struct storage)); storage_sortitem(stor->store_item, MAX_STORAGE, &stor->sortkey, battle_config.personal_storage_sort); stor->storage_status = 1; sd->state.storage_flag = 1; clif_storageitemlist(sd,stor); clif_storageequiplist(sd,stor); clif_updatestorageamount(sd,stor); return 0; }
static void _iq_private_user_delete(mod_instance_t mi, jid_t jid) { log_debug(ZONE, "deleting private xml storage for %s", jid_user(jid)); storage_delete(mi->sm->st, "private", jid_user(jid), NULL); }
static mod_ret_t _vacation_in_sess(mod_instance_t mi, sess_t sess, pkt_t pkt) { module_t mod = mi->mod; vacation_t v = sess->user->module_data[mod->index]; int ns, start, end, msg; char dt[30]; pkt_t res; os_t os; os_object_t o; /* we only want to play with vacation iq packets */ if((pkt->type != pkt_IQ && pkt->type != pkt_IQ_SET) || pkt->ns != ns_VACATION) return mod_PASS; /* if it has a to, throw it out */ if(pkt->to != NULL) return -stanza_err_BAD_REQUEST; /* get */ if(pkt->type == pkt_IQ) { if(v->msg == NULL) { res = pkt_create(mod->mm->sm, "iq", "result", NULL, NULL); pkt_id(pkt, res); pkt_free(pkt); pkt_sess(res, sess); return mod_HANDLED; } ns = nad_find_scoped_namespace(pkt->nad, uri_VACATION, NULL); if(v->start != 0) { datetime_out(v->start, dt_DATETIME, dt, 30); nad_insert_elem(pkt->nad, 2, ns, "start", dt); } else nad_insert_elem(pkt->nad, 2, ns, "start", NULL); if(v->end != 0) { datetime_out(v->end, dt_DATETIME, dt, 30); nad_insert_elem(pkt->nad, 2, ns, "end", dt); } else nad_insert_elem(pkt->nad, 2, ns, "end", NULL); nad_insert_elem(pkt->nad, 2, ns, "message", v->msg); pkt_tofrom(pkt); nad_set_attr(pkt->nad, 1, -1, "type", "result", 6); pkt_sess(pkt, sess); return mod_HANDLED; } /* set */ ns = nad_find_scoped_namespace(pkt->nad, uri_VACATION, NULL); start = nad_find_elem(pkt->nad, 2, ns, "start", 1); end = nad_find_elem(pkt->nad, 2, ns, "end", 1); msg = nad_find_elem(pkt->nad, 2, ns, "message", 1); if(start < 0 || end < 0 || msg < 0) { /* forget */ if(v->msg != NULL) { free(v->msg); v->msg = NULL; } v->start = 0; v->end = 0; storage_delete(mi->sm->st, "vacation-settings", jid_user(sess->jid), NULL); res = pkt_create(mod->mm->sm, "iq", "result", NULL, NULL); pkt_id(pkt, res); pkt_free(pkt); pkt_sess(res, sess); return mod_HANDLED; } if(NAD_CDATA_L(pkt->nad, start) > 0) { strncpy(dt, NAD_CDATA(pkt->nad, start), (30 < NAD_CDATA_L(pkt->nad, start) ? 30 : NAD_CDATA_L(pkt->nad, start))); v->start = datetime_in(dt); } else v->start = 0; if(NAD_CDATA_L(pkt->nad, end) > 0) { strncpy(dt, NAD_CDATA(pkt->nad, end), (30 < NAD_CDATA_L(pkt->nad, end) ? 30 : NAD_CDATA_L(pkt->nad, end))); v->end = datetime_in(dt); } else v->end = 0; v->msg = (char *) malloc(sizeof(char) * (NAD_CDATA_L(pkt->nad, msg) + 1)); strncpy(v->msg, NAD_CDATA(pkt->nad, msg), NAD_CDATA_L(pkt->nad, msg)); v->msg[NAD_CDATA_L(pkt->nad, msg)] = '\0'; os = os_new(); o = os_object_new(os); os_object_put(o, "start", &v->start, os_type_INTEGER); os_object_put(o, "end", &v->end, os_type_INTEGER); os_object_put(o, "message", v->msg, os_type_STRING); if(storage_replace(mod->mm->sm->st, "vacation-settings", jid_user(sess->user->jid), NULL, os) != st_SUCCESS) { free(v->msg); v->msg = NULL; v->start = 0; v->end = 0; return -stanza_err_INTERNAL_SERVER_ERROR; } res = pkt_create(mod->mm->sm, "iq", "result", NULL, NULL); pkt_id(pkt, res); pkt_free(pkt); pkt_sess(res, sess); return mod_HANDLED; }
static void _vacation_user_delete(mod_instance_t mi, jid_t jid) { log_debug(ZONE, "deleting vacations settings for %s", jid_user(jid)); storage_delete(mi->sm->st, "vacation-settings", jid_user(jid), NULL); }
static mod_ret_t _offline_in_sess(mod_instance_t mi, sess_t sess, pkt_t pkt) { st_ret_t ret; os_t os; os_object_t o; nad_t nad; pkt_t queued; int ns, elem, attr; char cttl[15], cstamp[18]; time_t ttl, stamp; /* if they're becoming available for the first time */ if(pkt->type == pkt_PRESENCE && pkt->to == NULL && sess->user->top == NULL) { ret = storage_get(pkt->sm->st, "queue", jid_user(sess->jid), NULL, &os); if(ret != st_SUCCESS) { log_debug(ZONE, "storage_get returned %d", ret); return mod_PASS; } if(os_iter_first(os)) do { o = os_iter_object(os); if(os_object_get_nad(os, o, "xml", &nad)) { queued = pkt_new(pkt->sm, nad_copy(nad)); if(queued == NULL) { log_debug(ZONE, "invalid queued packet, not delivering"); } else { /* check expiry as necessary */ if((ns = nad_find_scoped_namespace(queued->nad, uri_EXPIRE, NULL)) >= 0 && (elem = nad_find_elem(queued->nad, 1, ns, "x", 1)) >= 0 && (attr = nad_find_attr(queued->nad, elem, -1, "seconds", NULL)) >= 0) { snprintf(cttl, 15, "%.*s", NAD_AVAL_L(queued->nad, attr), NAD_AVAL(queued->nad, attr)); ttl = atoi(cttl); /* it should have a x:delay stamp, because we stamp everything we store */ if((ns = nad_find_scoped_namespace(queued->nad, uri_DELAY, NULL)) >= 0 && (elem = nad_find_elem(queued->nad, 1, ns, "x", 1)) >= 0 && (attr = nad_find_attr(queued->nad, elem, -1, "stamp", NULL)) >= 0) { snprintf(cstamp, 18, "%.*s", NAD_AVAL_L(queued->nad, attr), NAD_AVAL(queued->nad, attr)); stamp = datetime_in(cstamp); if(stamp + ttl <= time(NULL)) { log_debug(ZONE, "queued packet has expired, dropping"); pkt_free(queued); continue; } } } log_debug(ZONE, "delivering queued packet to %s", jid_full(sess->jid)); pkt_sess(queued, sess); } } } while(os_iter_next(os)); os_free(os); /* drop the spool */ storage_delete(pkt->sm->st, "queue", jid_user(sess->jid), NULL); } /* pass it so that other modules and mod_presence can get it */ return mod_PASS; }
static void _active_user_delete(mod_instance_t mi, jid_t jid) { log_debug(ZONE, "deactivating user %s", jid_user(jid)); storage_delete(mi->sm->st, "active", jid_user(jid), NULL); }
/** Handles iq messages */ mod_ret_t archive_iq_in_sess(mod_instance_t mi, sess_t sess, pkt_t pkt) { int prefs, type; int section, ptr; os_t os; os_object_t o; char* owner; char buff[2048]; log_debug(ZONE, "In session"); // we only want to play IQs if((!((pkt->type & pkt_IQ) || (pkt->type & pkt_IQ_SET))) || (pkt->ns != ns_ARCHIVE)) return mod_PASS; log_debug(ZONE, "Passed through packet checks"); // if it has a to, throw it out if(pkt->to != NULL) return -stanza_err_BAD_REQUEST; // Who are we? owner=jid_user(sess->jid); // Check for no type or get to send current settings if((type = (nad_find_attr(pkt->nad, 2, -1, "type", NULL)<0)) || ((NAD_AVAL_L(pkt->nad, type ) == 3) && strncmp("get", NAD_AVAL(pkt->nad, type), 3))) { log_debug(ZONE, "Somebody is asking about settings"); send_arch_prefs(mi, sess, pkt); return mod_HANDLED; } // We are setting stuff if(pkt->type == pkt_IQ_SET) { // Prepare to store them log_debug(ZONE, "Setting archiving preferences..."); os = os_new(); if(os == NULL) return mod_PASS; o = os_object_new(os); if(o == NULL) return mod_PASS; // Get rid of old settings storage_delete(pkt->sm->st, tbl_name "_settings", owner, NULL); log_debug(ZONE, "Got rid of old preferences..."); // Find if there is an default option if(!((prefs=nad_find_elem(pkt->nad, 1, -1, "prefs", 1))>0)) return mod_PASS; ptr=nad_find_attr(pkt->nad, prefs, -1, "default", NULL); if(ptr>0) { // Defaults log_debug(ZONE, "Saving defaults..."); os_object_put(o, "jid", owner, os_type_STRING); if (strncmp("roster",NAD_AVAL(pkt->nad, ptr), NAD_AVAL_L(pkt->nad, ptr))==0) prefs=A_ROSTER; else if(strncmp("always",NAD_AVAL(pkt->nad, ptr), NAD_AVAL_L(pkt->nad, ptr))==0) prefs=A_ALWAYS; else prefs=A_NEVER; os_object_put(o, "setting", &prefs, os_type_INTEGER); log_debug(ZONE, "Setting default to %d...", prefs); // What to save always log_debug(ZONE, "Saving what to save always..."); if(((section = nad_find_elem(pkt->nad, prefs, -1, "always", 1))>0)) { log_debug(ZONE, "Found always section %d...", section); prefs=A_ALWAYS; for(ptr = nad_find_elem(pkt->nad, section, -1, "jid", 1); ptr > 0; ptr = nad_find_elem(pkt->nad, ptr, -1, "jid", 0)) { o = os_object_new(os); strncpy(buff, NAD_CDATA(pkt->nad, ptr), min(2047,NAD_CDATA_L(pkt->nad, ptr))); buff[min(2047,NAD_CDATA_L(pkt->nad, ptr))]=0; os_object_put(o, "jid", buff, os_type_STRING); os_object_put(o, "setting", &prefs, os_type_INTEGER); log_debug(ZONE, "Always archiving %s...", buff); } } // What to never save log_debug(ZONE, "Saving what never save..."); if(((section = nad_find_elem(pkt->nad, 2, -1, "never", 1))>0)) { log_debug(ZONE, "Found never section %d...", section); prefs=A_NEVER; for(ptr = nad_find_elem(pkt->nad, section, -1, "jid", 1); ptr > 0; ptr = nad_find_elem(pkt->nad, ptr, -1, "jid", 0)) { o = os_object_new(os); strncpy(buff, NAD_CDATA(pkt->nad, ptr), min(2047,NAD_CDATA_L(pkt->nad, ptr))); buff[min(2047,NAD_CDATA_L(pkt->nad, ptr))]=0; os_object_put(o, "jid", buff, os_type_STRING); os_object_put(o, "setting", &prefs, os_type_INTEGER); log_debug(ZONE, "Never archiving %s...", buff); } } // Save everything storage_put(pkt->sm->st, tbl_name "_settings", owner, os); } // Send current settings send_arch_prefs(mi, sess, pkt); return mod_HANDLED; } return mod_PASS; }