static void
do_ntlm_round (SoupURI *base_uri, gboolean use_ntlm, const char *user)
{
SoupSession *session;
gboolean alice = use_ntlm && !strcmp (user, "alice");
gboolean bob = use_ntlm && !strcmp (user, "bob");
g_return_if_fail (use_ntlm || !alice);
session = soup_test_session_new (
SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_NTLM, use_ntlm,
NULL);
if (user) {
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), (char *)user);
}
do_message (session, base_uri, "/noauth",
FALSE, use_ntlm,
FALSE, FALSE,
SOUP_STATUS_OK);
do_message (session, base_uri, "/alice",
!use_ntlm || bob, FALSE,
FALSE, FALSE,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/alice/404",
!use_ntlm, bob,
FALSE, FALSE,
alice ? SOUP_STATUS_NOT_FOUND :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/alice",
!use_ntlm, bob,
FALSE, FALSE,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/bob",
!use_ntlm || alice, bob,
FALSE, FALSE,
bob ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/alice",
!use_ntlm || bob, alice,
FALSE, FALSE,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/basic",
FALSE, bob,
TRUE, user != NULL,
user != NULL ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/either",
!use_ntlm, FALSE,
!use_ntlm, !use_ntlm && user != NULL,
user != NULL ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
soup_test_session_abort_unref (session);
}
int
configure_spamd(u_short dport, char *name, char *message,
struct cidr *blacklists)
{
int lport = IPPORT_RESERVED - 1, s;
struct sockaddr_in sin;
FILE* sdc;
s = rresvport(&lport);
if (s == -1)
return (-1);
memset(&sin, 0, sizeof sin);
sin.sin_len = sizeof(sin);
sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
sin.sin_family = AF_INET;
sin.sin_port = htons(dport);
if (connect(s, (struct sockaddr *)&sin, sizeof sin) == -1)
return (-1);
sdc = fdopen(s, "w");
if (sdc == NULL) {
close(s);
return (-1);
}
fprintf(sdc, "%s", name);
do_message(sdc, message);
while (blacklists->addr != 0) {
fprintf(sdc, ";%s/%u", atop(blacklists->addr),
blacklists->bits);
blacklists++;
}
fputc('\n', sdc);
fclose(sdc);
close(s);
return (0);
}
void messOne(int mynum, char *name, int who, const char *fmt, ...)
{
va_list args;
char addrbuf[15];
/* On the chance that I am sending myself a message */
/* And it is not from god. This is a bad thing, I think. */
if (who == mynum){
ERROR(2,("roboshar:messOne(): Messaging self (slot %i)!\n",who));
return; /* hack: don't message self :) */
}
sprintf(addrbuf, "%s->%2s", name, players[who].p_mapchars);
va_start(args, fmt);
do_message(who, MINDIV, addrbuf, mynum, fmt, args);
va_end(args);
}
void messAll(int mynum, char *name, const char *fmt, ...)
{
va_list args;
char addrbuf[15];
va_start(args, fmt);
/* +++ 2.6pl0 [email protected] */
#if defined(__alpha)
sprintf(addrbuf, "%s->ALL", &name );
#else
sprintf(addrbuf, "%s->ALL", name );
#endif
/* --- */
do_message(0, MALL, addrbuf, mynum, fmt, args);
va_end(args);
}
void
do_message(int flags, int code, const char *fmt, ...)
{
va_list ap;
int eek = 0;
if (flags & LOG) {
va_start(ap, fmt);
if (vfprintf(logerr, fmt, ap) <= 0)
eek = 1;
va_end(ap);
}
if (eek)
flags |= ERR; /* failed, force stderr */
if (flags & ERR) {
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
} else if (flags & OUT) {
va_start(ap, fmt);
vfprintf(stdout, fmt, ap);
va_end(ap);
}
if (flags & PRE) {
do_message(flags & ~PRE, 0, ": %s\n", strerror(code));
if (flags & LAST)
fprintf(stderr,
_("Check logfile \"%s\" for more details\n"),
logfile_name);
}
/* logfile is broken, force a write to stderr */
if (eek) {
fprintf(stderr, _("%s: could not write to logfile \"%s\".\n"),
progname, logfile_name);
fprintf(stderr,
_("Aborting XFS copy -- logfile error -- reason: %s\n"),
strerror(errno));
pthread_exit(NULL);
}
}
char*
do_key(void)
{
return do_message(MSGTYPE_KEY);
}
char*
do_char(void)
{
return do_message(MSGTYPE_CHAR);
}
char*
do_sound_icon(void)
{
return do_message(MSGTYPE_SOUND_ICON);
}
char*
do_speak(void)
{
return do_message(MSGTYPE_TEXT);
}
/*
* main:
* Main program for local process
*/
int
main(int ac, char **av)
{
char *term;
int c;
int enter_status;
bool Query_driver = false;
bool Show_scores = false;
enter_status = env_init(Q_CLOAK);
while ((c = getopt(ac, av, "Sbcfh:l:mn:op:qst:w:")) != -1) {
switch (c) {
case 'l': /* rsh compatibility */
case 'n':
(void) strncpy(name, optarg, sizeof(name));
break;
case 't':
team = *optarg;
if (!isdigit((unsigned char)team)) {
warnx("Team names must be numeric");
team = ' ';
}
break;
case 'o':
#ifndef OTTO
warnx("The -o flag is reserved for future use.");
goto usage;
#else
Otto_mode = true;
break;
#endif
case 'm':
#ifdef MONITOR
Am_monitor = true;
#else
warnx("The monitor was not compiled in.");
#endif
break;
#ifdef INTERNET
case 'S':
Show_scores = true;
break;
case 'q': /* query whether hunt is running */
Query_driver = true;
break;
case 'w':
Send_message = optarg;
break;
case 'h':
contacthost = optarg;
break;
case 'p':
contactportstr = optarg;
contactport = atoi(contactportstr);
break;
#else
case 'S':
case 'q':
case 'w':
case 'h':
case 'p':
wanrx("Need TCP/IP for S, q, w, h, and p options.");
break;
#endif
case 'c':
enter_status = Q_CLOAK;
break;
case 'f':
#ifdef FLY
enter_status = Q_FLY;
#else
warnx("The flying code was not compiled in.");
#endif
break;
case 's':
enter_status = Q_SCAN;
break;
case 'b':
no_beep = !no_beep;
break;
default:
usage:
fputs(
"usage:\thunt [-qmcsfS] [-n name] [-t team] [-p port] [-w message] [host]\n",
stderr);
exit(1);
}
}
#ifdef INTERNET
if (optind + 1 < ac)
goto usage;
else if (optind + 1 == ac)
contacthost = av[ac - 1];
#else
if (optind < ac)
goto usage;
#endif
#ifdef INTERNET
serverlist_setup(contacthost, contactport);
if (Show_scores) {
const struct sockaddr_storage *host;
socklen_t hostlen;
u_short msg = C_SCORES;
unsigned i;
serverlist_query(msg);
for (i = 0; i < serverlist_num(); i++) {
host = serverlist_gethost(i, &hostlen);
dump_scores(host, hostlen);
}
exit(0);
}
if (Query_driver) {
const struct sockaddr_storage *host;
socklen_t hostlen;
u_short msg = C_MESSAGE;
u_short num_players;
unsigned i;
serverlist_query(msg);
for (i = 0; i < serverlist_num(); i++) {
host = serverlist_gethost(i, &hostlen);
num_players = ntohs(serverlist_getresponse(i));
printf("%d player%s hunting on %s!\n",
num_players, (num_players == 1) ? "" : "s",
lookuphost(host, hostlen));
}
exit(0);
}
#endif
#ifdef OTTO
if (Otto_mode)
(void) strncpy(name, "otto", sizeof(name));
else
#endif
fill_in_blanks();
(void) fflush(stdout);
if (!isatty(0) || (term = getenv("TERM")) == NULL)
errx(1, "no terminal type");
if (!initscr())
errx(0, "couldn't initialize screen");
(void) noecho();
(void) cbreak();
in_visual = true;
if (LINES < SCREEN_HEIGHT || COLS < SCREEN_WIDTH)
leavex(1, "Need a larger window");
clear_the_screen();
(void) signal(SIGINT, intr);
(void) signal(SIGTERM, sigterm);
(void) signal(SIGUSR1, sigusr1);
(void) signal(SIGPIPE, SIG_IGN);
for (;;) {
#ifdef INTERNET
find_driver();
if (Daemon.sin_port == 0)
leavex(1, "Game not found, try again");
jump_in:
do {
int option;
huntsocket = socket(SOCK_FAMILY, SOCK_STREAM, 0);
if (huntsocket < 0)
err(1, "socket");
option = 1;
if (setsockopt(huntsocket, SOL_SOCKET, SO_USELOOPBACK,
&option, sizeof option) < 0)
warn("setsockopt loopback");
errno = 0;
if (connect(huntsocket, (struct sockaddr *) &Daemon,
DAEMON_SIZE) < 0) {
if (errno != ECONNREFUSED) {
leave(1, "connect");
}
}
else
break;
sleep(1);
} while (close(huntsocket) == 0);
#else /* !INTERNET */
/*
* set up a socket
*/
if ((huntsocket = socket(SOCK_FAMILY, SOCK_STREAM, 0)) < 0)
err(1, "socket");
/*
* attempt to connect the socket to a name; if it fails that
* usually means that the driver isn't running, so we start
* up the driver.
*/
Daemon.sun_family = SOCK_FAMILY;
(void) strcpy(Daemon.sun_path, huntsockpath);
if (connect(huntsocket, &Daemon, DAEMON_SIZE) < 0) {
if (errno != ENOENT) {
leavex(1, "connect2");
}
start_driver();
do {
(void) close(huntsocket);
if ((huntsocket = socket(SOCK_FAMILY, SOCK_STREAM,
0)) < 0)
err(1, "socket");
sleep(2);
} while (connect(huntsocket, &Daemon, DAEMON_SIZE) < 0);
}
#endif
do_connect(name, sizeof(name), team, enter_status);
#ifdef INTERNET
if (Send_message != NULL) {
do_message();
if (enter_status == Q_MESSAGE)
break;
Send_message = NULL;
/* don't continue as that will call find_driver */
goto jump_in;
}
#endif
playit();
if ((enter_status = quit(enter_status)) == Q_QUIT)
break;
}
leavex(0, NULL);
/* NOTREACHED */
return(0);
}
static void
do_ntlm_round (SoupURI *base_uri, gboolean use_ntlm,
const char *user, gboolean use_builtin_ntlm)
{
SoupSession *session;
gboolean alice = !g_strcmp0 (user, "alice");
gboolean bob = !g_strcmp0 (user, "bob");
gboolean alice_via_ntlm = use_ntlm && alice;
gboolean bob_via_ntlm = use_ntlm && bob;
gboolean alice_via_basic = !use_ntlm && alice;
session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
if (user) {
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), (char *)user);
if (use_ntlm && !use_builtin_ntlm)
g_setenv ("NTLMUSER", user, TRUE);
}
if (use_ntlm) {
SoupAuthManager *auth_manager;
SoupAuth *ntlm;
soup_session_add_feature_by_type (session, SOUP_TYPE_AUTH_NTLM);
auth_manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER));
ntlm = g_object_new (SOUP_TYPE_AUTH_NTLM, NULL);
soup_auth_manager_use_auth (auth_manager, base_uri, ntlm);
g_object_unref (ntlm);
}
/* 1. Server doesn't request auth, so both get_ntlm_prompt and
* get_basic_prompt are both FALSE, and likewise do_basic. But
* if we're using NTLM we'll try that even without the server
* asking.
*/
authenticated_ntlm = FALSE;
do_message (session, base_uri, "/noauth",
FALSE, use_ntlm,
FALSE, FALSE,
SOUP_STATUS_OK);
if (authenticated_ntlm != (use_ntlm && use_builtin_ntlm)) {
debug_printf (1, " ERROR: %s built-in NTLM support, but authenticate signal %s emitted\n",
use_builtin_ntlm ? "Using" : "Not using",
authenticated_ntlm ? "was" : "wasn't");
errors++;
}
/* 2. Server requires auth as Alice, so it will request that
* if we didn't already authenticate the connection to her in
* the previous step. If we authenticated as Bob in the
* previous step, then we'll just immediately get a 401 here.
* So in no case will we see the client try to do_ntlm.
*/
do_message (session, base_uri, "/alice",
!alice_via_ntlm, FALSE,
!alice_via_ntlm, alice_via_basic,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
/* 3. Server still requires auth as Alice, but this URI
* doesn't exist, so Alice should get a 404, but others still
* get 401. Alice-via-NTLM is still authenticated, and so
* won't get prompts, and Alice-via-Basic knows at this point
* to send auth without it being requested, so also won't get
* prompts. But Bob/nobody will.
*/
do_message (session, base_uri, "/alice/404",
!alice, bob_via_ntlm,
!alice, alice_via_basic,
alice ? SOUP_STATUS_NOT_FOUND :
SOUP_STATUS_UNAUTHORIZED);
/* 4. Should be exactly the same as #3, except the status code */
do_message (session, base_uri, "/alice",
!alice, bob_via_ntlm,
!alice, alice_via_basic,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
/* 5. This path requires auth as Bob; Alice-via-NTLM will get
* an immediate 401 and not try to reauthenticate.
* Alice-via-Basic will get a 401 and then try to do Basic
* (and fail). Bob-via-NTLM will try to do NTLM right away and
* succeed.
*/
do_message (session, base_uri, "/bob",
!bob_via_ntlm, bob_via_ntlm,
!bob_via_ntlm, alice_via_basic,
bob ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
/* 6. Back to /alice. Somewhat the inverse of #5; Bob-via-NTLM
* will get an immediate 401 and not try again, Alice-via-NTLM
* will try to do NTLM right away and succeed. Alice-via-Basic
* still knows about this path, so will try Basic right away
* and succeed.
*/
do_message (session, base_uri, "/alice",
!alice_via_ntlm, alice_via_ntlm,
!alice_via_ntlm, alice_via_basic,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
/* 7. Server accepts Basic auth from either user, but not NTLM.
* Since Bob-via-NTLM is unauthenticated at this point, he'll try
* NTLM before realizing that the server doesn't support it.
*/
do_message (session, base_uri, "/basic",
FALSE, bob_via_ntlm,
TRUE, user != NULL,
user != NULL ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
/* 8. Server accepts Basic or NTLM from either user.
* Alice-via-NTLM is still authenticated at this point from #6,
* and Bob-via-NTLM is authenticated from #7, so neither
* of them will do anything.
*/
do_message (session, base_uri, "/either",
!use_ntlm, FALSE,
!use_ntlm, !use_ntlm && user != NULL,
user != NULL ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
soup_test_session_abort_unref (session);
}
