GroupedDataFrame::GroupedDataFrame(DataFrame x, const GroupedDataFrame& model):
data_(x),
symbols(model.get_vars()),
groups(build_index_cpp(data_, model.get_vars())),
nvars_(symbols.size())
{
set_groups(data_, groups);
}
void
build_stubs(stub_t * stubs, int stubs_len) {
int stub_i = 0;
for (; stub_i < stubs_len; stub_i++) {
stub_t * stub = &stubs[stub_i];
sort_cards(stub);
stub->type = parse_stub_type(stub);
reorder_straight(stub);
set_groups(stub);
}
sort_stubs(stubs, stubs_len);
}
void test_ncache_both_group(void **state)
{
errno_t ret;
struct ncache_test_ctx *test_ctx;
test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
assert_non_null(test_ctx);
ret = sss_ncache_init(test_ctx, TIMEOUT, TIMEOUT, &test_ctx->ncache);
assert_int_equal(ret, EOK);
set_groups(test_ctx);
check_groups(test_ctx, EEXIST, ENOENT, EEXIST, ENOENT);
talloc_zfree(test_ctx->ncache);
}
gint
main (gint argc, gchar ** argv)
{
GtkWidget *window;
GtkWidget *matekbd_keyboard_drawing;
GdkScreen *screen;
gint monitor;
GdkRectangle rect;
GOptionContext *context;
MatekbdKeyboardDrawingGroupLevel groupLevels[4] =
{ {0, 0}, {1, 0}, {0, 1}, {1, 1} };
MatekbdKeyboardDrawingGroupLevel *pgroupLevels[4] =
{ &groupLevels[0], &groupLevels[1], &groupLevels[2],
&groupLevels[3]
};
context = g_option_context_new ("kbdraw");
g_option_context_add_main_entries (context, options, NULL);
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
if (program_version) {
g_print ("kbdraw %s\n", VERSION);
exit (0);
}
gtk_init (&argc, &argv);
if (!set_groups (groups, groupLevels)) {
g_printerr ("--groups: invalid argument\n");
exit (1);
}
if (!set_levels (levels, groupLevels)) {
g_printerr ("--levels: invalid argument\n");
exit (1);
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
screen = gtk_window_get_screen (GTK_WINDOW (window));
monitor = gdk_screen_get_monitor_at_point (screen, 0, 0);
gdk_screen_get_monitor_geometry (screen, monitor, &rect);
gtk_window_set_default_size (GTK_WINDOW (window),
rect.width * 4 / 5,
rect.height * 1 / 2);
gtk_widget_show (window);
matekbd_keyboard_drawing = matekbd_keyboard_drawing_new ();
gtk_widget_show (matekbd_keyboard_drawing);
gtk_container_add (GTK_CONTAINER (window), matekbd_keyboard_drawing);
matekbd_keyboard_drawing_set_groups_levels (MATEKBD_KEYBOARD_DRAWING
(matekbd_keyboard_drawing),
pgroupLevels);
if (track_modifiers)
matekbd_keyboard_drawing_set_track_modifiers
(MATEKBD_KEYBOARD_DRAWING (matekbd_keyboard_drawing), TRUE);
if (track_config)
matekbd_keyboard_drawing_set_track_config
(MATEKBD_KEYBOARD_DRAWING (matekbd_keyboard_drawing), TRUE);
g_signal_connect (G_OBJECT (matekbd_keyboard_drawing), "bad-keycode",
G_CALLBACK (bad_keycode), NULL);
if (symbols || geometry || keycodes) {
XkbComponentNamesRec names;
gint success;
memset (&names, '\0', sizeof (names));
if (symbols)
names.symbols = symbols;
else
names.symbols = (gchar *)
matekbd_keyboard_drawing_get_symbols
(MATEKBD_KEYBOARD_DRAWING
(matekbd_keyboard_drawing));
if (keycodes)
names.keycodes = keycodes;
else
names.keycodes = (gchar *)
matekbd_keyboard_drawing_get_keycodes
(MATEKBD_KEYBOARD_DRAWING
(matekbd_keyboard_drawing));
if (geometry)
names.geometry = geometry;
else
names.geometry = (gchar *)
matekbd_keyboard_drawing_get_geometry
(MATEKBD_KEYBOARD_DRAWING
(matekbd_keyboard_drawing));
success =
matekbd_keyboard_drawing_set_keyboard
(MATEKBD_KEYBOARD_DRAWING (matekbd_keyboard_drawing),
&names);
if (!success) {
g_printerr
("\nError loading new keyboard description with components:\n\n"
" keycodes: %s\n" " types: %s\n"
" compat: %s\n" " symbols: %s\n"
" geometry: %s\n\n", names.keycodes,
names.types, names.compat, names.symbols,
names.geometry);
exit (1);
}
}
gtk_widget_grab_focus (matekbd_keyboard_drawing);
gtk_main ();
return 0;
}
int proxy_session_setup_env(pool *p, const char *user, int flags) {
struct passwd *pw;
config_rec *c;
int i, res = 0, xerrno = 0;
const char *xferlog = NULL;
session.hide_password = TRUE;
/* Note: the given user name may not be known locally on the proxy; thus
* having pr_auth_getpwnam() returning NULL here is not an unexpected
* use case.
*/
pw = pr_auth_getpwnam(p, user);
if (pw != NULL) {
if (pw->pw_uid == PR_ROOT_UID) {
int root_login = FALSE;
pr_event_generate("mod_auth.root-login", NULL);
c = find_config(main_server->conf, CONF_PARAM, "RootLogin", FALSE);
if (c != NULL) {
root_login = *((int *) c->argv[0]);
}
if (root_login == FALSE) {
(void) pr_log_writefile(proxy_logfd, MOD_PROXY_VERSION,
"root login attempted, denied by RootLogin configuration");
pr_log_auth(PR_LOG_NOTICE, "SECURITY VIOLATION: Root login attempted.");
return -1;
}
pr_log_auth(PR_LOG_WARNING, "ROOT proxy login successful");
}
res = pr_auth_is_valid_shell(main_server->conf, pw->pw_shell);
if (res == FALSE) {
(void) pr_log_writefile(proxy_logfd, MOD_PROXY_VERSION,
"authentication for user '%s' failed: Invalid shell", user);
pr_log_auth(PR_LOG_NOTICE, "USER %s (Login failed): Invalid shell: '%s'",
user, pw->pw_shell);
errno = EPERM;
return -1;
}
res = pr_auth_banned_by_ftpusers(main_server->conf, pw->pw_name);
if (res == TRUE) {
(void) pr_log_writefile(proxy_logfd, MOD_PROXY_VERSION,
"authentication for user '%s' failed: User in " PR_FTPUSERS_PATH, user);
pr_log_auth(PR_LOG_NOTICE, "USER %s (Login failed): User in "
PR_FTPUSERS_PATH, pw->pw_name);
errno = EPERM;
return -1;
}
session.user = pstrdup(p, pw->pw_name);
session.group = pstrdup(p, pr_auth_gid2name(p, pw->pw_gid));
session.login_uid = pw->pw_uid;
session.login_gid = pw->pw_gid;
} else {
session.user = pstrdup(session.pool, user);
/* XXX What should session.group, session.login_uid, session.login_gid
* be? Kept as is?
*/
}
if (session.gids == NULL &&
session.groups == NULL) {
res = pr_auth_getgroups(p, session.user, &session.gids, &session.groups);
if (res < 1 &&
errno != ENOENT) {
(void) pr_log_writefile(proxy_logfd, MOD_PROXY_VERSION,
"no supplemental groups found for user '%s'", session.user);
}
}
if (flags & PROXY_SESSION_FL_CHECK_LOGIN_ACL) {
int login_acl;
login_acl = login_check_limits(main_server->conf, FALSE, TRUE, &i);
if (!login_acl) {
pr_log_auth(PR_LOG_NOTICE, "USER %s (Login failed): Limit configuration "
"denies login", user);
return -1;
}
}
/* XXX Will users want wtmp logging for a proxy login? */
session.wtmp_log = FALSE;
c = find_config(main_server->conf, CONF_PARAM, "TransferLog", FALSE);
if (c == NULL) {
xferlog = PR_XFERLOG_PATH;
} else {
xferlog = c->argv[0];
}
PRIVS_ROOT
if (strncasecmp(xferlog, "none", 5) == 0) {
xferlog_open(NULL);
} else {
xferlog_open(xferlog);
}
res = xerrno = 0;
if (pw != NULL) {
res = set_groups(p, pw->pw_gid, session.gids);
xerrno = errno;
}
PRIVS_RELINQUISH
if (res < 0) {
pr_log_pri(PR_LOG_WARNING, "unable to set process groups: %s",
strerror(xerrno));
}
session.disable_id_switching = TRUE;
session.proc_prefix = pstrdup(session.pool, session.c->remote_name);
session.sf_flags = 0;
pr_scoreboard_entry_update(session.pid,
PR_SCORE_USER, session.user,
PR_SCORE_CWD, pr_fs_getcwd(),
NULL);
if (session.group != NULL) {
session.group = pstrdup(session.pool, session.group);
}
if (session.groups != NULL) {
session.groups = copy_array_str(session.pool, session.groups);
}
proxy_sess_state |= PROXY_SESS_STATE_PROXY_AUTHENTICATED;
pr_timer_remove(PR_TIMER_LOGIN, ANY_MODULE);
return 0;
}
int main (int argc, char *argv[])
{
char *accuser, *victim, *names[1000000];
int ii, total_vets, acc_hashed, num_votes, vet_iter, names_iter = 0;
ENTRY vet, *vetptr;
fpos_t fp_pos;
FILE *fp = fopen(argv[1], "r");
if (fp == NULL) {
printf("File not found\n");
return 0;
}
/* Create hash based on total number of veterans */
fscanf(fp, "%d", &total_vets);
if (!hcreate(total_vets)) {
printf("Hash creation failed. Not enough memory (probably).\n");
return 0;
}
/* Save file pointer so we can reload it after grabbing first name */
if (fgetpos(fp, &fp_pos)) {
printf("fgetpos() failed\n");
fclose(fp);
return -1;
}
/* Grab first name, assume they're honest (so we start with an
assumption to base everything else off of) and load in the hash */
names[names_iter] = malloc(MAX_NAME_LEN);
fscanf(fp, "%s", names[names_iter]);
vet.key = names[names_iter];
vet.data = HONEST;
num_hashed++;
vetptr = hsearch(vet, ENTER);
if (vetptr == NULL) {
printf("hsearch(ENTER) failed\n");
return -1;
}
names_iter++;
do {
/* Reset the file pointer increment names_iter and start reading accusations! */
if (fsetpos(fp, &fp_pos)) {
printf("fsetpos() failed\n");
fclose(fp);
return -1;
}
for (vet_iter = 0; vet_iter < total_vets; vet_iter++)
{
names[names_iter] = malloc(MAX_NAME_LEN);
fscanf(fp, "%s", names[names_iter]);
accuser = names[names_iter];
acc_hashed = 0;
names_iter++;
fscanf(fp, "%d", &num_votes);
while (num_votes > 0) {
names[names_iter] = malloc(MAX_NAME_LEN);
fscanf(fp, "%s", names[names_iter]);
victim = names[names_iter];
if (set_groups(accuser, victim)) {
acc_hashed = 1;
names_iter++;
num_hashed++;
} else {
/* Free victim's name. It wasn't hashed yet */
free(names[names_iter]);
}
num_votes--;
}
if (!acc_hashed) {
/* Free accuser's name, too. It wasn't hashed */
names_iter--;
free(names[names_iter]);
}
}
} while (num_hashed < total_vets);
if (num_liars > (total_vets - num_liars)) {
printf("%d %d\n", num_liars, total_vets-num_liars);
} else {
printf("%d %d\n", total_vets-num_liars, num_liars);
}
names_iter--;
while (names_iter >= 0)
{
free(names[names_iter]);
names_iter--;
}
fclose(fp);
return 0;
}
