/****************************************************************** * WDML_InvokeCallback16 * * */ static HDDEDATA CALLBACK WDML_InvokeCallback16(DWORD pfn16, UINT uType, UINT uFmt, HCONV hConv, HSZ hsz1, HSZ hsz2, HDDEDATA hdata, ULONG_PTR dwData1, ULONG_PTR dwData2) { DWORD d1 = 0; HDDEDATA ret; CONVCONTEXT16 cc16; WORD args[16]; switch (uType) { case XTYP_CONNECT: case XTYP_WILDCONNECT: if (dwData1) { map3216_conv_context(&cc16, (const CONVCONTEXT*)dwData1); d1 = MapLS(&cc16); } else break; default: d1 = dwData1; break; } args[15] = HIWORD(uType); args[14] = LOWORD(uType); args[13] = HIWORD(uFmt); args[12] = LOWORD(uFmt); args[11] = HIWORD(hConv); args[10] = LOWORD(hConv); args[9] = HIWORD(hsz1); args[8] = LOWORD(hsz1); args[7] = HIWORD(hsz2); args[6] = LOWORD(hsz2); args[5] = HIWORD(hdata); args[4] = LOWORD(hdata); args[3] = HIWORD(d1); args[2] = LOWORD(d1); args[1] = HIWORD(dwData2); args[0] = LOWORD(dwData2); WOWCallback16Ex(pfn16, WCB16_PASCAL, sizeof(args), args, (DWORD *)&ret); switch (uType) { case XTYP_CONNECT: case XTYP_WILDCONNECT: if (d1 != 0) UnMapLS(d1); break; } return ret; }
/**************************************************************** * MMIO_Map32To16 [INTERNAL] */ static LRESULT MMIO_Map32To16(DWORD wMsg, LPARAM* lp1, LPARAM* lp2) { switch (wMsg) { case MMIOM_CLOSE: case MMIOM_SEEK: /* nothing to do */ break; case MMIOM_OPEN: case MMIOM_READ: case MMIOM_WRITE: case MMIOM_WRITEFLUSH: *lp1 = MapLS( (void *)*lp1 ); break; case MMIOM_RENAME: *lp1 = MapLS( (void *)*lp1 ); *lp2 = MapLS( (void *)*lp2 ); break; default: if (wMsg < MMIOM_USER) TRACE("Not a mappable message (%d)\n", wMsg); } return MMSYSERR_NOERROR; }
/* * MemAlloc16 * * Allocate some memory, and return a 16:16 pointer to that memory * * NOTE: ASSUMES WE ARE IN THE DLL CRITICAL SECTION! */ LPVOID __cdecl MemAlloc16( UINT size, LPDWORD p16 ) { LPBYTE lptr; LPSELLIST psel; DWORD diff; DEBUG_TRACK_UPDATE_SIZE( size ); lptr = HeapAlloc( hHeap, HEAP_ZERO_MEMORY, size ); DEBUG_TRACK( lptr, size ); if( lptr == NULL ) { return NULL; } /* * try to find an existing selector that maps this area */ psel = lpSelList; while( psel != NULL ) { if( psel->base <= lptr ) { diff = lptr - psel->base; if( diff+size < 0xf000 ) { *p16 = ((DWORD)psel->sel << 16l) + diff; return lptr; } } psel = psel->link; } /* * no selector found, create a new one */ psel = HeapAlloc( hHeap, HEAP_ZERO_MEMORY, sizeof( SELLIST )); if( psel == NULL ) { return NULL; } psel->sel = HIWORD( MapLS( lptr ) ); DPF( 2, "$$$$$$ New selector allocated: %04x", psel->sel ); psel->base = lptr; psel->link = lpSelList; lpSelList = psel; *p16 = ((DWORD) psel->sel) << 16l; return lptr; } /* MemAlloc16 */
/*********************************************************************** * call_WH_GETMESSAGE */ static LRESULT CALLBACK call_WH_GETMESSAGE( INT code, WPARAM wp, LPARAM lp ) { MSG *msg32 = (MSG *)lp; MSG16 msg16; LRESULT ret; map_msg_32_to_16( msg32, &msg16 ); lp = MapLS( &msg16 ); ret = call_hook_16( WH_GETMESSAGE, code, wp, lp ); UnMapLS( lp ); map_msg_16_to_32( &msg16, msg32 ); return ret; }
/* helper for SendMessage16 */ void call_WH_CALLWNDPROC_hook( HWND16 hwnd, UINT16 msg, WPARAM16 wp, LPARAM lp ) { CWPSTRUCT16 cwp; struct hook16_queue_info *info = get_hook_info( FALSE ); if (!info || !info->proc[WH_CALLWNDPROC - WH_MINHOOK]) return; cwp.hwnd = hwnd; cwp.message = msg; cwp.wParam = wp; cwp.lParam = lp; lp = MapLS( &cwp ); call_hook_16( WH_CALLWNDPROC, HC_ACTION, 1, lp ); UnMapLS( lp ); }
/*********************************************************************** * DiCreateDeviceInfo (SETUPX.303) */ RETERR16 WINAPI DiCreateDeviceInfo16(LPLPDEVICE_INFO16 lplpdi, LPCSTR lpszDescription, DWORD dnDevnode, HKEY16 hkey, LPCSTR lpszRegsubkey, LPCSTR lpszClassName, HWND16 hwndParent) { LPDEVICE_INFO16 lpdi; FIXME("(%p %s %08x %x %s %s %x): stub\n", lplpdi, debugstr_a(lpszDescription), dnDevnode, hkey, debugstr_a(lpszRegsubkey), debugstr_a(lpszClassName), hwndParent); lpdi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DEVICE_INFO16)); lpdi->cbSize = sizeof(DEVICE_INFO16); strcpy(lpdi->szClassName, lpszClassName); lpdi->hwndParent = hwndParent; *lplpdi = (LPDEVICE_INFO16)MapLS(lpdi); return OK; }
/*********************************************************************** * _ICDrawBegin [MSVIDEO.232] */ DWORD VFWAPIV ICDrawBegin16(HIC16 hic, /* [in] */ DWORD dwFlags, /* [in] flags */ HPALETTE16 hpal, /* [in] palette to draw with */ HWND16 hwnd, /* [in] window to draw to */ HDC16 hdc, /* [in] HDC to draw to */ INT16 xDst, /* [in] destination rectangle */ INT16 yDst, /* [in] */ INT16 dxDst, /* [in] */ INT16 dyDst, /* [in] */ LPBITMAPINFOHEADER lpbi, /* [in] format of frame to draw NOTE: SEGPTR */ INT16 xSrc, /* [in] source rectangle */ INT16 ySrc, /* [in] */ INT16 dxSrc, /* [in] */ INT16 dySrc, /* [in] */ DWORD dwRate, /* [in] frames/second = (dwRate/dwScale) */ DWORD dwScale) /* [in] */ { DWORD ret; ICDRAWBEGIN16 icdb; SEGPTR seg_icdb; TRACE ("(0x%08x,%d,0x%08x,0x%08x,0x%08x,%u,%u,%u,%u,%p,%u,%u,%u,%u,%d,%d)\n", (DWORD) hic, dwFlags, (DWORD) hpal, (DWORD) hwnd, (DWORD) hdc, xDst, yDst, dxDst, dyDst, lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale); icdb.dwFlags = dwFlags; icdb.hpal = hpal; icdb.hwnd = hwnd; icdb.hdc = hdc; icdb.xDst = xDst; icdb.yDst = yDst; icdb.dxDst = dxDst; icdb.dyDst = dyDst; icdb.lpbi = lpbi; /* Keep this as SEGPTR for the mapping code to deal with */ icdb.xSrc = xSrc; icdb.ySrc = ySrc; icdb.dxSrc = dxSrc; icdb.dySrc = dySrc; icdb.dwRate = dwRate; icdb.dwScale = dwScale; seg_icdb = MapLS(&icdb); ret = (DWORD) ICSendMessage16(hic, ICM_DRAW_BEGIN, seg_icdb, sizeof(ICDRAWBEGIN16)); UnMapLS(seg_icdb); return ret; }
/************************************************************************* * RunDLL_CallEntry16 * * Only exported from shell32 on Windows, probably imported * from shell through the 16/32 thunks. */ void WINAPI RunDLL_CallEntry16( DWORD proc, HWND hwnd, HINSTANCE inst, LPCSTR cmdline, INT cmdshow ) { WORD args[5]; SEGPTR cmdline_seg; TRACE( "proc %x hwnd %p inst %p cmdline %s cmdshow %d\n", proc, hwnd, inst, debugstr_a(cmdline), cmdshow ); cmdline_seg = MapLS( cmdline ); args[4] = HWND_16(hwnd); args[3] = MapHModuleLS(inst); args[2] = SELECTOROF(cmdline_seg); args[1] = OFFSETOF(cmdline_seg); args[0] = cmdshow; WOWCallback16Ex( proc, WCB16_PASCAL, sizeof(args), args, NULL ); UnMapLS( cmdline_seg ); }
/****************************************************************************** * IMalloc16_Realloc [COMPOBJ.504] */ SEGPTR CDECL IMalloc16_fnRealloc(IMalloc16* iface,SEGPTR pv,DWORD cb) { SEGPTR ret; IMalloc16Impl *This = impl_from_IMalloc16(iface); TRACE("(%p)->Realloc(%08x,%d)\n",This,pv,cb); if (!pv) ret = IMalloc16_fnAlloc(iface, cb); else if (cb) { ret = MapLS( HeapReAlloc( GetProcessHeap(), 0, MapSL(pv), cb ) ); UnMapLS(pv); } else { IMalloc16_fnFree(iface, pv); ret = 0; } return ret; }
/*********************************************************************** * call_WH_MOUSE */ static LRESULT CALLBACK call_WH_MOUSE( INT code, WPARAM wp, LPARAM lp ) { MOUSEHOOKSTRUCT *ms32 = (MOUSEHOOKSTRUCT *)lp; MOUSEHOOKSTRUCT16 ms16; LRESULT ret; ms16.pt.x = ms32->pt.x; ms16.pt.y = ms32->pt.y; ms16.hwnd = HWND_16( ms32->hwnd ); ms16.wHitTestCode = ms32->wHitTestCode; ms16.dwExtraInfo = ms32->dwExtraInfo; lp = MapLS( &ms16 ); ret = call_hook_16( WH_MOUSE, code, wp, lp ); UnMapLS( lp ); return ret; }
/* callback for WINPROC_Call32ATo16 */ static LRESULT wndproc_hook_callback16( HWND16 hwnd, UINT16 msg, WPARAM16 wp, LPARAM lp, LRESULT *result, void *arg ) { struct wndproc_hook_params *params = arg; CWPSTRUCT16 cwp; LRESULT ret; cwp.hwnd = hwnd; cwp.message = msg; cwp.wParam = wp; cwp.lParam = lp; lp = MapLS( &cwp ); ret = call_hook_16( WH_CALLWNDPROC, params->code, params->wparam, lp ); UnMapLS( lp ); *result = 0; return ret; }
/*********************************************************************** * _ICDraw [MSVIDEO.234] */ DWORD VFWAPIV ICDraw16(HIC16 hic, DWORD dwFlags, LPVOID lpFormat, /* [???] NOTE: SEGPTR */ LPVOID lpData, /* [???] NOTE: SEGPTR */ DWORD cbData, LONG lTime) { DWORD ret; ICDRAW icd; SEGPTR seg_icd; TRACE("(0x%08x,0x%08x,%p,%p,%d,%d)\n", (DWORD) hic, dwFlags, lpFormat, lpData, cbData, lTime); icd.dwFlags = dwFlags; icd.lpFormat = lpFormat; icd.lpData = lpData; icd.cbData = cbData; icd.lTime = lTime; seg_icd = MapLS(&icd); ret = ICSendMessage16(hic, ICM_DRAW, seg_icd, sizeof(ICDRAW)); UnMapLS(seg_icd); return ret; }
/**************************************************************************** * QueryPathOfRegTypeLib [TYPELIB.14] * * Get the registry key of a registered type library. * * RETURNS * Success: S_OK. path is updated with the key name * Failure: E_FAIL, if guid was not found in the registry * * NOTES * The key takes the form "Classes\Typelib\<guid>\<major>.<minor>\<lcid>\win16\" */ HRESULT WINAPI QueryPathOfRegTypeLib16( REFGUID guid, /* [in] Guid to get the key name for */ WORD wMaj, /* [in] Major version */ WORD wMin, /* [in] Minor version */ LCID lcid, /* [in] Locale Id */ SEGPTR *path) /* [out] Destination for the registry key name */ { char xguid[80]; char typelibkey[100],pathname[260]; LONG plen; char *ret; TRACE("\n"); if (HIWORD(guid)) { sprintf( typelibkey, "SOFTWARE\\Classes\\Typelib\\{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\%d.%d\\%x\\win16", guid->Data1, guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7], wMaj,wMin,lcid); } else { sprintf(xguid,"<guid 0x%08x>",(DWORD)guid); FIXME("(%s,%d,%d,0x%04x,%p),can't handle non-string guids.\n",xguid,wMaj,wMin,lcid,path); return E_FAIL; } plen = sizeof(pathname); if (RegQueryValueA(HKEY_LOCAL_MACHINE,typelibkey,pathname,&plen)) { /* try again without lang specific id */ if (SUBLANGID(lcid)) return QueryPathOfRegTypeLib16(guid,wMaj,wMin,PRIMARYLANGID(lcid),path); FIXME("key %s not found\n",typelibkey); return E_FAIL; } ret = HeapAlloc( GetProcessHeap(), 0, strlen(pathname) + 1 ); if (!ret) return E_FAIL; strcpy( ret, pathname ); *path = MapLS(ret); return S_OK; }
/*********************************************************************** * _ICDecompress [MSVIDEO.230] */ DWORD VFWAPIV ICDecompress16(HIC16 hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat, LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits) { ICDECOMPRESS icd; SEGPTR segptr; DWORD ret; TRACE("(0x%08x,%d,%p,%p,%p,%p)\n", (DWORD) hic, dwFlags, lpbiFormat, lpData, lpbi, lpBits); icd.dwFlags = dwFlags; icd.lpbiInput = lpbiFormat; icd.lpInput = lpData; icd.lpbiOutput = lpbi; icd.lpOutput = lpBits; icd.ckid = 0; segptr = MapLS(&icd); ret = ICSendMessage16(hic, ICM_DECOMPRESS, segptr, sizeof(ICDECOMPRESS)); UnMapLS(segptr); return ret; }
/****************************************************************** * MMIO_Callback3216 * * */ static LRESULT MMIO_Callback3216(SEGPTR cb16, LPMMIOINFO lpmmioinfo, UINT uMessage, LPARAM lParam1, LPARAM lParam2) { DWORD result; MMIOINFO16 mmioInfo16; SEGPTR segmmioInfo16; LPARAM lp1 = lParam1, lp2 = lParam2; WORD args[7]; if (!cb16) return MMSYSERR_INVALPARAM; memset(&mmioInfo16, 0, sizeof(MMIOINFO16)); mmioInfo16.lDiskOffset = lpmmioinfo->lDiskOffset; mmioInfo16.adwInfo[0] = lpmmioinfo->adwInfo[0]; mmioInfo16.adwInfo[1] = lpmmioinfo->adwInfo[1]; mmioInfo16.adwInfo[2] = lpmmioinfo->adwInfo[2]; /* map (lParam1, lParam2) into (lp1, lp2) 32=>16 */ if ((result = MMIO_Map32To16(uMessage, &lp1, &lp2)) != MMSYSERR_NOERROR) return result; segmmioInfo16 = MapLS(&mmioInfo16); args[6] = HIWORD(segmmioInfo16); args[5] = LOWORD(segmmioInfo16); args[4] = uMessage; args[3] = HIWORD(lp1); args[2] = LOWORD(lp1); args[1] = HIWORD(lp2); args[0] = LOWORD(lp2); WOWCallback16Ex( cb16, WCB16_PASCAL, sizeof(args), args, &result ); UnMapLS(segmmioInfo16); MMIO_UnMap32To16(uMessage, lParam1, lParam2, lp1, lp2); lpmmioinfo->lDiskOffset = mmioInfo16.lDiskOffset; lpmmioinfo->adwInfo[0] = mmioInfo16.adwInfo[0]; lpmmioinfo->adwInfo[1] = mmioInfo16.adwInfo[1]; lpmmioinfo->adwInfo[2] = mmioInfo16.adwInfo[2]; return result; }
/*********************************************************************** * _ICMessage [MSVIDEO.207] */ LRESULT VFWAPIV ICMessage16( HIC16 hic, UINT16 msg, UINT16 cb, VA_LIST16 valist ) { LPWORD lpData; SEGPTR segData; LRESULT ret; UINT16 i; lpData = HeapAlloc(GetProcessHeap(), 0, cb); TRACE("0x%08x, %u, %u, ...)\n", (DWORD) hic, msg, cb); for (i = 0; i < cb / sizeof(WORD); i++) { lpData[i] = VA_ARG16(valist, WORD); } segData = MapLS(lpData); ret = ICSendMessage16(hic, msg, segData, (DWORD) cb); UnMapLS(segData); HeapFree(GetProcessHeap(), 0, lpData); return ret; }
/************************************************************************* * RunDLL_CallEntry16 [SHELL32.122] * the name is probably wrong */ EXTERN_C void WINAPI RunDLL_CallEntry16( DWORD proc, HWND hwnd, HINSTANCE inst, LPCSTR cmdline, INT cmdshow ) { #if !defined(__CYGWIN__) && !defined (__MINGW32__) && !defined(_MSC_VER) WORD args[5]; SEGPTR cmdline_seg; TRACE( "proc %x hwnd %p inst %p cmdline %s cmdshow %d\n", proc, hwnd, inst, debugstr_a(cmdline), cmdshow ); cmdline_seg = MapLS( cmdline ); args[4] = HWND_16(hwnd); args[3] = MapHModuleLS(inst); args[2] = SELECTOROF(cmdline_seg); args[1] = OFFSETOF(cmdline_seg); args[0] = cmdshow; WOWCallback16Ex( proc, WCB16_PASCAL, sizeof(args), args, NULL ); UnMapLS( cmdline_seg ); #else FIXME( "proc %lx hwnd %p inst %p cmdline %s cmdshow %d\n", proc, hwnd, inst, debugstr_a(cmdline), cmdshow ); #endif }
/****************************************************************************** * IMalloc16_Alloc [COMPOBJ.503] */ SEGPTR CDECL IMalloc16_fnAlloc(IMalloc16* iface,DWORD cb) { IMalloc16Impl *This = impl_from_IMalloc16(iface); TRACE("(%p)->Alloc(%d)\n",This,cb); return MapLS( HeapAlloc( GetProcessHeap(), 0, cb ) ); }
/*********************************************************************** * call_WH_CBT */ static LRESULT CALLBACK call_WH_CBT( INT code, WPARAM wp, LPARAM lp ) { LRESULT ret = 0; switch (code) { case HCBT_CREATEWND: { CBT_CREATEWNDA *cbtcw32 = (CBT_CREATEWNDA *)lp; CBT_CREATEWND16 cbtcw16; CREATESTRUCT16 cs16; cs16.lpCreateParams = (SEGPTR)cbtcw32->lpcs->lpCreateParams; cs16.hInstance = HINSTANCE_16(cbtcw32->lpcs->hInstance); cs16.hMenu = HMENU_16(cbtcw32->lpcs->hMenu); cs16.hwndParent = HWND_16(cbtcw32->lpcs->hwndParent); cs16.cy = cbtcw32->lpcs->cy; cs16.cx = cbtcw32->lpcs->cx; cs16.y = cbtcw32->lpcs->y; cs16.x = cbtcw32->lpcs->x; cs16.style = cbtcw32->lpcs->style; cs16.lpszName = MapLS( cbtcw32->lpcs->lpszName ); cs16.lpszClass = MapLS( cbtcw32->lpcs->lpszClass ); cs16.dwExStyle = cbtcw32->lpcs->dwExStyle; cbtcw16.lpcs = (CREATESTRUCT16 *)MapLS( &cs16 ); cbtcw16.hwndInsertAfter = HWND_16( cbtcw32->hwndInsertAfter ); lp = MapLS( &cbtcw16 ); ret = call_hook_16( WH_CBT, code, wp, lp ); UnMapLS( cs16.lpszName ); UnMapLS( cs16.lpszClass ); cbtcw32->hwndInsertAfter = WIN_Handle32( cbtcw16.hwndInsertAfter ); UnMapLS( (SEGPTR)cbtcw16.lpcs ); UnMapLS( lp ); break; } case HCBT_ACTIVATE: { CBTACTIVATESTRUCT *cas32 = (CBTACTIVATESTRUCT *)lp; CBTACTIVATESTRUCT16 cas16; cas16.fMouse = cas32->fMouse; cas16.hWndActive = HWND_16( cas32->hWndActive ); lp = MapLS( &cas16 ); ret = call_hook_16( WH_CBT, code, wp, lp ); UnMapLS( lp ); break; } case HCBT_CLICKSKIPPED: { MOUSEHOOKSTRUCT *ms32 = (MOUSEHOOKSTRUCT *)lp; MOUSEHOOKSTRUCT16 ms16; ms16.pt.x = ms32->pt.x; ms16.pt.y = ms32->pt.y; ms16.hwnd = HWND_16( ms32->hwnd ); ms16.wHitTestCode = ms32->wHitTestCode; ms16.dwExtraInfo = ms32->dwExtraInfo; lp = MapLS( &ms16 ); ret = call_hook_16( WH_CBT, code, wp, lp ); UnMapLS( lp ); break; } case HCBT_MOVESIZE: { RECT *rect32 = (RECT *)lp; RECT16 rect16; rect16.left = rect32->left; rect16.top = rect32->top; rect16.right = rect32->right; rect16.bottom = rect32->bottom; lp = MapLS( &rect16 ); ret = call_hook_16( WH_CBT, code, wp, lp ); UnMapLS( lp ); break; } } return ret; }
/****************************************************************************** * BSTR_AllocBytes [Internal] */ static BSTR16 BSTR_AllocBytes(int n) { void *ptr = HeapAlloc( GetProcessHeap(), 0, n ); return (BSTR16)MapLS(ptr); }
/***************************************************************** * DdeAccessData (DDEML.17) */ LPBYTE WINAPI DdeAccessData16(HDDEDATA hData, LPDWORD pcbDataSize) { FIXME("expect trouble\n"); /* FIXME: there's a memory leak here... */ return (LPBYTE)MapLS(DdeAccessData(hData, pcbDataSize)); }
static WORD ASPI_ExecScsiCmd(DWORD ptrPRB, UINT16 mode) { SRB_ExecSCSICmd16 *lpPRB = PTR_TO_LIN( ptrPRB, mode ); struct sg_header *sg_hd, *sg_reply_hdr; int status; BYTE *lpBuf = 0; int in_len, out_len; int error_code = 0; int fd; ASPI_DebugPrintCmd(lpPRB, mode); fd = ASPI_OpenDevice16(lpPRB); if (fd == -1) { WARN("Failed: could not open device. Device permissions !?\n"); lpPRB->SRB_Status = SS_ERR; return SS_ERR; } sg_hd = NULL; sg_reply_hdr = NULL; lpPRB->SRB_Status = SS_PENDING; lpBuf = PTR_TO_LIN( lpPRB->SRB_BufPointer, mode ); if (!lpPRB->SRB_CDBLen) { WARN("Failed: lpPRB->SRB_CDBLen = 0.\n"); lpPRB->SRB_Status = SS_ERR; return SS_ERR; } /* build up sg_header + scsi cmd */ if (HOST_TO_TARGET(lpPRB)) { /* send header, command, and then data */ in_len = SCSI_OFF + lpPRB->SRB_CDBLen + lpPRB->SRB_BufLen; sg_hd = (struct sg_header *) malloc(in_len); memset(sg_hd, 0, SCSI_OFF); memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen); if (lpPRB->SRB_BufLen) { memcpy(((BYTE *) sg_hd) + SCSI_OFF + lpPRB->SRB_CDBLen, lpBuf, lpPRB->SRB_BufLen); } } else { /* send header and command - no data */ in_len = SCSI_OFF + lpPRB->SRB_CDBLen; sg_hd = (struct sg_header *) malloc(in_len); memset(sg_hd, 0, SCSI_OFF); memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen); } if (TARGET_TO_HOST(lpPRB)) { out_len = SCSI_OFF + lpPRB->SRB_BufLen; sg_reply_hdr = (struct sg_header *) malloc(out_len); memset(sg_reply_hdr, 0, SCSI_OFF); sg_hd->reply_len = out_len; } else { out_len = SCSI_OFF; sg_reply_hdr = (struct sg_header *) malloc(out_len); memset(sg_reply_hdr, 0, SCSI_OFF); sg_hd->reply_len = out_len; } status = write(fd, sg_hd, in_len); if (status < 0 || status != in_len) { int save_error = errno; WARN("Not enough bytes written to scsi device bytes=%d .. %d\n", in_len, status); if (status < 0) { if (save_error == ENOMEM) { MESSAGE("ASPI: Linux generic scsi driver\n You probably need to re-compile your kernel with a larger SG_BIG_BUFF value (sg.h)\n Suggest 130560\n"); } WARN("error:= '%s'\n", strerror(save_error)); } goto error_exit; } status = read(fd, sg_reply_hdr, out_len); if (status < 0 || status != out_len) { WARN("not enough bytes read from scsi device%d\n", status); goto error_exit; } if (sg_reply_hdr->result != 0) { error_code = sg_reply_hdr->result; WARN("reply header error (%d)\n", sg_reply_hdr->result); goto error_exit; } if (TARGET_TO_HOST(lpPRB) && lpPRB->SRB_BufLen) { memcpy(lpBuf, sg_reply_hdr + 1, lpPRB->SRB_BufLen); } /* copy in sense buffer to amount that is available in client */ if (lpPRB->SRB_SenseLen) { int sense_len = lpPRB->SRB_SenseLen; if (lpPRB->SRB_SenseLen > 16) sense_len = 16; memcpy(SENSE_BUFFER(lpPRB), &sg_reply_hdr->sense_buffer[0], sense_len); } lpPRB->SRB_Status = SS_COMP; lpPRB->SRB_HaStat = HASTAT_OK; lpPRB->SRB_TargStat = STATUS_GOOD; /* now do posting */ if (ASPI_POSTING(lpPRB) && lpPRB->SRB_PostProc) { TRACE("Post Routine (%x) called\n", (DWORD) lpPRB->SRB_PostProc); switch (mode) { case ASPI_DOS: { SEGPTR spPRB = MapLS(lpPRB); WOWCallback16((DWORD)lpPRB->SRB_PostProc, spPRB); UnMapLS(spPRB); break; } case ASPI_WIN16: WOWCallback16((DWORD)lpPRB->SRB_PostProc, ptrPRB); break; } } free(sg_reply_hdr); free(sg_hd); ASPI_DebugPrintResult(lpPRB, mode); return SS_COMP; error_exit: if (error_code == EBUSY) { lpPRB->SRB_Status = SS_ASPI_IS_BUSY; TRACE("Device busy\n"); } else { WARN("Failed\n"); lpPRB->SRB_Status = SS_ERR; } /* I'm not sure exactly error codes work here * We probably should set lpPRB->SRB_TargStat, SRB_HaStat ? */ WARN("error_exit\n"); free(sg_reply_hdr); free(sg_hd); return lpPRB->SRB_Status; }
/**************************************************************************** * UTRegister (KERNEL32.@) */ BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL, LPSTR lpszInitName, LPSTR lpszProcName, FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack, LPVOID lpBuff ) { UTINFO *ut; HMODULE16 hModule16; FARPROC16 target16, init16; static BOOL done; if (!done) { LoadLibrary16( "gdi.exe" ); LoadLibrary16( "user.exe" ); done = TRUE; } /* Load 16-bit DLL and get UTProc16 entry point */ if ( (hModule16 = LoadLibrary16( lpsz16BITDLL )) <= 32 || (target16 = GetProcAddress16( hModule16, lpszProcName )) == 0 ) return FALSE; /* Allocate UTINFO struct */ RtlAcquirePebLock(); if ( (ut = UTFind( hModule )) != NULL ) ut = NULL; else ut = UTAlloc( hModule, hModule16, target16, pfnUT32CallBack ); RtlReleasePebLock(); if ( !ut ) { FreeLibrary16( hModule16 ); return FALSE; } /* Call UTInit16 if present */ if ( lpszInitName && (init16 = GetProcAddress16( hModule16, lpszInitName )) != 0 ) { SEGPTR callback = MapLS( &ut->ut16 ); SEGPTR segBuff = MapLS( lpBuff ); WORD args[4]; DWORD ret; args[3] = SELECTOROF(callback); args[2] = OFFSETOF(callback); args[1] = SELECTOROF(segBuff); args[0] = OFFSETOF(segBuff); WOWCallback16Ex( (DWORD)init16, WCB16_PASCAL, sizeof(args), args, &ret ); UnMapLS( segBuff ); UnMapLS( callback ); if (!ret) { UTUnRegister( hModule ); return FALSE; } } /* Return 32-bit thunk */ *ppfn32Thunk = (FARPROC) &ut->ut32; return TRUE; }
/*********************************************************************** * main */ int main( int argc, char *argv[] ) { DWORD count; HINSTANCE16 instance; LOADPARAMS16 params; WORD showCmd[2]; char buffer[MAX_PATH]; STARTUPINFOA info; char *cmdline, *appname, **first_arg; char *p; if (!argv[1]) usage(); if (!strcmp( argv[1], "--app-name" )) { if (!(appname = argv[2])) usage(); first_arg = argv + 3; } else { if (!SearchPathA( NULL, argv[1], ".exe", sizeof(buffer), buffer, NULL )) { WINE_MESSAGE( "winevdm: unable to exec '%s': file not found\n", argv[1] ); ExitProcess(1); } appname = buffer; first_arg = argv + 1; } if (*first_arg) first_arg++; /* skip program name */ cmdline = build_command_line( first_arg ); if (WINE_TRACE_ON(winevdm)) { int i; WINE_TRACE( "GetCommandLine = '%s'\n", GetCommandLineA() ); WINE_TRACE( "appname = '%s'\n", appname ); WINE_TRACE( "cmdline = '%.*s'\n", cmdline[0], cmdline+1 ); for (i = 0; argv[i]; i++) WINE_TRACE( "argv[%d]: '%s'\n", i, argv[i] ); } GetStartupInfoA( &info ); showCmd[0] = 2; showCmd[1] = (info.dwFlags & STARTF_USESHOWWINDOW) ? info.wShowWindow : SW_SHOWNORMAL; params.hEnvironment = 0; params.cmdLine = MapLS( cmdline ); params.showCmd = MapLS( showCmd ); params.reserved = 0; RestoreThunkLock(1); /* grab the Win16 lock */ /* some programs assume mmsystem is always present */ LoadLibrary16( "gdi.exe" ); LoadLibrary16( "user.exe" ); LoadLibrary16( "mmsystem.dll" ); if ((instance = LoadModule16( appname, ¶ms )) < 32) { if (instance == 11) { /* first see if it is a .pif file */ if( ( p = strrchr( appname, '.' )) && !strcasecmp( p, ".pif")) pif_cmd( appname, cmdline + 1); else { /* try DOS format */ /* loader expects arguments to be regular C strings */ start_dos_exe( appname, cmdline + 1 ); } /* if we get back here it failed */ instance = GetLastError(); } WINE_MESSAGE( "winevdm: can't exec '%s': ", appname ); switch (instance) { case 2: WINE_MESSAGE("file not found\n" ); break; case 11: WINE_MESSAGE("invalid program file\n" ); break; default: WINE_MESSAGE("error=%d\n", instance ); break; } ExitProcess(instance); } /* wait forever; the process will be killed when the last task exits */ ReleaseThunkLock( &count ); Sleep( INFINITE ); return 0; }