/*
TeXlive uses its own gs in
$SELFAUTOPARENT/tlpkg/tlgs
*/
void texlive_gs_init(void)
{
char *nptr, *path;
char tlgsbindir[512];
char tlgslibdir[512];
nptr = kpse_var_value("SELFAUTOPARENT");
if (nptr) {
strcpy(tlgsbindir, nptr);
strcat(tlgsbindir,"/tlpkg/tlgs");
if(is_dir(tlgsbindir)) {
strcpy(tlgslibdir, tlgsbindir);
strcat(tlgslibdir, "/lib;");
strcat(tlgslibdir, tlgsbindir);
strcat(tlgslibdir, "/fonts");
strcat(tlgsbindir, "/bin;");
free(nptr);
for(nptr = tlgsbindir; *nptr; nptr++) {
if(*nptr == '/') *nptr = '\\';
}
nptr = getenv("PATH");
path = (char *)malloc(strlen(nptr) + strlen(tlgsbindir) + 6);
strcpy(path, tlgsbindir);
strcat(path, nptr);
xputenv("PATH", path);
xputenv("GS_LIB", tlgslibdir);
}
}
}
int
main ()
{
/* All lists end with NULL. */
test_path_search (".", "nonexistent");
test_path_search (".", "/nonexistent");
test_path_search ("/k" ENV_SEP_STRING ".", "kpathsea.texi");
test_path_search ("/k" ENV_SEP_STRING ".", "/etc/fstab");
test_path_search ("." ENV_SEP_STRING TEXFONTS "//", "cmr10.tfm");
test_path_search ("." ENV_SEP_STRING TEXFONTS "//", "logo10.tfm");
test_path_search (TEXFONTS "//times" ENV_SEP_STRING "."
ENV_SEP_STRING ENV_SEP_STRING, "ptmr.vf");
test_path_search (TEXFONTS "/adobe//" ENV_SEP_STRING
"/usr/local/src/TeX+MF/typefaces//", "plcr.pfa");
test_path_search ("~karl", ".bashrc");
test_path_search ("/k", "~karl/.bashrc");
xputenv ("NONEXIST", "nonexistent");
test_path_search (".", "$NONEXISTENT");
xputenv ("KPATHSEA", "kpathsea");
test_path_search ("/k" ENV_SEP_STRING ".", "$KPATHSEA.texi");
test_path_search ("/k" ENV_SEP_STRING ".", "${KPATHSEA}.texi");
test_path_search ("$KPATHSEA" ENV_SEP_STRING ".", "README");
test_path_search ("." ENV_SEP_STRING "$KPATHSEA", "README");
return 0;
}
/*
TeXlive uses its own gs in
$SELFAUTOPARENT/tlpkg/tlgs
*/
void texlive_gs_init(void)
{
char *nptr, *path;
char tlgsbindir[512];
char tlgslibdir[512];
char resourcedir[512];
nptr = kpse_var_value("TEXLIVE_WINDOWS_EXTERNAL_GS");
if (nptr == NULL || *nptr == '0' || *nptr == 'n' || *nptr == 'f') {
if (nptr)
free (nptr);
nptr = kpse_var_value("SELFAUTOPARENT");
if (nptr) {
strcpy(tlgsbindir, nptr);
strcat(tlgsbindir,"/tlpkg/tlgs");
strcpy(resourcedir, tlgsbindir);
strcat(resourcedir, "/Resource");
if(is_dir(tlgsbindir)) {
strcpy(tlgslibdir, tlgsbindir);
strcat(tlgslibdir, "/lib;");
if(is_dir(resourcedir)) {
strcat(tlgslibdir, tlgsbindir);
strcat(tlgslibdir, "/fonts;");
strcat(tlgslibdir, tlgsbindir);
strcat(tlgslibdir, "/Resource/Init;");
strcat(tlgslibdir, tlgsbindir);
strcat(tlgslibdir, "/Resource;");
strcat(tlgslibdir, tlgsbindir);
strcat(tlgslibdir, "/kanji");
} else {
strcat(tlgslibdir, tlgsbindir);
strcat(tlgslibdir, "/fonts");
}
strcat(tlgsbindir, "/bin;");
free(nptr);
for(nptr = tlgsbindir; *nptr; nptr++) {
if(*nptr == '/') *nptr = '\\';
}
nptr = getenv("PATH");
path = (char *)malloc(strlen(nptr) + strlen(tlgsbindir) + 6);
strcpy(path, tlgsbindir);
strcat(path, nptr);
xputenv("PATH", path);
xputenv("GS_LIB", tlgslibdir);
}
}
} else {
free (nptr);
}
}
static string
try_fontmap P4C(string *, fontname_ptr, unsigned, dpi,
kpse_file_format_type, format,
kpse_glyph_file_type *, glyph_file)
{
string *mapped_names;
string fontname = *fontname_ptr;
string ret = NULL;
mapped_names = kpse_fontmap_lookup (fontname);
if (mapped_names) {
string mapped_name;
string first_name = *mapped_names;
while (!ret && (mapped_name = *mapped_names++)) {
xputenv ("KPATHSEA_NAME", mapped_name);
ret = try_resolution (mapped_name, dpi, format, glyph_file);
}
if (ret) {
/* If some alias succeeeded, return that alias. */
*fontname_ptr = xstrdup (mapped_name);
/* Return first alias name, unless that itself is an alias,
in which case do nothing. */
} else if (!kpse_fontmap_lookup (first_name)) {
*fontname_ptr = xstrdup (first_name);
}
}
return ret;
}
static string
try_fontmap P4C(const_string, font_name,
unsigned, dpi,
string *, glyph_paths,
kpse_font_file_type *, font_file)
{
static hash_table_type fontmap;
string *mapped_names;
string ret = NULL;
if (fontmap.size == 0)
{ /* If we wanted to complicate our lives, we could handle separate
maps for GF and PK ones. I don't see that this has any
practical utility, though, because if someone wants an alias,
most likely the alias should apply to non-glyphs as well as
glyphs (let alone to only GF format or PK format). */
const_string map_path = KPSE_GLYPH_PATH ();
fontmap = map_create (map_path);
}
mapped_names = map_lookup (fontmap, font_name);
if (mapped_names)
{
string mapped_name;
while ((mapped_name = *mapped_names++) && !ret)
{
xputenv ("KPATHSEA_NAME", mapped_name);
ret = try_resolution (mapped_name, dpi, glyph_paths, font_file);
}
}
return ret;
}
void
init_xauth (const struct passwd *pw)
{
const char *env_term;
const char *env_xauthority;
env_term = g_getenv ("TERM");
env_xauthority = g_getenv ("XAUTHORITY");
/* Sanity-check the environment variables as best we can: those
* which aren't path names shouldn't contain "/", and none of
* them should contain ".." or "%". */
if (env_term &&
(strstr(env_term, "..") ||
strchr(env_term, '%')))
setenv ("XAUTHORITY", "dumb", 1);
if (env_xauthority &&
(strstr(env_xauthority , "..") ||
strchr(env_xauthority , '%')))
unsetenv ("XAUTHORITY");
/* Setup X authentication stuff. */
saveXauth ();
xputenv (concat ("XAUTHORITY=", pw->pw_dir, "/.Xauthority"));
}
static void
set_maketex_mag P1H(void)
{
char q[MAX_INT_LENGTH * 3 + 3];
int m;
string dpi_str = getenv ("KPATHSEA_DPI");
string bdpi_str = getenv ("MAKETEX_BASE_DPI");
unsigned dpi = dpi_str ? atoi (dpi_str) : 0;
unsigned bdpi = bdpi_str ? atoi (bdpi_str) : 0;
/* If the environment variables aren't set, it's a bug. */
assert (dpi != 0 && bdpi != 0);
/* Fix up for roundoff error. Hopefully the driver has already fixed
up DPI, but may as well be safe, and also get the magstep number. */
(void) kpse_magstep_fix (dpi, bdpi, &m);
if (m == 0)
sprintf (q, "%d+%d/%d", dpi / bdpi, dpi % bdpi, bdpi);
else
{ /* m is encoded with LSB being a ``half'' bit (see magstep.h). Are
we making an assumption here about two's complement? Probably.
In any case, if m is negative, we have to put in the sign
explicitly, since m/2==0 if m==-1. */
const_string sign = "";
if (m < 0)
{
m *= -1;
sign = "-";
}
sprintf (q, "magstep\\(%s%d.%d\\)", sign, m / 2, (m & 1) * 5);
}
xputenv ("MAKETEX_MAG", q);
}
void
xputenv_int P2C(const_string, var_name, int, num)
{
char str[MAX_INT_LENGTH];
sprintf (str, "%d", num);
xputenv (var_name, str);
}
int
main ()
{
xputenv ("KPATHSEA_DPI", "781"); /* call mktexpk */
xputenv ("MAKETEX_BASE_DPI", "300"); /* call mktexpk */
KPSE_MAKE_SPEC_ENABLED (kpse_make_specs[kpse_pk_format]) = true;
test_make_tex (kpse_pk_format, "cmr10");
/* Fail with mktextfm. */
KPSE_MAKE_SPEC_ENABLED (kpse_make_specs[kpse_tfm_format]) = true;
test_make_tex (kpse_tfm_format, "foozler99");
/* Call something disabled. */
test_make_tex (kpse_bst_format, "no-way");
return 0;
}
int ht_engine(char *runstr, int argc, char *argv[])
{
int i;
if (argc < 2 || argc > 5) {
usage();
}
sprintf(cmd, runstr, texargs, argv[2], texfile);
for (i = 0; i < 3; i++)
RUN_SYSTEM(cmd);
if (TESTNZ(argv[3])) {
xputenv("TEX4HTFONTSET", argv[3]);
}
else {
xputenv("TEX4HTFONTSET", "alias,iso8859");
}
if (dry_run) {
fprintf(stderr, "TEX4HTFONTSET = %s\n", getenv("TEX4HTFONTSET"));
}
sprintf(cmd, "tex4ht %s %s", stdcfg[math][dtd][1], output_name);
RUN_SYSTEM(cmd);
if (TESTNZ(argv[4])) {
sprintf(cmd, "t4ht %s %s", output_name, argv[4]);
}
else {
sprintf(cmd, "t4ht %s", output_name);
}
if (TESTNZ(output_dir)) {
strcat(cmd, " -d");
strcat(cmd, output_dir);
}
RUN_SYSTEM(cmd);
return 0;
}
int
main (int argc, char **argv)
{
setprogname (argv[0]);
xputenv ("POSIXLY_CORRECT=1"); // Prevents Linux from reordering options
sfsconst_init ();
srp_base::minprimsize = sfs_mindlogsize;
int ch;
while ((ch = getopt (argc, argv, "S:p:vqV")) != -1)
switch (ch) {
case 'S':
agentsock = optarg;
break;
case 'V':
sfskey_version ();
break;
case 'p':
{
int fd;
if (!convertint (optarg, &fd))
usage ();
opt_pwd_fd = true;
close_on_exec (fd); // Paranoia
pwd_fds.push_back (fd);
break;
}
case 'v':
opt_verbose = true;
break;
case 'q':
opt_quiet = true;
break;
default:
usage ();
break;
}
if (optind >= argc)
usage ();
const modevec *mp;
for (mp = modes; mp->name; mp++)
if (!strcmp (argv[optind], mp->name))
break;
if (!mp->name)
usage ();
sfskey_mode = mp;
optind++;
mp->fn (argc, argv);
amain ();
}
int
main (int argc, char **argv)
{
bool opt_nodaemon = false;
setprogname (argv[0]);
int ch;
while ((ch = getopt (argc, argv, "df:S:")) != -1)
switch (ch) {
case 'd':
opt_nodaemon = true;
break;
case 'f':
if (configfile)
usage ();
configfile = optarg;
break;
case 'S':
{
str sfsconf (strbuf ("SFS_CONFIG=%s", optarg));
xputenv (const_cast<char*>(sfsconf.cstr()));
}
case '?':
default:
usage ();
}
argc -= optind;
argv += optind;
if (argc > 1)
usage ();
sfsconst_init ();
if (!configfile)
configfile = sfsconst_etcfile_required ("sfssd_config");
parseconfig ();
if (!revocationdir)
revocationdir = sfsdir << "srvrevoke";
if (!opt_nodaemon && !builddir) {
daemonize ();
sigcb (SIGINT, wrap (termsig, SIGINT));
sigcb (SIGTERM, wrap (termsig, SIGTERM));
}
warn ("version %s, pid %d\n", VERSION, int (getpid ()));
sigcb (SIGHUP, wrap (restart));
launchservers ();
amain ();
}
int
main (int argc, char **argv)
{
kpse_set_program_name(argv[0], NULL);
test_var ("a", "a");
test_var ("$foo", "");
test_var ("a$foo", "a");
test_var ("$foo a", " a");
test_var ("a$foo b", "a b");
xputenv ("FOO", "foo value");
test_var ("a$FOO", "afoo value");
xputenv ("Dollar", "$");
test_var ("$Dollar a", "$ a");
test_var ("a${FOO}b", "afoo valueb");
test_var ("a${}b", "ab");
test_var ("$$", ""); /* and error */
test_var ("a${oops", "a"); /* and error */
return 0;
}
void
kpse_init_prog P4C(const_string, prefix, unsigned, dpi, const_string, mode,
const_string, fallback)
{
string font_var = concat (prefix, "FONTS");
string header_var = concat (prefix, "HEADERS");
string makepk_var = concat (prefix, "MAKEPK");
string size_var = concat (prefix, "SIZES");
/* Do both `pk_format' and `any_glyph_format' for the sake of xdvi; in
general, mktexpk might apply to either, and the program will ask
for the one it wants. */
/* Might have a program-specific name for mktexpk itself. */
if (getenv (makepk_var)) {
/* If we did, we want to enable the program, I think. */
kpse_set_program_enabled (kpse_pk_format, 1, kpse_src_env);
kpse_set_program_enabled (kpse_any_glyph_format, 1, kpse_src_env);
kpse_format_info[kpse_pk_format].program
= kpse_format_info[kpse_any_glyph_format].program
= getenv (makepk_var);
}
/* A couple font paths have traditionally had application-specific
environment variables to override all else; namely, XDVIFONTS and
DVIPSHEADERS. So set those if we have them. */
kpse_format_info[kpse_pk_format].override_path
= kpse_format_info[kpse_gf_format].override_path
= kpse_format_info[kpse_any_glyph_format].override_path
= kpse_format_info[kpse_tfm_format].override_path
= getenv (font_var);
kpse_format_info[kpse_tex_ps_header_format].override_path
= getenv (header_var);
kpse_init_fallback_resolutions (size_var);
xputenv_int ("MAKETEX_BASE_DPI", dpi);
kpse_fallback_font = fallback;
/* Ugliness. See comments in kpse_make_tex in kpathsea/tex-make.c. */
xputenv ("MAKETEX_MODE", mode ? mode : DIR_SEP_STRING);
free (font_var);
free (header_var);
free (makepk_var);
free (size_var);
}
static string
try_format P4C(const_string, font_name, unsigned, dpi,
const_string, path, const_string, extension)
{
string name, ret;
/* Set the suffix on the name we'll be searching for. */
xputenv ("KPATHSEA_FORMAT", extension);
name = bitmap_name (font_name, dpi, extension);
ret = kpse_path_search (path, name, true);
if (name != ret)
free (name);
return ret;
}
int
main ()
{
test_find_glyph ("/usr/local/lib/tex/fonts/cm/cmr10", 300); /* absolute */
test_find_glyph ("cmr10", 300); /* normal */
test_find_glyph ("logo10", 300); /* find gf */
test_find_glyph ("cmr10", 299); /* find 300 */
test_find_glyph ("circle10", 300); /* in fontmap */
test_find_glyph ("none", 300); /* do not find */
kpse_fallback_font = "cmr10";
test_find_glyph ("fallback", 300); /* find fallback font cmr10 */
kpse_init_fallback_resolutions ("KPATHSEA_TEST_SIZES");
test_find_glyph ("fallbackdpi", 759); /* find fallback font cmr10@300 */
xputenv ("GFFONTS", ".");
test_find_glyph ("cmr10", 300); /* different GFFONTS/TEXFONTS */
return 0;
}
static void
setfds (ptr<vec<int> > fdsp, rex_env env)
{
const vec<int> &fds = *fdsp;
const int firstfd = fds.size () >= 3 ? 0 : 3 - fds.size ();
for (int i = 0; i < firstfd; i++)
if (i != fds[0] && dup2 (fds[0], i) < 0)
fatal ("dup2: %m\n");
//for 1 fd case, child shares stderr with proxy so that errors go to sfssd console
if (fds.size () == 1) {
close (fds[0]);
}
else {
for (int i = 0; implicit_cast<size_t> (i) < fds.size (); i++)
if (fds[i] != i + firstfd) {
assert (fds[i] > i + firstfd); // XXX - relying on mkchannel_prog
if (dup2 (fds[i], firstfd + i) < 0)
fatal ("dup2: %m\n");
close (fds[i]);
}
}
/* chdir to $HOME might not work in rexd which runs as root if the
* user's home directory is in /sfs (because root doesn't have access
* to the user's agent) */
char *homedir = getenv ("HOME");
if (homedir) {
if (chdir (homedir) < 0)
warn << "Could not chdir to home directory "
<< homedir << ": " << strerror (errno) << "\n";
}
for (size_t v = 0; v < env.size (); v++)
if (env[v] && env[v][0] == '!')
unsetenv (substr (env[v], 1));
else
xputenv (env[v]);
}
static string
try_format P3C(const_string, fontname, unsigned, dpi,
kpse_file_format_type, format)
{
static const_string bitmap_specs[]
= { UNIX_BITMAP_SPEC, DPI_BITMAP_SPEC, NULL };
const_string *spec;
boolean must_exist;
string ret = NULL;
const_string path = kpse_format_info[format].path;
const_string *sfx;
if (!path)
path = kpse_init_format (format);
/* Set the suffix on the name we'll be searching for. */
sfx = kpse_format_info[format].suffix;
if (sfx && *sfx)
xputenv ("KPATHSEA_FORMAT", *sfx);
/* OK, the limits on this for loop are a little hokey, but it saves
having to repeat the body. We want to do it once with `must_exist'
false to avoid looking on the disk for cmr10.600pk if
dpi600/cmr10.pk is in ls-R. (The time spent in the extra variable
expansions and db searches is negligible.) */
for (must_exist = false; !ret && must_exist <= true; must_exist++)
{
for (spec = bitmap_specs; !ret && *spec; spec++)
{
string name = kpse_var_expand (*spec);
ret = kpse_path_search (path, name, must_exist);
if (name != ret)
free (name);
}
}
return ret;
}
static void
parseconfig ()
{
str cf = configfile;
parseargs pa (cf);
bool errors = false;
str hostname;
rpc_ptr<sfs_hash> hostid;
server *s = NULL;
release *r = NULL;
extension *e = NULL;
char *c;
int line;
vec<str> av;
while (pa.getline (&av, &line)) {
if (!strcasecmp (av[0], "BindAddr")) {
in_addr addr;
u_int16_t port = 0;
if (av.size () < 2 || av.size () > 3
|| !inet_aton (av[1], &addr)
|| (av.size () == 3 && !convertint (av[2], &port))) {
warn << cf << ":" << line
<< ": usage: BindAddr addr [port]\n";
errors = true;
continue;
}
if (!port)
port = sfs_defport ? sfs_defport : SFS_PORT;
sockaddr_in *sinp
= static_cast<sockaddr_in *> (xmalloc (sizeof (*sinp)));
bzero (sinp, sizeof (*sinp));
sinp->sin_family = AF_INET;
sinp->sin_port = htons (port);
sinp->sin_addr = addr;
#ifdef HAVE_SA_LEN
sinp->sin_len = sizeof (*sinp);
#endif /* HAVE_SA_LEN */
listenaddrs.push_back (reinterpret_cast<sockaddr *> (sinp));
}
else if (!strcasecmp (av[0], "Server")) {
if (av.size () != 2) {
warn << cf << ":" << line
<< ": usage: Server {hostname|*}[:hostid]\n";
errors = true;
continue;
}
if (strchr (av[1], ':') ||
((c = strchr (av[1], '@')) && strchr (c, ','))) {
hostid.alloc ();
if (!sfs_parsepath (av[1], &hostname, hostid)) {
warn << cf << ":" << line << ": bad hostname/hostid\n";
errors = true;
continue;
}
}
else {
hostid.clear ();
if (av[1] == "*")
hostname = sfshostname ();
else
hostname = av[1];
}
for (s = serverlist.first; s; s = serverlist.next (s))
if (hostname == s->host
&& ((hostid && s->hostid && *hostid == *s->hostid)
|| (!hostid && !s->hostid)))
break;
if (!s)
s = New server (hostname, hostid);
r = NULL;
e = NULL;
}
else if (!strcasecmp (av[0], "Release")) {
static rxx relrx ("^(\\d+)\\.(\\d\\d?)$");
if (av.size () != 2 || (!relrx.search (av[1]) && av[1] != "*")) {
warn << cf << ":" << line << ": usage Release { N.NN | * }\n";
errors = true;
r = NULL;
continue;
}
if (!s) {
warn << cf << ":" << line << ": Release must follow Server\n";
errors = true;
r = NULL;
continue;
}
u_int32_t rel;
if (av[1] == "*")
rel = 0xffffffff;
else
rel = strtoi64 (relrx[1]) * 100 + strtoi64 (relrx[2]);
r = s->reltab[rel];
if (!r)
s->reltab.insert ((r = New release (rel)));
for (e = r->extlist.first; r->extlist.next (e); e = r->extlist.next (e))
;
}
else if (!strcasecmp (av[0], "Extensions")) {
av.pop_front ();
e = r->getext (av);
}
else if (!strcasecmp (av[0], "Service")) {
if (!parse_service (av, e, cf << ":" << line))
errors = true;
}
else if (!strcasecmp (av[0], "HashCost")) {
if (av.size () != 2 || !convertint (av[1], &sfs_hashcost)) {
warn << cf << ":" << line << ": usage: HashCost <nbits>\n";
errors = true;
}
else {
if (sfs_hashcost > sfs_maxhashcost)
sfs_hashcost = sfs_maxhashcost;
str s (strbuf ("SFS_HASHCOST=%d", sfs_hashcost));
xputenv (const_cast<char*>(s.cstr()));
}
}
else if (!strcasecmp (av[0], "RevocationDir")) {
if (av.size () != 2) {
warn << cf << ":" << line << ": usage: RevocationDir <directory>\n";
errors = true;
}
else {
revocationdir = av[1];
}
}
else {
errors = true;
warn << cf << ":" << line << ": unknown directive '"
<< av[0] << "'\n";
}
}
if (errors)
fatal ("parse errors in configuration file\n");
}
BOOL DviConfigImport(HWND hwnd)
{
char szBuf[256], *p;
int i;
SendDlgItemMessage(hwnd, IDC_EDITBDPI, WM_GETTEXT, (WPARAM)sizeof(szBuf), (LPARAM)szBuf);
if (resource._pixels_per_inch = atoi(szBuf))
xputenv("BDPI", szBuf);
SendDlgItemMessage(hwnd, IDC_EDITALTFONT, WM_GETTEXT, (WPARAM)sizeof(szBuf), (LPARAM)szBuf);
if (resource._alt_font)
free(resource._alt_font);
resource._alt_font = strdup(szBuf);
SendDlgItemMessage(hwnd, IDC_COMBOMFMODE, WM_GETTEXT, (WPARAM)sizeof(szBuf), (LPARAM)szBuf);
if (resource.mfmode)
free(resource.mfmode);
for (i = 0; i < sizeof(avail_modes)/sizeof(mfmode) - 1; i++) {
if (strcmp(szBuf, avail_modes[i].desc) == 0) {
resource.mfmode = strdup(avail_modes[i].name);
xputenv("MODE", resource.mfmode);
break;
}
}
#if 0
fprintf(stderr, "Dvi config import putenv MODE\n");
#endif
SendDlgItemMessage(hwnd, IDC_COMBOPAPER, WM_GETTEXT, (WPARAM)sizeof(szBuf), (LPARAM)szBuf);
if (resource.paper)
free(resource.paper);
if (*szBuf) {
for (p = szBuf; *p && p < szBuf+sizeof(szBuf); p++)
if (*p == ' ') {
*p = '\0';
break;
}
resource.paper = strdup(szBuf);
set_paper_type();
init_page();
}
resource.makepk = (SendDlgItemMessage(hwnd, IDC_CHECKMAKEPK, BM_GETCHECK,
(WPARAM) 0, (LPARAM)0) == BST_CHECKED);
resource._list_fonts = (SendDlgItemMessage(hwnd, IDC_CHECKLISTFONTS,
BM_GETCHECK, (WPARAM) 0, (LPARAM)0) == BST_CHECKED);
resource.scan_flag = (SendDlgItemMessage(hwnd, IDC_CHECKSCAN,
BM_GETCHECK, (WPARAM) 0, (LPARAM)0) == BST_CHECKED);
resource.log_flag = (SendDlgItemMessage(hwnd, IDC_CHECKLOG,
BM_GETCHECK, (WPARAM) 0, (LPARAM)0) == BST_CHECKED);
resource.single_flag = (SendDlgItemMessage(hwnd, IDC_CHECKSINGLE,
BM_GETCHECK, (WPARAM) 0, (LPARAM)0) == BST_CHECKED);
resource._warn_spec = (SendDlgItemMessage(hwnd, IDC_CHECKHUSHSPECIALS,
BM_GETCHECK, (WPARAM) 0, (LPARAM)0) == BST_CHECKED);
resource._hush_chars = (SendDlgItemMessage(hwnd, IDC_CHECKHUSHCHARS,
BM_GETCHECK,(WPARAM) 0, (LPARAM)0) == BST_CHECKED);
resource._hush_chk = (SendDlgItemMessage(hwnd, IDC_CHECKHUSHCHECKSUMS,
BM_GETCHECK, (WPARAM) 0, (LPARAM)0) == BST_CHECKED);
resource.allow_shell = (SendDlgItemMessage(hwnd, IDC_CHECKALLOWSHELL,
BM_GETCHECK, (WPARAM) 0, (LPARAM)0) == BST_CHECKED);
return TRUE;
}
int
main (int argc, char **argv)
{
#ifdef MAINTAINER
if (getenv ("SFS_RUNINPLACE")) {
setgid (getgid ());
setuid (getuid ());
}
#endif /* MAINTAINER */
setprogname (argv[0]);
sfsconst_init ();
const uid_t procuid = getuid ();
uid_t newuid = procuid;
uid_t uid = myaid () & INT64 (0xffffffff);
gid_t gid;
bool opt_gid = false;
bool opt_login = false;
bool opt_nogid = false;
bool opt_U = false;
str opt_chdir;
size_t num_u = 0;
int ch;
while ((ch = getopt (argc, argv, "lu:U:g:GC:")) != -1)
switch (ch) {
case 'l':
opt_login = true;
break;
case 'u':
if (num_u++ || !convertint (optarg, &uid))
usage ();
break;
case 'U':
if (num_u++ || !convertint (optarg, &newuid))
usage ();
uid = newuid;
opt_U = true;
break;
case 'g':
if (opt_nogid || !convertint (optarg, &gid))
usage ();
opt_gid = true;
break;
case 'G':
if (opt_gid)
usage ();
opt_nogid = true;
case 'C':
if (opt_chdir)
usage ();
opt_chdir = optarg;
break;
default:
usage ();
}
argc -= optind;
argv += optind;
if (procuid && (newuid != procuid || uid != procuid))
fatal ("only root can change uids.\n");
if (!opt_gid && !opt_nogid)
opt_gid = gid_alloc (&gid, uid);
fixgroups (newuid != uid, uid, opt_gid, gid);
if (opt_U)
sfs_setlogin (newuid);
if (setgid (getgid ()) < 0 || setuid (newuid) < 0)
fatal ("setuid/setgid: %m\n");
vec<char *> av;
char *path = argc > 0 ? argv[0] : getenv ("SHELL");
if (!path)
fatal ("no SHELL environment variable\n");
av.push_back (path);
for (int i = 1; i < argc; i++)
av.push_back (argv[i]);
av.push_back (NULL);
str av0;
if (opt_login) {
const char *p = strrchr (path, '/');
p = p ? p + 1 : path;
av0 = strbuf ("-%s", p);
av[0] = const_cast<char *> (av0.cstr ());
}
if (opt_chdir) {
if (chdir (opt_chdir) < 0)
warn << opt_chdir << ": " << strerror (errno) << "\n";
else if (opt_chdir[0] == '/') {
str e (strbuf ("PWD=%s", opt_chdir.cstr ()));
xputenv (e);
}
else if (const char *p = getenv ("PWD")) {
str e (strbuf ("PWD=%s/%s", p, opt_chdir.cstr ()));
xputenv (e);
}
}
str aidvar (strbuf ("SFS_AID=") << myaid ());
xputenv (aidvar);
/* The SFS libraries use asynchronous IO which some programs don't
* like. Thus, we remove the O_NONBLOCK flag from stdin/stdout. */
make_sync (0);
make_sync (1);
execvp (path, av.base ());
warnx ("%s: %m\n", path);
return 1;
}
int
main (int ac, char **av)
{
char rbuff[TBUF];
char buff[TBUF];
char savebuff[TBUF];
char cmd[TBUF];
char mffile[TBUF];
char *arg[4];
static char execfile[TBUF];
char kpsedot[TBUF];
char currdir[TBUF];
char *tmp;
int cdrive, tdrive;
FILE *fr, *fw, *fnul;
int i, savo, savi;
char *p, *fp, *fpp;
int issetdest;
char fontname[TBUF];
char texbindir[TBUF];
char fullbin[TBUF];
kpse_set_program_name (av[0], NULL);
progname = kpse_program_name;
/*
* get tex binary dir
*
*/
p = kpse_var_value("SELFAUTOLOC");
if(p == 0) {
fprintf(stderr, "I cannot get SELFAUTOLOC\n");
exit(100);
}
strcpy(texbindir, p);
free(p);
for(p=texbindir; *p; p++) {
if(*p == '/') *p = '\\';
}
*p = '\\';
*(p+1) = '\0';
tmp = getenv ("TEMP");
if (!tmp)
tmp = getenv ("TMP");
if (!tmp)
tmp = getenv ("TMPDIR");
if (!tmp) {
fprintf (stderr, "Please define TEMP | TMP | TMPDIR.\n");
return (100);
}
tmp = xstrdup(tmp);
for (fpp = tmp; *fpp; fpp++) {
if (IS_KANJI(fpp))
fpp++;
else if (*fpp == '\\')
*fpp = '/';
}
/*
issetdest = 0 : TDS
issetdest = 1 : user setting
issetdest = 2 : current directory
*/
issetdest = 0;
if (ac < 2) {
usage ();
free(tmp);
return (100);
}
if ((!strcmp (av[1], "--version")) || (!strcmp (av[1], "-version"))) {
version ();
free(tmp);
return (100);
}
if ((!strcmp (av[1], "--help")) || (!strcmp (av[1], "-help"))) {
help ();
free(tmp);
return (100);
}
for (i = 0; i < 4; i++)
arg[i] = (char *) malloc (TBUF);
if ((!strcmp (av[1], "--destdir")) || (!strcmp (av[1], "-destdir"))) {
if (ac != 4) {
usage ();
relmem (arg);
free(tmp);
return (100);
}
issetdest = 1;
if (strlen(av[2]) > TBUF - 1 || strlen(av[3]) > TBUF - 1) {
fprintf (stderr, "Too long a string.\n");
return (100);
}
strcpy (buff, av[2]);
strcpy (fontname, av[3]);
for (p = buff; *p; p++) {
if (IS_KANJI(p))
p++;
else if (*p == '\\')
*p = '/';
}
} else {
if (strlen(av[1]) > TBUF - 1) {
fprintf (stderr, "Too long a string.\n");
return (100);
}
strcpy (fontname, av[1]);
}
/* fontname = font name
*/
if ((p = strrchr (fontname, '.')))
*p = '\0';
/* mffile is METAFONT file name
*/
strcpy (mffile, fontname);
strcat (mffile, ".mf");
if (!(fp = kpse_var_value ("MFINPUTS"))) {
fprintf (stderr, "Cannot get value of MFINPUTS\n");
relmem (arg);
free(tmp);
return (100);
}
free (fp);
xputenv("MKTEXMF", "1");
if (!(p = kpse_find_file (mffile, kpse_mf_format, 1))) {
fprintf (stderr, "Cannot find %s.\n", mffile);
relmem (arg);
free(tmp);
return (100);
}
fpp = _getcwd (currdir, TBUF);
if (!fpp) {
fprintf (stderr, "Failed to get current working directory.\n");
relmem (arg);
free(tmp);
return (100);
}
for (fpp = currdir; *fpp; fpp++) {
if (IS_KANJI(fpp))
fpp++;
else if (*fpp == '\\')
*fpp = '/';
}
i = (int)strlen (currdir);
if (currdir[i - 1] == '/')
currdir[i - 1] = '\0';
strcpy (kpsedot, "KPSE_DOT=.;");
strcat (kpsedot, currdir);
_putenv (kpsedot);
if ((p[0] == '.') && (p[1] == '/') && (issetdest != 1)) {
issetdest = 2;
strcpy (buff, currdir);
}
if (issetdest == 0) {
/* now path of ${name}.mf is in p */
strcpy (arg[0], "Dummy");
strcpy (arg[1], "tfm");
strcpy (arg[2], p);
if (!(p = getdestdir (3, arg))) {
fprintf (stderr, "Cannot get destination directory name.\n");
relmem (arg);
free(tmp);
return (100);
}
strcpy (buff, p);
}
/* Now buff is the destdir */
p = buff;
i = (int)strlen (p);
if (p[i - 1] != '/')
strcat (p, "/");
strcat (p, fontname);
strcat (p, ".tfm");
/* now p (or buff) is the full path name of the tfm font */
/* check if it exists */
if (_access (p, 0) == 0) {
fprintf (stderr, "%s exists\n", p);
printf ("%s\n", p);
relmem (arg);
free(tmp);
return (0);
}
cdrive = _getdrive ();
if (tmp[1] == ':') {
tdrive = tolower (*tmp) - 'a' + 1;
_chdrive (tdrive);
}
_chdir (tmp);
/* save stdout and stdin */
savo = _dup (fileno (stdout));
savi = _dup (fileno (stdin));
/* connect stdout to stderr */
_dup2 (fileno (stderr), fileno (stdout));
/* connect stdin to nul device */
if (!(fnul = fopen ("nul", "r"))) {
fprintf (stderr, "Cannot open nul device to read\n");
relmem (arg);
_chdrive (cdrive);
_chdir (currdir);
free(tmp);
return (100);
}
_dup2 (fileno (fnul), fileno (stdin));
/* METAFONT command line */
strcpy (cmd, "--progname=mf --base=mf ");
strcat (cmd, "\\mode:=ljfour; \\mag:=1; nonstopmode; input ");
strcat (cmd, fontname);
strcat (cmd, ";");
strcpy (execfile, "mf-nowin.exe");
fprintf (stderr, "%s %s\n", execfile, cmd);
strcpy(fullbin, texbindir);
strcat(fullbin, execfile);
(void) _spawnlp (_P_WAIT, fullbin, execfile, cmd, NULL);
/* return to original stdout and stdin */
_dup2 (savo, fileno (stdout));
close (savo);
_dup2 (savi, fileno (stdin));
close (savi);
/* close nul device */
fclose (fnul);
/* check consistency */
strcpy (cmd, fontname);
strcat (cmd, ".600gf");
if (_access (cmd, 0) == -1) {
fprintf (stderr, "METAFONT failed to make gf font.\n");
relmem (arg);
_chdrive (cdrive);
_chdir (currdir);
free(tmp);
return (100);
}
remove (cmd);
strcpy (cmd, fontname);
strcat (cmd, ".tfm");
/* copy the tfm file */
if (!(fr = fopen (cmd, "rb"))) {
fprintf (stderr, "Cannot open %s to read\n", cmd);
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
if (!(fw = fopen (buff, "wb"))) {
fprintf (stderr, "Cannot open %s to write\n", buff);
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
while ((i = (int)fread (rbuff, 1, TBUF, fr)))
fwrite (rbuff, 1, i, fw);
fclose (fr);
fclose (fw);
strcpy(savebuff, buff);
/*
copy log file into the current directory
in the case that issetdest == 2,
because feynmf package requires the
log file.
*/
if(issetdest == 2) {
i = (int)strlen(buff);
if(i > 3) {
i -= 4;
buff[i] = '\0';
strcat(buff, ".log");
strcpy(cmd, fontname);
strcat(cmd, ".log");
if (!(fr = fopen (cmd, "rb"))) {
fprintf (stderr, "Cannot open %s to read\n", cmd);
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
if (!(fw = fopen (buff, "wb"))) {
fprintf (stderr, "Cannot open %s to write\n", buff);
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
while ((i = (int)fread (rbuff, 1, TBUF, fr)))
fwrite (rbuff, 1, i, fw);
fclose (fr);
fclose (fw);
}
}
relmem (arg);
if(issetdest != 2)
mktexupd (savebuff);
/* erase files */
strcpy (cmd, fontname);
strcat (cmd, ".log");
remove (cmd);
strcpy (cmd, fontname);
strcat (cmd, ".tfm");
remove (cmd);
_chdrive (cdrive);
_chdir (currdir);
/* send message to Kpathsea */
printf ("%s\n", savebuff);
free(tmp);
return (0);
}
static void oct2env(char *env[], int idx, unsigned long val)
{
env[idx] = xasprintf("TAR_%s=%lo", tar_var[idx], val);
xputenv(env[idx]);
}
static void str2env(char *env[], int idx, const char *str)
{
env[idx] = xasprintf("TAR_%s=%s", tar_var[idx], str);
xputenv(env[idx]);
}
int
main (int ac, char **av)
{
static char execfile[SBUF];
char rbuff[LBUF];
char buff[LBUF];
char cmd[LBUF];
char mfname[TBUF];
char tfname[TBUF];
char pkname[TBUF];
char name[TBUF];
char dpi[TBUF];
char ydpi[TBUF];
char bdpi[TBUF];
char mag[TBUF];
char mode[TBUF];
char destdir[SBUF];
char designsize[64];
char *arg[4];
char currdir[SBUF];
char kpsedot[SBUF];
char *tmp;
int cdrive, tdrive;
FILE *fr, *fw, *fnul, *tfmfileptr;
int i, savo, savi, ret;
int style;
int issetdest;
int app;
int oldform;
int ps2pkok;
char *env;
char *p, *fpp;
double Xdpi, Ydpi;
char texname[TBUF], pfbname[TBUF], slant[TBUF], extend[TBUF], encname[TBUF];
char texbindir[256];
char fullbin[512];
/*
* style = 0 : MAKETEXPK_STYLE undefined or other than dosnames
* style = 1 : MAKETEXPK_STYLE = dosnames
*/
/*
* issetdest = 0 : no destdir
* issetdest = 1 : destdir
* issetdest = 2 : current working dir
*/
/*
* app = 0 : mf
* app = 1 : ps2pk
* app = 2 : gsftopk
* app = 3 : ttf2pk
* app = 4 : hbf2gf
*/
/*
* oldform = 0 : newform of the command line
* oldform = 1 : oldform of the command line
*/
/*
* TEMP | TMP | TMPDIR (necessary)
*
*/
tmp = getenv ("TEMP");
if (!tmp)
tmp = getenv ("TMP");
if (!tmp)
tmp = getenv ("TMPDIR");
if (!tmp) {
tpkerr ("Please define TEMP | TMP | TMPDIR.");
return (100);
}
tmp = xstrdup(tmp);
/*
* normalize directory separators
*/
normalize (tmp);
for (i = 0; i < 4; i++)
arg[i] = (char *) malloc (SBUF);
kpse_set_program_name (av[0], NULL);
progname = kpse_program_name;
/*
* get tex binary dir
*
*/
p = kpse_var_value("SELFAUTOLOC");
if(p == 0) {
fprintf(stderr, "I cannot get SELFAUTOLOC\n");
exit(100);
}
strcpy(texbindir, p);
free(p);
for(p=texbindir; *p; p++) {
if(*p == '/') *p = '\\';
}
*p = '\\';
*(p+1) = '\0';
if (ac < 2) {
usage ();
relmem (arg);
free(tmp);
return (100);
}
issetdest = 0;
ps2pkok = 0;
/*
* oldform or newform ?
*
*/
if (av[1][0] == '-')
oldform = 0;
else
oldform = 1;
/*
* Old form of the command line
*/
if (oldform == 1) {
if (ac < 5) {
usage ();
relmem (arg);
free(tmp);
return (100);
}
if((strlen(av[1]) > TBUF -1 ) ||
(strlen(av[2]) > TBUF -1 ) ||
(strlen(av[3]) > TBUF -1 ) ||
(strlen(av[4]) > TBUF -1 )) {
fprintf(stderr, "\nToo long a string.\n");
free(tmp);
return 100;
}
strcpy (name, av[1]);
strcpy (dpi, av[2]);
strcpy (bdpi, av[3]);
strcpy (mag, av[4]);
if (ac > 5) {
if(strlen(av[5]) > TBUF -1) {
fprintf(stderr, "\nToo long a string.\n");
free(tmp);
return 100;
}
strcpy (mode, av[5]);
}
else
mode[0] = '\0';
} else {
/*
* New form of the command line
*/
name[0] = dpi[0] = bdpi[0] = mag[0] = mode[0] = destdir[0] = '\0';
i = 1;
while (i < ac) {
if(strlen(av[i]) > TBUF - 1) {
fprintf(stderr, "\nToo long a string.\n");
free(tmp);
return 100;
}
if (av[i][0] != '-') {
strcpy (name, av[i]);
break;
}
if (!strcmp (av[i], "--dpi") || !strcmp (av[i], "-dpi")) {
i++;
if (i >= ac) {
tpkerr ("Invalid arguments.");
relmem (arg);
free(tmp);
return (100);
}
strcpy (dpi, av[i]);
i++;
} else if (!strcmp (av[i], "--bdpi") || !strcmp (av[i], "-bdpi")) {
i++;
if (i >= ac) {
tpkerr ("Invalid arguments.");
relmem (arg);
free(tmp);
return (100);
}
strcpy (bdpi, av[i]);
i++;
} else if (!strcmp (av[i], "--mag") || !strcmp (av[i], "-mag")) {
i++;
if (i >= ac) {
tpkerr ("Invalid arguments.");
relmem (arg);
free(tmp);
return (100);
}
strcpy (mag, av[i]);
i++;
} else if (!strcmp (av[i], "--mfmode") || !strcmp (av[i], "-mfmode")) {
i++;
if (i >= ac) {
tpkerr ("Invalid arguments.");
relmem (arg);
free(tmp);
return (100);
}
strcpy (mode, av[i]);
i++;
} else if (!strcmp (av[i], "--destdir") || !strcmp (av[i], "-destdir")) {
i++;
if (i >= ac) {
tpkerr ("Invalid arguments.");
relmem (arg);
free(tmp);
return (100);
}
strcpy (destdir, av[i]);
issetdest = 1;
i++;
} else if (!strcmp (av[i], "--version") || !strcmp (av[i], "-version")) {
version ();
relmem (arg);
free(tmp);
return (0);
} else if (!strcmp (av[i], "--help") || !strcmp (av[i], "-help")) {
help ();
relmem (arg);
free(tmp);
return (0);
} else {
tpkerr ("Argument error.");
relmem (arg);
free(tmp);
return (100);
}
}
} /* End of command line analysis */
env = kpse_var_value ("MAKETEXPK_STYLE");
if ((env == NULL) || !(*env) || (env && strcmp (env, "dosnames"))) {
style = 0;
} else
style = 1;
/*
* Default program is mf
*/
app = 0;
/*
* check if mfmode and bdpi are consistent or not
*/
if (bdpi[0] && mode[0] && mode[0] != '/') {
FILE *frd;
char buff[128];
int len;
strcpy (fullbin, texbindir);
strcat (fullbin, "mf-nowin.exe \"\\mode:=");
strcat (fullbin, mode);
strcat (fullbin, ";mode_setup;message");
strcat (fullbin, "(decimal round pixels_per_inch);");
strcat (fullbin, "end. <nul\"");
frd = popen (fullbin, "r");
if (!frd) {
tpkerr ("I cannot find METAFONT.\n");
relmem (arg);
free(tmp);
return (100);
}
(void) fgets (buff, 126, frd);
(void) fgets (buff, 126, frd);
pclose (frd);
system("del /Q mfput.*");
len = (int)strlen (buff);
if (buff[len - 1] == '\n') {
buff[len - 1] = '\0';
if (buff[len - 2] == '\r')
buff[len - 2] = '\0';
}
if (strcmp (bdpi, buff)) {
fprintf(stderr, "mode_dpi %s and bdpi %s are inconsistent.\n", buff, bdpi);
fprintf(stderr, "therefore I reset mfmode.\n");
mode[0] = '\0';
}
}
/*
* determine mfmode if not given
*/
if (mode[0] == 0 || mode[0] == '/') {
if (bdpi[0] == 0) {
tpkerr ("Cannot determine the mode.");
tpkerr ("I will try other possibilities.");
app = 1;
} else {
strcpy (rbuff, "MAKETEXPK_MODE_");
strcat (rbuff, bdpi);
if ((env = kpse_var_value ("MAKETEXPK_MODE")) && *env)
strcpy (mode, env);
else if ((env = kpse_var_value (rbuff)))
strcpy (mode, env);
else if (!strcmp (bdpi, "85"))
strcpy (mode, "sun");
else if (!strcmp (bdpi, "100"))
strcpy (mode, "nextscrn");
else if (!strcmp (bdpi, "118"))
strcpy (mode, "pcprevw");
else if (!strcmp (bdpi, "160"))
strcpy (mode, "nectzo");
else if (!strcmp (bdpi, "180"))
strcpy (mode, "toshiba");
else if (!strcmp (bdpi, "200"))
strcpy (mode, "highfax");
else if (!strcmp (bdpi, "240"))
strcpy (mode, "canonlbp");
else if (!strcmp (bdpi, "300"))
strcpy (mode, "cx");
else if (!strcmp (bdpi, "320"))
strcpy (mode, "neclm");
else if (!strcmp (bdpi, "360"))
strcpy (mode, "epstylus");
else if (!strcmp (bdpi, "400"))
strcpy (mode, "nexthi");
else if (!strcmp (bdpi, "600"))
strcpy (mode, "ljfour");
else if (!strcmp (bdpi, "720"))
strcpy (mode, "epscszz");
else if (!strcmp (bdpi, "800"))
strcpy (mode, "lwpro");
else if (!strcmp (bdpi, "1000"))
strcpy (mode, "lmaster");
else if (!strcmp (bdpi, "1200"))
strcpy (mode, "ultre");
else if (!strcmp (bdpi, "1270"))
strcpy (mode, "linoone");
else if (!strcmp (bdpi, "1800"))
strcpy (mode, "vtftzz");
else if (!strcmp (bdpi, "2400"))
strcpy (mode, "supre");
else if (!strcmp (bdpi, "2540"))
strcpy (mode, "linotzzh");
else if (!strcmp (bdpi, "3386"))
strcpy (mode, "linolttz");
else if (!strcmp (bdpi, "8000"))
strcpy (mode, "dpdfezzz");
else if (!strcmp (bdpi, "9600"))
strcpy (mode, "ibx");
else {
tpkerr ("Cannot determine the mode.");
tpkerr ("I will try other possibilities.");
app = 1;
}
}
}
if (env) free (env);
if (name[0] == 0) {
tpkerr ("Font name is not given.");
relmem (arg);
free(tmp);
return (100);
}
if ((p = strrchr (name, '.')))
*p = '\0';
strcpy (mfname, name);
strcat (mfname, ".mf");
if (app == 0) {
if (!(p = kpse_var_value ("MFINPUTS"))) {
tpkerr ("Cannot get value of MFINPUTS.");
relmem (arg);
free(tmp);
return (100);
}
free (p);
xputenv("MKTEXMF", "1");
if (!(p = kpse_find_file (mfname, kpse_mf_format, 1))) {
fprintf (stderr, "Cannot find %s .\n", mfname);
tpkerr ("I try ps2pk --> gsftopk --> ttf2pk --> hbf2gf.");
app = 1;
}
}
if (app != 0) {
strcpy (mode, "modeless");
strcpy (tfname, name);
strcat (tfname, ".tfm");
if (!(p = kpse_var_value ("TFMFONTS"))) {
tpkerr ("Cannot get value of TFMFONTS.");
relmem (arg);
free(tmp);
return (100);
}
free (p);
/*
I don't try to create nonexisting tfm here.
*/
if (!(p = kpse_find_file (tfname, kpse_tfm_format, 0))) {
fprintf (stderr, "Cannot find %s .\n", tfname);
relmem (arg);
free(tmp);
return 100;
}
tfmfileptr = fopen (p, "rb");
if (!tfmfileptr) {
fprintf (stderr, "I cannot open %s.\n", p);
relmem (arg);
free(tmp);
return 100;
}
i = 256 * getc (tfmfileptr);
i += getc (tfmfileptr);
fclose (tfmfileptr);
if ((i == 9) || (i == 11)) {
fprintf (stderr, "Current font seems to be a Japanese one.\n");
fprintf (stderr, "I give up to create a PK font.\n");
relmem (arg);
free(tmp);
return 100;
}
}
if ((p[0] == '.') && (p[1] == '/') && (issetdest != 1))
issetdest = 2;
fpp = _getcwd (currdir, SBUF);
if (!fpp) {
fprintf (stderr, "Failed to get current working directory.\n");
relmem (arg);
free(tmp);
return (100);
}
normalize (currdir);
i = (int)strlen (currdir);
if (currdir[i - 1] == '/')
currdir[i - 1] = '\0';
strcpy (kpsedot, "KPSE_DOT=.;");
strcat (kpsedot, currdir);
_putenv (kpsedot);
if (issetdest == 2) {
strcpy (destdir, currdir);
}
if (issetdest == 0) {
strcpy (arg[0], "Dummy");
strcpy (arg[1], "pk");
strcpy (arg[2], p);
strcpy (arg[3], mode);
if (!(p = getdestdir (4, arg))) {
tpkerr ("Cannot get destination directory name.");
relmem (arg);
free(tmp);
return (100);
}
strcpy (rbuff, p);
} else
strcpy (rbuff, destdir);
/*
* Change backslash into slash
*/
normalize (rbuff);
p = rbuff;
i = (int)strlen (p);
if (p[i - 1] == '/')
p[i - 1] = '\0';
if (issetdest) {
if (!is_dir (p)) {
fprintf (stderr, "Destination %s is not found.\n", p);
relmem (arg);
free(tmp);
return (100);
}
} else if (!is_dir (p)) {
if (make_dir (p)) {
tpkerr ("Error in make_dir.");
relmem (arg);
free(tmp);
return (100);
}
}
strcpy (buff, p);
p = buff;
i = (int)strlen (p);
if (p[i - 1] != '/')
strcat (p, "/");
if (dpi[0] == 0) {
tpkerr ("Cannot determine DPI.");
relmem (arg);
free(tmp);
return (100);
}
if (style == 1 && issetdest != 2) { /* dosnames */
strcat (p, "dpi");
strcat (p, dpi);
if (!is_dir (p)) {
if (make_dir (p)) {
tpkerr ("Error in make_dir.");
relmem (arg);
free(tmp);
return (100);
}
}
strcat (p, "/");
}
strcat (p, name);
strcat (p, ".");
if (style != 1 || issetdest == 2)
strcat (p, dpi); /* long suffix */
strcat (p, "pk");
/* Now buff and p is the full path name of pk file */
/* check the existence of pk file */
if (_access (p, 0) == 0) {
fprintf (stderr, "%s exists.\n", p);
relmem (arg);
printf ("%s\n", p);
free(tmp);
return (0);
}
/*
* Go to the temporary directory
*/
cdrive = _getdrive ();
if (tmp[1] == ':') {
tdrive = tolower (*tmp) - 'a' + 1;
_chdrive (tdrive);
}
_chdir (tmp);
/*
* save stdout and stdin
*/
savo = _dup (fileno (stdout));
savi = _dup (fileno (stdin));
/*
* connect stdout to stderr
*/
_dup2 (fileno (stderr), fileno (stdout));
/*
* connect stdin to nul
*/
if (!(fnul = fopen ("nul", "rb"))) {
fprintf (stderr, "Cannot open nul device to read.\n");
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
_dup2 (fileno (fnul), fileno (stdin));
/*
* pkname is the filename of PK font
*/
sprintf (pkname, "%s.%spk", name, dpi);
if (app == 0) {
/*
* METAFONT command line
*/
if (mag[0] == 0) {
tpkerr ("Cannot determine MAG.");
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
sprintf (cmd,
"--progname=mf --base=mf \\mode:=%s; \\mag:=%s; nonstopmode; input %s;",
mode, mag, name);
strcpy (execfile, "mf-nowin.exe");
fprintf (stderr, "%s %s\n", execfile, cmd);
strcpy(fullbin, texbindir);
strcat(fullbin, execfile);
(void) _spawnlp (_P_WAIT, fullbin, execfile, cmd, NULL);
sprintf (cmd, "%s.%sgf", name, dpi);
/*
* check the consistency
*/
if (_access (cmd, 0) != 0) {
tpkerr ("Failed to make gf font by METAFONT.");
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
/*
* Change gf into pk
*/
strcpy (execfile, "gftopk.exe");
fprintf (stderr, "%s %s %s\n", execfile, cmd, pkname);
strcpy(fullbin, texbindir);
strcat(fullbin, execfile);
(void) _spawnlp (_P_WAIT, fullbin, execfile, cmd, pkname, NULL);
if (_access (pkname, 0) != 0) {
tpkerr ("Failed to make pk from gf.");
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
/*
* erase gf file
*/
remove (cmd);
/*
* erase log file
*/
sprintf (cmd, "%s.log", name);
remove (cmd);
/*
* erase tfm file
*/
sprintf (cmd, "%s.tfm", name);
remove (cmd);
goto finale;
}
/*
* app = 1 : ps2pk --> gsftopk --> ttf2pk --> hbf2gf
*/
p = kpse_find_file ("pspksupp.map", kpse_fontmap_format, 0);
if(p) {
fr = fopen (p, "r"); /* Read pspksupp.map */
free (p);
if (!fr) {
tpkerr ("Cannot open pspksupp.map to read.");
ps2pkok = 0;
goto do_ps2pk;
}
while (fgets (rbuff, SBUF, fr)) {
if (rbuff[0] == '%' || rbuff[0] == '#' || rbuff[0] == '\n')
continue;
texname[0] = pfbname[0] = slant[0] = extend[0] = encname[0] = '\0';
i = sscanf (rbuff, "%s %s %s %s %s", texname, pfbname, slant, extend,
encname);
if (i == 2 && !strncmp (texname, "AspectRatio", 11)) {
if (!sscanf (pfbname, "%lf", &AspectRatio)) {
tpkerr ("File format of pspksupp.map is wrong.");
fclose (fr);
ps2pkok = 0;
goto do_ps2pk;
}
UseAspectRatio = 1;
continue;
} else if (i > 0 && !stricmp (texname, name)) {
p = kpse_var_value ("T1FONTS");
if (!p) {
tpkerr ("T1FONTS is not defined.");
ps2pkok = 0;
break;
}
free (p);
p = kpse_find_file (pfbname, kpse_type1_format, 0);
if (!p) {
fprintf (stderr, "%s is not found.\n", pfbname);
ps2pkok = 0;
break;
}
free (p);
ps2pkok = 1;
if(bdpi[0] == 0)
i--;
break;
}
}
fclose (fr);
goto do_ps2pk;
} else {
char *q;
char a[SBUF];
char b[SBUF];
char psname[SBUF];
char pscommand[SBUF];
double slantval, extendval;
texname[0] = pfbname[0] = encname[0] = '\0';
a[0] = b[0] = psname[0] = pscommand[0] = '\0';
FileName = 0;
strcpy(slant, "0");
strcpy(extend, "1");
ps2pkok = 0;
p = kpse_find_file ("ps2pk.map", kpse_fontmap_format, 0);
if(!p) {
tpkerr("Necessary map file for ps2pk is not found.");
goto do_ps2pk;
}
fr = fopen(p,"rb");
free(p);
if (!fr) {
tpkerr ("Cannot open ps2pk.map to read.");
goto do_ps2pk;
}
while ((ret=ffgets (rbuff, LBUF, fr)) != FFILE_END) {
if(ret == BBUFF_FUL) {
fprintf(stderr, "A line in ps2pk.map seems to be too long.\n");
fprintf(stderr, "I try to continue. But something may be wrong.\n");
}
p = rbuff;
skipchar(&p);
if((*p == '%') || (*p == '#') || (*p == '\n'))
continue;
q = texname;
while(!isskip(*p) && (*p != '\n'))
*q++ = *p++;
*q = '\0';
if(stricmp(texname, name))
continue;
skipchar(&p);
if((*p == '%') || (*p == '#') || (*p == '\n')) {
fprintf(stderr, "Incorrect line in \"ps2pk.map\".\n");
break;
}
if(FileName)
q = a;
else
q = psname;
while(!isskip(*p) && (*p != '\n'))
*q++ = *p++;
*q = '\0';
skipchar(&p);
/*
skip flag
*/
if(!FileName) {
while(isdigit(*p))
p++;
skipchar(&p);
}
if((*p == '%') || (*p == '#') || (*p == '\n')) {
tpkerr("I cannot use ps2pk due to lack of data.");
break;
}
if(*p == '\"') {
q = pscommand;
*q++ = *p++;
while(*p != '\"')
*q++ = *p++;
*q++ = *p++;
*q = '\0';
skipchar(&p);
if((*p == '%') || (*p == '#') || (*p == '\n'))
break;
}
if(FileName && a[0] == '\0')
q = a;
else if(FileName && b[0] == '\0')
q = b;
else {
tpkerr("Incorrect line in ps2pk.map.");
break;
}
while(!isskip(*p) && (*p != '\n'))
*q++ = *p++;
*q = '\0';
skipchar(&p);
if((*p == '%') || (*p == '#') || (*p == '\n'))
break;
if(*p == '\"') {
q = pscommand;
*q++ = *p++;
while(*p != '\"')
*q++ = *p++;
*q++ = *p++;
*q = '\0';
skipchar(&p);
if((*p == '%') || (*p == '#') || (*p == '\n'))
break;
}
if (FileName && a[0] == '\0')
q = a;
else if (FileName && b[0] == '\0')
q = b;
else {
fprintf(stderr, "Incorrect line in \"ps2pk.map\".\n");
break;
}
while(!isskip(*p) && (*p != '\n'))
*q++ = *p++;
*q = '\0';
skipchar(&p);
if((*p == '%') || (*p == '#') || (*p == '\n'))
break;
if(*p == '\"') {
q = pscommand;
*q++ = *p++;
while(*p != '\"')
*q++ = *p++;
*q++ = *p++;
*q = '\0';
skipchar(&p);
if((*p == '%') || (*p == '#') || (*p == '\n'))
break;
}
skipchar(&p);
if((*p == '%') || (*p == '#') || (*p == '\n'))
break;
else {
fprintf(stderr, "Incorrect line in \"ps2pk.map\".\n");
break;
}
}
fclose(fr);
if(pscommand[0]) {
p = strstr(pscommand, "SlantFont");
if(p) {
p--;
while(*p == ' ' || *p == '\t') p--;
while(*p != ' ' && *p != '\t' && *p != '\"') p--;
p++;
sscanf(p, "%lf SlantFont", &slantval);
sprintf(slant, "%lf", slantval);
p = slant + strlen(slant) - 1;
while(*p == '0') {
*p = '\0';
p--;
}
}
p = strstr(pscommand, "ExtendFont");
if(p) {
p--;
while(*p == ' ' || *p == '\t') p--;
while(*p != ' ' && *p != '\t' && *p != '\"') p--;
p++;
sscanf(p, "%lf ExtendFont", &extendval);
sprintf(extend, "%lf", extendval);
p = extend + strlen(extend) - 1;
while(*p == '0') {
*p = '\0';
p--;
}
}
}
if(a[0]) {
p = strrchr(a, '.');
if(p && !stricmp(p, ".enc")) {
*p = '\0';
strcpy(encname, a);
}
else if(p && !stricmp(p, ".pfb")) {
*p = '\0';
strcpy(pfbname, a);
}
}
if(b[0]) {
p = strrchr(b, '.');
if(p && !stricmp(p, ".enc")) {
*p = '\0';
strcpy(encname, b);
}
else if(p && !stricmp(p, ".pfb")) {
*p = '\0';
strcpy(pfbname, b);
}
}
if(pfbname[0] == '\0')
goto do_ps2pk;
p = kpse_find_file (pfbname, kpse_type1_format, 0);
if(!p)
goto do_ps2pk;
free(p);
ps2pkok = 1;
if(encname[0] && bdpi[0]) {
i = 5;
} else if(!encname[0] && !bdpi[0]) {
i = 3;
} else {
i = 4;
}
}
do_ps2pk:
if (ps2pkok) {
if (UseAspectRatio) {
sscanf (dpi, "%lf", &Xdpi);
Ydpi = Xdpi * AspectRatio;
sprintf (ydpi, "%d", (int) Ydpi);
} else
strcpy (ydpi, dpi);
strcpy(tfname, name);
strcat(tfname, ".tfm");
get_designsize(tfname, designsize);
if (i == 3) {
sprintf (cmd, "-X%s -Y%s -S%s -E%s -P%s %s %s",
dpi, ydpi, slant, extend, designsize, pfbname, pkname);
} else if (i == 4 && bdpi[0]) {
sprintf (cmd, "-X%s -Y%s -R%s -S%s -E%s -P%s %s %s",
dpi, ydpi, bdpi, slant, extend, designsize, pfbname, pkname);
} else if (i == 4 && encname[0]) {
sprintf (cmd, "-e%s -X%s -Y%s -S%s -E%s -P%s %s %s",
encname, dpi, ydpi, slant, extend, designsize, pfbname, pkname);
} else if (i == 5) {
sprintf (cmd, "-e%s -X%s -Y%s -R%s -S%s -E%s -P%s %s %s",
encname, dpi, ydpi, bdpi, slant, extend, designsize, pfbname, pkname);
} else {
tpkerr ("File format of pspksupp.map is wrong.");
goto do_gsftopk;
}
strcpy (execfile, "ps2pk.exe");
fprintf (stderr, "%s %s\n", execfile, cmd);
strcpy(fullbin, texbindir);
strcat(fullbin, execfile);
(void) _spawnlp (_P_WAIT, fullbin, execfile, cmd, NULL);
if (_access (pkname, 0) != 0) {
tpkerr ("ps2pk failed to make pk font.");
goto do_gsftopk;
}
goto finale;
}
/*
* ps2pk is impossible to use
*/
do_gsftopk:
tpkerr ("ps2pk cannot be used.");
tpkerr ("I try gsftopk.");
app = 2;
strcpy (execfile, "gsftopk.exe");
fprintf (stderr, "%s %s %s\n", execfile, name, dpi);
strcpy(fullbin, texbindir);
strcat(fullbin, execfile);
(void) _spawnlp (_P_WAIT, fullbin, execfile, name, dpi, NULL);
if (_access (pkname, 0) != 0) {
tpkerr ("gsftopk cannot be used.");
tpkerr ("Next I try ttf2pk.");
app = 3;
strcpy (execfile, "ttf2pk.exe");
fprintf (stderr, "%s -q %s %s\n", execfile, name, dpi);
strcpy(fullbin, texbindir);
strcat(fullbin, execfile);
(void) _spawnlp (_P_WAIT, fullbin, execfile, "-q", name, dpi, NULL);
if (_access (pkname, 0) != 0) {
tpkerr ("ttf2pk failed.");
tpkerr ("Finally I try hbf2gf.");
app = 4;
strcpy (execfile, "hbf2gf.exe");
fprintf (stderr, "%s -q -p %s %s\n", execfile, name, dpi);
strcpy(fullbin, texbindir);
strcat(fullbin, execfile);
(void) _spawnlp (_P_WAIT, fullbin, execfile, "-q -p", name, dpi, NULL);
sprintf (cmd, "%s.%sgf", name, dpi);
if (_access (cmd, 0) != 0) {
tpkerr ("All trials failed.");
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
strcpy (execfile, "gftopk.exe");
fprintf (stderr, "%s %s %s\n", execfile, cmd, pkname);
strcpy(fullbin, texbindir);
strcat(fullbin, execfile);
(void) _spawnlp (_P_WAIT, fullbin, execfile, cmd, pkname, NULL);
if (_access (pkname, 0) != 0) {
tpkerr ("All trials failed.");
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
remove (cmd);
}
}
finale:
/*
* return to original stdout and stdin
*/
_dup2 (savo, fileno (stdout));
close (savo);
_dup2 (savi, fileno (stdin));
close (savi);
/*
* close nul device
*/
fclose (fnul);
/*
* copy the pk file
*/
if (!(fr = fopen (pkname, "rb"))) {
fprintf (stderr, "Cannot open %s to read.\n", pkname);
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
if (!(fw = fopen (buff, "wb"))) {
fprintf (stderr, "Cannot open %s to write.\n", buff);
_chdrive (cdrive);
_chdir (currdir);
relmem (arg);
free(tmp);
return (100);
}
while ((i = (int)fread (rbuff, 1, LBUF, fr)))
fwrite (rbuff, 1, i, fw);
fclose (fr);
fclose (fw);
remove (pkname);
relmem (arg);
/*
* update ls-R if it exists
*/
mktexupd (buff);
/*
* tell kpathsea
*/
printf ("%s\n", buff);
_chdrive (cdrive);
_chdir (currdir);
free(tmp);
return (0);
}
void
async_init::start ()
{
static bool initialized;
if (initialized)
panic ("async_init called twice\n");
initialized = true;
/* Ignore SIGPIPE, since we may get a lot of these */
struct sigaction sa;
bzero (&sa, sizeof (sa));
sa.sa_handler = SIG_IGN;
sigaction (SIGPIPE, &sa, NULL);
if (!execsafe ()) {
int fdlim_hard = fdlim_get (1);
if (char *p = getenv ("FDLIM_HARD")) {
int n = atoi (p);
if (n > 0 && n < fdlim_hard) {
fdlim_hard = n;
fdlim_set (fdlim_hard, -1);
}
}
}
if (!getenv ("FDLIM_HARD") || !execsafe ()) {
str var = strbuf ("FDLIM_HARD=%d", fdlim_get (1));
xputenv (const_cast<char*>(var.cstr()));
var = strbuf ("FDLIM_SOFT=%d", fdlim_get (0));
xputenv (const_cast<char*>(var.cstr()));
}
sfs_core::selector_t::init ();
sfs_core::selector = New sfs_core::std_selector_t ();
lazylist = New list<lazycb_t, &lazycb_t::link>;
#ifdef WRAP_DEBUG
if (char *p = getenv ("CALLBACK_TRACE")) {
if (strchr (p, 'f'))
callback_trace |= CBTR_FD;
if (strchr (p, 't'))
callback_trace |= CBTR_TIME;
if (strchr (p, 's'))
callback_trace |= CBTR_SIG;
if (strchr (p, 'c'))
callback_trace |= CBTR_CHLD;
if (strchr (p, 'l'))
callback_trace |= CBTR_LAZY;
if (strchr (p, 'a'))
callback_trace |= -1;
if (strchr (p, 'T'))
callback_time = true;
}
#endif /* WRAP_DEBUG */
if (char *p = getenv ("SFS_OPTIONS")) {
for (const char *cp = p; *cp; cp++) {
switch (*cp) {
case 'b':
sfs_core::set_busywait (true);
break;
case 'e':
if (sfs_core::set_select_policy (sfs_core::SELECT_EPOLL) < 0)
warn ("failed to switch select policy to EPOLL\n");
break;
case 'k':
if (sfs_core::set_select_policy (sfs_core::SELECT_KQUEUE) < 0)
warn ("failed to switch select policy to KQUEUE\n");
break;
case 'z':
sfs_core::set_zombie_collect (true);
break;
default:
warn ("unknown SFS_OPTION: '%c'\n", *cp);
break;
}
}
}
}
int main(int argc, char *argv[])
{
int i;
int retval = 0;
kpse_set_progname(argv[0]);
progname = xstrdup(program_invocation_short_name);
#ifdef _WIN32
SetConsoleCtrlHandler((PHANDLER_ROUTINE)sigint_handler, TRUE);
#else
# ifdef SIGHUP
signal (SIGHUP, sigint_handler);
# endif
# ifdef SIGINT
signal (SIGINT, sigint_handler);
# endif
# ifdef SIGQUIT
signal (SIGQUIT, sigint_handler);
# endif
# ifdef SIGEMT
signal (SIGEMT, sigint_handler);
# endif
# ifdef SIGPIPE
signal (SIGPIPE, sigint_handler);
# endif
# ifdef SIGTERM
signal (SIGTERM, sigint_handler);
# endif
#endif
if (strlen(progname) > 4 && FILESTRNCASEEQ(progname + strlen(progname) - 4, ".exe", 4)) {
*(progname + strlen(progname) - 4) = '\0';
}
is_ht = FILESTRCASEEQ(progname, "ht");
argv = parse_arguments(&argc, argv);
#if 0
fprintf(stderr, "%s:\n", progname);
for (i = 1; i < argc; i++)
fprintf(stderr, "\t argv[%d] = %s\n", i, argv[i]);
fprintf(stderr, "\nconfig(%d,%d) = ", math, dtd);
for (i = 0; i < 3; i++)
fprintf(stderr, "%s ", stdcfg[math][dtd][i]);
fprintf(stderr, "\n");
#endif
texargs = (force ? "--interaction=nonstopmode" : "");
if (TESTZ(argv[1])) {
fprintf(stderr, "%s: error, no file specified.\n", progname);
exit(1);
}
texsrc = xstrdup(argv[1]);
#if 0
/* Rely on latex / kpathsea to find the right source file. */
if ((strlen(texsrc) < 4)
|| _strnicmp(texsrc + strlen(texsrc) - 4, ".tex", 4) != 0) {
texsrc = concat(texsrc, ".tex");
}
#endif
texfile = xstrdup(texsrc);
if ((strlen(texfile) >= 4)
&& _strnicmp(texfile + strlen(texfile) - 4, ".tex", 4) == 0) {
*(texfile + strlen(texfile) - 4) = '\0';
}
if (TESTZ(output_name)) {
output_name = xstrdup(texfile);
}
else {
if ((strlen(output_name) >= 4)
&& _strnicmp(output_name + strlen(output_name) - 4, ".tex", 4) == 0) {
*(output_name + strlen(output_name) - 4) = '\0';
}
texargs = concat3(texargs, " --jobname=", output_name);
}
#if 0
// copy the original name to output name if needed
if (TESTNZ(output_dir)) {
texfile = concat3(output_dir, "\\", output_name);
}
else if (TESTNZ(output_name)) {
texfile = xstrdup(output_name);
}
else
texfile = NULL;
if (texfile) {
unixtodos_filename(texfile);
if (dry_run) {
fprintf(stderr, "%s: copying %s to %s\n", progname, texsrc, texfile);
}
else {
if (CopyFile(texsrc, texfile, false) == 0) {
fprintf(stderr, "%s: failed to copy %s to %s (Error %d)\n",
progname, texsrc, texfile, GetLastError());
}
}
free(texfile);
}
texfile = xstrdup(output_name);
if (TESTNZ(output_dir)) {
pushd(output_dir);
xputenv("KPSE_DOT", cwd);
xputenv("TEXINPUTS", concatn(cwd, "/", output_dir, ";", NULL));
if (dry_run) {
fprintf(stderr, "%s: changing directory to %s\n", progname, output_dir);
fprintf(stderr, "%s: setting KPSE_DOT to %s\n", progname, cwd);
}
}
#endif
if (is_ht) {
retval = ht(argc, argv);
}
else if (FILESTRCASEEQ(progname, "httex")) {
retval = ht_engine(runstr_tex, argc, argv);
}
else if (FILESTRCASEEQ(progname, "htlatex")) {
retval = ht_engine(runstr_latex, argc, argv);
}
else if (FILESTRCASEEQ(progname, "httexi")) {
retval = ht_engine(runstr_texi, argc, argv);
}
else {
fprintf(stderr, "%s: %s is unknown, aborting.\n", argv[0], progname);
retval = 1;
}
if (opt_index) {
/* copy dest_dir/output_name.html to dest_dir/index.html */
char *destfile = output_name;
char *indexfile = "index.html";
if (TESTNZ(output_dir)) {
destfile = concat3(output_dir, "\\", output_name);
indexfile = concat(output_dir, "\\index.html");
}
if ((strlen(destfile) < 5)
|| _strnicmp(destfile + strlen(destfile) - 5, ".html", 5) != 0) {
destfile = concat(destfile, ".html");
}
if (CopyFile(destfile, indexfile, false) == 0) {
fprintf(stderr, "%s: failed to copy %s to %s (Error %d)\n",
progname, destfile, indexfile, GetLastError());
}
}
mt_exit(retval);
/* Not Reached */
return retval;
}
string
kpse_find_glyph P4C(const_string, passed_fontname, unsigned, dpi,
kpse_file_format_type, format,
kpse_glyph_file_type *, glyph_file)
{
string ret;
kpse_glyph_source_type source;
string fontname = (string) passed_fontname; /* discard const */
/* Start the search: try the name we're given. */
source = kpse_glyph_source_normal;
xputenv ("KPATHSEA_NAME", fontname);
ret = try_resolution (fontname, dpi, format, glyph_file);
/* Try all the various possibilities in order of preference. */
if (!ret) {
/* Maybe FONTNAME was an alias. */
source = kpse_glyph_source_alias;
ret = try_fontmap (&fontname, dpi, format, glyph_file);
/* If not an alias, try creating it on the fly with mktexpk,
unless FONTNAME is absolute or explicitly relative. */
if (!ret && !kpse_absolute_p (fontname, true)) {
source = kpse_glyph_source_maketex;
/* `try_resolution' leaves the envvar set randomly. */
xputenv_int ("KPATHSEA_DPI", dpi);
ret = kpse_make_tex (format, fontname);
}
/* If mktex... succeeded, set return struct. Doesn't make sense for
`kpse_make_tex' to set it, since it can only succeed or fail,
unlike the other routines. */
if (ret) {
KPSE_GLYPH_FILE_DPI (*glyph_file) = dpi;
KPSE_GLYPH_FILE_NAME (*glyph_file) = fontname;
}
/* If mktex... failed, try any fallback resolutions. */
else {
if (kpse_fallback_resolutions)
ret = try_fallback_resolutions (fontname, dpi, format, glyph_file);
/* We're down to the font of last resort. */
if (!ret && kpse_fallback_font) {
const_string name = kpse_fallback_font;
source = kpse_glyph_source_fallback;
xputenv ("KPATHSEA_NAME", name);
/* As before, first try it at the given size. */
ret = try_resolution (name, dpi, format, glyph_file);
/* The fallback font at the fallback resolutions. */
if (!ret && kpse_fallback_resolutions)
ret = try_fallback_resolutions (name, dpi, format, glyph_file);
}
}
}
/* If RET is null, then the caller is not supposed to look at GLYPH_FILE,
so it doesn't matter if we assign something incorrect. */
KPSE_GLYPH_FILE_SOURCE (*glyph_file) = source;
/* FIXME: fontname may have been allocated, but (worse) it may also
have been assigned to struct that's passed out of this function.
if (fontname != passed_fontname)
free (fontname);
*/
return ret;
}
void
sfsconst_init (bool lite_mode)
{
if (const_set)
return;
const_set = true;
{
char *p = safegetenv ("SFS_RELEASE");
if (!p || !convertint (p, &sfs_release)) {
str rel (strbuf () << "SFS_RELEASE=" << sfs_release);
xputenv (const_cast<char*>(rel.cstr()));
}
}
#ifdef MAINTAINER
if (char *p = safegetenv ("SFS_RUNINPLACE")) {
runinplace = true;
builddir = p;
buildtmpdir = builddir << "/runinplace";
}
if (char *p = safegetenv ("SFS_ROOT"))
if (*p == '/')
sfsroot = p;
#endif /* MAINTAINER */
sfsdevdb = strbuf ("%s/.devdb", sfsroot);
#ifdef MAINTAINER
if (runinplace) {
sfsdir = buildtmpdir;
sfssockdir = sfsdir;
etc3dir = etc1dir;
etc1dir = sfsdir.cstr();
etc2dir = xstrdup (str (builddir << "/etc"));
}
#endif /* MAINTAINER */
if (char *ps = safegetenv ("SFS_PORT"))
if (int pv = atoi (ps))
sfs_defport = pv;
str sfs_config = safegetenv ("SFS_CONFIG");
if (sfs_config && sfs_config[0] == '/') {
if (!parseconfig (NULL, sfs_config))
fatal << sfs_config << ": " << strerror (errno) << "\n";
}
else {
if (!parseconfig (etc3dir, sfs_config)) {
parseconfig (etc3dir, "sfs_config");
if (!parseconfig (etc2dir, sfs_config)) {
parseconfig (etc2dir, "sfs_config");
if (!parseconfig (etc1dir, sfs_config))
parseconfig (etc1dir, "sfs_config");
}
}
}
if (!lite_mode) {
if (!sfs_uid)
idlookup (NULL, NULL);
}
if (char *p = getenv ("SFS_HASHCOST")) {
sfs_hashcost = strtoi64 (p);
if (sfs_hashcost > sfs_maxhashcost)
sfs_hashcost = sfs_maxhashcost;
}
if (!getuid () && !runinplace) {
mksfsdir (sfsdir, 0755);
mksfsdir (sfssockdir, 0750);
}
else if (runinplace && access (sfsdir, 0) < 0) {
struct stat sb;
if (!stat (builddir, &sb)) {
mode_t m = umask (0);
if (!getuid ()) {
if (pid_t pid = fork ())
waitpid (pid, NULL, 0);
else {
umask (0);
setgid (sfs_gid);
setuid (sb.st_uid);
if (mkdir (sfsdir, 02770) >= 0)
rc_ignore (chown (sfsdir, (uid_t) -1, sfs_gid));
_exit (0);
}
}
else
mkdir (sfsdir, 0777);
umask (m);
}
}
}
/* Update environment variables for the new user. */
void
modify_environment (const struct passwd *pw)
{
const gchar *path;
const char *env_term;
const char *env_display, *env_shell;
const char *env_lang, *env_lcall, *env_lcmsgs;
const char *env_dbus;
/* Sanity-check the environment variables as best we can: those
* which aren't path names shouldn't contain "/", and none of
* them should contain ".." or "%". */
env_display = getenv("DISPLAY");
env_lang = g_getenv ("LANG");
env_lcall = g_getenv ("LC_ALL");
env_lcmsgs = g_getenv ("LC_MESSAGES");
env_shell = g_getenv ("SHELL");
env_term = g_getenv ("TERM");
if (env_display &&
(strstr(env_display, "..") ||
strchr(env_display, '%')))
unsetenv ("DISPLAY");
if (env_lang &&
(strstr(env_lang, "/") ||
strstr(env_lang, "..") ||
strchr(env_lang, '%')))
unsetenv ("LANG");
if (env_lcall &&
(strstr(env_lcall, "/") ||
strstr(env_lcall, "..") ||
strchr(env_lcall, '%')))
unsetenv ("LC_ALL");
if (env_lcmsgs &&
(strstr(env_lcmsgs, "/") ||
strstr(env_lcmsgs, "..") ||
strchr(env_lcmsgs, '%')))
unsetenv ("LC_MESSAGES");
if (env_shell &&
(strstr(env_shell, "..") ||
strchr(env_shell, '%')))
unsetenv ("SHELL");
if (!g_getenv ("ICEAUTHORITY"))
xputenv (concat ("ICEAUTHORITY=", pw->pw_dir, "/.ICEauthority"));
/* Set HOME, SHELL, USER and LOGNAME. */
xputenv (concat ("HOME", "=", pw->pw_dir));
xputenv (concat ("SHELL", "=", pw->pw_shell));
xputenv (concat ("USER", "=", pw->pw_name));
xputenv (concat ("LOGNAME", "=", pw->pw_name));
/* set XDG_RUNTIME_DIR for the new user */
xputenv (g_strdup_printf("XDG_RUNTIME_DIR=/run/user/%d", pw->pw_uid));
/* Sanity-check PATH. It shouldn't contain . entries! */
path = g_getenv ("PATH");
if (path && (strstr (path, ":.:") || strncmp (path, ".:", 2) == 0
|| (strlen (path) > 2 && strcmp (path + strlen (path) - 2, ":.") == 0)
|| strcmp (path, ".") == 0))
{
char **paths;
char **new_paths;
int path_len;
int i, j;
paths = g_strsplit (path, ":", -1);
path_len = g_strv_length (paths);
new_paths = g_new0 (char *, path_len);
j = 0;
for (i = 0; i < path_len; i++) {
if (paths[i] && !strchr(paths[i], '.')) {
new_paths[j++] = g_strdup (paths[i]);
}
}
g_strfreev (paths);
if (j != 0) {
char *new_path;
new_path = g_strjoinv (":", new_paths);
setenv ("PATH", new_path, 1);
g_free (new_path);
} else {
/* make sure we set PATH to something below */
path = NULL;
}
}
