1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-25 23:21:54 +03:00
samba-mirror/source3/lib/charcnv.c
Andreas Schneider 71b40127e1 s3:lib: Fix code spelling
Signed-off-by: Andreas Schneider <asn@samba.org>
Reviewed-by: Martin Schwenke <mschwenke@ddn.com>
2023-07-13 05:41:36 +00:00

536 lines
13 KiB
C

/*
Unix SMB/CIFS implementation.
Character set conversion Extensions
Copyright (C) Igor Vergeichik <iverg@mail.ru> 2001
Copyright (C) Andrew Tridgell 2001
Copyright (C) Simo Sorce 2001
Copyright (C) Martin Pool 2003
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
/**
* Destroy global objects allocated by init_iconv()
**/
void gfree_charcnv(void)
{
free_iconv_handle();
}
/**
* Copy a string from a char* unix src to a dos codepage string destination.
*
* @return the number of bytes occupied by the string in the destination.
*
* @param flags can include
* <dl>
* <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
* <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
* </dl>
*
* @param dest_len the maximum length in bytes allowed in the
* destination.
**/
size_t push_ascii(void *dest, const char *src, size_t dest_len, int flags)
{
size_t src_len = 0;
char *tmpbuf = NULL;
size_t size = 0;
bool ret;
/* No longer allow a length of -1. */
if (dest_len == (size_t)-1) {
smb_panic("push_ascii - dest_len == -1");
}
if (flags & STR_UPPER) {
tmpbuf = SMB_STRDUP(src);
if (!tmpbuf) {
smb_panic("malloc fail");
}
if (!strupper_m(tmpbuf)) {
if ((flags & (STR_TERMINATE|STR_TERMINATE_ASCII)) &&
dest &&
dest_len > 0) {
*(char *)dest = 0;
}
SAFE_FREE(tmpbuf);
return 0;
}
src = tmpbuf;
}
src_len = strlen(src);
if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII)) {
src_len++;
}
ret = convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, &size);
SAFE_FREE(tmpbuf);
if (ret == false) {
if ((flags & (STR_TERMINATE | STR_TERMINATE_ASCII)) &&
dest_len > 0) {
((char *)dest)[0] = '\0';
}
return 0;
}
return size;
}
/********************************************************************
Push and malloc an ascii string. src and dest null terminated.
********************************************************************/
/**
* Copy a string from a dos codepage source to a unix char* destination.
*
* The resulting string in "dest" is always null terminated.
*
* @param flags can have:
* <dl>
* <dt>STR_TERMINATE</dt>
* <dd>STR_TERMINATE means the string in @p src
* is null terminated, and src_len is ignored.</dd>
* </dl>
*
* @param src_len is the length of the source area in bytes.
* @returns the number of bytes occupied by the string in @p src.
**/
size_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
{
bool ret;
size_t size = 0;
if (dest_len == (size_t)-1) {
/* No longer allow dest_len of -1. */
smb_panic("pull_ascii - invalid dest_len of -1");
}
if (flags & STR_TERMINATE) {
if (src_len == (size_t)-1) {
src_len = strlen((const char *)src) + 1;
} else {
size_t len = strnlen((const char *)src, src_len);
if (len < src_len)
len++;
src_len = len;
}
}
ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, &size);
if (ret == false) {
size = 0;
dest_len = 0;
}
if (dest_len && size) {
/* Did we already process the terminating zero ? */
if (dest[MIN(size-1, dest_len-1)] != 0) {
dest[MIN(size, dest_len-1)] = 0;
}
} else {
dest[0] = 0;
}
return src_len;
}
/**
* Copy a string from a dos codepage source to a unix char* destination.
* Talloc version.
*
* The resulting string in "dest" is always null terminated.
*
* @param flags can have:
* <dl>
* <dt>STR_TERMINATE</dt>
* <dd>STR_TERMINATE means the string in @p src
* is null terminated, and src_len is ignored.</dd>
* </dl>
*
* @param src_len is the length of the source area in bytes.
* @returns the number of bytes occupied by the string in @p src.
**/
static size_t pull_ascii_base_talloc(TALLOC_CTX *ctx,
char **ppdest,
const void *src,
size_t src_len,
int flags)
{
char *dest = NULL;
size_t dest_len;
*ppdest = NULL;
if (!src_len) {
return 0;
}
if (src_len == (size_t)-1) {
smb_panic("src_len == -1 in pull_ascii_base_talloc");
}
if (flags & STR_TERMINATE) {
size_t len = strnlen((const char *)src, src_len);
if (len < src_len)
len++;
src_len = len;
/* Ensure we don't use an insane length from the client. */
if (src_len >= 1024*1024) {
char *msg = talloc_asprintf(ctx,
"Bad src length (%u) in "
"pull_ascii_base_talloc",
(unsigned int)src_len);
smb_panic(msg);
}
}
/* src_len != -1 here. */
if (!convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, &dest,
&dest_len)) {
dest_len = 0;
}
if (dest_len && dest) {
/* Did we already process the terminating zero ? */
if (dest[dest_len-1] != 0) {
size_t size = talloc_get_size(dest);
/* Have we got space to append the '\0' ? */
if (size <= dest_len) {
/* No, realloc. */
dest = talloc_realloc(ctx, dest, char,
dest_len+1);
if (!dest) {
/* talloc fail. */
dest_len = (size_t)-1;
return 0;
}
}
/* Yay - space ! */
dest[dest_len] = '\0';
dest_len++;
}
} else if (dest) {
dest[0] = 0;
}
*ppdest = dest;
return src_len;
}
/**
* Copy a string from a char* src to a unicode destination.
*
* @returns the number of bytes occupied by the string in the destination.
*
* @param flags can have:
*
* <dl>
* <dt>STR_TERMINATE <dd>means include the null termination.
* <dt>STR_UPPER <dd>means uppercase in the destination.
* <dt>STR_NOALIGN <dd>means don't do alignment.
* </dl>
*
* @param dest_len is the maximum length allowed in the
* destination.
**/
static size_t push_ucs2(const void *base_ptr, void *dest, const char *src, size_t dest_len, int flags)
{
size_t len=0;
size_t src_len;
size_t size = 0;
bool ret;
if (dest_len == (size_t)-1) {
/* No longer allow dest_len of -1. */
smb_panic("push_ucs2 - invalid dest_len of -1");
}
if (flags & STR_TERMINATE)
src_len = (size_t)-1;
else
src_len = strlen(src);
if (ucs2_align(base_ptr, dest, flags)) {
*(char *)dest = 0;
dest = (void *)((char *)dest + 1);
if (dest_len)
dest_len--;
len++;
}
/* ucs2 is always a multiple of 2 bytes */
dest_len &= ~1;
ret = convert_string(CH_UNIX, CH_UTF16LE, src, src_len, dest, dest_len, &size);
if (ret == false) {
if ((flags & STR_TERMINATE) &&
dest &&
dest_len) {
*(char *)dest = 0;
}
return len;
}
len += size;
if (flags & STR_UPPER) {
smb_ucs2_t *dest_ucs2 = (smb_ucs2_t *)dest;
size_t i;
/* We check for i < (size / 2) below as the dest string isn't null
terminated if STR_TERMINATE isn't set. */
for (i = 0; i < (size / 2) && i < (dest_len / 2) && dest_ucs2[i]; i++) {
smb_ucs2_t v = toupper_w(dest_ucs2[i]);
if (v != dest_ucs2[i]) {
dest_ucs2[i] = v;
}
}
}
return len;
}
/**
Copy a string from a ucs2 source to a unix char* destination.
Talloc version with a base pointer.
Uses malloc if TALLOC_CTX is NULL (this is a bad interface and
needs fixing. JRA).
Flags can have:
STR_TERMINATE means the string in src is null terminated.
STR_NOALIGN means don't try to align.
if STR_TERMINATE is set then src_len is ignored if it is -1.
src_len is the length of the source area in bytes
Return the number of bytes occupied by the string in src.
The resulting string in "dest" is always null terminated.
**/
static size_t pull_ucs2_base_talloc(TALLOC_CTX *ctx,
const void *base_ptr,
char **ppdest,
const void *src,
size_t src_len,
int flags)
{
char *dest;
size_t dest_len;
size_t ucs2_align_len = 0;
*ppdest = NULL;
#ifdef DEVELOPER
/* Ensure we never use the braindead "malloc" variant. */
if (ctx == NULL) {
smb_panic("NULL talloc CTX in pull_ucs2_base_talloc\n");
}
#endif
if (!src_len) {
return 0;
}
if (src_len == (size_t)-1) {
/* no longer used anywhere, but worth checking */
smb_panic("sec_len == -1 in pull_ucs2_base_talloc");
}
if (ucs2_align(base_ptr, src, flags)) {
src = (const void *)((const char *)src + 1);
src_len--;
ucs2_align_len = 1;
}
if (flags & STR_TERMINATE) {
/* src_len -1 is the default for null terminated strings. */
size_t len = strnlen_w((const smb_ucs2_t *)src,
src_len/2);
if (len < src_len/2)
len++;
src_len = len*2;
/* Ensure we don't use an insane length from the client. */
if (src_len >= 1024*1024) {
smb_panic("Bad src length in pull_ucs2_base_talloc\n");
}
}
/* ucs2 is always a multiple of 2 bytes */
src_len &= ~1;
if (!convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len,
(void *)&dest, &dest_len)) {
dest_len = 0;
}
if (dest_len) {
/* Did we already process the terminating zero ? */
if (dest[dest_len-1] != 0) {
size_t size = talloc_get_size(dest);
/* Have we got space to append the '\0' ? */
if (size <= dest_len) {
/* No, realloc. */
dest = talloc_realloc(ctx, dest, char,
dest_len+1);
if (!dest) {
/* talloc fail. */
dest_len = (size_t)-1;
return 0;
}
}
/* Yay - space ! */
dest[dest_len] = '\0';
dest_len++;
}
} else if (dest) {
dest[0] = 0;
}
*ppdest = dest;
return src_len + ucs2_align_len;
}
/**
Copy a string from a char* src to a unicode or ascii
dos codepage destination choosing unicode or ascii based on the
flags supplied
Return the number of bytes occupied by the string in the destination.
flags can have:
STR_TERMINATE means include the null termination.
STR_UPPER means uppercase in the destination.
STR_ASCII use ascii even with unicode packet.
STR_NOALIGN means don't do alignment.
dest_len is the maximum length allowed in the destination. If dest_len
is -1 then no maximum is used.
**/
size_t push_string_check_fn(void *dest, const char *src,
size_t dest_len, int flags)
{
if (!(flags & STR_ASCII) && (flags & STR_UNICODE)) {
return push_ucs2(NULL, dest, src, dest_len, flags);
}
return push_ascii(dest, src, dest_len, flags);
}
/**
Copy a string from a char* src to a unicode or ascii
dos codepage destination choosing unicode or ascii based on the
flags in the SMB buffer starting at base_ptr.
Return the number of bytes occupied by the string in the destination.
flags can have:
STR_TERMINATE means include the null termination.
STR_UPPER means uppercase in the destination.
STR_ASCII use ascii even with unicode packet.
STR_NOALIGN means don't do alignment.
dest_len is the maximum length allowed in the destination. If dest_len
is -1 then no maximum is used.
**/
size_t push_string_base(const char *base, uint16_t flags2,
void *dest, const char *src,
size_t dest_len, int flags)
{
if (!(flags & STR_ASCII) && \
((flags & STR_UNICODE || \
(flags2 & FLAGS2_UNICODE_STRINGS)))) {
return push_ucs2(base, dest, src, dest_len, flags);
}
return push_ascii(dest, src, dest_len, flags);
}
/**
Copy a string from a unicode or ascii source (depending on
the packet flags) to a char* destination.
Variant that uses talloc.
Flags can have:
STR_TERMINATE means the string in src is null terminated.
STR_UNICODE means to force as unicode.
STR_ASCII use ascii even with unicode packet.
STR_NOALIGN means don't do alignment.
if STR_TERMINATE is set then src_len is ignored is it is -1
src_len is the length of the source area in bytes.
Return the number of bytes occupied by the string in src.
The resulting string in "dest" is always null terminated.
**/
size_t pull_string_talloc(TALLOC_CTX *ctx,
const void *base_ptr,
uint16_t smb_flags2,
char **ppdest,
const void *src,
size_t src_len,
int flags)
{
if ((base_ptr == NULL) && ((flags & (STR_ASCII|STR_UNICODE)) == 0)) {
smb_panic("No base ptr to get flg2 and neither ASCII nor "
"UNICODE defined");
}
if (!(flags & STR_ASCII) && \
((flags & STR_UNICODE || \
(smb_flags2 & FLAGS2_UNICODE_STRINGS)))) {
return pull_ucs2_base_talloc(ctx,
base_ptr,
ppdest,
src,
src_len,
flags);
}
return pull_ascii_base_talloc(ctx,
ppdest,
src,
src_len,
flags);
}
/*******************************************************************
Write a string in (little-endian) unicode format. src is in
the current DOS codepage. len is the length in bytes of the
string pointed to by dst.
if null_terminate is True then null terminate the packet (adds 2 bytes)
the return value is the length in bytes consumed by the string, including the
null termination if applied
********************************************************************/
size_t dos_PutUniCode(char *dst,const char *src, size_t len, bool null_terminate)
{
int flags = null_terminate ? STR_UNICODE|STR_NOALIGN|STR_TERMINATE
: STR_UNICODE|STR_NOALIGN;
return push_ucs2(NULL, dst, src, len, flags);
}
/* Converts a string from internal samba format to unicode. Always terminates.
* Actually just a wrapper round push_ucs2_talloc().
*/
int rpcstr_push_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
{
size_t size;
if (push_ucs2_talloc(ctx, dest, src, &size))
return size;
else
return -1;
}