int
rlogind_auth (int fd, struct auth_data *ap)
{
struct hostent *hp;
char *hostname;
int authenticated = 0;
#ifdef SHISHI
int len, c;
#endif
confirmed = 0;
/* Check the remote host name */
hp = gethostbyaddr ((char *) &ap->from.sin_addr, sizeof (struct in_addr),
ap->from.sin_family);
if (hp)
hostname = hp->h_name;
else if (reverse_required)
{
syslog (LOG_CRIT, "can't resolve remote IP address");
exit (1);
}
else
hostname = inet_ntoa (ap->from.sin_addr);
ap->hostname = strdup (hostname);
if (verify_hostname || in_local_domain (ap->hostname))
{
int match = 0;
for (hp = gethostbyname (ap->hostname); hp && !match; hp->h_addr_list++)
{
if (hp->h_addr_list[0] == NULL)
break;
match = memcmp (hp->h_addr_list[0], &ap->from.sin_addr,
sizeof (ap->from.sin_addr)) == 0;
}
if (!match)
{
syslog (LOG_ERR | LOG_AUTH, "cannot find matching IP for %s (%s)",
ap->hostname, inet_ntoa (ap->from.sin_addr));
fatal (fd, "Permission denied", 0);
}
}
#if defined(KERBEROS) || defined(SHISHI)
if (kerberos)
{
const char *err_msg;
int c = 0;
if (do_krb_login (fd, ap, &err_msg) == 0)
authenticated++;
else
fatal (fd, err_msg, 0);
write (fd, &c, 1);
confirmed = 1; /* we sent the null! */
}
else
#endif
{
int port = ntohs (ap->from.sin_port);
if (ap->from.sin_family != AF_INET ||
port >= IPPORT_RESERVED || port < IPPORT_RESERVED / 2)
{
syslog (LOG_NOTICE, "Connection from %s on illegal port %d",
inet_ntoa (ap->from.sin_addr), port);
fatal (fd, "Permission denied", 0);
}
#ifdef IP_OPTIONS
{
u_char optbuf[BUFSIZ / 3], *cp;
char lbuf[BUFSIZ], *lp;
socklen_t optsize = sizeof (optbuf);
int ipproto;
struct protoent *ip;
if ((ip = getprotobyname ("ip")) != NULL)
ipproto = ip->p_proto;
else
ipproto = IPPROTO_IP;
if (getsockopt (0, ipproto, IP_OPTIONS, (char *) optbuf,
&optsize) == 0 && optsize != 0)
{
lp = lbuf;
for (cp = optbuf; optsize > 0; cp++, optsize--, lp += 3)
sprintf (lp, " %2.2x", *cp);
syslog (LOG_NOTICE, "Ignoring IP options: %s", lbuf);
if (setsockopt (0, ipproto, IP_OPTIONS, (char *) NULL, optsize))
{
syslog (LOG_ERR, "setsockopt IP_OPTIONS NULL: %m");
exit (1);
}
}
}
#endif /* IP_OPTIONS */
if (do_rlogin (fd, ap) == 0)
authenticated++;
}
if (confirmed == 0)
{
write (fd, "", 1);
confirmed = 1; /* we sent the null! */
}
#ifdef SHISHI
len = sizeof (SECURE_MESSAGE) - 1;
IF_ENCRYPT (writeenc
(ap->h, fd, SECURE_MESSAGE, len, &c, &ap->iv2, ap->enckey,
ap->protocol));
#else
IF_ENCRYPT (des_write (fd, SECURE_MESSAGE, sizeof (SECURE_MESSAGE) - 1));
#endif
return authenticated;
}
int
main(int argc, char *argv[])
{
Font font;
ttfinfo *ti;
#ifdef MIKTEX
miktex_initialize();
#endif
init_font_structure(&font);
TeX_search_init(argv[0], "ttf2tfm", "TTF2TFM");
if (argc == 1)
{
fputs("ttf2tfm: Need at least one file argument.\n", stderr);
fputs("Try `ttf2tfm --help' for more information.\n", stderr);
exit(1);
}
if (argc == 2)
{
if (strcmp(argv[1], "--help") == 0)
usage();
else if (strcmp(argv[1], "--version") == 0)
version();
}
handle_options(argc, argv, &font);
if (font.sfdname)
{
while (get_sfd(&font, True))
{
char *temp, *ttemp;
int i, start, end, len;
get_tfm_fullname(&font);
/*
* Extract base name of sfd file.
*/
temp = newstring(font.sfdname);
len = strlen(temp);
start = 0;
for (i = len - 1; i >= 0; i--)
if (temp[i] == '/' || temp[i] == ':' || temp[i] == '\\')
{
start = i + 1;
break;
}
end = len;
for (i = len - 1; i >= 0; i--)
if (temp[i] == '.')
{
end = i;
break;
}
temp[end] = '\0';
ttemp = (char *)mymalloc(strlen(temp + start) + 4 + 1);
sprintf(ttemp, "CJK-%s", temp + start);
font.codingscheme = ttemp;
free(temp);
readttf(&font, quiet, True);
if (font.replacements)
warning("Replacement glyphs will be ignored.");
/* second try to get an xheight value */
if (font.xheight == 0)
{
if (NULL != (ti = findadobe("x", font.charlist)))
font.xheight = ti->ury;
else if (font.pid == 3 && font.eid == 1 &&
NULL != (ti = findadobe(".c0x78", font.charlist)))
font.xheight = ti->ury;
else
font.xheight = 400;
}
if (NULL != (ti = findadobe("space", font.charlist)))
font.fontspace = ti->width;
else if (NULL != (ti = findadobe(".c0x20", font.charlist)))
font.fontspace = ti->width;
else
font.fontspace = transform(500, 0, font.efactor, font.slant);
if (font.ligname)
get_sfd(&font, False); /* read sfd files for ligatures */
if (buildtfm(&font))
{
writetfm(&font);
if (font.write_enc)
writeenc(&font);
if (font.vplout)
add_subfont_list(&font);
}
}
close_sfd();
if (font.vplout)
{
writeovp(&font);
fclose(font.vplout);
release_subfont_list(&font);
}
}
else
{
get_tfm_fullname(&font);
readttf(&font, quiet, False);
replace_glyphs(&font);
/* second try to get an xheight value */
if (font.xheight == 0)
{
if (NULL != (ti = findadobe("x", font.charlist)))
font.xheight = ti->ury;
else if (font.pid == 3 && font.eid == 1 &&
NULL != (ti = findadobe(".c0x78", font.charlist)))
font.xheight = ti->ury;
else
font.xheight = 400;
}
if (NULL != (ti = findadobe("space", font.charlist)))
font.fontspace = ti->width;
else if (NULL != (ti = findadobe(".c0x20", font.charlist)))
font.fontspace = ti->width;
else
font.fontspace = transform(500, 0, font.efactor, font.slant);
handlereencoding(&font);
buildtfm(&font);
writetfm(&font);
}
if (makevpl)
{
assignchars(&font);
if (makevpl > 1)
upmap(&font);
writevpl(&font, makevpl, forceoctal);
fclose(font.vplout);
}
consttfonts(&font);
exit(0); /* for safety reasons */
return 0; /* never reached */
}
int
main (int argc, char **argv)
{
char *user = NULL;
char *luser = NULL;
char *host = NULL;
char *port = "shell";
char *p;
char lport[5];
struct passwd *pw;
int af = AF_UNSPEC;
struct addrinfo hint, *ai, *aip, *lai;
struct sockaddr raddr;
int raddrlen;
int err, sock = -1, lsock = -1, esock = -1, i;
int opt;
bool verbose = false;
char hostaddr[NI_MAXHOST];
char portnr[NI_MAXSERV];
char buf[3][BUFLEN], *bufp[3];
int len[3], wlen;
fd_set infd, outfd, infdset, outfdset, errfd;
int maxfd;
int flags;
#ifdef SHISHI
Shishi *h;
Shishi_key *enckey = NULL, *deckey = NULL;
int rc;
char *sname = NULL;
int shishi = 0;
int encryption = 0;
int auth2 = 0;
char *cmd, *tcmd;
int hostlen, cmdlen;
struct hostent *hostdata;
char *iv = NULL;
char *iv2 = NULL;
char *iv3 = NULL;
int ivlen;
int ivlen2;
int ivlen3;
#endif
argv0 = argv[0];
/* Lookup local username */
if (!(pw = getpwuid (getuid ())))
{
fprintf (stderr, "%s: Could not lookup username: %s\n", argv0,
strerror (errno));
return 1;
}
/* Process options */
#ifdef SHISHI
while ((opt = getopt (argc, argv, "+l:p:46vsx")) != -1)
#else
while ((opt = getopt (argc, argv, "+l:p:46v")) != -1)
#endif
{
switch (opt)
{
case 'l':
user = optarg;
break;
case 'p':
port = optarg;
break;
case '4':
af = AF_INET;
break;
case '6':
af = AF_INET6;
break;
case 'v':
verbose = true;
break;
#ifdef SHISHI
case 's':
shishi = 1;
port = "544";
break;
case 'x':
shishi = 1;
encryption = 1;
port = "544";
break;
#endif
default:
fprintf (stderr, "%s: Unknown option!\n", argv0);
usage ();
return 1;
}
}
if (optind == argc)
{
fprintf (stderr, "%s: No host specified!\n", argv0);
usage ();
return 1;
}
#ifdef SHISHI
if (!shishi)
{
luser = pw->pw_name;
if (!user)
user = luser;
}
#endif
host = argv[optind++];
if ((p = strchr (host, '@')))
{
user = host;
*p = '\0';
host = p + 1;
}
/* Resolve hostname and try to make a connection */
memset (&hint, '\0', sizeof (hint));
hint.ai_family = af;
hint.ai_socktype = SOCK_STREAM;
err = getaddrinfo (host, port, &hint, &ai);
if (err)
{
fprintf (stderr, "%s: Error looking up host: %s\n", argv0,
gai_strerror (err));
return 1;
}
hint.ai_flags = AI_PASSIVE;
for (aip = ai; aip; aip = aip->ai_next)
{
if (getnameinfo
(aip->ai_addr, aip->ai_addrlen, hostaddr, sizeof (hostaddr), portnr,
sizeof (portnr), NI_NUMERICHOST | NI_NUMERICSERV))
{
fprintf (stderr, "%s: Error resolving address: %s\n", argv0,
strerror (errno));
return 1;
}
if (verbose)
fprintf (stderr, "Trying %s port %s...", hostaddr, portnr);
if ((sock =
socket (aip->ai_family, aip->ai_socktype, aip->ai_protocol)) == -1)
{
if (verbose)
fprintf (stderr, " Could not open socket: %s\n",
strerror (errno));
continue;
}
hint.ai_family = aip->ai_family;
/* Bind to a privileged port */
for (i = 1023; i >= 512; i--)
{
snprintf (lport, sizeof (lport), "%d", i);
err = getaddrinfo (NULL, lport, &hint, &lai);
if (err)
{
fprintf (stderr, " Error looking up localhost: %s\n",
gai_strerror (err));
return 1;
}
err = bind (sock, lai->ai_addr, lai->ai_addrlen);
freeaddrinfo (lai);
if (err)
continue;
else
break;
}
if (err)
{
if (verbose)
fprintf (stderr, " Could not bind to privileged port: %s\n",
strerror (errno));
continue;
}
if (connect (sock, aip->ai_addr, aip->ai_addrlen) == -1)
{
if (verbose)
fprintf (stderr, " Connection failed: %s\n", strerror (errno));
continue;
}
if (verbose)
fprintf (stderr, " Connected.\n");
break;
}
if (!aip)
{
fprintf (stderr, "%s: Could not make a connection.\n", argv0);
return 1;
}
/* Create a socket for the incoming connection for stderr output */
if ((lsock =
socket (aip->ai_family, aip->ai_socktype, aip->ai_protocol)) == -1)
{
fprintf (stderr, "%s: Could not open socket: %s\n", argv0,
strerror (errno));
return 1;
}
hint.ai_family = aip->ai_family;
freeaddrinfo (ai);
for (i--; i >= 512; i--)
{
snprintf (lport, sizeof (lport), "%d", i);
err = getaddrinfo (NULL, lport, &hint, &lai);
if (err)
{
fprintf (stderr, "%s: Error looking up localhost: %s\n", argv0,
gai_strerror (err));
return 1;
}
err = bind (lsock, lai->ai_addr, lai->ai_addrlen);
freeaddrinfo (lai);
if (err)
continue;
else
break;
}
if (err)
{
fprintf (stderr, "%s: Could not bind to privileged port: %s\n", argv0,
strerror (errno));
return 1;
}
if (listen (lsock, 1))
{
fprintf (stderr, "%s: Could not listen: %s\n", argv0, strerror (errno));
return 1;
}
/* Drop privileges */
if (setuid (getuid ()))
{
fprintf (stderr, "%s: Unable to drop privileges: %s\n", argv0,
strerror (errno));
return 1;
}
/* Send required information to the server */
bufp[0] = buf[0];
len[0] = sizeof (buf[0]);
#ifdef SHISHI
if (shishi)
{
if (!shishi_check_version (SHISHI_VERSION))
{
printf ("shishi_check_version() failed:\n"
"Header file incompatible with shared library.\n");
return 1;
}
rc = shishi_init (&h);
if (rc != SHISHI_OK)
{
printf ("error initializing shishi: %s\n", shishi_strerror (rc));
return 1;
}
hostdata = gethostbyname (host);
hostlen = strlen (hostdata->h_name) + strlen (SERVICE) + 2;
sname = malloc (hostlen);
snprintf (sname, hostlen, "%s/%s", SERVICE, hostdata->h_name);
rc = optind;
cmdlen = BUFLEN;
cmd = malloc (cmdlen);
tcmd = cmd;
if (encryption)
safecpy (&tcmd, &cmdlen, "-x ", 0);
for (; optind < argc; optind++)
{
safecpy (&tcmd, &cmdlen, argv[optind], 0);
if (optind < argc - 1)
safecpy (&tcmd, &cmdlen, " ", 0);
}
safecpy (&tcmd, &cmdlen, "", 1);
optind = rc;
if (!user)
user = (char *) shishi_principal_default (h);
safewrite (sock, lport, strlen (lport) + 1);
/* Wait for incoming connection from server */
if ((esock = accept (lsock, &raddr, &raddrlen)) == -1)
{
fprintf (stderr, "%s: Could not accept stderr connection: %s\n",
argv0, strerror (errno));
return 1;
}
close (lsock);
if (auth (h, 0, user, sname, sock, cmd, port, &enckey, deckey) !=
AUTH_OK)
return 1;
free (cmd);
}
else
{
safecpy (&bufp[0], &len[0], lport, 1);
safecpy (&bufp[0], &len[0], luser, 1);
}
#else
safecpy (&bufp[0], &len[0], lport, 1);
safecpy (&bufp[0], &len[0], luser, 1);
#endif
safecpy (&bufp[0], &len[0], user, 1);
#ifdef SHISHI
if (encryption)
safecpy (&bufp[0], &len[0], "-x ", 0);
#endif
for (; optind < argc; optind++)
{
safecpy (&bufp[0], &len[0], argv[optind], 0);
if (optind < argc - 1)
safecpy (&bufp[0], &len[0], " ", 0);
}
#ifdef SHISHI
if (shishi)
{
safecpy (&bufp[0], &len[0], "", 1);
safecpy (&bufp[0], &len[0], user, 1);
}
else
#endif
safecpy (&bufp[0], &len[0], "", 1);
if (!len[0])
{
fprintf (stderr, "%s: Arguments too long!\n", argv0);
return 1;
}
if (safewrite (sock, buf[0], bufp[0] - buf[0]) == -1)
{
fprintf (stderr, "%s: Unable to send required information: %s\n", argv0,
strerror (errno));
return 1;
}
#ifdef SHISHI
if (shishi)
{
safewrite (sock, &auth2, sizeof (int));
}
#endif
/* Wait for acknowledgement from server */
errno = 0;
if (read (sock, buf[0], 1) != 1 || *buf[0])
{
fprintf (stderr, "%s: Didn't receive NULL byte from server: %s\n",
argv0, strerror (errno));
return 1;
}
#ifdef SHISHI
if (encryption)
{
ivlen = ivlen2 = ivlen3 = shishi_key_length (enckey);
iv = malloc (ivlen);
memset (iv, 1, ivlen);
iv2 = malloc (ivlen2);
memset (iv2, 3, ivlen2);
iv3 = malloc (ivlen3);
memset (iv3, 0, ivlen3);
}
if (!shishi)
{
/* Wait for incoming connection from server */
if ((esock = accept (lsock, &raddr, &raddrlen)) == -1)
{
fprintf (stderr, "%s: Could not accept stderr connection: %s\n",
argv0, strerror (errno));
return 1;
}
close (lsock);
}
#else
/* Wait for incoming connection from server */
if ((esock = accept (lsock, &raddr, &raddrlen)) == -1)
{
fprintf (stderr, "%s: Could not accept stderr connection: %s\n", argv0,
strerror (errno));
return 1;
}
close (lsock);
#endif
/* Process input/output */
flags = fcntl (sock, F_GETFL);
fcntl (sock, F_SETFL, flags | O_NONBLOCK);
flags = fcntl (esock, F_GETFL);
fcntl (esock, F_SETFL, flags | O_NONBLOCK);
bufp[0] = buf[0];
bufp[1] = buf[1];
bufp[2] = buf[2];
FD_ZERO (&infdset);
FD_ZERO (&outfdset);
FD_SET (0, &infdset);
FD_SET (sock, &infdset);
FD_SET (esock, &infdset);
maxfd = (sock > esock ? sock : esock) + 1;
for (;;)
{
errno = 0;
infd = infdset;
outfd = outfdset;
errfd = infdset;
if (select (maxfd, &infd, &outfd, &errfd, NULL) <= 0)
{
if (errno == EINTR)
continue;
else
break;
}
if (FD_ISSET (esock, &infd))
{
#ifdef SHISHI
if (encryption)
{
rc = readenc (h, esock, buf[2], &len[2], iv2, &ivlen2, enckey);
if (rc != SHISHI_OK)
break;
}
else
#endif
len[2] = read (esock, buf[2], BUFLEN);
if (len[2] <= 0)
{
if (errno != EINTR)
{
if (FD_ISSET (sock, &infdset) || FD_ISSET (1, &outfdset))
FD_CLR (esock, &infdset);
else
break;
}
}
else
{
FD_SET (2, &outfdset);
FD_CLR (esock, &infdset);
}
}
if (FD_ISSET (2, &outfd))
{
wlen = write (2, bufp[2], len[2]);
if (wlen <= 0)
{
if (errno != EINTR)
{
if (FD_ISSET (sock, &infdset) || FD_ISSET (1, &outfdset))
FD_CLR (esock, &infdset);
else
break;
}
}
else
{
len[2] -= wlen;
bufp[2] += wlen;
if (!len[2])
{
FD_CLR (2, &outfdset);
FD_SET (esock, &infdset);
bufp[2] = buf[2];
}
}
}
if (FD_ISSET (sock, &infd))
{
#ifdef SHISHI
if (encryption)
{
rc = readenc (h, sock, buf[1], &len[1], iv, &ivlen, enckey);
if (rc != SHISHI_OK)
break;
}
else
#endif
len[1] = read (sock, buf[1], BUFLEN);
if (len[1] <= 0)
{
if (errno != EINTR)
{
if (FD_ISSET (esock, &infdset) || FD_ISSET (2, &outfdset))
FD_CLR (sock, &infdset);
else
break;
}
}
else
{
FD_SET (1, &outfdset);
FD_CLR (sock, &infdset);
}
}
if (FD_ISSET (1, &outfd))
{
wlen = write (1, bufp[1], len[1]);
if (wlen <= 0)
{
if (errno != EINTR)
{
if (FD_ISSET (esock, &infdset) || FD_ISSET (2, &outfdset))
FD_CLR (sock, &infdset);
else
break;
}
}
else
{
len[1] -= wlen;
bufp[1] += wlen;
if (!len[1])
{
FD_CLR (1, &outfdset);
FD_SET (sock, &infdset);
bufp[1] = buf[1];
}
}
}
if (FD_ISSET (0, &infd))
{
len[0] = read (0, buf[0], BUFLEN);
if (len[0] <= 0)
{
if (errno != EINTR)
{
FD_CLR (0, &infdset);
shutdown (sock, SHUT_WR);
}
}
else
{
FD_SET (sock, &outfdset);
FD_CLR (0, &infdset);
}
}
if (FD_ISSET (sock, &outfd))
{
#ifdef SHISHI
if (encryption)
{
rc =
writeenc (h, sock, bufp[0], len[0], &wlen, iv3, &ivlen3,
enckey);
if (rc != SHISHI_OK)
break;
}
else
#endif
wlen = write (sock, bufp[0], len[0]);
if (wlen <= 0)
{
if (errno != EINTR)
break;
}
else
{
len[0] -= wlen;
bufp[0] += wlen;
if (!len[0])
{
FD_CLR (sock, &outfdset);
FD_SET (0, &infdset);
bufp[0] = buf[0];
}
}
}
}
if (errno)
{
fprintf (stderr, "%s: %s\n", argv0, strerror (errno));
return 1;
}
close (sock);
close (esock);
#ifdef SHISHI
if (shishi)
{
shishi_done (h);
if (encryption)
{
free (iv);
free (iv2);
free (iv3);
}
}
#endif
return 0;
}