Unicode
UnicodeAllocInternal(const void *buffer, // IN
ssize_t lengthInBytes, // IN
StringEncoding encoding, // IN
Bool strict) // IN
{
char *utf8Result = NULL;
ASSERT(buffer != NULL);
ASSERT(lengthInBytes >= 0);
ASSERT(Unicode_IsEncodingValid(encoding));
if (!strict) {
CodeSet_GenericToGeneric(Unicode_EncodingEnumToName(encoding),
buffer, lengthInBytes,
"UTF-8", CSGTG_TRANSLIT, &utf8Result, NULL);
return utf8Result;
}
switch (encoding) {
case STRING_ENCODING_US_ASCII:
case STRING_ENCODING_UTF8:
if (Unicode_IsBufferValid(buffer, lengthInBytes, encoding)) {
utf8Result = Util_SafeStrndup(buffer, lengthInBytes);
}
break;
case STRING_ENCODING_UTF16_LE:
// utf8Result will be left NULL on failure.
CodeSet_Utf16leToUtf8((const char *)buffer,
lengthInBytes,
&utf8Result,
NULL);
break;
default:
CodeSet_GenericToGeneric(Unicode_EncodingEnumToName(encoding),
buffer, lengthInBytes,
"UTF-8", 0, &utf8Result, NULL);
break;
}
return (Unicode)utf8Result;
}
Bool
CPClipboard_SetItem(CPClipboard *clip, // IN/OUT: the clipboard
const DND_CPFORMAT fmt, // IN: the item format
const void *clipitem, // IN: the item
const size_t size) // IN: the item size
{
CPClipItem *item;
uint8 *newBuf = NULL;
/*
* Image, rtf and text may be put into a clipboard at same time, and total
* size may be more than limit. Image data will be first dropped, then
* rtf data.
*/
DND_CPFORMAT filterList[] = {CPFORMAT_IMG_PNG, CPFORMAT_RTF, CPFORMAT_TEXT};
int filterIndex = 0;
ASSERT(clip);
if (!(CPFORMAT_UNKNOWN < fmt && fmt < CPFORMAT_MAX)) {
return FALSE;
}
if (!CPClipboard_ClearItem(clip, fmt)) {
return FALSE;
}
if (size >= CPCLIPITEM_MAX_SIZE_V3) {
return FALSE;
}
item = &clip->items[CPFormatToIndex(fmt)];
if (clipitem) {
/* It has to be valid utf8 for plain text format. */
if (CPFORMAT_TEXT == fmt) {
char *str = (char *)clipitem;
if (!Unicode_IsBufferValid(str,
size,
STRING_ENCODING_UTF8)) {
return FALSE;
}
}
newBuf = malloc(size + 1);
if (!newBuf) {
return FALSE;
}
memcpy(newBuf, clipitem, size);
newBuf[size] = 0;
}
item->buf = newBuf;
item->size = size;
item->exists = TRUE;
/* Drop some data if total size is more than limit. */
while (CPClipboard_GetTotalSize(clip) >= CPCLIPITEM_MAX_SIZE_V3 &&
filterIndex < ARRAYSIZE(filterList)) {
if (!CPClipboard_ClearItem(clip, filterList[filterIndex])) {
return FALSE;
}
filterIndex++;
}
return TRUE;
}
static MsgCatalog *
MsgLoadCatalog(const char *path)
{
gchar *localPath;
GError *err = NULL;
GIOChannel *stream;
gboolean error = FALSE;
MsgCatalog *catalog = NULL;
HashTable *dict;
ASSERT(path != NULL);
localPath = VMTOOLS_GET_FILENAME_LOCAL(path, NULL);
ASSERT(localPath != NULL);
stream = g_io_channel_new_file(localPath, "r", &err);
VMTOOLS_RELEASE_FILENAME_LOCAL(localPath);
if (err != NULL) {
g_debug("Unable to open '%s': %s\n", path, err->message);
g_clear_error(&err);
return NULL;
}
dict = HashTable_Alloc(8, HASH_STRING_KEY | HASH_FLAG_COPYKEY, g_free);
ASSERT_MEM_ALLOC(dict);
for (;;) {
gboolean eof = FALSE;
char *name = NULL;
char *value = NULL;
gchar *line;
/* Read the next key / value pair. */
for (;;) {
gsize i;
gsize len;
gsize term;
char *unused = NULL;
gboolean cont = FALSE;
g_io_channel_read_line(stream, &line, &len, &term, &err);
if (err != NULL) {
g_warning("Unable to read a line from '%s': %s\n",
path, err->message);
g_clear_error(&err);
error = TRUE;
g_free(line);
break;
}
if (line == NULL) {
eof = TRUE;
break;
}
/*
* Fix the line break to always be Unix-style, to make lib/dict
* happy.
*/
if (line[term] == '\r') {
line[term] = '\n';
if (len > term) {
line[term + 1] = '\0';
}
}
/*
* If currently name is not NULL, then check if this is a continuation
* line and, if it is, just append the contents to the current value.
*/
if (term > 0 && name != NULL && line[term - 1] == '"') {
for (i = 0; i < len; i++) {
if (line[i] == '"') {
/* OK, looks like a continuation line. */
char *tmp;
char *unescaped;
line[term - 1] = '\0';
unescaped = Escape_Undo('|', line + i + 1, len - i, NULL);
tmp = Str_Asprintf(NULL, "%s%s", value, unescaped);
free(unescaped);
free(value);
value = tmp;
cont = TRUE;
break;
} else if (line[i] != ' ' && line[i] != '\t') {
break;
}
}
}
/*
* If not a continuation line and we have a name, break out of the
* inner loop to update the dictionaty.
*/
if (!cont && name != NULL) {
g_free(line);
break;
}
/*
* Finally, try to parse the string using the dictionary library.
*/
if (!cont && DictLL_UnmarshalLine(line, len, &unused, &name, &value) == NULL) {
g_warning("Couldn't parse line from catalog: %s", line);
error = TRUE;
}
g_free(line);
free(unused);
}
if (error) {
break;
}
if (name != NULL) {
ASSERT(value);
if (!Unicode_IsBufferValid(name, strlen(name) + 1, STRING_ENCODING_UTF8) ||
!Unicode_IsBufferValid(value, strlen(value) + 1, STRING_ENCODING_UTF8)) {
g_warning("Invalid UTF-8 string in message catalog (key = %s)\n", name);
error = TRUE;
break;
}
MsgUnescape(value);
HashTable_ReplaceOrInsert(dict, name, g_strdup(value));
free(name);
free(value);
name = NULL;
value = NULL;
}
if (eof) {
break;
}
}
g_io_channel_unref(stream);
if (error) {
HashTable_Free(dict);
dict = NULL;
} else {
catalog = g_new0(MsgCatalog, 1);
catalog->utf8 = dict;
}
return catalog;
}
