const WORD * CResModule::CountMemReplaceDialogResource(const WORD * res, size_t * wordcount, WORD * newDialog)
{
BOOL bEx = FALSE;
DWORD style = GET_DWORD(res);
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++);
newDialog[(*wordcount)++] = GET_WORD(res++);
}
else
{
res += 2;
(*wordcount) += 2;
}
if (style == 0xffff0001) // DIALOGEX resource
{
bEx = TRUE;
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++); //help id
newDialog[(*wordcount)++] = GET_WORD(res++); //help id
newDialog[(*wordcount)++] = GET_WORD(res++); //exStyle
newDialog[(*wordcount)++] = GET_WORD(res++); //exStyle
style = GET_DWORD(res);
newDialog[(*wordcount)++] = GET_WORD(res++); //style
newDialog[(*wordcount)++] = GET_WORD(res++); //style
}
else
{
res += 4;
style = GET_DWORD(res);
res += 2;
(*wordcount) += 6;
}
}
else
{
bEx = FALSE;
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++); //exStyle
newDialog[(*wordcount)++] = GET_WORD(res++); //exStyle
//style = GET_DWORD(res);
//newDialog[(*wordcount)++] = GET_WORD(res++); //style
//newDialog[(*wordcount)++] = GET_WORD(res++); //style
}
else
{
res += 2;
(*wordcount) += 2;
}
}
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res);
WORD nbItems = GET_WORD(res);
(*wordcount)++;
res++;
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res); //x
(*wordcount)++;
res++;
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res); //y
(*wordcount)++;
res++;
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res); //cx
(*wordcount)++;
res++;
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res); //cy
(*wordcount)++;
res++;
// Get the menu name
switch (GET_WORD(res))
{
case 0x0000:
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res);
(*wordcount)++;
res++;
break;
case 0xffff:
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++);
newDialog[(*wordcount)++] = GET_WORD(res++);
}
else
{
(*wordcount) += 2;
res += 2;
}
break;
default:
if (newDialog)
{
wcscpy((LPWSTR)&newDialog[(*wordcount)], (LPCWSTR)res);
}
(*wordcount) += wcslen((LPCWSTR) res) + 1;
res += wcslen((LPCWSTR) res) + 1;
break;
}
// Get the class name
switch (GET_WORD(res))
{
case 0x0000:
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res);
(*wordcount)++;
res++;
break;
case 0xffff:
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++);
newDialog[(*wordcount)++] = GET_WORD(res++);
}
else
{
(*wordcount) += 2;
res += 2;
}
break;
default:
if (newDialog)
{
wcscpy((LPWSTR)&newDialog[(*wordcount)], (LPCWSTR)res);
}
(*wordcount) += wcslen((LPCWSTR) res) + 1;
res += wcslen((LPCWSTR) res) + 1;
break;
}
// Get the window caption
ReplaceStr((LPCWSTR)res, newDialog, wordcount, &m_bTranslatedDialogStrings, &m_bDefaultDialogStrings);
res += wcslen((LPCWSTR)res) + 1;
// Get the font name
if (style & DS_SETFONT)
{
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res);
res++;
(*wordcount)++;
if (bEx)
{
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++);
newDialog[(*wordcount)++] = GET_WORD(res++);
}
else
{
res += 2;
(*wordcount) += 2;
}
}
if (newDialog)
wcscpy((LPWSTR)&newDialog[(*wordcount)], (LPCWSTR)res);
(*wordcount) += wcslen((LPCWSTR)res) + 1;
res += wcslen((LPCWSTR)res) + 1;
}
// First control is on DWORD boundary
while ((*wordcount)%2)
(*wordcount)++;
while ((ULONG)res % 4)
res++;
while (nbItems--)
{
res = ReplaceControlInfo(res, wordcount, newDialog, bEx);
}
return res;
}
const WORD* CResModule::GetDialogInfo(const WORD * pTemplate, LPDIALOGINFO lpDlgInfo)
{
const WORD* p = (const WORD *)pTemplate;
lpDlgInfo->style = GET_DWORD(p);
p += 2;
if (lpDlgInfo->style == 0xffff0001) // DIALOGEX resource
{
lpDlgInfo->dialogEx = TRUE;
lpDlgInfo->helpId = GET_DWORD(p);
p += 2;
lpDlgInfo->exStyle = GET_DWORD(p);
p += 2;
lpDlgInfo->style = GET_DWORD(p);
p += 2;
}
else
{
lpDlgInfo->dialogEx = FALSE;
lpDlgInfo->helpId = 0;
lpDlgInfo->exStyle = GET_DWORD(p);
p += 2;
}
lpDlgInfo->nbItems = GET_WORD(p);
p++;
lpDlgInfo->x = GET_WORD(p);
p++;
lpDlgInfo->y = GET_WORD(p);
p++;
lpDlgInfo->cx = GET_WORD(p);
p++;
lpDlgInfo->cy = GET_WORD(p);
p++;
// Get the menu name
switch (GET_WORD(p))
{
case 0x0000:
lpDlgInfo->menuName = NULL;
p++;
break;
case 0xffff:
lpDlgInfo->menuName = (LPCTSTR) (WORD) GET_WORD(p + 1);
p += 2;
break;
default:
lpDlgInfo->menuName = (LPCTSTR) p;
p += wcslen((LPCWSTR) p) + 1;
break;
}
// Get the class name
switch (GET_WORD(p))
{
case 0x0000:
lpDlgInfo->className = (LPCTSTR)MAKEINTATOM(32770);
p++;
break;
case 0xffff:
lpDlgInfo->className = (LPCTSTR) (WORD) GET_WORD(p + 1);
p += 2;
break;
default:
lpDlgInfo->className = (LPCTSTR) p;
p += wcslen((LPCTSTR)p) + 1;
break;
}
// Get the window caption
lpDlgInfo->caption = (LPCTSTR)p;
p += wcslen((LPCWSTR) p) + 1;
// Get the font name
if (lpDlgInfo->style & DS_SETFONT)
{
lpDlgInfo->pointSize = GET_WORD(p);
p++;
if (lpDlgInfo->dialogEx)
{
lpDlgInfo->weight = GET_WORD(p);
p++;
lpDlgInfo->italic = LOBYTE(GET_WORD(p));
p++;
}
else
{
lpDlgInfo->weight = FW_DONTCARE;
lpDlgInfo->italic = FALSE;
}
lpDlgInfo->faceName = (LPCTSTR)p;
p += wcslen((LPCWSTR) p) + 1;
}
// First control is on DWORD boundary
return (const WORD *) ((((long)p) + 3) & ~3);
}
const WORD* CResModule::GetControlInfo(const WORD* p, LPDLGITEMINFO lpDlgItemInfo, BOOL dialogEx, LPBOOL bIsID)
{
if (dialogEx)
{
lpDlgItemInfo->helpId = GET_DWORD(p);
p += 2;
lpDlgItemInfo->exStyle = GET_DWORD(p);
p += 2;
lpDlgItemInfo->style = GET_DWORD(p);
p += 2;
}
else
{
lpDlgItemInfo->helpId = 0;
lpDlgItemInfo->style = GET_DWORD(p);
p += 2;
lpDlgItemInfo->exStyle = GET_DWORD(p);
p += 2;
}
lpDlgItemInfo->x = GET_WORD(p);
p++;
lpDlgItemInfo->y = GET_WORD(p);
p++;
lpDlgItemInfo->cx = GET_WORD(p);
p++;
lpDlgItemInfo->cy = GET_WORD(p);
p++;
if (dialogEx)
{
// ID is a DWORD for DIALOGEX
lpDlgItemInfo->id = (WORD) GET_DWORD(p);
p += 2;
}
else
{
lpDlgItemInfo->id = GET_WORD(p);
p++;
}
if (GET_WORD(p) == 0xffff)
{
GET_WORD(p + 1);
p += 2;
}
else
{
lpDlgItemInfo->className = (LPCTSTR) p;
p += wcslen((LPCWSTR) p) + 1;
}
if (GET_WORD(p) == 0xffff) // an integer ID?
{
*bIsID = TRUE;
lpDlgItemInfo->windowName = (LPCTSTR) (DWORD) GET_WORD(p + 1);
p += 2;
}
else
{
*bIsID = FALSE;
lpDlgItemInfo->windowName = (LPCTSTR) p;
p += wcslen((LPCWSTR) p) + 1;
}
if (GET_WORD(p))
{
lpDlgItemInfo->data = (LPVOID) (p + 1);
p += GET_WORD(p) / sizeof(WORD);
}
else
lpDlgItemInfo->data = NULL;
p++;
// Next control is on DWORD boundary
return (const WORD *)((((long)p) + 3) & ~3);
}
uint16_t getBigEndianWord(uint8_t *bytes){
uint8_t msb = *bytes;
uint8_t lsb = GET_NEXT_BYTE_OF(bytes);
return GET_WORD(msb,lsb);
}
Elf_Arsym *
_libelf_ar_process_symtab(Elf *e, size_t *count)
{
size_t n, nentries, off;
Elf_Arsym *symtab, *sym;
unsigned char *p, *s, *end;
assert(e != NULL);
assert(count != NULL);
if (e->e_u.e_ar.e_rawsymtabsz < INTSZ) {
LIBELF_SET_ERROR(ARCHIVE, 0);
return (NULL);
}
p = (unsigned char *) e->e_u.e_ar.e_rawsymtab;
end = p + e->e_u.e_ar.e_rawsymtabsz;
GET_WORD(p, nentries);
p += INTSZ;
if (nentries == 0 || p + nentries * INTSZ >= end) {
LIBELF_SET_ERROR(ARCHIVE, 0);
return (NULL);
}
/* Allocate space for a nentries + a sentinel. */
if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries+1))) == NULL) {
LIBELF_SET_ERROR(RESOURCE, 0);
return (NULL);
}
s = p + (nentries * INTSZ); /* start of the string table. */
for (n = nentries, sym = symtab; n > 0; n--) {
off = 0;
GET_WORD(p, off);
sym->as_off = off;
sym->as_hash = elf_hash(s);
sym->as_name = s;
p += INTSZ;
sym++;
for (; s < end && *s++ != '\0';) /* skip to next string */
;
if (s > end) {
LIBELF_SET_ERROR(ARCHIVE, 0);
free(symtab);
return (NULL);
}
}
/* Fill up the sentinel entry. */
sym->as_name = NULL;
sym->as_hash = ~0UL;
sym->as_off = (off_t) 0;
*count = e->e_u.e_ar.e_symtabsz = nentries + 1;
e->e_u.e_ar.e_symtab = symtab;
return (symtab);
}
BOOL CResModule::ExtractMenu(UINT nID)
{
HRSRC hrsrc = FindResource(m_hResDll, MAKEINTRESOURCE(nID), RT_MENU);
HGLOBAL hglMenuTemplate;
WORD version, offset;
DWORD dwHelpId;
const WORD *p, *p0;
if (!hrsrc)
MYERROR;
hglMenuTemplate = LoadResource(m_hResDll, hrsrc);
if (!hglMenuTemplate)
MYERROR;
p = (const WORD*)LockResource(hglMenuTemplate);
if (p == NULL)
MYERROR;
// Standard MENU resource
//struct MenuHeader {
// WORD wVersion; // Currently zero
// WORD cbHeaderSize; // Also zero
//};
// MENUEX resource
//struct MenuExHeader {
// WORD wVersion; // One
// WORD wOffset;
// DWORD dwHelpId;
//};
p0 = p;
version = GET_WORD(p);
p++;
switch (version)
{
case 0:
{
offset = GET_WORD(p);
p += offset;
p++;
if (!ParseMenuResource(p))
goto DONE_ERROR;
}
break;
case 1:
{
offset = GET_WORD(p);
p++;
dwHelpId = GET_DWORD(p);
if (!ParseMenuExResource(p0 + offset))
goto DONE_ERROR;
}
break;
default:
goto DONE_ERROR;
}
UnlockResource(hglMenuTemplate);
FreeResource(hglMenuTemplate);
return TRUE;
DONE_ERROR:
UnlockResource(hglMenuTemplate);
FreeResource(hglMenuTemplate);
MYERROR;
}
const WORD* CResModule::ParseMenuResource(const WORD * res)
{
WORD flags;
WORD id = 0;
LPCWSTR str;
WORD *p0;
//struct PopupMenuItem {
// WORD fItemFlags;
// WCHAR szItemText[];
//};
//struct NormalMenuItem {
// WORD fItemFlags;
// WORD wMenuID;
// WCHAR szItemText[];
//};
do
{
p0 = (WORD *)res;
flags = GET_WORD(res);
res++;
if (!(flags & MF_POPUP))
{
id = GET_WORD(res); //normal menu item
res++;
}
else
id = (WORD)-1; //popup menu item
str = (LPCWSTR)res;
size_t l = wcslen(str)+1;
res += l;
if (flags & MF_POPUP)
{
TCHAR * pBuf = new TCHAR[MAX_STRING_LENGTH];
SecureZeroMemory(pBuf, MAX_STRING_LENGTH * sizeof(TCHAR));
_tcscpy(pBuf, str);
CUtils::StringExtend(pBuf);
std::wstring wstr = std::wstring(pBuf);
RESOURCEENTRY entry = m_StringEntries[wstr];
if (id)
entry.resourceIDs.insert(id);
m_StringEntries[wstr] = entry;
delete [] pBuf;
if ((res = ParseMenuResource(res))==0)
return NULL;
}
else if (id != 0)
{
TCHAR * pBuf = new TCHAR[MAX_STRING_LENGTH];
SecureZeroMemory(pBuf, MAX_STRING_LENGTH * sizeof(TCHAR));
_tcscpy(pBuf, str);
CUtils::StringExtend(pBuf);
std::wstring wstr = std::wstring(pBuf);
RESOURCEENTRY entry = m_StringEntries[wstr];
entry.resourceIDs.insert(id);
TCHAR szTempBuf[1024];
_stprintf(szTempBuf, _T("#: MenuEntry; ID:%d"), id);
MENUENTRY menu_entry;
menu_entry.wID = id;
menu_entry.reference = szTempBuf;
menu_entry.msgstr = wstr;
m_StringEntries[wstr] = entry;
m_MenuEntries[id] = menu_entry;
delete [] pBuf;
}
} while (!(flags & MF_END));
return res;
}
PROTO(void, bout_swap_exec_header_in,
(bfd *abfd,
struct external_exec *raw_bytes,
struct internal_exec *execp));
void
DEFUN(bout_swap_exec_header_in,(abfd, raw_bytes, execp),
bfd *abfd AND
struct external_exec *raw_bytes AND
struct internal_exec *execp)
{
struct external_exec *bytes = (struct external_exec *)raw_bytes;
/* Now fill in fields in the execp, from the bytes in the raw data. */
execp->a_info = bfd_h_get_32 (abfd, bytes->e_info);
execp->a_text = GET_WORD (abfd, bytes->e_text);
execp->a_data = GET_WORD (abfd, bytes->e_data);
execp->a_bss = GET_WORD (abfd, bytes->e_bss);
execp->a_syms = GET_WORD (abfd, bytes->e_syms);
execp->a_entry = GET_WORD (abfd, bytes->e_entry);
execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
execp->a_tload = GET_WORD (abfd, bytes->e_tload);
execp->a_dload = GET_WORD (abfd, bytes->e_dload);
execp->a_talign = bytes->e_talign[0];
execp->a_dalign = bytes->e_dalign[0];
execp->a_balign = bytes->e_balign[0];
execp->a_relaxable = bytes->e_relaxable[0];
}
/* Swaps the information in an internal exec header structure into the
TEST( Types, basic_word_get ) {
util::WORD result = GET_WORD(types::values);
ASSERT_TRUE( result == 0xAA55 );
}
int capi2_checkuser2(int fd,
char *user,
char *passwd)
{
#define CCHECK_ERR -1
int ev;
struct {
CAPI_control_req_t req;
char buffer[256];
} r;
struct {
CAPI_control_conf_ex_t conf;
char buffer[256];
} a;
union CAPI_primitives *cmsg = (union CAPI_primitives *)&a;
int len;
int chall_len = 0;
char *chall = NULL;
struct userdata *data;
md5context_t md5Context;
memset(&r.req, 0, sizeof(r.req));
if (user == NULL) {
return 0; /* OK no authentication desired */
}
if (passwd == NULL) {
passwd = "";
}
PUT_WORD( r.req.len , sizeof(r.req));
PUT_WORD( r.req.appl , fd);
PUT_WORD( r.req.PRIM_type , CAPI_CONTROL_REQ);
PUT_WORD( r.req.messid , 0);
PUT_WORD( r.req.contrl , 0);
PUT_WORD( r.req.type , CTRL_GETCHALLENGE);
PUT_BYTE( r.req.structlen , 0);
if ((ev = capi2_put_message( fd, (char *)&r)) != 0) {
cTRACE( 1, fprintf( stderr, "capi2_put_message rn=0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if ((ev = capi2_wait_for_signal(fd, MAXRTT)) != 0) {
cTRACE(1, fprintf(stderr, "capi2_wait_for_signal 0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if ((ev = capi2_get_message( fd, &cmsg, (union CAPI_primitives *)&a, NULL, 0)) != 0) {
cTRACE( 1, fprintf( stderr, "capi2_get_message rn=0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if (GET_PRIMTYPE(cmsg) == CAPI_CONTROL_CONF
&& GET_WORD(a.conf.type) == CTRL_GETCHALLENGE /* get random number */
&& a.conf.structlen
) {
chall_len = (size_t)a.conf.structlen;
chall = a.buffer; /* random number computed by the brick */
} else {
cTRACE( 1, fprintf( stderr, "CAPI_CONTROL_CONF failed\n"));
capi2_errno = CAPI2_E_REG_OS_RESOURCE_ERROR;
return CCHECK_ERR;
}
/*
* calculate hash value;
* see RFC 1321 for a description of the MD5 algorithm
*/
MD5Init(&md5Context);
MD5Update (&md5Context, (unsigned char *) user, strlen(user));
MD5Update (&md5Context, chall, chall_len);
MD5Update (&md5Context, (unsigned char *) passwd, strlen(passwd));
MD5Final (&md5Context);
PUT_WORD( r.req.appl , fd);
PUT_WORD( r.req.PRIM_type , CAPI_CONTROL_REQ);
PUT_WORD( r.req.messid , 0);
PUT_WORD( r.req.contrl , 0);
PUT_WORD( r.req.type , CTRL_SETUSER);
/* copy user and hash value */
data = (struct userdata *)&r.req.structlen;
data->length = strlen(user);
memcpy( data->data, user, data->length);
data = (struct userdata *)&data->data[data->length];
data->length = CAPI_MD5_HASH_LEN;
memcpy( data->data, md5Context.digest, CAPI_MD5_HASH_LEN); /* hash value to be compared */
data = (struct userdata *)&data->data[data->length]; /* on the other side */
len = (char *)data - (char *)&r;
PUT_WORD( r.req.len, len );
if ((ev = capi2_put_message( fd, (char *)&r)) != 0) {
cTRACE( 1, fprintf( stderr, "capi2_put_message rn=0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if ((ev = capi2_wait_for_signal(fd, MAXRTT)) != 0) {
cTRACE(1, fprintf(stderr, "capi2_wait_for_signal 0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if ((ev = capi2_get_message( fd, &cmsg, (union CAPI_primitives *)&a, NULL, 0)) != 0) {
cTRACE( 1, fprintf( stderr, "capi2_get_message rn=0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if (GET_PRIMTYPE(cmsg) == CAPI_CONTROL_CONF
&& GET_WORD(a.conf.type) == CTRL_SETUSER
&& GET_WORD(a.conf.info) == 1
) {
return 0; /* OK authentication passed */
}
cTRACE( 1, fprintf( stderr, "CAPI_CONTROL_CONF failed, invalid authentication"));
capi2_errno = CAPI2_E_REG_EXT_EQUIPMENT_NOT_SUPPORTED;
return CCHECK_ERR;
}
/************************************************************************
* *
* capi2_register2 *
* *
***********************************************************************/
int rcapi_register(int msgsize,
int level3cnt,
int datablkcnt,
int datablklen,
char *datablock,
rcapi_host_t *host,
rcapi_auth_t *auth)
{
int ev, fd = -1;
CAPI_register_req_t req;
struct {
CAPI_register_conf_t conf;
char buffer[256];
} a;
union CAPI_primitives *cmsg;
memset(&req, 0, sizeof(req));
memset(&a, 0, sizeof(a));
if ((fd = rcapi_open(host)) == -1) {
cTRACE( 1, perror("capi2_open"));
capi2_errno = CAPI2_E_REG_CAPI_NOT_INSTALLED;
goto error;
}
if(auth != NULL) {
if (capi2_checkuser2(fd, auth->user ,auth->passwd) < 0) return -1;
}
PUT_WORD( req.len , sizeof(req));
PUT_WORD( req.appl , fd);
PUT_WORD( req.PRIM_type , CAPI_REGISTER_REQ);
PUT_WORD( req.messid , 0);
PUT_WORD( req.nmess , msgsize);
PUT_WORD( req.nconn , level3cnt);
PUT_WORD( req.ndblock , datablkcnt);
PUT_WORD( req.dblocksiz , datablklen);
PUT_BYTE( req.version , 2); /* CAPI 2.0 */
if ((ev = capi2_put_message( fd, (char *)&req)) != 0) {
cTRACE( 1, fprintf( stderr, "capi2_put_message rn=0x%x", ev));
capi2_errno = ev;
goto error;
}
while ((ev = capi2_get_message( fd, &cmsg, (union CAPI_primitives *)&a,
NULL, 0)) != 0) {
if (ev != CAPI2_E_MSG_QUEUE_EMPTY) break;
}
if (ev) { capi2_errno = ev; goto error; }
if (GET_PRIMTYPE(cmsg) == CAPI_REGISTER_CONF
&& GET_WORD(a.conf.info) == 0
) {
return fd;
}
error:
cTRACE( 1, fprintf( stderr, "capi2_register_req failed\n"));
capi2_close(fd);
return -1;
}
size_t
md_stack_capture_curthread(caddr_t *pcs, size_t size)
{
struct trapframe *tf = curthread->td_intr_frame;
pmap_t pmap = vmspace_pmap(curthread->td_proc->p_vmspace);
size_t num_kstacks = 0, num_ustacks = 0;
#if SAMPLE_DEBUG > 2
printf("%s(%d): curthread pid %u, tid %u, name %s\n", __FUNCTION__, __LINE__, curthread->td_proc->p_pid, curthread->td_tid, curthread->td_name);
#endif
if (tf == NULL) {
#if SAMPLE_DEBUG > 5
printf("%s(%d): intr frame is NULL?\n", __FUNCTION__, __LINE__);
#endif
// tf = curthread->td_frame;
/*
* I'm not sure what this means. This should be done via interrupt,
* so if curthread wasn't interrupted, then I don't think we can get
* anything here? Please tell me what I'm doing wrong.
*/
return 0;
}
if (!TRAPF_USERMODE(tf)) {
// Start with kernel mode
unsigned long callpc;
struct amd64_frame *frame;
frame = (struct amd64_frame*)tf->tf_rbp;
while (num_kstacks < size) {
if (!INKERNEL((long)frame))
break;
callpc = frame->f_retaddr;
if (!INKERNEL(callpc))
break;
pcs[num_kstacks++] = (caddr_t)callpc;
if (frame->f_frame <= frame ||
(vm_offset_t)frame->f_frame >= (vm_offset_t)tf->tf_rbp + KSTACK_PAGES * PAGE_SIZE)
break;
frame = frame->f_frame;
}
tf = curthread->td_frame;
}
if (TRAPF_USERMODE(tf)) {
caddr_t *start_pc = pcs + num_kstacks;
struct amd64_frame frame;
#if SAMPLE_DEBUG > 3
printf("%s(%d): doing user mode crawl\n", __FUNCTION__, __LINE__);
#endif
frame.f_frame = (struct amd64_frame*)tf->tf_rbp;
if (tf != curthread->td_intr_frame) {
start_pc[num_ustacks++] = (caddr_t)tf->tf_rip;
}
while ((num_kstacks + num_ustacks) < size) {
void *bp = frame.f_frame;
/*
* The calls to GET_WORD replace the non-functional:
* copyin_nofault((void*)frame.f_frame, &frame, sizeof(frame));
*/
frame.f_frame = (struct amd64_frame*)GET_WORD(pmap, (caddr_t)frame.f_frame);
if (frame.f_frame == 0) {
#if SAMPLE_DEBUG > 4
printf("%s(%d): %s: frame is 0\n", __FUNCTION__, __LINE__, curthread->td_name);
#endif
break;
}
frame.f_retaddr = (long)GET_WORD(pmap, (caddr_t)frame.f_frame + offsetof(struct amd64_frame, f_retaddr));
if (frame.f_retaddr == 0) {
#if SAMPLE_DEBUG > 4
printf("%s(%d): %s: retaddr from frame %p is 0\n", __FUNCTION__, __LINE__, curthread->td_name, (void*)frame.f_frame);
#endif
break;
}
#if SAMPLE_DEBUG > 2
printf("%s(%d): f_frame = %ld, f_retaddr = %ld\n", __FUNCTION__, __LINE__, (long)frame.f_frame, (long)frame.f_retaddr);
#endif
start_pc[num_ustacks++] = (caddr_t)frame.f_retaddr;
if ((void*)frame.f_frame < bp) {
break;
}
}
} else {
static bool handle_event_in_level(Game *game, SDL_Event *event)
{
if (event->type == SDL_USEREVENT) {
switch (event->user.code) {
case SECOND_ELAPSED_EVENT:
game->time_left--;
if (game->time_left == 0) {
puts("Time's up!");
SDL_Color blue = { 0, 0xDB, 0xEB, 0xFF };
SDL_Texture *missed_words = render_empty_words(game, blue);
SDL_Texture *original_render_target =
SDL_GetRenderTarget(game->renderer);
SDL_SetRenderTarget(game->renderer, game->guessed_words_texture);
SDL_RenderCopy(game->renderer, missed_words, NULL, NULL);
SDL_SetRenderTarget(game->renderer, original_render_target);
// TODO: This could be made more efficient by keeping an index
// into guessed_words too.
for (size_t i = 0; i < game->anagrams->count; i++) {
char *word = GET_WORD(game->anagrams, i);
if (word_position(game->guessed_words, word) == -1)
render_guessed_word(game, word);
}
bool guessed_a_six_letter_word = false;
for (size_t i = 0; i < game->guessed_words->count; i++) {
if (strlen(GET_WORD(game->guessed_words, i)) == 6) {
guessed_a_six_letter_word = true;
break;
}
}
if (guessed_a_six_letter_word) {
char *message = "You qualify for the next round!";
puts(message);
game->state = WON_LEVEL;
game->message_box = render_message_box(game, message);
return true;
} else {
printf("You suck, you failed. No new level for you\n"
"Your final score was %d\n", game->points);
game->state = GAME_OVER;
game->message_box = render_message_box(game, "Game over, loser");
return true;
}
}
break;
}
return true;
} else if (event->type != SDL_KEYDOWN) {
return true;
}
SDL_KeyboardEvent kbe = event->key;
SDL_Keycode vk = kbe.keysym.sym;
if (vk == SDLK_ESCAPE) {
return false;
} else if ((vk >= 'a') && (vk <= 'z')) {
int removed_char_index = -1;
for (size_t i = 0; i < MAX_WORD_LENGTH - game->chars_entered; i++) {
char c = game->remaining_chars[i];
if (c == vk) {
removed_char_index = i;
break;
}
}
if (removed_char_index == -1)
return true;
for (int i = removed_char_index; i < MAX_WORD_LENGTH; i++)
game->remaining_chars[i] = game->remaining_chars[i + 1];
game->curr_input[game->chars_entered++] = vk;
} else if (vk == SDLK_BACKSPACE) {
if (game->chars_entered != 0) {
game->chars_entered--;
char removed = game->curr_input[game->chars_entered];
game->remaining_chars[
MAX_WORD_LENGTH - game->chars_entered - 1] = removed;
game->curr_input[game->chars_entered] = '\0';
}
} else if (vk == SDLK_SPACE) {
shuffle(game->remaining_chars);
} else if (vk == SDLK_RETURN) {
size_t length = strlen(game->curr_input);
int position;
if (length < 3 || length > 6) {
printf("%s is not the right length\n", game->curr_input);
} else if (word_position(game->guessed_words, game->curr_input) != -1) {
printf("you've already guessed %s\n", game->curr_input);
} else if ((position = word_position(
game->anagrams_by_length[length - 3],
game->curr_input))
!= -1) {
printf("yep, %s is correct\n", game->curr_input);
memcpy(GET_WORD(game->guessed_words, game->guessed_words->count),
game->curr_input, length);
game->guessed_words->count++;
render_guessed_word(game, game->curr_input);
game->points += 10 * length * length;
if (game->guessed_words->count == game->anagrams->count) {
char *message = "You guessed all the words!";
puts(message);
game->message_box = render_message_box(game, message);
game->state = WON_LEVEL;
// Bonus for guessing all the words.
game->points += game->anagrams->count * 200 + 100;
return true;
}
} else {
printf("no, %s is wrong\n", game->curr_input);
}
memcpy((game->remaining_chars + MAX_WORD_LENGTH) - game->chars_entered,
game->curr_input, game->chars_entered);
memset(game->curr_input, 0, game->chars_entered);
game->chars_entered = 0;
}
return true;
}
int getCapiInfo( union CAPI_primitives *capi )
{
int info;
switch (GET_PRIMTYPE(capi)) {
case CAPI2_LISTEN_CONF:
info = GET_WORD(capi->c2listen_conf.info);
break;
case CAPI2_ALERT_CONF:
info = GET_WORD(capi->c2alert_conf.info);
break;
case CAPI2_CONNECT_CONF:
info = GET_WORD(capi->c2connect_conf.info);
break;
case CAPI2_INFO_CONF:
info = GET_WORD(capi->c2info_conf.info);
break;
case CAPI2_CONNECTB3_CONF:
info = GET_WORD(capi->c2connectb3_conf.info);
break;
case CAPI2_DATAB3_CONF:
info = GET_WORD(capi->c2datab3_conf.info);
break;
case CAPI2_RESETB3_CONF:
info = GET_WORD(capi->c2resetb3_conf.info);
break;
case CAPI2_DISCONNECTB3_CONF:
info = GET_WORD(capi->c2disconnectb3_conf.info);
break;
case CAPI2_DISCONNECT_CONF:
info = GET_WORD(capi->c2disconnect_conf.info);
break;
case CAPI2_FACILITY_CONF:
info = GET_WORD(capi->c2facility_conf.info);
break;
case CAPI2_SELECTB_CONF:
info = GET_WORD(capi->c2selectb_conf.info);
break;
case CAPI2_DISCONNECT_IND:
info = GET_WORD(capi->c2disconnect_ind.reason);
break;
case CAPI2_DISCONNECTB3_IND:
info = GET_WORD(capi->c2disconnectb3_ind.reason_b3);
break;
default:
info = 0;
break;
}
return (info);
}
const WORD* CResModule::ReplaceControlInfo(const WORD * res, size_t * wordcount, WORD * newDialog, BOOL bEx)
{
if (bEx)
{
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++); //helpid
newDialog[(*wordcount)++] = GET_WORD(res++); //helpid
}
else
{
res += 2;
(*wordcount) += 2;
}
}
if (newDialog)
{
LONG * exStyle = (LONG*)&newDialog[(*wordcount)];
newDialog[(*wordcount)++] = GET_WORD(res++); //exStyle
newDialog[(*wordcount)++] = GET_WORD(res++); //exStyle
if (m_bRTL)
*exStyle |= WS_EX_RTLREADING;
}
else
{
res += 2;
(*wordcount) += 2;
}
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++); //style
newDialog[(*wordcount)++] = GET_WORD(res++); //style
}
else
{
res += 2;
(*wordcount) += 2;
}
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res); //x
res++;
(*wordcount)++;
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res); //y
res++;
(*wordcount)++;
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res); //cx
res++;
(*wordcount)++;
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res); //cy
res++;
(*wordcount)++;
if (bEx)
{
// ID is a DWORD for DIALOGEX
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++);
newDialog[(*wordcount)++] = GET_WORD(res++);
}
else
{
res += 2;
(*wordcount) += 2;
}
}
else
{
if (newDialog)
newDialog[(*wordcount)] = GET_WORD(res);
res++;
(*wordcount)++;
}
if (GET_WORD(res) == 0xffff) //classID
{
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++);
newDialog[(*wordcount)++] = GET_WORD(res++);
}
else
{
res += 2;
(*wordcount) += 2;
}
}
else
{
if (newDialog)
wcscpy((LPWSTR)&newDialog[(*wordcount)], (LPCWSTR)res);
(*wordcount) += wcslen((LPCWSTR) res) + 1;
res += wcslen((LPCWSTR) res) + 1;
}
if (GET_WORD(res) == 0xffff) // an integer ID?
{
if (newDialog)
{
newDialog[(*wordcount)++] = GET_WORD(res++);
newDialog[(*wordcount)++] = GET_WORD(res++);
}
else
{
res += 2;
(*wordcount) += 2;
}
}
else
{
ReplaceStr((LPCWSTR)res, newDialog, wordcount, &m_bTranslatedDialogStrings, &m_bDefaultDialogStrings);
res += wcslen((LPCWSTR)res) + 1;
}
if (newDialog)
memcpy(&newDialog[(*wordcount)], res, (GET_WORD(res)+1)*sizeof(WORD));
(*wordcount) += (GET_WORD(res)+1);
res += (GET_WORD(res)+1);
// Next control is on DWORD boundary
while ((*wordcount) % 2)
(*wordcount)++;
return (const WORD *)((((long)res) + 3) & ~3);
}
// =======================================================
void CHfsPart::readSuperBlock()
{
BEGIN;
QWORD qwBlocksInRegularAlloc;
hfsSuperBlock sb, sb2;
int nRes;
// read superblock
nRes = readData(&sb, 1024, sizeof(sb));
if (nRes == -1)
{
showDebug(10, "ERROR 1\n");
g_interface -> ErrorReadingSuperblock(errno);
THROW(ERR_READING, (DWORD)0, errno);
}
if (Be16ToCpu(GET_WORD(&sb.drSigWord)) != HFS_SUPER_MAGIC)
{
showDebug(10, "ERROR 2\n");
g_interface -> ErrorReadingSuperblock(errno);
THROW(ERR_READING, (DWORD)0, errno);
}
// init
memset(&m_info, 0, sizeof(CInfoHfsHeader));
m_info.qwAllocCount = BeToCpu(GET_WORD(&sb.drNmAlBlks));
m_info.dwAllocSize = BeToCpu(GET_DWORD(&sb.drAlBlkSize));
m_info.dwBlocksPerAlloc = m_info.dwAllocSize / 512;
m_info.qwBitmapSectLocation = (QWORD)BeToCpu(GET_WORD(&sb.drVBMSt));
m_info.qwFirstAllocBlock = (QWORD)BeToCpu(GET_WORD(&sb.drAlBlSt));
m_info.qwFreeAllocs = (QWORD)BeToCpu(GET_WORD(&sb.drFreeBks));
// if not a 512 multiple
if ((m_info.dwAllocSize % 512) != 0)
THROW(ERR_READING, (DWORD)0, errno);
// check the last but one block is a superblock
qwBlocksInRegularAlloc = m_info.dwBlocksPerAlloc * m_info.qwAllocCount;
nRes = readData(&sb2, (m_info.qwFirstAllocBlock+qwBlocksInRegularAlloc)*512LL, sizeof(sb2));
if (nRes == -1)
{
showDebug(10, "ERROR 3\n");
g_interface -> ErrorReadingSuperblock(errno);
THROW(ERR_READING, (DWORD)0, errno);
}
if (Be16ToCpu(GET_WORD(&sb.drSigWord)) != HFS_SUPER_MAGIC)
{
showDebug(10, "ERROR 4\n");
g_interface -> ErrorReadingSuperblock(errno);
THROW(ERR_READING, (DWORD)0, errno);
}
// show infos
showDebug(10, "m_info.qwAllocCount=%llu\n", m_info.qwAllocCount);
showDebug(10, "m_info.dwAllocSize=%lu=%lu sectors\n", m_info.dwAllocSize, m_info.dwBlocksPerAlloc);
showDebug(10, "m_info.qwBitmapSectLocation=%llu\n", m_info.qwBitmapSectLocation);
showDebug(10, "m_info.qwFirstAllocBlock=%llu\n", m_info.qwFirstAllocBlock);
showDebug(10, "m_info.qwFreeAllocs=%llu\n", m_info.qwFreeAllocs);
// label == pascal string
memset(m_header.szLabel, 0, 64);
memcpy(m_header.szLabel, ((char*)&sb.drVN)+1, my_min(((BYTE*)&sb.drVN)[0], 63));
showDebug(10, "label=[%s]\n", m_header.szLabel);
// calculate sectors count
m_header.qwBlocksCount = m_info.qwFirstAllocBlock // first reserved (2 boot blocks, 1 superblock, ...)
+ (m_info.dwBlocksPerAlloc * m_info.qwAllocCount) // allocation blocks
+ 1 // alternate superblock
+ 1; // last volume of sector
showDebug(10, "m_header.qwBlocksCount = %llu\n", m_header.qwBlocksCount);
m_header.qwBlockSize = 512;
m_header.qwBitmapSize = (m_header.qwBlocksCount+7)/8;
QWORD qwUsedBlocks = m_info.qwFirstAllocBlock + 2 + ((m_info.qwAllocCount-m_info.qwFreeAllocs) * m_info.dwBlocksPerAlloc);
QWORD qwFreeBlocks = m_info.qwFreeAllocs * m_info.dwBlocksPerAlloc;
setSuperBlockInfos(true, true, qwUsedBlocks*512, qwFreeBlocks*512);
RETURN;
}
BOOL CResModule::ReplaceString(UINT nID, WORD wLanguage)
{
HRSRC hrsrc = FindResourceEx(m_hResDll, RT_STRING, MAKEINTRESOURCE(nID), wLanguage);
HGLOBAL hglStringTable;
LPWSTR p;
if (!hrsrc)
MYERROR;
hglStringTable = LoadResource(m_hResDll, hrsrc);
if (!hglStringTable)
goto DONE_ERROR;
p = (LPWSTR)LockResource(hglStringTable);
if (p == NULL)
goto DONE_ERROR;
/* [Block of 16 strings. The strings are Pascal style with a WORD
length preceding the string. 16 strings are always written, even
if not all slots are full. Any slots in the block with no string
have a zero WORD for the length.]
*/
//first check how much memory we need
size_t nMem = 0;
LPWSTR pp = p;
for (int i=0; i<16; ++i)
{
nMem++;
size_t len = GET_WORD(pp);
pp++;
std::wstring msgid = std::wstring(pp, len);
WCHAR * pBuf = new WCHAR[MAX_STRING_LENGTH*2];
SecureZeroMemory(pBuf, MAX_STRING_LENGTH*2*sizeof(WCHAR));
wcscpy(pBuf, msgid.c_str());
CUtils::StringExtend(pBuf);
msgid = std::wstring(pBuf);
RESOURCEENTRY resEntry;
resEntry = m_StringEntries[msgid];
wcscpy(pBuf, resEntry.msgstr.c_str());
CUtils::StringCollapse(pBuf);
size_t newlen = wcslen(pBuf);
if (newlen)
nMem += newlen;
else
nMem += len;
pp += len;
delete [] pBuf;
}
WORD * newTable = new WORD[nMem + (nMem % 2)];
SecureZeroMemory(newTable, (nMem + (nMem % 2))*2);
size_t index = 0;
for (int i=0; i<16; ++i)
{
int len = GET_WORD(p);
p++;
std::wstring msgid = std::wstring(p, len);
WCHAR * pBuf = new WCHAR[MAX_STRING_LENGTH*2];
SecureZeroMemory(pBuf, MAX_STRING_LENGTH*2*sizeof(WCHAR));
wcscpy(pBuf, msgid.c_str());
CUtils::StringExtend(pBuf);
msgid = std::wstring(pBuf);
RESOURCEENTRY resEntry;
resEntry = m_StringEntries[msgid];
wcscpy(pBuf, resEntry.msgstr.c_str());
CUtils::StringCollapse(pBuf);
size_t newlen = wcslen(pBuf);
if (newlen)
{
newTable[index++] = (WORD)newlen;
wcsncpy((wchar_t *)&newTable[index], pBuf, newlen);
index += newlen;
m_bTranslatedStrings++;
}
else
{
newTable[index++] = (WORD)len;
if (len)
wcsncpy((wchar_t *)&newTable[index], p, len);
index += len;
if (len)
m_bDefaultStrings++;
}
p += len;
delete [] pBuf;
}
if (!UpdateResource(m_hUpdateRes, RT_STRING, MAKEINTRESOURCE(nID), (m_wTargetLang ? m_wTargetLang : wLanguage), newTable, (DWORD)(nMem + (nMem % 2))*2))
{
delete [] newTable;
goto DONE_ERROR;
}
if ((m_wTargetLang)&&(!UpdateResource(m_hUpdateRes, RT_STRING, MAKEINTRESOURCE(nID), wLanguage, NULL, 0)))
{
delete [] newTable;
goto DONE_ERROR;
}
delete [] newTable;
UnlockResource(hglStringTable);
FreeResource(hglStringTable);
return TRUE;
DONE_ERROR:
UnlockResource(hglStringTable);
FreeResource(hglStringTable);
MYERROR;
}
/**********************************************************************
* Convert ActiveX control templates to AtlAxWin class instances
*/
static LPDLGTEMPLATEW AX_ConvertDialogTemplate(LPCDLGTEMPLATEW src_tmpl)
{
#define GET_WORD(x) (*(const WORD *)(x))
#define GET_DWORD(x) (*(const DWORD *)(x))
#define PUT_BLOCK(x,y) do {if (!advance_array(&output, &allocated, &filled, (x), (y))) return NULL;} while (0)
#define PUT_WORD(x) do {WORD w = (x);PUT_BLOCK(&w, 1);} while(0)
#define PUT_DWORD(x) do {DWORD w = (x);PUT_BLOCK(&w, 2);} while(0)
const WORD *tmp, *src = (const WORD *)src_tmpl;
WORD *output;
DWORD allocated, filled; /* in WORDs */
BOOL ext;
WORD signature, dlgver, rescount;
DWORD style;
filled = 0; allocated = 256;
output = HeapAlloc( GetProcessHeap(), 0, allocated * sizeof(WORD) );
if (!output)
return NULL;
/* header */
tmp = src;
signature = GET_WORD(src);
dlgver = GET_WORD(src + 1);
if (signature == 1 && dlgver == 0xFFFF)
{
ext = TRUE;
src += 6;
style = GET_DWORD(src);
src += 2;
rescount = GET_WORD(src++);
src += 4;
if ( GET_WORD(src) == 0xFFFF ) /* menu */
src += 2;
else
src += strlenW(src) + 1;
if ( GET_WORD(src) == 0xFFFF ) /* class */
src += 2;
else
src += strlenW(src) + 1;
src += strlenW(src) + 1; /* title */
if ( style & (DS_SETFONT | DS_SHELLFONT) )
{
src += 3;
src += strlenW(src) + 1;
}
} else {
ext = FALSE;
style = GET_DWORD(src);
src += 4;
rescount = GET_WORD(src++);
src += 4;
if ( GET_WORD(src) == 0xFFFF ) /* menu */
src += 2;
else
src += strlenW(src) + 1;
if ( GET_WORD(src) == 0xFFFF ) /* class */
src += 2;
else
src += strlenW(src) + 1;
src += strlenW(src) + 1; /* title */
if ( style & DS_SETFONT )
{
src++;
src += strlenW(src) + 1;
}
}
PUT_BLOCK(tmp, src-tmp);
while(rescount--)
{
src = (const WORD *)( ( ((ULONG_PTR)src) + 3) & ~3); /* align on DWORD boundary */
filled = (filled + 1) & ~1; /* depends on DWORD-aligned allocation unit */
tmp = src;
if (ext)
src += 12;
else
src += 9;
PUT_BLOCK(tmp, src-tmp);
tmp = src;
if ( GET_WORD(src) == 0xFFFF ) /* class */
{
src += 2;
} else
{
src += strlenW(src) + 1;
}
src += strlenW(src) + 1; /* title */
if ( GET_WORD(tmp) == '{' ) /* all this mess created because of this line */
{
static const WCHAR AtlAxWin[] = {'A','t','l','A','x','W','i','n', 0};
PUT_BLOCK(AtlAxWin, sizeof(AtlAxWin)/sizeof(WCHAR));
PUT_BLOCK(tmp, strlenW(tmp)+1);
} else
PUT_BLOCK(tmp, src-tmp);
if ( GET_WORD(src) )
{
WORD size = (GET_WORD(src)+sizeof(WORD)-1) / sizeof(WORD); /* quite ugly :( Maybe use BYTE* instead of WORD* everywhere ? */
PUT_BLOCK(src, size);
src+=size;
}
else
{
PUT_WORD(0);
src++;
}
}
return (LPDLGTEMPLATEW) output;
}
BOOL CResModule::ReplaceMenu(UINT nID, WORD wLanguage)
{
HRSRC hrsrc = FindResourceEx(m_hResDll, RT_MENU, MAKEINTRESOURCE(nID), wLanguage);
HGLOBAL hglMenuTemplate;
WORD version, offset;
LPWSTR p;
WORD *p0;
DWORD dwHelpId;
if (!hrsrc)
MYERROR; //just the language wasn't found
hglMenuTemplate = LoadResource(m_hResDll, hrsrc);
if (!hglMenuTemplate)
MYERROR;
p = (LPWSTR)LockResource(hglMenuTemplate);
if (p == NULL)
MYERROR;
//struct MenuHeader {
// WORD wVersion; // Currently zero
// WORD cbHeaderSize; // Also zero
//};
// MENUEX resource
//struct MenuExHeader {
// WORD wVersion; // One
// WORD wOffset;
// DWORD dwHelpId;
//};
p0 = (WORD *)p;
version = GET_WORD(p);
p++;
switch (version)
{
case 0:
{
offset = GET_WORD(p);
p += offset;
p++;
size_t nMem = 0;
if (!CountMemReplaceMenuResource((WORD *)p, &nMem, NULL))
goto DONE_ERROR;
WORD * newMenu = new WORD[nMem + (nMem % 2)+2];
SecureZeroMemory(newMenu, (nMem + (nMem % 2)+2)*2);
size_t index = 2; // MenuHeader has 2 WORDs zero
if (!CountMemReplaceMenuResource((WORD *)p, &index, newMenu))
{
delete [] newMenu;
goto DONE_ERROR;
}
if (!UpdateResource(m_hUpdateRes, RT_MENU, MAKEINTRESOURCE(nID), (m_wTargetLang ? m_wTargetLang : wLanguage), newMenu, (DWORD)(nMem + (nMem % 2)+2)*2))
{
delete [] newMenu;
goto DONE_ERROR;
}
if ((m_wTargetLang)&&(!UpdateResource(m_hUpdateRes, RT_MENU, MAKEINTRESOURCE(nID), wLanguage, NULL, 0)))
{
delete [] newMenu;
goto DONE_ERROR;
}
delete [] newMenu;
}
break;
case 1:
{
offset = GET_WORD(p);
p++;
dwHelpId = GET_DWORD(p);
size_t nMem = 0;
if (!CountMemReplaceMenuExResource((WORD *)(p0 + offset), &nMem, NULL))
goto DONE_ERROR;
WORD * newMenu = new WORD[nMem + (nMem % 2) + 4];
SecureZeroMemory(newMenu, (nMem + (nMem % 2) + 4) * 2);
CopyMemory(newMenu, p0, 2 * sizeof(WORD) + sizeof(DWORD));
size_t index = 4; // MenuExHeader has 2 x WORD + 1 x DWORD
if (!CountMemReplaceMenuExResource((WORD *)(p0 + offset), &index, newMenu))
{
delete [] newMenu;
goto DONE_ERROR;
}
if (!UpdateResource(m_hUpdateRes, RT_MENU, MAKEINTRESOURCE(nID), (m_wTargetLang ? m_wTargetLang : wLanguage), newMenu, (DWORD)(nMem + (nMem % 2) + 4) * 2))
{
delete [] newMenu;
goto DONE_ERROR;
}
if ((m_wTargetLang)&&(!UpdateResource(m_hUpdateRes, RT_MENU, MAKEINTRESOURCE(nID), wLanguage, NULL, 0)))
{
delete [] newMenu;
goto DONE_ERROR;
}
delete [] newMenu;
}
break;
default:
goto DONE_ERROR;
}
UnlockResource(hglMenuTemplate);
FreeResource(hglMenuTemplate);
return TRUE;
DONE_ERROR:
UnlockResource(hglMenuTemplate);
FreeResource(hglMenuTemplate);
MYERROR;
}
/**
* This can't be implemented directly with QT.
* (We can use QSound to play local files but that was not enough.
* Also support of media formats is limited)
*
* Current implementation is copied from GTK side and implementation uses ESD interface.
*
* If we have Qtopia then we can drop ESD implementation and use Qtopia "Multimedia API"
*/
NS_IMETHODIMP nsSound::OnStreamComplete(nsIStreamLoader *aLoader,
nsISupports *context,
nsresult aStatus,
PRUint32 dataLen,
const PRUint8 *data)
{
#define GET_WORD(s, i) (s[i+1] << 8) | s[i]
#define GET_DWORD(s, i) (s[i+3] << 24) | (s[i+2] << 16) | (s[i+1] << 8) | s[i]
// print a load error on bad status, and return
if (NS_FAILED(aStatus)) {
#ifdef DEBUG
if (aLoader) {
nsCOMPtr<nsIRequest> request;
aLoader->GetRequest(getter_AddRefs(request));
if (request) {
nsCOMPtr<nsIURI> uri;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (channel) {
channel->GetURI(getter_AddRefs(uri));
if (uri) {
nsCAutoString uriSpec;
uri->GetSpec(uriSpec);
printf("Failed to load %s\n", uriSpec.get());
}
}
}
}
#endif
return aStatus;
}
int fd, mask = 0;
PRUint32 samples_per_sec = 0, avg_bytes_per_sec = 0, chunk_len = 0;
PRUint16 format, channels = 1, bits_per_sample = 0;
const PRUint8 *audio = nsnull;
size_t audio_len = 0;
if (dataLen < 4) {
NS_WARNING("Sound stream too short to determine its type");
return NS_ERROR_FAILURE;
}
if (memcmp(data, "RIFF", 4)) {
#ifdef DEBUG
printf("We only support WAV files currently.\n");
#endif
return NS_ERROR_FAILURE;
}
if (dataLen <= WAV_MIN_LENGTH) {
NS_WARNING("WAV files should be longer than 44 bytes.");
return NS_ERROR_FAILURE;
}
PRUint32 i = 12;
while (i + 7 < dataLen) {
if (!memcmp(data + i, "fmt ", 4) && !chunk_len) {
i += 4;
/* length of the rest of this subblock (should be 16 for PCM data */
chunk_len = GET_DWORD(data, i);
i += 4;
if (chunk_len < 16 || i + chunk_len >= dataLen) {
NS_WARNING("Invalid WAV file: bad fmt chunk.");
return NS_ERROR_FAILURE;
}
format = GET_WORD(data, i);
i += 2;
channels = GET_WORD(data, i);
i += 2;
samples_per_sec = GET_DWORD(data, i);
i += 4;
avg_bytes_per_sec = GET_DWORD(data, i);
i += 4;
// block align
i += 2;
bits_per_sample = GET_WORD(data, i);
i += 2;
/* we don't support WAVs with odd compression codes */
if (chunk_len != 16)
NS_WARNING("Extra format bits found in WAV. Ignoring");
i += chunk_len - 16;
} else if (!memcmp(data + i, "data", 4)) {
i += 4;
if (!chunk_len) {
NS_WARNING("Invalid WAV file: no fmt chunk found");
return NS_ERROR_FAILURE;
}
audio_len = GET_DWORD(data, i);
i += 4;
/* try to play truncated WAVs */
if (i + audio_len > dataLen)
audio_len = dataLen - i;
audio = data + i;
break;
} else {
i += 4;
i += GET_DWORD(data, i);
i += 4;
}
}
if (!audio) {
NS_WARNING("Invalid WAV file: no data chunk found");
return NS_ERROR_FAILURE;
}
/* No audio data? well, at least the WAV was valid. */
if (!audio_len)
return NS_OK;
#if 0
printf("f: %d | c: %d | sps: %li | abps: %li | ba: %d | bps: %d | rate: %li\n",
format, channels, samples_per_sec, avg_bytes_per_sec, block_align, bits_per_sample, rate);
#endif
/* open up connection to esd */
EsdPlayStreamType EsdPlayStream =
(EsdPlayStreamType) PR_FindFunctionSymbol(elib,
"esd_play_stream");
if (!EsdPlayStream)
return NS_ERROR_FAILURE;
mask = ESD_PLAY | ESD_STREAM;
if (bits_per_sample == 8)
mask |= ESD_BITS8;
else
mask |= ESD_BITS16;
if (channels == 1)
mask |= ESD_MONO;
else
mask |= ESD_STEREO;
nsAutoArrayPtr<PRUint8> buf;
// ESD only handle little-endian data.
// Swap the byte order if we're on a big-endian architecture.
#ifdef IS_BIG_ENDIAN
if (bits_per_sample != 8) {
buf = new PRUint8[audio_len];
if (!buf)
return NS_ERROR_OUT_OF_MEMORY;
for (PRUint32 j = 0; j + 2 < audio_len; j += 2) {
buf[j] = audio[j + 1];
buf[j + 1] = audio[j];
}
audio = buf;
}
#endif
fd = (*EsdPlayStream)(mask, samples_per_sec, NULL, "mozillaSound");
if (fd < 0) {
int *esd_audio_format = (int *) PR_FindSymbol(elib, "esd_audio_format");
int *esd_audio_rate = (int *) PR_FindSymbol(elib, "esd_audio_rate");
EsdAudioOpenType EsdAudioOpen = (EsdAudioOpenType) PR_FindFunctionSymbol(elib, "esd_audio_open");
EsdAudioWriteType EsdAudioWrite = (EsdAudioWriteType) PR_FindFunctionSymbol(elib, "esd_audio_write");
EsdAudioCloseType EsdAudioClose = (EsdAudioCloseType) PR_FindFunctionSymbol(elib, "esd_audio_close");
if (!esd_audio_format || !esd_audio_rate ||
!EsdAudioOpen || !EsdAudioWrite || !EsdAudioClose)
return NS_ERROR_FAILURE;
*esd_audio_format = mask;
*esd_audio_rate = samples_per_sec;
fd = (*EsdAudioOpen)();
if (fd < 0)
return NS_ERROR_FAILURE;
(*EsdAudioWrite)(audio, audio_len);
(*EsdAudioClose)();
} else {
while (audio_len > 0) {
size_t written = write(fd, audio, audio_len);
if (written <= 0)
break;
audio += written;
audio_len -= written;
}
close(fd);
}
return NS_OK;
}
const WORD* CResModule::ParseMenuExResource(const WORD * res)
{
DWORD dwType, dwState, menuId;
WORD bResInfo;
LPCWSTR str;
WORD *p0;
//struct MenuExItem {
// DWORD dwType;
// DWORD dwState;
// DWORD menuId;
// WORD bResInfo;
// WCHAR szText[];
// DWORD dwHelpId; - Popup menu only
//};
do
{
p0 = (WORD *)res;
dwType = GET_DWORD(res);
res += 2;
dwState = GET_DWORD(res);
res += 2;
menuId = GET_DWORD(res);
res += 2;
bResInfo = GET_WORD(res);
res++;
str = (LPCWSTR)res;
size_t l = wcslen(str)+1;
res += l;
// Align to DWORD boundary
res += ((((WORD)res + 3) & ~3) - (WORD)res)/sizeof(WORD);
if (dwType & MFT_SEPARATOR)
continue;
if (bResInfo & 0x01)
{
// Popup menu - note this can also have a non-zero ID
if (menuId == 0)
menuId = (WORD)-1;
TCHAR * pBuf = new TCHAR[MAX_STRING_LENGTH];
SecureZeroMemory(pBuf, MAX_STRING_LENGTH * sizeof(TCHAR));
_tcscpy(pBuf, str);
CUtils::StringExtend(pBuf);
std::wstring wstr = std::wstring(pBuf);
RESOURCEENTRY entry = m_StringEntries[wstr];
// Popup has a DWORD help entry on a DWORD boundary - skip over it
res += 2;
entry.resourceIDs.insert(menuId);
TCHAR szTempBuf[1024];
_stprintf(szTempBuf, _T("#: MenuExPopupEntry; ID:%d"), menuId);
MENUENTRY menu_entry;
menu_entry.wID = (WORD)menuId;
menu_entry.reference = szTempBuf;
menu_entry.msgstr = wstr;
m_StringEntries[wstr] = entry;
m_MenuEntries[(WORD)menuId] = menu_entry;
delete [] pBuf;
if ((res = ParseMenuExResource(res)) == 0)
return NULL;
} else if (menuId != 0)
{
TCHAR * pBuf = new TCHAR[MAX_STRING_LENGTH];
SecureZeroMemory(pBuf, MAX_STRING_LENGTH * sizeof(TCHAR));
_tcscpy(pBuf, str);
CUtils::StringExtend(pBuf);
std::wstring wstr = std::wstring(pBuf);
RESOURCEENTRY entry = m_StringEntries[wstr];
entry.resourceIDs.insert(menuId);
TCHAR szTempBuf[1024];
_stprintf(szTempBuf, _T("#: MenuExEntry; ID:%d"), menuId);
MENUENTRY menu_entry;
menu_entry.wID = (WORD)menuId;
menu_entry.reference = szTempBuf;
menu_entry.msgstr = wstr;
m_StringEntries[wstr] = entry;
m_MenuEntries[(WORD)menuId] = menu_entry;
delete [] pBuf;
}
} while (!(bResInfo & 0x80));
return res;
}
void debug_printf(void) {
char buffer[4096];
size_t maxlen = sizeof(buffer);
int fp = GET_REG16(7)+2;
const char *format = (char*) &memory[GET_WORD(fp)];
fp += 2;
char ch;
long value;
char *strvalue;
int min;
int max;
int state;
int flags;
int cflags;
size_t currlen;
state = DP_S_DEFAULT;
currlen = flags = cflags = min = 0;
max = -1;
ch = *format++;
while (state != DP_S_DONE) {
if (ch == '\0')
state = DP_S_DONE;
switch(state) {
case DP_S_DEFAULT:
if (ch == '%')
state = DP_S_FLAGS;
else
dopr_outch (buffer, &currlen, maxlen, ch);
ch = *format++;
break;
case DP_S_FLAGS:
switch (ch) {
case '-':
flags |= DP_F_MINUS;
ch = *format++;
break;
case '+':
flags |= DP_F_PLUS;
ch = *format++;
break;
case ' ':
flags |= DP_F_SPACE;
ch = *format++;
break;
case '#':
flags |= DP_F_NUM;
ch = *format++;
break;
case '0':
flags |= DP_F_ZERO;
ch = *format++;
break;
default:
state = DP_S_MIN;
break;
}
break;
case DP_S_MIN:
if (isdigit((unsigned char)ch)) {
min = 10*min + char_to_int (ch);
ch = *format++;
} else if (ch == '*') {
min = (short) GET_WORD(fp);
fp += 2;
ch = *format++;
state = DP_S_DOT;
} else {
state = DP_S_DOT;
}
break;
case DP_S_DOT:
if (ch == '.') {
state = DP_S_MAX;
ch = *format++;
} else {
state = DP_S_MOD;
}
break;
case DP_S_MAX:
if (isdigit((unsigned char)ch)) {
if (max < 0)
max = 0;
max = 10*max + char_to_int (ch);
ch = *format++;
} else if (ch == '*') {
min = (short) GET_WORD(fp);
fp += 2;
ch = *format++;
state = DP_S_MOD;
} else {
state = DP_S_MOD;
}
break;
case DP_S_MOD:
switch (ch) {
case 'h':
cflags = DP_C_SHORT;
ch = *format++;
break;
case 'l':
cflags = DP_C_LONG;
ch = *format++;
break;
default:
break;
}
state = DP_S_CONV;
break;
case DP_S_CONV:
switch (ch) {
case 'd':
case 'i':
if (cflags == DP_C_LONG) {
value = ((int) (short) GET_WORD(fp)) << 16
| GET_WORD(fp+2);
fp += 4;
} else {
value = (short) GET_WORD(fp);
fp += 2;
}
fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
break;
case 'o':
flags |= DP_F_UNSIGNED;
if (cflags == DP_C_LONG) {
value = ((unsigned int) GET_WORD(fp)) << 16
| GET_WORD(fp+2);
fp += 4;
} else {
value = GET_WORD(fp);
fp += 2;
}
fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
break;
case 'u':
flags |= DP_F_UNSIGNED;
if (cflags == DP_C_LONG) {
value = ((unsigned int) GET_WORD(fp)) << 16
| GET_WORD(fp+2);
fp += 4;
} else {
value = GET_WORD(fp);
fp += 2;
}
fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
break;
case 'X':
flags |= DP_F_UP;
case 'x':
flags |= DP_F_UNSIGNED;
if (cflags == DP_C_LONG) {
value = ((unsigned int) GET_WORD(fp)) << 16
| GET_WORD(fp+2);
fp += 4;
} else {
value = GET_WORD(fp);
fp += 2;
}
fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
break;
case 'c':
dopr_outch (buffer, &currlen, maxlen,
(int)(short)GET_WORD(fp));
fp += 2;
break;
case 's':
{
int addr = GET_WORD(fp);
strvalue = (char*) &memory[addr];
if (!addr)
strvalue = "(NULL)";
if (max == -1) {
max = strlen(strvalue);
}
if (min > 0 && max >= 0 && min > max) max = min;
fmtstr (buffer, &currlen, maxlen, strvalue, flags,
min, max);
}
break;
case 'p':
value = GET_WORD(fp);
fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
break;
case '%':
dopr_outch (buffer, &currlen, maxlen, ch);
break;
default:
/* Unknown, skip */
break;
}
ch = *format++;
state = DP_S_DEFAULT;
flags = cflags = min = 0;
max = -1;
break;
case DP_S_DONE:
break;
default:
/* hmm? */
break; /* some picky compilers need this */
}
}
if (maxlen != 0) {
if (currlen < maxlen - 1)
buffer[currlen] = '\0';
else if (maxlen > 0)
buffer[maxlen - 1] = '\0';
}
printf("Program said: `%s'\n", buffer);
}
