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