void tty_print_utf8_string2 (estream_t fp, const byte *p, size_t n, size_t max_n) { size_t i; char *buf; if (no_terminal && !fp) return; /* we can handle plain ascii simpler, so check for it first */ for(i=0; i < n; i++ ) { if( p[i] & 0x80 ) break; } if( i < n ) { buf = utf8_to_native( (const char *)p, n, 0 ); if( max_n && (strlen( buf ) > max_n )) { buf[max_n] = 0; } /*(utf8 conversion already does the control character quoting)*/ tty_fprintf (fp, "%s", buf); xfree (buf); } else { if( max_n && (n > max_n) ) { n = max_n; } tty_print_string (fp, p, n ); } }
/* Helper to get the help through the configurable GnuPG help system. */ static char * get_help_from_file (const char *keyword) { char *key, *result; key = xtrymalloc (4 + strlen (keyword) + 1); if (key) { strcpy (stpcpy (key, "gpg."), keyword); result = gnupg_get_help_string (key, 0); xfree (key); if (result && !is_native_utf8 ()) { char *tmp = utf8_to_native (result, strlen (result), -1); if (tmp) { xfree (result); result = tmp; } } } else result = NULL; return result; }
/**************** * Print an UTF8 string to FP and filter all control characters out. */ void print_utf8_string2 ( FILE *fp, const byte *p, size_t n, int delim ) { size_t i; char *buf; /* we can handle plain ascii simpler, so check for it first */ for(i=0; i < n; i++ ) { if( p[i] & 0x80 ) break; } if( i < n ) { buf = utf8_to_native ( p, n, delim ); /*(utf8 conversion already does the control character quoting)*/ fputs( buf, fp ); xfree( buf ); } else print_string( fp, p, n, delim ); }
bool main_menu::new_character_tab() { std::vector<std::string> vSubItems; vSubItems.push_back( pgettext( "Main Menu|New Game", "<C|c>ustom Character" ) ); vSubItems.push_back( pgettext( "Main Menu|New Game", "<P|p>reset Character" ) ); vSubItems.push_back( pgettext( "Main Menu|New Game", "<R|r>andom Character" ) ); if( !MAP_SHARING::isSharing() ) { // "Play Now" function doesn't play well together with shared maps vSubItems.push_back( pgettext( "Main Menu|New Game", "Play Now! (<F|f>ixed Scenario)" ) ); vSubItems.push_back( pgettext( "Main Menu|New Game", "Play <N|n>ow!" ) ); } std::vector<std::vector<std::string>> vNewGameHotkeys; for( auto item : vSubItems ) { vNewGameHotkeys.push_back( get_hotkeys( item ) ); } bool start = false; while( !start && sel1 == 1 && ( layer == 2 || layer == 3 ) ) { print_menu( w_open, 1, iMenuOffsetX, iMenuOffsetY, true ); if( layer == 2 && sel1 == 1 ) { // Then choose custom character, random character, preset, etc if( MAP_SHARING::isSharing() && world_generator->all_worldnames().empty() ) { //don't show anything when there are no worlds (will not work if there are special maps) layer = 1; sel1 = 1; continue; } print_menu_items( w_open, vSubItems, sel2, iMenuOffsetY - 2, iMenuOffsetX ); wrefresh( w_open ); catacurses::refresh(); std::string action = handle_input_timeout( ctxt ); std::string sInput = ctxt.get_raw_input().text; for( size_t i = 0; i < vNewGameHotkeys.size(); ++i ) { for( auto hotkey : vNewGameHotkeys[i] ) { if( sInput == hotkey ) { sel2 = i; action = "CONFIRM"; } } } if( action == "LEFT" ) { sel2--; if( sel2 < 0 ) { sel2 = vSubItems.size() - 1; } on_move(); } else if( action == "RIGHT" ) { sel2++; if( sel2 >= ( int )vSubItems.size() ) { sel2 = 0; } on_move(); } else if( action == "DOWN" || action == "QUIT" ) { layer = 1; sel1 = 1; } if( action == "UP" || action == "CONFIRM" ) { if( sel2 == 0 || sel2 == 2 || sel2 == 3 || sel2 == 4 ) { // First load the mods, this is done by // loading the world. // Pick a world, suppressing prompts if it's "play now" mode. WORLDPTR world = world_generator->pick_world( sel2 != 3 && sel2 != 4 ); if( world == NULL ) { continue; } world_generator->set_active_world( world ); try { g->setup(); } catch( const std::exception &err ) { debugmsg( "Error: %s", err.what() ); g->u = player(); continue; } character_type play_type = PLTYPE_CUSTOM; switch( sel2 ) { case 0: play_type = PLTYPE_CUSTOM; break; case 2: play_type = PLTYPE_RANDOM; break; case 3: play_type = PLTYPE_NOW; break; case 4: play_type = PLTYPE_FULL_RANDOM; break; } if( !g->u.create( play_type ) ) { g->u = player(); werase( w_background ); wrefresh( w_background ); continue; } werase( w_background ); wrefresh( w_background ); if( !g->start_game() ) { g->u = player(); continue; } start = true; } else if( sel2 == 1 ) { layer = 3; sel3 = 0; } } } else if( layer == 3 && sel1 == 1 ) { // Then view presets if( templates.empty() ) { mvwprintz( w_open, iMenuOffsetY - 4, iMenuOffsetX + 20 + extra_w / 2, c_red, _( "No templates found!" ) ); sfx::play_variant_sound( "menu_error", "default", 100 ); } else { mvwprintz( w_open, iMenuOffsetY - 2, iMenuOffsetX + 20 + extra_w / 2, c_white, _( "Press 'd' to delete a preset." ) ); for( int i = 0; i < ( int )templates.size(); i++ ) { int line = iMenuOffsetY - 4 - i; mvwprintz( w_open, line, 20 + iMenuOffsetX + extra_w / 2, ( sel3 == i ? h_white : c_white ), templates[i].c_str() ); } } wrefresh( w_open ); catacurses::refresh(); std::string action = handle_input_timeout( ctxt ); if( action == "DOWN" ) { if( sel3 > 0 ) { sel3--; } else { sel3 = templates.size() - 1; } } else if( templates.empty() && ( action == "UP" || action == "CONFIRM" ) ) { sel1 = 1; layer = 2; print_menu( w_open, sel1, iMenuOffsetX, iMenuOffsetY ); } else if( action == "UP" ) { if( sel3 < ( int )templates.size() - 1 ) { sel3++; } else { sel3 = 0; } } else if( action == "LEFT" || action == "QUIT" || templates.empty() ) { sel1 = 1; layer = 2; print_menu( w_open, sel1, iMenuOffsetX, iMenuOffsetY ); } else if( !templates.empty() && action == "DELETE_TEMPLATE" ) { if( query_yn( _( "Are you sure you want to delete %s?" ), templates[sel3].c_str() ) ) { const auto path = FILENAMES["templatedir"] + utf8_to_native( templates[sel3] ) + ".template"; if( std::remove( path.c_str() ) != 0 ) { popup( _( "Sorry, something went wrong." ) ); } else { templates.erase( templates.begin() + sel3 ); if( ( size_t )sel3 > templates.size() - 1 ) { sel3--; } } } } else if( action == "RIGHT" || action == "CONFIRM" ) { WORLDPTR world = world_generator->pick_world(); if( world == NULL ) { g->u = player(); continue; } world_generator->set_active_world( world ); try { g->setup(); } catch( const std::exception &err ) { debugmsg( "Error: %s", err.what() ); g->u = player(); continue; } if( !g->u.create( PLTYPE_TEMPLATE, templates[sel3] ) ) { g->u = player(); werase( w_background ); wrefresh( w_background ); continue; } werase( w_background ); wrefresh( w_background ); if( !g->start_game() ) { g->u = player(); continue; } start = true; } } } // end while return start; }
/**************** * mode: 0 = standard * 1 = Without key info and additional menu option 'm' * this does also add an option to set the key to ultimately trusted. * Returns: * -2 = nothing changed - caller should show some additional info * -1 = quit operation * 0 = nothing changed * 1 = new ownertrust now in new_trust */ static int do_edit_ownertrust (PKT_public_key *pk, int mode, unsigned *new_trust, int defer_help ) { char *p; u32 keyid[2]; int changed=0; int quit=0; int show=0; int min_num; int did_help=defer_help; unsigned int minimum=get_min_ownertrust(pk); switch(minimum) { default: case TRUST_UNDEFINED: min_num=1; break; case TRUST_NEVER: min_num=2; break; case TRUST_MARGINAL: min_num=3; break; case TRUST_FULLY: min_num=4; break; } keyid_from_pk (pk, keyid); for(;;) { /* A string with valid answers. Note to translators: These are the allowed answers in lower and uppercase. Below you will find the matching strings which should be translated accordingly and the letter changed to match the one in the answer string. i = please show me more information m = back to the main menu s = skip this key q = quit */ const char *ans = _("iImMqQsS"); if( !did_help ) { if( !mode ) { KBNODE keyblock, un; tty_printf(_("No trust value assigned to:\n")); tty_printf("%4u%c/%s %s\n",nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ), keystr(keyid), datestr_from_pk( pk ) ); p=get_user_id_native(keyid); tty_printf(_(" \"%s\"\n"),p); xfree(p); keyblock = get_pubkeyblock (keyid); if (!keyblock) BUG (); for (un=keyblock; un; un = un->next) { if (un->pkt->pkttype != PKT_USER_ID ) continue; if (un->pkt->pkt.user_id->is_revoked ) continue; if (un->pkt->pkt.user_id->is_expired ) continue; /* Only skip textual primaries */ if (un->pkt->pkt.user_id->is_primary && !un->pkt->pkt.user_id->attrib_data ) continue; if((opt.verify_options&VERIFY_SHOW_PHOTOS) && un->pkt->pkt.user_id->attrib_data) show_photos(un->pkt->pkt.user_id->attribs, un->pkt->pkt.user_id->numattribs,pk,NULL); p=utf8_to_native(un->pkt->pkt.user_id->name, un->pkt->pkt.user_id->len,0); tty_printf(_(" aka \"%s\"\n"),p); } print_fingerprint (pk, NULL, 2); tty_printf("\n"); release_kbnode (keyblock); } if(opt.trust_model==TM_DIRECT) { tty_printf(_("How much do you trust that this key actually " "belongs to the named user?\n")); tty_printf("\n"); } else { /* This string also used in keyedit.c:trustsig_prompt */ tty_printf(_("Please decide how far you trust this user to" " correctly verify other users' keys\n" "(by looking at passports, checking fingerprints from" " different sources, etc.)\n")); tty_printf("\n"); } if(min_num<=1) tty_printf (_(" %d = I don't know or won't say\n"), 1); if(min_num<=2) tty_printf (_(" %d = I do NOT trust\n"), 2); if(min_num<=3) tty_printf (_(" %d = I trust marginally\n"), 3); if(min_num<=4) tty_printf (_(" %d = I trust fully\n"), 4); if (mode) tty_printf (_(" %d = I trust ultimately\n"), 5); #if 0 /* not yet implemented */ tty_printf (" i = please show me more information\n"); #endif if( mode ) tty_printf(_(" m = back to the main menu\n")); else { tty_printf(_(" s = skip this key\n")); tty_printf(_(" q = quit\n")); } tty_printf("\n"); if(minimum) tty_printf(_("The minimum trust level for this key is: %s\n\n"), trust_value_to_string(minimum)); did_help = 1; } if( strlen(ans) != 8 ) BUG(); p = cpr_get("edit_ownertrust.value",_("Your decision? ")); trim_spaces(p); cpr_kill_prompt(); if( !*p ) did_help = 0; else if( *p && p[1] ) ; else if( !p[1] && ((*p >= '0'+min_num) && *p <= (mode?'5':'4')) ) { unsigned int trust; switch( *p ) { case '1': trust = TRUST_UNDEFINED; break; case '2': trust = TRUST_NEVER ; break; case '3': trust = TRUST_MARGINAL ; break; case '4': trust = TRUST_FULLY ; break; case '5': trust = TRUST_ULTIMATE ; break; default: BUG(); } if (trust == TRUST_ULTIMATE && !cpr_get_answer_is_yes ("edit_ownertrust.set_ultimate.okay", _("Do you really want to set this key" " to ultimate trust? (y/N) "))) ; /* no */ else { *new_trust = trust; changed = 1; break; } } #if 0 /* not yet implemented */ else if( *p == ans[0] || *p == ans[1] ) { tty_printf(_("Certificates leading to an ultimately trusted key:\n")); show = 1; break; } #endif else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) { break ; /* back to the menu */ } else if( !mode && (*p == ans[6] || *p == ans[7] ) ) { break; /* skip */ } else if( !mode && (*p == ans[4] || *p == ans[5] ) ) { quit = 1; break ; /* back to the menu */ } xfree(p); p = NULL; } xfree(p); return show? -2: quit? -1 : changed; }
/* Returns a keyrec (which must be freed) once a key is complete, and NULL otherwise. Call with a NULL keystring once key parsing is complete to return any unfinished keys. */ static struct keyrec * parse_keyrec(char *keystring) { /* FIXME: Remove the static and put the data into the parms we use for the caller anyway. */ static struct keyrec *work=NULL; struct keyrec *ret=NULL; char *record; int i; if(keystring==NULL) { if(work==NULL) return NULL; else if(work->desc.mode==KEYDB_SEARCH_MODE_NONE) { xfree(work); return NULL; } else { ret=work; work=NULL; return ret; } } if(work==NULL) { work=xmalloc_clear(sizeof(struct keyrec)); work->uidbuf=iobuf_temp(); } trim_trailing_ws (keystring, strlen (keystring)); if((record=strsep(&keystring,":"))==NULL) return ret; if(ascii_strcasecmp("pub",record)==0) { char *tok; gpg_error_t err; if(work->desc.mode) { ret=work; work=xmalloc_clear(sizeof(struct keyrec)); work->uidbuf=iobuf_temp(); } if((tok=strsep(&keystring,":"))==NULL) return ret; err = classify_user_id (tok, &work->desc, 1); if (err || (work->desc.mode != KEYDB_SEARCH_MODE_SHORT_KID && work->desc.mode != KEYDB_SEARCH_MODE_LONG_KID && work->desc.mode != KEYDB_SEARCH_MODE_FPR16 && work->desc.mode != KEYDB_SEARCH_MODE_FPR20)) { work->desc.mode=KEYDB_SEARCH_MODE_NONE; return ret; } /* Note all items after this are optional. This allows us to have a pub line as simple as pub:keyid and nothing else. */ work->lines++; if((tok=strsep(&keystring,":"))==NULL) return ret; work->type=atoi(tok); if((tok=strsep(&keystring,":"))==NULL) return ret; work->size=atoi(tok); if((tok=strsep(&keystring,":"))==NULL) return ret; if(atoi(tok)<=0) work->createtime=0; else work->createtime=atoi(tok); if((tok=strsep(&keystring,":"))==NULL) return ret; if(atoi(tok)<=0) work->expiretime=0; else { work->expiretime=atoi(tok); /* Force the 'e' flag on if this key is expired. */ if(work->expiretime<=make_timestamp()) work->flags|=4; } if((tok=strsep(&keystring,":"))==NULL) return ret; while(*tok) switch(*tok++) { case 'r': case 'R': work->flags|=1; break; case 'd': case 'D': work->flags|=2; break; case 'e': case 'E': work->flags|=4; break; } } else if(ascii_strcasecmp("uid",record)==0 && work->desc.mode) { char *userid,*tok,*decoded; if((tok=strsep(&keystring,":"))==NULL) return ret; if(strlen(tok)==0) return ret; userid=tok; /* By definition, de-%-encoding is always smaller than the original string so we can decode in place. */ i=0; while(*tok) if(tok[0]=='%' && tok[1] && tok[2]) { int c; userid[i] = (c=hextobyte(&tok[1])) == -1 ? '?' : c; i++; tok+=3; } else userid[i++]=*tok++; /* We don't care about the other info provided in the uid: line since no keyserver supports marking userids with timestamps or revoked/expired/disabled yet. */ /* No need to check for control characters, as utf8_to_native does this for us. */ decoded=utf8_to_native(userid,i,0); if(strlen(decoded)>opt.screen_columns-10) decoded[opt.screen_columns-10]='\0'; iobuf_writestr(work->uidbuf,decoded); xfree(decoded); iobuf_writestr(work->uidbuf,"\n\t"); work->lines++; } /* Ignore any records other than "pri" and "uid" for easy future growth. */ return ret; }
/* Search for keys on the keyservers. The patterns are given in the string list TOKENS. */ gpg_error_t keyserver_search (ctrl_t ctrl, strlist_t tokens) { gpg_error_t err; char *searchstr; struct search_line_handler_parm_s parm; memset (&parm, 0, sizeof parm); if (!tokens) return 0; /* Return success if no patterns are given. */ if (!opt.keyserver) { log_error (_("no keyserver known (use option --keyserver)\n")); return gpg_error (GPG_ERR_NO_KEYSERVER); } /* Write global options */ /* for(temp=opt.keyserver_options.other;temp;temp=temp->next) */ /* fprintf(spawn->tochild,"OPTION %s\n",temp->d); */ /* Write per-keyserver options */ /* for(temp=keyserver->options;temp;temp=temp->next) */ /* fprintf(spawn->tochild,"OPTION %s\n",temp->d); */ { membuf_t mb; strlist_t item; init_membuf (&mb, 1024); for (item = tokens; item; item = item->next) { if (item != tokens) put_membuf (&mb, " ", 1); put_membuf_str (&mb, item->d); } put_membuf (&mb, "", 1); /* Append Nul. */ searchstr = get_membuf (&mb, NULL); if (!searchstr) { err = gpg_error_from_syserror (); goto leave; } } /* FIXME: Enable the next line */ /* log_info (_("searching for \"%s\" from %s\n"), searchstr, keyserver->uri); */ parm.ctrl = ctrl; if (searchstr) parm.searchstr_disp = utf8_to_native (searchstr, strlen (searchstr), 0); err = gpg_dirmngr_ks_search (ctrl, searchstr, search_line_handler, &parm); if (parm.not_found) { if (parm.searchstr_disp) log_info (_("key \"%s\" not found on keyserver\n"), parm.searchstr_disp); else log_info (_("key not found on keyserver\n")); } if (gpg_err_code (err) == GPG_ERR_NO_KEYSERVER) log_error (_("no keyserver known (use option --keyserver)\n")); else if (err) log_error ("error searching keyserver: %s\n", gpg_strerror (err)); /* switch(ret) */ /* { */ /* case KEYSERVER_SCHEME_NOT_FOUND: */ /* log_error(_("no handler for keyserver scheme '%s'\n"), */ /* opt.keyserver->scheme); */ /* break; */ /* case KEYSERVER_NOT_SUPPORTED: */ /* log_error(_("action '%s' not supported with keyserver " */ /* "scheme '%s'\n"), "search", opt.keyserver->scheme); */ /* break; */ /* case KEYSERVER_TIMEOUT: */ /* log_error(_("keyserver timed out\n")); */ /* break; */ /* case KEYSERVER_INTERNAL_ERROR: */ /* default: */ /* log_error(_("keyserver internal error\n")); */ /* break; */ /* } */ /* return gpg_error (GPG_ERR_KEYSERVER); */ leave: xfree (parm.desc); xfree (parm.searchstr_disp); xfree(searchstr); return err; }