int main(int argc, char** argv) { unsigned int n = 0; int optc; WINE_FIXME( "this command currently just sleeps based on -n parameter\n" ); while ((optc = getopt( argc, argv, "n:w:tal:fi:v:r:s:j:k:" )) != -1) { switch(optc) { case 'n': n = atoi(optarg); if (n == 0) { printf("Bad value for option -n, valid range is from 1 to 4294967295.\n"); exit(1); } break; case '?': usage(); exit(1); default: usage(); WINE_FIXME( "this command currently only supports the -n parameter\n" ); exit(1); } } if (n != 0) Sleep((n - 1) * 1000); return 0; }
int main(int argc, char** argv) { int n = 0; int optc; WINE_FIXME( "this command currently just sleeps based on -n parameter\n" ); while ((optc = getopt( argc, argv, "n:w:tal:fi:v:r:s:j:k:" )) != -1) { switch(optc) { case 'n': n = atoi( optarg ); break; case '?': usage(); exit(1); default: usage(); WINE_FIXME( "this command currently only supports the -n parameter\n" ); exit(1); } } Sleep(n * 1000); return 0; }
static BOOL set_host_properties(const WCHAR *prop) { static const WCHAR nologoW[] = {'n','o','l','o','g','o',0}; static const WCHAR iactive[] = {'i',0}; static const WCHAR batch[] = {'b',0}; if(*prop == '/') { ++prop; if(*prop == '/') ++prop; } else ++prop; if(strcmpiW(prop, iactive) == 0) wshInteractive = VARIANT_TRUE; else if(strcmpiW(prop, batch) == 0) wshInteractive = VARIANT_FALSE; else if(strcmpiW(prop, nologoW) == 0) WINE_FIXME("ignored %s switch\n", debugstr_w(nologoW)); else { WINE_FIXME("unsupported switch %s\n", debugstr_w(prop)); return FALSE; } return TRUE; }
int wmain(int argc, WCHAR *argv[]) { int i; WINE_FIXME("stub:"); for (i = 0; i < argc; i++) WINE_FIXME(" %s", wine_dbgstr_w(argv[i])); WINE_FIXME("\n"); return 0; }
static HANDLE CALLBACK WHD_Open(LPSTR name, BYTE flags) { unsigned mode = 0; WINE_FIXME("(%s %x)\n", wine_dbgstr_a(name), flags); switch (flags) { case 0: mode = GENERIC_READ | GENERIC_WRITE; break; case 2: mode = GENERIC_READ; break; default: WINE_FIXME("Undocumented flags %x\n", flags); } return CreateFile(name, mode, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); }
int WINAPI wWinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPWSTR cmdline, int cmdshow) { static const WCHAR wscriptW[] = {'\\','w','s','c','r','i','p','t','.','e','x','e',0}; static const WCHAR parbW[] = {' ','/','B',' ',0}; WCHAR app[MAX_PATH]; WCHAR cmd[MAX_PATH]; PROCESS_INFORMATION pi; BOOL ret; DWORD exitcode; STARTUPINFOW si = { sizeof(si) }; WINE_FIXME("(%p %p %s %x) forwarding to wscript\n", hInst, hPrevInst, wine_dbgstr_w(cmdline), cmdshow); GetSystemDirectoryW(app, MAX_PATH); strcatW(app, wscriptW); strcpyW(cmd, app); strcatW(app, parbW); strcatW(app, cmdline); if (!CreateProcessW(app, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) return 1; WaitForSingleObject( pi.hProcess, INFINITE ); ret = GetExitCodeProcess(pi.hProcess, &exitcode); CloseHandle( pi.hProcess ); CloseHandle( pi.hThread ); if (ret) return exitcode; else return 1; }
static INT_PTR CDECL list_notify( FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin ) { WCHAR *nameW; switch (fdint) { case fdintCABINET_INFO: return 0; case fdintCOPY_FILE: nameW = strdupAtoW( (pfdin->attribs & _A_NAME_IS_UTF) ? CP_UTF8 : CP_ACP, pfdin->psz1 ); if (match_files( nameW )) { char *nameU = strdupWtoA( CP_UNIXCP, nameW ); if (opt_verbose) { char attrs[] = "rxash"; if (!(pfdin->attribs & _A_RDONLY)) attrs[0] = '-'; if (!(pfdin->attribs & _A_EXEC)) attrs[1] = '-'; if (!(pfdin->attribs & _A_ARCH)) attrs[2] = '-'; if (!(pfdin->attribs & _A_SYSTEM)) attrs[3] = '-'; if (!(pfdin->attribs & _A_HIDDEN)) attrs[4] = '-'; printf( " %s %9u %04u/%02u/%02u %02u:%02u:%02u ", attrs, pfdin->cb, (pfdin->date >> 9) + 1980, (pfdin->date >> 5) & 0x0f, pfdin->date & 0x1f, pfdin->time >> 11, (pfdin->time >> 5) & 0x3f, (pfdin->time & 0x1f) * 2 ); } printf( "%s\n", nameU ); cab_free( nameU ); } cab_free( nameW ); return 0; default: WINE_FIXME( "Unexpected notification type %d.\n", fdint ); return 0; } }
HRESULT __cdecl SchRpcRun(const WCHAR *path, DWORD n_args, const WCHAR **args, DWORD flags, DWORD session_id, const WCHAR *user, GUID *guid) { WINE_FIXME("%s,%u,%p,%#x,%#x,%s,%p: stub\n", wine_dbgstr_w(path), n_args, args, flags, session_id, wine_dbgstr_w(user), guid); return E_NOTIMPL; }
/****************************************************************** * WCUSER_NewBitmap * * Either the font geometry or the sb geometry has changed. we need to recreate the * bitmap geometry */ static void WCUSER_NewBitmap(struct inner_data* data, BOOL fill) { HDC hDC; HBITMAP hnew, hold; if (!data->curcfg.sb_width || !data->curcfg.sb_height || !PRIVATE(data)->hFont || !(hDC = GetDC(PRIVATE(data)->hWnd))) return; hnew = CreateCompatibleBitmap(hDC, data->curcfg.sb_width * data->curcfg.cell_width, data->curcfg.sb_height * data->curcfg.cell_height); ReleaseDC(PRIVATE(data)->hWnd, hDC); hold = SelectObject(PRIVATE(data)->hMemDC, hnew); if (PRIVATE(data)->hBitmap) { if (hold == PRIVATE(data)->hBitmap) DeleteObject(PRIVATE(data)->hBitmap); else WINE_FIXME("leak\n"); } PRIVATE(data)->hBitmap = hnew; if (fill) WCUSER_FillMemDC(data, 0, data->curcfg.sb_height - 1); }
static DWORD WINAPI service_handler( DWORD ctrl, DWORD event_type, LPVOID event_data, LPVOID context ) { SERVICE_STATUS status; status.dwServiceType = SERVICE_WIN32; status.dwControlsAccepted = SERVICE_ACCEPT_STOP; status.dwWin32ExitCode = 0; status.dwServiceSpecificExitCode = 0; status.dwCheckPoint = 0; status.dwWaitHint = 0; switch(ctrl) { case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_SHUTDOWN: WINE_TRACE( "shutting down\n" ); status.dwCurrentState = SERVICE_STOP_PENDING; status.dwControlsAccepted = 0; SetServiceStatus( service_handle, &status ); SetEvent( stop_event ); return NO_ERROR; default: WINE_FIXME( "got service ctrl %x\n", ctrl ); status.dwCurrentState = SERVICE_RUNNING; SetServiceStatus( service_handle, &status ); return NO_ERROR; } }
/*********************************************************************** * pif_cmd * * execute a pif file. */ static VOID pif_cmd( char *filename, char *cmdline) { HANDLE hFile; char progpath[MAX_PATH]; char buf[128]; char progname[64]; char title[31]; char optparams[65]; char startdir[65]; char *p; int closeonexit; int textmode; if( (hFile = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE) { WINE_ERR("open file %s failed\n", wine_dbgstr_a(filename)); return; } if( !read_pif_file( hFile, progname, title, optparams, startdir, &closeonexit, &textmode)) { WINE_ERR( "failed to read %s\n", wine_dbgstr_a(filename)); CloseHandle( hFile); sprintf( buf, "%s\nInvalid file format. Check your pif file.", filename); MessageBoxA( NULL, buf, "16 bit DOS subsystem", MB_OK|MB_ICONWARNING); SetLastError( ERROR_BAD_FORMAT); return; } CloseHandle( hFile); if( (p = strrchr( progname, '.')) && !strcasecmp( p, ".bat")) WINE_FIXME(".bat programs in pif files are not supported.\n"); /* first change dir, so the search below can start from there */ if( startdir[0] && !SetCurrentDirectoryA( startdir)) { WINE_ERR("Cannot change directory %s\n", wine_dbgstr_a( startdir)); sprintf( buf, "%s\nInvalid startup directory. Check your pif file.", filename); MessageBoxA( NULL, buf, "16 bit DOS subsystem", MB_OK|MB_ICONWARNING); } /* search for the program */ if( !SearchPathA( NULL, progname, NULL, MAX_PATH, progpath, NULL )) { sprintf( buf, "%s\nInvalid program file name. Check your pif file.", filename); MessageBoxA( NULL, buf, "16 bit DOS subsystem", MB_OK|MB_ICONERROR); SetLastError( ERROR_FILE_NOT_FOUND); return; } if( textmode) if( AllocConsole()) SetConsoleTitleA( title) ; /* if no arguments on the commandline, use them from the pif file */ if( !cmdline[0] && optparams[0]) cmdline = optparams; /* FIXME: do something with: * - close on exit * - graphic modes * - hot key's * - etc. */ start_dos_exe( progpath, cmdline ); }
HRESULT __cdecl SchRpcGetInstanceInfo(GUID guid, WCHAR **path, DWORD *task_state, WCHAR **action, WCHAR **info, DWORD *n_instances, GUID **instances, DWORD *pid) { WINE_FIXME("%s,%p,%p,%p,%p,%p,%p,%p: stub\n", wine_dbgstr_guid(&guid), path, task_state, action, info, n_instances, instances, pid); return E_NOTIMPL; }
HRESULT __cdecl SchRpcScheduledRuntimes(const WCHAR *path, SYSTEMTIME *start, SYSTEMTIME *end, DWORD flags, DWORD n_requested, DWORD *n_runtimes, SYSTEMTIME **runtimes) { WINE_FIXME("%s,%p,%p,%#x,%u,%p,%p: stub\n", wine_dbgstr_w(path), start, end, flags, n_requested, n_runtimes, runtimes); return E_NOTIMPL; }
static HRESULT WINAPI Host_GetObject(IHost *iface, BSTR Pathname, BSTR ProgID, BSTR Prefix, IDispatch **out_Dispatch) { WINE_FIXME("(%s %s %s %p)\n", wine_dbgstr_w(Pathname), wine_dbgstr_w(ProgID), wine_dbgstr_w(Prefix), out_Dispatch); return E_NOTIMPL; }
/* Load svchost group specified on the command line via the /k option */ int wmain(int argc, WCHAR *argv[]) { int option_index; WINE_TRACE("\n"); for (option_index = 1; option_index < argc; option_index++) { if (lstrcmpiW(argv[option_index], ks) == 0 || lstrcmpiW(argv[option_index], kd) == 0) { ++option_index; if (option_index >= argc) { WINE_ERR("Must specify group to initialize\n"); return 0; } if (!LoadGroup(argv[option_index])) { WINE_ERR("Failed to load requested group: %s\n", wine_dbgstr_w(argv[option_index])); return 0; } } else { WINE_FIXME("Unrecognized option: %s\n", wine_dbgstr_w(argv[option_index])); return 0; } } return 0; }
static void __cdecl output_write(UINT id, ...) { WCHAR fmt[1024]; __ms_va_list va_args; WCHAR *str; DWORD len, nOut, ret; if (Silent) return; if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, sizeof(fmt)/sizeof(fmt[0]))) { WINE_FIXME("LoadString failed with %d\n", GetLastError()); return; } __ms_va_start(va_args, id); SetLastError(NO_ERROR); len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER, fmt, 0, 0, (LPWSTR)&str, 0, &va_args); __ms_va_end(va_args); if (len == 0 && GetLastError() != NO_ERROR) { WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(fmt)); return; } ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), str, len, &nOut, NULL); /* WriteConsole fails if its output is redirected to a file. * If this occurs, we should use an OEM codepage and call WriteFile. */ if (!ret) { DWORD lenA; char *strA; lenA = WideCharToMultiByte(GetConsoleOutputCP(), 0, str, len, NULL, 0, NULL, NULL); strA = HeapAlloc(GetProcessHeap(), 0, lenA); if (strA) { WideCharToMultiByte(GetConsoleOutputCP(), 0, str, len, strA, lenA, NULL, NULL); WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), strA, lenA, &nOut, FALSE); HeapFree(GetProcessHeap(), 0, strA); } } LocalFree(str); }
/************************************************************************** * mmioInstallIOProc [MMSYSTEM.1221] */ LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC fccIOProc, LPMMIOPROC16 pIOProc, DWORD dwFlags) { struct mmio_thunk* thunk = NULL; LPMMIOPROC pIOProc32; EnterCriticalSection(&mmio_cs); switch (dwFlags & (MMIO_INSTALLPROC|MMIO_REMOVEPROC|MMIO_FINDPROC)) { case MMIO_INSTALLPROC: if (!(thunk = MMIO_AddThunk(pIOProc, NULL))) { LeaveCriticalSection(&mmio_cs); return NULL; } if (!mmioInstallIOProcA(fccIOProc, (LPMMIOPROC)thunk, dwFlags)) { thunk->pfn16 = NULL; pIOProc = NULL; } break; case MMIO_REMOVEPROC: if (MMIO_Thunks) { for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++) { if (thunk->pfn16 == pIOProc && thunk->segbuffer == 0) { if (mmioInstallIOProcA(fccIOProc, (LPMMIOPROC)thunk, dwFlags)) thunk->pfn16 = NULL; else pIOProc = NULL; break; } } } if (!thunk) pIOProc = NULL; break; case MMIO_FINDPROC: if ((pIOProc32 = mmioInstallIOProcA(fccIOProc, NULL, dwFlags)) && MMIO_Thunks) { for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++) { if ((LPMMIOPROC)thunk == pIOProc32) { pIOProc = thunk->pfn16; break; } } } break; default: WINE_FIXME("Unsupported flags %08x\n", dwFlags); pIOProc = NULL; } LeaveCriticalSection(&mmio_cs); return pIOProc; }
void ept_lookup_handle_free(handle_t h, ept_lookup_handle_t *entry_handle, error_status_t *status) { WINE_FIXME("(%p, %p, %p): stub\n", h, entry_handle, status); *status = EPT_S_CANT_PERFORM_OP; }
void ept_inq_object(handle_t h, GUID *ept_object, error_status_t *status) { WINE_FIXME("(%p, %p, %p): stub\n", h, ept_object, status); *status = EPT_S_CANT_PERFORM_OP; }
/*********************************************************************** * symbol_get_function_line_status * * Find the symbol nearest to a given address. */ enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr) { IMAGEHLP_LINE64 il; DWORD disp; ULONG64 disp64, start; DWORD_PTR lin = (DWORD_PTR)memory_to_linear_addr(addr); char buffer[sizeof(SYMBOL_INFO) + 256]; SYMBOL_INFO* sym = (SYMBOL_INFO*)buffer; struct dbg_type func; il.SizeOfStruct = sizeof(il); sym->SizeOfStruct = sizeof(SYMBOL_INFO); sym->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO); /* do we have some info for lin address ? */ if (!SymFromAddr(dbg_curr_process->handle, lin, &disp64, sym)) { ADDRESS64 jumpee; /* some compilers insert thunks in their code without debug info associated * take care of this situation */ if (be_cpu->is_jump((void*)lin, &jumpee)) return symbol_get_function_line_status(&jumpee); return dbg_no_line_info; } switch (sym->Tag) { case SymTagThunk: /* FIXME: so far dbghelp doesn't return the 16 <=> 32 thunks * and furthermore, we no longer take care of them !!! */ return dbg_in_a_thunk; case SymTagFunction: case SymTagPublicSymbol: break; default: WINE_FIXME("Unexpected sym-tag 0x%08x\n", sym->Tag); case SymTagData: return dbg_no_line_info; } /* we should have a function now */ if (!SymGetLineFromAddr64(dbg_curr_process->handle, lin, &disp, &il)) return dbg_no_line_info; func.module = sym->ModBase; func.id = sym->info; if (symbol_get_debug_start(&func, &start) && lin < start) return dbg_not_on_a_line_number; if (!sym->Size) sym->Size = 0x100000; if (il.FileName && il.FileName[0] && disp < sym->Size) return (disp == 0) ? dbg_on_a_line_number : dbg_not_on_a_line_number; return dbg_no_line_info; }
/* ========================================================================= * Load a string from the resource file, handling any error * Returns string retrieved from resource file * ========================================================================= */ static WCHAR *XCOPY_LoadMessage(UINT id) { static WCHAR msg[MAXSTRING]; const WCHAR failedMsg[] = {'F', 'a', 'i', 'l', 'e', 'd', '!', 0}; if (!LoadStringW(GetModuleHandleW(NULL), id, msg, sizeof(msg)/sizeof(WCHAR))) { WINE_FIXME("LoadString failed with %d\n", GetLastError()); lstrcpyW(msg, failedMsg); } return msg; }
void ept_mgmt_delete(handle_t h, boolean32 object_speced, uuid_p_t object, twr_p_t tower, error_status_t *status) { WINE_FIXME("(%p, %ld, %p, %p, %p): stub\n", h, object_speced, object, tower, status); *status = EPT_S_CANT_PERFORM_OP; }
static WCHAR *NETSTAT_load_message(UINT id) { static WCHAR msg[2048]; static const WCHAR failedW[] = {'F','a','i','l','e','d','!','\0'}; if (!LoadStringW(GetModuleHandleW(NULL), id, msg, sizeof(msg)/sizeof(WCHAR))) { WINE_FIXME("LoadString failed with %d\n", GetLastError()); strcpyW(msg, failedW); } return msg; }
static void scmdatabase_autostart_services(struct scmdatabase *db) { struct service_entry **services_list; unsigned int i = 0; unsigned int size = 32; struct service_entry *service; services_list = HeapAlloc(GetProcessHeap(), 0, size * sizeof(services_list[0])); if (!services_list) return; scmdatabase_lock_shared(db); LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry) { if (service->config.dwStartType == SERVICE_BOOT_START || service->config.dwStartType == SERVICE_SYSTEM_START || service->config.dwStartType == SERVICE_AUTO_START) { if (i+1 >= size) { struct service_entry **slist_new; size *= 2; slist_new = HeapReAlloc(GetProcessHeap(), 0, services_list, size * sizeof(services_list[0])); if (!slist_new) break; services_list = slist_new; } services_list[i] = service; service->ref_count++; i++; } } scmdatabase_unlock(db); size = i; for (i = 0; i < size; i++) { DWORD err; const WCHAR *argv[2]; service = services_list[i]; argv[0] = service->name; argv[1] = NULL; err = service_start(service, 1, argv); if (err != ERROR_SUCCESS) WINE_FIXME("Auto-start service %s failed to start: %d\n", wine_dbgstr_w(service->name), err); release_service(service); } HeapFree(GetProcessHeap(), 0, services_list); }
static int output_vprintf(const WCHAR* fmt, va_list va_args) { WCHAR str[8192]; int len; len = vsnprintfW(str, sizeof(str)/sizeof(*str), fmt, va_args); if (len < 0) WINE_FIXME("String too long.\n"); else output_write(str, len); return 0; }
static void run_script(const WCHAR *filename, IActiveScript *script, IActiveScriptParse *parser) { BSTR text; HRESULT hres; text = get_script_str(filename); if(!text) { WINE_FIXME("Could not get script text\n"); return; } hres = IActiveScriptParse_ParseScriptText(parser, text, NULL, NULL, NULL, 1, 1, SCRIPTTEXT_HOSTMANAGESSOURCE|SCRIPTITEM_ISVISIBLE, NULL, NULL); SysFreeString(text); if(FAILED(hres)) { WINE_FIXME("ParseScriptText failed: %08x\n", hres); return; } hres = IActiveScript_SetScriptState(script, SCRIPTSTATE_STARTED); if(FAILED(hres)) WINE_FIXME("SetScriptState failed: %08x\n", hres); }
static void __cdecl output_message(unsigned int id, ...) { WCHAR fmt[1024]; __ms_va_list va_args; if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, ARRAY_SIZE(fmt))) { WINE_FIXME("LoadString failed with %d\n", GetLastError()); return; } __ms_va_start(va_args, id); output_formatstring(fmt, va_args); __ms_va_end(va_args); }
void ept_lookup(handle_t h, unsigned32 inquiry_type, uuid_p_t object, rpc_if_id_p_t interface_id, unsigned32 vers_option, ept_lookup_handle_t *entry_handle, unsigned32 max_ents, unsigned32 *num_ents, ept_entry_t entries[], error_status_t *status) { WINE_FIXME("(%p, %p, %p): stub\n", h, entry_handle, status); *status = EPT_S_CANT_PERFORM_OP; }
static ULONG_PTR CALLBACK WHD_GetInfo(WORD what, HWND hnd) { ULONG_PTR ret = 0; WINE_TRACE("(%x %p)\n", what, hnd); switch (what) { case 0: break; case 1: /* instance */ ret = (ULONG_PTR)Globals.hInstance; break; case 3: /* current window */ ret = (ULONG_PTR)Globals.active_win->hMainWnd; break; case 2: /* main window */ case 4: /* handle to opened file */ case 5: /* foreground color */ case 6: /* background color */ case 7: /* topic number */ case 8: /* current opened file name */ WINE_FIXME("NIY %u\n", what); break; default: WINE_FIXME("Undocumented %u\n", what); break; } return ret; }
static void REGPROC_print_error(void) { WCHAR *str; DWORD error_code, len; error_code = GetLastError(); len = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, error_code, 0, (WCHAR *)&str, 0, NULL); if (len == 0 && GetLastError() != NO_ERROR) { WINE_FIXME("FormatMessage failed: le=%u, previous=%u\n", GetLastError(), error_code); exit(1); } output_writeconsole(str, len); LocalFree(str); exit(1); }