void output_global_data(PERF_DATA_BLOCK *data, RuntimeSettings rt, int tdb_flags) { int i; char key[NAME_LEN]; char sdata[NAME_LEN]; /* Initialize BaseIndex */ make_key(key, NAME_LEN, 1, NULL); memset(sdata, 0, NAME_LEN); sprintf(sdata, "%d", data->num_counters); add_key(rt.cnames, key, sdata, tdb_flags); /* Initialize PerfTime, PerfFreq and PerfTime100nSec */ memset(sdata, 0, NAME_LEN); make_key(key, NAME_LEN, 0, "PerfTime"); sprintf(sdata, "%Lu", data->PerfTime); add_key(rt.cdata, key, sdata, tdb_flags); make_key(key, NAME_LEN, 0, "PerfTime100nSec"); memset(sdata, 0, NAME_LEN); sprintf(sdata, "%Lu", data->PerfTime100nSec); add_key(rt.cdata, key, sdata, tdb_flags); memset(sdata, 0, NAME_LEN); make_key(key, NAME_LEN, 0, "PerfFreq"); sprintf(sdata, "%Lu", data->PerfFreq); add_key(rt.cnames, key, sdata, tdb_flags); return; }
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { static uint8_t mods_pressed; switch (id) { case 0: /* Handle the combined Grave/Esc key */ mods_pressed = get_mods()&GRAVE_MODS; // Check to see what mods are pressed if (record->event.pressed) { /* The key is being pressed. */ if (mods_pressed) { add_key(KC_GRV); send_keyboard_report(); } else { add_key(KC_ESC); send_keyboard_report(); } } else { /* The key is being released. */ if (mods_pressed) { del_key(KC_GRV); send_keyboard_report(); } else { del_key(KC_ESC); send_keyboard_report(); } } break; } }
bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case SFT_ESC: if (record->event.pressed) { if (get_mods() & MODS_SHIFT_MASK) { add_key(KC_GRV); send_keyboard_report(); } else { add_key(KC_ESC); send_keyboard_report(); } } else { if (get_mods() & MODS_SHIFT_MASK) { del_key(KC_GRV); send_keyboard_report(); } else { del_key(KC_ESC); send_keyboard_report(); } } return false; default: return true; } }
void output_perf_desc(PerfCounter counter, RuntimeSettings rt) { char key[NAME_LEN]; char sdata[NAME_LEN]; /* First insert the counter name */ make_key(key, NAME_LEN, counter.index, NULL); add_key(rt.cnames, key, counter.name, TDB_INSERT); /* Add the help string */ make_key(key, NAME_LEN, counter.index + 1, NULL); add_key(rt.cnames, key, counter.help, TDB_INSERT); /* Add the relationships */ make_key(key, NAME_LEN, counter.index, "rel"); add_key(rt.cnames, key, counter.relationships, TDB_INSERT); /* Add type data if not PERF_OBJECT or PERF_INSTANCE */ if(counter.record_type == PERF_COUNTER) { make_key(key, NAME_LEN, counter.index, "type"); memset(sdata, 0, NAME_LEN); sprintf(sdata, "%d", counter.counter_type); add_key(rt.cnames, key, sdata, TDB_INSERT); } return; }
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { static uint8_t shift_esc_shift_mask; switch (id) { case SHIFT_ESC: shift_esc_shift_mask = get_mods()&MODS_CTRL_MASK; if (record->event.pressed) { if (shift_esc_shift_mask) { add_key(KC_GRV); send_keyboard_report(); } else { add_key(KC_ESC); send_keyboard_report(); } } else { if (shift_esc_shift_mask) { del_key(KC_GRV); send_keyboard_report(); } else { del_key(KC_ESC); send_keyboard_report(); } } break; } }
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { # define MODS_CTRL_MASK (MOD_BIT(KC_LCTRL)|MOD_BIT(KC_RCTRL)) static uint8_t ctrl_space_i_prev_ctrl; switch (id) { // Ctrl + Up(SpaceFN) -> PgUp case CTRL_SPACE_I: ctrl_space_i_prev_ctrl = get_mods()&MODS_CTRL_MASK; if (record->event.pressed) { if (ctrl_space_i_prev_ctrl) { del_mods(ctrl_space_i_prev_ctrl); // remove Ctrl add_key(KC_PGUP); send_keyboard_report(); // send PgUp without Ctrl add_mods(ctrl_space_i_prev_ctrl); // return Ctrl but not sent } else { add_key(KC_UP); send_keyboard_report(); } } else { if (ctrl_space_i_prev_ctrl) { del_key(KC_PGUP); send_keyboard_report(); } else { del_key(KC_UP); send_keyboard_report(); } } break; } }
// Sends the HMDP request 'List' // @param sockfd the socket descriptor of the server // @param token the token used for verification // @param list the list of files found in the clients hooli directory void request_list(int sockfd, char *token, csv_record *list) { char *request; // The 'List' message char *list_size; // The size of the list of files and checksums int length; // The length of the 'List' message asprintf(&list_size, "%d", get_list_size(list)); add_command(&request, COMMAND_LIST); // |-----------------| add_key(&request, KEY_TOKEN); // |List\n | add_value(&request, token); // |-----------------| add_key(&request, KEY_LENGTH); // |Token:value\n | add_value(&request, list_size); // |-----------------| delimit_header(&request); // |Length:value\n\n | add_body(&request, list); // |-----------------| // |Body: | // |-----------------| length = strlen(request); // Check to see if the message sent successfully if (send_all(sockfd, request, &length) == -1) { syslog(LOG_ERR, "Only sent %d bytes\n", length); } //end if free(list_size); free(request); list_size = NULL; request = NULL; } //end request_list
// Sends the HMDP request 'Auth' // @param sockfd the socket descriptor of the server // @param username the username of the client // @param password the password of the client void request_auth(int sockfd, char *username, char *password) { char *request; // The 'Auth' message int length; // The length of the 'Auth' message add_command(&request, COMMAND_AUTH); // |-------------------| add_key(&request, KEY_USERNAME); // |Auth\n | add_value(&request, username); // |-------------------| add_key(&request, KEY_PASSWORD); // |Username:value\n | add_value(&request, password); // |-------------------| delimit_header(&request); // |Password:value\n\n | // |-------------------| length = strlen(request); // Check to see if the message sent successfully if (send_all(sockfd, request, &length) == -1) { syslog(LOG_ERR, "Only sent %d bytes\n", length); } //end if free(request); request = NULL; } //end request_auth
int t = result; while(t >= 0x0100) { num ++; t = t >> 1; } num --; result = result ^ (m << num); } temp = result; return temp; } void row_mix(unsigned char state[4][4]) { unsigned char temp[4][4]; for (int i = 0 ; i < 4 ; i ++) { for(int j = 0 ; j < 4 ; j ++) { temp[i][j] = state[i][j]; } } for(int i = 0 ; i < 4 ; i ++) { state[0][i] = mul_gf8(0x02,temp[0][i]) ^ mul_gf8(0x03,temp[1][i]) ^ mul_gf8(0x01,temp[2][i]) ^ mul_gf8(0x01,temp[3][i]); state[1][i] = mul_gf8(0x01,temp[0][i]) ^ mul_gf8(0x02,temp[1][i]) ^ mul_gf8(0x03,temp[2][i]) ^ mul_gf8(0x01,temp[3][i]); state[2][i] = mul_gf8(0x01,temp[0][i]) ^ mul_gf8(0x01,temp[1][i]) ^ mul_gf8(0x02,temp[2][i]) ^ mul_gf8(0x03,temp[3][i]); state[3][i] = mul_gf8(0x03,temp[0][i]) ^ mul_gf8(0x01,temp[1][i]) ^ mul_gf8(0x01,temp[2][i]) ^ mul_gf8(0x02,temp[3][i]);
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { if (record->event.pressed) dprint("P"); else dprint("R"); if (record->tap.interrupted) dprint("i"); # define MODS_SHIFT_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)) static uint8_t shift_mod; switch (id) { // Shift + Esc -> ~ case SHIFT_ESC: shift_mod = get_mods()&MODS_SHIFT_MASK; if (record->event.pressed) { if (shift_mod) { add_key(KC_GRV); send_keyboard_report(); // send grave with shift for tilde result } else { del_mods(shift_mod); // remove shift add_key(KC_ESC); send_keyboard_report(); // send escape add_mods(shift_mod); // return shift but not sent } } else { if (shift_mod) { del_key(KC_GRV); send_keyboard_report(); } else { del_key(KC_ESC); send_keyboard_report(); } } break; case SHIFT_BSPC: shift_mod = get_mods()&MODS_SHIFT_MASK; if (record->event.pressed) { if (shift_mod) { add_key(KC_BSLS); send_keyboard_report(); // send backslash with shift for pipe result } else { del_mods(shift_mod); // remove shift add_key(KC_BSPC); send_keyboard_report(); // send backspace add_mods(shift_mod); // return shift but not sent } } else { if (shift_mod) { del_key(KC_BSLS); send_keyboard_report(); } else { del_key(KC_BSPC); send_keyboard_report(); } } break; } }
void special_esc(bool pressed) { if (pressed) { if (shifted() || guied()) { add_key(KC_GRV); } else { add_key(KC_ESC); } send_keyboard_report(); } else { clear_keyboard_but_mods(); } }
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { static uint8_t mods_pressed; static bool mod_flag; switch (id) { case 0: // clueboard specific hook to make escape quite tetris if (tetris_running) { tetris_running = 0; return; } /* Handle the combined Grave/Esc key */ mods_pressed = get_mods()&GRAVE_MODS; // Check to see what mods are pressed if (record->event.pressed) { /* The key is being pressed. */ if (mods_pressed) { mod_flag = true; add_key(KC_GRV); send_keyboard_report(); } else { add_key(KC_ESC); send_keyboard_report(); } } else { /* The key is being released. */ if (mod_flag) { mod_flag = false; del_key(KC_GRV); send_keyboard_report(); } else { del_key(KC_ESC); send_keyboard_report(); } } break; case 1: if (record->event.pressed) { tetris_running = 1; tetris_timer = 0; tetris_keypress = 0; // set randomness using total number of key presses tetris_start(tetris_key_presses); } break; } }
/* emulate poll_keyboard() and poll_joystick() combined */ void poll_input() { ALLEGRO_EVENT event; while (al_get_next_event(input_queue, &event)) { switch (event.type) { case ALLEGRO_EVENT_KEY_DOWN: key[event.keyboard.keycode] = 1; add_key(&event.keyboard); break; case ALLEGRO_EVENT_KEY_REPEAT: add_key(&event.keyboard); break; case ALLEGRO_EVENT_KEY_UP: key[event.keyboard.keycode] = 0; break; case ALLEGRO_EVENT_JOYSTICK_BUTTON_DOWN: if (event.joystick.button == 0) joy_b1 = 1; break; case ALLEGRO_EVENT_JOYSTICK_BUTTON_UP: if (event.joystick.button == 0) joy_b1 = 0; break; case ALLEGRO_EVENT_JOYSTICK_AXIS: if (event.joystick.stick == 0 && event.joystick.axis == 0) { float pos = event.joystick.pos; joy_left = (pos < 0.0); joy_right = (pos > 0.0); } break; case ALLEGRO_EVENT_TIMER: /* retrace_count incremented */ break; case ALLEGRO_EVENT_DISPLAY_EXPOSE: break; } } }
/* * user defined action function */ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { keyevent_t event = record->event; tap_t tap = record->tap; switch (id) { case LSHIFT_LPAREN: // LShft + tap '(' // NOTE: cant use register_code to avoid conflicting with magic key bind if (event.pressed) { if (tap.count == 0 || tap.interrupted) { add_mods(MOD_BIT(KC_LSHIFT)); } else { add_mods(MOD_BIT(KC_LSHIFT)); add_key(KC_9); send_keyboard_report(); del_mods(MOD_BIT(KC_LSHIFT)); del_key(KC_9); send_keyboard_report(); } } else { if (tap.count == 0 || tap.interrupted) { del_mods(MOD_BIT(KC_LSHIFT)); //layer_off(1); } } break; case RSHIFT_RPAREN: // RShift + tap ')' if (event.pressed) { if (tap.count == 0 || tap.interrupted) { add_mods(MOD_BIT(KC_RSHIFT)); } else { add_mods(MOD_BIT(KC_RSHIFT)); add_key(KC_0); send_keyboard_report(); del_mods(MOD_BIT(KC_RSHIFT)); del_key(KC_0); send_keyboard_report(); } } else { if (tap.count == 0 || tap.interrupted) { del_mods(MOD_BIT(KC_RSHIFT)); } } break; } }
class_tag::class_tag(const config & cfg) : name_(cfg["name"].str()) , min_(cfg["min"].to_int()) , max_(cfg["max"].to_int()) , super_("") , tags_() , keys_() , links_() { if (max_ < 0){ max_ = INT_MAX; } if (cfg.has_attribute("super")){ super_ = cfg["super"].str(); } foreach (const config &child, cfg.child_range("tag")) { class_tag child_tag (child); add_tag(child_tag); } foreach (const config &child, cfg.child_range("key")) { class_key child_key (child); add_key(child_key); } foreach (const config &link, cfg.child_range("link")) { std::string link_name = link["name"].str(); add_link(link_name); } }
void hal_aes_crypt(uint8_t * dest_buf,uint8_t * src_buf) { uint8_t a; for(a=0; a<16; a++) { aes_state[a] = src_buf[a]; } //Start CCPDATIB = 0x02; //Set co-prosessor the GF(2^8)*2 (used in mix-colums) for (a=0; a<9; a++) { add_sub_shift(); mix_columns_hw(); key_upgrade(a); } //FINAL round add_sub_shift(); key_upgrade(9); add_key(); //Clean up for(a=0; a<16; a++) { aes_round_key[a]=cipher_key[a]; //Write back cipher-key dest_buf[a] = aes_state[a]; //Write out encrypted result } }
static int add_secret_to_kernel(const char *secret, const char *key_name) { /* try to submit key to kernel via the keys api */ key_serial_t serial; int ret; int secret_len = strlen(secret); char payload[((secret_len * 3) / 4) + 4]; char error_buf[80]; ret = ceph_unarmor(payload, payload+sizeof(payload), secret, secret+secret_len); if (ret < 0) { fprintf(stderr, "secret is not valid base64: %s.\n", strerror_r(-ret, error_buf, sizeof(error_buf))); return ret; } serial = add_key("ceph", key_name, payload, sizeof(payload), KEY_SPEC_USER_KEYRING); if (serial < 0) { ret = -errno; fprintf(stderr, "error adding secret to kernel, key name %s: %s.\n", key_name, strerror_r(-ret, error_buf, sizeof(error_buf))); } return ret; }
/*@-globs -internalglobs -mods @*/ char * _GetPass(const char * prompt) { char * pw; /*@-unrecog@*/ pw = getpass( prompt ? prompt : "" ); /*@=unrecog@*/ #if defined(HAVE_KEYUTILS_H) if (_kuKeyring == 0) { const char * _keyutils_keyring = rpmExpand("%{?_keyutils_keyring}", NULL); _kuKeyring = (rpmuint32_t) kuValue(_keyutils_keyring); if (_kuKeyring == 0) _kuKeyring = KEY_SPEC_PROCESS_KEYRING; _keyutils_keyring = _free(_keyutils_keyring); } if (pw && *pw) { key_serial_t keyring = (key_serial_t) _kuKeyring; size_t npw = strlen(pw); (void) add_key("user", "rpm:passwd", pw, npw, keyring); (void) memset(pw, 0, npw); /* burn the password */ pw = (char *) "@u user rpm:passwd"; } #endif /* HAVE_KEYUTILS_H */ assert(pw != NULL); /*@-observertrans -statictrans@*/ return pw; /*@=observertrans =statictrans@*/ }
static int key(W_Event *data) { if (data->y == (metaHeight-B_ADD)) return add_key(data); if (data->key == 113 || data->key == 196) { /* q or ^d */ metadone(); terminate(0); } else if (data->key == 114 || data->key == 210) { /* r or ^r */ refresh(); } else if (data->key == W_Key_Up) { choose(-1); } else if (data->key == W_Key_Down) { choose(1); } else if (data->key == '\r' || data->key == ' ') { /* enter or space */ if (chosen != -1) return chose(chosen, W_LBUTTON); } else if (data->key == 'g') { /* g, for guest */ if (chosen != -1) return chose(chosen, W_MBUTTON); } else if (data->key == 'o') { /* o, for observe */ if (chosen != -1) return chose(chosen, W_RBUTTON); } else if (data->key == 'h') { toggle_help(); } else { return button(data); } return 0; }
int receive_tau (void *msg) { msg_s *m = msg; msgbuf_s *mb; packet_s *p; ki_t k; int rc; mb = emalloc(sizeof(msgbuf_s)); receive_tcp(mb); // deq_dq( &Me.pr_msgq, mb, mb_process); // if (!mb) return ENOMSGS; p = &mb->mb_packet; rc = p->pk_error; if (rc) return rc; k = 0; if (p->pk_passed_key.k_id) { k = add_key(p->pk_passed_key); if (!k) fatal("Out of keys"); } p->pk_sys.q_passed_key = k; memmove(m, &p->pk_sys, sizeof(msg_s)); free(mb); return 0; }
// keyboard service routine void keyboard_routine(void) { struct list_head *e; struct task_struct *t; unsigned char c = inb(0x60); if ((c & 0x80) == 0) { // make char aux = char_map[c&0x7F]; if (aux != '\0') { print_key(aux); add_key(aux); if (threads_waiting()) { //sys_write(1,"esperant",8); e = list_first(&key_buffer.keyboardqueue); t = list_head_to_task_struct(e); if (can_read(t->num_chars_to_read)) { sys_write(1,"llegim",6); list_del(e); list_add_tail(e, &readyqueue); } } //char b[1]; //itoa(current()->num_chars_to_read,b); //sys_write(1,b,1); //print_buffer(6); } else { print_key('C'); } } else { // break // do nothing } }
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) { switch (id) { case SPACE_FN: if (record->event.pressed) { // Change the keyboard maps. // Whatever even layer's are on, turn on the odd one's too. for (uint8_t i = 0; i < 9; i += 2) { if (layer_state & (1UL << i)) layer_on(i + 1); } layer_on(1); } else { // turn off all the even layers. for (uint8_t i = 0; i < 9; i += 2) layer_off(i + 1); if (record->tap.count != 0) { // Space was tapped rather than used like a modifier. // So send a space up and down event. add_key(KC_SPC); send_keyboard_report(); del_key(KC_SPC); send_keyboard_report(); } } break; } }
int create_gate_tau (void *msg) { msg_s *m = msg; static u64 id = 0; gate_s *gate; key_s key; ki_t k; gate = ezalloc(sizeof(*gate)); gate->gt_id = ++id; gate->gt_tag = m->q.q_tag; gate->gt_type = m->q.q_type; gate->gt_avatar = &Me; add_gate(gate); m->cr_id = gate->gt_id; key.k_length = 0; key.k_node = 0; key.k_type = gate->gt_type; key.k_reserved = 0; key.k_id = gate->gt_id; k = add_key(key); if (!k) fatal("Out of keys"); m->q.q_passed_key = k; return 0; }
static int init_key(char *name, int cmd) { int n; int sec = 1; n = add_key("keyring", name, NULL, 0, KEY_SPEC_THREAD_KEYRING); if (n == -1) tst_brk(TBROK | TERRNO, "add_key() failed"); if (cmd == KEYCTL_REVOKE) { if (keyctl(cmd, n) == -1) { tst_brk(TBROK | TERRNO, "failed to revoke a key"); } } if (cmd == KEYCTL_SET_TIMEOUT) { if (keyctl(cmd, n, sec) == -1) { tst_brk(TBROK | TERRNO, "failed to set timeout for a key"); } sleep(sec + 1); } return n; }
static void refresh_callback (SoupSession *session, SoupMessage *msg, SeahorseHKPOperation *hop) { GList *keys, *k; if (hop->cancelling) return; if (SOUP_MESSAGE_IS_ERROR (msg)) { fail_hkp_operation (hop, msg, NULL); return; } keys = parse_hkp_index (msg->response_body->data); for (k = keys; k; k = g_list_next (k)) add_key (hop->hsrc, SEAHORSE_PGP_KEY (k->data)); seahorse_object_list_free (keys); if (--hop->requests <= 0) seahorse_operation_mark_done (SEAHORSE_OPERATION (hop), FALSE, NULL); else seahorse_operation_mark_progress_full (SEAHORSE_OPERATION (hop), _("Searching for keys..."), hop->requests, hop->total); }
/* We are adding values to the tree while insterting the to a std::unordered_set as well. Afterwards we compare the set's and the tree's size and check if every key found in the set can be found in the tree as well. */ TEST(LibAvlBasicSanity, validate_with_set) { auto n = TEST_NUMBER; while(n--) { auto keys_vec = generate_random_keys(TREE_SIZE, MAX_TEST_UINT); std::unordered_set<int> keys{}; auto avl = avl::AvlTree<int>(); uint quantity = 0; for(auto value : keys_vec) { if(avl.add_key(value)) { keys.insert(value); quantity++; } else { ASSERT_TRUE(avl.find_key(value)); } validate_bst(avl.get_root()); ASSERT_EQ(quantity, get_subtree_count(avl.get_root())); ASSERT_EQ(quantity, keys.size()); } for(const auto& value : keys_vec) { ASSERT_TRUE(avl.find_key(value)); } } }
/* Function for updating the keyboard buffer and pushing back codes that haven't received a break code yet. */ void update_input_buffer( UINT8 bTimeElapsed ) { UINT8 bIndex = 0; int old_ssp = Super( 1 ); int old_ipl; if( USER_MODE == old_ssp ) old_ssp = Super( 0 ); old_ipl = set_ipl( KEYBOARD_INTERRUPT_MASK ); for( bIndex; bIndex < cHotKeyCount; bIndex++ ) { if( cMakeTable[ bHotKeys[ bIndex ] ].bMakeReceived ) { cMakeTable[ bHotKeys[ bIndex ] ].wDuration -= bTimeElapsed; if( cMakeTable[ bHotKeys[ bIndex ] ].wDuration == 0 || cMakeTable[ bHotKeys[ bIndex ] ].wDuration > STARTING_DURATION ) { add_key( bHotKeys[ bIndex ] ); cMakeTable[ bHotKeys[ bIndex ] ].wDuration = SUBSEQUENT_DURATION; } } } set_ipl( old_ipl ); if( SUPER_MODE != old_ssp ) Super( old_ssp ); }
int ecryptfs_add_auth_tok_to_keyring(struct ecryptfs_auth_tok *auth_tok, char *auth_tok_sig) { int rc; rc = (int)keyctl_search(KEY_SPEC_USER_KEYRING, "user", auth_tok_sig, 0); if (rc != -1) { /* we already have this key in keyring; we're done */ rc = 1; goto out; } else if ((rc == -1) && (errno != ENOKEY)) { int errnum = errno; syslog(LOG_ERR, "keyctl_search failed: %m errno=[%d]\n", errnum); rc = (errnum < 0) ? errnum : errnum * -1; goto out; } rc = add_key("user", auth_tok_sig, (void *)auth_tok, sizeof(struct ecryptfs_auth_tok), KEY_SPEC_USER_KEYRING); if (rc == -1) { rc = -errno; syslog(LOG_ERR, "Error adding key with sig [%s]; rc = [%d] " "\"%m\"\n", auth_tok_sig, rc); if (rc == -EDQUOT) syslog(LOG_WARNING, "Error adding key to keyring - keyring is full\n"); goto out; } rc = 0; out: return rc; }
// Sends the HMDP response '302' // @param connectionfd the socket descriptor of the client // @param response_list the list of files for the client to upload void response_302(int connectionfd, csv_record *response_list) { char *response; // The '302' message char *list_size; // The size of the body of the message int length; // The length of the message asprintf(&list_size, "%d", get_list_size(response_list)); add_status(&response, STATUS_302); // |----------------------| add_message(&response, MESSAGE_302); // |302 Files requested\n | add_key(&response, KEY_LENGTH); // |----------------------| add_value(&response, list_size); // |Length:value\n\n | delimit_header(&response); // |----------------------| add_body(&response, response_list); // |Body: | // |----------------------| length = strlen(response); // Check to see if the message sent successfully if (send_all(connectionfd, response, &length) == -1) { syslog(LOG_ERR, "Only sent %d bytes\n", length); } //end if free(list_size); free(response); list_size = NULL; response = NULL; } //end response_302
PAM_EXTERN int pam_sm_authenticate(pam_handle_t *pamh, int flags, int argc, const char **argv) { int ret; char const *user; ret = pam_get_item(pamh, PAM_USER, (void const **)&user); if (ret != PAM_SUCCESS) return PAM_IGNORE; int user_len = strlen(user); char const *pw; ret = pam_get_item(pamh, PAM_AUTHTOK, (void const **)&pw); if (ret != PAM_SUCCESS) return PAM_IGNORE; int pw_len = strlen(pw); int key_len = 24; char key[24]; PKCS5_PBKDF2_HMAC_SHA1(pw, pw_len, user, user_len, 1000, key_len, key); add_key("user", "login", key, key_len, KEY_SPEC_SESSION_KEYRING); return PAM_SUCCESS; }