int main(void){
size_t length;
plan(7);
ok(SUCCEEDED(StringCbLengthA("", 1, &length)),
"Calculate length of empty string.");
is_int(0, length,
"Value for length of empty string.");
ok(SUCCEEDED(StringCbLengthA("test", 5, &length)),
"Calculate length of short string.");
is_int(4, length,
"Value for length of short string.");
ok(SUCCEEDED(StringCbLengthA("test\0test", 10, &length)),
"Calculate length of string with embedded null character.");
is_int(4, length,
"Value for length of string with embedded null character.");
ok(StringCbLengthA("too long", 8, &length) ==
STRSAFE_E_INVALID_PARAMETER,
"Make sure error is thrown if null termination is not found.");
return 0;
}
LPSTR WINAPI StringDupA(_In_ HANDLE hHeap, _In_ LPCSTR lpszString)
{
LPSTR lpszCopy;
size_t cbCopy;
HRESULT hr;
if (!lpszString)
return NULL;
hr = StringCbLengthA(lpszString, (STRSAFE_MAX_CCH-1) * sizeof(CHAR), &cbCopy);
if (FAILED(hr))
return NULL;
if ((cbCopy + sizeof(CHAR)) <= cbCopy)
return NULL;
cbCopy += sizeof(CHAR);
lpszCopy = (LPSTR) HeapAlloc(hHeap, HEAP_ZERO_MEMORY, cbCopy);
if (!lpszCopy)
return NULL;
hr = StringCbCopyNA(lpszCopy, cbCopy, lpszString, cbCopy);
if (FAILED(hr)) {
HeapSafeFree(hHeap, 0, lpszCopy);
return NULL;
}
return lpszCopy;
}
/*****************************************************************************
DWORD WriteSfvHeader(CONST HANDLE hFile)
hFile : (IN) handle to an open file
Return Value:
- returns NOERROR or GetLastError()
*****************************************************************************/
DWORD WriteSfvHeader(CONST HANDLE hFile)
{
TCHAR szLine[MAX_LINE_LENGTH];
#ifdef UNICODE
CHAR szLineAnsi[MAX_LINE_LENGTH];
#endif
DWORD dwNumberOfBytesWritten;
size_t stStringLength;
VOID *szOutLine=szLine;
StringCbPrintf(szLine, MAX_LINE_LENGTH, TEXT("; Generated by WIN-SFV32 v1 (compatible; RapidCRC http://rapidcrc.sourceforge.net unicode-file mod by OV2)%s;%s"),
g_program_options.bCreateUnixStyle ? TEXT("\n") : TEXT("\r\n"), g_program_options.bCreateUnixStyle ? TEXT("\n") : TEXT("\r\n"));
StringCbLength(szLine, MAX_LINE_LENGTH, & stStringLength);
#ifdef UNICODE
if(!g_program_options.bCreateUnicodeFiles || g_program_options.iUnicodeSaveType == UTF_8 || g_program_options.iUnicodeSaveType==UTF_8_BOM) {
if(!WideCharToMultiByte(CP_ACP, 0, szLine, -1, szLineAnsi, MAX_UTF8_PATH, NULL, NULL) )
return GetLastError();
StringCbLengthA(szLineAnsi, MAX_LINE_LENGTH, & stStringLength);
szOutLine=szLineAnsi;
}
#endif
if(!WriteFile(hFile, szOutLine, (DWORD)stStringLength, & dwNumberOfBytesWritten, NULL) )
return GetLastError();
return NOERROR;
}
/*---------------------------------------------------------------------------------------------*/
static HRESULT _get_value_length(unsigned int value_type, const void* value, size_t* length)
{
HRESULT hr;
size_t l;
switch (value_type)
{
case AXV_INT8: case AXV_UINT8: *length = 1; return S_OK;
case AXV_INT16: case AXV_UINT16: *length = 2; return S_OK;
case AXV_INT32: case AXV_UINT32: *length = 4; return S_OK;
case AXV_INT64: case AXV_UINT64: *length = 8; return S_OK;
case AXV_FLOAT32: *length = 4; return S_OK;
case AXV_FLOAT64: *length = 8; return S_OK;
case AXV_STR_ACP: case AXV_STR_UTF8:
{
hr = StringCbLengthA((const char*)value, AXTRACE_MAX_VALUE_LENGTH - 1, &l);
if (FAILED(hr)) return hr;
*length = l + 1;
return S_OK;
}
case AXV_STR_UTF16:
{
hr = StringCbLengthW((const wchar_t*)value, AXTRACE_MAX_VALUE_LENGTH - 1, &l);
if (FAILED(hr)) return hr;
*length = l + 2;
return S_OK;
}
default: break;
}
return E_FAIL;
}
BOOL CDbgHook::InitHook(PVOID pfnAddr, LPCSTR Name)
{
BYTE OrgByte;
BYTE Int3 = 0xCC;
CHAR* buf;
size_t len;
StringCbLengthA(Name, MAX_PATH, &len);
buf = new CHAR[len+1];
StringCbCopyA(buf, len+1, Name);
if (!ReadProcessMemory(m_cpdi.hProcess,
pfnAddr, &OrgByte, sizeof(BYTE), NULL))
{
return FALSE;
}
if (!WriteProcessMemory(m_cpdi.hProcess, pfnAddr,
(LPCVOID)&Int3, sizeof(BYTE), NULL))
{
return FALSE;
}
OrgBytes.insert(hsOrgOpcode::value_type(pfnAddr, OrgByte));
Funcs.insert(hsFuncName::value_type(pfnAddr, buf));
return TRUE;
}
/*****************************************************************************
DWORD WriteHashLine(CONST HANDLE hFile, CONST TCHAR szFilename[MAX_PATH_EX], CONST TCHAR szHashResult[RESULT_AS_STRING_MAX_LENGTH], BOOL bIsSfv)
hFile : (IN) handle to an open file
szFilename : (IN) string of the filename that we want to write into the hash file
szHashResult : (IN) string of the hash result
bIsSfv : (IN) is this a sfv hash
Return Value:
- returns NOERROR or GetLastError()
*****************************************************************************/
DWORD WriteHashLine(CONST HANDLE hFile, CONST TCHAR szFilename[MAX_PATH_EX], CONST TCHAR szHashResult[RESULT_AS_STRING_MAX_LENGTH], BOOL bIsSfv)
{
TCHAR szFilenameTemp[MAX_PATH_EX];
TCHAR szLine[MAX_LINE_LENGTH];
#ifdef UNICODE
CHAR szLineAnsi[MAX_LINE_LENGTH];
#endif
DWORD dwNumberOfBytesWritten;
size_t stStringLength;
VOID *szOutLine=szLine;
if(!RegularFromLongFilename(szFilenameTemp, szFilename)) {
if(g_program_options.bCreateUnixStyle)
ReplaceChar(szFilenameTemp, MAX_PATH_EX, TEXT('\\'), TEXT('/'));
}
if(bIsSfv)
StringCchPrintf(szLine, MAX_LINE_LENGTH, TEXT("%s %s%s"), szFilenameTemp,
szHashResult, g_program_options.bCreateUnixStyle ? TEXT("\n") : TEXT("\r\n"));
else
StringCchPrintf(szLine, MAX_LINE_LENGTH, TEXT("%s *%s%s"), szHashResult,
szFilenameTemp, g_program_options.bCreateUnixStyle ? TEXT("\n") : TEXT("\r\n"));
StringCbLength(szLine, MAX_LINE_LENGTH, & stStringLength);
#ifdef UNICODE
// we only need the conversion if we don't write unicode data
if(!g_program_options.bCreateUnicodeFiles) {
if(!WideCharToMultiByte(CP_ACP, 0, szLine, -1, szLineAnsi, MAX_UTF8_PATH, NULL, NULL) )
return GetLastError();
StringCbLengthA(szLineAnsi, MAX_LINE_LENGTH, & stStringLength);
szOutLine=szLineAnsi;
} else if(g_program_options.iUnicodeSaveType == UTF_8 || g_program_options.iUnicodeSaveType==UTF_8_BOM) {
if(!WideCharToMultiByte(CP_UTF8, 0, szLine, -1, szLineAnsi, MAX_UTF8_PATH, NULL, NULL) )
return GetLastError();
StringCbLengthA(szLineAnsi, MAX_LINE_LENGTH, & stStringLength);
szOutLine=szLineAnsi;
}
#endif
if(!WriteFile(hFile, szOutLine, (DWORD)stStringLength, & dwNumberOfBytesWritten, NULL) )
return GetLastError();
return NOERROR;
}
KHMEXP void
perf_set_thread_desc(const char * file, int line,
const wchar_t * name, const wchar_t * creator) {
thread_info * t;
char * fn_copy;
perf_once();
t = malloc(sizeof(*t));
ZeroMemory(t, sizeof(*t));
#ifdef _WIN32
t->thread = GetCurrentThreadId();
#else
#error Unsupported platform
#endif
StringCbCopy(t->name, sizeof(t->name), name);
if (creator)
StringCbCopy(t->creator, sizeof(t->creator), creator);
if (file[0] == '.' && file[1] == '\\')
file += 2;
EnterCriticalSection(&cs_alloc);
fn_copy = hash_lookup(&fn_hash, file);
if (fn_copy == NULL) {
size_t cblen = 0;
if (FAILED(StringCbLengthA(file, MAX_PATH * sizeof(char),
&cblen)))
fn_copy = NULL;
else {
fn_copy = malloc(cblen + sizeof(char));
if (fn_copy) {
hash_bin * b;
int hv;
StringCbCopyA(fn_copy, cblen + sizeof(char), file);
hv = fn_hash.hash(fn_copy) % fn_hash.n;
b = malloc(sizeof(*b));
b->data = fn_copy;
b->key = fn_copy;
LINIT(b);
LPUSH(&fn_hash.bins[hv], b);
}
}
}
t->file = fn_copy;
t->line = line;
LPUSH(&threads, t);
LeaveCriticalSection(&cs_alloc);
}
/*---------------------------------------------------------------------------------------------*/
void axvalue(unsigned int value_type, const char* value_name, const void* value)
{
axtrace_contex_s* ctx;
HRESULT hr;
size_t value_name_length;
size_t value_length;
int send_len;
size_t final_length;
/* buf for send , call send() once*/
char buf[sizeof(axtrace_value_s) + AXTRACE_MAX_VALUENAME_LENGTH + AXTRACE_MAX_VALUE_LENGTH] = { 0 };
axtrace_value_s* trace_head = (axtrace_value_s*)(buf);
char* value_name_buf = (char*)(buf + sizeof(axtrace_value_s));
/* is init ok? */
ctx = _axtrace_get_thread_contex(0, 0);
if (ctx == 0) return;
/** get value name length*/
if (value_name == 0) return;
hr = StringCbLengthA(value_name, AXTRACE_MAX_VALUENAME_LENGTH - 1, &value_name_length);
if (FAILED(hr)) return;
/* add '\0' ended */
value_name_length += 1;
if (value_name_length <= 0 || value_name_length >= AXTRACE_MAX_VALUENAME_LENGTH) return;
if (value == 0) return;
hr = _get_value_length(value_type, value, &value_length);
if (FAILED(hr)) return;
if (value_length <= 0 || value_length >= AXTRACE_MAX_VALUE_LENGTH) return;
/*calc final length */
final_length = sizeof(axtrace_value_s) + value_name_length + value_length;
trace_head->head.length = (unsigned short)(final_length);
trace_head->head.flag = 'A';
trace_head->head.type = AXTRACE_CMD_TYPE_VALUE;
trace_head->head.pid = GetCurrentProcessId();
trace_head->head.tid = GetCurrentThreadId();
trace_head->value_type = value_type;
trace_head->name_len = (unsigned short)value_name_length;
trace_head->value_len = (unsigned short)value_length;
/* fill the value data */
memcpy(value_name_buf, value_name, value_name_length);
memcpy(value_name_buf + value_name_length, value, value_length);
/* send to axtrace server*/
send_len = send(ctx->sfd, buf, (int)final_length, MSG_DONTROUTE);
/*TODO: check result, may be reconnect to server */
return;
}
void
HttpRequest::FetchGravatarForEmail()
{
unsigned char ehash[MD5LEN];
{
char email[1024];
DWORD d;
size_t len;
if (WideCharToMultiByte(CP_UTF8, 0, m_target.c_str(), -1,
email, sizeof(email), NULL, NULL) == 0) {
ReportStatus(KHERR_ERROR,
L"Can't convert email address to UTF-8",
L"%s", GetLastErrorString().c_str());
return;
}
_strlwr_s(email, sizeof(email));
if (FAILED(StringCbLengthA(email, sizeof(email), &len))) {
ReportStatus(KHERR_ERROR,
L"UTF-8 email address too long",
L"The email address can't be longer than 1024 characters");
return;
}
d = sizeof(ehash);
if (KHM_FAILED(hash_data((BYTE *) email, (DWORD)len, CALG_MD5, (BYTE *) ehash, &d))) {
ReportStatus(KHERR_ERROR, L"Failed to hash email address", NULL);
return;
}
}
{
wchar_t resource[60];
wchar_t * tail;
size_t len;
int i;
static const wchar_t hexdigits[] = L"0123456789abcdef";
StringCbCopyEx(resource, sizeof(resource), L"/avatar/", &tail, &len, STRSAFE_NO_TRUNCATION);
for (i = 0; i < sizeof(ehash); i++) {
*tail++ = hexdigits[ehash[i] >> 4];
*tail++ = hexdigits[ehash[i] & 0xf];
len -= sizeof(wchar_t) * 2;
}
*tail++ = L'\0';
StringCbCat(resource, sizeof(resource), L".jpg?d=404&s=128");
FetchResource(L"www.gravatar.com", resource, jpg_mimetypes);
}
}
/*****************************************************************************
DWORD WriteSfvHeader(CONST HANDLE hFile)
hFile : (IN) handle to an open file
Return Value:
- returns NOERROR or GetLastError()
*****************************************************************************/
DWORD WriteFileComment(CONST HANDLE hFile, CONST FILEINFO *pFileInfo, UINT startChar)
{
TCHAR szLine[MAX_LINE_LENGTH];
#ifdef UNICODE
CHAR szLineAnsi[MAX_LINE_LENGTH];
#endif
DWORD dwNumberOfBytesWritten;
size_t stStringLength;
VOID *szOutLine=szLine;
SYSTEMTIME st;
FILETIME ft;
TCHAR szTimeStamp[50];
FileTimeToLocalFileTime( &pFileInfo->ftModificationTime, &ft );
FileTimeToSystemTime( &ft, &st );
int chars = GetTimeFormat( LOCALE_USER_DEFAULT, 0, &st, TEXT("HH':'mm'.'ss"), szTimeStamp, 50 );
GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, TEXT("' 'yyyy'-'MM'-'dd"), szTimeStamp + chars - 1, 50 - chars );
StringCbPrintf(szLine, MAX_LINE_LENGTH, TEXT(";%13I64d %s %s%s"), pFileInfo->qwFilesize, szTimeStamp, pFileInfo->szFilename.GetString() + startChar,
g_program_options.bCreateUnixStyle ? TEXT("\n") : TEXT("\r\n"));
StringCbLength(szLine, MAX_LINE_LENGTH, & stStringLength);
#ifdef UNICODE
if(!g_program_options.bCreateUnicodeFiles) {
if(!WideCharToMultiByte(CP_ACP, 0, szLine, -1, szLineAnsi, MAX_UTF8_PATH, NULL, NULL) )
return GetLastError();
StringCbLengthA(szLineAnsi, MAX_LINE_LENGTH, & stStringLength);
szOutLine=szLineAnsi;
} else if(g_program_options.iUnicodeSaveType == UTF_8 || g_program_options.iUnicodeSaveType==UTF_8_BOM) {
if(!WideCharToMultiByte(CP_UTF8, 0, szLine, -1, szLineAnsi, MAX_UTF8_PATH, NULL, NULL) )
return GetLastError();
StringCbLengthA(szLineAnsi, MAX_LINE_LENGTH, & stStringLength);
szOutLine=szLineAnsi;
}
#endif
if(!WriteFile(hFile, szOutLine, (DWORD)stStringLength, & dwNumberOfBytesWritten, NULL) )
return GetLastError();
return NOERROR;
}
/*---------------------------------------------------------------------------------------------*/
void ax2d_actor(const char* scene_name, __int64 actor_id, double x, double y, double dir, unsigned int actor_style)
{
axtrace_contex_s* ctx;
HRESULT hr;
size_t scene_name_size, final_length;
int send_len;
/* buf for send , call send() once*/
char buf[sizeof(axtrace_2d_actor_s) + AXTRACE_MAX_SCENE_NAME_LENGTH] = { 0 };
axtrace_2d_actor_s* trace_head = (axtrace_2d_actor_s*)(buf);
char* _name = (char*)(buf + sizeof(axtrace_2d_actor_s));
/* is init ok? */
ctx = _axtrace_get_thread_contex(0, 0);
if (ctx == 0) return;
/* copy scene name */
hr = StringCbCopyA(_name, AXTRACE_MAX_SCENE_NAME_LENGTH, scene_name);
/* failed ?*/
if (FAILED(hr)) return;
/** get string length*/
hr = StringCbLengthA(_name, AXTRACE_MAX_SCENE_NAME_LENGTH - 1, &scene_name_size);
/* failed ?*/
if (FAILED(hr)) return;
if (scene_name_size <= 0 || scene_name_size >= AXTRACE_MAX_SCENE_NAME_LENGTH) return;
/* add '\0' ended */
scene_name_size += 1;
final_length = sizeof(axtrace_2d_actor_s) + scene_name_size;
trace_head->head.length = (unsigned short)(final_length);
trace_head->head.flag = 'A';
trace_head->head.type = AXTRACE_CMD_TYPE_2D_ACTOR;
trace_head->head.pid = GetCurrentProcessId();
trace_head->head.tid = GetCurrentThreadId();
trace_head->actor_id = actor_id;
trace_head->x = x;
trace_head->y = y;
trace_head->dir = dir;
trace_head->style = actor_style;
trace_head->name_len = (unsigned short)scene_name_size;
/* send to axtrace server*/
send_len = send(ctx->sfd, buf, (int)final_length, MSG_DONTROUTE);
/*TODO: check result, may be reconnect to server */
return;
}
/*---------------------------------------------------------------------------------------------*/
void axlog(unsigned int log_type, const char *format, ...)
{
axtrace_contex_s* ctx;
va_list ptr = 0;
HRESULT hr;
size_t contents_byte_size, final_length;
int send_len;
/* buf for send , call send() once*/
char buf[sizeof(axtrace_log_s) + AXTRACE_MAX_TRACE_STRING_LENGTH] = { 0 };
axtrace_log_s* trace_head = (axtrace_log_s*)(buf);
char* trace_string = (char*)(buf + sizeof(axtrace_log_s));
/* is init ok? */
ctx = _axtrace_get_thread_contex(0, 0);
if (ctx == 0) return;
/* Create String Contents*/
va_start(ptr, format);
hr = StringCbVPrintfA(trace_string, AXTRACE_MAX_TRACE_STRING_LENGTH, format, ptr);
va_end(ptr);
/* failed ?*/
if (FAILED(hr)) return;
/** get string length*/
hr = StringCbLengthA(trace_string, AXTRACE_MAX_TRACE_STRING_LENGTH - 1, &contents_byte_size);
/* failed ?*/
if (FAILED(hr)) return;
/* add '\0' ended */
contents_byte_size += 1;
/* fill the trace head data */
final_length = sizeof(axtrace_log_s)+contents_byte_size;
trace_head->head.length = (unsigned short)(final_length);
trace_head->head.flag = 'A';
trace_head->head.type = AXTRACE_CMD_TYPE_LOG;
trace_head->head.pid = GetCurrentProcessId();
trace_head->head.tid = GetCurrentThreadId();
trace_head->log_type = log_type;
trace_head->code_page = ATC_ACP;
trace_head->length = (unsigned short)contents_byte_size;
/* send to axtrace server*/
send_len = send(ctx->sfd, buf, (int)final_length, MSG_DONTROUTE);
/*TODO: check result, may be reconnect to server */
return;
}
KHMEXP char *
perf_strdup(const char * file, int line, const char * str) {
size_t cb;
char * dest;
if (FAILED(StringCbLengthA(str, MAXCB_STR, &cb)))
return NULL;
cb += sizeof(char);
dest = (char *) perf_malloc(file, line, cb);
StringCbCopyA(dest, cb, str);
return dest;
}
/* functions for handling the configuration file */
BOOL parseConfFile(user_input_data *user_dat)
{
cfg_opt_t email_opts[] = {
CFG_STR("From", NULL, CFGF_NONE),
CFG_STR("To", NULL, CFGF_NONE),
CFG_STR("Cc", NULL, CFGF_NONE),
CFG_STR("Subject", NULL, CFGF_NONE),
CFG_STR("Body", NULL, CFGF_NONE),
CFG_STR("Password", NULL, CFGF_NONE),
CFG_STR("SMTP_server", NULL, CFGF_NONE),
CFG_INT("Port_number", 0, CFGF_NONE),
CFG_END()
};
cfg_t *U2MConf;
U2MConf = cfg_init(email_opts, CFGF_NONE);
int cfg_err = cfg_parse(U2MConf, cfg_filename);
if (cfg_err) {
#if 0
if (cfg_err == CFG_PARSE_ERROR)
fprintf(stderr, "Error at parsing %s\n", cfg_filename);
else
fprintf(stderr, "Couldn't find configuration file with filename %s\n", cfg_filename);
#endif
cfg_free(U2MConf);
return FALSE;
}
char *temp[7] = {
cfg_getstr(U2MConf, "From"),
cfg_getstr(U2MConf, "To"),
cfg_getstr(U2MConf, "Cc"),
cfg_getstr(U2MConf, "Subject"),
cfg_getstr(U2MConf, "Body"),
cfg_getstr(U2MConf, "Password"),
cfg_getstr(U2MConf, "SMTP_server")
};
if (temp[0]) {
size_t len;
if (SUCCEEDED(StringCbLengthA(temp[0], MAX_BUFFER, &len))) {
if (user_dat->FROM) HeapFree(GetProcessHeap(), 0, user_dat->FROM);
user_dat->FROM = HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY, sizeof(temp[0])*(len + 1));
if (user_dat->FROM) StringCchCopyA(user_dat->FROM, MAX_BUFFER, temp[0]);
else __MsgBoxGetLastError(NULL, TEXT("HeapAlloc()"), __LINE__);
}
}
if (temp[1]) {
size_t len;
if (SUCCEEDED(StringCbLengthA(temp[1], MAX_BUFFER, &len))) {
if (user_dat->TO) HeapFree(GetProcessHeap(), 0, user_dat->TO);
user_dat->TO = HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY, sizeof(temp[1])*(len + 1));
if (user_dat->TO) StringCchCopyA(user_dat->TO, MAX_BUFFER, temp[1]);
else __MsgBoxGetLastError(NULL, TEXT("HeapAlloc()"), __LINE__);
}
}
if (temp[2]) {
size_t len;
if (SUCCEEDED(StringCbLengthA(temp[2], MAX_BUFFER, &len))) {
if (user_dat->CC) HeapFree(GetProcessHeap(), 0, user_dat->CC);
user_dat->CC = HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY, sizeof(temp[2])*(len + 1));
if (user_dat->CC) StringCchCopyA(user_dat->CC, MAX_BUFFER, temp[2]);
else __MsgBoxGetLastError(NULL, TEXT("HeapAlloc()"), __LINE__);
}
}
if (temp[3]) {
size_t len;
if (SUCCEEDED(StringCbLengthA(temp[3], MAX_BUFFER, &len))) {
if (user_dat->SUBJECT) HeapFree(GetProcessHeap(), 0, user_dat->SUBJECT);
user_dat->SUBJECT = HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY, sizeof(temp[3])*(len + 1));
if (user_dat->SUBJECT) StringCchCopyA(user_dat->SUBJECT, MAX_BUFFER, temp[3]);
else __MsgBoxGetLastError(NULL, TEXT("HeapAlloc()"), __LINE__);
}
}
if (temp[4]) {
size_t len;
if (SUCCEEDED(StringCbLengthA(temp[4], MAX_BUFFER, &len))) {
if (user_dat->BODY) HeapFree(GetProcessHeap(), 0, user_dat->BODY);
user_dat->BODY = HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY, sizeof(temp[4])*(len + 1));
if (user_dat->BODY) StringCchCopyA(user_dat->BODY, MAX_BUFFER, temp[4]);
else __MsgBoxGetLastError(NULL, TEXT("HeapAlloc()"), __LINE__);
}
}
if (temp[5]) {
size_t len;
if (SUCCEEDED(StringCbLengthA(temp[5], MAX_BUFFER, &len))) {
if (user_dat->pass) HeapFree(GetProcessHeap(), 0, user_dat->pass);
user_dat->pass = HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY, sizeof(temp[5])*(len + 1));
if (user_dat->pass) StringCchCopyA(user_dat->pass, MAX_BUFFER, temp[5]);
else __MsgBoxGetLastError(NULL, TEXT("HeapAlloc()"), __LINE__);
}
}
if (temp[6]) {
size_t len;
if (SUCCEEDED(StringCbLengthA(temp[6], MAX_BUFFER, &len))) {
if (user_dat->SMTP_SERVER) HeapFree(GetProcessHeap(), 0, user_dat->SMTP_SERVER);
user_dat->SMTP_SERVER = HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY, sizeof(temp[6])*(len + 1));
if (user_dat->SMTP_SERVER) StringCchCopyA(user_dat->SMTP_SERVER, MAX_BUFFER, temp[6]);
else __MsgBoxGetLastError(NULL, TEXT("HeapAlloc()"), __LINE__);
}
}
int signed_port = cfg_getint(U2MConf, "Port_number");
user_dat->PORT = (UINT)signed_port;
cfg_free(U2MConf);
#ifdef DEBUG
printf("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%u\n", user_dat->FROM, user_dat->TO, user_dat->CC,
user_dat->SUBJECT, user_dat->BODY, user_dat->pass, user_dat->SMTP_SERVER, user_dat->PORT);
#endif
return TRUE;
}
KHMEXP void *
perf_malloc(const char * file, int line, size_t s) {
allocation * a;
void * ptr;
size_t h;
char * fn_copy = NULL;
perf_once();
assert(s > 0);
EnterCriticalSection(&cs_alloc);
a = get_allocation();
ptr = malloc(s);
assert(ptr); /* TODO: handle this gracefully */
if (file[0] == '.' && file[1] == '\\')
file += 2;
fn_copy = hash_lookup(&fn_hash, file);
if (fn_copy == NULL) {
size_t cblen = 0;
if (FAILED(StringCbLengthA(file, MAX_PATH * sizeof(char),
&cblen)))
fn_copy = NULL;
else {
fn_copy = malloc(cblen + sizeof(char));
if (fn_copy) {
hash_bin * b;
int hv;
StringCbCopyA(fn_copy, cblen + sizeof(char), file);
hv = fn_hash.hash(fn_copy) % fn_hash.n;
b = malloc(sizeof(*b));
b->data = fn_copy;
b->key = fn_copy;
LINIT(b);
LPUSH(&fn_hash.bins[hv], b);
}
}
}
a->file = fn_copy;
a->line = line;
a->size = s;
a->ptr = ptr;
#ifdef _WIN32
a->thread = GetCurrentThreadId();
#endif
h = HASHPTR(ptr);
LPUSH(&ht[h], a);
LeaveCriticalSection(&cs_alloc);
return ptr;
}
bool CPlaylist::Save()
{
DWORD dwToWrite, dwWritten;
DWORD dwASXDataLen = 0;
DWORD dwFileAttrib;
char * pszASXData = NULL;
playlist_t * pTrack;
char szFilename[MAX_PATH];
HANDLE hFile;
BOOL bWrite;
bool bResult = true;
// Don't save a playlist that wasn't created by the player
if (false == m_bCEPlaylist || true == m_bTransient)
{
return true;
}
if (m_bHidden)
{
dwFileAttrib = FILE_ATTRIBUTE_HIDDEN;
}
else
{
dwFileAttrib = FILE_ATTRIBUTE_NORMAL;
}
hFile = CreateFile(m_pszPath, GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, dwFileAttrib, NULL);
if (INVALID_HANDLE_VALUE != hFile)
{
bWrite = FALSE;
// write out the header
dwASXDataLen = sizeof (c_szASXHeaderFormat) + 10;
if (pszASXData = new char[dwASXDataLen])
{
pszASXData[0] = '\0';
if(SUCCEEDED(StringCbPrintfA(pszASXData, dwASXDataLen, c_szASXHeaderFormat, m_iCurrentTrack)))
{
if(SUCCEEDED(StringCbLengthA(pszASXData, dwASXDataLen, (size_t*)&dwToWrite)))
{
dwWritten = 0;
bWrite = WriteFile(hFile, pszASXData, dwToWrite, &dwWritten, NULL);
}
else
{
bWrite = FALSE;
}
}
else
{
bWrite = FALSE;
}
}
if (FALSE == bWrite || dwToWrite != dwWritten)
{
bResult = false;
}
}
else
{
bResult = false;
}
pTrack = m_pList;
while (NULL != pTrack && bResult)
{
LPCTSTR pszPath = pTrack->pClip->GetPath();
szFilename[0] = '\0';
if (NETWORK != pTrack->pClip->GetLocation())
{
#ifdef _UNICODE
_snprintf(szFilename, MAX_PATH-1, "file://%ls", pszPath);
#else
_snprintf(szFilename, MAX_PATH-1, "file://%s", pszPath);
#endif /* _UNICODE */
szFilename[MAX_PATH-1] = '\0';
}
else
{
#ifdef _UNICODE
WideCharToMultiByte(CP_ACP, 0, pszPath, -1, szFilename, MAX_PATH, NULL, NULL);
#else
strncpy(szFilename, pszPath, MAX_PATH);
pszPath[MAX_PATH-1] = '\0';
#endif /* _UNICODE */
}
dwToWrite = sizeof (c_szASXEntryFormat) + strlen(szFilename);
if (dwASXDataLen < dwToWrite)
{
delete [] pszASXData;
pszASXData = new char [dwToWrite];
dwASXDataLen = dwToWrite;
}
if((NULL != pszASXData) && (SUCCEEDED(StringCbPrintfA(pszASXData, dwToWrite, c_szASXEntryFormat, szFilename))))
{
if(SUCCEEDED(StringCbLengthA(pszASXData, dwASXDataLen, (size_t*)&dwToWrite)))
{
dwWritten = 0;
bWrite = WriteFile(hFile, pszASXData, dwToWrite, &dwWritten, NULL);
}
else
{
bWrite = FALSE;
}
}
else
{
bWrite = FALSE;
}
if (FALSE == bWrite || dwToWrite != dwWritten)
{
bResult = false;
}
pTrack = pTrack->pNext;
}
if (INVALID_HANDLE_VALUE != hFile && NULL != pszASXData)
{
// write out the footer
size_t ASXFooterFormatLen = sizeof (c_szASXFooterFormat);
if (dwASXDataLen < ASXFooterFormatLen)
{
delete [] pszASXData;
pszASXData = new char [ASXFooterFormatLen];
}
if((NULL != pszASXData) && (SUCCEEDED(StringCbCopyA(pszASXData, ASXFooterFormatLen, c_szASXFooterFormat))))
{
if(SUCCEEDED(StringCbLengthA(pszASXData, ASXFooterFormatLen, (size_t*)&dwToWrite)))
{
dwWritten = 0;
bWrite = WriteFile(hFile, pszASXData, dwToWrite, &dwWritten, NULL);
}
else
{
bWrite = FALSE;
}
}
else
{
bWrite = FALSE;
}
if (FALSE == bWrite || dwToWrite != dwWritten)
{
bResult = false;
}
CloseHandle(hFile);
}
else if (INVALID_HANDLE_VALUE != hFile)
{
CloseHandle(hFile);
}
delete [] pszASXData;
return bResult;
}
/*---------------------------------------------------------------------------------------------*/
void ax2d_begin_scene(const char* scene_name, double left, double top, double right, double bottom, const char* scene_define)
{
axtrace_contex_s* ctx;
HRESULT hr;
size_t scene_name_size, scene_define_size, final_length;
int send_len;
/* buf for send , call send() once*/
char buf[sizeof(axtrace_2d_begin_scene_s) + AXTRACE_MAX_SCENE_NAME_LENGTH + AXTRACE_MAX_SCENE_DEFINE_LENGTH] = { 0 };
axtrace_2d_begin_scene_s* trace_head = (axtrace_2d_begin_scene_s*)(buf);
char* _name = (char*)(buf + sizeof(axtrace_2d_begin_scene_s));
/* is init ok? */
ctx = _axtrace_get_thread_contex(0, 0);
if (ctx == 0) return;
/* copy scene name */
hr = StringCbCopyA(_name, AXTRACE_MAX_SCENE_NAME_LENGTH, scene_name);
/* failed ?*/
if (FAILED(hr)) return;
/** get string length*/
hr = StringCbLengthA(_name, AXTRACE_MAX_SCENE_NAME_LENGTH - 1, &scene_name_size);
/* failed ?*/
if (FAILED(hr)) return;
if (scene_name_size <= 0 || scene_name_size >= AXTRACE_MAX_SCENE_NAME_LENGTH) return;
/* add '\0' ended */
scene_name_size += 1;
/* to scene define point */
if (scene_define != 0) {
_name = (char*)(buf + sizeof(axtrace_2d_begin_scene_s) + scene_name_size);
/* copy scene define */
hr = StringCbCopyA(_name, AXTRACE_MAX_SCENE_DEFINE_LENGTH, scene_define);
/* failed ?*/
if (FAILED(hr)) return;
/** get string length*/
hr = StringCbLengthA(_name, AXTRACE_MAX_SCENE_DEFINE_LENGTH - 1, &scene_define_size);
/* failed ?*/
if (FAILED(hr)) return;
if (scene_define_size >= AXTRACE_MAX_SCENE_DEFINE_LENGTH) return;
/* add '\0' ended */
scene_define_size += 1;
}
else {
scene_define_size = 0;
}
final_length = sizeof(axtrace_2d_begin_scene_s) + scene_name_size + scene_define_size;
trace_head->head.length = (unsigned short)(final_length);
trace_head->head.flag = 'A';
trace_head->head.type = AXTRACE_CMD_TYPE_2D_BEGIN_SCENE;
trace_head->head.pid = GetCurrentProcessId();
trace_head->head.tid = GetCurrentThreadId();
trace_head->left = left;
trace_head->top = top;
trace_head->right = right;
trace_head->bottom = bottom;
trace_head->name_len = (unsigned short)scene_name_size;
trace_head->define_len = (unsigned short)scene_define_size;
/* send to axtrace server*/
send_len = send(ctx->sfd, buf, (int)final_length, MSG_DONTROUTE);
/*TODO: check result, may be reconnect to server */
return;
}
