int
userlist_clnt_copy_user_info(struct userlist_clnt *clnt, int user_id,
int cnts_from, int cnts_to)
{
struct userlist_pk_edit_field *out = 0;
struct userlist_packet *in = 0;
int r;
size_t out_size, in_size = 0;
void *void_in = 0;
out_size = sizeof(*out);
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = ULS_COPY_USER_INFO;
out->user_id = user_id;
out->contest_id = cnts_from;
out->serial = cnts_to;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &void_in)) < 0)
return r;
in = (struct userlist_packet *) void_in;
if (in_size != sizeof(*in)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
r = in->id;
xfree(in);
return r;
}
int
userlist_clnt_lookup_user(
struct userlist_clnt *clnt,
unsigned char const *login,
int contest_id,
int *p_user_id,
unsigned char **p_name)
{
struct userlist_pk_do_login *out = 0;
struct userlist_pk_login_ok *in = 0;
unsigned char *login_ptr, *name_ptr;
int r, login_len;
size_t out_size = 0, in_size = 0;
void *void_in = 0;
if (!login || !*login) return -ULS_ERR_INVALID_LOGIN;
if ((login_len = strlen(login)) > 255) return -ULS_ERR_INVALID_SIZE;
out_size = sizeof(*out) + login_len;
out = alloca(out_size);
memset(out, 0, out_size);
login_ptr = out->data;
out->request_id = ULS_LOOKUP_USER;
out->contest_id = contest_id;
out->login_length = login_len;
out->password_length = 0;
strcpy(login_ptr, login);
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &void_in)) < 0)
return r;
in = void_in;
if (in->reply_id != ULS_LOGIN_OK && in->reply_id != ULS_LOGIN_COOKIE) {
r = in->reply_id;
goto cleanup;
}
if (in_size < sizeof(*in)) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
login_ptr = in->data;
if (strlen(login_ptr) != in->login_len) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
name_ptr = login_ptr + in->login_len + 1;
if (strlen(name_ptr) != in->name_len) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
if (in_size != sizeof(*in) + in->login_len + in->name_len) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
if (p_user_id) *p_user_id = in->user_id;
if (p_name) *p_name = xstrdup(name_ptr);
r = in->reply_id;
cleanup:
xfree(in);
return r;
}
int
userlist_clnt_map_contest(struct userlist_clnt *clnt,
int contest_id,
int *p_sem_key,
int *p_shm_key)
{
struct userlist_pk_map_contest *out = 0;
struct userlist_pk_contest_mapped *in = 0;
int r;
size_t out_size, in_size = 0;
/* FIXME: check args? */
out_size = sizeof(*out);
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = ULS_MAP_CONTEST;
out->contest_id = contest_id;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, (void*) &in)) < 0)
return r;
if (in->reply_id != ULS_CONTEST_MAPPED) {
r = in->reply_id;
xfree(in);
return r;
}
if (p_sem_key) *p_sem_key = in->sem_key;
if (p_shm_key) *p_shm_key = in->shm_key;
r = in->reply_id;
xfree(in);
return r;
}
int
userlist_clnt_change_registration(struct userlist_clnt *clnt,
int user_id,
int contest_id,
int new_status,
int flags_cmd,
unsigned int new_flags)
{
struct userlist_pk_edit_registration *out = 0;
struct userlist_packet *in = 0;
int r;
size_t out_size, in_size = 0;
out_size = sizeof(*out);
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = ULS_EDIT_REGISTRATION;
out->user_id = user_id;
out->contest_id = contest_id;
out->new_status = new_status;
out->flags_cmd = flags_cmd;
out->new_flags = new_flags;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, (void*) &in)) < 0)
return r;
if (in_size != sizeof(*in)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
r = in->id;
xfree(in);
return r;
}
int
userlist_clnt_move_member(
struct userlist_clnt *clnt,
int cmd,
int user_id,
int contest_id,
int serial,
int new_role)
{
struct userlist_pk_move_info *out = 0;
struct userlist_packet *in = 0;
int r;
size_t out_size, in_size = 0;
out_size = sizeof(*out);
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = cmd;
out->user_id = user_id;
out->contest_id = contest_id;
out->serial = serial;
out->new_role = new_role;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, (void*) &in)) < 0)
return r;
if (in_size != sizeof(*in)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
r = in->id;
xfree(in);
return r;
}
int
userlist_clnt_logout(
struct userlist_clnt *clnt,
int cmd,
const ej_ip_t *origin_ip,
int ssl,
ej_cookie_t cookie,
ej_cookie_t client_key)
{
struct userlist_pk_do_logout out;
struct userlist_packet *in = 0;
void *void_in = 0;
size_t in_size = 0;
int r;
memset(&out, 0, sizeof(out));
out.request_id = cmd;
if (origin_ip) {
out.origin_ip = *origin_ip;
}
out.ssl = ssl;
out.cookie = cookie;
out.client_key = client_key;
if ((r = userlist_clnt_send_packet(clnt, sizeof(out), &out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &void_in)) < 0)
return r;
in = void_in;
if (in_size != sizeof(*in) || in->id > 0) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
r = in->id;
xfree(in);
return r;
}
int
userlist_clnt_set_info(struct userlist_clnt *clnt,
int uid, int contest_id, const unsigned char *info)
{
struct userlist_pk_set_user_info *out;
struct userlist_packet *in = 0;
size_t out_size, in_size = 0;
int r;
ASSERT(clnt);
ASSERT(clnt->fd >= 0);
ASSERT(info);
out_size = sizeof(*out) + strlen(info);
out = (struct userlist_pk_set_user_info*) alloca(out_size);
if (!out) return -ULS_ERR_OUT_OF_MEM;
memset(out, 0, out_size);
out->request_id = ULS_SET_USER_INFO;
out->user_id = uid;
out->contest_id = contest_id;
strcpy(out->data, info);
out->info_len = strlen(info);
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, (void*) &in)) < 0)
return r;
if (in_size != sizeof(*in)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
r = in->id;
xfree(in);
return r;
}
int
userlist_clnt_notify(struct userlist_clnt *clnt, int cmd, int contest_id)
{
struct userlist_pk_map_contest *out = 0;
struct userlist_packet *in = 0;
int r;
size_t out_size, in_size = 0;
void *void_in = 0;
out_size = sizeof(*out);
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = cmd;
out->contest_id = contest_id;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &void_in)) < 0)
return r;
in = (struct userlist_packet*) void_in;
if (in_size != sizeof(*in)) {
r = -ULS_ERR_PROTOCOL;
} else {
r = in->id;
}
xfree(in);
return r;
}
int
userlist_clnt_create_member(
struct userlist_clnt *clnt,
int user_id,
int contest_id,
int role)
{
struct userlist_pk_edit_field *out = 0;
struct userlist_packet *in = 0;
struct userlist_pk_login_ok *in2 = 0;
int r;
size_t out_size, in_size = 0;
void *void_in = 0;
out_size = sizeof(*out);
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = ULS_CREATE_MEMBER;
out->user_id = user_id;
out->contest_id = contest_id;
out->serial = role;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &void_in)) < 0)
return r;
in = (struct userlist_packet *) void_in;
if (in_size < sizeof(*in)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
if (in->id < 0) {
if (in_size != sizeof(*in)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
r = in->id;
xfree(in);
return r;
}
if (in_size != sizeof(*in2)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
in2 = (struct userlist_pk_login_ok *) void_in;
if (in2->reply_id != ULS_LOGIN_OK) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
r = in2->user_id;
xfree(in);
return r;
}
int
userlist_clnt_get_xml_by_text(
struct userlist_clnt *clnt,
int cmd,
const unsigned char *request_text,
unsigned char **reply_text)
{
size_t request_len, out_size, xml_len, in_size = 0;
struct userlist_pk_set_user_info *out;
void *in_void = 0;
struct userlist_packet *in_gen = 0;
struct userlist_pk_xml_data *in = 0;
int r;
if (!request_text) request_text = "";
request_len = strlen(request_text);
out_size = sizeof(*out) + request_len;
XALLOCAZ(out, 1);
out->request_id = cmd;
out->info_len = request_len;
memcpy(out->data, request_text, request_len + 1);
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &in_void)) < 0)
return r;
r = -ULS_ERR_PROTOCOL;
in_gen = (struct userlist_packet*) in_void;
if (!in_gen || in_size < sizeof(*in_gen)) goto cleanup;
if (in_gen->id < 0) {
r = in_gen->id;
goto cleanup;
}
if (in_gen->id != ULS_XML_DATA) goto cleanup;
if (in_size < sizeof(*in)) goto cleanup;
in = (struct userlist_pk_xml_data*) in_gen;
xml_len = strlen(in->data);
if (xml_len != in->info_len) goto cleanup;
if (in_size != sizeof(*in) + xml_len) goto cleanup;
if (reply_text) {
*reply_text = xstrdup(in->data);
}
r = ULS_XML_DATA;
cleanup:
xfree(in_void);
return r;
}
int
userlist_clnt_lookup_cookie(
struct userlist_clnt *clnt,
const ej_ip_t *origin_ip,
int ssl,
ej_cookie_t cookie,
ej_cookie_t client_key,
int *p_user_id,
unsigned char **p_login,
unsigned char **p_name,
int *p_locale_id,
int *p_contest_id)
{
struct userlist_pk_check_cookie * data;
struct userlist_pk_login_ok * answer = 0;
void *void_answer = 0;
int len;
size_t anslen;
int res;
int r;
len = sizeof (struct userlist_pk_check_cookie);
data = alloca(len);
memset(data, 0, len);
data->request_id = ULS_CHECK_COOKIE;
if (origin_ip) {
data->origin_ip = *origin_ip;
}
data->ssl = ssl;
// data->contest_id = contest_id;
data->cookie = cookie;
data->client_key = client_key;
if ((r = userlist_clnt_send_packet(clnt,len,data)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt,&anslen,&void_answer)) < 0)
return r;
answer = void_answer;
if (answer->reply_id == ULS_LOGIN_COOKIE) {
*p_user_id = answer->user_id;
*p_locale_id = answer->locale_id;
*p_login = xstrdup(answer->data);
*p_name = xcalloc(1,answer->name_len + 1);
*p_contest_id = answer->contest_id;
strcpy(*p_name,answer->data + answer->login_len + 1);
}
res = answer->reply_id;
xfree(answer);
return res;
}
int
userlist_clnt_generate_team_passwd(
struct userlist_clnt *clnt,
int cmd,
int contest_id,
int out_fd)
{
struct userlist_pk_map_contest *out = 0;
struct userlist_packet *in = 0;
int r;
size_t out_size, in_size = 0;
int pfd[2], pp[2];
char b;
if (cmd != ULS_GENERATE_TEAM_PASSWORDS && cmd != ULS_GENERATE_PASSWORDS) {
return -ULS_ERR_PROTOCOL;
}
if (pipe(pp) < 0) {
err("pipe() failed: %s", os_ErrorMsg());
return -ULS_ERR_WRITE_ERROR;
}
pfd[0] = out_fd;
pfd[1] = pp[1];
out_size = sizeof(*out);
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = cmd;
out->contest_id = contest_id;
if ((r = userlist_clnt_pass_fd(clnt, 2, pfd)) < 0) return r;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, (void*) &in)) < 0)
return r;
r = in->id;
xfree(in);
if (r < 0) return r;
close(pfd[1]);
r = read(pp[0], &b, 1);
if (r > 0) return -ULS_ERR_PROTOCOL;
if (r < 0) return -ULS_ERR_READ_ERROR;
return 0;
}
int
userlist_clnt_register_contest(
struct userlist_clnt *clnt,
int cmd,
int user_id,
int contest_id,
const ej_ip_t *ip,
int ssl_flag)
{
struct userlist_pk_register_contest *out;
struct userlist_packet *in = 0;
int r;
size_t out_size, in_size = 0;
/*
if (cmd != ULS_REGISTER_CONTEST && cmd != ULS_PRIV_REGISTER_CONTEST)
return -ULS_ERR_PROTOCOL;
*/
out_size = sizeof(*out);
out = alloca(out_size);
memset(out, 0, out_size);
if (!out) return -ULS_ERR_OUT_OF_MEM;
out->request_id = cmd;
out->user_id = user_id;
out->contest_id = contest_id;
if (ip) {
out->ip = *ip;
}
out->ssl_flag = ssl_flag;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, (void*) &in)) < 0)
return r;
if (in_size != sizeof(*in)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
r = in->id;
xfree(in);
return r;
}
int
userlist_clnt_get_database(struct userlist_clnt *clnt,
int cmd,
int contest_id,
unsigned char **p_info)
{
struct userlist_pk_dump_database out_pkt;
struct userlist_pk_xml_data *in_pkt = 0;
size_t in_size;
int info_len;
int r;
#if !defined PYTHON
ASSERT(clnt);
ASSERT(clnt->fd >= 0);
#endif
memset(&out_pkt, 0, sizeof(out_pkt));
out_pkt.request_id = cmd;
out_pkt.contest_id = contest_id;
if ((r = userlist_clnt_send_packet(clnt, sizeof(out_pkt), &out_pkt)) < 0)
return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, (void*) &in_pkt)) < 0)
return -r;
if (!in_size || !in_pkt) return -1;
if (in_pkt->reply_id != ULS_TEXT_DATA) {
r = in_pkt->reply_id;
xfree(in_pkt);
return r;
}
if (in_size <= sizeof(struct userlist_pk_xml_data)) return -1;
info_len = strlen(in_pkt->data);
if (info_len != in_pkt->info_len) {
xfree(in_pkt);
return -ULS_ERR_PROTOCOL;
}
*p_info = xstrdup(in_pkt->data);
xfree(in_pkt);
return ULS_TEXT_DATA;
}
int
userlist_clnt_priv_login(
struct userlist_clnt *clnt,
int cmd,
const ej_ip_t *origin_ip,
ej_cookie_t client_key,
int ssl,
int contest_id,
int locale_id,
int role,
unsigned char const *login,
unsigned char const *passwd,
int *p_user_id,
ej_cookie_t *p_cookie,
ej_cookie_t *p_client_key,
int *p_priv_level,
unsigned char **p_name)
{
struct userlist_pk_do_login *out = 0;
struct userlist_pk_login_ok *in = 0;
unsigned char *login_ptr, *passwd_ptr, *name_ptr;
int r, login_len, passwd_len;
size_t out_size, in_size = 0;
void *void_in = 0;
if (!login || !*login) return -ULS_ERR_INVALID_LOGIN;
if (!passwd || !*passwd) return -ULS_ERR_INVALID_PASSWORD;
if ((login_len = strlen(login)) > 255) return -ULS_ERR_INVALID_SIZE;
if ((passwd_len = strlen(passwd)) > 255) return -ULS_ERR_INVALID_SIZE;
out_size = sizeof(*out) + login_len + passwd_len;
out = alloca(out_size);
memset(out, 0, out_size);
login_ptr = out->data;
passwd_ptr = login_ptr + login_len + 1;
out->request_id = cmd;
if (origin_ip) {
out->origin_ip = *origin_ip;
}
out->client_key = client_key;
out->ssl = ssl;
out->contest_id = contest_id;
out->locale_id = locale_id;
out->role = role;
out->login_length = login_len;
out->password_length = passwd_len;
strcpy(login_ptr, login);
strcpy(passwd_ptr, passwd);
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &void_in)) < 0)
return r;
in = void_in;
if (in->reply_id < 0) {
r = in->reply_id;
goto cleanup;
}
if (in->reply_id != ULS_LOGIN_OK && in->reply_id != ULS_LOGIN_COOKIE) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
if (in_size < sizeof(*in)) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
login_ptr = in->data;
if (strlen(login_ptr) != in->login_len) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
name_ptr = login_ptr + in->login_len + 1;
if (strlen(name_ptr) != in->name_len) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
if (in_size != sizeof(*in) + in->login_len + in->name_len) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
if (p_user_id) *p_user_id = in->user_id;
if (p_cookie) *p_cookie = in->cookie;
if (p_client_key) *p_client_key = in->client_key;
if (p_priv_level) *p_priv_level = in->priv_level;
if (p_name) *p_name = xstrdup(name_ptr);
r = in->reply_id;
cleanup:
xfree(in);
return r;
}
int
userlist_clnt_create_user_2(
struct userlist_clnt *clnt,
int cmd,
const struct userlist_pk_create_user_2 *params,
const unsigned char *login_str,
const unsigned char *email_str,
const unsigned char *reg_password_str,
const unsigned char *cnts_password_str,
const unsigned char *cnts_name_str,
int *p_user_id)
{
if (!params) return -ULS_ERR_PROTOCOL;
if (!login_str) login_str = "";
if (!email_str) email_str = "";
if (!reg_password_str) reg_password_str = "";
if (!cnts_password_str) cnts_password_str = "";
if (!cnts_name_str) cnts_name_str = "";
size_t login_len = strlen(login_str);
if (login_len > MAX_LEN) return -ULS_ERR_PROTOCOL;
size_t email_len = strlen(email_str);
if (email_len > MAX_LEN) return -ULS_ERR_PROTOCOL;
size_t reg_password_len = strlen(reg_password_str);
if (reg_password_len > MAX_LEN) return -ULS_ERR_PROTOCOL;
size_t cnts_password_len = strlen(cnts_password_str);
if (cnts_password_len > MAX_LEN) return -ULS_ERR_PROTOCOL;
size_t cnts_name_len = strlen(cnts_name_str);
if (cnts_name_len > MAX_LEN) return -ULS_ERR_PROTOCOL;
size_t out_size = sizeof(struct userlist_pk_create_user_2) + login_len + email_len + reg_password_len + cnts_password_len + cnts_name_len;
if (out_size > MAX_SIZE) return -ULS_ERR_PROTOCOL;
struct userlist_pk_create_user_2 *out = (struct userlist_pk_create_user_2*) xcalloc(out_size, 1);
unsigned char *login_ptr = out->data;
unsigned char *email_ptr = login_ptr + login_len + 1;
unsigned char *reg_password_ptr = email_ptr + email_len + 1;
unsigned char *cnts_password_ptr = reg_password_ptr + reg_password_len + 1;
unsigned char *cnts_name_ptr = cnts_password_ptr + cnts_password_len + 1;
out->request_id = cmd;
out->login_len = login_len;
out->email_len = email_len;
out->send_email_flag = params->send_email_flag;
out->confirm_email_flag = params->confirm_email_flag;
out->random_password_flag = params->random_password_flag;
out->reg_password_len = reg_password_len;
out->use_sha1_flag = params->use_sha1_flag;
out->is_privileged_flag = params->is_privileged_flag;
out->is_invisible_flag = params->is_invisible_flag;
out->is_banned_flag = params->is_banned_flag;
out->is_locked_flag = params->is_locked_flag;
out->show_login_flag = params->show_login_flag;
out->show_email_flag = params->show_email_flag;
out->read_only_flag = params->read_only_flag;
out->never_clean_flag = params->never_clean_flag;
out->simple_registration_flag = params->simple_registration_flag;
out->contest_id = params->contest_id;
out->cnts_status = params->cnts_status;
out->cnts_is_invisible_flag = params->cnts_is_invisible_flag;
out->cnts_is_banned_flag = params->cnts_is_banned_flag;
out->cnts_is_locked_flag = params->cnts_is_locked_flag;
out->cnts_is_incomplete_flag = params->cnts_is_incomplete_flag;
out->cnts_is_disqualified_flag = params->cnts_is_disqualified_flag;
out->cnts_use_reg_passwd_flag = params->cnts_use_reg_passwd_flag;
out->cnts_set_null_passwd_flag = params->cnts_set_null_passwd_flag;
out->cnts_random_password_flag = params->cnts_random_password_flag;
out->cnts_password_len = cnts_password_len;
out->cnts_use_sha1_flag = params->cnts_use_sha1_flag;
out->cnts_name_len = cnts_name_len;
out->group_id = params->group_id;
memcpy(login_ptr, login_str, login_len + 1);
memcpy(email_ptr, email_str, email_len + 1);
memcpy(reg_password_ptr, reg_password_str, reg_password_len + 1);
memcpy(cnts_password_ptr, cnts_password_str, cnts_password_len + 1);
memcpy(cnts_name_ptr, cnts_name_str, cnts_name_len + 1);
int r = 0;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
size_t in_size = 0;
void *void_in = 0;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &void_in)) < 0)
return r;
struct userlist_packet *in = (struct userlist_packet *) void_in;
struct userlist_pk_login_ok *uin = 0;
if (in_size < sizeof(*in)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
if (in->id == ULS_LOGIN_OK) {
uin = (struct userlist_pk_login_ok*) in;
if (in_size != sizeof(*uin)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
if (p_user_id) *p_user_id = uin->user_id;
xfree(in);
return ULS_LOGIN_OK;
}
if (in_size != sizeof(*in)) {
xfree(in);
return -ULS_ERR_PROTOCOL;
}
r = in->id;
xfree(in);
return r;
}
int
userlist_clnt_get_cookie(
struct userlist_clnt *clnt,
int cmd,
const ej_ip_t *origin_ip,
int ssl,
ej_cookie_t cookie,
ej_cookie_t client_key,
int *p_user_id,
int *p_contest_id,
int *p_locale_id,
int *p_priv_level,
int *p_role,
int *p_team_login,
int *p_reg_status,
int *p_reg_flags,
unsigned char **p_login,
unsigned char **p_name)
{
struct userlist_pk_check_cookie *out = 0;
struct userlist_pk_login_ok *in = 0;
int r;
size_t out_size, in_size = 0;
unsigned char *login_ptr, *name_ptr;
void *void_in = 0;
if (!clnt) return -ULS_ERR_NO_CONNECT;
if (!cookie) return -ULS_ERR_NO_COOKIE;
out_size = sizeof(*out);
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = cmd;
if (origin_ip) {
out->origin_ip = *origin_ip;
}
out->ssl = ssl;
out->contest_id = 0;
out->cookie = cookie;
out->client_key = client_key;
out->priv_level = 0;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &void_in)) < 0)
return r;
in = void_in;
if (in->reply_id < 0) {
r = in->reply_id;
goto cleanup;
}
if (in->reply_id != ULS_LOGIN_COOKIE || in_size < sizeof(*in)) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
login_ptr = in->data;
if (strlen(login_ptr) != in->login_len) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
name_ptr = login_ptr + in->login_len + 1;
if (strlen(name_ptr) != in->name_len) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
if (in_size != sizeof(*in) + in->login_len + in->name_len) {
r = -ULS_ERR_PROTOCOL;
goto cleanup;
}
if (p_user_id) *p_user_id = in->user_id;
if (p_locale_id) *p_locale_id = in->locale_id;
if (p_contest_id) *p_contest_id = in->contest_id;
if (p_priv_level) *p_priv_level = in->priv_level;
if (p_role) *p_role = in->role;
if (p_team_login) *p_team_login = in->team_login;
if (p_reg_status) *p_reg_status = in->reg_status;
if (p_reg_flags) *p_reg_flags = in->reg_flags;
if (p_login) *p_login = xstrdup(login_ptr);
if (p_name) *p_name = xstrdup(name_ptr);
r = in->reply_id;
cleanup:
xfree(in);
return r;
}
int
userlist_clnt_register_new_2(
struct userlist_clnt *clnt,
const ej_ip_t *origin_ip,
int ssl,
int contest_id,
int locale_id,
int action,
unsigned char const *login,
unsigned char const *email,
const unsigned char *self_url,
int *p_user_id,
unsigned char **p_login,
unsigned char **p_passwd)
{
struct userlist_pk_register_new *data;
struct userlist_pk_new_password *answer;
unsigned char *p;
void *v_ans;
short *s_ans;
int len, login_len, email_len, self_url_len;
size_t anslen;
int res;
int r;
if (!login) login = "";
if (!email) email = "";
if (!self_url) self_url = "";
login_len = strlen(login);
email_len = strlen(email);
self_url_len = strlen(self_url);
len = sizeof(struct userlist_pk_register_new)
+ login_len + email_len + self_url_len;
data = alloca(len);
memset(data, 0, len);
data->request_id = ULS_REGISTER_NEW_2;
if (origin_ip) {
data->origin_ip = *origin_ip;
}
data->ssl = ssl;
data->contest_id = contest_id;
data->locale_id = locale_id;
data->action = action;
data->login_length = login_len;
data->email_length = email_len;
data->self_url_length = self_url_len;
p = data->data;
strcpy(p, login);
p += login_len + 1;
strcpy(p, email);
p += email_len + 1;
strcpy(p, self_url);
if ((r = userlist_clnt_send_packet(clnt,len,data)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt,&anslen,(void*) &v_ans)) < 0)
return r;
if (anslen < sizeof(short)) goto protocol_error;
s_ans = (short*) v_ans;
if (*s_ans < 0) {
res = *s_ans;
xfree(v_ans);
return res;
}
if (*s_ans != ULS_PASSWORD) goto protocol_error;
answer = (struct userlist_pk_new_password*) v_ans;
if (anslen < sizeof(*answer)) goto protocol_error;
if (sizeof(*answer) + answer->login_len + answer->passwd_len != anslen)
goto protocol_error;
if (strlen(answer->data) != answer->login_len) goto protocol_error;
if (strlen(answer->data + answer->login_len + 2) != answer->passwd_len)
goto protocol_error;
if (p_user_id) *p_user_id = answer->user_id;
if (p_login) *p_login = xstrdup(answer->data);
if (p_passwd) *p_passwd = xstrdup(answer->data + answer->login_len + 2);
xfree(answer);
return ULS_PASSWORD;
protocol_error:
xfree(v_ans);
return -ULS_ERR_PROTOCOL;
}
int
userlist_clnt_list_users_2(
struct userlist_clnt *clnt,
int cmd,
int contest_id,
int group_id,
const unsigned char *filter,
int offset,
int count,
unsigned char **p_info)
{
struct userlist_pk_list_users_2 *out = 0;
struct userlist_pk_xml_data *in = 0;
struct userlist_packet *in_generic = 0;
void *in_void = 0;
int filter_len = 0, r;
size_t out_size, in_size = 0;
if (!filter) filter = "";
filter_len = strlen(filter);
if (filter_len < 0 || filter_len > MAX_FILTER_LEN)
return -ULS_ERR_PROTOCOL;
out_size = sizeof(*out) + filter_len;
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = cmd;
out->contest_id = contest_id;
out->group_id = group_id;
out->filter_len = filter_len;
out->offset = offset;
out->count = count;
memcpy(out->data, filter, filter_len + 1);
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &in_void)) < 0)
return r;
if (in_size < sizeof(*in_generic)) {
xfree(in_void); in_void = 0;
return -ULS_ERR_PROTOCOL;
}
in_generic = (struct userlist_packet *) in_void; in_void = 0;
if (in_generic->id < 0) {
r = in_generic->id;
xfree(in_generic); in_generic = 0;
return r;
}
if (in_generic->id != ULS_XML_DATA) {
r = in_generic->id;
xfree(in_generic); in_generic = 0;
return -ULS_ERR_PROTOCOL;
}
if (in_size < sizeof(*in)) {
xfree(in_generic); in_generic = 0;
return -ULS_ERR_PROTOCOL;
}
in = (struct userlist_pk_xml_data*) in_generic; in_generic = 0;
if (in->info_len > MAX_XML_LEN) {
xfree(in); in = 0;
return -ULS_ERR_PROTOCOL;
}
if (in->info_len != strlen(in->data)) {
xfree(in); in = 0;
return -ULS_ERR_PROTOCOL;
}
*p_info = xstrdup(in->data);
xfree(in); in = 0;
return ULS_XML_DATA;
}
int
userlist_clnt_import_csv_users(
struct userlist_clnt *clnt,
int cmd,
int contest_id,
int separator,
int flags,
const unsigned char *csv_text,
unsigned char **p_log)
{
struct userlist_pk_edit_field *out = 0;
struct userlist_packet *in_dflt = 0;
struct userlist_pk_xml_data *in = 0;
size_t text_len, out_size, in_size = 0, log_len;
void *in_void = 0;
int r;
#if !defined PYTHON
ASSERT(clnt);
ASSERT(clnt->fd >= 0);
#endif
if (!csv_text) csv_text = "";
text_len = strlen(csv_text);
if (text_len >= 1024 * 1024 * 1024) return -ULS_ERR_PROTOCOL;
out_size = sizeof(*out) + text_len;
out = (struct userlist_pk_edit_field*) alloca(out_size);
memset(out, 0, out_size);
out->request_id = cmd;
out->contest_id = contest_id;
out->serial = flags;
out->field = separator;
out->value_len = text_len;
memcpy(out->data, csv_text, text_len + 1);
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &in_void)) < 0)
return r;
if (in_size < sizeof(*in_dflt)) {
xfree(in_void);
return -ULS_ERR_PROTOCOL;
}
in_dflt = (struct userlist_packet*) in_void;
if (in_dflt->id < 0) {
r = in_dflt->id;
xfree(in_void);
return r;
}
if (in_dflt->id != ULS_TEXT_DATA && in_dflt->id != ULS_TEXT_DATA_FAILURE) {
xfree(in_void);
return -ULS_ERR_PROTOCOL;
}
if (in_size < sizeof(*in)) {
xfree(in_void);
return -ULS_ERR_PROTOCOL;
}
in = (struct userlist_pk_xml_data*) in_void;
log_len = strlen(in->data);
if (log_len != in->info_len) {
xfree(in_void);
return -ULS_ERR_PROTOCOL;
}
if (sizeof(*in) + log_len != in_size) {
xfree(in_void);
return -ULS_ERR_PROTOCOL;
}
if (p_log) *p_log = xstrdup(in->data);
r = in->reply_id;
xfree(in_void);
return r;
}
int
userlist_clnt_recover_passwd_2(
struct userlist_clnt *clnt,
int cmd,
const ej_ip_t *ip,
int ssl_flag,
int contest_id,
ej_cookie_t cookie,
int *p_user_id,
int *p_regstatus,
unsigned char **p_login,
unsigned char **p_name,
unsigned char **p_passwd)
{
struct userlist_pk_check_cookie *out;
void *in1 = 0;
struct userlist_packet *in2;
struct userlist_pk_new_password *in;
size_t out_size, in_size, login_len, name_len, passwd_len, packet_len;
int r;
unsigned char *login_ptr, *name_ptr, *passwd_ptr;
out_size = sizeof(*out);
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = cmd;
if (ip) {
out->origin_ip = *ip;
}
out->ssl = ssl_flag;
out->contest_id = contest_id;
out->cookie = cookie;
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &in1)) < 0)
return r;
if (in_size < sizeof(*in2)) goto protocol_error;
in2 = (struct userlist_packet*) in1;
if (in2->id < 0) {
r = in2->id;
xfree(in1);
return r;
}
if (in2->id != ULS_NEW_PASSWORD) goto protocol_error;
if (in_size < sizeof(*in)) goto protocol_error;
in = (struct userlist_pk_new_password *) in1;
login_ptr = in->data;
login_len = strlen(login_ptr);
if (login_len != in->login_len) goto protocol_error;
name_ptr = login_ptr + login_len + 1;
name_len = strlen(name_ptr);
if (name_len != in->name_len) goto protocol_error;
passwd_ptr = name_ptr + name_len + 1;
passwd_len = strlen(passwd_ptr);
if (passwd_len != in->passwd_len) goto protocol_error;
packet_len = sizeof(*in);
packet_len += login_len + name_len + passwd_len;
if (packet_len != in_size) goto protocol_error;
if (p_user_id) *p_user_id = in->user_id;
if (p_regstatus) *p_regstatus = in->regstatus;
if (p_login) *p_login = xstrdup(login_ptr);
if (p_name) *p_name = xstrdup(name_ptr);
if (p_passwd) *p_passwd = xstrdup(passwd_ptr);
xfree(in1);
return ULS_NEW_PASSWORD;
protocol_error:
xfree(in1);
return -ULS_ERR_PROTOCOL;
}
int
userlist_clnt_get_count(
struct userlist_clnt *clnt,
int cmd,
int contest_id,
int group_id,
const unsigned char *filter,
long long *p_count)
{
struct userlist_pk_list_users_2 *out = 0;
struct userlist_pk_count *in = 0;
struct userlist_packet *in_generic = 0;
void *in_void = 0;
int filter_len = 0, r;
size_t out_size, in_size = 0;
long long count = 0;
if (!filter) filter = "";
filter_len = strlen(filter);
if (filter_len < 0 || filter_len > MAX_FILTER_LEN)
return -ULS_ERR_PROTOCOL;
out_size = sizeof(*out) + filter_len;
out = alloca(out_size);
memset(out, 0, out_size);
out->request_id = cmd;
out->contest_id = contest_id;
out->group_id = group_id;
out->filter_len = filter_len;
memcpy(out->data, filter, filter_len + 1);
if ((r = userlist_clnt_send_packet(clnt, out_size, out)) < 0) return r;
if ((r = userlist_clnt_read_and_notify(clnt, &in_size, &in_void)) < 0)
return r;
if (in_size < sizeof(*in_generic)) {
xfree(in_void); in_void = 0;
return -ULS_ERR_PROTOCOL;
}
in_generic = (struct userlist_packet *) in_void; in_void = 0;
if (in_generic->id < 0) {
r = in_generic->id;
xfree(in_generic); in_generic = 0;
return r;
}
if (in_generic->id != ULS_COUNT) {
r = in_generic->id;
xfree(in_generic); in_generic = 0;
return -ULS_ERR_PROTOCOL;
}
if (in_size != sizeof(*in)) {
xfree(in_generic); in_generic = 0;
return -ULS_ERR_PROTOCOL;
}
in = (struct userlist_pk_count*) in_generic; in_generic = 0;
count = in->count;
if (count < 0) {
xfree(in); in = 0;
return -ULS_ERR_PROTOCOL;
}
xfree(in); in = 0;
if (p_count) *p_count = count;
return ULS_COUNT;
}
