HANDLE *handle_get_events(int *nevents)
{
HANDLE *ret;
struct handle *h;
int i, n, size;
/*
* Go through our tree counting the handle objects currently
* engaged in useful activity.
*/
ret = NULL;
n = size = 0;
if (handles_by_evtomain) {
for (i = 0; (h = index234(handles_by_evtomain, i)) != NULL; i++) {
if (h->u.g.busy) {
if (n >= size) {
size += 32;
ret = sresize(ret, size, HANDLE);
}
ret[n++] = h->u.g.ev_to_main;
}
}
}
*nevents = n;
return ret;
}
void cygterm_setup_config_box(struct controlbox *b, int midsession)
{
union control *c;
int i;
if( !CygTermFlag ) return ;
struct controlset *s;
s = ctrl_getset(b, "Session", "hostport",
"Specify the destination you want to connect to");
for (i = 0; i < s->ncontrols; i++) {
c = s->ctrls[i];
if (c->generic.type == CTRL_RADIO &&
c->generic.handler == config_protocolbuttons_handler) {
c->radio.nbuttons++;
/* c->radio.ncolumns++; */
c->radio.buttons =
sresize(c->radio.buttons, c->radio.nbuttons, char *);
c->radio.buttons[c->radio.nbuttons-1] = dupstr("Cygterm");
c->radio.buttondata =
sresize(c->radio.buttondata, c->radio.nbuttons, intorptr);
c->radio.buttondata[c->radio.nbuttons-1] = I(PROT_CYGTERM);
if (c->radio.shortcuts) {
c->radio.shortcuts =
sresize(c->radio.shortcuts, c->radio.nbuttons, char);
c->radio.shortcuts[c->radio.nbuttons-1] = NO_SHORTCUT;
}
}
void edupd(int flg)
{
W *w;
int wid, hei;
if (dostaupd) {
staupd = 1;
dostaupd = 0;
}
ttgtsz(&wid, &hei);
if (nresize(maint->t, wid, hei)) {
sresize(maint);
#ifdef MOUSE_GPM
gpm_mx = wid;
gpm_my = hei;
#endif
}
dofollows();
ttflsh();
nscroll(maint->t, BG_COLOR(bg_text));
help_display(maint);
w = maint->curwin;
do {
if (w->y != -1) {
if (w->object && w->watom->disp)
w->watom->disp(w->object, flg);
msgout(w);
}
w = (W *) (w->link.next);
} while (w != maint->curwin);
cpos(maint->t, maint->curwin->x + maint->curwin->curx, maint->curwin->y + maint->curwin->cury);
staupd = 0;
}
void ser_setup_config_box(struct controlbox *b, int midsession,
int parity_mask, int flow_mask)
{
struct controlset *s;
union control *c;
if (!midsession) {
int i;
extern void config_protocolbuttons_handler(union control *, void *,
void *, int);
/*
* Add the serial back end to the protocols list at the
* top of the config box.
*/
s = ctrl_getset(b, "Session", "hostport",
"Specify the destination you want to connect to");
for (i = 0; i < s->ncontrols; i++) {
c = s->ctrls[i];
if (c->generic.type == CTRL_RADIO &&
c->generic.handler == config_protocolbuttons_handler) {
c->radio.nbuttons++;
c->radio.ncolumns++;
c->radio.buttons =
sresize(c->radio.buttons, c->radio.nbuttons, char *);
c->radio.buttons[c->radio.nbuttons-1] =
dupstr("Serial");
c->radio.buttondata =
sresize(c->radio.buttondata, c->radio.nbuttons, intorptr);
c->radio.buttondata[c->radio.nbuttons-1] = I(PROT_SERIAL);
if (c->radio.shortcuts) {
c->radio.shortcuts =
sresize(c->radio.shortcuts, c->radio.nbuttons, char);
c->radio.shortcuts[c->radio.nbuttons-1] = 'r';
}
}
void win_setup_config_box(struct controlbox *b, HWND *hwndp, int has_help,
int midsession, int protocol)
{
struct controlset *s;
union control *c;
char *str;
if (!midsession) {
/*
* Add the About and Help buttons to the standard panel.
*/
s = ctrl_getset(b, "", "", "");
c = ctrl_pushbutton(s, "About", 'a', HELPCTX(no_help),
about_handler, P(hwndp));
c->generic.column = 0;
if (has_help) {
c = ctrl_pushbutton(s, "Help", 'h', HELPCTX(no_help),
help_handler, P(hwndp));
c->generic.column = 1;
}
}
/*
* Full-screen mode is a Windows peculiarity; hence
* scrollbar_in_fullscreen is as well.
*/
s = ctrl_getset(b, "Window", "scrollback",
"Control the scrollback in the window");
ctrl_checkbox(s, "Display scrollbar in full screen mode", 'i',
HELPCTX(window_scrollback),
dlg_stdcheckbox_handler,
I(offsetof(Config,scrollbar_in_fullscreen)));
/*
* Really this wants to go just after `Display scrollbar'. See
* if we can find that control, and do some shuffling.
*/
{
int i;
for (i = 0; i < s->ncontrols; i++) {
c = s->ctrls[i];
if (c->generic.type == CTRL_CHECKBOX &&
c->generic.context.i == offsetof(Config,scrollbar)) {
/*
* Control i is the scrollbar checkbox.
* Control s->ncontrols-1 is the scrollbar-in-FS one.
*/
if (i < s->ncontrols-2) {
c = s->ctrls[s->ncontrols-1];
memmove(s->ctrls+i+2, s->ctrls+i+1,
(s->ncontrols-i-2)*sizeof(union control *));
s->ctrls[i+1] = c;
}
break;
}
}
}
/*
* Windows has the AltGr key, which has various Windows-
* specific options.
*/
s = ctrl_getset(b, "Terminal/Keyboard", "features",
"Enable extra keyboard features:");
ctrl_checkbox(s, "AltGr acts as Compose key", 't',
HELPCTX(keyboard_compose),
dlg_stdcheckbox_handler, I(offsetof(Config,compose_key)));
ctrl_checkbox(s, "Control-Alt is different from AltGr", 'd',
HELPCTX(keyboard_ctrlalt),
dlg_stdcheckbox_handler, I(offsetof(Config,ctrlaltkeys)));
/*
* Windows allows an arbitrary .WAV to be played as a bell, and
* also the use of the PC speaker. For this we must search the
* existing controlset for the radio-button set controlling the
* `beep' option, and add extra buttons to it.
*
* Note that although this _looks_ like a hideous hack, it's
* actually all above board. The well-defined interface to the
* per-platform dialog box code is the _data structures_ `union
* control', `struct controlset' and so on; so code like this
* that reaches into those data structures and changes bits of
* them is perfectly legitimate and crosses no boundaries. All
* the ctrl_* routines that create most of the controls are
* convenient shortcuts provided on the cross-platform side of
* the interface, and template creation code is under no actual
* obligation to use them.
*/
s = ctrl_getset(b, "Terminal/Bell", "style", "Set the style of bell");
{
int i;
for (i = 0; i < s->ncontrols; i++) {
c = s->ctrls[i];
if (c->generic.type == CTRL_RADIO &&
c->generic.context.i == offsetof(Config, beep)) {
assert(c->generic.handler == dlg_stdradiobutton_handler);
c->radio.nbuttons += 2;
c->radio.buttons =
sresize(c->radio.buttons, c->radio.nbuttons, char *);
c->radio.buttons[c->radio.nbuttons-1] =
dupstr("Play a custom sound file");
c->radio.buttons[c->radio.nbuttons-2] =
dupstr("Beep using the PC speaker");
c->radio.buttondata =
sresize(c->radio.buttondata, c->radio.nbuttons, intorptr);
c->radio.buttondata[c->radio.nbuttons-1] = I(BELL_WAVEFILE);
c->radio.buttondata[c->radio.nbuttons-2] = I(BELL_PCSPEAKER);
if (c->radio.shortcuts) {
c->radio.shortcuts =
sresize(c->radio.shortcuts, c->radio.nbuttons, char);
c->radio.shortcuts[c->radio.nbuttons-1] = NO_SHORTCUT;
c->radio.shortcuts[c->radio.nbuttons-2] = NO_SHORTCUT;
}
break;
}
}
int do_eventsel_loop(HANDLE other_event)
{
int n, nhandles, nallhandles, netindex, otherindex;
long next, ticks;
HANDLE *handles;
SOCKET *sklist;
int skcount;
long now = GETTICKCOUNT();
static int timeoutCount = 0;
if (sk_isClosed()) {
return -1;
}
if (run_timers(now, &next)) {
ticks = next - GETTICKCOUNT();
if (ticks < 0) ticks = 0; /* just in case */
} else {
ticks = INFINITE;
}
if (ticks < 0 || ticks > 100) ticks = 100;
handles = handle_get_events(&nhandles);
handles = sresize(handles, nhandles+2, HANDLE);
nallhandles = nhandles;
if (netevent != INVALID_HANDLE_VALUE)
handles[netindex = nallhandles++] = netevent;
else
netindex = -1;
if (other_event != INVALID_HANDLE_VALUE)
handles[otherindex = nallhandles++] = other_event;
else
otherindex = -1;
n = WaitForMultipleObjects(nallhandles, handles, FALSE, ticks);
if (STATUS_TIMEOUT == n) {
sfree(handles);
++timeoutCount;
return timeoutCount > 50 ? -1 : 0;
}
timeoutCount = 0;
if ((unsigned)(n - WAIT_OBJECT_0) < (unsigned)nhandles) {
handle_got_event(handles[n - WAIT_OBJECT_0]);
} else if (netindex >= 0 && n == WAIT_OBJECT_0 + netindex) {
WSANETWORKEVENTS things;
SOCKET socket;
extern SOCKET first_socket(int *), next_socket(int *);
extern int select_result(WPARAM, LPARAM);
int i, socketstate;
/*
* We must not call select_result() for any socket
* until we have finished enumerating within the
* tree. This is because select_result() may close
* the socket and modify the tree.
*/
/* Count the active sockets. */
i = 0;
for (socket = first_socket(&socketstate);
socket != INVALID_SOCKET;
socket = next_socket(&socketstate)) i++;
/* Expand the buffer if necessary. */
sklist = snewn(i, SOCKET);
/* Retrieve the sockets into sklist. */
skcount = 0;
for (socket = first_socket(&socketstate);
socket != INVALID_SOCKET;
socket = next_socket(&socketstate)) {
sklist[skcount++] = socket;
}
/* Now we're done enumerating; go through the list. */
for (i = 0; i < skcount; i++) {
WPARAM wp;
socket = sklist[i];
wp = (WPARAM) socket;
if (!p_WSAEnumNetworkEvents(socket, NULL, &things)) {
static const struct { int bit, mask; } eventtypes[] = {
{FD_CONNECT_BIT, FD_CONNECT},
{FD_READ_BIT, FD_READ},
{FD_CLOSE_BIT, FD_CLOSE},
{FD_OOB_BIT, FD_OOB},
{FD_WRITE_BIT, FD_WRITE},
{FD_ACCEPT_BIT, FD_ACCEPT},
};
int e;
noise_ultralight(socket);
noise_ultralight(things.lNetworkEvents);
for (e = 0; e < lenof(eventtypes); e++)
if (things.lNetworkEvents & eventtypes[e].mask) {
LPARAM lp;
int err = things.iErrorCode[eventtypes[e].bit];
lp = WSAMAKESELECTREPLY(eventtypes[e].mask, err);
select_result(wp, lp);
}
}
}
sfree(sklist);
}
sfree(handles);
if (n == WAIT_TIMEOUT) {
now = next;
} else {
now = GETTICKCOUNT();
}
if (otherindex >= 0 && n == WAIT_OBJECT_0 + otherindex)
return 1;
return 0;
}
int main(int argc, char **argv)
{
bool sending;
SOCKET *sklist;
size_t skcount, sksize;
int exitcode;
bool errors;
bool use_subsystem = false;
bool just_test_share_exists = false;
enum TriState sanitise_stdout = AUTO, sanitise_stderr = AUTO;
unsigned long now, next, then;
const struct BackendVtable *vt;
dll_hijacking_protection();
sklist = NULL;
skcount = sksize = 0;
/*
* Initialise port and protocol to sensible defaults. (These
* will be overridden by more or less anything.)
*/
default_protocol = PROT_SSH;
default_port = 22;
flags = 0;
cmdline_tooltype |=
(TOOLTYPE_HOST_ARG |
TOOLTYPE_HOST_ARG_CAN_BE_SESSION |
TOOLTYPE_HOST_ARG_PROTOCOL_PREFIX |
TOOLTYPE_HOST_ARG_FROM_LAUNCHABLE_LOAD);
/*
* Process the command line.
*/
conf = conf_new();
do_defaults(NULL, conf);
loaded_session = false;
default_protocol = conf_get_int(conf, CONF_protocol);
default_port = conf_get_int(conf, CONF_port);
errors = false;
{
/*
* Override the default protocol if PLINK_PROTOCOL is set.
*/
char *p = getenv("PLINK_PROTOCOL");
if (p) {
const struct BackendVtable *vt = backend_vt_from_name(p);
if (vt) {
default_protocol = vt->protocol;
default_port = vt->default_port;
conf_set_int(conf, CONF_protocol, default_protocol);
conf_set_int(conf, CONF_port, default_port);
}
}
}
while (--argc) {
char *p = *++argv;
int ret = cmdline_process_param(p, (argc > 1 ? argv[1] : NULL),
1, conf);
if (ret == -2) {
fprintf(stderr,
"plink: option \"%s\" requires an argument\n", p);
errors = true;
} else if (ret == 2) {
--argc, ++argv;
} else if (ret == 1) {
continue;
} else if (!strcmp(p, "-batch")) {
console_batch_mode = true;
} else if (!strcmp(p, "-s")) {
/* Save status to write to conf later. */
use_subsystem = true;
} else if (!strcmp(p, "-V") || !strcmp(p, "--version")) {
version();
} else if (!strcmp(p, "--help")) {
usage();
} else if (!strcmp(p, "-pgpfp")) {
pgp_fingerprints();
exit(1);
} else if (!strcmp(p, "-shareexists")) {
just_test_share_exists = true;
} else if (!strcmp(p, "-sanitise-stdout") ||
!strcmp(p, "-sanitize-stdout")) {
sanitise_stdout = FORCE_ON;
} else if (!strcmp(p, "-no-sanitise-stdout") ||
!strcmp(p, "-no-sanitize-stdout")) {
sanitise_stdout = FORCE_OFF;
} else if (!strcmp(p, "-sanitise-stderr") ||
!strcmp(p, "-sanitize-stderr")) {
sanitise_stderr = FORCE_ON;
} else if (!strcmp(p, "-no-sanitise-stderr") ||
!strcmp(p, "-no-sanitize-stderr")) {
sanitise_stderr = FORCE_OFF;
} else if (!strcmp(p, "-no-antispoof")) {
console_antispoof_prompt = false;
} else if (*p != '-') {
strbuf *cmdbuf = strbuf_new();
while (argc > 0) {
if (cmdbuf->len > 0)
put_byte(cmdbuf, ' '); /* add space separator */
put_datapl(cmdbuf, ptrlen_from_asciz(p));
if (--argc > 0)
p = *++argv;
}
conf_set_str(conf, CONF_remote_cmd, cmdbuf->s);
conf_set_str(conf, CONF_remote_cmd2, "");
conf_set_bool(conf, CONF_nopty, true); /* command => no tty */
strbuf_free(cmdbuf);
break; /* done with cmdline */
} else {
fprintf(stderr, "plink: unknown option \"%s\"\n", p);
errors = true;
}
}
if (errors)
return 1;
if (!cmdline_host_ok(conf)) {
usage();
}
prepare_session(conf);
/*
* Perform command-line overrides on session configuration.
*/
cmdline_run_saved(conf);
/*
* Apply subsystem status.
*/
if (use_subsystem)
conf_set_bool(conf, CONF_ssh_subsys, true);
if (!*conf_get_str(conf, CONF_remote_cmd) &&
!*conf_get_str(conf, CONF_remote_cmd2) &&
!*conf_get_str(conf, CONF_ssh_nc_host))
flags |= FLAG_INTERACTIVE;
/*
* Select protocol. This is farmed out into a table in a
* separate file to enable an ssh-free variant.
*/
vt = backend_vt_from_proto(conf_get_int(conf, CONF_protocol));
if (vt == NULL) {
fprintf(stderr,
"Internal fault: Unsupported protocol found\n");
return 1;
}
sk_init();
if (p_WSAEventSelect == NULL) {
fprintf(stderr, "Plink requires WinSock 2\n");
return 1;
}
/*
* Plink doesn't provide any way to add forwardings after the
* connection is set up, so if there are none now, we can safely set
* the "simple" flag.
*/
if (conf_get_int(conf, CONF_protocol) == PROT_SSH &&
!conf_get_bool(conf, CONF_x11_forward) &&
!conf_get_bool(conf, CONF_agentfwd) &&
!conf_get_str_nthstrkey(conf, CONF_portfwd, 0))
conf_set_bool(conf, CONF_ssh_simple, true);
logctx = log_init(default_logpolicy, conf);
if (just_test_share_exists) {
if (!vt->test_for_upstream) {
fprintf(stderr, "Connection sharing not supported for connection "
"type '%s'\n", vt->name);
return 1;
}
if (vt->test_for_upstream(conf_get_str(conf, CONF_host),
conf_get_int(conf, CONF_port), conf))
return 0;
else
return 1;
}
if (restricted_acl) {
lp_eventlog(default_logpolicy, "Running with restricted process ACL");
}
/*
* Start up the connection.
*/
netevent = CreateEvent(NULL, false, false, NULL);
{
const char *error;
char *realhost;
/* nodelay is only useful if stdin is a character device (console) */
bool nodelay = conf_get_bool(conf, CONF_tcp_nodelay) &&
(GetFileType(GetStdHandle(STD_INPUT_HANDLE)) == FILE_TYPE_CHAR);
error = backend_init(vt, plink_seat, &backend, logctx, conf,
conf_get_str(conf, CONF_host),
conf_get_int(conf, CONF_port),
&realhost, nodelay,
conf_get_bool(conf, CONF_tcp_keepalives));
if (error) {
fprintf(stderr, "Unable to open connection:\n%s", error);
return 1;
}
sfree(realhost);
}
inhandle = GetStdHandle(STD_INPUT_HANDLE);
outhandle = GetStdHandle(STD_OUTPUT_HANDLE);
errhandle = GetStdHandle(STD_ERROR_HANDLE);
/*
* Turn off ECHO and LINE input modes. We don't care if this
* call fails, because we know we aren't necessarily running in
* a console.
*/
GetConsoleMode(inhandle, &orig_console_mode);
SetConsoleMode(inhandle, ENABLE_PROCESSED_INPUT);
/*
* Pass the output handles to the handle-handling subsystem.
* (The input one we leave until we're through the
* authentication process.)
*/
stdout_handle = handle_output_new(outhandle, stdouterr_sent, NULL, 0);
stderr_handle = handle_output_new(errhandle, stdouterr_sent, NULL, 0);
handle_sink_init(&stdout_hs, stdout_handle);
handle_sink_init(&stderr_hs, stderr_handle);
stdout_bs = BinarySink_UPCAST(&stdout_hs);
stderr_bs = BinarySink_UPCAST(&stderr_hs);
/*
* Decide whether to sanitise control sequences out of standard
* output and standard error.
*
* If we weren't given a command-line override, we do this if (a)
* the fd in question is pointing at a console, and (b) we aren't
* trying to allocate a terminal as part of the session.
*
* (Rationale: the risk of control sequences is that they cause
* confusion when sent to a local console, so if there isn't one,
* no problem. Also, if we allocate a remote terminal, then we
* sent a terminal type, i.e. we told it what kind of escape
* sequences we _like_, i.e. we were expecting to receive some.)
*/
if (sanitise_stdout == FORCE_ON ||
(sanitise_stdout == AUTO && is_console_handle(outhandle) &&
conf_get_bool(conf, CONF_nopty))) {
stdout_scc = stripctrl_new(stdout_bs, true, L'\0');
stdout_bs = BinarySink_UPCAST(stdout_scc);
}
if (sanitise_stderr == FORCE_ON ||
(sanitise_stderr == AUTO && is_console_handle(errhandle) &&
conf_get_bool(conf, CONF_nopty))) {
stderr_scc = stripctrl_new(stderr_bs, true, L'\0');
stderr_bs = BinarySink_UPCAST(stderr_scc);
}
main_thread_id = GetCurrentThreadId();
sending = false;
now = GETTICKCOUNT();
while (1) {
int nhandles;
HANDLE *handles;
int n;
DWORD ticks;
if (!sending && backend_sendok(backend)) {
stdin_handle = handle_input_new(inhandle, stdin_gotdata, NULL,
0);
sending = true;
}
if (toplevel_callback_pending()) {
ticks = 0;
next = now;
} else if (run_timers(now, &next)) {
then = now;
now = GETTICKCOUNT();
if (now - then > next - then)
ticks = 0;
else
ticks = next - now;
} else {
ticks = INFINITE;
/* no need to initialise next here because we can never
* get WAIT_TIMEOUT */
}
handles = handle_get_events(&nhandles);
handles = sresize(handles, nhandles+1, HANDLE);
handles[nhandles] = netevent;
n = MsgWaitForMultipleObjects(nhandles+1, handles, false, ticks,
QS_POSTMESSAGE);
if ((unsigned)(n - WAIT_OBJECT_0) < (unsigned)nhandles) {
handle_got_event(handles[n - WAIT_OBJECT_0]);
} else if (n == WAIT_OBJECT_0 + nhandles) {
WSANETWORKEVENTS things;
SOCKET socket;
int i, socketstate;
/*
* We must not call select_result() for any socket
* until we have finished enumerating within the tree.
* This is because select_result() may close the socket
* and modify the tree.
*/
/* Count the active sockets. */
i = 0;
for (socket = first_socket(&socketstate);
socket != INVALID_SOCKET;
socket = next_socket(&socketstate)) i++;
/* Expand the buffer if necessary. */
sgrowarray(sklist, sksize, i);
/* Retrieve the sockets into sklist. */
skcount = 0;
for (socket = first_socket(&socketstate);
socket != INVALID_SOCKET;
socket = next_socket(&socketstate)) {
sklist[skcount++] = socket;
}
/* Now we're done enumerating; go through the list. */
for (i = 0; i < skcount; i++) {
WPARAM wp;
socket = sklist[i];
wp = (WPARAM) socket;
if (!p_WSAEnumNetworkEvents(socket, NULL, &things)) {
static const struct { int bit, mask; } eventtypes[] = {
{FD_CONNECT_BIT, FD_CONNECT},
{FD_READ_BIT, FD_READ},
{FD_CLOSE_BIT, FD_CLOSE},
{FD_OOB_BIT, FD_OOB},
{FD_WRITE_BIT, FD_WRITE},
{FD_ACCEPT_BIT, FD_ACCEPT},
};
int e;
noise_ultralight(NOISE_SOURCE_IOID, socket);
for (e = 0; e < lenof(eventtypes); e++)
if (things.lNetworkEvents & eventtypes[e].mask) {
LPARAM lp;
int err = things.iErrorCode[eventtypes[e].bit];
lp = WSAMAKESELECTREPLY(eventtypes[e].mask, err);
select_result(wp, lp);
}
}
}
} else if (n == WAIT_OBJECT_0 + nhandles + 1) {
MSG msg;
while (PeekMessage(&msg, INVALID_HANDLE_VALUE,
WM_AGENT_CALLBACK, WM_AGENT_CALLBACK,
PM_REMOVE)) {
struct agent_callback *c = (struct agent_callback *)msg.lParam;
c->callback(c->callback_ctx, c->data, c->len);
sfree(c);
}
}
run_toplevel_callbacks();
if (n == WAIT_TIMEOUT) {
now = next;
} else {
now = GETTICKCOUNT();
}
sfree(handles);
if (sending)
handle_unthrottle(stdin_handle, backend_sendbuffer(backend));
if (!backend_connected(backend) &&
handle_backlog(stdout_handle) + handle_backlog(stderr_handle) == 0)
break; /* we closed the connection */
}
exitcode = backend_exitcode(backend);
if (exitcode < 0) {
fprintf(stderr, "Remote process exit code unavailable\n");
exitcode = 1; /* this is an error condition */
}
cleanup_exit(exitcode);
return 0; /* placate compiler warning */
}
static textconfig text_configure(paragraph *source) {
textconfig ret;
paragraph *p;
int n;
/*
* Non-negotiables.
*/
ret.bullet.next = NULL;
ret.bullet.alt = NULL;
ret.bullet.type = word_Normal;
ret.atitle.just_numbers = FALSE; /* ignored */
ret.atitle.number_at_all = TRUE; /* ignored */
/*
* Defaults.
*/
ret.indent = 7;
ret.indent_code = 2;
ret.listindentbefore = 1;
ret.listindentafter = 3;
ret.width = 68;
ret.atitle.align = CENTRE;
ret.atitle.underline = L"\x2550\0=\0\0";
ret.achapter.align = LEFT;
ret.achapter.just_numbers = FALSE;
ret.achapter.number_at_all = TRUE;
ret.achapter.number_suffix = L": ";
ret.achapter.underline = L"\x203E\0-\0\0";
ret.nasect = 1;
ret.asect = snewn(ret.nasect, alignstruct);
ret.asect[0].align = LEFTPLUS;
ret.asect[0].just_numbers = TRUE;
ret.asect[0].number_at_all = TRUE;
ret.asect[0].number_suffix = L" ";
ret.asect[0].underline = L"\0";
ret.include_version_id = TRUE;
ret.indent_preambles = FALSE;
ret.bullet.text = L"\x2022\0-\0\0";
ret.rule = L"\x2500\0-\0\0";
ret.filename = dupstr("output.txt");
ret.startemph = L"_\0_\0\0";
ret.endemph = uadv(ret.startemph);
ret.startstrong = L"*\0*\0\0";
ret.endstrong = uadv(ret.startstrong);
ret.listsuffix = L".";
ret.charset = CS_ASCII;
/*
* Default quote characters are Unicode matched single quotes,
* falling back to the TeXlike `'.
*/
ret.lquote = L"\x2018\0\x2019\0`\0'\0\0";
ret.rquote = uadv(ret.lquote);
/*
* Two-pass configuration so that we can pick up global config
* (e.g. `quotes') before having it overridden by specific
* config (`text-quotes'), irrespective of the order in which
* they occur.
*/
for (p = source; p; p = p->next) {
if (p->type == para_Config) {
if (!ustricmp(p->keyword, L"quotes")) {
if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
ret.lquote = uadv(p->keyword);
ret.rquote = uadv(ret.lquote);
}
}
}
}
for (p = source; p; p = p->next) {
if (p->type == para_Config) {
if (!ustricmp(p->keyword, L"text-indent")) {
ret.indent = utoi(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-charset")) {
ret.charset = charset_from_ustr(&p->fpos, uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-filename")) {
sfree(ret.filename);
ret.filename = dupstr(adv(p->origkeyword));
} else if (!ustricmp(p->keyword, L"text-indent-code")) {
ret.indent_code = utoi(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-width")) {
ret.width = utoi(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-list-indent")) {
ret.listindentbefore = utoi(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-listitem-indent")) {
ret.listindentafter = utoi(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-chapter-align")) {
ret.achapter.align = utoalign(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-chapter-underline")) {
ret.achapter.underline = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-chapter-numeric")) {
ret.achapter.just_numbers = utob(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-chapter-shownumber")) {
ret.achapter.number_at_all = utob(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-chapter-suffix")) {
ret.achapter.number_suffix = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-section-align")) {
wchar_t *q = uadv(p->keyword);
int n = 0;
if (uisdigit(*q)) {
n = utoi(q);
q = uadv(q);
}
if (n >= ret.nasect) {
int i;
ret.asect = sresize(ret.asect, n+1, alignstruct);
for (i = ret.nasect; i <= n; i++)
ret.asect[i] = ret.asect[ret.nasect-1];
ret.nasect = n+1;
}
ret.asect[n].align = utoalign(q);
} else if (!ustricmp(p->keyword, L"text-section-underline")) {
wchar_t *q = uadv(p->keyword);
int n = 0;
if (uisdigit(*q)) {
n = utoi(q);
q = uadv(q);
}
if (n >= ret.nasect) {
int i;
ret.asect = sresize(ret.asect, n+1, alignstruct);
for (i = ret.nasect; i <= n; i++)
ret.asect[i] = ret.asect[ret.nasect-1];
ret.nasect = n+1;
}
ret.asect[n].underline = q;
} else if (!ustricmp(p->keyword, L"text-section-numeric")) {
wchar_t *q = uadv(p->keyword);
int n = 0;
if (uisdigit(*q)) {
n = utoi(q);
q = uadv(q);
}
if (n >= ret.nasect) {
int i;
ret.asect = sresize(ret.asect, n+1, alignstruct);
for (i = ret.nasect; i <= n; i++)
ret.asect[i] = ret.asect[ret.nasect-1];
ret.nasect = n+1;
}
ret.asect[n].just_numbers = utob(q);
} else if (!ustricmp(p->keyword, L"text-section-shownumber")) {
wchar_t *q = uadv(p->keyword);
int n = 0;
if (uisdigit(*q)) {
n = utoi(q);
q = uadv(q);
}
if (n >= ret.nasect) {
int i;
ret.asect = sresize(ret.asect, n+1, alignstruct);
for (i = ret.nasect; i <= n; i++)
ret.asect[i] = ret.asect[ret.nasect-1];
ret.nasect = n+1;
}
ret.asect[n].number_at_all = utob(q);
} else if (!ustricmp(p->keyword, L"text-section-suffix")) {
wchar_t *q = uadv(p->keyword);
int n = 0;
if (uisdigit(*q)) {
n = utoi(q);
q = uadv(q);
}
if (n >= ret.nasect) {
int i;
ret.asect = sresize(ret.asect, n+1, alignstruct);
for (i = ret.nasect; i <= n; i++) {
ret.asect[i] = ret.asect[ret.nasect-1];
}
ret.nasect = n+1;
}
ret.asect[n].number_suffix = q;
} else if (!ustricmp(p->keyword, L"text-title-align")) {
ret.atitle.align = utoalign(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-title-underline")) {
ret.atitle.underline = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-versionid")) {
ret.include_version_id = utob(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-indent-preamble")) {
ret.indent_preambles = utob(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-bullet")) {
ret.bullet.text = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-rule")) {
ret.rule = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-list-suffix")) {
ret.listsuffix = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-emphasis")) {
if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
ret.startemph = uadv(p->keyword);
ret.endemph = uadv(ret.startemph);
}
} else if (!ustricmp(p->keyword, L"text-strong")) {
if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
ret.startstrong = uadv(p->keyword);
ret.endstrong = uadv(ret.startstrong);
}
} else if (!ustricmp(p->keyword, L"text-quotes")) {
if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
ret.lquote = uadv(p->keyword);
ret.rquote = uadv(ret.lquote);
}
}
}
}
/*
* Now process fallbacks on quote characters, underlines, the
* rule character, the emphasis characters, and bullets.
*/
while (*uadv(ret.rquote) && *uadv(uadv(ret.rquote)) &&
(!cvt_ok(ret.charset, ret.lquote) ||
!cvt_ok(ret.charset, ret.rquote))) {
ret.lquote = uadv(ret.rquote);
ret.rquote = uadv(ret.lquote);
}
while (*uadv(ret.endemph) && *uadv(uadv(ret.endemph)) &&
(!cvt_ok(ret.charset, ret.startemph) ||
!cvt_ok(ret.charset, ret.endemph))) {
ret.startemph = uadv(ret.endemph);
ret.endemph = uadv(ret.startemph);
}
while (*uadv(ret.endstrong) && *uadv(uadv(ret.endstrong)) &&
(!cvt_ok(ret.charset, ret.startstrong) ||
!cvt_ok(ret.charset, ret.endstrong))) {
ret.startstrong = uadv(ret.endstrong);
ret.endstrong = uadv(ret.startstrong);
}
while (*ret.atitle.underline && *uadv(ret.atitle.underline) &&
!cvt_ok(ret.charset, ret.atitle.underline))
ret.atitle.underline = uadv(ret.atitle.underline);
while (*ret.achapter.underline && *uadv(ret.achapter.underline) &&
!cvt_ok(ret.charset, ret.achapter.underline))
ret.achapter.underline = uadv(ret.achapter.underline);
for (n = 0; n < ret.nasect; n++) {
while (*ret.asect[n].underline && *uadv(ret.asect[n].underline) &&
!cvt_ok(ret.charset, ret.asect[n].underline))
ret.asect[n].underline = uadv(ret.asect[n].underline);
}
while (*ret.bullet.text && *uadv(ret.bullet.text) &&
!cvt_ok(ret.charset, ret.bullet.text))
ret.bullet.text = uadv(ret.bullet.text);
while (*ret.rule && *uadv(ret.rule) &&
!cvt_ok(ret.charset, ret.rule))
ret.rule = uadv(ret.rule);
return ret;
}
/*
* Add a \IM. `tags' points to a zero-terminated chain of
* zero-terminated strings ("first\0second\0thirdandlast\0\0").
* `text' points to a word list.
*
* Guarantee on calling sequence: all implicit merges are given
* before the explicit ones.
*/
void index_merge(indexdata *idx, int is_explicit, wchar_t *tags, word *text,
filepos *fpos) {
indextag *t, *existing;
/*
* For an implicit merge, we want to remove all emphasis,
* because the chances are that the user didn't really want to
* index the term as emphasised.
*/
{
word *w;
for (w = text; w; w = w->next) {
if (w->type == word_Emph || w->type == word_Strong)
w->type = word_Normal;
else if (w->type == word_EmphSpace || w->type == word_StrongSpace)
w->type = word_WhiteSpace;
else if (w->type == word_EmphQuote || w->type == word_StrongQuote)
w->type = word_Quote;
}
}
/*
* FIXME: want to warn on overlapping source sets.
*/
for (; *tags; tags = uadv(tags)) {
t = make_indextag();
t->name = tags;
existing = add234(idx->tags, t);
if (existing == t) {
/*
* Duplicate this so we can free it independently.
*/
t->name = ustrdup(tags);
/*
* Every tag has an implicit \IM. So if this tag
* doesn't exist and we're explicit, then we should
* warn (and drop it, since it won't be referenced).
*/
if (is_explicit) {
err_nosuchidxtag(fpos, tags);
continue;
}
/*
* Otherwise, this is a new tag with an implicit \IM.
*/
t->implicit_text = text;
t->implicit_fpos = *fpos;
} else {
if (!is_explicit) {
/*
* An implicit \IM for a tag that's had an implicit
* \IM before. FIXME: we should check the text
* against the existing text and warn on
* differences. And check the tag for case match
* against the existing tag, likewise.
*/
/*
* Check the tag against its previous occurrence to
* see if the cases match.
*/
if (ustrcmp(t->name, existing->name)) {
err_indexcase(fpos, t->name,
&existing->implicit_fpos, existing->name);
}
sfree(t);
} else {
/*
* An explicit \IM added to a valid tag. In
* particular, this removes the implicit \IM if
* present.
*/
sfree(t);
t = existing;
if (t->implicit_text) {
free_word_list(t->implicit_text);
t->implicit_text = NULL;
}
if (t->nexplicit >= t->explicit_size) {
t->explicit_size = t->nexplicit + 8;
t->explicit_texts = sresize(t->explicit_texts,
t->explicit_size, word *);
t->explicit_fpos = sresize(t->explicit_fpos,
t->explicit_size, filepos);
}
t->explicit_texts[t->nexplicit] = text;
t->explicit_fpos[t->nexplicit] = *fpos;
t->nexplicit++;
}
}
}
void unix_setup_config_box(struct controlbox *b, int midsession, void *win)
{
struct controlset *s, *s2;
union control *c;
int i;
if (!midsession) {
/*
* Add the About button to the standard panel.
*/
s = ctrl_getset(b, "", "", "");
c = ctrl_pushbutton(s, "About", 'a', HELPCTX(no_help),
about_handler, P(win));
c->generic.column = 0;
}
/*
* The Config structure contains two Unix-specific elements
* which are not configured in here: stamp_utmp and
* login_shell. This is because pterm does not put up a
* configuration box right at the start, which is the only time
* when these elements would be useful to configure.
*/
/*
* On Unix, we don't have a drop-down list for the printer
* control.
*/
s = ctrl_getset(b, "Terminal", "printing", "Remote-controlled printing");
assert(s->ncontrols == 1 && s->ctrls[0]->generic.type == CTRL_EDITBOX);
s->ctrls[0]->editbox.has_list = 0;
/*
* GTK makes it rather easier to put the scrollbar on the left
* than Windows does!
*/
s = ctrl_getset(b, "Window", "scrollback",
"Control the scrollback in the window");
ctrl_checkbox(s, "Scrollbar on left", 'l',
HELPCTX(no_help),
dlg_stdcheckbox_handler,
I(offsetof(Config,scrollbar_on_left)));
/*
* Really this wants to go just after `Display scrollbar'. See
* if we can find that control, and do some shuffling.
*/
for (i = 0; i < s->ncontrols; i++) {
c = s->ctrls[i];
if (c->generic.type == CTRL_CHECKBOX &&
c->generic.context.i == offsetof(Config,scrollbar)) {
/*
* Control i is the scrollbar checkbox.
* Control s->ncontrols-1 is the scrollbar-on-left one.
*/
if (i < s->ncontrols-2) {
c = s->ctrls[s->ncontrols-1];
memmove(s->ctrls+i+2, s->ctrls+i+1,
(s->ncontrols-i-2)*sizeof(union control *));
s->ctrls[i+1] = c;
}
break;
}
}
/*
* X requires three more fonts: bold, wide, and wide-bold; also
* we need the fiddly shadow-bold-offset control. This would
* make the Window/Appearance panel rather unwieldy and large,
* so I think the sensible thing here is to _move_ this
* controlset into a separate Window/Fonts panel!
*/
s2 = ctrl_getset(b, "Window/Appearance", "font",
"Font settings");
/* Remove this controlset from b. */
for (i = 0; i < b->nctrlsets; i++) {
if (b->ctrlsets[i] == s2) {
memmove(b->ctrlsets+i, b->ctrlsets+i+1,
(b->nctrlsets-i-1) * sizeof(*b->ctrlsets));
b->nctrlsets--;
break;
}
}
ctrl_settitle(b, "Window/Fonts", "Options controlling font usage");
s = ctrl_getset(b, "Window/Fonts", "font",
"Fonts for displaying non-bold text");
ctrl_fontsel(s, "Font used for ordinary text", 'f',
HELPCTX(no_help),
dlg_stdfontsel_handler, I(offsetof(Config,font)));
ctrl_fontsel(s, "Font used for wide (CJK) text", 'w',
HELPCTX(no_help),
dlg_stdfontsel_handler, I(offsetof(Config,widefont)));
s = ctrl_getset(b, "Window/Fonts", "fontbold",
"Fonts for displaying bolded text");
ctrl_fontsel(s, "Font used for bolded text", 'b',
HELPCTX(no_help),
dlg_stdfontsel_handler, I(offsetof(Config,boldfont)));
ctrl_fontsel(s, "Font used for bold wide text", 'i',
HELPCTX(no_help),
dlg_stdfontsel_handler, I(offsetof(Config,wideboldfont)));
ctrl_checkbox(s, "Use shadow bold instead of bold fonts", 'u',
HELPCTX(no_help),
dlg_stdcheckbox_handler,
I(offsetof(Config,shadowbold)));
ctrl_text(s, "(Note that bold fonts or shadow bolding are only"
" used if you have not requested bolding to be done by"
" changing the text colour.)",
HELPCTX(no_help));
ctrl_editbox(s, "Horizontal offset for shadow bold:", 'z', 20,
HELPCTX(no_help), dlg_stdeditbox_handler,
I(offsetof(Config,shadowboldoffset)), I(-1));
/*
* Unix supports a local-command proxy. This also means we must
* adjust the text on the `Telnet command' control.
*/
if (!midsession) {
int i;
s = ctrl_getset(b, "Connection/Proxy", "basics", NULL);
for (i = 0; i < s->ncontrols; i++) {
c = s->ctrls[i];
if (c->generic.type == CTRL_RADIO &&
c->generic.context.i == offsetof(Config, proxy_type)) {
assert(c->generic.handler == dlg_stdradiobutton_handler);
c->radio.nbuttons++;
c->radio.buttons =
sresize(c->radio.buttons, c->radio.nbuttons, char *);
c->radio.buttons[c->radio.nbuttons-1] =
dupstr("Local");
c->radio.buttondata =
sresize(c->radio.buttondata, c->radio.nbuttons, intorptr);
c->radio.buttondata[c->radio.nbuttons-1] = I(PROXY_CMD);
break;
}
}
