liAction *li_plugin_config_action(liServer *srv, liWorker *wrk, const gchar *name, liValue *val) {
liAction *a = NULL;
liServerAction *sa;
liServerOption *sopt;
liServerOptionPtr *soptptr;
if (NULL != (sa = (liServerAction*) g_hash_table_lookup(srv->actions, name))) {
if (NULL == (a = sa->create_action(srv, wrk, sa->p, val, sa->userdata))) {
ERROR(srv, "Action '%s' creation failed", name);
}
} else if (NULL != (sopt = find_option(srv, name))) {
liOptionSet setting;
if (!li_parse_option(srv, wrk, sopt, name, option_value(val), &setting)) goto exit;
a = li_action_new_setting(setting);
} else if (NULL != (soptptr = find_optionptr(srv, name))) {
liOptionPtrSet setting;
if (!li_parse_optionptr(srv, wrk, soptptr, name, option_value(val), &setting)) goto exit;
a = li_action_new_settingptr(setting);
} else if (NULL != g_hash_table_lookup(srv->setups, name)) {
ERROR(srv, "'%s' can only be called in a setup block", name);
} else {
ERROR(srv, "unknown action %s", name);
}
exit:
li_value_free(val);
return a;
}
gboolean li_plugin_config_setup(liServer *srv, const char *name, liValue *val) {
gboolean result = FALSE;
liServerSetup *ss;
liServerOption *sopt;
liServerOptionPtr *soptptr;
if (NULL != (ss = (liServerSetup*) g_hash_table_lookup(srv->setups, name))) {
if (!ss->setup(srv, ss->p, val, ss->userdata)) {
ERROR(srv, "Setup '%s' failed", name);
goto exit;
}
result = TRUE;
} else if (NULL != (sopt = find_option(srv, name))) {
liOptionSet setting;
if (!li_parse_option(srv, srv->main_worker, sopt, name, option_value(val), &setting)) goto exit;
g_array_index(srv->option_def_values, liOptionValue, sopt->index) = setting.value;
result = TRUE;
} else if (NULL != (soptptr = find_optionptr(srv, name))) {
liOptionPtrSet setting;
if (!li_parse_optionptr(srv, srv->main_worker, soptptr, name, option_value(val), &setting)) goto exit;
li_release_optionptr(srv, g_array_index(srv->optionptr_def_values, liOptionPtrValue*, soptptr->index));
g_array_index(srv->optionptr_def_values, liOptionPtrValue*, soptptr->index) = setting.value;
result = TRUE;
} else if (NULL != g_hash_table_lookup(srv->setups, name)) {
void option_target::assign(const std::string& value) {
if (this->empty()) {
throw option_parse_error{error_type::futile_value, value};
}
auto& r = (*this->result)[this->name];
switch (this->container) {
case json::content_type::null: {
r = option_value(this->element, value);
this->clear();
break;
}
case json::content_type::array: {
r.as_array().emplace_back(option_value(this->element, value));
break;
}
case json::content_type::object: {
auto p = value.find('=');
if (p == std::string::npos) {
throw option_parse_error{error_type::not_kv, value};
}
auto v = option_value(this->element, value.substr(p + 1));
r.as_object().emplace(
std::make_pair(value.substr(0, p), std::move(v))
);
break;
}
default: {
throw this->container;
}
}
this->assigned = true;
}
static void TB_rank_root_moves(Pos *pos, RootMoves *rm)
{
TB_RootInTB = 0;
TB_UseRule50 = option_value(OPT_SYZ_50_MOVE);
TB_ProbeDepth = option_value(OPT_SYZ_PROBE_DEPTH) * ONE_PLY;
TB_Cardinality = option_value(OPT_SYZ_PROBE_LIMIT);
int dtz_available = 1, dtm_available = 0;
if (TB_Cardinality > TB_MaxCardinality) {
TB_Cardinality = TB_MaxCardinality;
TB_ProbeDepth = DEPTH_ZERO;
}
TB_CardinalityDTM = option_value(OPT_SYZ_USE_DTM)
? min(TB_Cardinality, TB_MaxCardinalityDTM)
: 0;
if (TB_Cardinality >= popcount(pieces()) && !can_castle_any()) {
// Try to rank moves using DTZ tables.
TB_RootInTB = TB_root_probe_dtz(pos, rm);
if (!TB_RootInTB) {
// DTZ tables are missing.
dtz_available = 0;
// Try to rank moves using WDL tables as fallback.
TB_RootInTB = TB_root_probe_wdl(pos, rm);
}
// If ranking was successful, try to obtain mate values from DTM tables.
if (TB_RootInTB && TB_CardinalityDTM >= popcount(pieces()))
dtm_available = TB_root_probe_dtm(pos, rm);
}
if (TB_RootInTB) { // Ranking was successful.
// Sort moves according to TB rank.
stable_sort(rm->move, rm->size);
// Only probe during search if DTM and DTZ are not available
// and we are winning.
if (dtm_available || dtz_available || rm->move[0].tbRank <= 0)
TB_Cardinality = 0;
}
else // Ranking was not successful.
for (int i = 0; i < rm->size; i++)
rm->move[i].tbRank = 0;
}
static void uci_print_pv(Pos *pos, Depth depth, Value alpha, Value beta)
{
TimePoint elapsed = time_elapsed() + 1;
RootMoves *rm = pos->rootMoves;
int pvIdx = pos->pvIdx;
int multiPV = min(option_value(OPT_MULTI_PV), rm->size);
uint64_t nodes_searched = threads_nodes_searched();
uint64_t tbhits = threads_tb_hits();
char buf[16];
flockfile(stdout);
for (int i = 0; i < multiPV; i++) {
int updated = (i <= pvIdx && rm->move[i].score != -VALUE_INFINITE);
if (depth == ONE_PLY && !updated)
continue;
Depth d = updated ? depth : depth - ONE_PLY;
Value v = updated ? rm->move[i].score : rm->move[i].previousScore;
int tb = TB_RootInTB && abs(v) < VALUE_MATE - MAX_MATE_PLY;
if (tb)
v = rm->move[i].tbScore;
// An incomplete mate PV may be caused by cutoffs in qsearch() and
// by TB cutoffs. We try to complete the mate PV if we may be in the
// latter case.
if ( abs(v) > VALUE_MATE - MAX_MATE_PLY
&& rm->move[i].pvSize < VALUE_MATE - abs(v)
&& TB_MaxCardinalityDTM > 0)
TB_expand_mate(pos, &rm->move[i]);
printf("info depth %d seldepth %d multipv %d score %s",
d / ONE_PLY, rm->move[i].selDepth, i + 1,
uci_value(buf, v));
if (!tb && i == pvIdx)
printf("%s", v >= beta ? " lowerbound" : v <= alpha ? " upperbound" : "");
printf(" nodes %"PRIu64" nps %"PRIu64, nodes_searched,
nodes_searched * 1000 / elapsed);
if (elapsed > 1000)
printf(" hashfull %d", tt_hashfull());
printf(" tbhits %"PRIu64" time %"PRIi64" pv", tbhits, elapsed);
for (int idx = 0; idx < rm->move[i].pvSize; idx++)
printf(" %s", uci_move(buf, rm->move[i].pv[idx], is_chess960()));
printf("\n");
}
fflush(stdout);
funlockfile(stdout);
}
// removed from libzmq3
SEXP set_mcast_loop(SEXP socket_, SEXP option_value_) {
zmq::socket_t* socket = reinterpret_cast<zmq::socket_t*>(checkExternalPointer(socket_,"zmq::socket_t*"));
if(!socket) { REprintf("bad socket object.\n");return R_NilValue; }
if(TYPEOF(option_value_)!=LGLSXP) { REprintf("option value must be a logical.\n");return R_NilValue; }
SEXP ans; PROTECT(ans = allocVector(LGLSXP,1)); LOGICAL(ans)[0] = 1;
int64_t option_value(LOGICAL(option_value_)[0]);
try {
socket->setsockopt(ZMQ_MCAST_LOOP, &option_value, sizeof(int64_t));
} catch(std::exception& e) {
REprintf("%s\n",e.what());
LOGICAL(ans)[0] = 0;
}
UNPROTECT(1);
return ans;
}
// removed from libzmq3
SEXP set_recovery_ivl_msec(SEXP socket_, SEXP option_value_) {
zmq::socket_t* socket = reinterpret_cast<zmq::socket_t*>(checkExternalPointer(socket_,"zmq::socket_t*"));
if(!socket) { REprintf("bad socket object.\n");return R_NilValue; }
if(TYPEOF(option_value_)!=INTSXP) { REprintf("option value must be an int.\n");return R_NilValue; }
SEXP ans; PROTECT(ans = allocVector(LGLSXP,1)); LOGICAL(ans)[0] = 1;
int64_t option_value(INTEGER(option_value_)[0]);
try {
socket->setsockopt(ZMQ_RECOVERY_IVL_MSEC, &option_value, sizeof(int64_t));
} catch(std::exception& e) {
REprintf("%s\n",e.what());
LOGICAL(ans)[0] = 0;
}
UNPROTECT(1);
return ans;
}
void SetOptionsFromStreamNode::set_options( const OptionsFromStream& options )
{
OptionsFromStream::options_group_t optgrp = options.options_group( name_map_.name() );
if( !OptionsFromStream::options_group_exists( optgrp ) ) {
TEST_FOR_EXCEPTION(
!exists_optional_, std::invalid_argument
,"SetOptionsFromStreamNode::set_options(...) : "
<< "Error, The options group " << name_map_.name()
<< " does not exist" );
if(exists_optional_)
return;
}
OptionsFromStream::options_group_t::const_iterator itr = optgrp.begin();
for( ; itr != optgrp.end(); ++itr ) {
setOption( name_map_( option_name(itr) ), option_value(itr).c_str() );
}
}
int main(void) {
volatile int i;
// stop watchdog timer or the the mcu will keep resetting.
WDTCTL = WDTPW | WDTHOLD;
// Set P1.0 and P1.6 as Output pins and make sure they
// start out set low.
P1DIR = 0x41;
P1OUT = 0x00;
// Blink on and off periodically.
for (;;) {
P1OUT |= option_value("RED");
for (i = 0; i < 0x6000; i++);
P1OUT &= ~option_value("GREEN");
for (i = 0; i < 0x6000; i++);
}
}
int main(void) {
volatile int i;
// stop watchdog timer
WDTCTL = WDTPW | WDTHOLD;
// set up bit 0 and 6 of P1 as output
P1DIR = 0x41;
// intialize P1 to 0
P1OUT = 0x00;
// loop forever
for (;;) {
P1OUT |= option_value("GREEN");
// delay for a while
for (i = 0; i < 0x6000; i++);
P1OUT &= ~option_value("GREEN");
for (i = 0; i < 0x6000; i++);
}
}
void thread_search(Pos *pos)
{
Value bestValue, alpha, beta, delta;
Move pv[MAX_PLY + 1];
Move lastBestMove = 0;
Depth lastBestMoveDepth = DEPTH_ZERO;
double timeReduction = 1.0;
Stack *ss = pos->st; // At least the seventh element of the allocated array.
for (int i = -7; i < 3; i++)
memset(SStackBegin(ss[i]), 0, SStackSize);
(ss-1)->endMoves = pos->moveList;
for (int i = -7; i < 0; i++)
ss[i].history = &(*pos->counterMoveHistory)[0][0]; // Use as sentinel
for (int i = 0; i <= MAX_PLY; i++)
ss[i].ply = i;
ss->pv = pv;
bestValue = delta = alpha = -VALUE_INFINITE;
beta = VALUE_INFINITE;
pos->completedDepth = DEPTH_ZERO;
if (pos->threadIdx == 0)
mainThread.bestMoveChanges = 0;
int multiPV = option_value(OPT_MULTI_PV);
#if 0
Skill skill(option_value(OPT_SKILL_LEVEL));
// When playing with strength handicap enable MultiPV search that we will
// use behind the scenes to retrieve a set of possible moves.
if (skill.enabled())
multiPV = std::max(multiPV, (size_t)4);
#endif
RootMoves *rm = pos->rootMoves;
multiPV = min(multiPV, rm->size);
// Iterative deepening loop until requested to stop or the target depth
// is reached.
while ( (pos->rootDepth += ONE_PLY) < DEPTH_MAX
&& !Signals.stop
&& !( Limits.depth
&& pos->threadIdx == 0
&& pos->rootDepth / ONE_PLY > Limits.depth))
{
// Age out PV variability metric
if (pos->threadIdx == 0)
mainThread.bestMoveChanges *= 0.517;
// Save the last iteration's scores before first PV line is searched and
// all the move scores except the (new) PV are set to -VALUE_INFINITE.
for (int idx = 0; idx < rm->size; idx++)
rm->move[idx].previousScore = rm->move[idx].score;
pos->contempt = pos_stm() == WHITE ? make_score(base_ct, base_ct / 2)
: -make_score(base_ct, base_ct / 2);
int pvFirst = 0, pvLast = 0;
// MultiPV loop. We perform a full root search for each PV line
for (int pvIdx = 0; pvIdx < multiPV && !Signals.stop; pvIdx++) {
pos->pvIdx = pvIdx;
if (pvIdx == pvLast) {
pvFirst = pvLast;
for (pvLast++; pvLast < rm->size; pvLast++)
if (rm->move[pvLast].tbRank != rm->move[pvFirst].tbRank)
break;
pos->pvLast = pvLast;
}
pos->selDepth = 0;
// Skip the search if we have a mate value from DTM tables.
if (abs(rm->move[pvIdx].tbRank) > 1000) {
bestValue = rm->move[pvIdx].score = rm->move[pvIdx].tbScore;
alpha = -VALUE_INFINITE;
beta = VALUE_INFINITE;
goto skip_search;
}
// Reset aspiration window starting size
if (pos->rootDepth >= 5 * ONE_PLY) {
Value previousScore = rm->move[pvIdx].previousScore;
delta = 20;
alpha = max(previousScore - delta, -VALUE_INFINITE);
beta = min(previousScore + delta, VALUE_INFINITE);
// Adjust contempt based on root move's previousScore
int ct = base_ct + 88 * previousScore / (abs(previousScore) + 200);
pos->contempt = pos_stm() == WHITE ? make_score(ct, ct / 2)
: -make_score(ct, ct / 2);
}
// Start with a small aspiration window and, in the case of a fail
// high/low, re-search with a bigger window until we're not failing
// high/low anymore.
int failedHighCnt = 0;
while (true) {
Depth adjustedDepth = max(ONE_PLY, pos->rootDepth - failedHighCnt * ONE_PLY);
bestValue = search_PV(pos, ss, alpha, beta, adjustedDepth);
// Bring the best move to the front. It is critical that sorting
// is done with a stable algorithm because all the values but the
// first and eventually the new best one are set to -VALUE_INFINITE
// and we want to keep the same order for all the moves except the
// new PV that goes to the front. Note that in case of MultiPV
// search the already searched PV lines are preserved.
stable_sort(&rm->move[pvIdx], pvLast - pvIdx);
// If search has been stopped, we break immediately. Sorting and
// writing PV back to TT is safe because RootMoves is still
// valid, although it refers to the previous iteration.
if (Signals.stop)
break;
// When failing high/low give some update (without cluttering
// the UI) before a re-search.
if ( pos->threadIdx == 0
&& multiPV == 1
&& (bestValue <= alpha || bestValue >= beta)
&& time_elapsed() > 3000)
uci_print_pv(pos, pos->rootDepth, alpha, beta);
// In case of failing low/high increase aspiration window and
// re-search, otherwise exit the loop.
if (bestValue <= alpha) {
beta = (alpha + beta) / 2;
alpha = max(bestValue - delta, -VALUE_INFINITE);
if (pos->threadIdx == 0) {
failedHighCnt = 0;
Signals.stopOnPonderhit = 0;
}
} else if (bestValue >= beta) {
beta = min(bestValue + delta, VALUE_INFINITE);
if (pos->threadIdx == 0)
failedHighCnt++;
} else
break;
delta += delta / 4 + 5;
assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
}
// Sort the PV lines searched so far and update the GUI
stable_sort(&rm->move[pvFirst], pvIdx - pvFirst + 1);
skip_search:
if ( pos->threadIdx == 0
&& (Signals.stop || pvIdx + 1 == multiPV || time_elapsed() > 3000))
uci_print_pv(pos, pos->rootDepth, alpha, beta);
}
if (!Signals.stop)
pos->completedDepth = pos->rootDepth;
if (rm->move[0].pv[0] != lastBestMove) {
lastBestMove = rm->move[0].pv[0];
lastBestMoveDepth = pos->rootDepth;
}
// Have we found a "mate in x"?
if ( Limits.mate
&& bestValue >= VALUE_MATE_IN_MAX_PLY
&& VALUE_MATE - bestValue <= 2 * Limits.mate)
Signals.stop = 1;
if (pos->threadIdx != 0)
continue;
#if 0
// If skill level is enabled and time is up, pick a sub-optimal best move
if (skill.enabled() && skill.time_to_pick(thread->rootDepth))
skill.pick_best(multiPV);
#endif
// Do we have time for the next iteration? Can we stop searching now?
if ( use_time_management()
&& !Signals.stop
&& !Signals.stopOnPonderhit) {
// Stop the search if only one legal move is available, or if all
// of the available time has been used.
double fallingEval = (306 + 9 * (mainThread.previousScore - bestValue)) / 581.0;
fallingEval = max(0.5, min(1.5, fallingEval));
// If the best move is stable over several iterations, reduce time
// accordingly
timeReduction = lastBestMoveDepth + 10 * ONE_PLY < pos->completedDepth
? 1.95 : 1.0;
double reduction = pow(mainThread.previousTimeReduction, 0.528) / timeReduction;
// Use part of the gained time from a previous stable move for this move
double bestMoveInstability = 1.0 + mainThread.bestMoveChanges;
if ( rm->size == 1
|| time_elapsed() > time_optimum() * fallingEval * reduction * bestMoveInstability)
{
// If we are allowed to ponder do not stop the search now but
// keep pondering until the GUI sends "ponderhit" or "stop".
if (Limits.ponder)
Signals.stopOnPonderhit = 1;
else
Signals.stop = 1;
}
}
}
if (pos->threadIdx != 0)
return;
mainThread.previousTimeReduction = timeReduction;
#if 0
// If skill level is enabled, swap best PV line with the sub-optimal one
if (skill.enabled())
std::swap(rm[0], *std::find(rm.begin(),
rm.end(), skill.best_move(multiPV)));
#endif
}
void mainthread_search(void)
{
Pos *pos = Threads.pos[0];
int us = pos_stm();
time_init(us, pos_game_ply());
tt_new_search();
char buf[16];
bool playBookMove = false;
base_ct = option_value(OPT_CONTEMPT) * PawnValueEg / 100;
const char *s = option_string_value(OPT_ANALYSIS_CONTEMPT);
if (Limits.infinite || option_value(OPT_ANALYSE_MODE))
base_ct = strcmp(s, "off") == 0 ? 0
: strcmp(s, "white") == 0 && us == BLACK ? -base_ct
: strcmp(s, "black") == 0 && us == WHITE ? -base_ct
: base_ct;
if (pos->rootMoves->size > 0) {
Move bookMove = 0;
if (!Limits.infinite && !Limits.mate)
bookMove = pb_probe(pos);
for (int i = 0; i < pos->rootMoves->size; i++)
if (pos->rootMoves->move[i].pv[0] == bookMove) {
RootMove tmp = pos->rootMoves->move[0];
pos->rootMoves->move[0] = pos->rootMoves->move[i];
pos->rootMoves->move[i] = tmp;
playBookMove = true;
break;
}
if (!playBookMove) {
for (int idx = 1; idx < Threads.numThreads; idx++)
thread_wake_up(Threads.pos[idx], THREAD_SEARCH);
thread_search(pos); // Let's start searching!
}
}
// When we reach the maximum depth, we can arrive here without a raise
// of Signals.stop. However, if we are pondering or in an infinite
// search, the UCI protocol states that we shouldn't print the best
// move before the GUI sends a "stop" or "ponderhit" command. We
// therefore simply wait here until the GUI sends one of those commands
// (which also raises Signals.stop).
LOCK(Signals.lock);
if (!Signals.stop && (Limits.ponder || Limits.infinite)) {
Signals.sleeping = 1;
UNLOCK(Signals.lock);
thread_wait(pos, &Signals.stop);
} else
UNLOCK(Signals.lock);
// Stop the threads if not already stopped
Signals.stop = 1;
// Wait until all threads have finished
if (pos->rootMoves->size > 0) {
if (!playBookMove) {
for (int idx = 1; idx < Threads.numThreads; idx++)
thread_wait_until_sleeping(Threads.pos[idx]);
}
} else {
pos->rootMoves->move[0].pv[0] = 0;
pos->rootMoves->move[0].pvSize = 1;
pos->rootMoves->size++;
printf("info depth 0 score %s\n",
uci_value(buf, pos_checkers() ? -VALUE_MATE : VALUE_DRAW));
fflush(stdout);
}
// When playing in 'nodes as time' mode, subtract the searched nodes from
// the available ones before exiting.
if (Limits.npmsec)
Time.availableNodes += Limits.inc[us] - threads_nodes_searched();
// Check if there are threads with a better score than main thread
Pos *bestThread = pos;
if ( option_value(OPT_MULTI_PV) == 1
&& !playBookMove
&& !Limits.depth
// && !Skill(option_value(OPT_SKILL_LEVEL)).enabled()
&& pos->rootMoves->move[0].pv[0] != 0)
{
int i, num = 0, maxNum = min(pos->rootMoves->size, Threads.numThreads);
Move mvs[maxNum];
int64_t votes[maxNum];
Value minScore = pos->rootMoves->move[0].score;
for (int idx = 1; idx < Threads.numThreads; idx++)
minScore = min(minScore, Threads.pos[idx]->rootMoves->move[0].score);
for (int idx = 0; idx < Threads.numThreads; idx++) {
Pos *p = Threads.pos[idx];
Move m = p->rootMoves->move[0].pv[0];
for (i = 0; i < num; i++)
if (mvs[i] == m) break;
if (i == num) {
num++;
mvs[i] = m;
votes[i] = 0;
}
int64_t diff = p->rootMoves->move[0].score - minScore + 1;
votes[i] += 200 + (diff * diff) * p->completedDepth;
}
int64_t bestVote = votes[0];
for (int idx = 1; idx < Threads.numThreads; idx++) {
Pos *p = Threads.pos[idx];
for (i = 0; mvs[i] != p->rootMoves->move[0].pv[0]; i++);
if (votes[i] > bestVote) {
bestVote = votes[i];
bestThread = p;
}
}
}
mainThread.previousScore = bestThread->rootMoves->move[0].score;
// Send new PV when needed
if (bestThread != pos)
uci_print_pv(bestThread, bestThread->completedDepth,
-VALUE_INFINITE, VALUE_INFINITE);
flockfile(stdout);
printf("bestmove %s", uci_move(buf, bestThread->rootMoves->move[0].pv[0], is_chess960()));
if (bestThread->rootMoves->move[0].pvSize > 1 || extract_ponder_from_tt(&bestThread->rootMoves->move[0], pos))
printf(" ponder %s", uci_move(buf, bestThread->rootMoves->move[0].pv[1], is_chess960()));
printf("\n");
fflush(stdout);
funlockfile(stdout);
}
/**
* parse_options
*/
static void parse_options(int argc, char *argv[])
{
long long ll;
char *s, *s2;
int c;
opt_alloc_len = 0;
opt_alloc_offs = 0;
if (argc && *argv)
EXEC_NAME = *argv;
fprintf(stderr, "%s v%s (libntfs-3g)\n", EXEC_NAME, VERSION);
while ((c = getopt_long(argc, argv, "fh?no:qvVl:", lopt, NULL)) != EOF) {
switch (c) {
case 'f':
opts.force = 1;
break;
case 'n':
opts.no_size_change = 1;
break;
case 'N': /* Not proposed as a short option */
opts.no_action = 1;
break;
case 'q':
opts.quiet = 1;
ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
break;
case 'v':
opts.verbose++;
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
break;
case 'V':
/* Version number already printed */
license();
exit(0);
case 'l':
ll = option_value(argv[optind - 1]);
if ((ll <= 0)
|| (ll >= LLONG_MAX && errno == ERANGE))
err_usage("Invalid length : %s\n",
argv[optind - 1]);
opt_alloc_len = ll;
break;
case 'o':
ll = option_value(argv[optind - 1]);
if ((ll < 0)
|| (ll >= LLONG_MAX && errno == ERANGE))
err_usage("Invalid offset : %s\n",
argv[optind - 1]);
opt_alloc_offs = ll;
break;
case 'h':
usage(0);
case '?':
default:
usage(1);
}
}
if (!opt_alloc_len) {
err_usage("Missing allocation length\n");
}
ntfs_log_verbose("length = %lli = 0x%llx\n",
(long long)opt_alloc_len, (long long)opt_alloc_len);
ntfs_log_verbose("offset = %lli = 0x%llx\n",
(long long)opt_alloc_offs, (long long)opt_alloc_offs);
if (optind == argc)
usage(1);
if (opts.verbose > 1)
ntfs_log_set_levels(NTFS_LOG_LEVEL_DEBUG | NTFS_LOG_LEVEL_TRACE |
NTFS_LOG_LEVEL_VERBOSE | NTFS_LOG_LEVEL_QUIET);
/* Get the device. */
dev_name = argv[optind++];
ntfs_log_verbose("device name = %s\n", dev_name);
if (optind == argc)
usage(1);
/* Get the file name. */
file_name = argv[optind++];
ntfs_log_verbose("file name = \"%s\"\n", file_name);
/* Get the attribute type, if specified. */
if (optind == argc) {
attr_type = AT_DATA;
attr_name = AT_UNNAMED;
attr_name_len = 0;
} else {
unsigned long ul;
s = argv[optind++];
ul = strtoul(s, &s2, 0);
if (*s2 || !ul || (ul >= ULONG_MAX && errno == ERANGE))
err_usage("Invalid attribute type %s: %s\n", s,
strerror(errno));
attr_type = cpu_to_le32(ul);
/* Get the attribute name, if specified. */
if (optind != argc) {
s = argv[optind++];
/* Convert the string to little endian Unicode. */
attr_name_len = ntfs_mbstoucs(s, &attr_name);
if ((int)attr_name_len < 0)
err_usage("Invalid attribute name "
"\"%s\": %s\n",
s, strerror(errno));
/* Keep hold of the original string. */
s2 = s;
s = argv[optind++];
if (optind != argc)
usage(1);
} else {
attr_name = AT_UNNAMED;
attr_name_len = 0;
}
}
ntfs_log_verbose("attribute type = 0x%lx\n",
(unsigned long)le32_to_cpu(attr_type));
if (attr_name == AT_UNNAMED)
ntfs_log_verbose("attribute name = \"\" (UNNAMED)\n");
else
ntfs_log_verbose("attribute name = \"%s\" (length %u "
"Unicode characters)\n", s2,
(unsigned int)attr_name_len);
}
void Kernel::collectExtraOptions()
{
for (const auto& o : m_extra_options)
{
typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
// if we don't have --, we're not an option we
// even care about
if (!boost::algorithm::find_first(o, "--")) continue;
// Find the dimensions listed and put them on the id list.
boost::char_separator<char> equal("=");
boost::char_separator<char> dot(".");
// boost::erase_all(o, " "); // Wipe off spaces
tokenizer option_tokens(o, equal);
std::vector<std::string> option_split;
for (auto ti = option_tokens.begin(); ti != option_tokens.end(); ++ti)
option_split.push_back(boost::lexical_cast<std::string>(*ti));
if (!(option_split.size() == 2))
{
std::ostringstream oss;
oss << "option '" << o << "' did not split correctly. Is it in the form --readers.las.option=foo?";
throw app_usage_error(oss.str());
}
std::string option_value(option_split[1]);
std::string stage_value(option_split[0]);
boost::algorithm::erase_all(stage_value, "--");
tokenizer name_tokens(stage_value, dot);
std::vector<std::string> stage_values;
for (auto ti = name_tokens.begin(); ti != name_tokens.end(); ++ti)
{
stage_values.push_back(*ti);
}
std::string option_name = *stage_values.rbegin();
std::ostringstream stage_name_ostr;
bool bFirst(true);
for (auto s = stage_values.begin(); s != stage_values.end()-1; ++s)
{
auto s2 = boost::algorithm::erase_all_copy(*s, " ");
if (bFirst)
{
bFirst = false;
}
else
stage_name_ostr <<".";
stage_name_ostr << s2;
}
std::string stage_name(stage_name_ostr.str());
auto found = m_extra_stage_options.find(stage_name);
if (found == m_extra_stage_options.end())
m_extra_stage_options.insert(std::make_pair(stage_name, Option(option_name, option_value, "")));
else
found->second.add(Option(option_name, option_value, ""));
}
}
int
main (int argc, char **argv)
{
char *args;
char *logfile;
char *passphrasefile;
char *passphrase;
/* We get our options via PINENTRY_USER_DATA. */
(void) argc, (void) argv;
setvbuf (stdin, NULL, _IOLBF, BUFSIZ);
setvbuf (stdout, NULL, _IOLBF, BUFSIZ);
args = getenv ("PINENTRY_USER_DATA");
if (! args)
args = "";
logfile = option_value (args, "--logfile");
if (logfile)
{
char *p = logfile, more;
while (*p && ! spacep (p))
p++;
more = !! *p;
*p = 0;
args = more ? p+1 : p;
log_stream = fopen (logfile, "a");
if (! log_stream)
{
perror (logfile);
return 1;
}
}
passphrasefile = option_value (args, "--passphrasefile");
if (passphrasefile)
{
char *p = passphrasefile, more;
while (*p && ! spacep (p))
p++;
more = !! *p;
*p = 0;
args = more ? p+1 : p;
passphrase = get_passphrase (passphrasefile);
if (! passphrase)
{
reply ("# Passphrasefile '%s' is empty. Terminating.\n",
passphrasefile);
return 1;
}
p = passphrase + strlen (passphrase) - 1;
if (*p == '\n')
*p = 0;
}
else
passphrase = skip_options (args);
reply ("# fake-pinentry started. Passphrase='%s'.\n", passphrase);
reply ("OK - what's up?\n");
while (! feof (stdin))
{
char buffer[1024];
if (fgets (buffer, sizeof buffer, stdin) == NULL)
break;
if (log_stream)
fprintf (log_stream, "< %s", buffer);
if (strncmp (buffer, "GETPIN", 6) == 0)
reply ("D %s\n", passphrase);
else if (strncmp (buffer, "BYE", 3) == 0)
{
reply ("OK\n");
break;
}
reply ("OK\n");
}
reply ("# Connection terminated.\n");
if (log_stream)
fclose (log_stream);
return 0;
}