static bool complete_records(void *parsed_arguments, const char *current_argument, size_t current_argument_len, DPtrArray *possibilities, void *UNUSED(data)) { domain_t *d; bool request_success; domain_record_argument_t *args; args = (domain_record_argument_t *) parsed_arguments; assert(NULL != args->domain); if ((request_success = (COMMAND_SUCCESS == get_domain_records(args->domain, &d, FALSE, NULL)))) { Iterator it; hashtable_to_iterator(&it, d->records); for (iterator_first(&it); iterator_is_valid(&it); iterator_next(&it)) { record_t *r; r = iterator_current(&it, NULL); if (0 == strncmp(r->name, current_argument, current_argument_len)) { dptrarray_push(possibilities, (void *) r->name); } } iterator_close(&it); } return request_success; }
static command_status_t fetch_domains(domain_set_t *ds, bool force, error_t **error) { if (!ds->uptodate || force) { request_t *req; bool request_success; json_document_t *doc; req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain"); request_success = request_execute(req, RESPONSE_JSON, (void **) &doc, error); request_destroy(req); if (request_success) { Iterator it; json_value_t root; root = json_document_get_root(doc); hashtable_clear(ds->domains); json_array_to_iterator(&it, root); for (iterator_first(&it); iterator_is_valid(&it); iterator_next(&it)) { json_value_t v; v = (json_value_t) iterator_current(&it, NULL); hashtable_put(ds->domains, 0, json_get_string(v), domain_new(), NULL); // ds->domains has strdup as key_duper, don't need to strdup it ourself } iterator_close(&it); ds->uptodate = TRUE; json_document_destroy(doc); } else { return COMMAND_FAILURE; } } return COMMAND_SUCCESS; }
static void warn(t_client *client, const char *reason) { t_channel *channel; t_client *dest; t_iterator chan_it; t_iterator client_it; iterator_ctor(&chan_it, &client->channels, IT_DATA); while ((channel = iterator_current(&chan_it))) { iterator_next(&chan_it); iterator_ctor(&client_it, &channel->clients, IT_DATA); while ((dest = iterator_current(&client_it))) { iterator_next(&client_it); client_out(dest, ":%s!%s@%s QUIT :%s\r\n", client->nickname, client->name, client->server, reason ? reason : "Quit"); } } }
void server_tna(t_zs *zs, t_zc *zc, void *server) { t_iterator it; char *name; iterator_ctor(&it, ((t_server *)server)->arg->team_names, IT_DATA); while ((name = iterator_current(&it))) { zs_send_cmd_tna(zs, zc, name); iterator_next(&it); } }
void server_send_ppo_all_graphic(t_bundle *bundle) { t_server *server; t_graphic *graphic; t_iterator it; server = bundle->server; iterator_ctor(&it, server->graphic, IT_DATA); while ((graphic = iterator_current(&it))) { server_ppo(server->zs, graphic->zc, zc_get_uid(bundle->player->zc), server); iterator_next(&it); } }
static command_status_t domain_check(COMMAND_ARGS) { bool success; domain_set_t *ds; USED(arg); USED(mainopts); FETCH_ACCOUNT_DOMAINS(ds); // populate if ((success = (COMMAND_SUCCESS == fetch_domains(ds, FALSE, error)))) { time_t now; Iterator it; now = time(NULL); hashtable_to_iterator(&it, ds->domains); for (iterator_first(&it); success && iterator_is_valid(&it); iterator_next(&it)) { request_t *req; json_document_t *doc; const char *domain_name; iterator_current(&it, (void **) &domain_name); // request req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain/%s/serviceInfos", domain_name); success = request_execute(req, RESPONSE_JSON, (void **) &doc, error); request_destroy(req); // response if (success) { time_t domain_expiration; json_value_t root, expiration; root = json_document_get_root(doc); if (json_object_get_property(root, "expiration", &expiration)) { if (date_parse_to_timestamp(json_get_string(expiration), NULL, &domain_expiration)) { int diff_days; diff_days = date_diff_in_days(domain_expiration, now); if (diff_days > 0 && diff_days < 3000) { printf("%s expires in %d days\n", domain_name, diff_days); } } } json_document_destroy(doc); } } iterator_close(&it); } return success ? COMMAND_SUCCESS : COMMAND_FAILURE; }
int break_outguess(struct ogobj *og, struct arc4_stream *as, iterator *it, char **pbuf, int *pbuflen) { u_char state[4]; static u_char buf[512]; struct arc4_stream tas = *as; int length, seed, need; int bits, i, n; state[0] = steg_retrbyte(og->coeff, 8, it) ^ arc4_getbyte(as); state[1] = steg_retrbyte(og->coeff, 8, it) ^ arc4_getbyte(as); state[2] = steg_retrbyte(og->coeff, 8, it) ^ arc4_getbyte(as); state[3] = steg_retrbyte(og->coeff, 8, it) ^ arc4_getbyte(as); seed = (state[1] << 8) | state[0]; length = (state[3] << 8) | state[2]; if (seed > max_seed || length * 8 >= og->bits/2 || length < min_len) return (0); iterator_seed(it, seed); bits = MIN(og->bits, sizeof(og->coeff) * 8); n = 0; while (iterator_current(it) < bits && length > 0 && n < sizeof(buf)) { iterator_adapt(it, og->bits, length); buf[n++] = steg_retrbyte(og->coeff, 8, it); length--; } /* For testing the randomness, we need some extra information */ need = MIN(min_len, sizeof(buf)); if (n < need || !is_random(buf, n)) return (0); /* Plaintext tests? */ for (i = 0; i < n; i++) buf[i] ^= arc4_getbyte(&tas); if (file_process(buf, n) == 0) return (0); *pbuf = buf; *pbuflen = n; return (1); }
u_int32_t steg_retrbyte(u_int32_t *bitmap, int bits, iterator *iter) { u_int32_t i = iterator_current(iter); u_int32_t tmp = 0; int where; for (where = 0; where < bits; where++) { tmp |= (TEST_BIT(bitmap, i) != 0) << where; i = iterator_next(iter); } return (tmp); }
// TODO: optionnal arguments fieldType and subDomain in query string static command_status_t record_list(COMMAND_ARGS) { domain_t *d; Iterator it; command_status_t ret; domain_record_argument_t *args; USED(mainopts); args = (domain_record_argument_t *) arg; assert(NULL != args->domain); if (COMMAND_SUCCESS == (ret = get_domain_records(args->domain, &d, args->nocache, error))) { // display table_t *t; t = table_new( #ifdef PRINT_OVH_ID 5, _("id"), TABLE_TYPE_INT, #else 4, #endif /* PRINT_OVH_ID */ _("subdomain"), TABLE_TYPE_STRING, _("type"), TABLE_TYPE_ENUM, domain_record_types, _("TTL"), TABLE_TYPE_INT, _("target"), TABLE_TYPE_STRING ); hashtable_to_iterator(&it, d->records); for (iterator_first(&it); iterator_is_valid(&it); iterator_next(&it)) { record_t *r; r = iterator_current(&it, NULL); if (0 == args->type || r->type == args->type) { table_store(t, #ifdef PRINT_OVH_ID r->id, #endif /* PRINT_OVH_ID */ r->name, r->type, r->ttl, r->target ); } } iterator_close(&it); table_display(t, TABLE_FLAG_NONE); table_destroy(t); } return ret; }
static bool get_domain_records(const char *domain, domain_t **d, bool force, error_t **error) { domain_set_t *ds; bool request_success; *d = NULL; FETCH_ACCOUNT_DOMAINS(ds); request_success = TRUE; // TODO: hashtable_clear((*d)->records) if force if (!hashtable_get(ds->domains, domain, d) || !(*d)->uptodate || force) { request_t *req; json_document_t *doc; if (NULL == *d) { *d = domain_new(); hashtable_put(ds->domains, 0, domain, *d, NULL); } req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain/zone/%s/record", domain); request_success = request_execute(req, RESPONSE_JSON, (void **) &doc, error); request_destroy(req); // result if (request_success) { Iterator it; json_value_t root; root = json_document_get_root(doc); json_array_to_iterator(&it, root); for (iterator_first(&it); request_success && iterator_is_valid(&it); iterator_next(&it)) { json_value_t v; json_document_t *doc; v = (json_value_t) iterator_current(&it, NULL); req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain/zone/%s/record/%u", domain, json_get_integer(v)); request_success = request_execute(req, RESPONSE_JSON, (void **) &doc, error); request_destroy(req); // result parse_record((*d)->records, doc); } iterator_close(&it); json_document_destroy(doc); (*d)->uptodate = TRUE; } } return request_success ? COMMAND_SUCCESS : COMMAND_FAILURE; }
static size_t find_record(HashTable *records, const char *name, record_t **match) { Iterator it; size_t matches; matches = 0; hashtable_to_iterator(&it, records); for (iterator_first(&it); iterator_is_valid(&it); iterator_next(&it)) { record_t *r; r = iterator_current(&it, NULL); if (r->name[0] == name[0] && 0 == strcmp(r->name, name)) { // TODO: strcmp_l? type? ++matches; *match = r; } } iterator_close(&it); return matches; }