*/
#include "includes.h"
-#include "dynconfig.h"
-#include "system/passwd.h"
+#include "system/filesys.h"
#include "lib/cmdline/popt_common.h"
#include "auth/auth.h"
-#include "asn_1.h"
-
-#undef DBGC_CLASS
-#define DBGC_CLASS DBGC_WINBIND
+#include "pstring.h"
+#include "smb_build.h"
#define SQUID_BUFFER_SIZE 2010
typedef void (*stdio_helper_function)(enum stdio_helper_mode stdio_helper_mode,
- char *buf, int length, void **private);
+ char *buf, int length, void **private,
+ unsigned int mux_id, void **private2);
static void manage_squid_basic_request (enum stdio_helper_mode stdio_helper_mode,
- char *buf, int length, void **private);
+ char *buf, int length, void **private,
+ unsigned int mux_id, void **private2);
static void manage_gensec_request (enum stdio_helper_mode stdio_helper_mode,
- char *buf, int length, void **private);
+ char *buf, int length, void **private,
+ unsigned int mux_id, void **private2);
static void manage_ntlm_server_1_request (enum stdio_helper_mode stdio_helper_mode,
- char *buf, int length, void **private);
+ char *buf, int length, void **private,
+ unsigned int mux_id, void **private2);
static void manage_squid_request(enum stdio_helper_mode helper_mode,
- stdio_helper_function fn, void *private);
+ stdio_helper_function fn, void **private2);
static const struct {
enum stdio_helper_mode mode;
extern int winbindd_fd;
-const char *opt_username;
-const char *opt_domain;
-const char *opt_workstation;
-const char *opt_password;
+static const char *opt_username;
+static const char *opt_domain;
+static const char *opt_workstation;
+static const char *opt_password;
+static int opt_multiplex;
+
+
+static void mux_printf(unsigned int mux_id, const char *format, ...) PRINTF_ATTRIBUTE(2, 3);
+
+static void mux_printf(unsigned int mux_id, const char *format, ...)
+{
+ va_list ap;
+
+ if (opt_multiplex) {
+ x_fprintf(x_stdout, "%d ", mux_id);
+ }
+
+ va_start(ap, format);
+ x_vfprintf(x_stdout, format, ap);
+ va_end(ap);
+}
+
/* Copy of parse_domain_user from winbindd_util.c. Parse a string of the
form DOMAIN/user into a domain and a user */
static BOOL parse_ntlm_auth_domain_user(const char *domuser, fstring domain,
- fstring user)
+ fstring user)
{
char *p = strchr(domuser,*lp_winbind_separator());
const DATA_BLOB *challenge,
const DATA_BLOB *lm_response,
const DATA_BLOB *nt_response,
- uint32 flags,
+ uint32_t flags,
DATA_BLOB *lm_session_key,
DATA_BLOB *user_session_key,
char **error_string,
char **unix_name)
{
NTSTATUS nt_status;
- uint8_t lm_pw[16], nt_pw[16];
- uint8_t *lm_pwd, *nt_pwd;
+ struct samr_Password lm_pw, nt_pw;
+ struct samr_Password *lm_pwd, *nt_pwd;
TALLOC_CTX *mem_ctx = talloc_init("local_pw_check_specified");
if (!mem_ctx) {
nt_status = NT_STATUS_NO_MEMORY;
} else {
- E_md4hash(opt_password, nt_pw);
- if (E_deshash(opt_password, lm_pw)) {
- lm_pwd = lm_pw;
+ E_md4hash(opt_password, nt_pw.hash);
+ if (E_deshash(opt_password, lm_pw.hash)) {
+ lm_pwd = &lm_pw;
} else {
lm_pwd = NULL;
}
- nt_pwd = nt_pw;
+ nt_pwd = &nt_pw;
nt_status = ntlm_password_check(mem_ctx,
+ MSV1_0_ALLOW_SERVER_TRUST_ACCOUNT |
+ MSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNT,
challenge,
lm_response,
nt_response,
- NULL, NULL,
username,
username,
domain,
domain, username, workstation,
nt_errstr(nt_status)));
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
if (error_string) {
*error_string = strdup(nt_errstr(nt_status));
}
static void manage_squid_basic_request(enum stdio_helper_mode stdio_helper_mode,
- char *buf, int length, void **private)
+ char *buf, int length, void **private,
+ unsigned int mux_id, void **private2)
{
char *user, *pass;
user=buf;
pass=memchr(buf,' ',length);
if (!pass) {
DEBUG(2, ("Password not found. Denying access\n"));
- x_fprintf(x_stdout, "ERR\n");
+ mux_printf(mux_id, "ERR\n");
return;
}
*pass='\0';
}
if (check_plaintext_auth(user, pass, False)) {
- x_fprintf(x_stdout, "OK\n");
+ mux_printf(mux_id, "OK\n");
} else {
- x_fprintf(x_stdout, "ERR\n");
+ mux_printf(mux_id, "ERR\n");
}
}
to the calling application. The callback comes from within gensec */
static void manage_gensec_get_pw_request(enum stdio_helper_mode stdio_helper_mode,
- char *buf, int length, void **private)
+ char *buf, int length, void **private,
+ unsigned int mux_id, void **password)
{
DATA_BLOB in;
- struct gensec_security **gensec_state = (struct gensec_security **)private;
if (strlen(buf) < 2) {
DEBUG(1, ("query [%s] invalid", buf));
- x_fprintf(x_stdout, "BH\n");
+ mux_printf(mux_id, "BH\n");
return;
}
if (strlen(buf) > 3) {
- in = base64_decode_data_blob(buf + 3);
+ in = base64_decode_data_blob(NULL, buf + 3);
} else {
in = data_blob(NULL, 0);
}
if (strncmp(buf, "PW ", 3) == 0) {
- (*gensec_state)->password_callback_private = talloc_strndup((*gensec_state),
- (const char *)in.data, in.length);
+ *password = talloc_strndup(*private /* hopefully the right gensec context, useful to use for talloc */,
+ (const char *)in.data, in.length);
- if ((*gensec_state)->password_callback_private == NULL) {
+ if (*password == NULL) {
DEBUG(1, ("Out of memory\n"));
- x_fprintf(x_stdout, "BH\n");
+ mux_printf(mux_id, "BH\n");
data_blob_free(&in);
return;
}
- x_fprintf(x_stdout, "OK\n");
+ mux_printf(mux_id, "OK\n");
data_blob_free(&in);
return;
}
DEBUG(1, ("Asked for (and expected) a password\n"));
- x_fprintf(x_stdout, "BH\n");
+ mux_printf(mux_id, "BH\n");
data_blob_free(&in);
}
-/*
- * Callback for gensec, to ask the calling application for a password. Uses the above function
- * for the stdio part of this.
+/**
+ * Callback for password credentails. This is not async, and when
+ * GENSEC and the credentails code is made async, it will look rather
+ * different.
*/
-static NTSTATUS get_password(struct gensec_security *gensec_security, TALLOC_CTX *mem_ctx,
- char **password)
+static const char *get_password(struct cli_credentials *credentials)
{
- *password = NULL;
+ char *password = NULL;
/* Ask for a password */
- x_fprintf(x_stdout, "PW\n");
- gensec_security->password_callback_private = NULL;
+ mux_printf((unsigned int)credentials->priv_data, "PW\n");
+ credentials->priv_data = NULL;
- manage_squid_request(NUM_HELPER_MODES /* bogus */, manage_gensec_get_pw_request, &gensec_security);
- *password = (char *)gensec_security->password_callback_private;
- if (*password) {
- return NT_STATUS_OK;
- } else {
- return NT_STATUS_INVALID_PARAMETER;
- }
+ manage_squid_request(NUM_HELPER_MODES /* bogus */, manage_gensec_get_pw_request, (void **)&password);
+ return password;
}
static void manage_gensec_request(enum stdio_helper_mode stdio_helper_mode,
- char *buf, int length, void **private)
+ char *buf, int length, void **private,
+ unsigned int mux_id, void **private2)
{
DATA_BLOB in;
DATA_BLOB out = data_blob(NULL, 0);
char *out_base64 = NULL;
const char *reply_arg = NULL;
- struct gensec_security **gensec_state = (struct gensec_security **)private;
+ struct gensec_ntlm_state {
+ struct gensec_security *gensec_state;
+ const char *set_password;
+ };
+ struct gensec_ntlm_state *state;
+
NTSTATUS nt_status;
BOOL first = False;
const char *reply_code;
+ struct cli_credentials *creds;
+
+ TALLOC_CTX *mem_ctx;
+
+ if (*private) {
+ state = *private;
+ } else {
+ state = talloc_zero(NULL, struct gensec_ntlm_state);
+ if (!state) {
+ mux_printf(mux_id, "BH No Memory\n");
+ exit(1);
+ }
+ *private = state;
+ if (opt_password) {
+ state->set_password = opt_password;
+ }
+ }
if (strlen(buf) < 2) {
DEBUG(1, ("query [%s] invalid", buf));
- x_fprintf(x_stdout, "BH\n");
+ mux_printf(mux_id, "BH\n");
return;
}
if (strlen(buf) > 3) {
- in = base64_decode_data_blob(buf + 3);
+ in = base64_decode_data_blob(NULL, buf + 3);
} else {
in = data_blob(NULL, 0);
}
if (strncmp(buf, "YR", 2) == 0) {
- if (gensec_state && *gensec_state) {
- gensec_end(gensec_state);
- *gensec_state = NULL;
+ if (state->gensec_state) {
+ talloc_free(state->gensec_state);
+ state->gensec_state = NULL;
}
} else if ( (strncmp(buf, "OK", 2) == 0)) {
/* do nothing */
(strncmp(buf, "KK ", 3) != 0) &&
(strncmp(buf, "AF ", 3) != 0) &&
(strncmp(buf, "NA ", 3) != 0) &&
+ (strncmp(buf, "UG", 2) != 0) &&
(strncmp(buf, "PW ", 3) != 0)) {
DEBUG(1, ("SPNEGO request [%s] invalid\n", buf));
- x_fprintf(x_stdout, "BH\n");
+ mux_printf(mux_id, "BH\n");
data_blob_free(&in);
return;
}
/* setup gensec */
- if (!(gensec_state && *gensec_state)) {
+ if (!(state->gensec_state)) {
switch (stdio_helper_mode) {
case GSS_SPNEGO_CLIENT:
case NTLMSSP_CLIENT_1:
/* setup the client side */
-
- if (!NT_STATUS_IS_OK(gensec_client_start(NULL, gensec_state))) {
+
+ nt_status = gensec_client_start(NULL, &state->gensec_state, NULL);
+ if (!NT_STATUS_IS_OK(nt_status)) {
exit(1);
}
- gensec_set_username(*gensec_state, opt_username);
- gensec_set_domain(*gensec_state, opt_domain);
- if (opt_password) {
- if (!NT_STATUS_IS_OK(gensec_set_password(*gensec_state, opt_password))) {
- DEBUG(1, ("Out of memory\n"));
- x_fprintf(x_stdout, "BH\n");
- data_blob_free(&in);
- return;
- }
- } else {
- gensec_set_password_callback(*gensec_state, get_password, NULL);
- }
-
+
break;
case GSS_SPNEGO_SERVER:
case SQUID_2_5_NTLMSSP:
- if (!NT_STATUS_IS_OK(gensec_server_start(NULL, gensec_state))) {
+ if (!NT_STATUS_IS_OK(gensec_server_start(NULL, &state->gensec_state, NULL))) {
exit(1);
}
break;
abort();
}
+ creds = cli_credentials_init(state->gensec_state);
+ cli_credentials_set_conf(creds);
+ if (opt_username) {
+ cli_credentials_set_username(creds, opt_username, CRED_SPECIFIED);
+ }
+ if (opt_domain) {
+ cli_credentials_set_domain(creds, opt_domain, CRED_SPECIFIED);
+ }
+ if (state->set_password) {
+ cli_credentials_set_password(creds, state->set_password, CRED_SPECIFIED);
+ } else {
+ cli_credentials_set_password_callback(creds, get_password);
+ creds->priv_data = (void*)mux_id;
+ }
+ if (opt_workstation) {
+ cli_credentials_set_workstation(creds, opt_workstation, CRED_SPECIFIED);
+ }
+
+ switch (stdio_helper_mode) {
+ case GSS_SPNEGO_SERVER:
+ case SQUID_2_5_NTLMSSP:
+ cli_credentials_set_machine_account(creds);
+ break;
+ default:
+ break;
+ }
+
+ gensec_set_credentials(state->gensec_state, creds);
+
switch (stdio_helper_mode) {
case GSS_SPNEGO_CLIENT:
case GSS_SPNEGO_SERVER:
- nt_status = gensec_start_mech_by_oid(*gensec_state, OID_SPNEGO);
+ nt_status = gensec_start_mech_by_oid(state->gensec_state, GENSEC_OID_SPNEGO);
+ if (!in.length) {
+ first = True;
+ }
break;
case NTLMSSP_CLIENT_1:
+ if (!in.length) {
+ first = True;
+ }
case SQUID_2_5_NTLMSSP:
- nt_status = gensec_start_mech_by_oid(*gensec_state, OID_NTLMSSP);
+ nt_status = gensec_start_mech_by_oid(state->gensec_state, GENSEC_OID_NTLMSSP);
break;
default:
abort();
}
if (!NT_STATUS_IS_OK(nt_status)) {
- DEBUG(1, ("SPENGO login failed to initialise: %s\n", nt_errstr(nt_status)));
- x_fprintf(x_stdout, "BH\n");
+ DEBUG(1, ("GENSEC mech failed to start: %s\n", nt_errstr(nt_status)));
+ mux_printf(mux_id, "BH\n");
return;
}
- if (!in.length) {
- first = True;
- }
+
}
+
+ /* update */
+ mem_ctx = talloc_named(NULL, 0, "manage_gensec_request internal mem_ctx");
if (strncmp(buf, "PW ", 3) == 0) {
+ state->set_password = talloc_strndup(state,
+ (const char *)in.data,
+ in.length);
+
+ cli_credentials_set_password(gensec_get_credentials(state->gensec_state),
+ state->set_password,
+ CRED_SPECIFIED);
+ mux_printf(mux_id, "OK\n");
+ data_blob_free(&in);
+ talloc_free(mem_ctx);
+ return;
+ }
- if (!NT_STATUS_IS_OK(gensec_set_password(*gensec_state,
- talloc_strndup((*gensec_state),
- (const char *)in.data,
- in.length)))) {
- DEBUG(1, ("Out of memory\n"));
- x_fprintf(x_stdout, "BH\n");
+ if (strncmp(buf, "UG", 2) == 0) {
+ int i;
+ char *grouplist = NULL;
+ struct auth_session_info *session_info;
+
+ if (!NT_STATUS_IS_OK(gensec_session_info(state->gensec_state, &session_info))) {
+ DEBUG(1, ("gensec_session_info failed: %s\n", nt_errstr(nt_status)));
+ mux_printf(mux_id, "BH %s\n", nt_errstr(nt_status));
data_blob_free(&in);
+ talloc_free(mem_ctx);
return;
}
+
+ /* get the string onto the context */
+ grouplist = talloc_strdup(mem_ctx, "");
+
+ for (i=0; i<session_info->security_token->num_sids; i++) {
+ struct security_token *token = session_info->security_token;
+ const char *sidstr = dom_sid_string(session_info,
+ token->sids[i]);
+ grouplist = talloc_asprintf_append(grouplist, "%s,", sidstr);
+ }
- x_fprintf(x_stdout, "OK\n");
+ mux_printf(mux_id, "GL %s\n", grouplist);
+ talloc_free(session_info);
data_blob_free(&in);
+ talloc_free(mem_ctx);
return;
}
- /* update */
-
- nt_status = gensec_update(*gensec_state, NULL, in, &out);
+ nt_status = gensec_update(state->gensec_state, mem_ctx, in, &out);
/* don't leak 'bad password'/'no such user' info to the network client */
- nt_status = nt_status_squash(nt_status);
+ nt_status = auth_nt_status_squash(nt_status);
if (out.length) {
- out_base64 = base64_encode_data_blob(out);
+ out_base64 = base64_encode_data_blob(mem_ctx, out);
} else {
out_base64 = NULL;
}
+
if (NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
reply_arg = "*";
if (first) {
reply_code = "YR";
- } else if ((*gensec_state)->gensec_role == GENSEC_CLIENT) {
+ } else if (state->gensec_state->gensec_role == GENSEC_CLIENT) {
reply_code = "KK";
- } else if ((*gensec_state)->gensec_role == GENSEC_SERVER) {
+ } else if (state->gensec_state->gensec_role == GENSEC_SERVER) {
reply_code = "TT";
} else {
abort();
reply_code = "NA";
reply_arg = nt_errstr(nt_status);
DEBUG(1, ("GENSEC login failed: %s\n", nt_errstr(nt_status)));
- } else if /* OK */ ((*gensec_state)->gensec_role == GENSEC_SERVER) {
+ } else if /* OK */ (state->gensec_state->gensec_role == GENSEC_SERVER) {
struct auth_session_info *session_info;
- nt_status = gensec_session_info(*gensec_state, &session_info);
+ nt_status = gensec_session_info(state->gensec_state, &session_info);
if (!NT_STATUS_IS_OK(nt_status)) {
reply_code = "BH";
reply_arg = nt_errstr(nt_status);
} else {
reply_code = "AF";
- reply_arg = talloc_asprintf(*gensec_state,
- "%s%s%s", session_info->server_info->domain,
+ reply_arg = talloc_asprintf(state->gensec_state,
+ "%s%s%s", session_info->server_info->domain_name,
lp_winbind_separator(), session_info->server_info->account_name);
talloc_free(session_info);
}
- } else if ((*gensec_state)->gensec_role == GENSEC_CLIENT) {
+ } else if (state->gensec_state->gensec_role == GENSEC_CLIENT) {
reply_code = "AF";
- reply_arg = NULL;
+ reply_arg = out_base64;
} else {
abort();
}
switch (stdio_helper_mode) {
case GSS_SPNEGO_SERVER:
- x_fprintf(x_stdout, "%s %s %s\n", reply_code,
+ mux_printf(mux_id, "%s %s %s\n", reply_code,
out_base64 ? out_base64 : "*",
reply_arg ? reply_arg : "*");
break;
default:
if (out_base64) {
- x_fprintf(x_stdout, "%s %s\n", reply_code, out_base64);
+ mux_printf(mux_id, "%s %s\n", reply_code, out_base64);
} else if (reply_arg) {
- x_fprintf(x_stdout, "%s %s\n", reply_code, reply_arg);
+ mux_printf(mux_id, "%s %s\n", reply_code, reply_arg);
} else {
- x_fprintf(x_stdout, "%s\n", reply_code);
+ mux_printf(mux_id, "%s\n", reply_code);
}
}
- SAFE_FREE(out_base64);
+ talloc_free(mem_ctx);
return;
}
static void manage_ntlm_server_1_request(enum stdio_helper_mode stdio_helper_mode,
- char *buf, int length, void **private)
+ char *buf, int length, void **private,
+ unsigned int mux_id, void **private2)
{
char *request, *parameter;
static DATA_BLOB challenge;
if (strequal(buf, ".")) {
if (!full_username && !username) {
- x_fprintf(x_stdout, "Error: No username supplied!\n");
+ mux_printf(mux_id, "Error: No username supplied!\n");
} else if (plaintext_password) {
/* handle this request as plaintext */
if (!full_username) {
if (asprintf(&full_username, "%s%c%s", domain, *lp_winbind_separator(), username) == -1) {
- x_fprintf(x_stdout, "Error: Out of memory in asprintf!\n.\n");
+ mux_printf(mux_id, "Error: Out of memory in asprintf!\n.\n");
return;
}
}
if (check_plaintext_auth(full_username, plaintext_password, False)) {
- x_fprintf(x_stdout, "Authenticated: Yes\n");
+ mux_printf(mux_id, "Authenticated: Yes\n");
} else {
- x_fprintf(x_stdout, "Authenticated: No\n");
+ mux_printf(mux_id, "Authenticated: No\n");
}
} else if (!lm_response.data && !nt_response.data) {
- x_fprintf(x_stdout, "Error: No password supplied!\n");
+ mux_printf(mux_id, "Error: No password supplied!\n");
} else if (!challenge.data) {
- x_fprintf(x_stdout, "Error: No lanman-challenge supplied!\n");
+ mux_printf(mux_id, "Error: No lanman-challenge supplied!\n");
} else {
char *error_string = NULL;
DATA_BLOB lm_key;
DATA_BLOB user_session_key;
- uint32 flags = 0;
+ uint32_t flags = 0;
if (full_username && !username) {
fstring fstr_user;
if (!parse_ntlm_auth_domain_user(full_username, fstr_user, fstr_domain)) {
/* username might be 'tainted', don't print into our new-line deleimianted stream */
- x_fprintf(x_stdout, "Error: Could not parse into domain and username\n");
+ mux_printf(mux_id, "Error: Could not parse into domain and username\n");
}
SAFE_FREE(username);
SAFE_FREE(domain);
&error_string,
NULL))) {
- x_fprintf(x_stdout, "Authenticated: No\n");
- x_fprintf(x_stdout, "Authentication-Error: %s\n.\n", error_string);
+ mux_printf(mux_id, "Authenticated: No\n");
+ mux_printf(mux_id, "Authentication-Error: %s\n.\n", error_string);
SAFE_FREE(error_string);
} else {
static char zeros[16];
char *hex_lm_key;
char *hex_user_session_key;
- x_fprintf(x_stdout, "Authenticated: Yes\n");
+ mux_printf(mux_id, "Authenticated: Yes\n");
if (ntlm_server_1_lm_session_key
&& lm_key.length
hex_encode(lm_key.data,
lm_key.length,
&hex_lm_key);
- x_fprintf(x_stdout, "LANMAN-Session-Key: %s\n", hex_lm_key);
+ mux_printf(mux_id, "LANMAN-Session-Key: %s\n", hex_lm_key);
SAFE_FREE(hex_lm_key);
}
hex_encode(user_session_key.data,
user_session_key.length,
&hex_user_session_key);
- x_fprintf(x_stdout, "User-Session-Key: %s\n", hex_user_session_key);
+ mux_printf(mux_id, "User-Session-Key: %s\n", hex_user_session_key);
SAFE_FREE(hex_user_session_key);
}
}
SAFE_FREE(plaintext_password);
ntlm_server_1_user_session_key = False;
ntlm_server_1_lm_session_key = False;
- x_fprintf(x_stdout, ".\n");
+ mux_printf(mux_id, ".\n");
return;
}
if (!parameter) {
DEBUG(0, ("Parameter not found!\n"));
- x_fprintf(x_stdout, "Error: Parameter not found!\n.\n");
+ mux_printf(mux_id, "Error: Parameter not found!\n.\n");
return;
}
if (strequal(request, "LANMAN-Challenge")) {
challenge = strhex_to_data_blob(parameter);
if (challenge.length != 8) {
- x_fprintf(x_stdout, "Error: hex decode of %s failed! (got %d bytes, expected 8)\n.\n",
+ mux_printf(mux_id, "Error: hex decode of %s failed! (got %d bytes, expected 8)\n.\n",
parameter,
(int)challenge.length);
challenge = data_blob(NULL, 0);
} else if (strequal(request, "NT-Response")) {
nt_response = strhex_to_data_blob(parameter);
if (nt_response.length < 24) {
- x_fprintf(x_stdout, "Error: hex decode of %s failed! (only got %d bytes, needed at least 24)\n.\n",
+ mux_printf(mux_id, "Error: hex decode of %s failed! (only got %d bytes, needed at least 24)\n.\n",
parameter,
(int)nt_response.length);
nt_response = data_blob(NULL, 0);
} else if (strequal(request, "LANMAN-Response")) {
lm_response = strhex_to_data_blob(parameter);
if (lm_response.length != 24) {
- x_fprintf(x_stdout, "Error: hex decode of %s failed! (got %d bytes, expected 24)\n.\n",
+ mux_printf(mux_id, "Error: hex decode of %s failed! (got %d bytes, expected 24)\n.\n",
parameter,
(int)lm_response.length);
lm_response = data_blob(NULL, 0);
} else if (strequal(request, "Request-LanMan-Session-Key")) {
ntlm_server_1_lm_session_key = strequal(parameter, "Yes");
} else {
- x_fprintf(x_stdout, "Error: Unknown request %s\n.\n", request);
+ mux_printf(mux_id, "Error: Unknown request %s\n.\n", request);
}
}
-static void manage_squid_request(enum stdio_helper_mode helper_mode, stdio_helper_function fn, void *private)
+static void manage_squid_request(enum stdio_helper_mode helper_mode,
+ stdio_helper_function fn, void **private2)
{
char buf[SQUID_BUFFER_SIZE+1];
+ unsigned int mux_id;
int length;
char *c;
static BOOL err;
+ struct mux_private {
+ unsigned int max_mux;
+ void **private_pointers;
+ };
+
+ static struct mux_private *mux_private;
+ static void *normal_private;
+ void **private;
/* this is not a typo - x_fgets doesn't work too well under squid */
if (fgets(buf, sizeof(buf)-1, stdin) == NULL) {
return;
}
if (err) {
- DEBUG(2, ("Oversized message\n"));
- x_fprintf(x_stderr, "ERR\n");
+ DEBUG(0, ("Oversized message\n"));
+ x_fprintf(x_stdout, "ERR\n");
err = 0;
return;
}
DEBUG(10, ("Got '%s' from squid (length: %d).\n",buf,length));
if (buf[0] == '\0') {
- DEBUG(2, ("Invalid Request\n"));
- x_fprintf(x_stderr, "ERR\n");
+ DEBUG(0, ("Invalid Request (empty)\n"));
+ x_fprintf(x_stdout, "ERR\n");
return;
}
+
+ if (opt_multiplex) {
+ if (sscanf(buf, "%u ", &mux_id) != 1) {
+ DEBUG(0, ("Invalid Request - no multiplex id\n"));
+ x_fprintf(x_stdout, "ERR\n");
+ return;
+ }
+ if (!mux_private) {
+ mux_private = talloc(NULL, struct mux_private);
+ mux_private->max_mux = 0;
+ mux_private->private_pointers = NULL;
+ }
+
+ c=strchr(buf,' ');
+ if (!c) {
+ DEBUG(0, ("Invalid Request - no data after multiplex id\n"));
+ x_fprintf(x_stdout, "ERR\n");
+ return;
+ }
+ c++;
+ if (mux_id >= mux_private->max_mux) {
+ unsigned int prev_max = mux_private->max_mux;
+ mux_private->max_mux = mux_id + 1;
+ mux_private->private_pointers
+ = talloc_realloc(mux_private,
+ mux_private->private_pointers,
+ void *, mux_private->max_mux);
+ memset(&mux_private->private_pointers[prev_max], '\0',
+ (sizeof(*mux_private->private_pointers) * (mux_private->max_mux - prev_max)));
+ };
+
+ private = &mux_private->private_pointers[mux_id];
+ } else {
+ c = buf;
+ private = &normal_private;
+ }
- fn(helper_mode, buf, length, private);
+ fn(helper_mode, c, length, private, mux_id, private2);
}
-static void squid_stream(enum stdio_helper_mode stdio_mode, stdio_helper_function fn) {
- void *private = NULL;
+static void squid_stream(enum stdio_helper_mode stdio_mode,
+ stdio_helper_function fn) {
/* initialize FDescs */
x_setbuf(x_stdout, NULL);
x_setbuf(x_stderr, NULL);
while(1) {
- manage_squid_request(stdio_mode, fn, &private);
+ manage_squid_request(stdio_mode, fn, NULL);
}
}
OPT_LM_KEY,
OPT_USER_SESSION_KEY,
OPT_DIAGNOSTICS,
- OPT_REQUIRE_MEMBERSHIP
+ OPT_REQUIRE_MEMBERSHIP,
+ OPT_MULTIPLEX,
};
- int main(int argc, const char **argv)
+int main(int argc, const char **argv)
{
static const char *helper_protocol;
int opt;
{ "workstation", 0, POPT_ARG_STRING, &opt_workstation, OPT_WORKSTATION, "workstation"},
{ "username", 0, POPT_ARG_STRING, &opt_username, OPT_PASSWORD, "Username"},
{ "password", 0, POPT_ARG_STRING, &opt_password, OPT_PASSWORD, "User's plaintext password"},
+ { "multiplex", 0, POPT_ARG_NONE, &opt_multiplex, OPT_MULTIPLEX, "Multiplex Mode"},
POPT_COMMON_SAMBA
+ POPT_COMMON_VERSION
POPT_TABLEEND
};
/* Samba client initialisation */
- setup_logging("ntlm_auth", DEBUG_STDERR);
-
- if (!lp_load(dyn_CONFIGFILE, True, False, False)) {
- d_fprintf(stderr, "wbinfo: error opening config file %s. Error was %s\n",
- dyn_CONFIGFILE, strerror(errno));
- exit(1);
- }
+ setup_logging(NULL, DEBUG_STDERR);
/* Parse options */
return 1;
}
+ ntlm_auth_init_subsystems;
+
+
if (opt_domain == NULL) {
opt_domain = lp_workgroup();
}
git.samba.org / abartlet / samba.git / .git / blobdiff