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