/***********************************************************************
* SHELL32_GetDisplayNameOfChild
*
* Retrieves the display name of a child object of a shellfolder.
*
* For a pidl eg. [subpidl1][subpidl2][subpidl3]:
* - it binds to the child shellfolder [subpidl1]
* - asks it for the displayname of [subpidl2][subpidl3]
*
* Is possible the pidl is a simple pidl. In this case it asks the
* subfolder for the displayname of an empty pidl. The subfolder
* returns the own displayname eg. "::{guid}". This is used for
* virtual folders with the registry key WantsFORPARSING set.
*/
HRESULT SHELL32_GetDisplayNameOfChild (IShellFolder2 * psf,
LPCITEMIDLIST pidl, DWORD dwFlags, LPWSTR szOut, DWORD dwOutLen)
{
LPITEMIDLIST pidlFirst;
HRESULT hr;
TRACE ("(%p)->(pidl=%p 0x%08x %p 0x%08x)\n", psf, pidl, dwFlags, szOut, dwOutLen);
pdump (pidl);
pidlFirst = ILCloneFirst (pidl);
if (pidlFirst) {
IShellFolder2 *psfChild;
hr = IShellFolder2_BindToObject (psf, pidlFirst, NULL, &IID_IShellFolder, (LPVOID *) & psfChild);
if (SUCCEEDED (hr)) {
STRRET strTemp;
LPITEMIDLIST pidlNext = ILGetNext (pidl);
hr = IShellFolder2_GetDisplayNameOf (psfChild, pidlNext, dwFlags, &strTemp);
if (SUCCEEDED (hr)) {
if(!StrRetToStrNW (szOut, dwOutLen, &strTemp, pidlNext))
hr = E_FAIL;
}
IShellFolder2_Release (psfChild);
}
ILFree (pidlFirst);
} else
hr = E_OUTOFMEMORY;
TRACE ("-- ret=0x%08x %s\n", hr, debugstr_w(szOut));
return hr;
}
/**************************************************************************
* ISF_ControlPanel_fnGetAttributesOf
*/
static HRESULT WINAPI
ISF_ControlPanel_fnGetAttributesOf(IShellFolder2 * iface, UINT cidl, LPCITEMIDLIST * apidl, DWORD * rgfInOut)
{
ICPanelImpl *This = (ICPanelImpl *)iface;
HRESULT hr = S_OK;
TRACE("(%p)->(cidl=%d apidl=%p mask=%p (0x%08lx))\n",
This, cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
if (!rgfInOut)
return E_INVALIDARG;
if (cidl && !apidl)
return E_INVALIDARG;
if (*rgfInOut == 0)
*rgfInOut = ~0;
while(cidl > 0 && *apidl) {
pdump(*apidl);
SHELL32_GetItemAttributes(_IShellFolder_(This), *apidl, rgfInOut);
apidl++;
cidl--;
}
/* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
*rgfInOut &= ~SFGAO_VALIDATE;
TRACE("-- result=0x%08lx\n", *rgfInOut);
return hr;
}
static BOOL BrsFolder_OnCommand( browse_info *info, UINT id )
{
LPBROWSEINFOW lpBrowseInfo = info->lpBrowseInfo;
switch (id)
{
case IDOK:
if (info->pidlRet == NULL) /* A null pidl would mean a cancel */
info->pidlRet = _ILCreateDesktop();
pdump( info->pidlRet );
if (lpBrowseInfo->pszDisplayName)
SHGetPathFromIDListW( info->pidlRet, lpBrowseInfo->pszDisplayName );
EndDialog( info->hWnd, 1 );
return TRUE;
case IDCANCEL:
EndDialog( info->hWnd, 0 );
return TRUE;
case IDD_MAKENEWFOLDER:
BrsFolder_NewFolder(info);
return TRUE;
}
return FALSE;
}
static BOOL BrsFolder_OnCommand( browse_info *info, UINT id )
{
LPBROWSEINFOW lpBrowseInfo = info->lpBrowseInfo;
switch (id)
{
case IDOK:
#ifdef __REACTOS__
/* The original pidl is owned by the treeview and will be free'd. */
info->pidlRet = ILClone(info->pidlRet);
#endif
if (info->pidlRet == NULL) /* A null pidl would mean a cancel */
info->pidlRet = _ILCreateDesktop();
pdump( info->pidlRet );
if (lpBrowseInfo->pszDisplayName)
SHGetPathFromIDListW( info->pidlRet, lpBrowseInfo->pszDisplayName );
EndDialog( info->hWnd, 1 );
return TRUE;
case IDCANCEL:
EndDialog( info->hWnd, 0 );
return TRUE;
case IDC_BROWSE_FOR_FOLDER_NEW_FOLDER:
BrsFolder_NewFolder(info);
return TRUE;
}
return FALSE;
}
static BOOL BrsFolder_OnCommand( browse_info *info, UINT id )
{
LPBROWSEINFOW lpBrowseInfo = info->lpBrowseInfo;
switch (id)
{
case IDOK:
/* The original pidl is owned by the treeview and will be free'd. */
info->pidlRet = ILClone(info->pidlRet);
if (info->pidlRet == NULL) /* A null pidl would mean a cancel */
info->pidlRet = _ILCreateDesktop();
pdump( info->pidlRet );
if (lpBrowseInfo->pszDisplayName)
SHGetPathFromIDListW( info->pidlRet, lpBrowseInfo->pszDisplayName );
EndDialog( info->hWnd, 1 );
return TRUE;
case IDCANCEL:
EndDialog( info->hWnd, 0 );
return TRUE;
case IDD_MAKENEWFOLDER:
FIXME("make new folder not implemented\n");
return TRUE;
}
return FALSE;
}
/**************************************************************************
* CDesktopFolder::GetDisplayNameOf
*
* NOTES
* special case: pidl = null gives desktop-name back
*/
HRESULT WINAPI CDesktopFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
{
TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
return E_INVALIDARG;
if (!_ILIsPidlSimple (pidl))
{
return SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, strRet);
}
else if (_ILIsDesktop(pidl))
{
if ((GET_SHGDN_RELATION(dwFlags) == SHGDN_NORMAL) && (GET_SHGDN_FOR(dwFlags) & SHGDN_FORPARSING))
return SHSetStrRet(strRet, sPathTarget);
else
return HCR_GetClassName(CLSID_ShellDesktop, strRet);
}
/* file system folder or file rooted at the desktop */
CComPtr<IShellFolder2> psf;
HRESULT hr = _GetSFFromPidl(pidl, &psf);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
return psf->GetDisplayNameOf(pidl, dwFlags, strRet);
}
/**************************************************************************
* ISF_Fonts_fnGetDisplayNameOf
*
*/
static HRESULT WINAPI ISF_Fonts_fnGetDisplayNameOf (IShellFolder2 * iface,
LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
{
IGenericSFImpl *This = (IGenericSFImpl *)iface;
PIDLFontStruct * pfont;
TRACE("ISF_Fonts_fnGetDisplayNameOf (%p)->(pidl=%p,0x%08x,%p)\n", This, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
return E_INVALIDARG;
pfont = _ILGetFontStruct(pidl);
if (!pfont)
return E_INVALIDARG;
strRet->u.pOleStr = CoTaskMemAlloc((wcslen(pfont->szName)+1) * sizeof(WCHAR));
if (!strRet->u.pOleStr)
return E_OUTOFMEMORY;
wcscpy(strRet->u.pOleStr, pfont->szName);
strRet->uType = STRRET_WSTR;
return S_OK;
}
/**************************************************************************
* CControlPanelFolder::GetAttributesOf
*/
HRESULT WINAPI CControlPanelFolder::GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD * rgfInOut)
{
HRESULT hr = S_OK;
TRACE("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n",
this, cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
if (!rgfInOut)
return E_INVALIDARG;
if (cidl && !apidl)
return E_INVALIDARG;
if (*rgfInOut == 0)
*rgfInOut = ~0;
while(cidl > 0 && *apidl)
{
pdump(*apidl);
SHELL32_GetItemAttributes(this, *apidl, rgfInOut);
apidl++;
cidl--;
}
/* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
*rgfInOut &= ~SFGAO_VALIDATE;
TRACE("-- result=0x%08x\n", *rgfInOut);
return hr;
}
HRESULT WINAPI CPrintersExtractIconW::Initialize(LPCITEMIDLIST pidl)
{
pidl = ILClone(pidl);
pdump(pidl);
return S_OK;
}
/**************************************************************************
* CNetFolder::GetDisplayNameOf
*
*/
HRESULT WINAPI CNetFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
{
FIXME("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet);
pdump(pidl);
if (!strRet)
return E_INVALIDARG;
return E_NOTIMPL;
}
/**************************************************************************
* ISF_ControlPanel_fnGetDisplayNameOf
*/
static HRESULT WINAPI ISF_ControlPanel_fnGetDisplayNameOf(IShellFolder2 * iface, LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
{
ICPanelImpl *This = (ICPanelImpl *)iface;
CHAR szPath[MAX_PATH];
WCHAR wszPath[MAX_PATH+1]; /* +1 for potential backslash */
PIDLCPanelStruct* pcpanel;
*szPath = '\0';
TRACE("(%p)->(pidl=%p,0x%08lx,%p)\n", This, pidl, dwFlags, strRet);
pdump(pidl);
if (!pidl || !strRet)
return E_INVALIDARG;
pcpanel = _ILGetCPanelPointer(pidl);
if (pcpanel) {
lstrcpyA(szPath, pcpanel->szName+pcpanel->offsDispName);
if (!(dwFlags & SHGDN_FORPARSING))
FIXME("retrieve display name from control panel app\n");
}
/* take names of special folders only if its only this folder */
else if (_ILIsSpecialFolder(pidl)) {
BOOL bSimplePidl = _ILIsPidlSimple(pidl);
if (bSimplePidl) {
_ILSimpleGetTextW(pidl, wszPath, MAX_PATH); /* append my own path */
} else {
FIXME("special pidl\n");
}
if ((dwFlags & SHGDN_FORPARSING) && !bSimplePidl) { /* go deeper if needed */
int len = 0;
PathAddBackslashW(wszPath);
len = lstrlenW(wszPath);
if (!SUCCEEDED
(SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags | SHGDN_INFOLDER, wszPath + len, MAX_PATH + 1 - len)))
return E_OUTOFMEMORY;
if (!WideCharToMultiByte(CP_ACP, 0, wszPath, -1, szPath, MAX_PATH, NULL, NULL))
wszPath[0] = '\0';
}
}
strRet->uType = STRRET_CSTR;
lstrcpynA(strRet->u.cStr, szPath, MAX_PATH);
TRACE("--(%p)->(%s)\n", This, szPath);
return S_OK;
}
void PktAnalyzer::dump_file(unsigned char *buf,uint32_t rv, int pkt_id)
{
std::string s=std::to_string(pkt_id);
Poco::FileOutputStream pdump("/tmp/packet_dump"+s,std::ios::binary);
for(uint32_t i=0; i < rv; i++)
{
pdump << (unsigned char) buf[i];
}
pdump.close();
}
/**************************************************************************
* CDesktopFolder::GetAttributesOf
*/
HRESULT WINAPI CDesktopFolder::GetAttributesOf(
UINT cidl,
PCUITEMID_CHILD_ARRAY apidl,
DWORD *rgfInOut)
{
HRESULT hr = S_OK;
TRACE("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n",
this, cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
if (cidl && !apidl)
return E_INVALIDARG;
if (*rgfInOut == 0)
*rgfInOut = ~0;
if(cidl == 0)
*rgfInOut &= dwDesktopAttributes;
else
{
/* TODO: always add SFGAO_CANLINK */
for (UINT i = 0; i < cidl; ++i)
{
pdump(*apidl);
if (_ILIsDesktop(*apidl))
*rgfInOut &= dwDesktopAttributes;
else if (_ILIsMyComputer(apidl[i]))
*rgfInOut &= dwMyComputerAttributes;
else if (_ILIsNetHood(apidl[i]))
*rgfInOut &= dwMyNetPlacesAttributes;
else if (_ILIsSpecialFolder(apidl[i]))
SHELL32_GetGuidItemAttributes(this, apidl[i], rgfInOut);
else if (_ILIsFolder(apidl[i]) || _ILIsValue(apidl[i]))
{
CComPtr<IShellFolder2> psf;
HRESULT hr = _GetSFFromPidl(apidl[i], &psf);
if (FAILED_UNEXPECTEDLY(hr))
continue;
psf->GetAttributesOf(1, &apidl[i], rgfInOut);
}
else
ERR("Got an unknown pidl type!!!\n");
}
}
/* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
*rgfInOut &= ~SFGAO_VALIDATE;
TRACE("-- result=0x%08x\n", *rgfInOut);
return hr;
}
/**************************************************************************
* ISF_NetworkPlaces_fnGetDisplayNameOf
*
*/
static HRESULT WINAPI ISF_NetworkPlaces_fnGetDisplayNameOf (IShellFolder2 * iface,
LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
{
IGenericSFImpl *This = impl_from_IShellFolder2(iface);
FIXME ("(%p)->(pidl=%p,0x%08x,%p)\n", This, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
return E_INVALIDARG;
return E_NOTIMPL;
}
/*************************************************************************
* SHMapPIDLToSystemImageListIndex [SHELL32.77]
*
* PARAMETERS
* sh [IN] pointer to an instance of IShellFolder
* pidl [IN]
* pIndex [OUT][OPTIONAL] SIC index for big icon
*
*/
int WINAPI SHMapPIDLToSystemImageListIndex(
LPSHELLFOLDER sh,
LPCITEMIDLIST pidl,
UINT * pIndex)
{
UINT Index;
TRACE("(SF=%p,pidl=%p,%p)\n",sh,pidl,pIndex);
pdump(pidl);
if (pIndex)
PidlToSicIndex ( sh, pidl, 1, 0, pIndex);
PidlToSicIndex ( sh, pidl, 0, 0, &Index);
return Index;
}
/**************************************************************************
* ISF_Printers_fnGetDisplayNameOf
*
*/
static HRESULT WINAPI ISF_Printers_fnGetDisplayNameOf (IShellFolder2 * iface,
LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
{
LPWSTR pszName;
IGenericSFImpl *This = (IGenericSFImpl *)iface;
PIDLPrinterStruct * p;
TRACE ("(%p)->(pidl=%p,0x%08lx,%p)\n", This, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
{
WARN("no strRet\n");
return E_INVALIDARG;
}
if (_ILIsPrinter(pidl))
{
pszName = CoTaskMemAlloc(MAX_PATH * sizeof(WCHAR));
if (!pszName)
return E_OUTOFMEMORY;
if (LoadStringW(shell32_hInstance, IDS_PRINTERS, pszName, MAX_PATH))
{
pszName[MAX_PATH-1] = L'\0';
strRet->uType = STRRET_WSTR;
strRet->u.pOleStr = pszName;
return S_OK;
}
CoTaskMemFree(pszName);
return E_FAIL;
}
p = _ILGetPrinterStruct(pidl);
if (!p)
{
WARN("no printer struct\n");
return E_INVALIDARG;
}
strRet->u.pOleStr = SHAlloc(p->offsServer * sizeof(WCHAR));
if (!strRet->u.pOleStr)
return E_OUTOFMEMORY;
memcpy((LPVOID)strRet->u.pOleStr, (LPVOID)p->szName, p->offsServer * sizeof(WCHAR));
TRACE("ret %s\n", debugstr_w(strRet->u.pOleStr));
return S_OK;
}
/**************************************************************************
* ISF_Desktop_fnGetAttributesOf
*/
static HRESULT WINAPI ISF_Desktop_fnGetAttributesOf (IShellFolder2 * iface,
UINT cidl, LPCITEMIDLIST * apidl, DWORD * rgfInOut)
{
IDesktopFolderImpl *This = impl_from_IShellFolder2(iface);
IShellFolder *shell_folder = (IShellFolder*)iface;
static const DWORD dwDesktopAttributes =
SFGAO_STORAGE | SFGAO_HASPROPSHEET | SFGAO_STORAGEANCESTOR |
SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_HASSUBFOLDER;
static const DWORD dwMyComputerAttributes =
SFGAO_CANRENAME | SFGAO_CANDELETE | SFGAO_HASPROPSHEET |
SFGAO_DROPTARGET | SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER;
TRACE ("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n",
This, cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
if (!rgfInOut)
return E_INVALIDARG;
if (cidl && !apidl)
return E_INVALIDARG;
if (*rgfInOut == 0)
*rgfInOut = ~0;
if(cidl == 0) {
*rgfInOut &= dwDesktopAttributes;
} else {
while (cidl > 0 && *apidl) {
pdump (*apidl);
if (_ILIsDesktop(*apidl)) {
*rgfInOut &= dwDesktopAttributes;
} else if (_ILIsMyComputer(*apidl)) {
*rgfInOut &= dwMyComputerAttributes;
} else {
SHELL32_GetItemAttributes ( shell_folder, *apidl, rgfInOut);
}
apidl++;
cidl--;
}
}
/* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
*rgfInOut &= ~SFGAO_VALIDATE;
TRACE ("-- result=0x%08x\n", *rgfInOut);
return S_OK;
}
/**************************************************************************
* IExtractIcon_Constructor
*/
static IUnknown *IEI_Printers_Constructor(LPCITEMIDLIST pidl)
{
IExtractIconWImpl* ei;
TRACE("%p\n", pidl);
ei = HeapAlloc(GetProcessHeap(),0,sizeof(IExtractIconWImpl));
ei->ref = 1;
ei->lpVtbl = &eivt;
ei->lpvtblExtractIconA = &eiavt;
ei->pidl=ILClone(pidl);
pdump(pidl);
TRACE("(%p)\n", ei);
return (IUnknown *)ei;
}
/**************************************************************************
* CPrinterFolder::GetDisplayNameOf
*
*/
HRESULT WINAPI CPrinterFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
{
LPWSTR pszName;
PIDLPrinterStruct * p;
TRACE ("(%p)->(pidl=%p,0x%08lx,%p)\n", this, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
{
WARN("no strRet\n");
return E_INVALIDARG;
}
if (!pidl->mkid.cb)
{
pszName = (LPWSTR)CoTaskMemAlloc(MAX_PATH * sizeof(WCHAR));
if (!pszName)
return E_OUTOFMEMORY;
if (LoadStringW(shell32_hInstance, IDS_PRINTERS, pszName, MAX_PATH))
{
pszName[MAX_PATH-1] = L'\0';
strRet->uType = STRRET_WSTR;
strRet->pOleStr = pszName;
return S_OK;
}
CoTaskMemFree(pszName);
return E_FAIL;
}
p = _ILGetPrinterStruct(pidl);
if (!p)
{
WARN("no printer struct\n");
return E_INVALIDARG;
}
strRet->pOleStr = (LPWSTR)SHAlloc(p->offsServer * sizeof(WCHAR));
if (!strRet->pOleStr)
return E_OUTOFMEMORY;
memcpy((LPVOID)strRet->pOleStr, (LPVOID)p->szName, p->offsServer * sizeof(WCHAR));
TRACE("ret %s\n", debugstr_w(strRet->pOleStr));
return S_OK;
}
/**************************************************************************
* ISF_NetworkPlaces_fnGetAttributesOf
*/
static HRESULT WINAPI ISF_NetworkPlaces_fnGetAttributesOf (IShellFolder2 * iface,
UINT cidl, LPCITEMIDLIST * apidl, DWORD * rgfInOut)
{
IGenericSFImpl *This = impl_from_IShellFolder2(iface);
HRESULT hr = S_OK;
TRACE ("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n", This,
cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
if (!rgfInOut)
return E_INVALIDARG;
if (cidl && !apidl)
return E_INVALIDARG;
if (*rgfInOut == 0)
*rgfInOut = ~0;
if (cidl == 0)
{
IShellFolder *psfParent = NULL;
LPCITEMIDLIST rpidl = NULL;
hr = SHBindToParent(This->pidlRoot, &IID_IShellFolder, (void**)&psfParent, &rpidl);
if(SUCCEEDED(hr))
{
SHELL32_GetItemAttributes (psfParent, rpidl, rgfInOut);
IShellFolder_Release(psfParent);
}
}
else
{
while (cidl > 0 && *apidl)
{
pdump (*apidl);
SHELL32_GetItemAttributes ((IShellFolder *)&This->IShellFolder2_iface, *apidl, rgfInOut);
apidl++;
cidl--;
}
}
/* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
*rgfInOut &= ~SFGAO_VALIDATE;
TRACE ("-- result=0x%08x\n", *rgfInOut);
return hr;
}
/**************************************************************************
* CFontsFolder::GetDisplayNameOf
*
*/
HRESULT WINAPI CFontsFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
{
PIDLFontStruct *pFont;
TRACE("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
return E_INVALIDARG;
pFont = _ILGetFontStruct(pidl);
if (pFont)
{
strRet->pOleStr = (LPWSTR)CoTaskMemAlloc((wcslen(pFont->szName) + 1) * sizeof(WCHAR));
if (!strRet->pOleStr)
return E_OUTOFMEMORY;
wcscpy(strRet->pOleStr, pFont->szName);
strRet->uType = STRRET_WSTR;
}
else if (!pidl->mkid.cb)
{
WCHAR wszPath[MAX_PATH];
if ((GET_SHGDN_RELATION (dwFlags) == SHGDN_NORMAL) &&
(GET_SHGDN_FOR (dwFlags) & SHGDN_FORPARSING))
{
if (!SHGetSpecialFolderPathW(NULL, wszPath, CSIDL_FONTS, FALSE))
return E_FAIL;
}
else if (!HCR_GetClassNameW(CLSID_FontsFolderShortcut, wszPath, MAX_PATH))
return E_FAIL;
strRet->pOleStr = (LPWSTR)CoTaskMemAlloc((wcslen(wszPath) + 1) * sizeof(WCHAR));
if (!strRet->pOleStr)
return E_OUTOFMEMORY;
wcscpy(strRet->pOleStr, wszPath);
strRet->uType = STRRET_WSTR;
}
else
return E_INVALIDARG;
return S_OK;
}
static IExtractIconWImpl *extracticon_create(LPCITEMIDLIST pidl)
{
IExtractIconWImpl *ei;
TRACE("%p\n", pidl);
ei = HeapAlloc(GetProcessHeap(), 0, sizeof(*ei));
ei->ref=1;
ei->IExtractIconW_iface.lpVtbl = &eivt;
ei->IExtractIconA_iface.lpVtbl = &eiavt;
ei->IPersistFile_iface.lpVtbl = &pfvt;
ei->pidl=ILClone(pidl);
pdump(pidl);
TRACE("(%p)\n", ei);
return ei;
}
/**************************************************************************
* IExtractIconW_Constructor
*/
IExtractIconW* IExtractIconW_Constructor(LPCITEMIDLIST pidl)
{
IExtractIconWImpl* ei;
TRACE("%p\n", pidl);
ei = HeapAlloc(GetProcessHeap(),0,sizeof(IExtractIconWImpl));
ei->ref=1;
ei->lpVtbl = &eivt;
ei->lpvtblPersistFile = &pfvt;
ei->lpvtblExtractIconA = &eiavt;
ei->pidl=ILClone(pidl);
pdump(pidl);
TRACE("(%p)\n", ei);
return (IExtractIconW *)ei;
}
/*************************************************************************
* FileMenu_InsertUsingPidl [SHELL32.110]
*
* NOTES
* uEnumFlags any SHCONTF flag
*/
int WINAPI FileMenu_InsertUsingPidl (
HMENU hmenu,
UINT uID,
LPCITEMIDLIST pidl,
UINT uFlags,
UINT uEnumFlags,
LPFNFMCALLBACK lpfnCallback)
{
TRACE("%p 0x%08x %p 0x%08x 0x%08x %p\n",
hmenu, uID, pidl, uFlags, uEnumFlags, lpfnCallback);
pdump (pidl);
bAbortInit = FALSE;
FM_SetMenuParameter(hmenu, uID, pidl, uFlags, uEnumFlags, lpfnCallback);
return FM_InitMenuPopup(hmenu, NULL);
}
/**************************************************************************
* CFontsFolder::GetAttributesOf
*/
HRESULT WINAPI CFontsFolder::GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD *rgfInOut)
{
HRESULT hr = S_OK;
TRACE ("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n", this,
cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
if (!rgfInOut)
return E_INVALIDARG;
if (cidl && !apidl)
return E_INVALIDARG;
if (*rgfInOut == 0)
*rgfInOut = ~0;
if (cidl == 0)
{
CComPtr<IShellFolder> psfParent;
LPCITEMIDLIST rpidl = NULL;
hr = SHBindToParent(pidlRoot, IID_PPV_ARG(IShellFolder, &psfParent), (LPCITEMIDLIST *)&rpidl);
if (SUCCEEDED(hr))
SHELL32_GetItemAttributes (psfParent, rpidl, rgfInOut);
}
else
{
while (cidl > 0 && *apidl)
{
pdump (*apidl);
SHELL32_GetItemAttributes (this, *apidl, rgfInOut);
apidl++;
cidl--;
}
}
/* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
*rgfInOut &= ~SFGAO_VALIDATE;
TRACE ("-- result=0x%08x\n", *rgfInOut);
return hr;
}
/**************************************************************************
* CPrinterFolder::GetDisplayNameOf
*
*/
HRESULT WINAPI CPrinterFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
{
PIDLPrinterStruct * p;
TRACE ("(%p)->(pidl=%p,0x%08lx,%p)\n", this, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
{
WARN("no strRet\n");
return E_INVALIDARG;
}
p = _ILGetPrinterStruct(pidl);
if (!p)
{
ERR("no printer struct\n");
return E_INVALIDARG;
}
return SHSetStrRet(strRet, p->szName);
}
/**************************************************************************
* ISF_AdminTools_fnGetAttributesOf
*/
HRESULT WINAPI CAdminToolsFolder::GetAttributesOf(UINT cidl, LPCITEMIDLIST *apidl, DWORD *rgfInOut)
{
HRESULT hr = S_OK;
static const DWORD dwAdminToolsAttributes =
SFGAO_STORAGE | SFGAO_HASPROPSHEET | SFGAO_STORAGEANCESTOR |
SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_FILESYSTEM;
TRACE ("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n",
this, cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
if (!rgfInOut)
return E_INVALIDARG;
if (cidl && !apidl)
return E_INVALIDARG;
if (*rgfInOut == 0)
*rgfInOut = ~0;
if(cidl == 0) {
*rgfInOut &= dwAdminToolsAttributes;
} else {
while (cidl > 0 && *apidl) {
pdump (*apidl);
if (_ILIsAdminTools(*apidl)) {
*rgfInOut &= dwAdminToolsAttributes;
} else {
SHELL32_GetItemAttributes (this, *apidl, rgfInOut);
}
apidl++;
cidl--;
}
}
/* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
*rgfInOut &= ~SFGAO_VALIDATE;
TRACE ("-- result=0x%08x\n", *rgfInOut);
return hr;
}
/*************************************************************************
* SHMapPIDLToSystemImageListIndex [SHELL32.77]
*
* PARAMETERS
* sh [IN] pointer to an instance of IShellFolder
* pidl [IN]
* pIndex [OUT][OPTIONAL] SIC index for big icon
*
*/
int WINAPI SHMapPIDLToSystemImageListIndex(
IShellFolder *sh,
LPCITEMIDLIST pidl,
int *pIndex)
{
int Index;
UINT uGilFlags = 0;
TRACE("(SF=%p,pidl=%p,%p)\n",sh,pidl,pIndex);
pdump(pidl);
if (SHELL_IsShortcut(pidl))
uGilFlags |= GIL_FORSHORTCUT;
if (pIndex)
if (!PidlToSicIndex ( sh, pidl, 1, uGilFlags, pIndex))
*pIndex = -1;
if (!PidlToSicIndex ( sh, pidl, 0, uGilFlags, &Index))
return -1;
return Index;
}
/*
* Transport for the Freecom USB/IDE adaptor.
*
*/
static int freecom_transport(struct scsi_cmnd *srb, struct us_data *us)
{
struct freecom_cb_wrap *fcb;
struct freecom_status *fst;
unsigned int ipipe, opipe; /* We need both pipes. */
int result;
unsigned int partial;
int length;
fcb = (struct freecom_cb_wrap *) us->iobuf;
fst = (struct freecom_status *) us->iobuf;
US_DEBUGP("Freecom TRANSPORT STARTED\n");
/* Get handles for both transports. */
opipe = us->send_bulk_pipe;
ipipe = us->recv_bulk_pipe;
/* The ATAPI Command always goes out first. */
fcb->Type = FCM_PACKET_ATAPI | 0x00;
fcb->Timeout = 0;
memcpy (fcb->Atapi, srb->cmnd, 12);
memset (fcb->Filler, 0, sizeof (fcb->Filler));
US_DEBUG(pdump (srb->cmnd, 12));
/* Send it out. */
result = usb_stor_bulk_transfer_buf (us, opipe, fcb,
FCM_PACKET_LENGTH, NULL);
/* The Freecom device will only fail if there is something wrong in
* USB land. It returns the status in its own registers, which
* come back in the bulk pipe. */
if (result != USB_STOR_XFER_GOOD) {
US_DEBUGP ("freecom transport error\n");
return USB_STOR_TRANSPORT_ERROR;
}
/* There are times we can optimize out this status read, but it
* doesn't hurt us to always do it now. */
result = usb_stor_bulk_transfer_buf (us, ipipe, fst,
FCM_STATUS_PACKET_LENGTH, &partial);
US_DEBUGP("foo Status result %d %u\n", result, partial);
if (result != USB_STOR_XFER_GOOD)
return USB_STOR_TRANSPORT_ERROR;
US_DEBUG(pdump ((void *) fst, partial));
/* The firmware will time-out commands after 20 seconds. Some commands
* can legitimately take longer than this, so we use a different
* command that only waits for the interrupt and then sends status,
* without having to send a new ATAPI command to the device.
*
* NOTE: There is some indication that a data transfer after a timeout
* may not work, but that is a condition that should never happen.
*/
while (fst->Status & FCM_STATUS_BUSY) {
US_DEBUGP("20 second USB/ATAPI bridge TIMEOUT occurred!\n");
US_DEBUGP("fst->Status is %x\n", fst->Status);
/* Get the status again */
fcb->Type = FCM_PACKET_STATUS;
fcb->Timeout = 0;
memset (fcb->Atapi, 0, sizeof(fcb->Atapi));
memset (fcb->Filler, 0, sizeof (fcb->Filler));
/* Send it out. */
result = usb_stor_bulk_transfer_buf (us, opipe, fcb,
FCM_PACKET_LENGTH, NULL);
/* The Freecom device will only fail if there is something
* wrong in USB land. It returns the status in its own
* registers, which come back in the bulk pipe.
*/
if (result != USB_STOR_XFER_GOOD) {
US_DEBUGP ("freecom transport error\n");
return USB_STOR_TRANSPORT_ERROR;
}
/* get the data */
result = usb_stor_bulk_transfer_buf (us, ipipe, fst,
FCM_STATUS_PACKET_LENGTH, &partial);
US_DEBUGP("bar Status result %d %u\n", result, partial);
if (result != USB_STOR_XFER_GOOD)
return USB_STOR_TRANSPORT_ERROR;
US_DEBUG(pdump ((void *) fst, partial));
}
if (partial != 4)
return USB_STOR_TRANSPORT_ERROR;
if ((fst->Status & 1) != 0) {
US_DEBUGP("operation failed\n");
return USB_STOR_TRANSPORT_FAILED;
}
/* The device might not have as much data available as we
* requested. If you ask for more than the device has, this reads
* and such will hang. */
US_DEBUGP("Device indicates that it has %d bytes available\n",
le16_to_cpu (fst->Count));
US_DEBUGP("SCSI requested %d\n", scsi_bufflen(srb));
/* Find the length we desire to read. */
switch (srb->cmnd[0]) {
case INQUIRY:
case REQUEST_SENSE: /* 16 or 18 bytes? spec says 18, lots of devices only have 16 */
case MODE_SENSE:
case MODE_SENSE_10:
length = le16_to_cpu(fst->Count);
break;
default:
length = scsi_bufflen(srb);
}
/* verify that this amount is legal */
if (length > scsi_bufflen(srb)) {
length = scsi_bufflen(srb);
US_DEBUGP("Truncating request to match buffer length: %d\n", length);
}
/* What we do now depends on what direction the data is supposed to
* move in. */
switch (us->srb->sc_data_direction) {
case DMA_FROM_DEVICE:
/* catch bogus "read 0 length" case */
if (!length)
break;
/* Make sure that the status indicates that the device
* wants data as well. */
if ((fst->Status & DRQ_STAT) == 0 || (fst->Reason & 3) != 2) {
US_DEBUGP("SCSI wants data, drive doesn't have any\n");
return USB_STOR_TRANSPORT_FAILED;
}
result = freecom_readdata (srb, us, ipipe, opipe, length);
if (result != USB_STOR_TRANSPORT_GOOD)
return result;
US_DEBUGP("FCM: Waiting for status\n");
result = usb_stor_bulk_transfer_buf (us, ipipe, fst,
FCM_PACKET_LENGTH, &partial);
US_DEBUG(pdump ((void *) fst, partial));
if (partial != 4 || result > USB_STOR_XFER_SHORT)
return USB_STOR_TRANSPORT_ERROR;
if ((fst->Status & ERR_STAT) != 0) {
US_DEBUGP("operation failed\n");
return USB_STOR_TRANSPORT_FAILED;
}
if ((fst->Reason & 3) != 3) {
US_DEBUGP("Drive seems still hungry\n");
return USB_STOR_TRANSPORT_FAILED;
}
US_DEBUGP("Transfer happy\n");
break;
case DMA_TO_DEVICE:
/* catch bogus "write 0 length" case */
if (!length)
break;
/* Make sure the status indicates that the device wants to
* send us data. */
/* !!IMPLEMENT!! */
result = freecom_writedata (srb, us, ipipe, opipe, length);
if (result != USB_STOR_TRANSPORT_GOOD)
return result;
US_DEBUGP("FCM: Waiting for status\n");
result = usb_stor_bulk_transfer_buf (us, ipipe, fst,
FCM_PACKET_LENGTH, &partial);
if (partial != 4 || result > USB_STOR_XFER_SHORT)
return USB_STOR_TRANSPORT_ERROR;
if ((fst->Status & ERR_STAT) != 0) {
US_DEBUGP("operation failed\n");
return USB_STOR_TRANSPORT_FAILED;
}
if ((fst->Reason & 3) != 3) {
US_DEBUGP("Drive seems still hungry\n");
return USB_STOR_TRANSPORT_FAILED;
}
US_DEBUGP("Transfer happy\n");
break;
case DMA_NONE:
/* Easy, do nothing. */
break;
default:
/* should never hit here -- filtered in usb.c */
US_DEBUGP ("freecom unimplemented direction: %d\n",
us->srb->sc_data_direction);
/* Return fail, SCSI seems to handle this better. */
return USB_STOR_TRANSPORT_FAILED;
break;
}
return USB_STOR_TRANSPORT_GOOD;
}
int main(int argc, char *argv[]) {
char** tokens;
int count = 1;
int addr1 = 0;
int addr2 = 0;
int num_inst = 0;
int i = 100; //for loop
int mem_dump_set = 0;
int debug_set = 0;
int num_inst_set = 0;
int pipe_dump_set = 0;
/* Error Checking */
if (argc < 2)
{
printf("Error: usage: %s [-m addr1:addr2] [-d] [-n num_instr] inputBinary\n", argv[0]);
exit(1);
}
initialize(argv[argc-1]);
//for checking parse result
//print_parse_result();
while(count != argc-1){
if(strcmp(argv[count], "-m") == 0){
tokens = str_split(argv[++count],':');
addr1 = (int)strtol(*(tokens), NULL, 16);
addr2 = (int)strtol(*(tokens+1), NULL, 16);
mem_dump_set = 1;
}
else if(strcmp(argv[count], "-d") == 0)
debug_set = 1;
else if(strcmp(argv[count], "-n") == 0){
num_inst = (int)strtol(argv[++count], NULL, 10);
num_inst_set = 1;
}
else if(strcmp(argv[count], "-p") == 0)
pipe_dump_set = 1;
else{
printf("Error: usage: %s [-nobp] [-f] [-m addr1:addr2] [-d] [-p] [-n num_instr] inputBinary\n", argv[0]);
//You must add nobp and f option yourself
exit(1);
}
count++;
}
if(num_inst_set) i = num_inst;
if(debug_set){
printf("Simulating for %d cycles...\n\n", i);
for(; i > 0; i--){
if (RUN_BIT == FALSE){
printf("Simulator halted\n\n");
break;
}
cycle();
if(pipe_dump_set) pdump();
rdump();
if(mem_dump_set) mdump(addr1, addr2);
}
}
else{
run(i);
if(pipe_dump_set) pdump();
rdump();
if(mem_dump_set) mdump(addr1, addr2);
}
return 0;
}