int main(int argc, char **args)
{
if(argc < 2) {
fprintf(stderr, "usage: runvm file [index]\n");
return 1;
}
genepool *e;
environment env;
int fd;
int ri = 0;
int si;
long long int steps;
fd = open(args[1], O_RDONLY);
e = load_genepool(fd);
close(fd);
if(argc >= 3 && sscanf(args[2], "%d", &si) && si > 0 && si < e->num_candidates) {
ri = si;
}
init_environment(&env);
env.ii[0].source = stdInput;
env.ii[0].context = stdin;
env.oo[0].sink = stdOutput;
env.oo[0].context = stdout;
steps = 200000;
vmRun(e->candidates[ri].genome, &env, &steps);
}
int main(int argc, char* argv[])
{
init_environment();
//return test_dispatch(argc,argv);
return start_server();
return 0;
}
int main(void)
{
init_environment();
MACHINE *mach = make_machine();
for (int i = 0; i < 23; i++)
printf("ins %d: %08x\n", i, factorial_ins[i]);
printf("\n");
init_machine(mach);
load_memory(factorial_ins, 100, mach, 0);
run_machine(mach);
free_machine(mach);
return 0;
}
int main(void) {
nagios_macros *mac;
reset_variables();
init_environment();
init_macros();
mac = setup_macro_object();
test_escaping(mac);
cleanup();
free(mac);
return exit_status();
}
int main(int argc, char *argv[]) {
FILE *input = ((argc > 1) ? fopen(argv[1], "r") : stdin);
if (!input) {
fprintf(stderr, "[%s] failed to open file\n", __func__);
exit(EXIT_FAILURE);
}
environment_t *env = init_environment();
repl(input, &env, argc);
fclose(input);
return EXIT_SUCCESS;
}
static void lmdbg_startup (void)
{
if (real_malloc){
/* already initialized */
return;
}
init_fun_ptrs ();
init_log ();
init_pid ();
init_st_range ();
print_sections_map ();
print_progname ();
init_environment ();
init_enabling_timeout ();
if (log_filename != NULL && enabling_timeout == 0)
enable_logging ();
else if (enabling_timeout == -1)
set_sigusr1_handler ();
}
int test_dispatch(int argc, char* argv[])
{
//CoUnInitialize(NULL);
if(argc<2){
printf("usage: pget <fileaname>\n");
return 0;
}
init_environment();
SmartDocumentDispatcher *dispatcher=NULL;
try{
dispatcher = new SmartDocumentDispatcher;
dispatcher->proc("f:\\document\\06.ppt","not good thing");
dispatcher->proc("f:\\document\\06.ppt","not good thing");
}catch(Exception &e){
e.report();
}
if(dispatcher)delete dispatcher;
//proc.processDocument(argv[1]);
return 0;
}
static CURLcode gskit_connect_step1(struct connectdata *conn, int sockindex)
{
struct Curl_easy *data = conn->data;
struct ssl_connect_data *connssl = &conn->ssl[sockindex];
gsk_handle envir;
CURLcode result;
int rc;
char *keyringfile;
char *keyringpwd;
char *keyringlabel;
char *sni;
unsigned int protoflags;
long timeout;
Qso_OverlappedIO_t commarea;
/* Create SSL environment, start (preferably asynchronous) handshake. */
connssl->handle = (gsk_handle) NULL;
connssl->iocport = -1;
/* GSKit supports two ways of specifying an SSL context: either by
* application identifier (that should have been defined at the system
* level) or by keyring file, password and certificate label.
* Local certificate name (CURLOPT_SSLCERT) is used to hold either the
* application identifier of the certificate label.
* Key password (CURLOPT_KEYPASSWD) holds the keyring password.
* It is not possible to have different keyrings for the CAs and the
* local certificate. We thus use the CA file (CURLOPT_CAINFO) to identify
* the keyring file.
* If no key password is given and the keyring is the system keyring,
* application identifier mode is tried first, as recommended in IBM doc.
*/
keyringfile = data->set.str[STRING_SSL_CAFILE];
keyringpwd = data->set.str[STRING_KEY_PASSWD];
keyringlabel = data->set.str[STRING_CERT];
envir = (gsk_handle) NULL;
if(keyringlabel && *keyringlabel && !keyringpwd &&
!strcmp(keyringfile, CURL_CA_BUNDLE)) {
/* Try application identifier mode. */
init_environment(data, &envir, keyringlabel, (const char *) NULL,
(const char *) NULL, (const char *) NULL);
}
if(!envir) {
/* Use keyring mode. */
result = init_environment(data, &envir, (const char *) NULL,
keyringfile, keyringlabel, keyringpwd);
if(result)
return result;
}
/* Create secure session. */
result = gskit_status(data, gsk_secure_soc_open(envir, &connssl->handle),
"gsk_secure_soc_open()", CURLE_SSL_CONNECT_ERROR);
gsk_environment_close(&envir);
if(result)
return result;
/* Determine which SSL/TLS version should be enabled. */
protoflags = CURL_GSKPROTO_TLSV10_MASK | CURL_GSKPROTO_TLSV11_MASK |
CURL_GSKPROTO_TLSV12_MASK;
sni = conn->host.name;
switch (data->set.ssl.version) {
case CURL_SSLVERSION_SSLv2:
protoflags = CURL_GSKPROTO_SSLV2_MASK;
sni = (char *) NULL;
break;
case CURL_SSLVERSION_SSLv3:
protoflags = CURL_GSKPROTO_SSLV3_MASK;
sni = (char *) NULL;
break;
case CURL_SSLVERSION_TLSv1:
protoflags = CURL_GSKPROTO_TLSV10_MASK |
CURL_GSKPROTO_TLSV11_MASK | CURL_GSKPROTO_TLSV12_MASK;
break;
case CURL_SSLVERSION_TLSv1_0:
protoflags = CURL_GSKPROTO_TLSV10_MASK;
break;
case CURL_SSLVERSION_TLSv1_1:
protoflags = CURL_GSKPROTO_TLSV11_MASK;
break;
case CURL_SSLVERSION_TLSv1_2:
protoflags = CURL_GSKPROTO_TLSV12_MASK;
break;
}
/* Process SNI. Ignore if not supported (on OS400 < V7R1). */
if(sni) {
result = set_buffer(data, connssl->handle,
GSK_SSL_EXTN_SERVERNAME_REQUEST, sni, TRUE);
if(result == CURLE_UNSUPPORTED_PROTOCOL)
result = CURLE_OK;
}
/* Set session parameters. */
if(!result) {
/* Compute the handshake timeout. Since GSKit granularity is 1 second,
we round up the required value. */
timeout = Curl_timeleft(data, NULL, TRUE);
if(timeout < 0)
result = CURLE_OPERATION_TIMEDOUT;
else
result = set_numeric(data, connssl->handle, GSK_HANDSHAKE_TIMEOUT,
(timeout + 999) / 1000);
}
if(!result)
result = set_numeric(data, connssl->handle, GSK_FD, conn->sock[sockindex]);
if(!result)
result = set_ciphers(data, connssl->handle, &protoflags);
if(!protoflags) {
failf(data, "No SSL protocol/cipher combination enabled");
result = CURLE_SSL_CIPHER;
}
if(!result)
result = set_enum(data, connssl->handle, GSK_PROTOCOL_SSLV2,
(protoflags & CURL_GSKPROTO_SSLV2_MASK)?
GSK_PROTOCOL_SSLV2_ON: GSK_PROTOCOL_SSLV2_OFF, FALSE);
if(!result)
result = set_enum(data, connssl->handle, GSK_PROTOCOL_SSLV3,
(protoflags & CURL_GSKPROTO_SSLV3_MASK)?
GSK_PROTOCOL_SSLV3_ON: GSK_PROTOCOL_SSLV3_OFF, FALSE);
if(!result)
result = set_enum(data, connssl->handle, GSK_PROTOCOL_TLSV1,
(protoflags & CURL_GSKPROTO_TLSV10_MASK)?
GSK_PROTOCOL_TLSV1_ON: GSK_PROTOCOL_TLSV1_OFF, FALSE);
if(!result) {
result = set_enum(data, connssl->handle, GSK_PROTOCOL_TLSV11,
(protoflags & CURL_GSKPROTO_TLSV11_MASK)?
GSK_TRUE: GSK_FALSE, TRUE);
if(result == CURLE_UNSUPPORTED_PROTOCOL) {
result = CURLE_OK;
if(protoflags == CURL_GSKPROTO_TLSV11_MASK) {
failf(data, "TLS 1.1 not yet supported");
result = CURLE_SSL_CIPHER;
}
}
}
if(!result) {
result = set_enum(data, connssl->handle, GSK_PROTOCOL_TLSV12,
(protoflags & CURL_GSKPROTO_TLSV12_MASK)?
GSK_TRUE: GSK_FALSE, TRUE);
if(result == CURLE_UNSUPPORTED_PROTOCOL) {
result = CURLE_OK;
if(protoflags == CURL_GSKPROTO_TLSV12_MASK) {
failf(data, "TLS 1.2 not yet supported");
result = CURLE_SSL_CIPHER;
}
}
}
if(!result)
result = set_enum(data, connssl->handle, GSK_SERVER_AUTH_TYPE,
data->set.ssl.verifypeer? GSK_SERVER_AUTH_FULL:
GSK_SERVER_AUTH_PASSTHRU, FALSE);
if(!result) {
/* Start handshake. Try asynchronous first. */
memset(&commarea, 0, sizeof commarea);
connssl->iocport = QsoCreateIOCompletionPort();
if(connssl->iocport != -1) {
result = gskit_status(data,
gsk_secure_soc_startInit(connssl->handle,
connssl->iocport,
&commarea),
"gsk_secure_soc_startInit()",
CURLE_SSL_CONNECT_ERROR);
if(!result) {
connssl->connecting_state = ssl_connect_2;
return CURLE_OK;
}
else
close_async_handshake(connssl);
}
else if(errno != ENOBUFS)
result = gskit_status(data, GSK_ERROR_IO,
"QsoCreateIOCompletionPort()", 0);
else {
/* No more completion port available. Use synchronous IO. */
result = gskit_status(data, gsk_secure_soc_init(connssl->handle),
"gsk_secure_soc_init()", CURLE_SSL_CONNECT_ERROR);
if(!result) {
connssl->connecting_state = ssl_connect_3;
return CURLE_OK;
}
}
}
/* Error: rollback. */
close_one(connssl, data);
return result;
}
int main()
{
init_environment();
init_data();
init_display();
cuss::interface i_editor;
Window w_editor(0, 0, 80, 24);
if (!i_editor.load_from_file("cuss/i_element_ed.cuss")) {
debugmsg("Can't load cuss/i_element_ed.cuss");
end_display();
return 1;
}
std::vector<std::string> element_names;
std::vector<std::string> transform_names;
std::vector<std::string> damage_names;
i_editor.ref_data("list_elements", &element_names);
i_editor.ref_data("list_transformations", &transform_names);
i_editor.ref_data("list_damagetypes", &damage_names);
i_editor.select ("list_elements");
bool quit = false;
while (!quit) {
element_names = get_names();
cuss::element* selected = i_editor.selected();
int ele_num = i_editor.get_int("list_elements");
element* cur_element = NULL;
if (ele_num < ELEMENTS_POOL.size()) {
cur_element = &(ELEMENTS_POOL[ele_num]);
std::stringstream color_data;
color_data << "<c=" << color_tag_name(cur_element->color) <<
">************<c=/>";
i_editor.set_data("text_color", color_data.str());
i_editor.ref_data("entry_name", &(cur_element->name));
}
transform_names = get_tra_names(cur_element);
damage_names = get_dmg_names(cur_element);
i_editor.draw(&w_editor);
long ch = getch();
if (selected->name == "entry_name" &&
((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == ' ')) {
cur_element->name += ch;
} else if (selected->name == "entry_name" && is_backspace(ch) &&
!cur_element->name.empty()) {
cur_element->name =
cur_element->name.substr( 0, cur_element->name.length() - 1);
} else if (ch == 's' || ch == 'S') {
quit = true;
} else if (ch == 'c' || ch == 'C') {
change_color(cur_element);
} else if (ch == 'a' || ch == 'A') {
// Where are we adding an element?
if (selected->name == "list_elements") {
element tmp;
tmp.name = string_input_popup("Name:");
ELEMENTS_POOL.push_back(tmp);
i_editor.set_data("list_elements", 999);
} else if (selected->name == "list_transformations") {
add_transformation(cur_element);
i_editor.set_data("list_transformations", 0);
} else if (selected->name == "list_damagetypes") {
add_damagetype(cur_element);
i_editor.set_data("list_damagetypes", 0);
}
} else if (ch == 'd' || ch == 'D') {
// Where are we deleting an element?
if (selected->name == "list_elements" && cur_element) {
delete_element(ele_num);
i_editor.set_data("list_elements", 0);
} else if (selected->name == "list_transformations") {
int index = i_editor.get_int("list_transformations");
if (cur_element && index >= 0 &&
index < cur_element->transformations.size()) {
delete_transformation(cur_element, index);
i_editor.set_data("list_transformations", 0);
}
} else if (selected->name == "list_damagetypes") {
int index = i_editor.get_int("list_damagetypes");
if (cur_element && index >= 0 &&
index < cur_element->damages.size()) {
delete_damagetype(cur_element, index);
i_editor.set_data("list_damagetypes", 0);
}
}
} else {
i_editor.handle_action(ch);
}
} // while (!quit)
save_data();
end_display();
return 0;
}
static CURLcode gskit_connect_step1(struct connectdata *conn, int sockindex)
{
struct Curl_easy *data = conn->data;
struct ssl_connect_data *connssl = &conn->ssl[sockindex];
gsk_handle envir;
CURLcode result;
int rc;
const char * const keyringfile = SSL_CONN_CONFIG(CAfile);
const char * const keyringpwd = SSL_SET_OPTION(key_passwd);
const char * const keyringlabel = SSL_SET_OPTION(cert);
const long int ssl_version = SSL_CONN_CONFIG(version);
const bool verifypeer = SSL_CONN_CONFIG(verifypeer);
const char * const hostname = SSL_IS_PROXY()? conn->http_proxy.host.name:
conn->host.name;
const char *sni;
unsigned int protoflags;
long timeout;
Qso_OverlappedIO_t commarea;
int sockpair[2];
static const int sobufsize = CURL_MAX_WRITE_SIZE;
/* Create SSL environment, start (preferably asynchronous) handshake. */
connssl->handle = (gsk_handle) NULL;
connssl->iocport = -1;
connssl->localfd = -1;
connssl->remotefd = -1;
/* GSKit supports two ways of specifying an SSL context: either by
* application identifier (that should have been defined at the system
* level) or by keyring file, password and certificate label.
* Local certificate name (CURLOPT_SSLCERT) is used to hold either the
* application identifier of the certificate label.
* Key password (CURLOPT_KEYPASSWD) holds the keyring password.
* It is not possible to have different keyrings for the CAs and the
* local certificate. We thus use the CA file (CURLOPT_CAINFO) to identify
* the keyring file.
* If no key password is given and the keyring is the system keyring,
* application identifier mode is tried first, as recommended in IBM doc.
*/
envir = (gsk_handle) NULL;
if(keyringlabel && *keyringlabel && !keyringpwd &&
!strcmp(keyringfile, CURL_CA_BUNDLE)) {
/* Try application identifier mode. */
init_environment(data, &envir, keyringlabel, (const char *) NULL,
(const char *) NULL, (const char *) NULL);
}
if(!envir) {
/* Use keyring mode. */
result = init_environment(data, &envir, (const char *) NULL,
keyringfile, keyringlabel, keyringpwd);
if(result)
return result;
}
/* Create secure session. */
result = gskit_status(data, gsk_secure_soc_open(envir, &connssl->handle),
"gsk_secure_soc_open()", CURLE_SSL_CONNECT_ERROR);
gsk_environment_close(&envir);
if(result)
return result;
/* Establish a pipelining socket pair for SSL over SSL. */
if(conn->proxy_ssl[sockindex].use) {
if(inetsocketpair(sockpair))
return CURLE_SSL_CONNECT_ERROR;
connssl->localfd = sockpair[0];
connssl->remotefd = sockpair[1];
setsockopt(connssl->localfd, SOL_SOCKET, SO_RCVBUF,
(void *) sobufsize, sizeof sobufsize);
setsockopt(connssl->remotefd, SOL_SOCKET, SO_RCVBUF,
(void *) sobufsize, sizeof sobufsize);
setsockopt(connssl->localfd, SOL_SOCKET, SO_SNDBUF,
(void *) sobufsize, sizeof sobufsize);
setsockopt(connssl->remotefd, SOL_SOCKET, SO_SNDBUF,
(void *) sobufsize, sizeof sobufsize);
curlx_nonblock(connssl->localfd, TRUE);
curlx_nonblock(connssl->remotefd, TRUE);
}
/* Determine which SSL/TLS version should be enabled. */
sni = hostname;
switch (ssl_version) {
case CURL_SSLVERSION_SSLv2:
protoflags = CURL_GSKPROTO_SSLV2_MASK;
sni = NULL;
break;
case CURL_SSLVERSION_SSLv3:
protoflags = CURL_GSKPROTO_SSLV3_MASK;
sni = NULL;
break;
case CURL_SSLVERSION_DEFAULT:
case CURL_SSLVERSION_TLSv1:
protoflags = CURL_GSKPROTO_TLSV10_MASK |
CURL_GSKPROTO_TLSV11_MASK | CURL_GSKPROTO_TLSV12_MASK;
break;
case CURL_SSLVERSION_TLSv1_0:
protoflags = CURL_GSKPROTO_TLSV10_MASK;
break;
case CURL_SSLVERSION_TLSv1_1:
protoflags = CURL_GSKPROTO_TLSV11_MASK;
break;
case CURL_SSLVERSION_TLSv1_2:
protoflags = CURL_GSKPROTO_TLSV12_MASK;
break;
case CURL_SSLVERSION_TLSv1_3:
failf(data, "GSKit: TLS 1.3 is not yet supported");
return CURLE_SSL_CONNECT_ERROR;
default:
failf(data, "Unrecognized parameter passed via CURLOPT_SSLVERSION");
return CURLE_SSL_CONNECT_ERROR;
}
/* Process SNI. Ignore if not supported (on OS400 < V7R1). */
if(sni) {
result = set_buffer(data, connssl->handle,
GSK_SSL_EXTN_SERVERNAME_REQUEST, sni, TRUE);
if(result == CURLE_UNSUPPORTED_PROTOCOL)
result = CURLE_OK;
}
/* Set session parameters. */
if(!result) {
/* Compute the handshake timeout. Since GSKit granularity is 1 second,
we round up the required value. */
timeout = Curl_timeleft(data, NULL, TRUE);
if(timeout < 0)
result = CURLE_OPERATION_TIMEDOUT;
else
result = set_numeric(data, connssl->handle, GSK_HANDSHAKE_TIMEOUT,
(timeout + 999) / 1000);
}
if(!result)
result = set_numeric(data, connssl->handle, GSK_OS400_READ_TIMEOUT, 1);
if(!result)
result = set_numeric(data, connssl->handle, GSK_FD, connssl->localfd >= 0?
connssl->localfd: conn->sock[sockindex]);
if(!result)
result = set_ciphers(conn, connssl->handle, &protoflags);
if(!protoflags) {
failf(data, "No SSL protocol/cipher combination enabled");
result = CURLE_SSL_CIPHER;
}
if(!result)
result = set_enum(data, connssl->handle, GSK_PROTOCOL_SSLV2,
(protoflags & CURL_GSKPROTO_SSLV2_MASK)?
GSK_PROTOCOL_SSLV2_ON: GSK_PROTOCOL_SSLV2_OFF, FALSE);
if(!result)
result = set_enum(data, connssl->handle, GSK_PROTOCOL_SSLV3,
(protoflags & CURL_GSKPROTO_SSLV3_MASK)?
GSK_PROTOCOL_SSLV3_ON: GSK_PROTOCOL_SSLV3_OFF, FALSE);
if(!result)
result = set_enum(data, connssl->handle, GSK_PROTOCOL_TLSV1,
(protoflags & CURL_GSKPROTO_TLSV10_MASK)?
GSK_PROTOCOL_TLSV1_ON: GSK_PROTOCOL_TLSV1_OFF, FALSE);
if(!result) {
result = set_enum(data, connssl->handle, GSK_PROTOCOL_TLSV11,
(protoflags & CURL_GSKPROTO_TLSV11_MASK)?
GSK_TRUE: GSK_FALSE, TRUE);
if(result == CURLE_UNSUPPORTED_PROTOCOL) {
result = CURLE_OK;
if(protoflags == CURL_GSKPROTO_TLSV11_MASK) {
failf(data, "TLS 1.1 not yet supported");
result = CURLE_SSL_CIPHER;
}
}
}
if(!result) {
result = set_enum(data, connssl->handle, GSK_PROTOCOL_TLSV12,
(protoflags & CURL_GSKPROTO_TLSV12_MASK)?
GSK_TRUE: GSK_FALSE, TRUE);
if(result == CURLE_UNSUPPORTED_PROTOCOL) {
result = CURLE_OK;
if(protoflags == CURL_GSKPROTO_TLSV12_MASK) {
failf(data, "TLS 1.2 not yet supported");
result = CURLE_SSL_CIPHER;
}
}
}
if(!result)
result = set_enum(data, connssl->handle, GSK_SERVER_AUTH_TYPE,
verifypeer? GSK_SERVER_AUTH_FULL:
GSK_SERVER_AUTH_PASSTHRU, FALSE);
if(!result) {
/* Start handshake. Try asynchronous first. */
memset(&commarea, 0, sizeof commarea);
connssl->iocport = QsoCreateIOCompletionPort();
if(connssl->iocport != -1) {
result = gskit_status(data,
gsk_secure_soc_startInit(connssl->handle,
connssl->iocport,
&commarea),
"gsk_secure_soc_startInit()",
CURLE_SSL_CONNECT_ERROR);
if(!result) {
connssl->connecting_state = ssl_connect_2;
return CURLE_OK;
}
else
close_async_handshake(connssl);
}
else if(errno != ENOBUFS)
result = gskit_status(data, GSK_ERROR_IO,
"QsoCreateIOCompletionPort()", 0);
else if(conn->proxy_ssl[sockindex].use) {
/* Cannot pipeline while handshaking synchronously. */
result = CURLE_SSL_CONNECT_ERROR;
}
else {
/* No more completion port available. Use synchronous IO. */
result = gskit_status(data, gsk_secure_soc_init(connssl->handle),
"gsk_secure_soc_init()", CURLE_SSL_CONNECT_ERROR);
if(!result) {
connssl->connecting_state = ssl_connect_3;
return CURLE_OK;
}
}
}
/* Error: rollback. */
close_one(connssl, conn, sockindex);
return result;
}
int
main(int argc, char *argv[]) {
IxpMsg m;
char **oargv;
char *wmiirc, *s;
int i;
quotefmtinstall();
fmtinstall('r', errfmt);
fmtinstall('a', afmt);
fmtinstall('C', Cfmt);
extern int fmtevent(Fmt*);
fmtinstall('E', fmtevent);
wmiirc = "wmiirc";
oargv = argv;
ARGBEGIN{
case 'a':
address = EARGF(usage());
break;
case 'r':
wmiirc = EARGF(usage());
break;
case 'v':
print("%s", version);
exit(0);
case 'D':
s = EARGF(usage());
m = ixp_message(s, strlen(s), 0);
msg_debug(&m);
break;
default:
usage();
break;
}ARGEND;
if(argc)
usage();
setlocale(LC_CTYPE, "");
starting = true;
initdisplay();
traperrors(true);
selectinput(&scr.root, EnterWindowMask
| SubstructureRedirectMask);
if(traperrors(false))
fatal("another window manager is already running");
passwd = getpwuid(getuid());
user = estrdup(passwd->pw_name);
init_environment();
fmtinstall('F', Ffmt);
ixp_printfcall = printfcall;
sock = ixp_announce(address);
if(sock < 0)
fatal("Can't create socket '%s': %r", address);
closeexec(ConnectionNumber(display));
closeexec(sock);
if(wmiirc[0])
spawn_command(wmiirc);
init_traps();
init_cursors();
init_lock_keys();
ewmh_init();
xext_init();
srv.preselect = check_preselect;
ixp_listen(&srv, sock, &p9srv, serve_9pcon, nil);
ixp_listen(&srv, ConnectionNumber(display), nil, check_x_event, closedisplay);
def.border = 1;
def.colmode = Colstack;
def.font = loadfont(FONT);
def.incmode = ISqueeze;
def.mod = Mod1Mask;
strcpy(def.grabmod, "Mod1");
loadcolor(&def.focuscolor, FOCUSCOLORS);
loadcolor(&def.normcolor, NORMCOLORS);
disp.sel = pointerscreen();
init_screens();
root_init();
disp.focus = nil;
setfocus(screen->barwin, RevertToParent);
view_select("1");
scan_wins();
starting = false;
view_update_all();
ewmh_updateviews();
event("FocusTag %s\n", selview->name);
i = ixp_serverloop(&srv);
if(i)
fprint(2, "%s: error: %r\n", argv0);
else
event("Quit");
cleanup();
if(exitsignal)
raise(exitsignal);
if(execstr) {
char *toks[32];
int n;
n = unquote(strdup(execstr), toks, nelem(toks)-1);
toks[n] = nil;
execvp(toks[0], toks);
fprint(2, "%s: failed to exec %q: %r\n", argv0, execstr);
execvp(argv0, oargv);
fatal("failed to exec myself");
}
return i;
}
/*
* main()
* ARGUMENTS: Warehouses n [Debug] [Help]
*/
int
main(int argc, char **argv )
{
char arg[2];
time_t t_clock;
do_autocommit = 0;
count_ware=0;
for (i=1; i<argc; i++)
{
strncpy(arg, argv[i], 2);
if(arg[0] != '-')
{
i++;
continue;
}
switch (arg[1]) {
case 'w': /* Warehouses */
if (count_ware)
{
printf("Error - Warehouses specified more than once.\n");
exit(-1);
}
if (argc-1>i)
{
i++;
count_ware=atoi(argv[i]);
if (count_ware<=0)
{
printf("Invalid Warehouse Count.\n");
exit(-1);
}
}
else
{
printf("Error - Warehouse count must follow");
printf(" Warehouse keyword\n");
exit(-1);
}
break;
/******* Generic Args *********************/
case 'd': /* Debug Option */
if (option_debug)
{
printf("Error - Debug option specified more than once\n");
exit(-1);
}
option_debug=1;
break;
case 'h': /* Get the home directory for db */
if(argc - 1 > i)
{
i++;
home_dir = argv[i];
}
else
{
printf("Error: home directory name must follow -H keyword\n");
exit(-1);
}
break;
default : printf("Error - Unknown Argument (%s)\n",arg);
printf("Usage: %s -w <number of warehouses> -h <home dir> ", argv[0]);
printf("-d [Debug]\n");
exit(-1);
}
}
if (!(count_ware)) {
printf("Not enough arguments.\n");
printf("Usage: %s -w <number of warehouses> -h <home dir> ", argv[0]);
printf("-d [Debug]\n");
exit(-1);
}
if(home_dir == NULL)
{
printf("Not enough arguments.\n");
printf("Usage: %s -w <number of warehouses> -h <home dir> ", argv[0]);
printf("-d [Debug]\n");
exit(-1);
}
srandom( time( 0 ) );
/* Create the db environment */
if(init_environment(&db_env, home_dir, DB_PRIVATE /* non-default flags */))
{
exit(1);
}
/* Make sure that databases do not exist. */
if(databases_exist())
{
printf("Please remove all old databases before");
printf(" loading the new ones.\n");
exit(1);
}
/* Initialize timestamp (for date columns) */
if((int)time(&t_clock) == -1)
{
error("time");
exit(1);
}
timestamp = ctime(&t_clock);
assert(timestamp != NULL);
printf( "TPCC Data Load Started...\n" );
LoadItems();
LoadWare();
LoadCust();
LoadOrd();
printf( "\n...DATA LOADING COMPLETED SUCCESSFULLY.\n" );
return(0);
}
static CURLcode gskit_connect_step1(struct connectdata * conn, int sockindex)
{
struct SessionHandle * data = conn->data;
struct ssl_connect_data * connssl = &conn->ssl[sockindex];
gsk_handle envir;
CURLcode cc;
int rc;
char * keyringfile;
char * keyringpwd;
char * keyringlabel;
char * v2ciphers;
char * v3ciphers;
char * sni;
bool sslv2enable, sslv3enable, tlsv1enable;
long timeout;
Qso_OverlappedIO_t commarea;
/* Create SSL environment, start (preferably asynchronous) handshake. */
connssl->handle = (gsk_handle) NULL;
connssl->iocport = -1;
/* GSKit supports two ways of specifying an SSL context: either by
* application identifier (that should have been defined at the system
* level) or by keyring file, password and certificate label.
* Local certificate name (CURLOPT_SSLCERT) is used to hold either the
* application identifier of the certificate label.
* Key password (CURLOPT_KEYPASSWD) holds the keyring password.
* It is not possible to have different keyrings for the CAs and the
* local certificate. We thus use the CA file (CURLOPT_CAINFO) to identify
* the keyring file.
* If no key password is given and the keyring is the system keyring,
* application identifier mode is tried first, as recommended in IBM doc.
*/
keyringfile = data->set.str[STRING_SSL_CAFILE];
keyringpwd = data->set.str[STRING_KEY_PASSWD];
keyringlabel = data->set.str[STRING_CERT];
envir = (gsk_handle) NULL;
if(keyringlabel && *keyringlabel && !keyringpwd &&
!strcmp(keyringfile, CURL_CA_BUNDLE)) {
/* Try application identifier mode. */
init_environment(data, &envir, keyringlabel, (const char *) NULL,
(const char *) NULL, (const char *) NULL);
}
if(!envir) {
/* Use keyring mode. */
cc = init_environment(data, &envir, (const char *) NULL,
keyringfile, keyringlabel, keyringpwd);
if(cc != CURLE_OK)
return cc;
}
/* Create secure session. */
cc = gskit_status(data, gsk_secure_soc_open(envir, &connssl->handle),
"gsk_secure_soc_open()", CURLE_SSL_CONNECT_ERROR);
gsk_environment_close(&envir);
if(cc != CURLE_OK)
return cc;
/* Determine which SSL/TLS version should be enabled. */
sslv2enable = sslv3enable = tlsv1enable = false;
sni = conn->host.name;
switch (data->set.ssl.version) {
case CURL_SSLVERSION_SSLv2:
sslv2enable = true;
sni = (char *) NULL;
break;
case CURL_SSLVERSION_SSLv3:
sslv3enable = true;
sni = (char *) NULL;
break;
case CURL_SSLVERSION_TLSv1:
tlsv1enable = true;
break;
default: /* CURL_SSLVERSION_DEFAULT. */
sslv3enable = true;
tlsv1enable = true;
break;
}
/* Process SNI. Ignore if not supported (on OS400 < V7R1). */
if(sni) {
rc = gsk_attribute_set_buffer(connssl->handle,
GSK_SSL_EXTN_SERVERNAME_REQUEST, sni, 0);
switch (rc) {
case GSK_OK:
case GSK_ATTRIBUTE_INVALID_ID:
break;
case GSK_ERROR_IO:
failf(data, "gsk_attribute_set_buffer() I/O error: %s", strerror(errno));
cc = CURLE_SSL_CONNECT_ERROR;
break;
default:
failf(data, "gsk_attribute_set_buffer(): %s", gsk_strerror(rc));
cc = CURLE_SSL_CONNECT_ERROR;
break;
}
}
/* Set session parameters. */
if(cc == CURLE_OK) {
/* Compute the handshake timeout. Since GSKit granularity is 1 second,
we round up the required value. */
timeout = Curl_timeleft(data, NULL, TRUE);
if(timeout < 0)
cc = CURLE_OPERATION_TIMEDOUT;
else
cc = set_numeric(data, connssl->handle, GSK_HANDSHAKE_TIMEOUT,
(timeout + 999) / 1000);
}
if(cc == CURLE_OK)
cc = set_numeric(data, connssl->handle, GSK_FD, conn->sock[sockindex]);
if(cc == CURLE_OK)
cc = set_ciphers(data, connssl->handle);
if(cc == CURLE_OK)
cc = set_enum(data, connssl->handle, GSK_PROTOCOL_SSLV2,
sslv2enable? GSK_PROTOCOL_SSLV2_ON:
GSK_PROTOCOL_SSLV2_OFF);
if(cc == CURLE_OK)
cc = set_enum(data, connssl->handle, GSK_PROTOCOL_SSLV3,
sslv3enable? GSK_PROTOCOL_SSLV3_ON:
GSK_PROTOCOL_SSLV3_OFF);
if(cc == CURLE_OK)
cc = set_enum(data, connssl->handle, GSK_PROTOCOL_TLSV1,
sslv3enable? GSK_PROTOCOL_TLSV1_ON:
GSK_PROTOCOL_TLSV1_OFF);
if(cc == CURLE_OK)
cc = set_enum(data, connssl->handle, GSK_SERVER_AUTH_TYPE,
data->set.ssl.verifypeer? GSK_SERVER_AUTH_FULL:
GSK_SERVER_AUTH_PASSTHRU);
if(cc == CURLE_OK) {
/* Start handshake. Try asynchronous first. */
memset(&commarea, 0, sizeof commarea);
connssl->iocport = QsoCreateIOCompletionPort();
if(connssl->iocport != -1) {
cc = gskit_status(data, gsk_secure_soc_startInit(connssl->handle,
connssl->iocport, &commarea),
"gsk_secure_soc_startInit()", CURLE_SSL_CONNECT_ERROR);
if(cc == CURLE_OK) {
connssl->connecting_state = ssl_connect_2;
return CURLE_OK;
}
else
close_async_handshake(connssl);
}
else if(errno != ENOBUFS)
cc = gskit_status(data, GSK_ERROR_IO, "QsoCreateIOCompletionPort()", 0);
else {
/* No more completion port available. Use synchronous IO. */
cc = gskit_status(data, gsk_secure_soc_init(connssl->handle),
"gsk_secure_soc_init()", CURLE_SSL_CONNECT_ERROR);
if(cc == CURLE_OK) {
connssl->connecting_state = ssl_connect_3;
return CURLE_OK;
}
}
}
/* Error: rollback. */
close_one(connssl, data);
return cc;
}
int
calc_performance_one_environment(int* chrom)
/* Environment is randomly generated. Chrom is run on
* environment for NUM_MOVES. Function returns number of performance points the chromosome
* gets. */
{
int site, move_number, action, performance_points = 0;
int n_row, n_column, s_row, s_column, e_row, e_column, w_row, w_column, c_row, c_column;
double robby_text_row_coord, robby_text_column_coord; /* Where to draw robby */
int state, smaller_state;
init_environment();
/* Keep going for NUM_MOVES. Performance is how many cans were
* collected. */
for (move_number = 1; move_number <= NUM_MOVES; move_number++) {
#if DEBUG
printf("Move: %d\n", move_number);
#endif
state = 0;
/* Calculate integer representing state of neighborhood NSEWC. It is in [0, 242].
The contents of each of these five cells is represented by: EMPTY = 0, CAN = 1, WALL = 2 */
/* NORTH */
n_row = environment[robby_row][robby_column].N_row;
n_column = environment[robby_row][robby_column].N_column;
if (((n_row < 0) || (n_row >= NUM_ENVIRONMENT_ROWS))
|| ((n_column < 0) || (n_column >= NUM_ENVIRONMENT_COLUMNS)))
state = state + NORTH_BASE * WALL ; /* NORTH is a wall */
else
if (environment[n_row][n_column].contains_soda_can)
state = state + NORTH_BASE * CAN; /* NORTH cell has a can */
else
state = state + NORTH_BASE * EMPTY; /* NORTH cell is empty */
#if DEBUG
printf("After north, state is %d\n", state);
#endif
/* SOUTH */
s_row = environment[robby_row][robby_column].S_row;
s_column = environment[robby_row][robby_column].S_column;
if (((s_row < 0) || (s_row >= NUM_ENVIRONMENT_ROWS))
|| ((s_column < 0) || (s_column >= NUM_ENVIRONMENT_COLUMNS)))
state = state + SOUTH_BASE * WALL; /* SOUTH is a wall */
else
if (environment[s_row][s_column].contains_soda_can)
state = state + SOUTH_BASE * CAN; /* SOUTH cell has a can */
else
state = state + SOUTH_BASE * EMPTY; /* SOUTH cell is empty */
#if DEBUG
printf("After south, state is %d\n", state);
#endif
/* EAST */
e_row = environment[robby_row][robby_column].E_row;
e_column = environment[robby_row][robby_column].E_column;
if (((e_row < 0) || (e_row >= NUM_ENVIRONMENT_ROWS))
|| ((e_column < 0) || (e_column >= NUM_ENVIRONMENT_COLUMNS)))
state = state + EAST_BASE * WALL; /* EAST is a wall */
else
if (environment[e_row][e_column].contains_soda_can)
state = state + EAST_BASE * CAN; /* EAST cell has a can */
else
state = state + EAST_BASE * EMPTY; /* EAST cell is empty */
#if DEBUG
printf("After east, state is %d\n", state);
#endif
/* WEST */
w_row = environment[robby_row][robby_column].W_row;
w_column = environment[robby_row][robby_column].W_column;
if (((w_row < 0) || (w_row >= NUM_ENVIRONMENT_ROWS))
|| ((w_column < 0) || (w_column >= NUM_ENVIRONMENT_COLUMNS)))
state = state + WEST_BASE * WALL; /* WEST is a wall */
else
if (environment[w_row][w_column].contains_soda_can)
state = state + WEST_BASE * CAN; /* WEST cell has a can */
else
state = state + WEST_BASE * EMPTY; /* WEST cell is empty */
#if DEBUG
printf("After west, state is %d\n", state);
#endif
/* CENTER */
c_row = environment[robby_row][robby_column].C_row;
c_column = environment[robby_row][robby_column].C_column;
/* Skip test for wall, since center cell is not a wall. */
if (environment[c_row][c_column].contains_soda_can)
state = state + CAN; /* CENTER cell has a can */
else
state = state + EMPTY; /* CENTER cell is empty */
#if DEBUG
printf("After center, state is %d\n", state);
#endif
action = chrom[state];
#if DEBUG
printf("Action is %d\n", action);
#endif
/* Perform action corresponding to state */
#if DEBUG
printf("Before perform action: current performance points: %d\n", performance_points);
#endif
performance_points = performance_points + perform_action(action);
#if DEBUG
printf("After perform action: current performance points: %d\n", performance_points);
#endif
}
#if DEBUG
printf("Performance: %d\n", performance_points);
#endif
return (performance_points);
}
int main()
{
init_environment();
init_data();
init_display();
cuss::interface i_editor;
Window w_editor(0, 0, 80, 24);
if (!i_editor.load_from_file("cuss/i_terrain.cuss")) {
debugmsg("Couldn't load cuss/i_terrain.cuss!");
end_display();
return 1;
}
std::vector<std::string> type_names;
std::vector<std::string> flags;
std::vector<std::string> transformations;
i_editor.ref_data("list_types", &type_names);
i_editor.ref_data("list_flags", &flags);
i_editor.ref_data("list_transformations", &transformations);
i_editor.select("list_types");
for (int i = 0; i < TER_MAX; i++) {
if (i >= TERRAIN_POOL.size() || TERRAIN_POOL[i] == NULL) {
TERRAIN_POOL.push_back( new terrain_type );
TERRAIN_POOL[i]->name = default_terrain_name( terrain_id(i) );
}
}
// Main loop
bool quit = false;
do {
type_names = get_names();
cuss::element* selected = i_editor.selected();
int ter_num = i_editor.get_int("list_types");
terrain_type* current_ter = NULL;
if (ter_num < TERRAIN_POOL.size()) {
current_ter = TERRAIN_POOL[ i_editor.get_int("list_types") ];
flags = get_flag_names(current_ter);
transformations = get_transformation_names(current_ter);
i_editor.ref_data("num_move", &(current_ter->move_cost));
i_editor.ref_data("num_sight", &(current_ter->sight_cost));
i_editor.ref_data("text_name", &(current_ter->name));
}
i_editor.draw(&w_editor);
long ch = getch();
if (selected->name == "text_name" &&
((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == ' ')) {
current_ter->name += ch;
} else if (selected->name == "text_name" && is_backspace(ch) &&
!current_ter->name.empty()) {
current_ter->name =
current_ter->name.substr(0, current_ter->name.length() - 1);
} else if (ch == 's' || ch == 'S') {
quit = true;
} else if (ch == 'c' || ch == 'C') {
set_symbol(current_ter);
} else if (ch == 'a' || ch == 'A') {
if (selected->name == "list_types") {
terrain_type *tmp = new terrain_type;
tmp->move_cost = 10;
tmp->name = string_input_popup("Name:");
set_symbol(tmp);
TERRAIN_POOL.push_back(tmp);
i_editor.set_data("list_types", 999);
} else if (selected->name == "list_flags") {
add_flag(current_ter);
i_editor.set_data("list_flags", 0);
} else if (selected->name == "list_transformations") {
add_transformation(current_ter);
i_editor.set_data("list_transformations", 0);
}
} else if (ch == 'd' || ch == 'D') {
if (selected->name == "list_flags") {
int index = i_editor.get_int("list_flags");
if (index < flags.size()) {
remove_flag(current_ter, index);
i_editor.set_data("list_flags", 0);
}
} else if (selected->name == "list_transformations") {
int index = i_editor.get_int("list_transformations");
if (index < transformations.size()) {
remove_transformation(current_ter, index);
i_editor.set_data("list_transformations", 0);
}
}
} else if (ch == '?') {
debugmsg("%d of %d", i_editor.get_int("list_transformations"),
transformations.size());
debugmsg("%d (\\n = %d", TERRAIN_POOL[1]->name[0], '\n');
} else {
i_editor.handle_action(ch);
}
} while (!quit);
save_data();
end_display();
return 0;
}
void
hastd_secondary(struct hast_resource *res, struct nv *nvin)
{
sigset_t mask;
pthread_t td;
pid_t pid;
int error, mode, debuglevel;
/*
* Create communication channel between parent and child.
*/
if (proto_client(NULL, "socketpair://", &res->hr_ctrl) < 0) {
KEEP_ERRNO((void)pidfile_remove(pfh));
pjdlog_exit(EX_OSERR,
"Unable to create control sockets between parent and child");
}
/*
* Create communication channel between child and parent.
*/
if (proto_client(NULL, "socketpair://", &res->hr_event) < 0) {
KEEP_ERRNO((void)pidfile_remove(pfh));
pjdlog_exit(EX_OSERR,
"Unable to create event sockets between child and parent");
}
pid = fork();
if (pid < 0) {
KEEP_ERRNO((void)pidfile_remove(pfh));
pjdlog_exit(EX_OSERR, "Unable to fork");
}
if (pid > 0) {
/* This is parent. */
proto_close(res->hr_remotein);
res->hr_remotein = NULL;
proto_close(res->hr_remoteout);
res->hr_remoteout = NULL;
/* Declare that we are receiver. */
proto_recv(res->hr_event, NULL, 0);
/* Declare that we are sender. */
proto_send(res->hr_ctrl, NULL, 0);
res->hr_workerpid = pid;
return;
}
gres = res;
mode = pjdlog_mode_get();
debuglevel = pjdlog_debug_get();
/* Declare that we are sender. */
proto_send(res->hr_event, NULL, 0);
/* Declare that we are receiver. */
proto_recv(res->hr_ctrl, NULL, 0);
descriptors_cleanup(res);
descriptors_assert(res, mode);
pjdlog_init(mode);
pjdlog_debug_set(debuglevel);
pjdlog_prefix_set("[%s] (%s) ", res->hr_name, role2str(res->hr_role));
setproctitle("%s (%s)", res->hr_name, role2str(res->hr_role));
PJDLOG_VERIFY(sigemptyset(&mask) == 0);
PJDLOG_VERIFY(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
/* Error in setting timeout is not critical, but why should it fail? */
if (proto_timeout(res->hr_remotein, 2 * HAST_KEEPALIVE) < 0)
pjdlog_errno(LOG_WARNING, "Unable to set connection timeout");
if (proto_timeout(res->hr_remoteout, res->hr_timeout) < 0)
pjdlog_errno(LOG_WARNING, "Unable to set connection timeout");
init_local(res);
init_environment();
if (drop_privs(res) != 0)
exit(EX_CONFIG);
pjdlog_info("Privileges successfully dropped.");
/*
* Create the control thread before sending any event to the parent,
* as we can deadlock when parent sends control request to worker,
* but worker has no control thread started yet, so parent waits.
* In the meantime worker sends an event to the parent, but parent
* is unable to handle the event, because it waits for control
* request response.
*/
error = pthread_create(&td, NULL, ctrl_thread, res);
PJDLOG_ASSERT(error == 0);
init_remote(res, nvin);
event_send(res, EVENT_CONNECT);
error = pthread_create(&td, NULL, recv_thread, res);
PJDLOG_ASSERT(error == 0);
error = pthread_create(&td, NULL, disk_thread, res);
PJDLOG_ASSERT(error == 0);
(void)send_thread(res);
}
/**
* main replayer method
*/
static void start(int option, int argc, char* argv[], char** envp)
{
pid_t pid;
int status, fake_argc;
if (option == RECORD) {
copy_executable(argv[2]);
if (access(__executable, X_OK)) {
printf("The specified file '%s' does not exist or is not executable\n", __executable);
return;
}
/* create directory for trace files */
setup_trace_dir(0);
/* initialize trace files */
open_trace_files();
init_trace_files();
copy_argv(argc, argv);
copy_envp(envp);
record_argv_envp(argc, __argv, __envp);
close_trace_files();
pid = sys_fork();
/* child process */
if (pid == 0) {
sys_start_trace(__executable, __argv, __envp);
/* parent process */
} else {
child = pid;
/* make sure that the child process dies when the master process gets interrupted */
install_signal_handler();
/* sync with the child process */
sys_waitpid(pid, &status);
/* configure the child process to get a message upon a thread start, fork(), etc. */
sys_ptrace_setup(pid);
/* initialize stuff */
init_libpfm();
/* initialize the trace file here -- we need to record argc and envp */
open_trace_files();
/* register thread at the scheduler and start the HPC */
rec_sched_register_thread(0, pid);
/* perform the action recording */
fprintf(stderr, "start recording...\n");
start_recording();
fprintf(stderr, "done recording -- cleaning up\n");
/* cleanup all initialized data-structures */
close_trace_files();
close_libpfm();
}
/* replayer code comes here */
} else if (option == REPLAY) {
init_environment(argv[2], &fake_argc, __argv, __envp);
copy_executable(__argv[0]);
if (access(__executable, X_OK)) {
printf("The specified file '%s' does not exist or is not executable\n", __executable);
return;
}
pid = sys_fork();
//child process
if (pid == 0) {
sys_start_trace(__executable, __argv, __envp);
/* parent process */
} else {
child = pid;
/* make sure that the child process dies when the master process gets interrupted */
install_signal_handler();
sys_waitpid(pid, &status);
sys_ptrace_setup(pid);
/* initialize stuff */
init_libpfm();
rep_sched_init();
/* sets the file pointer to the first trace entry */
read_trace_init(argv[2]);
pid_t rec_main_thread = get_recorded_main_thread();
rep_sched_register_thread(pid, rec_main_thread);
/* main loop */
replay();
/* thread wants to exit*/
close_libpfm();
read_trace_close();
rep_sched_close();
}
}
}
int
main(int argc, char *argv[]) {
char *wmiirc;
WMScreen *s;
WinAttr wa;
int i;
fmtinstall('r', errfmt);
fmtinstall('C', Cfmt);
wmiirc = "wmiistartrc";
ARGBEGIN{
case 'v':
print("%s", version);
exit(0);
case 'V':
verbose = True;
break;
case 'a':
address = EARGF(usage());
break;
case 'r':
wmiirc = EARGF(usage());
break;
default:
usage();
break;
}ARGEND;
if(argc)
usage();
setlocale(LC_CTYPE, "");
starting = True;
initdisplay();
xlib_errorhandler = XSetErrorHandler(errorhandler);
check_other_wm = True;
XSelectInput(display, scr.root.w,
SubstructureRedirectMask
| EnterWindowMask);
XSync(display, False);
check_other_wm = False;
passwd = getpwuid(getuid());
user = estrdup(passwd->pw_name);
init_environment();
sock = ixp_announce(address);
if(sock < 0)
fatal("Can't create socket '%s': %r", address);
if(wmiirc)
spawn_command(wmiirc);
init_traps();
init_atoms();
init_cursors();
init_lock_keys();
srv.preselect = check_preselect;
ixp_listen(&srv, sock, &p9srv, serve_9pcon, nil);
ixp_listen(&srv, ConnectionNumber(display), nil, check_x_event, closedisplay);
def.font = loadfont(FONT);
def.border = 1;
def.colmode = Coldefault;
def.mod = Mod1Mask;
strcpy(def.grabmod, "Mod1");
loadcolor(&def.focuscolor, FOCUSCOLORS);
loadcolor(&def.normcolor, NORMCOLORS);
num_screens = 1;
screens = emallocz(num_screens * sizeof(*screens));
screen = &screens[0];
for(i = 0; i < num_screens; i++) {
s = &screens[i];
init_screen(s);
s->ibuf = allocimage(Dx(s->r), Dy(s->r), scr.depth);
wa.event_mask =
SubstructureRedirectMask
| SubstructureNotifyMask
| EnterWindowMask
| LeaveWindowMask
| FocusChangeMask;
wa.cursor = cursor[CurNormal];
setwinattr(&scr.root, &wa,
CWEventMask
| CWCursor);
initbar(s);
}
screen->focus = nil;
setfocus(screen->barwin, RevertToParent);
scan_wins();
starting = False;
select_view("nil");
update_views();
write_event("FocusTag %s\n", screen->sel->name);
check_x_event(nil);
i = ixp_serverloop(&srv);
if(i)
fprint(2, "%s: error: %r\n", argv0);
cleanup();
if(exitsignal)
raise(exitsignal);
if(execstr)
execl("/bin/sh", "sh", "-c", execstr, nil);
return i;
}