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); }