void subtract(int a, int b) {
notify(Subtract(a, b));
}
void Qt5String::stringChanged(QString text) {
notify(text.toStdString());
}
void Scrollable::allocate(Canvas* c, const Allocation& a, Extension& ext) {
Patch::allocate(c, a, ext);
notify(Dimension_X);
notify(Dimension_Y);
}
void
process_command(int descr, dbref player, char *command)
{
char *arg1;
char *arg2;
char *full_command;
char *p; /* utility */
char pbuf[BUFFER_LEN];
char xbuf[BUFFER_LEN];
char ybuf[BUFFER_LEN];
struct timeval starttime;
struct timeval endtime;
double totaltime;
if (command == 0)
abort();
/* robustify player */
if (player < 0 || player >= db_top ||
(Typeof(player) != TYPE_PLAYER && Typeof(player) != TYPE_THING)) {
log_status("process_command: bad player %d", player);
return;
}
if ((tp_log_commands || Wizard(OWNER(player)))) {
if (!(FLAGS(player) & (INTERACTIVE | READMODE))) {
if (!*command) {
return;
}
log_command("%s%s%s%s(%d) in %s(%d):%s %s",
Wizard(OWNER(player)) ? "WIZ: " : "",
(Typeof(player) != TYPE_PLAYER) ? NAME(player) : "",
(Typeof(player) != TYPE_PLAYER) ? " owned by " : "",
NAME(OWNER(player)), (int) player,
NAME(DBFETCH(player)->location),
(int) DBFETCH(player)->location, " ", command);
} else {
if (tp_log_interactive) {
log_command("%s%s%s%s(%d) in %s(%d):%s %s",
Wizard(OWNER(player)) ? "WIZ: " : "",
(Typeof(player) != TYPE_PLAYER) ? NAME(player) : "",
(Typeof(player) != TYPE_PLAYER) ? " owned by " : "",
NAME(OWNER(player)), (int) player,
NAME(DBFETCH(player)->location),
(int) DBFETCH(player)->location,
(FLAGS(player) & (READMODE)) ? " [READ] " : " [INTERP] ", command);
}
}
}
if (FLAGS(player) & INTERACTIVE) {
interactive(descr, player, command);
return;
}
/* eat leading whitespace */
while (*command && isspace(*command))
command++;
/* Disable null command once past READ line */
if (!*command)
return;
/* check for single-character commands */
if (!tp_enable_prefix) {
if (*command == SAY_TOKEN) {
snprintf(pbuf, sizeof(pbuf), "say %s", command + 1);
command = &pbuf[0];
} else if (*command == POSE_TOKEN) {
snprintf(pbuf, sizeof(pbuf), "pose %s", command + 1);
command = &pbuf[0];
} else if (*command == EXIT_DELIMITER) {
snprintf(pbuf, sizeof(pbuf), "delimiter %s", command + 1);
command = &pbuf[0];
}
}
/* profile how long command takes. */
gettimeofday(&starttime, NULL);
/* if player is a wizard, and uses overide token to start line... */
/* ... then do NOT run actions, but run the command they specify. */
if (!(TrueWizard(OWNER(player)) && (*command == OVERIDE_TOKEN))) {
if (can_move(descr, player, command, 0)) {
do_move(descr, player, command, 0); /* command is exact match for exit */
*match_args = 0;
*match_cmdname = 0;
} else {
if (tp_enable_prefix) {
if (*command == SAY_TOKEN) {
snprintf(pbuf, sizeof(pbuf), "say %s", command + 1);
command = &pbuf[0];
} else if (*command == POSE_TOKEN) {
snprintf(pbuf, sizeof(pbuf), "pose %s", command + 1);
command = &pbuf[0];
} else if (*command == EXIT_DELIMITER) {
snprintf(pbuf, sizeof(pbuf), "delimiter %s", command + 1);
command = &pbuf[0];
} else {
goto bad_pre_command;
}
if (can_move(descr, player, command, 0)) {
do_move(descr, player, command, 0); /* command is exact match for exit */
*match_args = 0;
*match_cmdname = 0;
} else {
goto bad_pre_command;
}
} else {
goto bad_pre_command;
}
}
} else {
bad_pre_command:
if (TrueWizard(OWNER(player)) && (*command == OVERIDE_TOKEN))
command++;
full_command = strcpyn(xbuf, sizeof(xbuf), command);
for (; *full_command && !isspace(*full_command); full_command++) ;
if (*full_command)
full_command++;
/* find arg1 -- move over command word */
command = strcpyn(ybuf, sizeof(ybuf), command);
for (arg1 = command; *arg1 && !isspace(*arg1); arg1++) ;
/* truncate command */
if (*arg1)
*arg1++ = '\0';
/* remember command for programs */
strcpyn(match_args, sizeof(match_args), full_command);
strcpyn(match_cmdname, sizeof(match_cmdname), command);
/* move over spaces */
while (*arg1 && isspace(*arg1))
arg1++;
/* find end of arg1, start of arg2 */
for (arg2 = arg1; *arg2 && *arg2 != ARG_DELIMITER; arg2++) ;
/* truncate arg1 */
for (p = arg2 - 1; p >= arg1 && isspace(*p); p--)
*p = '\0';
/* go past delimiter if present */
if (*arg2)
*arg2++ = '\0';
while (*arg2 && isspace(*arg2))
arg2++;
switch (command[0]) {
case '@':
switch (command[1]) {
case 'a':
case 'A':
/* @action, @armageddon, @attach */
switch (command[2]) {
case 'c':
case 'C':
Matched("@action");
do_action(descr, player, arg1, arg2);
break;
case 'r':
case 'R':
if (strcmp(command, "@armageddon"))
goto bad;
do_armageddon(player, full_command);
break;
case 't':
case 'T':
Matched("@attach");
do_attach(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'b':
case 'B':
/* @bless, @boot */
switch (command[2]) {
case 'l':
case 'L':
Matched("@bless");
do_bless(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
Matched("@boot");
do_boot(player, arg1);
break;
default:
goto bad;
}
break;
case 'c':
case 'C':
/* @chlock, @chown, @chown_lock, @clone,
@conlock, @contents, @create, @credits */
switch (command[2]) {
case 'h':
case 'H':
switch (command[3]) {
case 'l':
case 'L':
Matched("@chlock");
do_chlock(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
if(strlen(command) < 7) {
Matched("@chown");
do_chown(descr, player, arg1, arg2);
} else {
Matched("@chown_lock");
do_chlock(descr, player, arg1, arg2);
}
break;
default:
goto bad;
}
break;
case 'l':
case 'L':
Matched("@clone");
do_clone(descr, player, arg1);
break;
case 'o':
case 'O':
switch (command[4]) {
case 'l':
case 'L':
Matched("@conlock");
do_conlock(descr, player, arg1, arg2);
break;
case 't':
case 'T':
Matched("@contents");
do_contents(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'r':
case 'R':
if (string_compare(command, "@credits")) {
Matched("@create");
do_create(player, arg1, arg2);
} else {
do_credits(player);
}
break;
default:
goto bad;
}
break;
case 'd':
case 'D':
/* @dbginfo, @delta, @describe, @dig, @dlt,
@doing, @drop, @dump */
switch (command[2]) {
case 'b':
case 'B':
Matched("@dbginfo");
do_serverdebug(descr, player, arg1, arg2);
break;
case 'e':
case 'E':
if(command[3] == 'l' || command[3] == 'L') {
Matched("@delta");
do_delta(player);
} else {
Matched("@describe");
do_describe(descr, player, arg1, arg2);
}
break;
case 'i':
case 'I':
Matched("@dig");
do_dig(descr, player, arg1, arg2);
break;
case 'l':
case 'L':
Matched("@dlt");
do_delta(player);
break;
case 'o':
case 'O':
Matched("@doing");
if (!tp_who_doing)
goto bad;
do_doing(descr, player, arg1, arg2);
break;
case 'r':
case 'R':
Matched("@drop");
do_drop_message(descr, player, arg1, arg2);
break;
case 'u':
case 'U':
Matched("@dump");
do_dump(player, full_command);
break;
default:
goto bad;
}
break;
case 'e':
case 'E':
/* @edit, @entrances, @examine */
switch (command[2]) {
case 'd':
case 'D':
Matched("@edit");
do_edit(descr, player, arg1);
break;
case 'n':
case 'N':
Matched("@entrances");
do_entrances(descr, player, arg1, arg2);
break;
case 'x':
case 'X':
Matched("@examine");
sane_dump_object(player, arg1);
break;
default:
goto bad;
}
break;
case 'f':
case 'F':
/* @fail, @find, @flock, @force, @force_lock */
switch (command[2]) {
case 'a':
case 'A':
Matched("@fail");
do_fail(descr, player, arg1, arg2);
break;
case 'i':
case 'I':
Matched("@find");
do_find(player, arg1, arg2);
break;
case 'l':
case 'L':
Matched("@flock");
do_flock(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
if(strlen(command) < 7) {
Matched("@force");
do_force(descr, player, arg1, arg2);
} else {
Matched("@force_lock");
do_flock(descr, player, arg1, arg2);
}
break;
default:
goto bad;
}
break;
case 'h':
case 'H':
/* @hashes */
Matched("@hashes");
do_hashes(player, arg1);
break;
case 'i':
case 'I':
/* @idescribe */
Matched("@idescribe");
do_idescribe(descr, player, arg1, arg2);
break;
case 'k':
case 'K':
/* @kill */
Matched("@kill");
do_dequeue(descr, player, arg1);
break;
case 'l':
case 'L':
/* @link, @list, @lock */
switch (command[2]) {
case 'i':
case 'I':
switch (command[3]) {
case 'n':
case 'N':
Matched("@link");
do_link(descr, player, arg1, arg2);
break;
case 's':
case 'S':
Matched("@list");
match_and_list(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'o':
case 'O':
Matched("@lock");
do_lock(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'm':
case 'M':
/* @mcpedit, @mcpprogram, @memory, @mpitops,
@muftops */
switch (command[2]) {
case 'c':
case 'C':
if (string_prefix("@mcpedit", command)) {
Matched("@mcpedit");
do_mcpedit(descr, player, arg1);
break;
} else {
Matched("@mcpprogram");
do_mcpprogram(descr, player, arg1);
break;
}
case 'e':
case 'E':
Matched("@memory");
do_memory(player);
break;
case 'p':
case 'P':
Matched("@mpitops");
do_mpi_topprofs(player, arg1);
break;
case 'u':
case 'U':
Matched("@muftops");
do_muf_topprofs(player, arg1);
break;
default:
goto bad;
}
break;
case 'n':
case 'N':
/* @name, @newpassword */
switch (command[2]) {
case 'a':
case 'A':
Matched("@name");
do_name(descr, player, arg1, arg2);
break;
case 'e':
case 'E':
if (strcmp(command, "@newpassword"))
goto bad;
do_newpassword(player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'o':
case 'O':
/* @odrop, @oecho, @ofail, @open, @osuccess,
@owned */
switch (command[2]) {
case 'd':
case 'D':
Matched("@odrop");
do_odrop(descr, player, arg1, arg2);
break;
case 'e':
case 'E':
Matched("@oecho");
do_oecho(descr, player, arg1, arg2);
break;
case 'f':
case 'F':
Matched("@ofail");
do_ofail(descr, player, arg1, arg2);
break;
case 'p':
case 'P':
Matched("@open");
do_open(descr, player, arg1, arg2);
break;
case 's':
case 'S':
Matched("@osuccess");
do_osuccess(descr, player, arg1, arg2);
break;
case 'w':
case 'W':
Matched("@owned");
do_owned(player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'p':
case 'P':
/* @password, @pcreate, @pecho, @program,
@propset, @ps */
switch (command[2]) {
case 'a':
case 'A':
Matched("@password");
do_password(player, arg1, arg2);
break;
case 'c':
case 'C':
Matched("@pcreate");
do_pcreate(player, arg1, arg2);
break;
case 'e':
case 'E':
Matched("@pecho");
do_pecho(descr, player, arg1, arg2);
break;
case 'r':
case 'R':
if (string_prefix("@program", command)) {
Matched("@program");
do_prog(descr, player, arg1);
break;
} else {
Matched("@propset");
do_propset(descr, player, arg1, arg2);
break;
}
case 's':
case 'S':
Matched("@ps");
list_events(player);
break;
default:
goto bad;
}
break;
case 'r':
case 'R':
/* @recycle, @relink, @restart, @restrict */
switch (command[3]) {
case 'c':
case 'C':
Matched("@recycle");
do_recycle(descr, player, arg1);
break;
case 'l':
case 'L':
Matched("@relink");
do_relink(descr, player, arg1, arg2);
break;
case 's':
case 'S':
if (!strcmp(command, "@restart")) {
do_restart(player);
} else if (!strcmp(command, "@restrict")) {
do_restrict(player, arg1);
} else {
goto bad;
}
break;
default:
goto bad;
}
break;
case 's':
case 'S':
/* @sanity, @sanchange, @sanfix, @set,
@shutdown, @stats, @success, @sweep */
switch (command[2]) {
case 'a':
case 'A':
if (!strcmp(command, "@sanity")) {
sanity(player);
} else if (!strcmp(command, "@sanchange")) {
sanechange(player, full_command);
} else if (!strcmp(command, "@sanfix")) {
sanfix(player);
} else {
goto bad;
}
break;
case 'e':
case 'E':
Matched("@set");
do_set(descr, player, arg1, arg2);
break;
case 'h':
case 'H':
if (strcmp(command, "@shutdown"))
goto bad;
do_shutdown(player);
break;
case 't':
case 'T':
Matched("@stats");
do_stats(player, arg1);
break;
case 'u':
case 'U':
Matched("@success");
do_success(descr, player, arg1, arg2);
break;
case 'w':
case 'W':
Matched("@sweep");
do_sweep(descr, player, arg1);
break;
default:
goto bad;
}
break;
case 't':
case 'T':
/* @teleport, @toad, @trace, @tune */
switch (command[2]) {
case 'e':
case 'E':
Matched("@teleport");
do_teleport(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
if (!strcmp(command, "@toad")) {
do_toad(descr, player, arg1, arg2);
} else if (!strcmp(command, "@tops")) {
do_all_topprofs(player, arg1);
} else {
goto bad;
}
break;
case 'r':
case 'R':
Matched("@trace");
do_trace(descr, player, arg1, atoi(arg2));
break;
case 'u':
case 'U':
Matched("@tune");
do_tune(player, arg1, arg2, !!strchr(full_command, ARG_DELIMITER));
break;
default:
goto bad;
}
break;
case 'u':
case 'U':
/* @unbless, @unlink, @unlock, @uncompile,
@usage */
switch (command[2]) {
case 'N':
case 'n':
if (string_prefix(command, "@unb")) {
Matched("@unbless");
do_unbless(descr, player, arg1, arg2);
} else if (string_prefix(command, "@unli")) {
Matched("@unlink");
do_unlink(descr, player, arg1);
} else if (string_prefix(command, "@unlo")) {
Matched("@unlock");
do_unlock(descr, player, arg1);
} else if (string_prefix(command, "@uncom")) {
Matched("@uncompile");
do_uncompile(player);
} else {
goto bad;
}
break;
case 'S':
case 's':
Matched("@usage");
do_usage(player);
break;
default:
goto bad;
break;
}
break;
case 'v':
case 'V':
/* @version */
Matched("@version");
do_version(player);
break;
case 'w':
case 'W':
/* @wall */
if (strcmp(command, "@wall"))
goto bad;
do_wall(player, full_command);
break;
default:
goto bad;
}
break;
case 'd':
case 'D':
/* disembark, drop */
switch (command[1]) {
case 'i':
case 'I':
Matched("disembark");
do_leave(descr, player);
break;
case 'r':
case 'R':
Matched("drop");
do_drop(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'e':
case 'E':
/* examine */
Matched("examine");
do_examine(descr, player, arg1, arg2);
break;
case 'g':
case 'G':
/* get, give, goto, gripe */
switch (command[1]) {
case 'e':
case 'E':
Matched("get");
do_get(descr, player, arg1, arg2);
break;
case 'i':
case 'I':
Matched("give");
do_give(descr, player, arg1, atoi(arg2));
break;
case 'o':
case 'O':
Matched("goto");
do_move(descr, player, arg1, 0);
break;
case 'r':
case 'R':
if (string_compare(command, "gripe"))
goto bad;
do_gripe(player, full_command);
break;
default:
goto bad;
}
break;
case 'h':
case 'H':
/* help */
Matched("help");
do_help(player, arg1, arg2);
break;
case 'i':
case 'I':
/* inventory, info */
if (string_compare(command, "info")) {
Matched("inventory");
do_inventory(player);
} else {
Matched("info");
do_info(player, arg1, arg2);
}
break;
case 'k':
case 'K':
/* kill */
Matched("kill");
do_kill(descr, player, arg1, atoi(arg2));
break;
case 'l':
case 'L':
/* leave, look */
if (string_prefix("look", command)) {
Matched("look");
do_look_at(descr, player, arg1, arg2);
break;
} else {
Matched("leave");
do_leave(descr, player);
break;
}
case 'm':
case 'M':
/* man, motd, move, mpi */
if (string_prefix(command, "move")) {
do_move(descr, player, arg1, 0);
break;
} else if (!string_compare(command, "motd")) {
do_motd(player, full_command);
break;
} else if (!string_compare(command, "mpi")) {
do_mpihelp(player, arg1, arg2);
break;
} else {
if (string_compare(command, "man"))
goto bad;
do_man(player, (!*arg1 && !*arg2 && arg1 != arg2) ? "=" : arg1, arg2);
}
break;
case 'n':
case 'N':
/* news */
Matched("news");
do_news(player, arg1, arg2);
break;
case 'p':
case 'P':
/* page, pose, put */
switch (command[1]) {
case 'a':
case 'A':
Matched("page");
do_page(player, arg1, arg2);
break;
case 'o':
case 'O':
Matched("pose");
do_pose(player, full_command);
break;
case 'u':
case 'U':
Matched("put");
do_drop(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'r':
case 'R':
/* read, rob */
switch (command[1]) {
case 'e':
case 'E':
Matched("read"); /* undocumented alias for look */
do_look_at(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
Matched("rob");
do_rob(descr, player, arg1);
break;
default:
goto bad;
}
break;
case 's':
case 'S':
/* say, score */
switch (command[1]) {
case 'a':
case 'A':
Matched("say");
do_say(player, full_command);
break;
case 'c':
case 'C':
Matched("score");
do_score(player);
break;
default:
goto bad;
}
break;
case 't':
case 'T':
/* take, throw */
switch (command[1]) {
case 'a':
case 'A':
Matched("take");
do_get(descr, player, arg1, arg2);
break;
case 'h':
case 'H':
Matched("throw");
do_drop(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'w':
case 'W':
/* whisper */
Matched("whisper");
do_whisper(descr, player, arg1, arg2);
break;
default:
bad:
if (tp_m3_huh != 0)
{
char hbuf[BUFFER_LEN];
snprintf(hbuf,BUFFER_LEN,"HUH? %s", command);
if(can_move(descr, player, hbuf, 3)) {
do_move(descr, player, hbuf, 3);
*match_args = 0;
*match_cmdname = 0;
break;
}
}
notify(player, tp_huh_mesg);
if (tp_log_failed_commands && !controls(player, DBFETCH(player)->location)) {
log_status("HUH from %s(%d) in %s(%d)[%s]: %s %s",
NAME(player), player, NAME(DBFETCH(player)->location),
DBFETCH(player)->location,
NAME(OWNER(DBFETCH(player)->location)), command, full_command);
}
break;
}
}
/* calculate time command took. */
gettimeofday(&endtime, NULL);
if (starttime.tv_usec > endtime.tv_usec) {
endtime.tv_usec += 1000000;
endtime.tv_sec -= 1;
}
endtime.tv_usec -= starttime.tv_usec;
endtime.tv_sec -= starttime.tv_sec;
totaltime = endtime.tv_sec + (endtime.tv_usec * 1.0e-6);
if (totaltime > (tp_cmd_log_threshold_msec / 1000.0)) {
log2file(LOG_CMD_TIMES, "%6.3fs, %.16s: %s%s%s%s(%d) in %s(%d):%s %s",
totaltime, ctime((time_t *)&starttime.tv_sec),
Wizard(OWNER(player)) ? "WIZ: " : "",
(Typeof(player) != TYPE_PLAYER) ? NAME(player) : "",
(Typeof(player) != TYPE_PLAYER) ? " owned by " : "",
NAME(OWNER(player)), (int) player,
NAME(DBFETCH(player)->location),
(int) DBFETCH(player)->location, " ", command);
}
}
/** Limit an attribute's possible values, using either an enum or a
* regexp /limit.
* \verbatim
* Given a name, restriction type and string for an attribute,
* set its data value to said data and set a flag for limit or
* enum.
*
* For an enum, the attr's data will be set to
* <delim><pattern><delim>, so a simple strstr() can be used when
* matching the pattern.
*
* An optional delimiter can be provided on the left hand side by using
* @attr/enum <delim> <attrname>=<enum list>
* \endverbatim
* \param player the enactor.
* \param name the attribute name.
* \param type AF_RLIMIT for regexp, AF_ENUM for enum.
* \param pattern The allowed pattern for the attribute.
*/
void
do_attribute_limit(dbref player, char *name, int type, char *pattern)
{
ATTR *ap;
char buff[BUFFER_LEN];
char *ptr, *bp;
char delim = ' ';
pcre *re;
const char *errptr;
int erroffset;
int unset = 0;
if (pattern && *pattern) {
if (type == AF_RLIMIT) {
/* Compile to regexp. */
re = pcre_compile(remove_markup(pattern, NULL), PCRE_CASELESS,
&errptr, &erroffset, tables);
if (!re) {
notify(player, T("Invalid Regular Expression."));
return;
}
/* We only care if it's valid, we're not using it. */
pcre_free(re);
/* Copy it to buff to be placed into ap->data. */
snprintf(buff, BUFFER_LEN, "%s", pattern);
} else if (type == AF_ENUM) {
ptr = name;
/* Check for a delimiter: @attr/enum | attrname=foo */
if ((name = strchr(ptr, ' ')) != NULL) {
*(name++) = '\0';
if (strlen(ptr) > 1) {
notify(player, T("Delimiter must be one character."));
return;
}
delim = *ptr;
} else {
name = ptr;
delim = ' ';
}
/* For speed purposes, we require the pattern to begin and end with
* a delimiter. */
snprintf(buff, BUFFER_LEN, "%c%s%c", delim, pattern, delim);
buff[BUFFER_LEN - 1] = '\0';
/* For sanity's sake, we'll enforce a properly delimited enum
* with a quick and dirty squish().
* We already know we start with a delim, hence the +1 =). */
for (ptr = buff + 1, bp = buff + 1; *ptr; ptr++) {
if (!(*ptr == delim && *(ptr - 1) == delim)) {
*(bp++) = *ptr;
}
}
*bp = '\0';
} else {
/* Err, we got called with the wrong limit type? */
notify(player, T("Unknown limit type?"));
return;
}
} else {
unset = 1;
}
/* Parse name and perms */
if (!name || !*name) {
notify(player, T("Which attribute do you mean?"));
return;
}
upcasestr(name);
if (*name == '@')
name++;
/* Is this attribute already in the table? */
ap = (ATTR *) ptab_find_exact(&ptab_attrib, name);
if (!ap) {
notify(player,
T
("I don't know that attribute. Please use @attribute/access to create it, first."));
return;
}
if (AF_Internal(ap)) {
/* Don't muck with internal attributes */
notify(player, T("That attribute's permissions cannot be changed."));
return;
}
/* All's good, set the data and the AF_RLIMIT or AF_ENUM flag. */
if (ap->data != NULL_CHUNK_REFERENCE) {
chunk_delete(ap->data);
}
/* Clear any extant rlimit or enum flags */
ap->flags &= ~(AF_RLIMIT | AF_ENUM);
if (unset) {
if (ap->data != NULL_CHUNK_REFERENCE) {
ap->data = NULL_CHUNK_REFERENCE;
notify_format(player, T("%s -- Attribute limit or enum unset."), name);
} else {
notify_format(player,
T("%s -- Attribute limit or enum already unset."), name);
}
} else {
char *t = compress(buff);
ap->data = chunk_create(t, strlen(t), 0);
free(t);
ap->flags |= type;
notify_format(player,
T("%s -- Attribute %s set to: %s"), name,
type == AF_RLIMIT ? "limit" : "enum", display_attr_limit(ap));
}
}
void ServiceThread::notifyStopped() {
Lock lock(this);
m_stopped = true;
notify();
}
LRESULT TabBarPlus::runProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
{
switch (Message)
{
// Custom window message to change tab control style on the fly
case WM_TABSETSTYLE:
{
LONG_PTR style = ::GetWindowLongPtr(hwnd, GWL_STYLE);
if (wParam > 0)
style |= lParam;
else
style &= ~lParam;
_isVertical = ((style & TCS_VERTICAL) != 0);
_isMultiLine = ((style & TCS_MULTILINE) != 0);
::SetWindowLongPtr(hwnd, GWL_STYLE, style);
::InvalidateRect(hwnd, NULL, TRUE);
return TRUE;
}
case WM_MOUSEWHEEL:
{
// ..............................................................................
// MOUSEWHEEL:
// will scroll the tab bar area (similar to Firefox's tab scrolling),
// it only happens if not in multi-line mode and at least one tab is hidden
// ..............................................................................
// CTRL + MOUSEWHEEL:
// will do previous/next tab WITH scroll wrapping (endless loop)
// ..............................................................................
// SHIFT + MOUSEWHEEL:
// if _doDragNDrop is enabled, then moves the tab, otherwise switches
// to previous/next tab WITHOUT scroll wrapping (stops at first/last tab)
// ..............................................................................
// CTRL + SHIFT + MOUSEWHEEL:
// will switch to the first/last tab
// ..............................................................................
if (_isDragging)
return TRUE;
const bool isForward = ((short)HIWORD(wParam)) < 0; // wheel rotation towards the user will be considered as forward direction
const int lastTabIndex = static_cast<int32_t>(::SendMessage(_hSelf, TCM_GETITEMCOUNT, 0, 0) - 1);
if ((wParam & MK_CONTROL) && (wParam & MK_SHIFT))
{
setActiveTab((isForward ? lastTabIndex : 0));
}
else if ((wParam & MK_SHIFT) && _doDragNDrop)
{
int oldTabIndex = static_cast<int32_t>(::SendMessage(_hSelf, TCM_GETCURSEL, 0, 0));
int newTabIndex = oldTabIndex + (isForward ? 1 : -1);
if (newTabIndex < 0)
{
newTabIndex = lastTabIndex; // wrap scrolling
}
else if (newTabIndex > lastTabIndex)
{
newTabIndex = 0; // wrap scrolling
}
if (oldTabIndex != newTabIndex)
{
exchangeTabItemData(oldTabIndex, newTabIndex);
}
}
else if (wParam & (MK_CONTROL | MK_SHIFT))
{
int tabIndex = static_cast<int32_t>(::SendMessage(_hSelf, TCM_GETCURSEL, 0, 0) + (isForward ? 1 : -1));
if (tabIndex < 0)
{
if (wParam & MK_CONTROL)
tabIndex = lastTabIndex; // wrap scrolling
else
return TRUE;
}
else if (tabIndex > lastTabIndex)
{
if (wParam & MK_CONTROL)
tabIndex = 0; // wrap scrolling
else
return TRUE;
}
setActiveTab(tabIndex);
}
else if (not _isMultiLine) // don't scroll if in multi-line mode
{
RECT rcTabCtrl, rcLastTab;
::SendMessage(_hSelf, TCM_GETITEMRECT, lastTabIndex, reinterpret_cast<LPARAM>(&rcLastTab));
::GetClientRect(_hSelf, &rcTabCtrl);
// get index of the first visible tab
TC_HITTESTINFO hti;
LONG xy = NppParameters::getInstance()->_dpiManager.scaleX(12); // an arbitrary coordinate inside the first visible tab
hti.pt = { xy, xy };
int scrollTabIndex = static_cast<int32_t>(::SendMessage(_hSelf, TCM_HITTEST, 0, reinterpret_cast<LPARAM>(&hti)));
if (scrollTabIndex < 1 && (_isVertical ? rcLastTab.bottom < rcTabCtrl.bottom : rcLastTab.right < rcTabCtrl.right)) // nothing to scroll
return TRUE;
// maximal width/height of the msctls_updown32 class (arrow box in the tab bar),
// this area may hide parts of the last tab and needs to be excluded
LONG maxLengthUpDownCtrl = NppParameters::getInstance()->_dpiManager.scaleX(44); // sufficient static value
// scroll forward as long as the last tab is hidden; scroll backward till the first tab
if ((_isVertical ? ((rcTabCtrl.bottom - rcLastTab.bottom) < maxLengthUpDownCtrl) : ((rcTabCtrl.right - rcLastTab.right) < maxLengthUpDownCtrl)) || not isForward)
{
if (isForward)
++scrollTabIndex;
else
--scrollTabIndex;
if (scrollTabIndex < 0 || scrollTabIndex > lastTabIndex)
return TRUE;
// clear hover state of the close button,
// WM_MOUSEMOVE won't handle this properly since the tab position will change
if (_isCloseHover)
{
_isCloseHover = false;
::InvalidateRect(_hSelf, &_currentHoverTabRect, false);
}
::SendMessage(_hSelf, WM_HSCROLL, MAKEWPARAM(SB_THUMBPOSITION, scrollTabIndex), 0);
}
}
return TRUE;
}
case WM_LBUTTONDOWN :
{
if (_drawTabCloseButton)
{
int xPos = LOWORD(lParam);
int yPos = HIWORD(lParam);
if (_closeButtonZone.isHit(xPos, yPos, _currentHoverTabRect, _isVertical))
{
_whichCloseClickDown = getTabIndexAt(xPos, yPos);
::SendMessage(_hParent, WM_COMMAND, IDM_VIEW_REFRESHTABAR, 0);
return TRUE;
}
}
::CallWindowProc(_tabBarDefaultProc, hwnd, Message, wParam, lParam);
int currentTabOn = static_cast<int32_t>(::SendMessage(_hSelf, TCM_GETCURSEL, 0, 0));
if (wParam == 2)
return TRUE;
if (_doDragNDrop)
{
_mightBeDragging = true;
}
notify(NM_CLICK, currentTabOn);
return TRUE;
}
case WM_RBUTTONDOWN : //rightclick selects tab aswell
{
// TCS_BUTTONS doesn't select the tab
if (::GetWindowLongPtr(_hSelf, GWL_STYLE) & TCS_BUTTONS)
{
int nTab = getTabIndexAt(LOWORD(lParam), HIWORD(lParam));
if (nTab != -1 && nTab != static_cast<int32_t>(::SendMessage(_hSelf, TCM_GETCURSEL, 0, 0)))
{
setActiveTab(nTab);
}
}
::CallWindowProc(_tabBarDefaultProc, hwnd, WM_LBUTTONDOWN, wParam, lParam);
return TRUE;
}
case WM_MOUSEMOVE :
{
if (_mightBeDragging && !_isDragging)
{
// Grrr! Who has stolen focus and eaten the WM_LBUTTONUP?!
if (GetKeyState(VK_LBUTTON) >= 0)
{
_mightBeDragging = false;
_dragCount = 0;
}
else if (++_dragCount > 2)
{
int tabFocused = static_cast<int32_t>(::SendMessage(_hSelf, TCM_GETCURFOCUS, 0, 0));
int tabSelected = static_cast<int32_t>(::SendMessage(_hSelf, TCM_GETCURSEL, 0, 0));
// make sure the tab they are moving is active.
if (tabFocused != tabSelected)
{
setActiveTab(tabFocused);
}
_nSrcTab = _nTabDragged = tabFocused;
_isDragging = true;
// ::SetCapture is required for normal non-TLS_BUTTONS.
if (!(::GetWindowLongPtr(_hSelf, GWL_STYLE) & TCS_BUTTONS))
{
::SetCapture(hwnd);
}
}
}
POINT p;
p.x = LOWORD(lParam);
p.y = HIWORD(lParam);
if (_isDragging)
{
exchangeItemData(p);
// Get cursor position of "Screen"
// For using the function "WindowFromPoint" afterward!!!
::GetCursorPos(&_draggingPoint);
draggingCursor(_draggingPoint);
return TRUE;
}
else
{
bool isFromTabToTab = false;
int iTabNow = getTabIndexAt(p.x, p.y); // _currentHoverTabItem keeps previous value, and it need to be updated
if (_currentHoverTabItem == iTabNow && _currentHoverTabItem != -1) // mouse moves arround in the same tab
{
// do nothing
}
else if (iTabNow == -1 && _currentHoverTabItem != -1) // mouse is no more on any tab, set hover -1
{
_currentHoverTabItem = -1;
// send mouse leave notif
notify(TCN_MOUSELEAVING, -1);
}
else if (iTabNow != -1 && _currentHoverTabItem == -1) // mouse is just entered in a tab zone
{
_currentHoverTabItem = iTabNow;
notify(TCN_MOUSEHOVERING, _currentHoverTabItem);
}
else if (iTabNow != -1 && _currentHoverTabItem != -1 && _currentHoverTabItem != iTabNow) // mouse is being moved from a tab and entering into another tab
{
isFromTabToTab = true;
// set current hovered
_currentHoverTabItem = iTabNow;
// send mouse enter notif
notify(TCN_MOUSEHOVERSWITCHING, _currentHoverTabItem);
}
else if (iTabNow == -1 && _currentHoverTabItem == -1) // mouse is already outside
{
// do nothing
}
if (_drawTabCloseButton)
{
RECT currentHoverTabRectOld = _currentHoverTabRect;
bool isCloseHoverOld = _isCloseHover;
if (_currentHoverTabItem != -1) // is hovering
{
::SendMessage(_hSelf, TCM_GETITEMRECT, _currentHoverTabItem, reinterpret_cast<LPARAM>(&_currentHoverTabRect));
_isCloseHover = _closeButtonZone.isHit(p.x, p.y, _currentHoverTabRect, _isVertical);
}
else
{
SetRectEmpty(&_currentHoverTabRect);
_isCloseHover = false;
}
if (isFromTabToTab || _isCloseHover != isCloseHoverOld)
{
if (isCloseHoverOld && (isFromTabToTab || !_isCloseHover))
InvalidateRect(hwnd, ¤tHoverTabRectOld, FALSE);
if (_isCloseHover)
InvalidateRect(hwnd, &_currentHoverTabRect, FALSE);
}
if (_isCloseHover)
{
// Mouse moves out from close zone will send WM_MOUSELEAVE message
trackMouseEvent(TME_LEAVE);
}
}
// Mouse moves out from tab zone will send WM_MOUSELEAVE message
// but it doesn't track mouse moving from a tab to another
trackMouseEvent(TME_LEAVE);
}
break;
}
case WM_MOUSELEAVE:
{
if (_isCloseHover)
InvalidateRect(hwnd, &_currentHoverTabRect, FALSE);
_currentHoverTabItem = -1;
SetRectEmpty(&_currentHoverTabRect);
_isCloseHover = false;
notify(TCN_MOUSELEAVING, _currentHoverTabItem);
break;
}
case WM_LBUTTONUP :
{
_mightBeDragging = false;
_dragCount = 0;
int xPos = LOWORD(lParam);
int yPos = HIWORD(lParam);
int currentTabOn = getTabIndexAt(xPos, yPos);
if (_isDragging)
{
if(::GetCapture() == _hSelf)
::ReleaseCapture();
notify(_isDraggingInside?TCN_TABDROPPED:TCN_TABDROPPEDOUTSIDE, currentTabOn);
return TRUE;
}
if (_drawTabCloseButton)
{
if ((_whichCloseClickDown == currentTabOn) && _closeButtonZone.isHit(xPos, yPos, _currentHoverTabRect, _isVertical))
{
notify(TCN_TABDELETE, currentTabOn);
_whichCloseClickDown = -1;
// Get the next tab at same position
// If valid tab is found then
// update the current hover tab RECT (_currentHoverTabRect)
// update close hover flag (_isCloseHover), so that x will be highlighted or not based on new _currentHoverTabRect
int nextTab = getTabIndexAt(xPos, yPos);
if (nextTab != -1)
{
::SendMessage(_hSelf, TCM_GETITEMRECT, nextTab, reinterpret_cast<LPARAM>(&_currentHoverTabRect));
_isCloseHover = _closeButtonZone.isHit(xPos, yPos, _currentHoverTabRect, _isVertical);
}
return TRUE;
}
_whichCloseClickDown = -1;
}
break;
}
case WM_CAPTURECHANGED :
{
if (_isDragging)
{
_isDragging = false;
return TRUE;
}
break;
}
case WM_DRAWITEM :
{
drawItem((DRAWITEMSTRUCT *)lParam);
return TRUE;
}
case WM_KEYDOWN :
{
if (wParam == VK_LCONTROL)
::SetCursor(::LoadCursor(_hInst, MAKEINTRESOURCE(IDC_DRAG_PLUS_TAB)));
return TRUE;
}
case WM_MBUTTONUP:
{
int xPos = LOWORD(lParam);
int yPos = HIWORD(lParam);
int currentTabOn = getTabIndexAt(xPos, yPos);
notify(TCN_TABDELETE, currentTabOn);
return TRUE;
}
case WM_LBUTTONDBLCLK:
{
if (_isDbClk2Close)
{
int xPos = LOWORD(lParam);
int yPos = HIWORD(lParam);
int currentTabOn = getTabIndexAt(xPos, yPos);
notify(TCN_TABDELETE, currentTabOn);
}
return TRUE;
}
}
return ::CallWindowProc(_tabBarDefaultProc, hwnd, Message, wParam, lParam);
}
/*===========================================================================*
* do_getset *
*===========================================================================*/
PUBLIC int do_getset()
{
/* Handle GETUID, GETGID, GETPID, GETPGRP, SETUID, SETGID, SETSID. The four
* GETs and SETSID return their primary results in 'r'. GETUID, GETGID, and
* GETPID also return secondary results (the effective IDs, or the parent
* process ID) in 'reply_res2', which is returned to the user.
*/
register struct mproc *rmp = mp;
int r, proc;
switch(call_nr) {
case GETUID:
r = rmp->mp_realuid;
rmp->mp_reply.reply_res2 = rmp->mp_effuid;
break;
case GETGID:
r = rmp->mp_realgid;
rmp->mp_reply.reply_res2 = rmp->mp_effgid;
break;
case GETPID:
r = mproc[who_p].mp_pid;
rmp->mp_reply.reply_res2 = mproc[rmp->mp_parent].mp_pid;
if(pm_isokendpt(m_in.endpt, &proc) == OK && proc >= 0)
rmp->mp_reply.reply_res3 = mproc[proc].mp_pid;
break;
case SETEUID:
case SETUID:
if (rmp->mp_realuid != (uid_t) m_in.usr_id &&
rmp->mp_effuid != SUPER_USER)
return(EPERM);
if(call_nr == SETUID) rmp->mp_realuid = (uid_t) m_in.usr_id;
rmp->mp_effuid = (uid_t) m_in.usr_id;
if (rmp->mp_fs_call != PM_IDLE)
{
panic(__FILE__, "do_getset: not idle",
rmp->mp_fs_call);
}
rmp->mp_fs_call= PM_SETUID;
r= notify(FS_PROC_NR);
if (r != OK)
panic(__FILE__, "do_getset: unable to notify FS", r);
/* Do not reply until FS is ready to process the setuid
* request
*/
r= SUSPEND;
break;
case SETEGID:
case SETGID:
if (rmp->mp_realgid != (gid_t) m_in.grp_id &&
rmp->mp_effuid != SUPER_USER)
return(EPERM);
if(call_nr == SETGID) rmp->mp_realgid = (gid_t) m_in.grp_id;
rmp->mp_effgid = (gid_t) m_in.grp_id;
if (rmp->mp_fs_call != PM_IDLE)
{
panic(__FILE__, "do_getset: not idle",
rmp->mp_fs_call);
}
rmp->mp_fs_call= PM_SETGID;
r= notify(FS_PROC_NR);
if (r != OK)
panic(__FILE__, "do_getset: unable to notify FS", r);
/* Do not reply until FS is ready to process the setgid
* request
*/
r= SUSPEND;
break;
case SETSID:
if (rmp->mp_procgrp == rmp->mp_pid) return(EPERM);
rmp->mp_procgrp = rmp->mp_pid;
if (rmp->mp_fs_call != PM_IDLE)
{
panic(__FILE__, "do_getset: not idle",
rmp->mp_fs_call);
}
rmp->mp_fs_call= PM_SETSID;
r= notify(FS_PROC_NR);
if (r != OK)
panic(__FILE__, "do_getset: unable to notify FS", r);
/* Do not reply until FS is ready to process the setsid
* request
*/
r= SUSPEND;
break;
case GETPGRP:
r = rmp->mp_procgrp;
break;
default:
r = EINVAL;
break;
}
return(r);
}
void SoftVorbis::onQueueFilled(OMX_U32 portIndex) {
List<BufferInfo *> &inQueue = getPortQueue(0);
List<BufferInfo *> &outQueue = getPortQueue(1);
if (mOutputPortSettingsChange != NONE) {
return;
}
if (portIndex == 0 && mInputBufferCount < 2) {
BufferInfo *info = *inQueue.begin();
OMX_BUFFERHEADERTYPE *header = info->mHeader;
const uint8_t *data = header->pBuffer + header->nOffset;
size_t size = header->nFilledLen;
ogg_buffer buf;
ogg_reference ref;
oggpack_buffer bits;
makeBitReader(
(const uint8_t *)data + 7, size - 7,
&buf, &ref, &bits);
if (mInputBufferCount == 0) {
CHECK(mVi == NULL);
mVi = new vorbis_info;
vorbis_info_init(mVi);
CHECK_EQ(0, _vorbis_unpack_info(mVi, &bits));
} else {
CHECK_EQ(0, _vorbis_unpack_books(mVi, &bits));
CHECK(mState == NULL);
mState = new vorbis_dsp_state;
CHECK_EQ(0, vorbis_dsp_init(mState, mVi));
notify(OMX_EventPortSettingsChanged, 1, 0, NULL);
mOutputPortSettingsChange = AWAITING_DISABLED;
}
inQueue.erase(inQueue.begin());
info->mOwnedByUs = false;
notifyEmptyBufferDone(header);
++mInputBufferCount;
return;
}
while ((!inQueue.empty() || (mSawInputEos && !mSignalledOutputEos)) && !outQueue.empty()) {
BufferInfo *inInfo = NULL;
OMX_BUFFERHEADERTYPE *inHeader = NULL;
if (!inQueue.empty()) {
inInfo = *inQueue.begin();
inHeader = inInfo->mHeader;
}
BufferInfo *outInfo = *outQueue.begin();
OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader;
int32_t numPageSamples = 0;
if (inHeader) {
if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
mSawInputEos = true;
}
if (inHeader->nFilledLen || !mSawInputEos) {
CHECK_GE(inHeader->nFilledLen, sizeof(numPageSamples));
memcpy(&numPageSamples,
inHeader->pBuffer
+ inHeader->nOffset + inHeader->nFilledLen - 4,
sizeof(numPageSamples));
if (inHeader->nOffset == 0) {
mAnchorTimeUs = inHeader->nTimeStamp;
mNumFramesOutput = 0;
}
inHeader->nFilledLen -= sizeof(numPageSamples);;
}
}
if (numPageSamples >= 0) {
mNumFramesLeftOnPage = numPageSamples;
}
ogg_buffer buf;
buf.data = inHeader ? inHeader->pBuffer + inHeader->nOffset : NULL;
buf.size = inHeader ? inHeader->nFilledLen : 0;
buf.refcount = 1;
buf.ptr.owner = NULL;
ogg_reference ref;
ref.buffer = &buf;
ref.begin = 0;
ref.length = buf.size;
ref.next = NULL;
ogg_packet pack;
pack.packet = &ref;
pack.bytes = ref.length;
pack.b_o_s = 0;
pack.e_o_s = 0;
pack.granulepos = 0;
pack.packetno = 0;
int numFrames = 0;
outHeader->nFlags = 0;
int err = vorbis_dsp_synthesis(mState, &pack, 1);
if (err != 0) {
// FIXME temporary workaround for log spam
#if !defined(__arm__) && !defined(__aarch64__)
ALOGV("vorbis_dsp_synthesis returned %d", err);
#else
ALOGW("vorbis_dsp_synthesis returned %d", err);
#endif
} else {
numFrames = vorbis_dsp_pcmout(
mState, (int16_t *)outHeader->pBuffer,
(kMaxNumSamplesPerBuffer / mVi->channels));
if (numFrames < 0) {
ALOGE("vorbis_dsp_pcmout returned %d", numFrames);
numFrames = 0;
}
}
if (mNumFramesLeftOnPage >= 0) {
if (numFrames > mNumFramesLeftOnPage) {
ALOGV("discarding %d frames at end of page",
numFrames - mNumFramesLeftOnPage);
numFrames = mNumFramesLeftOnPage;
if (mSawInputEos) {
outHeader->nFlags = OMX_BUFFERFLAG_EOS;
mSignalledOutputEos = true;
}
}
mNumFramesLeftOnPage -= numFrames;
}
outHeader->nFilledLen = numFrames * sizeof(int16_t) * mVi->channels;
outHeader->nOffset = 0;
outHeader->nTimeStamp =
mAnchorTimeUs
+ (mNumFramesOutput * 1000000ll) / mVi->rate;
mNumFramesOutput += numFrames;
if (inHeader) {
inInfo->mOwnedByUs = false;
inQueue.erase(inQueue.begin());
inInfo = NULL;
notifyEmptyBufferDone(inHeader);
inHeader = NULL;
}
outInfo->mOwnedByUs = false;
outQueue.erase(outQueue.begin());
outInfo = NULL;
notifyFillBufferDone(outHeader);
outHeader = NULL;
++mInputBufferCount;
}
}
virtual ~TaskFieldReceiveAndInsertExchange()
{
notify(this->myId, RECVFINISHED, nullptr);
}
void set()
{
BOOST_ASSERT(!m_cond);
std::lock_guard<std::mutex> lock(m_mutex);
notify();
}
bool Search_Monte_Carlo_Threaded<RETURNTYPE,DIMTYPE,SUBSET,CRITERION,max_threads>::search(const DIMTYPE target_d, RETURNTYPE &result, const PSubset sub, const PCriterion crit, std::ostream& os) // returns found subset + criterion value
{
swatch.reset(new StopWatch);
notify("Search_Monte_Carlo_Threaded::search().");
assert(sub);
assert(crit);
const DIMTYPE n=sub->get_n();
assert(target_d>=0 && target_d<=n);
if(parent::result_tracker_active()) parent::_tracker->set_output_detail(parent::get_output_detail());
assert(_trials_limit!=0 || _time_limit!=0);
assert(_trials_limit==0 || _trials_limit>max_threads);
assert(_time_limit_check_freq>0);
_target_d=target_d;
_trials=0;
if(parent::output_normal()) {
std::ostringstream sos;
sos << "---------------------------------------" << std::endl;
sos << "Starting " << *this << std::endl;
sos << "with Criterion: " << *crit << std::endl;
if(target_d==0) sos << "Subset size to be optimized." << std::endl; else sos << "Target subset size set to: " << target_d << std::endl;
sos << std::endl << std::flush;
syncout::print(os,sos);
}
// test master crit pointer change ? then recreate criterion clones
if(template_crit!=crit) {
for(unsigned int i=0;i<max_threads;i++) tlocal[i].crit.reset(crit->clone());
template_crit=crit;
}
// initialize all other thread local structures
for(unsigned int i=0;i<max_threads;i++) {
if(!tlocal[i].bestsub || tlocal[i].bestsub->get_n()!=n) tlocal[i].bestsub.reset(new SUBSET(n));
if(parent::_tracker) tlocal[i].tracker.reset(parent::_tracker->stateless_clone());
tlocal[i].bestval_available=false;
tlocal[i].os=&os;
}
// launch worker threads and wait for them to finish
ThreadPool<max_threads> tp;
for(unsigned int i=0;i<max_threads;i++) tp.go(boost::bind(&Search_Monte_Carlo_Threaded::evaluator_thread, this, i));
tp.join_all();
// join thread-local trackers' contents
if(parent::_tracker) {
if(parent::output_detailed()) {std::ostringstream sos; sos << "Global tracker before join (size=" << parent::_tracker->size() << ")." << std::endl << std::flush; syncout::print(os,sos);}
for(unsigned int i=0;i<max_threads;i++) {
if(parent::output_detailed()) {std::ostringstream sos; sos << "Joining thread ["<<i<<"] tracker.. (size=" << tlocal[i].tracker->size() << ")" << std::endl << std::flush; syncout::print(os,sos);}
parent::_tracker->join(*(tlocal[i].tracker.get()));
tlocal[i].tracker->clear();
}
if(parent::output_detailed()) {std::ostringstream sos; sos << "Joined thread local trackers (size=" << parent::_tracker->size() << ")." << std::endl << *swatch << std::endl << std::endl << std::flush; syncout::print(os,sos);}
}
// identify the globally best result
assert(tlocal[0].bestval_available);
unsigned int bestidx=0;
for(unsigned int i=1;i<max_threads;i++) if(tlocal[i].bestval_available && tlocal[i].bestval>tlocal[bestidx].bestval) bestidx=i;
sub->stateless_copy(*tlocal[bestidx].bestsub);
result=tlocal[bestidx].bestval;
if(parent::output_normal()) {
std::ostringstream sos;
sos << "......................................." << std::endl;
sos << "Search_Monte_Carlo_Threaded() search finished after "<<_trials<<" trials. " << *swatch << std::endl;
sos << "Search result: "<< std::endl << *sub << std::endl << "Criterion value: " << result << std::endl << std::endl << std::flush;
syncout::print(os,sos);
}
swatch.reset();
return true;
}
virtual ~Search_Monte_Carlo_Threaded() {notify("Search_Monte_Carlo_Threaded destructor.");}
Search_Monte_Carlo_Threaded(const unsigned long trials_limit=1000, const unsigned long time_limit=0, const unsigned int time_limit_check_freq=10):Search<RETURNTYPE,DIMTYPE,SUBSET,CRITERION>()
{
BOOST_STATIC_ASSERT(max_threads>0);
notify("Search_Monte_Carlo_Threaded constructor.");
set_stopping_condition(trials_limit,time_limit,time_limit_check_freq); reset_cardinality_randomization();
}
// ---
void ScenePacman::processEvent (const QGAMES::Event& e)
{
QGAMES::Scene::processEvent (e);
if (e.code () == __MAZECLEAN)
notify (e);
}
status_t WAVEWriter::threadFunc() {
mEstimatedDurationUs = 0;
mEstimatedSizeBytes = 0;
bool stoppedPrematurely = true;
int64_t previousPausedDurationUs = 0;
int64_t maxTimestampUs = 0;
status_t err = OK;
prctl(PR_SET_NAME, (unsigned long)"WAVEWriter", 0, 0, 0);
hdr.data_sz = 0;
while (!mDone) {
MediaBuffer *buffer;
err = mSource->read(&buffer);
if (err != OK) {
break;
}
if (mPaused) {
buffer->release();
buffer = NULL;
continue;
}
mEstimatedSizeBytes += buffer->range_length();
if (exceedsFileSizeLimit()) {
buffer->release();
buffer = NULL;
notify(MEDIA_RECORDER_EVENT_INFO, MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED, 0);
break;
}
int64_t timestampUs;
CHECK(buffer->meta_data()->findInt64(kKeyTime, ×tampUs));
if (timestampUs > mEstimatedDurationUs) {
mEstimatedDurationUs = timestampUs;
}
if (mResumed) {
previousPausedDurationUs += (timestampUs - maxTimestampUs - 20000);
mResumed = false;
}
timestampUs -= previousPausedDurationUs;
ALOGV("time stamp: %lld, previous paused duration: %lld",
timestampUs, previousPausedDurationUs);
if (timestampUs > maxTimestampUs) {
maxTimestampUs = timestampUs;
}
if (exceedsFileDurationLimit()) {
buffer->release();
buffer = NULL;
notify(MEDIA_RECORDER_EVENT_INFO, MEDIA_RECORDER_INFO_MAX_DURATION_REACHED, 0);
break;
}
ssize_t n = write(mFd,
(const uint8_t *)buffer->data() + buffer->range_offset(),
buffer->range_length());
hdr.data_sz += (ssize_t)buffer->range_length();
hdr.riff_sz = hdr.data_sz + 44 - 8;
if (n < (ssize_t)buffer->range_length()) {
buffer->release();
buffer = NULL;
break;
}
if (stoppedPrematurely) {
stoppedPrematurely = false;
}
buffer->release();
buffer = NULL;
}
if (stoppedPrematurely) {
notify(MEDIA_RECORDER_EVENT_INFO, MEDIA_RECORDER_TRACK_INFO_COMPLETION_STATUS, UNKNOWN_ERROR);
}
lseek(mFd, 0, SEEK_SET);
write(mFd, &hdr, sizeof(hdr));
lseek(mFd, 0, SEEK_END);
close(mFd);
mFd = -1;
mReachedEOS = true;
if (err == ERROR_END_OF_STREAM) {
return OK;
}
return err;
}
void MediaPlayer::died()
{
ALOGV("died");
notify(MEDIA_ERROR, MEDIA_ERROR_SERVER_DIED, 0);
}
int update_watchers_status(str pres_uri, pres_ev_t* ev, str* rules_doc)
{
subs_t subs;
db_key_t query_cols[6], result_cols[5];
db_val_t query_vals[6];
int n_result_cols= 0, n_query_cols = 0;
db1_res_t* result= NULL;
db_row_t *row;
db_val_t *row_vals ;
int i;
str w_user, w_domain, reason= {0, 0};
unsigned int status;
int status_col, w_user_col, w_domain_col, reason_col;
subs_t* subs_array= NULL,* s;
unsigned int hash_code;
int err_ret= -1;
int n= 0;
typedef struct ws {
int status;
str reason;
str w_user;
str w_domain;
} ws_t;
ws_t* ws_list= NULL;
LM_DBG("start\n");
if(ev->content_type.s== NULL)
{
ev= contains_event(&ev->name, NULL);
if(ev== NULL)
{
LM_ERR("wrong event parameter\n");
return 0;
}
}
memset(&subs, 0, sizeof(subs_t));
subs.pres_uri= pres_uri;
subs.event= ev;
subs.auth_rules_doc= rules_doc;
/* update in watchers_table */
query_cols[n_query_cols]= &str_presentity_uri_col;
query_vals[n_query_cols].nul= 0;
query_vals[n_query_cols].type= DB1_STR;
query_vals[n_query_cols].val.str_val= pres_uri;
n_query_cols++;
query_cols[n_query_cols]= &str_event_col;
query_vals[n_query_cols].nul= 0;
query_vals[n_query_cols].type= DB1_STR;
query_vals[n_query_cols].val.str_val= ev->name;
n_query_cols++;
result_cols[status_col= n_result_cols++]= &str_status_col;
result_cols[reason_col= n_result_cols++]= &str_reason_col;
result_cols[w_user_col= n_result_cols++]= &str_watcher_username_col;
result_cols[w_domain_col= n_result_cols++]= &str_watcher_domain_col;
if (pa_dbf.use_table(pa_db, &watchers_table) < 0)
{
LM_ERR( "in use_table\n");
goto done;
}
if(pa_dbf.query(pa_db, query_cols, 0, query_vals, result_cols,n_query_cols,
n_result_cols, 0, &result)< 0)
{
LM_ERR( "in sql query\n");
goto done;
}
if(result== NULL)
return 0;
if(result->n<= 0)
{
err_ret= 0;
goto done;
}
LM_DBG("found %d record-uri in watchers_table\n", result->n);
hash_code= core_case_hash(&pres_uri, &ev->name, shtable_size);
subs.db_flag= hash_code;
/* must do a copy as sphere_check requires database queries */
if(sphere_enable)
{
n= result->n;
ws_list= (ws_t*)pkg_malloc(n * sizeof(ws_t));
if(ws_list== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memset(ws_list, 0, n * sizeof(ws_t));
for(i= 0; i< result->n ; i++)
{
row= &result->rows[i];
row_vals = ROW_VALUES(row);
status= row_vals[status_col].val.int_val;
reason.s= (char*)row_vals[reason_col].val.string_val;
reason.len= reason.s?strlen(reason.s):0;
w_user.s= (char*)row_vals[w_user_col].val.string_val;
w_user.len= strlen(w_user.s);
w_domain.s= (char*)row_vals[w_domain_col].val.string_val;
w_domain.len= strlen(w_domain.s);
if(reason.len)
{
ws_list[i].reason.s = (char*)pkg_malloc(reason.len* sizeof(char));
if(ws_list[i].reason.s== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memcpy(ws_list[i].reason.s, reason.s, reason.len);
ws_list[i].reason.len= reason.len;
}
else
ws_list[i].reason.s= NULL;
ws_list[i].w_user.s = (char*)pkg_malloc(w_user.len* sizeof(char));
if(ws_list[i].w_user.s== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memcpy(ws_list[i].w_user.s, w_user.s, w_user.len);
ws_list[i].w_user.len= w_user.len;
ws_list[i].w_domain.s = (char*)pkg_malloc(w_domain.len* sizeof(char));
if(ws_list[i].w_domain.s== NULL)
{
LM_ERR("No more private memory\n");
goto done;
}
memcpy(ws_list[i].w_domain.s, w_domain.s, w_domain.len);
ws_list[i].w_domain.len= w_domain.len;
ws_list[i].status= status;
}
pa_dbf.free_result(pa_db, result);
result= NULL;
for(i=0; i< n; i++)
{
subs.watcher_user = ws_list[i].w_user;
subs.watcher_domain = ws_list[i].w_domain;
subs.status = ws_list[i].status;
memset(&subs.reason, 0, sizeof(str));
if( pres_update_status(&subs, reason, query_cols, query_vals,
n_query_cols, &subs_array)< 0)
{
LM_ERR("failed to update watcher status\n");
goto done;
}
}
for(i=0; i< n; i++)
{
pkg_free(ws_list[i].w_user.s);
pkg_free(ws_list[i].w_domain.s);
if(ws_list[i].reason.s)
pkg_free(ws_list[i].reason.s);
}
pkg_free(ws_list);
ws_list= NULL;
goto send_notify;
}
for(i = 0; i< result->n; i++)
{
row= &result->rows[i];
row_vals = ROW_VALUES(row);
status= row_vals[status_col].val.int_val;
reason.s= (char*)row_vals[reason_col].val.string_val;
reason.len= reason.s?strlen(reason.s):0;
w_user.s= (char*)row_vals[w_user_col].val.string_val;
w_user.len= strlen(w_user.s);
w_domain.s= (char*)row_vals[w_domain_col].val.string_val;
w_domain.len= strlen(w_domain.s);
subs.watcher_user= w_user;
subs.watcher_domain= w_domain;
subs.status= status;
memset(&subs.reason, 0, sizeof(str));
if( pres_update_status(&subs,reason, query_cols, query_vals,
n_query_cols, &subs_array)< 0)
{
LM_ERR("failed to update watcher status\n");
goto done;
}
}
pa_dbf.free_result(pa_db, result);
result= NULL;
send_notify:
if (pres_notifier_processes == 0)
{
s= subs_array;
while(s)
{
if(notify(s, NULL, NULL, 0, 0)< 0)
{
LM_ERR( "sending Notify request\n");
goto done;
}
/* delete from database also */
if(s->status== TERMINATED_STATUS)
{
if(pres_db_delete_status(s)<0)
{
LM_ERR("failed to delete terminated "
"dialog from database\n");
goto done;
}
}
s= s->next;
}
}
free_subs_list(subs_array, PKG_MEM_TYPE, 0);
return 0;
done:
if(result)
pa_dbf.free_result(pa_db, result);
free_subs_list(subs_array, PKG_MEM_TYPE, 0);
if(ws_list)
{
for(i= 0; i< n; i++)
{
if(ws_list[i].w_user.s)
pkg_free(ws_list[i].w_user.s);
if(ws_list[i].w_domain.s)
pkg_free(ws_list[i].w_domain.s);
if(ws_list[i].reason.s)
pkg_free(ws_list[i].reason.s);
}
pkg_free(ws_list);
}
return err_ret;
}
void SoftFlacEncoder::onQueueFilled(OMX_U32 portIndex) {
//UNUSED_UNLESS_VERBOSE(portIndex);
ALOGV("SoftFlacEncoder::onQueueFilled(portIndex=%d)", portIndex);
if (mSignalledError) {
return;
}
List<BufferInfo *> &inQueue = getPortQueue(0);
List<BufferInfo *> &outQueue = getPortQueue(1);
while (!inQueue.empty() && !outQueue.empty()) {
BufferInfo *inInfo = *inQueue.begin();
OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader;
BufferInfo *outInfo = *outQueue.begin();
OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader;
if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
inQueue.erase(inQueue.begin());
inInfo->mOwnedByUs = false;
notifyEmptyBufferDone(inHeader);
outHeader->nFilledLen = 0;
outHeader->nFlags = OMX_BUFFERFLAG_EOS;
outQueue.erase(outQueue.begin());
outInfo->mOwnedByUs = false;
notifyFillBufferDone(outHeader);
return;
}
if (inHeader->nFilledLen > kMaxInputBufferSize) {
ALOGE("input buffer too large (%d).", inHeader->nFilledLen);
mSignalledError = true;
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
return;
}
assert(mNumChannels != 0);
mEncoderWriteData = true;
mEncoderReturnedEncodedData = false;
mEncoderReturnedNbBytes = 0;
mCurrentInputTimeStamp = inHeader->nTimeStamp;
const unsigned nbInputFrames = inHeader->nFilledLen / (2 * mNumChannels);
const unsigned nbInputSamples = inHeader->nFilledLen / 2;
const OMX_S16 * const pcm16 = reinterpret_cast<OMX_S16 *>(inHeader->pBuffer);
CHECK_LE(nbInputSamples, 2 * kMaxNumSamplesPerFrame);
for (unsigned i=0 ; i < nbInputSamples ; i++) {
mInputBufferPcm32[i] = (FLAC__int32) pcm16[i];
}
ALOGV(" about to encode %u samples per channel", nbInputFrames);
FLAC__bool ok = FLAC__stream_encoder_process_interleaved(
mFlacStreamEncoder,
mInputBufferPcm32,
nbInputFrames /*samples per channel*/ );
if (ok) {
if (mEncoderReturnedEncodedData && (mEncoderReturnedNbBytes != 0)) {
ALOGV(" dequeueing buffer on output port after writing data");
outInfo->mOwnedByUs = false;
outQueue.erase(outQueue.begin());
outInfo = NULL;
notifyFillBufferDone(outHeader);
outHeader = NULL;
mEncoderReturnedEncodedData = false;
} else {
ALOGV(" encoder process_interleaved returned without data to write");
}
} else {
ALOGE(" error encountered during encoding");
mSignalledError = true;
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
return;
}
inInfo->mOwnedByUs = false;
inQueue.erase(inQueue.begin());
inInfo = NULL;
notifyEmptyBufferDone(inHeader);
inHeader = NULL;
}
}
void OtrNotifier::notifyTryingToRefreshSession(const Contact &contact)
{
notify(
contact, normalizeHtml(HtmlString{tr("%1: trying to refresh private conversation")}.arg(
plainToHtml(contact.display(true)))));
}
void Settings::initAndNotify(const QString &key, QObject *receiver, const char *slot, const QVariant &defaultValue)
{
notify(key, receiver, slot);
emit notifier(normalizedKey(group, key))->valueChanged(localValue(key, defaultValue));
}
void OtrNotifier::notifyPeerEndedSession(const Contact &contact)
{
notify(
contact, normalizeHtml(HtmlString{tr("%1: peer ended private conversation; you should do the same")}.arg(
plainToHtml(contact.display(true)))));
}
/** Check an attribute's value against /limit or /enum restrictions.
* \param player Player to send error message to, or NOTHING to skip
* \param name the attribute name.
* \param value The desired attribute value.
* \retval The new value to set if valid, NULL if not.
*/
const char *
check_attr_value(dbref player, const char *name, const char *value)
{
/* Check for attribute limits and enums. */
ATTR *ap;
char *attrval;
pcre *re;
int subpatterns;
const char *errptr;
int erroffset;
char *ptr, *ptr2;
char delim;
int len;
static char buff[BUFFER_LEN];
char vbuff[BUFFER_LEN];
if (!name || !*name)
return value;
if (!value)
return value;
upcasestr((char *) name);
ap = (ATTR *) ptab_find_exact(&ptab_attrib, name);
if (!ap)
return value;
attrval = atr_value(ap);
if (!attrval) {
return value;
}
if (ap->flags & AF_RLIMIT) {
re = pcre_compile(remove_markup(attrval, NULL), PCRE_CASELESS,
&errptr, &erroffset, tables);
if (!re)
return value;
subpatterns = pcre_exec(re, default_match_limit(), value, strlen(value),
0, 0, NULL, 0);
pcre_free(re);
if (subpatterns >= 0) {
return value;
} else {
if (player != NOTHING)
notify(player, T("Attribute value does not match the /limit regexp."));
return NULL;
}
} else if (ap->flags & AF_ENUM) {
/* Delimiter is always the first character of the enum string.
* and the value cannot have the delimiter in it. */
delim = *attrval;
if (!*value || strchr(value, delim)) {
if (player != NOTHING)
notify_format(player,
T("Value for %s needs to be one of: %s"),
ap->name, display_attr_limit(ap));
return NULL;
}
/* We match the enum case-insensitively, BUT we use the case
* that is defined in the enum, so we copy the attr value
* to buff and use that. */
snprintf(buff, BUFFER_LEN, "%s", attrval);
upcasestr(buff);
len = strlen(value);
snprintf(vbuff, BUFFER_LEN, "%c%s%c", delim, value, delim);
upcasestr(vbuff);
ptr = strstr(buff, vbuff);
if (!ptr) {
*(vbuff + len + 1) = '\0'; /* Remove the second delim */
ptr = strstr(buff, vbuff);
}
/* Do we have a match? */
if (ptr) {
/* ptr is pointing at the delim before the value. */
ptr++;
ptr2 = strchr(ptr, delim);
if (!ptr2)
return NULL; /* Shouldn't happen, but sanity check. */
/* Now we need to copy over the _original case_ version of the
* enumerated string. Nasty pointer arithmetic. */
strncpy(buff, attrval + (ptr - buff), (int) (ptr2 - ptr));
buff[ptr2 - ptr] = '\0';
return buff;
} else {
if (player != NOTHING)
notify_format(player,
T("Value for %s needs to be one of: %s"),
ap->name, display_attr_limit(ap));
return NULL;
}
}
return value;
}
void OtrNotifier::notifyGoneInsecure(const Contact &contact)
{
notify(
contact,
normalizeHtml(HtmlString{tr("%1: private conversation stopped")}.arg(plainToHtml(contact.display(true)))));
}
/** Add new standard attributes, or change permissions on them.
* \verbatim
* Given the name and permission string for an attribute, add it to
* the attribute table (or modify the permissions if it's already
* there). Permissions may be changed retroactively, which modifies
* permissions on any copies of that attribute set on objects in the
* database. This is the top-level code for @attribute/access.
* \endverbatim
* \param player the enactor.
* \param name the attribute name.
* \param perms a string of attribute permissions, space-separated.
* \param retroactive if true, apply the permissions retroactively.
*/
void
do_attribute_access(dbref player, char *name, char *perms, int retroactive)
{
ATTR *ap, *ap2;
privbits flags = 0;
int i;
int insert = 0;
/* Parse name and perms */
if (!name || !*name) {
notify(player, T("Which attribute do you mean?"));
return;
}
if (strcasecmp(perms, "none")) {
flags = list_to_privs(attr_privs_set, perms, 0);
if (!flags) {
notify(player, T("I don't understand those permissions."));
return;
}
}
upcasestr(name);
/* Is this attribute already in the table? */
ap = (ATTR *) ptab_find_exact(&ptab_attrib, name);
if (ap) {
if (AF_Internal(ap)) {
/* Don't muck with internal attributes */
notify(player, T("That attribute's permissions can not be changed."));
return;
}
/* Preserve any existing @attribute/limit */
flags |= (AL_FLAGS(ap) & (AF_RLIMIT | AF_ENUM));
} else {
/* Create fresh if the name is ok */
if (!good_atr_name(name)) {
notify(player, T("Invalid attribute name."));
return;
}
insert = 1;
ap = (ATTR *) mush_malloc(sizeof(ATTR), "ATTR");
if (!ap) {
notify(player, T("Critical memory failure - Alert God!"));
do_log(LT_ERR, 0, 0, "do_attribute_access: unable to malloc ATTR");
return;
}
AL_NAME(ap) = strdup(name);
ap->data = NULL_CHUNK_REFERENCE;
}
AL_FLAGS(ap) = flags;
AL_CREATOR(ap) = player;
/* Only insert when it's not already in the table */
if (insert) {
ptab_insert_one(&ptab_attrib, name, ap);
}
/* Ok, now we need to see if there are any attributes of this name
* set on objects in the db. If so, and if we're retroactive, set
* perms/creator
*/
if (retroactive) {
for (i = 0; i < db_top; i++) {
if ((ap2 = atr_get_noparent(i, name))) {
if (AL_FLAGS(ap2) & AF_ROOT)
AL_FLAGS(ap2) = flags | AF_ROOT;
else
AL_FLAGS(ap2) = flags;
AL_CREATOR(ap2) = player;
}
}
}
notify_format(player, T("%s -- Attribute permissions now: %s"), name,
privs_to_string(attr_privs_view, flags));
}
void OtrNotifier::notifyStillSecure(const Contact &contact)
{
notify(
contact,
normalizeHtml(HtmlString{tr("%1: conversation is still private")}.arg(plainToHtml(contact.display(true)))));
}
bool QAudioOutputPrivate::deviceReady()
{
if(deviceState == QAudio::StoppedState || deviceState == QAudio::SuspendedState)
return false;
if(pullMode) {
int chunks = bytesAvailable/period_size;
#ifdef DEBUG_AUDIO
qDebug()<<"deviceReady() avail="<<bytesAvailable<<" bytes, period size="<<period_size<<" bytes";
qDebug()<<"deviceReady() no. of chunks that can fit ="<<chunks<<", chunks in bytes ="<<chunks*period_size;
#endif
bool startup = false;
if(totalTimeValue == 0)
startup = true;
bool full=false;
mutex.lock();
if(waveFreeBlockCount==0) full = true;
mutex.unlock();
if (full){
#ifdef DEBUG_AUDIO
qDebug() << "Skipping data as unable to write";
#endif
if((timeStamp.elapsed() + elapsedTimeOffset) > intervalTime ) {
emit notify();
elapsedTimeOffset = timeStamp.elapsed() + elapsedTimeOffset - intervalTime;
timeStamp.restart();
}
return true;
}
if(startup)
waveOutPause(hWaveOut);
int input = period_size*chunks;
int l = audioSource->read(audioBuffer,input);
if(l > 0) {
int out= write(audioBuffer,l);
if(out > 0) {
if (deviceState != QAudio::ActiveState) {
deviceState = QAudio::ActiveState;
emit stateChanged(deviceState);
}
}
if ( out < l) {
// Didn't write all data
audioSource->seek(audioSource->pos()-(l-out));
}
if(startup)
waveOutRestart(hWaveOut);
} else if(l == 0) {
bytesAvailable = bytesFree();
int check = 0;
mutex.lock();
check = waveFreeBlockCount;
mutex.unlock();
if(check == buffer_size/period_size) {
if (deviceState != QAudio::IdleState) {
errorState = QAudio::UnderrunError;
deviceState = QAudio::IdleState;
emit stateChanged(deviceState);
}
}
} else if(l < 0) {
bytesAvailable = bytesFree();
if (errorState != QAudio::IOError)
errorState = QAudio::IOError;
}
} else {
int buffered;
mutex.lock();
buffered = waveFreeBlockCount;
mutex.unlock();
if (buffered >= buffer_size/period_size && deviceState == QAudio::ActiveState) {
if (deviceState != QAudio::IdleState) {
errorState = QAudio::UnderrunError;
deviceState = QAudio::IdleState;
emit stateChanged(deviceState);
}
}
}
if(deviceState != QAudio::ActiveState && deviceState != QAudio::IdleState)
return true;
if(intervalTime && (timeStamp.elapsed() + elapsedTimeOffset) > intervalTime) {
emit notify();
elapsedTimeOffset = timeStamp.elapsed() + elapsedTimeOffset - intervalTime;
timeStamp.restart();
}
return true;
}
void
main(int argc, char *argv[])
{
int fd, lckfd, lckpid, cmdpid;
char *cmd, *p, *lock;
char **args;
char *argarr[2];
Waitmsg *w;
ARGBEGIN {
case 'd':
++debug;
break;
case 'w':
++lockwait;
break;
default:
usage();
break;
} ARGEND
if (argc < 1)
usage();
if (argc == 1) {
args = argarr;
args[0] = cmd = "rc";
args[1] = nil;
} else {
cmd = argv[1];
args = &argv[1];
}
/* set up lock and process to keep it alive */
lock = argv[0];
lckfd = openlock(lock);
lckpid = fork();
switch(lckpid){
case -1:
error("fork");
case 0:
/* keep lock alive until killed */
for (;;) {
sleep(60*1000);
seek(lckfd, 0, 0);
fprint(lckfd, "\n");
}
}
/* spawn argument command */
cmdpid = rfork(RFFDG|RFREND|RFPROC|RFENVG);
switch(cmdpid){
case -1:
error("fork");
case 0:
fd = create("/env/prompt", OWRITE, 0666);
if (fd >= 0) {
fprint(fd, "%s%% ", lock);
close(fd);
}
exec(cmd, args);
if(cmd[0] != '/' && strncmp(cmd, "./", 2) != 0 &&
strncmp(cmd, "../", 3) != 0)
exec(smprint("/bin/%s", cmd), args);
error(cmd);
}
notify(notifyf);
w = waitfor(cmdpid);
if (w == nil)
error("wait");
postnote(PNPROC, lckpid, "die");
waitfor(lckpid);
if(w->msg[0]){
p = utfrune(w->msg, ':');
if(p && p[1])
p++;
else
p = w->msg;
while (isspace(*p))
p++;
fprint(2, "%s: %s # status=%s\n", argv0, cmd, p);
}
exits(w->msg);
}
void DummySandbox::notifySignal(int signum) {
Lock lock(this);
m_signum = signum;
notify();
}
void add(int a, int b) {
notify(Add(a, b));
}
