C++ print_key函数代码示例

static void interactive(int fd)
{
	struct input_event ev;
	uint32_t last_scan = 0;
	uint16_t last_key = 0;
	int has_scan; /* boolean */
	int has_key; /* 0: none, 1: release, 2: press */

	/* grab input device */
	ioctl(fd, EVIOCGRAB, 1);
	puts("Press ESC to finish, or Control-C if this device is not your primary keyboard");

	has_scan = has_key = 0;
	while (read_event(fd, &ev)) {
		/* Drivers usually send the scan code first, then the key code,
		 * then a SYN. Some drivers (like thinkpad_acpi) send the key
		 * code first, and some drivers might not send SYN events, so
		 * keep a robust state machine which can deal with any of those
		 */

		if (ev.type == EV_MSC && ev.code == MSC_SCAN) {
			if (has_scan) {
				fputs("driver did not send SYN event in between key events; previous event:\n",
				      stderr);
				print_key(last_scan, last_key, has_scan, has_key);
				has_key = 0;
			}

			last_scan = ev.value;
			has_scan = 1;
			/*printf("--- got scan %u; has scan %i key %i\n", last_scan, has_scan, has_key); */
		}
		else if (ev.type == EV_KEY) {
			if (has_key) {
				fputs("driver did not send SYN event in between key events; previous event:\n",
				      stderr);
				print_key(last_scan, last_key, has_scan, has_key);
				has_scan = 0;
			}

		       	last_key = ev.code;
			has_key = 1 + ev.value;
			/*printf("--- got key %hu; has scan %i key %i\n", last_key, has_scan, has_key);*/

			/* Stop on ESC */
			if (ev.code == KEY_ESC && ev.value == 0)
				break;
		}
		else if (ev.type == EV_SYN) {
			/*printf("--- got SYN; has scan %i key %i\n", has_scan, has_key);*/
			print_key(last_scan, last_key, has_scan, has_key);

			has_scan = has_key = 0;
		}

	}

	/* release input device */
	ioctl(fd, EVIOCGRAB, 0);
}

static void cmap_notify_fn(
	cmap_handle_t cmap_handle,
	cmap_track_handle_t cmap_track_handle,
	int32_t event,
	const char *key_name,
	struct cmap_notify_value new_val,
	struct cmap_notify_value old_val,
	void *user_data)
{
	switch (event) {
	case CMAP_TRACK_ADD:
		printf("create> ");
		print_key(cmap_handle, key_name, new_val.len, new_val.data, new_val.type);
		break;
	case CMAP_TRACK_DELETE:
		printf("delete> ");
		print_key(cmap_handle, key_name, old_val.len, old_val.data, old_val.type);
		break;
	case CMAP_TRACK_MODIFY:
		printf("modify> ");
		print_key(cmap_handle, key_name, new_val.len, new_val.data, new_val.type);
		break;
	default:
		printf("unknown change> ");
		break;
	}

}

/*
* Routine: 
* Purpose: 
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By: 
* Calls: 
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_store_returns(void *row)
{
	struct W_STORE_RETURNS_TBL *r;


	if (row == NULL)
		r = &g_w_store_returns;
	else
		r = row;
	print_start(STORE_RETURNS);
	print_key(SR_RETURNED_DATE_SK, r->sr_returned_date_sk, 1);
	print_key(SR_RETURNED_TIME_SK, r->sr_returned_time_sk, 1);
	print_key(SR_ITEM_SK, r->sr_item_sk, 1);
	print_key(SR_CUSTOMER_SK, r->sr_customer_sk, 1);
	print_key(SR_CDEMO_SK, r->sr_cdemo_sk, 1);
	print_key(SR_HDEMO_SK, r->sr_hdemo_sk, 1);
	print_key(SR_ADDR_SK, r->sr_addr_sk, 1);
	print_key(SR_STORE_SK, r->sr_store_sk, 1);
	print_key(SR_REASON_SK, r->sr_reason_sk, 1);
	print_key(SR_TICKET_NUMBER, r->sr_ticket_number, 1);
	print_integer(SR_PRICING_QUANTITY, r->sr_pricing.quantity, 1);
	print_decimal(SR_PRICING_NET_PAID, &r->sr_pricing.net_paid, 1);
	print_decimal(SR_PRICING_EXT_TAX, &r->sr_pricing.ext_tax, 1);
	print_decimal(SR_PRICING_NET_PAID_INC_TAX, &r->sr_pricing.net_paid_inc_tax, 1);
	print_decimal(SR_PRICING_FEE, &r->sr_pricing.fee, 1);
	print_decimal(SR_PRICING_EXT_SHIP_COST, &r->sr_pricing.ext_ship_cost, 1);
	print_decimal(SR_PRICING_REFUNDED_CASH, &r->sr_pricing.refunded_cash, 1);
	print_decimal(SR_PRICING_REVERSED_CHARGE, &r->sr_pricing.reversed_charge, 1);
	print_decimal(SR_PRICING_STORE_CREDIT, &r->sr_pricing.store_credit, 1);
	print_decimal(SR_PRICING_NET_LOSS, &r->sr_pricing.net_loss, 0);
	print_end(STORE_RETURNS);
	
	return(0);
}

static int poll_events(void)
{
  gx_event ev;

  while (gx_poll(&ev)) {
    switch (ev.type) {
    case GX_ev_quit:
      return 1;
    case GX_ev_keydown:
      print_key(ev.key, 1);
      if (ev.key == GX_key_esc)
        return 1;
      else if (ev.key == 'f') {
        limitfps ^= 1;
        printf("limitfps: %d\n", limitfps);
      } else if (ev.key == 'm') {
        pmouse ^= 1;
        printf("pmouse: %d\n", pmouse);
      }
      break;
    case GX_ev_keyup:
      print_key(ev.key, 0);
      break;
    case GX_ev_keychar:
      print_char(ev.key);
      break;
    case GX_ev_mouse:
      if (pmouse)
        printf("mouse: %3d,%3d\n", (int)(ev.mx*XRES), (int)(ev.my*YRES));
      break;
    }
  }
  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
  }
}

/*
* Routine: 
* Purpose: 
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By: 
* Calls: 
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_customer(void *row)
{
	struct W_CUSTOMER_TBL *r;

	if (row == NULL)
		r = &g_w_customer;
	else
		r = row;

	print_start(CUSTOMER);
	print_key(C_CUSTOMER_SK, r->c_customer_sk, 1);
	print_varchar(C_CUSTOMER_ID, r->c_customer_id, 1);
	print_key(C_CURRENT_CDEMO_SK, r->c_current_cdemo_sk, 1);
	print_key(C_CURRENT_HDEMO_SK, r->c_current_hdemo_sk, 1);
	print_key(C_CURRENT_ADDR_SK, r->c_current_addr_sk, 1);
	print_integer(C_FIRST_SHIPTO_DATE_ID, r->c_first_shipto_date_id, 1);
	print_integer(C_FIRST_SALES_DATE_ID, r->c_first_sales_date_id, 1);
	print_varchar(C_SALUTATION, r->c_salutation, 1);
	print_varchar(C_FIRST_NAME, r->c_first_name, 1);
	print_varchar(C_LAST_NAME, r->c_last_name, 1);
	print_boolean(C_PREFERRED_CUST_FLAG, r->c_preferred_cust_flag, 1);
	print_integer(C_BIRTH_DAY, r->c_birth_day, 1);
	print_integer(C_BIRTH_MONTH, r->c_birth_month, 1);
	print_integer(C_BIRTH_YEAR, r->c_birth_year, 1);
	print_varchar(C_BIRTH_COUNTRY, r->c_birth_country, 1);
	print_varchar(C_LOGIN, &r->c_login[0], 1);
	print_varchar(C_EMAIL_ADDRESS, &r->c_email_address[0], 1);
	print_integer(C_LAST_REVIEW_DATE, r->c_last_review_date, 0);
	print_end(CUSTOMER);

	return(0);
}

void ls_recv_playok(unsigned char *raw, unsigned char *sessionkey_p1, unsigned char *sessionkey_p2)
{	
	printf("[!] Проверка возможности подключения успешно произведена! \n");
	memcpy(sessionkey_p1,raw+3,4);
	memcpy(sessionkey_p2,raw+7,4);
	printf("[!] Задан SessionKey2: ");
	print_key(sessionkey_p1,4);
	print_key(sessionkey_p2,4);
	printf("\n");
}

void ls_recv_logok(unsigned char* raw, unsigned char* sessionkey_p1, unsigned char* sessionkey_p2)
{
	printf("[!] Авторизация на логин-сервере успешно произведена!\n");
	memcpy(sessionkey_p1,raw+3,4);
	memcpy(sessionkey_p2,raw+7,4);
	printf("[!] Задан SessionKey1: ");	
	print_key(sessionkey_p1,4);
	print_key(sessionkey_p2,4);
	printf("\n");
}

bool x11_hotkeys::grab_keys(Display *dpy, Keys_t keys[], int nb_keys)
{
  int i;
  int min, max;
  int screen;
  

  XDisplayKeycodes(dpy, &min, &max);

#ifdef DEBUG  
  printf("\n");
  printf("min_keycode=%d     max_keycode=%d (ie: know keycodes)\n", 
	 min, max);
#endif  


  for (i = 0; i < nb_keys; i++) {
#ifdef DEBUG
    print_key(dpy, &keys[i]);
#endif
    if (keys[i].type == SYM) {
      for (screen = 0; screen < ScreenCount (dpy); screen++) {
				my_grab_key(dpy, XKeysymToKeycode(dpy, keys[i].key.sym),
										keys[i].modifier, RootWindow(dpy, screen));
      }
    } else if (keys[i].type == BUTTON) {
      for (screen = 0; screen < ScreenCount (dpy); screen++) {
	my_grab_button(dpy, keys[i].key.button, keys[i].modifier,
		       RootWindow (dpy, screen));
      }
    } else {
      if (keys[i].key.code >= min && keys[i].key.code <= max) {
	for (screen = 0; screen < ScreenCount (dpy); screen++) {
	  my_grab_key (dpy, keys[i].key.code, keys[i].modifier,
		       RootWindow (dpy, screen));
	}
      } else {
#ifdef DEBUG	
	print_key (dpy, &keys[i]);


	fprintf (stderr,
		 "  The keycode %d cannot be used, as it's not between the\n"
		 "  min(%d) and max(%d) keycode of your keyboard.\n"
		 "  Please increase the 'maximum' value in\n"
		 "    /usr/X11R6/lib/X11/xkb/keycodes/xfree86,\n"
		 "  then restart X.\n", keys[i].key.code, min, max);	
#endif	
	return false;
      }
    }
  }

  return true;
}

int main(int argc, char *argv[]) {
	gcry_mpi_t g,p,M,N,pw,t1,t2;
	size_t scanned;
	int iterations, keySize;

	g = gcry_mpi_new(0);
	p = gcry_mpi_new(0);
	M = gcry_mpi_new(0);
	N = gcry_mpi_new(0);
	pw = gcry_mpi_new(0);
	t1 = gcry_mpi_new(0);
	t2 = gcry_mpi_new(0);

	/* MODP_2048 */
	const char* pString = "00FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF";
	const char* gString = "2";

	/* password */
	const char* pwd = "My$Very=Secure;Password";
	const char* salt = "abcdefghijklmno";
	iterations = 1000;
	keySize = 32;	
	
	/* read p and g */
	gcry_mpi_scan(&g, GCRYMPI_FMT_HEX, gString, 0, &scanned);
	gcry_mpi_scan(&p, GCRYMPI_FMT_HEX, pString, 0, &scanned);

	/* hash password */
	char* result = calloc(keySize, sizeof(char));
	gcry_kdf_derive(pwd, strlen(pwd), GCRY_KDF_PBKDF2, GCRY_MD_SHA256, salt, strlen(salt), iterations, keySize, result);
	gcry_mpi_scan(&pw, GCRYMPI_FMT_STD, result, strlen((const char*)result), &scanned);

	/* create M and N */
	gen_rand(t1, p);
	gen_rand(t2, p);
	gcry_mpi_powm(M, g, t1, p);
	gcry_mpi_powm(N, g, t2, p);

	/* run test ... */
	struct spake_session client = spake_init(0, g, p, M, N, pw, keySize); /* client */
	struct spake_session server = spake_init(1, g, p, M, N, pw, keySize); /* server */

	spake_next(&client, server.X);
	spake_next(&server, client.X);

	print_key(client.k, keySize, "k1");
	print_key(server.k, keySize, "k2");

	if (strncmp(client.k, server.k, keySize) == 0)
		printf("Successful SPAKE session :)\n");
	else
		printf("Sorry, error in SPAKE session :(\n");
	
	return 0;
}

static void decrypt_password(uint8_t *encryptkey, uint8_t *IV, uint8_t *integrity){
	char password[128];

	ask_password(password, sizeof(password));
#ifdef CRYPTO_DEBUG
	print_key("encrypt_salt",descriptor.encryption_salt, sizeof(descriptor.encryption_salt));
	print_key("password salt", descriptor.password_salt, sizeof(descriptor.password_salt));
#endif
	compute_session_keys_password(
			password, descriptor.hash_loops,
			encryptkey, IV, integrity,
			descriptor.encryption_salt,
			descriptor.password_salt);
	ZERO(password);
}

/*
* Routine: 
* Purpose: 
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By: 
* Calls: 
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_item(void *pSrc)
{
	struct W_ITEM_TBL *r;

	if (pSrc == NULL)
		r = &g_w_item;
	else
		r = pSrc;
	
	print_start(S_ITEM);
	print_varchar(S_ITEM_ID, r->i_item_id, 1);
	print_varchar(S_ITEM_DESC, r->i_item_desc, 1);
	print_decimal(S_ITEM_LIST_PRICE, &r->i_current_price, 1);
	print_decimal(S_ITEM_WHOLESALE_COST, &r->i_wholesale_cost, 1);
	print_varchar(S_ITEM_SIZE, r->i_size, 1);
	print_varchar(S_ITEM_FORMULATION, r->i_formulation, 1);
	print_varchar(S_ITEM_FLAVOR, r->i_color, 1);
	print_varchar(S_ITEM_UNITS, r->i_units, 1);
	print_varchar(S_ITEM_CONTAINER, r->i_container, 1);
	print_key(S_ITEM_MANAGER_ID, r->i_manager_id, 0);
	print_end(S_ITEM);
	
	return(0);
}

/*
* Routine: 
* Purpose: 
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By: 
* Calls: 
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_web_return(void *pSrc)
{
	struct S_WEB_RETURNS_TBL *r;
	
	if (pSrc == NULL)
		r = &g_s_web_returns;
	else
		r = pSrc;
	
	print_start(S_WEB_RETURNS);
	print_id(S_WRET_SITE_ID, r->kSiteID, 1);
	print_key(S_WRET_ORDER_ID,r->kOrderID, 1);
	print_integer(S_WRET_LINE_NUMBER, r->nLineNumber, 1);
	print_id(S_WRET_ITEM_ID, r->kItemID, 1);
	print_id(S_WRET_RETURN_CUST_ID, r->kReturningCustomerID, 1);
	print_id(S_WRET_REFUND_CUST_ID,r->kRefundedCustomerID, 1);
	print_date(S_WRET_RETURN_DATE, r->dtReturnDate.julian, 1);
	print_time(S_WRET_RETURN_TIME, r->kReturnTime, 1);
	print_integer(S_WRET_PRICING, r->Pricing.quantity, 1);
	print_decimal(S_WRET_PRICING, &r->Pricing.ext_sales_price, 1);
	print_decimal(S_WRET_PRICING, &r->Pricing.ext_tax, 1);
   print_decimal(S_WRET_PRICING, &r->Pricing.fee, 1);
	print_decimal(S_WRET_PRICING, &r->Pricing.ext_ship_cost, 1);
	print_decimal(S_WRET_PRICING, &r->Pricing.refunded_cash, 1);
	print_decimal(S_WRET_PRICING, &r->Pricing.reversed_charge, 1);
	print_decimal(S_WRET_PRICING, &r->Pricing.store_credit, 1);
   print_id(S_WRET_REASON_ID, r->kReasonID, 0);
	print_end(S_WEB_RETURNS);
	
	return(0);
}

void
print_class(const struct tesla_class *c)
{
	static const char *DEBUG_NAME = "libtesla.class.state";
	if (!tesla_debugging(DEBUG_NAME))
		return;

	print("----\n");
	print("struct tesla_class @ 0x%tx {\n", (intptr_t) c);
	print("  name:         '%s',\n", c->tc_automaton->ta_name);
	print("  description:  '[...]',\n");   // TL;DR
	print("  scope:        ");
	switch (c->tc_context) {
		case TESLA_CONTEXT_THREAD:  print("thread-local\n"); break;
		case TESLA_CONTEXT_GLOBAL:  print("global\n");       break;
		default:
			print("UNKNOWN (0x%x)\n", c->tc_context);
	}
	print("  limit:        %d\n", c->tc_limit);
	print("  %d/%d instances\n", c->tc_limit - c->tc_free, c->tc_limit);
	for (uint32_t i = 0; i < c->tc_limit; i++) {
		const struct tesla_instance *inst = c->tc_instances + i;
		if (!tesla_instance_active(inst))
			continue;

		print("    %2u: state %d, ", i, inst->ti_state);
		print_key(DEBUG_NAME, &inst->ti_key);
		print("\n");
	}
	print("}\n");
	print("----\n");
}

/*
* Routine: 
* Purpose: 
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By: 
* Calls: 
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_purchase(void *pSrc)
{
	struct S_PURCHASE_TBL *r;
   char szKey[RS_BKEY + 1];

   if (pSrc == NULL)
		r = &g_s_purchase;
	else
		r = pSrc;
	
	print_start(S_PURCHASE);
	print_key(S_PURCHASE_ID, r->kID, 1);
   mk_bkey(szKey, r->kID, 0);
   mk_bkey(szKey, r->kStoreID, 0);
	print_varchar(S_PURCHASE_STORE_ID, szKey, 1);
   mk_bkey(szKey, r->kCustomerID, 0);
	print_varchar(S_PURCHASE_CUSTOMER_ID, szKey, 1);
	print_date(S_PURCHASE_DATE, r->dtPurchaseDate.julian, 1);
	print_integer(S_PURCHASE_TIME, r->nPurchaseTime, 1);
	print_integer(S_PURCHASE_REGISTER, r->nRegister, 1);
	print_integer(S_PURCHASE_CLERK, r->nClerk, 1);
	print_varchar(S_PURCHASE_COMMENT, r->szComment, 0);
	print_end(S_PURCHASE);

	return(0);
}