/****************************************************************************
send a message
****************************************************************************/
int cli_message_text_build(struct cli_state *cli, char *msg, int len, int grp)
{
char *msgdos;
int lendos;
char *p;
memset(cli->outbuf,'\0',smb_size);
set_message(cli->outbuf,1,0,True);
SCVAL(cli->outbuf,smb_com,SMBsendtxt);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
SSVAL(cli->outbuf,smb_vwv0,grp);
p = smb_buf(cli->outbuf);
*p++ = 1;
if ((lendos = (int)convert_string_allocate(NULL,CH_UNIX, CH_DOS, msg,len, (void **)(void *)&msgdos, True)) < 0 || !msgdos) {
DEBUG(3,("Conversion failed, sending message in UNIX charset\n"));
SSVAL(p, 0, len); p += 2;
memcpy(p, msg, len);
p += len;
} else {
SSVAL(p, 0, lendos); p += 2;
memcpy(p, msgdos, lendos);
p += lendos;
SAFE_FREE(msgdos);
}
cli_setup_bcc(cli, p);
return(PTR_DIFF(p, cli->outbuf));
}
size_t push_utf8_allocate(char **dest, const char *src)
{
size_t src_len = strlen(src)+1;
*dest = NULL;
return convert_string_allocate(NULL, CH_UNIX, CH_UTF8, src, src_len, (void **)dest, True);
}
size_t charset_to_utf8_allocate(charset_t ch, char **dest, const char *src)
{
size_t src_len = strlen(src);
*dest = NULL;
return convert_string_allocate(ch, CH_UTF8, src, src_len, dest);
}
size_t charset_to_ucs2_allocate(charset_t ch, ucs2_t **dest, const char *src)
{
size_t src_len = strlen(src);
*dest = NULL;
return convert_string_allocate(ch, CH_UCS2, src, src_len, (char**) dest);
}
int main(int ac, char **av)
{
char *Obj = NULL, *Type = NULL, *Zone = NULL;
char *convname = NULL;
struct at_addr addr;
int c;
charset_t chMac = CH_MAC;
extern char *optarg;
extern int optind;
memset(&addr, 0, sizeof(addr));
while ((c = getopt(ac, av, "A:m:")) != EOF) {
switch (c) {
case 'A':
if (!atalk_aton(optarg, &addr)) {
fprintf(stderr, "Bad address.\n");
exit(1);
}
break;
case 'm':
if ((charset_t)-1 == (chMac = add_charset(optarg)) ) {
fprintf(stderr, "Invalid Mac charset.\n");
exit(1);
}
break;
default:
Usage(av[0]);
break;
}
}
if (ac - optind != 1) {
Usage( av[ 0 ] );
}
/* Convert the name */
if ((size_t)(-1) == convert_string_allocate(CH_UNIX, chMac,
av[optind], -1, &convname))
convname = av[optind];
/*
* Get the name. If Type or Obj aren't specified, error.
*/
if ( nbp_name( convname, &Obj, &Type, &Zone ) || !Obj || !Type ) {
Usage( av[ 0 ] );
}
if ( nbp_unrgstr( Obj, Type, Zone, &addr ) < 0 ) {
fprintf( stderr, "Can't unregister %s:%s@%s\n", Obj, Type,
Zone ? Zone : "*" );
exit( 1 );
}
return 0;
}
/**
* Convert between character sets, allocating a new buffer using talloc for the result.
*
* @param srclen length of source buffer.
* @param dest always set at least to NULL
* @note -1 is not accepted for srclen.
*
* @returns Size in bytes of the converted string; or -1 in case of error.
**/
size_t convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
void const *src, size_t srclen, void *dst,
BOOL allow_bad_conv)
{
void **dest = (void **)dst;
size_t dest_len;
*dest = NULL;
dest_len=convert_string_allocate(ctx, from, to, src, srclen, dest, allow_bad_conv);
if (dest_len == (size_t)-1)
return (size_t)-1;
if (*dest == NULL)
return (size_t)-1;
return dest_len;
}
size_t unix_strlower(const char *src, size_t srclen, char *dest, size_t destlen)
{
size_t size;
smb_ucs2_t *buffer = NULL;
size = convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, srclen,
(void **)(void *)&buffer, True);
if (size == (size_t)-1 || !buffer) {
smb_panic("failed to create UCS2 buffer");
}
if (!strlower_w(buffer) && (dest == src)) {
SAFE_FREE(buffer);
return srclen;
}
size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
SAFE_FREE(buffer);
return size;
}
size_t pull_ucs2_allocate(char **dest, const smb_ucs2_t *src)
{
size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
*dest = NULL;
return convert_string_allocate(NULL, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
}
static bool test_plaintext(enum ntlm_break break_which)
{
NTSTATUS nt_status;
uint32 flags = 0;
DATA_BLOB nt_response = data_blob_null;
DATA_BLOB lm_response = data_blob_null;
char *password;
smb_ucs2_t *nt_response_ucs2;
size_t converted_size;
uchar user_session_key[16];
uchar lm_key[16];
static const uchar zeros[8] = { 0, };
DATA_BLOB chall = data_blob(zeros, sizeof(zeros));
char *error_string;
ZERO_STRUCT(user_session_key);
flags |= WBFLAG_PAM_LMKEY;
flags |= WBFLAG_PAM_USER_SESSION_KEY;
if (!push_ucs2_allocate(&nt_response_ucs2, opt_password,
&converted_size))
{
DEBUG(0, ("push_ucs2_allocate failed!\n"));
exit(1);
}
nt_response.data = (unsigned char *)nt_response_ucs2;
nt_response.length = strlen_w(nt_response_ucs2)*sizeof(smb_ucs2_t);
if ((password = strdup_upper(opt_password)) == NULL) {
DEBUG(0, ("strdup_upper failed!\n"));
exit(1);
}
if (!convert_string_allocate(NULL, CH_UNIX,
CH_DOS, password,
strlen(password)+1,
&lm_response.data,
&lm_response.length, True)) {
DEBUG(0, ("convert_string_allocate failed!\n"));
exit(1);
}
SAFE_FREE(password);
switch (break_which) {
case BREAK_NONE:
break;
case BREAK_LM:
lm_response.data[0]++;
break;
case BREAK_NT:
nt_response.data[0]++;
break;
case NO_LM:
SAFE_FREE(lm_response.data);
lm_response.length = 0;
break;
case NO_NT:
SAFE_FREE(nt_response.data);
nt_response.length = 0;
break;
}
nt_status = contact_winbind_auth_crap(opt_username, opt_domain,
opt_workstation,
&chall,
&lm_response,
&nt_response,
flags,
lm_key,
user_session_key,
&error_string, NULL);
SAFE_FREE(nt_response.data);
SAFE_FREE(lm_response.data);
data_blob_free(&chall);
if (!NT_STATUS_IS_OK(nt_status)) {
d_printf("%s (0x%x)\n",
error_string,
NT_STATUS_V(nt_status));
SAFE_FREE(error_string);
return break_which == BREAK_NT;
}
return break_which != BREAK_NT;
}
/***************************************************************************
load all the variables passed to the CGI program. May have multiple variables
with the same name and the same or different values. Takes a file parameter
for simulating CGI invocation eg loading saved preferences.
***************************************************************************/
void cgi_load_variables(void)
{
static char *line;
char *p, *s, *tok;
int len, i;
FILE *f = stdin;
#ifdef DEBUG_COMMENTS
char dummy[100]="";
print_title(dummy);
d_printf("<!== Start dump in cgi_load_variables() %s ==>\n",__FILE__);
#endif
if (!content_length) {
p = getenv("CONTENT_LENGTH");
len = p?atoi(p):0;
} else {
len = content_length;
}
if (len > 0 &&
(request_post ||
((s=getenv("REQUEST_METHOD")) &&
strequal(s,"POST")))) {
while (len && (line=grab_line(f, &len))) {
p = strchr_m(line,'=');
if (!p) continue;
*p = 0;
variables[num_variables].name = SMB_STRDUP(line);
variables[num_variables].value = SMB_STRDUP(p+1);
SAFE_FREE(line);
if (!variables[num_variables].name ||
!variables[num_variables].value)
continue;
plus_to_space_unescape(variables[num_variables].value);
rfc1738_unescape(variables[num_variables].value);
plus_to_space_unescape(variables[num_variables].name);
rfc1738_unescape(variables[num_variables].name);
#ifdef DEBUG_COMMENTS
printf("<!== POST var %s has value \"%s\" ==>\n",
variables[num_variables].name,
variables[num_variables].value);
#endif
num_variables++;
if (num_variables == MAX_VARIABLES) break;
}
}
fclose(stdin);
open("/dev/null", O_RDWR);
if ((s=query_string) || (s=getenv("QUERY_STRING"))) {
char *saveptr;
for (tok=strtok_r(s, "&;", &saveptr); tok;
tok=strtok_r(NULL, "&;", &saveptr)) {
p = strchr_m(tok,'=');
if (!p) continue;
*p = 0;
variables[num_variables].name = SMB_STRDUP(tok);
variables[num_variables].value = SMB_STRDUP(p+1);
if (!variables[num_variables].name ||
!variables[num_variables].value)
continue;
plus_to_space_unescape(variables[num_variables].value);
rfc1738_unescape(variables[num_variables].value);
plus_to_space_unescape(variables[num_variables].name);
rfc1738_unescape(variables[num_variables].name);
#ifdef DEBUG_COMMENTS
printf("<!== Commandline var %s has value \"%s\" ==>\n",
variables[num_variables].name,
variables[num_variables].value);
#endif
num_variables++;
if (num_variables == MAX_VARIABLES) break;
}
}
#ifdef DEBUG_COMMENTS
printf("<!== End dump in cgi_load_variables() ==>\n");
#endif
/* variables from the client are in UTF-8 - convert them
to our internal unix charset before use */
for (i=0;i<num_variables;i++) {
TALLOC_CTX *frame = talloc_stackframe();
char *dest = NULL;
size_t dest_len;
convert_string_allocate(frame, CH_UTF8, CH_UNIX,
variables[i].name, strlen(variables[i].name),
&dest, &dest_len, True);
SAFE_FREE(variables[i].name);
variables[i].name = SMB_STRDUP(dest ? dest : "");
dest = NULL;
convert_string_allocate(frame, CH_UTF8, CH_UNIX,
variables[i].value, strlen(variables[i].value),
&dest, &dest_len, True);
SAFE_FREE(variables[i].value);
variables[i].value = SMB_STRDUP(dest ? dest : "");
TALLOC_FREE(frame);
}
}
/* --------------------------------- */
size_t ucs2_to_charset_allocate(charset_t ch, char **dest, const ucs2_t *src)
{
size_t src_len = (strlen_w(src)) * sizeof(ucs2_t);
*dest = NULL;
return convert_string_allocate(CH_UCS2, ch, src, src_len, dest);
}
/****************************************************************************
deliver the message
****************************************************************************/
static void msg_deliver(void)
{
pstring name;
int i;
int fd;
char *msg;
int len;
if (! (*lp_msg_command()))
{
DEBUG(1,("no messaging command specified\n"));
msgpos = 0;
return;
}
/* put it in a temporary file */
slprintf(name,sizeof(name)-1, "%s/msg.XXXXXX",tmpdir());
fd = smb_mkstemp(name);
if (fd == -1) {
DEBUG(1,("can't open message file %s\n",name));
return;
}
/*
* Incoming message is in DOS codepage format. Convert to UNIX.
*/
if ((len = convert_string_allocate(NULL,CH_DOS, CH_UNIX, msgbuf, msgpos, (void **) &msg)) < 0 || !msg) {
DEBUG(3,("Conversion failed, delivering message in DOS codepage format\n"));
for (i = 0; i < msgpos;) {
if (msgbuf[i] == '\r' && i < (msgpos-1) && msgbuf[i+1] == '\n') {
i++; continue;
}
write(fd, &msgbuf[i++], 1);
}
} else {
for (i = 0; i < len;) {
if (msg[i] == '\r' && i < (len-1) && msg[i+1] == '\n') {
i++; continue;
}
write(fd, &msg[i++],1);
}
SAFE_FREE(msg);
}
close(fd);
/* run the command */
if (*lp_msg_command())
{
fstring alpha_msgfrom;
fstring alpha_msgto;
pstring s;
pstrcpy(s,lp_msg_command());
pstring_sub(s,"%f",alpha_strcpy(alpha_msgfrom,msgfrom,NULL,sizeof(alpha_msgfrom)));
pstring_sub(s,"%t",alpha_strcpy(alpha_msgto,msgto,NULL,sizeof(alpha_msgto)));
standard_sub_basic(current_user_info.smb_name, s, sizeof(s));
pstring_sub(s,"%s",name);
smbrun(s,NULL);
}
msgpos = 0;
}