static xmlParserInputPtr external_entity_loader(const char *URL, const char *ID,
xmlParserCtxtPtr ctxt)
{
xmlParserInputPtr input;
TRACE("(%s, %s, %p)\n", wine_dbgstr_a(URL), wine_dbgstr_a(ID), ctxt);
assert(MSXML_hInstance != NULL);
assert(datatypes_rsrc != NULL);
assert(datatypes_handle != NULL);
assert(datatypes_src != NULL);
/* TODO: if the desired schema is in the cache, load it from there */
if (lstrcmpA(URL, "urn:schemas-microsoft-com:datatypes") == 0)
{
TRACE("loading built-in schema for %s\n", URL);
input = xmlNewStringInputStream(ctxt, datatypes_src);
}
else
{
input = _external_entity_loader(URL, ID, ctxt);
}
return input;
}
/* try to launch a unix app from a comma separated string of app names */
static int launch_app( WCHAR *candidates, const WCHAR *argv1 )
{
char *app, *applist, *cmdline;
const char *argv_new[3];
if (!(applist = strdup_unixcp( candidates ))) return 1;
if (!(cmdline = strdup_unixcp( argv1 )))
{
HeapFree( GetProcessHeap(), 0, applist );
return 1;
}
app = strtok( applist, "," );
while (app)
{
WINE_TRACE( "Considering: %s\n", wine_dbgstr_a(app) );
WINE_TRACE( "argv[1]: %s\n", wine_dbgstr_a(cmdline) );
argv_new[0] = app;
argv_new[1] = cmdline;
argv_new[2] = NULL;
_spawnvp( _P_OVERLAY, app, argv_new ); /* only returns on error */
app = strtok( NULL, "," ); /* grab the next app */
}
WINE_ERR( "could not find a suitable app to run\n" );
HeapFree( GetProcessHeap(), 0, applist );
HeapFree( GetProcessHeap(), 0, cmdline );
return 1;
}
/***********************************************************************
* 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 );
}
/* HAL callback for property changes */
static void hal_property_modified (LibHalContext *ctx, const char *udi,
const char *key, dbus_bool_t is_removed, dbus_bool_t is_added)
{
TRACE( "udi %s key %s %s\n", wine_dbgstr_a(udi), wine_dbgstr_a(key),
is_added ? "added" : is_removed ? "removed" : "modified" );
if (!strcmp( key, "volume.mount_point" )) hal_new_device( ctx, udi );
}
static DBusHandlerResult udisks_filter( DBusConnection *ctx, DBusMessage *msg, void *user_data )
{
char *path;
DBusError error;
p_dbus_error_init( &error );
/* udisks signals */
if (p_dbus_message_is_signal( msg, "org.freedesktop.UDisks", "DeviceAdded" ) &&
p_dbus_message_get_args( msg, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID ))
{
udisks_new_device( path );
}
else if (p_dbus_message_is_signal( msg, "org.freedesktop.UDisks", "DeviceRemoved" ) &&
p_dbus_message_get_args( msg, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID ))
{
udisks_removed_device( path );
}
else if (p_dbus_message_is_signal( msg, "org.freedesktop.UDisks", "DeviceChanged" ) &&
p_dbus_message_get_args( msg, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID ))
{
udisks_changed_device( path );
}
/* udisks2 signals */
else if (p_dbus_message_is_signal( msg, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded" ) &&
p_dbus_message_get_args( msg, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID ))
{
TRACE( "added %s\n", wine_dbgstr_a(path) );
udisks2_add_devices( path );
}
else if (p_dbus_message_is_signal( msg, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved" ) &&
p_dbus_message_get_args( msg, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID ))
{
udisks_removed_device( path );
}
else if (p_dbus_message_is_signal( msg, "org.freedesktop.DBus.Properties", "PropertiesChanged" ))
{
const char *udi = p_dbus_message_get_path( msg );
TRACE( "changed %s\n", wine_dbgstr_a(udi) );
udisks2_add_devices( udi );
}
else TRACE( "ignoring message type=%d path=%s interface=%s method=%s\n",
p_dbus_message_get_type( msg ), p_dbus_message_get_path( msg ),
p_dbus_message_get_interface( msg ), p_dbus_message_get_member( msg ) );
p_dbus_error_free( &error );
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
/* inspired by write_desktop_entry() in xdg support code */
static BOOL generate_bundle_script(const char *file, const char *path,
const char *args, const char *workdir)
{
FILE *fp;
const char *libpath;
WINE_TRACE("Creating Bundle helper script at %s\n", wine_dbgstr_a(file));
fp = fopen(file, "w");
if (fp == NULL)
return FALSE;
fprintf(fp, "#!/bin/sh\n");
fprintf(fp, "PATH=\"%s\"\nexport PATH\n", getenv("PATH"));
libpath = getenv("DYLD_FALLBACK_LIBRARY_PATH");
if (libpath)
fprintf(fp, "DYLD_FALLBACK_LIBRARY_PATH=\"%s\"\nexport DYLD_FALLBACK_LIBRARY_PATH\n", libpath);
fprintf(fp, "WINEPREFIX=\"%s\"\nexport WINEPREFIX\n\n", wine_get_config_dir());
if (workdir)
fprintf(fp, "cd \"%s\"\n", workdir);
fprintf(fp, "exec sh -c \"exec wine %s %s\"\n\n", path, args);
fprintf(fp, "#EOF\n");
fclose(fp);
chmod(file, 0755);
return TRUE;
}
/* try to launch a unix app from a comma separated string of app names */
static int launch_app( const WCHAR *candidates, const WCHAR *argv1 )
{
char *cmdline;
int i, count;
char **argv_new;
if (!(cmdline = strdup_unixcp( argv1 ))) return 1;
while (*candidates)
{
WCHAR **args = CommandLineToArgvW( candidates, &count );
if (!(argv_new = HeapAlloc( GetProcessHeap(), 0, (count + 2) * sizeof(*argv_new) ))) break;
for (i = 0; i < count; i++) argv_new[i] = strdup_unixcp( args[i] );
argv_new[count] = cmdline;
argv_new[count + 1] = NULL;
TRACE( "Trying" );
for (i = 0; i <= count; i++) TRACE( " %s", wine_dbgstr_a( argv_new[i] ));
TRACE( "\n" );
_spawnvp( _P_OVERLAY, argv_new[0], (const char **)argv_new ); /* only returns on error */
for (i = 0; i < count; i++) HeapFree( GetProcessHeap(), 0, argv_new[i] );
HeapFree( GetProcessHeap(), 0, argv_new );
candidates += strlenW( candidates ) + 1; /* grab the next app */
}
WINE_ERR( "could not find a suitable app to open %s\n", debugstr_w( argv1 ));
HeapFree( GetProcessHeap(), 0, cmdline );
return 1;
}
static cache_entry* cache_entry_from_url(char const* url)
{
cache_entry* entry = heap_alloc(sizeof(cache_entry));
xmlSchemaParserCtxtPtr spctx = xmlSchemaNewParserCtxt(url);
entry->type = SCHEMA_TYPE_XSD;
entry->ref = 0;
if (spctx)
{
if((entry->schema = xmlSchemaParse(spctx)))
{
xmldoc_init(entry->schema->doc, &CLSID_DOMDocument40);
entry->doc = entry->schema->doc;
xmldoc_add_ref(entry->doc);
}
else
{
heap_free(entry);
entry = NULL;
}
xmlSchemaFreeParserCtxt(spctx);
}
else
{
FIXME("schema for nsURI %s not found\n", wine_dbgstr_a(url));
heap_free(entry);
entry = NULL;
}
return entry;
}
static void add_dos_device( const char *udi, const char *device,
const char *mount_point, const char *type )
{
struct dos_drive *drive;
/* first check if it already exists */
LIST_FOR_EACH_ENTRY( drive, &drives_list, struct dos_drive, entry )
{
if (!strcmp( udi, drive->udi )) goto found;
}
if (!(drive = HeapAlloc( GetProcessHeap(), 0, sizeof(*drive) ))) return;
if (!(drive->udi = HeapAlloc( GetProcessHeap(), 0, strlen(udi)+1 )))
{
HeapFree( GetProcessHeap(), 0, drive );
return;
}
strcpy( drive->udi, udi );
list_add_tail( &drives_list, &drive->entry );
found:
drive->drive = add_drive( device, type );
if (drive->drive != -1)
{
HKEY hkey;
set_mount_point( drive, mount_point );
WINE_TRACE( "added device %c: udi %s for %s on %s type %s\n",
'a' + drive->drive, wine_dbgstr_a(udi), wine_dbgstr_a(device),
wine_dbgstr_a(mount_point), wine_dbgstr_a(type) );
/* hack: force the drive type in the registry */
if (!RegCreateKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Drives", &hkey ))
{
char name[3] = "a:";
name[0] += drive->drive;
if (!type || strcmp( type, "cdrom" )) type = "floppy"; /* FIXME: default to floppy */
RegSetValueExA( hkey, name, 0, REG_SZ, (const BYTE *)type, strlen(type) + 1 );
RegCloseKey( hkey );
}
send_notify( drive->drive, DBT_DEVICEARRIVAL );
}
}
HRESULT WINAPI D3D10CompileEffectFromMemory(void *data, SIZE_T data_size, const char *filename,
const D3D10_SHADER_MACRO *defines, ID3D10Include *include, UINT hlsl_flags, UINT fx_flags,
ID3D10Blob **effect, ID3D10Blob **errors)
{
TRACE("data %p, data_size %lu, filename %s, defines %p, include %p, "
"hlsl_flags %#x, fx_flags %#x, effect %p, errors %p.\n",
data, data_size, wine_dbgstr_a(filename), defines, include,
hlsl_flags, fx_flags, effect, errors);
return D3DCompile(data, data_size, filename, defines, include,
NULL, "fx_4_0", hlsl_flags, fx_flags, effect, errors);
}
static IUri *convert_file_uri(IUri *uri)
{
wine_get_unix_file_name_t wine_get_unix_file_name_ptr;
IUriBuilder *uri_builder;
struct stat dummy;
WCHAR *new_path;
char *unixpath;
BSTR filename;
IUri *new_uri;
HRESULT hres;
/* check if the argument is a local file */
wine_get_unix_file_name_ptr = (wine_get_unix_file_name_t)
GetProcAddress( GetModuleHandleA( "KERNEL32" ), "wine_get_unix_file_name" );
if(!wine_get_unix_file_name_ptr)
return NULL;
hres = IUri_GetPath(uri, &filename);
if(FAILED(hres))
return NULL;
unixpath = wine_get_unix_file_name_ptr(filename);
SysFreeString(filename);
if(unixpath && stat(unixpath, &dummy) >= 0) {
int len;
len = MultiByteToWideChar(CP_UNIXCP, 0, unixpath, -1, NULL, 0);
new_path = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
if(new_path)
MultiByteToWideChar(CP_UNIXCP, 0, unixpath, -1, new_path, len);
HeapFree(GetProcessHeap(), 0, unixpath);
}else {
WINE_WARN("File %s does not exist\n", wine_dbgstr_a(unixpath));
HeapFree(GetProcessHeap(), 0, unixpath);
new_path = NULL;
}
hres = CreateIUriBuilder(uri, 0, 0, &uri_builder);
if(SUCCEEDED(hres) && new_path)
hres = IUriBuilder_SetPath(uri_builder, new_path);
HeapFree(GetProcessHeap(), 0, new_path);
if(FAILED(hres))
return NULL;
hres = IUriBuilder_CreateUri(uri_builder, 0, 0, 0, &new_uri);
IUriBuilder_Release(uri_builder);
if(FAILED(hres))
return NULL;
return new_uri;
}
/* HAL callback for removed device */
static void hal_removed_device( LibHalContext *ctx, const char *udi )
{
DBusError error;
TRACE( "removed %s\n", wine_dbgstr_a(udi) );
if (!remove_dos_device( -1, udi ))
{
p_dbus_error_init( &error );
p_libhal_device_remove_property_watch( ctx, udi, &error );
p_dbus_error_free( &error );
}
else remove_volume( udi );
}
BOOL add_drive(char letter, const char *targetpath, const char *device, const WCHAR *label,
DWORD serial, DWORD type)
{
int driveIndex = letter_to_index(letter);
if(drives[driveIndex].in_use)
return FALSE;
WINE_TRACE("letter == '%c', unixpath == %s, device == %s, label == %s, serial == %08x, type == %d\n",
letter, wine_dbgstr_a(targetpath), wine_dbgstr_a(device),
wine_dbgstr_w(label), serial, type);
drives[driveIndex].letter = toupper(letter);
drives[driveIndex].unixpath = targetpath ? strdupA(targetpath) : NULL;
drives[driveIndex].device = device ? strdupA(device) : NULL;
drives[driveIndex].label = label ? strdupW(label) : NULL;
drives[driveIndex].serial = serial;
drives[driveIndex].type = type;
drives[driveIndex].in_use = TRUE;
drives[driveIndex].modified = TRUE;
return TRUE;
}
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);
}
static WCHAR *convert_file_uri(IUri *uri)
{
wine_get_unix_file_name_t wine_get_unix_file_name_ptr;
struct stat dummy;
WCHAR *new_path;
char *unixpath;
BSTR filename;
HRESULT hres;
/* check if the argument is a local file */
wine_get_unix_file_name_ptr = (wine_get_unix_file_name_t)
GetProcAddress( GetModuleHandleA( "KERNEL32" ), "wine_get_unix_file_name" );
if(!wine_get_unix_file_name_ptr)
return NULL;
hres = IUri_GetPath(uri, &filename);
if(FAILED(hres))
return NULL;
WINE_TRACE("Windows path: %s\n", wine_dbgstr_w(filename));
unixpath = wine_get_unix_file_name_ptr(filename);
SysFreeString(filename);
if(unixpath && stat(unixpath, &dummy) >= 0) {
WINE_TRACE("Unix path: %s\n", wine_dbgstr_a(unixpath));
new_path = encode_unix_path(unixpath);
HeapFree(GetProcessHeap(), 0, unixpath);
}else {
WINE_WARN("File %s does not exist\n", wine_dbgstr_a(unixpath));
HeapFree(GetProcessHeap(), 0, unixpath);
new_path = NULL;
}
WINE_TRACE("New path: %s\n", wine_dbgstr_w(new_path));
return new_path;
}
/*************************************************************************
* AddERExcludedApplicationA [FAULTREP.@]
*
* See AddERExcludedApplicationW
*/
BOOL WINAPI AddERExcludedApplicationA(LPCSTR lpAppFileName)
{
int len = MultiByteToWideChar(CP_ACP, 0, lpAppFileName, -1, NULL, 0);
WCHAR *wstr;
BOOL ret;
TRACE("(%s)\n", wine_dbgstr_a(lpAppFileName));
if (len == 0)
return FALSE;
wstr = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
MultiByteToWideChar(CP_ACP, 0, lpAppFileName, -1, wstr, len);
ret = AddERExcludedApplicationW(wstr);
HeapFree(GetProcessHeap(), 0, wstr);
return ret;
}
HRESULT WINAPI D3D10CompileEffectFromMemory(void *data, SIZE_T data_size, const char *filename,
const D3D10_SHADER_MACRO *defines, ID3D10Include *include, UINT hlsl_flags, UINT fx_flags,
ID3D10Blob **effect, ID3D10Blob **errors)
{
FIXME("data %p, data_size %lu, filename %s, defines %p, include %p,"
" hlsl_flags %#x, fx_flags %#x, effect %p, errors %p stub!\n",
data, data_size, wine_dbgstr_a(filename), defines, include,
hlsl_flags, fx_flags, effect, errors);
if (effect)
*effect = NULL;
if (errors)
*errors = NULL;
return E_NOTIMPL;
}
/* HAL callback for removed device */
static void removed_device( LibHalContext *ctx, const char *udi )
{
DBusError error;
struct dos_drive *drive;
WINE_TRACE( "removed %s\n", wine_dbgstr_a(udi) );
LIST_FOR_EACH_ENTRY( drive, &drives_list, struct dos_drive, entry )
{
if (strcmp( udi, drive->udi )) continue;
p_dbus_error_init( &error );
p_libhal_device_remove_property_watch( ctx, udi, &error );
remove_dos_device( drive );
p_dbus_error_free( &error );
return;
}
}
static int new_cabinet( char *cab_dir )
{
static const WCHAR plusW[] = {'+',0};
WCHAR **file;
ERF erf;
BOOL ret = FALSE;
HFCI fci;
CCAB cab;
cab.cb = opt_cabinet_size;
cab.cbFolderThresh = CB_MAX_DISK;
cab.cbReserveCFHeader = opt_reserve_space;
cab.cbReserveCFFolder = 0;
cab.cbReserveCFData = 0;
cab.iCab = 0;
cab.iDisk = 0;
cab.setID = opt_cabinet_id;
cab.szDisk[0] = 0;
strcpy( cab.szCabPath, cab_dir );
strcat( cab.szCabPath, "\\" );
format_cab_name( cab.szCab, 1, opt_cab_file );
fci = FCICreate( &erf, fci_file_placed, cab_alloc, cab_free,fci_open, fci_read,
fci_write, fci_close, fci_lseek, fci_delete, fci_get_temp, &cab, NULL );
for (file = opt_files; *file; file++)
{
if (!strcmpW( *file, plusW ))
FCIFlushFolder( fci, fci_get_next_cab, fci_status );
else
if (!(ret = add_file_or_directory( fci, *file ))) break;
}
if (ret)
{
if (!(ret = FCIFlushCabinet( fci, FALSE, fci_get_next_cab, fci_status )))
WINE_MESSAGE( "cabarc: Failed to create cabinet %s\n", wine_dbgstr_a(opt_cab_file) );
}
FCIDestroy( fci );
return !ret;
}
static BOOL get_display_device_reg_key(char *key, unsigned len)
{
static const char display_device_guid_prop[] = "__wine_display_device_guid";
static const char video_path[] = "System\\CurrentControlSet\\Control\\Video\\{";
static const char display0[] = "}\\0000";
ATOM guid_atom;
assert(len >= sizeof(video_path) + sizeof(display0) + 40);
guid_atom = HandleToULong(GetPropA(GetDesktopWindow(), display_device_guid_prop));
if (!guid_atom) return FALSE;
memcpy(key, video_path, sizeof(video_path));
if (!GlobalGetAtomNameA(guid_atom, key + strlen(key), 40))
return FALSE;
strcat(key, display0);
TRACE("display device key %s\n", wine_dbgstr_a(key));
return TRUE;
}
static HANDLE RPCSS_NPConnect(void)
{
HANDLE the_pipe;
DWORD dwmode, wait_result;
HANDLE master_mutex = RPCSS_GetMasterMutex();
WINE_TRACE("\n");
while (TRUE) {
wait_result = WaitForSingleObject(master_mutex, MASTER_MUTEX_TIMEOUT);
switch (wait_result) {
case WAIT_ABANDONED:
case WAIT_OBJECT_0:
break;
case WAIT_FAILED:
case WAIT_TIMEOUT:
default:
WINE_ERR("This should never happen: couldn't enter mutex.\n");
return NULL;
}
/* try to open the client side of the named pipe. */
the_pipe = CreateFileA(
NAME_RPCSS_NAMED_PIPE, /* pipe name */
GENERIC_READ | GENERIC_WRITE, /* r/w access */
0, /* no sharing */
NULL, /* no security attributes */
OPEN_EXISTING, /* open an existing pipe */
0, /* default attributes */
NULL /* no template file */
);
if (the_pipe != INVALID_HANDLE_VALUE)
break;
if (GetLastError() != ERROR_PIPE_BUSY) {
WINE_WARN("Unable to open named pipe %s (assuming unavailable).\n",
wine_dbgstr_a(NAME_RPCSS_NAMED_PIPE));
break;
}
WINE_WARN("Named pipe busy (will wait)\n");
if (!ReleaseMutex(master_mutex))
WINE_ERR("Failed to release master mutex. Expect deadlock.\n");
/* wait for the named pipe. We are only
willing to wait only 5 seconds. It should be available /very/ soon. */
if (! WaitNamedPipeA(NAME_RPCSS_NAMED_PIPE, MASTER_MUTEX_WAITNAMEDPIPE_TIMEOUT))
{
WINE_ERR("Named pipe unavailable after waiting. Something is probably wrong.\n");
return NULL;
}
}
if (the_pipe != INVALID_HANDLE_VALUE) {
dwmode = PIPE_READMODE_MESSAGE;
/* SetNamedPipeHandleState not implemented ATM, but still seems to work somehow. */
if (! SetNamedPipeHandleState(the_pipe, &dwmode, NULL, NULL))
WINE_WARN("Failed to set pipe handle state\n");
}
if (!ReleaseMutex(master_mutex))
WINE_ERR("Uh oh, failed to leave the RPC Master Mutex!\n");
return the_pipe;
}
HRESULT create_selection(xmlNodePtr node, xmlChar* query, IXMLDOMNodeList **out)
{
domselection *This = heap_alloc(sizeof(domselection));
xmlXPathContextPtr ctxt = xmlXPathNewContext(node->doc);
HRESULT hr;
TRACE("(%p, %s, %p)\n", node, wine_dbgstr_a((char const*)query), out);
*out = NULL;
if (!This || !ctxt || !query)
{
xmlXPathFreeContext(ctxt);
heap_free(This);
return E_OUTOFMEMORY;
}
This->IXMLDOMSelection_iface.lpVtbl = &domselection_vtbl;
This->ref = 1;
This->resultPos = 0;
This->node = node;
This->enumvariant = NULL;
init_dispex(&This->dispex, (IUnknown*)&This->IXMLDOMSelection_iface, &domselection_dispex);
xmldoc_add_ref(This->node->doc);
ctxt->error = query_serror;
ctxt->node = node;
registerNamespaces(ctxt);
if (is_xpathmode(This->node->doc))
{
xmlXPathRegisterAllFunctions(ctxt);
This->result = xmlXPathEvalExpression(query, ctxt);
}
else
{
xmlChar* pattern_query = XSLPattern_to_XPath(ctxt, query);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"not", xmlXPathNotFunction);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"boolean", xmlXPathBooleanFunction);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"index", XSLPattern_index);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"end", XSLPattern_end);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"nodeType", XSLPattern_nodeType);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_IEq", XSLPattern_OP_IEq);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_INEq", XSLPattern_OP_INEq);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_ILt", XSLPattern_OP_ILt);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_ILEq", XSLPattern_OP_ILEq);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_IGt", XSLPattern_OP_IGt);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_IGEq", XSLPattern_OP_IGEq);
This->result = xmlXPathEvalExpression(pattern_query, ctxt);
xmlFree(pattern_query);
}
if (!This->result || This->result->type != XPATH_NODESET)
{
hr = E_FAIL;
goto cleanup;
}
*out = (IXMLDOMNodeList*)&This->IXMLDOMSelection_iface;
hr = S_OK;
TRACE("found %d matches\n", xmlXPathNodeSetGetLength(This->result->nodesetval));
cleanup:
if (This && FAILED(hr))
IXMLDOMSelection_Release( &This->IXMLDOMSelection_iface );
xmlXPathFreeContext(ctxt);
return hr;
}
HRESULT queryresult_create(xmlNodePtr node, xmlChar* szQuery, IXMLDOMNodeList **out)
{
queryresult *This = heap_alloc_zero(sizeof(queryresult));
xmlXPathContextPtr ctxt = xmlXPathNewContext(node->doc);
HRESULT hr;
TRACE("(%p, %s, %p)\n", node, wine_dbgstr_a((char const*)szQuery), out);
*out = NULL;
if (This == NULL || ctxt == NULL || szQuery == NULL)
{
hr = E_OUTOFMEMORY;
goto cleanup;
}
This->lpVtbl = &queryresult_vtbl;
This->ref = 1;
This->resultPos = 0;
This->node = node;
xmldoc_add_ref(This->node->doc);
ctxt->error = query_serror;
ctxt->node = node;
registerNamespaces(ctxt);
if (is_xpathmode(This->node->doc))
{
xmlXPathRegisterAllFunctions(ctxt);
This->result = xmlXPathEvalExpression(szQuery, ctxt);
}
else
{
xmlChar* xslpQuery = XSLPattern_to_XPath(ctxt, szQuery);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"not", xmlXPathNotFunction);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"boolean", xmlXPathBooleanFunction);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"index", XSLPattern_index);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"end", XSLPattern_end);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"nodeType", XSLPattern_nodeType);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_IEq", XSLPattern_OP_IEq);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_INEq", XSLPattern_OP_INEq);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_ILt", XSLPattern_OP_ILt);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_ILEq", XSLPattern_OP_ILEq);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_IGt", XSLPattern_OP_IGt);
xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_IGEq", XSLPattern_OP_IGEq);
This->result = xmlXPathEvalExpression(xslpQuery, ctxt);
xmlFree(xslpQuery);
}
if (!This->result || This->result->type != XPATH_NODESET)
{
hr = E_FAIL;
goto cleanup;
}
init_dispex(&This->dispex, (IUnknown*)&This->lpVtbl, &queryresult_dispex);
*out = (IXMLDOMNodeList *) &This->lpVtbl;
hr = S_OK;
TRACE("found %d matches\n", xmlXPathNodeSetGetLength(This->result->nodesetval));
cleanup:
if (This != NULL && FAILED(hr))
IXMLDOMNodeList_Release( (IXMLDOMNodeList*) &This->lpVtbl );
xmlXPathFreeContext(ctxt);
return hr;
}
/* some of this code appears to be broken by bugs in Wine: the label
* setting code has no effect, for instance */
void apply_drive_changes(void)
{
int i;
HANDLE mgr;
DWORD len;
struct mountmgr_unix_drive *ioctl;
WINE_TRACE("\n");
if ((mgr = open_mountmgr()) == INVALID_HANDLE_VALUE) return;
/* add each drive and remove as we go */
for(i = 0; i < 26; i++)
{
if (!drives[i].modified) continue;
drives[i].modified = FALSE;
len = sizeof(*ioctl);
if (drives[i].in_use)
{
if (drives[i].unixpath) len += strlen(drives[i].unixpath) + 1;
if (drives[i].device) len += strlen(drives[i].device) + 1;
}
if (!(ioctl = HeapAlloc( GetProcessHeap(), 0, len ))) continue;
ioctl->size = len;
ioctl->type = DRIVE_NO_ROOT_DIR;
ioctl->letter = 'a' + i;
ioctl->mount_point_offset = 0;
ioctl->device_offset = 0;
if (drives[i].in_use)
{
char *ptr = (char *)(ioctl + 1);
ioctl->type = drives[i].type;
if (drives[i].unixpath)
{
strcpy( ptr, drives[i].unixpath );
ioctl->mount_point_offset = ptr - (char *)ioctl;
ptr += strlen(ptr) + 1;
}
if (drives[i].device)
{
strcpy( ptr, drives[i].device );
ioctl->device_offset = ptr - (char *)ioctl;
}
}
if (DeviceIoControl( mgr, IOCTL_MOUNTMGR_DEFINE_UNIX_DRIVE, ioctl, len, NULL, 0, NULL, NULL ))
{
set_drive_label( drives[i].letter, drives[i].label );
if (drives[i].in_use) set_drive_serial( drives[i].letter, drives[i].serial );
WINE_TRACE( "set drive %c: to %s type %u\n", 'a' + i,
wine_dbgstr_a(drives[i].unixpath), drives[i].type );
}
else WINE_WARN( "failed to set drive %c: to %s type %u err %u\n", 'a' + i,
wine_dbgstr_a(drives[i].unixpath), drives[i].type, GetLastError() );
HeapFree( GetProcessHeap(), 0, ioctl );
}
CloseHandle( mgr );
}
int wmain( int argc, WCHAR *argv[] )
{
static const WCHAR noneW[] = {'n','o','n','e',0};
static const WCHAR mszipW[] = {'m','s','z','i','p',0};
WCHAR *p, *command;
char buffer[MAX_PATH];
char filename[MAX_PATH];
char *cab_file, *file_part;
int i;
while (argv[1] && argv[1][0] == '-')
{
switch (argv[1][1])
{
case 'd':
argv++; argc--;
opt_cabinet_size = atoiW( argv[1] );
if (opt_cabinet_size < 50000)
{
WINE_MESSAGE( "cabarc: Cabinet size must be at least 50000\n" );
return 1;
}
break;
case 'h':
usage();
return 0;
case 'i':
argv++; argc--;
opt_cabinet_id = atoiW( argv[1] );
break;
case 'm':
argv++; argc--;
if (!strcmpiW( argv[1], noneW )) opt_compression = tcompTYPE_NONE;
else if (!strcmpiW( argv[1], mszipW )) opt_compression = tcompTYPE_MSZIP;
else
{
WINE_MESSAGE( "cabarc: Unknown compression type '%s'\n", optarg );
return 1;
}
break;
case 'p':
opt_preserve_paths = 1;
break;
case 'r':
opt_recurse = 1;
break;
case 's':
argv++; argc--;
opt_reserve_space = atoiW( argv[1] );
break;
case 'v':
opt_verbose++;
break;
default:
usage();
return 1;
}
argv++; argc--;
}
command = argv[1];
if (argc < 3 || !command[0] || command[1])
{
usage();
return 1;
}
cab_file = strdupWtoA( CP_ACP, argv[2] );
argv += 2;
argc -= 2;
if (!GetFullPathNameA( cab_file, MAX_PATH, buffer, &file_part ) || !file_part)
{
WINE_ERR( "cannot get full name for %s\n", wine_dbgstr_a( cab_file ));
return 1;
}
strcpy(filename, file_part);
file_part[0] = 0;
/* map slash to backslash in all file arguments */
for (i = 1; i < argc; i++)
for (p = argv[i]; *p; p++)
if (*p == '/') *p = '\\';
opt_files = argv + 1;
opt_cab_file = filename;
switch (*command)
{
case 'l':
case 'L':
return list_cabinet( buffer );
case 'n':
case 'N':
return new_cabinet( buffer );
case 'x':
case 'X':
if (argc > 1) /* check for destination dir as last argument */
{
WCHAR *last = argv[argc - 1];
if (last[0] && last[strlenW(last) - 1] == '\\')
{
opt_dest_dir = last;
argv[--argc] = NULL;
}
}
WINE_TRACE("Extracting file(s) from cabinet %s\n", wine_dbgstr_a(cab_file));
return extract_cabinet( buffer );
default:
usage();
return 1;
}
}
/* UDisks callback for removed device */
static void udisks_removed_device( const char *udi )
{
TRACE( "removed %s\n", wine_dbgstr_a(udi) );
if (!remove_dos_device( -1, udi )) remove_volume( udi );
}
HRESULT dt_validate(XDR_DT dt, xmlChar const* content)
{
xmlDocPtr tmp_doc;
xmlNodePtr node;
xmlNsPtr ns;
HRESULT hr;
TRACE("(dt:%s, %s)\n", dt_to_str(dt), wine_dbgstr_a((char const*)content));
if (!datatypes_schema)
{
xmlSchemaParserCtxtPtr spctx;
assert(datatypes_src != NULL);
spctx = xmlSchemaNewMemParserCtxt((char const*)datatypes_src, datatypes_len);
datatypes_schema = Schema_parse(spctx);
xmlSchemaFreeParserCtxt(spctx);
}
switch (dt)
{
case DT_INVALID:
return E_FAIL;
case DT_BIN_BASE64:
case DT_BIN_HEX:
case DT_BOOLEAN:
case DT_CHAR:
case DT_DATE:
case DT_DATE_TZ:
case DT_DATETIME:
case DT_DATETIME_TZ:
case DT_FIXED_14_4:
case DT_FLOAT:
case DT_I1:
case DT_I2:
case DT_I4:
case DT_I8:
case DT_INT:
case DT_NMTOKEN:
case DT_NMTOKENS:
case DT_NUMBER:
case DT_R4:
case DT_R8:
case DT_STRING:
case DT_TIME:
case DT_TIME_TZ:
case DT_UI1:
case DT_UI2:
case DT_UI4:
case DT_UI8:
case DT_URI:
case DT_UUID:
if (!datatypes_schema)
{
ERR("failed to load schema for urn:schemas-microsoft-com:datatypes, "
"you're probably using an old version of libxml2: " LIBXML_DOTTED_VERSION "\n");
/* Hopefully they don't need much in the way of XDR datatypes support... */
return S_OK;
}
if (content && xmlStrlen(content))
{
tmp_doc = xmlNewDoc(NULL);
node = xmlNewChild((xmlNodePtr)tmp_doc, NULL, dt_to_str(dt), content);
ns = xmlNewNs(node, DT_nsURI, BAD_CAST "dt");
xmlSetNs(node, ns);
xmlDocSetRootElement(tmp_doc, node);
hr = Schema_validate_tree(datatypes_schema, (xmlNodePtr)tmp_doc);
xmlFreeDoc(tmp_doc);
}
else
{ /* probably the node is being created manually and has no content yet */
hr = S_OK;
}
return hr;
default:
FIXME("need to handle dt:%s\n", dt_to_str(dt));
return S_OK;
}
}
HRESULT dt_validate(XDR_DT dt, xmlChar const* content)
{
xmlDocPtr tmp_doc;
xmlNodePtr node;
xmlNsPtr ns;
HRESULT hr;
TRACE("(dt:%s, %s)\n", dt_to_str(dt), wine_dbgstr_a((char const*)content));
if (!datatypes_schema)
{
xmlSchemaParserCtxtPtr spctx;
assert(datatypes_src != NULL);
spctx = xmlSchemaNewMemParserCtxt((char const*)datatypes_src, datatypes_len);
datatypes_schema = Schema_parse(spctx);
xmlSchemaFreeParserCtxt(spctx);
}
switch (dt)
{
case DT_INVALID:
return E_FAIL;
case DT_BIN_BASE64:
case DT_BIN_HEX:
case DT_BOOLEAN:
case DT_CHAR:
case DT_DATE:
case DT_DATE_TZ:
case DT_DATETIME:
case DT_DATETIME_TZ:
case DT_FIXED_14_4:
case DT_FLOAT:
case DT_I1:
case DT_I2:
case DT_I4:
case DT_I8:
case DT_INT:
case DT_NMTOKEN:
case DT_NMTOKENS:
case DT_NUMBER:
case DT_R4:
case DT_R8:
case DT_STRING:
case DT_TIME:
case DT_TIME_TZ:
case DT_UI1:
case DT_UI2:
case DT_UI4:
case DT_UI8:
case DT_URI:
case DT_UUID:
assert(datatypes_schema != NULL);
if (content && xmlStrlen(content))
{
tmp_doc = xmlNewDoc(NULL);
node = xmlNewChild((xmlNodePtr)tmp_doc, NULL, dt_to_str(dt), content);
ns = xmlNewNs(node, DT_nsURI, BAD_CAST "dt");
xmlSetNs(node, ns);
xmlDocSetRootElement(tmp_doc, node);
hr = Schema_validate_tree(datatypes_schema, (xmlNodePtr)tmp_doc);
xmlFreeDoc(tmp_doc);
}
else
{ /* probably the node is being created manually and has no content yet */
hr = S_OK;
}
return hr;
default:
FIXME("need to handle dt:%s\n", dt_to_str(dt));
return S_OK;
}
}
/* create a new dos drive */
NTSTATUS add_dos_device( int letter, const char *udi, const char *device,
const char *mount_point, enum device_type type )
{
struct dos_drive *drive, *next;
if (letter == -1) /* auto-assign a letter */
{
letter = add_drive( device, type );
if (letter == -1) return STATUS_OBJECT_NAME_COLLISION;
}
else /* simply reset the device symlink */
{
char *path, *p;
if (!(path = get_dosdevices_path( &p ))) return STATUS_NO_MEMORY;
*p = 'a' + letter;
unlink( path );
if (device) symlink( device, path );
}
LIST_FOR_EACH_ENTRY_SAFE( drive, next, &drives_list, struct dos_drive, entry )
{
if (udi && drive->udi && !strcmp( udi, drive->udi ))
{
if (type == drive->type) goto found;
delete_disk_device( drive );
continue;
}
if (drive->drive == letter) delete_disk_device( drive );
}
if (create_disk_device( udi, type, &drive )) return STATUS_NO_MEMORY;
found:
RtlFreeHeap( GetProcessHeap(), 0, drive->unix_device );
drive->unix_device = strdupA( device );
set_drive_letter( drive, letter );
set_unix_mount_point( drive, mount_point );
if (drive->drive != -1)
{
HKEY hkey;
TRACE( "added device %c: udi %s for %s on %s type %u\n",
'a' + drive->drive, wine_dbgstr_a(udi), wine_dbgstr_a(device),
wine_dbgstr_a(mount_point), type );
/* hack: force the drive type in the registry */
if (!RegCreateKeyW( HKEY_LOCAL_MACHINE, drives_keyW, &hkey ))
{
const WCHAR *type_name = drive_types[type];
WCHAR name[3] = {'a',':',0};
name[0] += drive->drive;
if (!type_name[0] && type == DEVICE_HARDDISK) type_name = drive_types[DEVICE_FLOPPY];
if (type_name[0])
RegSetValueExW( hkey, name, 0, REG_SZ, (const BYTE *)type_name,
(strlenW(type_name) + 1) * sizeof(WCHAR) );
else
RegDeleteValueW( hkey, name );
RegCloseKey( hkey );
}
if (udi) send_notify( drive->drive, DBT_DEVICEARRIVAL );
}
return STATUS_SUCCESS;
}
/***********************************************************************
* read_pif_file
*pif386rec_tu
* Read a pif file and return the header and possibly the 286 (real mode)
* record or 386 (enhanced mode) record. Returns FALSE if the file is
* invalid otherwise TRUE.
*/
static BOOL read_pif_file( HANDLE hFile, char *progname, char *title,
char *optparams, char *startdir, int *closeonexit, int *textmode)
{
DWORD nread;
LARGE_INTEGER filesize;
recordhead_t rhead;
BOOL found386rec = FALSE;
pif386rec_t pif386rec;
pifhead_t pifheader;
if( !GetFileSizeEx( hFile, &filesize) ||
filesize.QuadPart < (sizeof(pifhead_t) + sizeof(recordhead_t))) {
WINE_ERR("Invalid pif file: size error %d\n", (int)filesize.QuadPart);
return FALSE;
}
SetFilePointer( hFile, 0, NULL, FILE_BEGIN);
if( !ReadFile( hFile, &pifheader, sizeof(pifhead_t), &nread, NULL))
return FALSE;
WINE_TRACE("header: program %s title %s startdir %s params %s\n",
wine_dbgstr_a(pifheader.program),
wine_dbgstr_an(pifheader.windowtitle, sizeof(pifheader.windowtitle)),
wine_dbgstr_a(pifheader.startdir),
wine_dbgstr_a(pifheader.optparams));
WINE_TRACE("header: memory req'd %d desr'd %d drive %d videomode %d\n",
pifheader.memmin, pifheader.memmax, pifheader.startdrive,
pifheader.videomode);
WINE_TRACE("header: flags 0x%x 0x%x 0x%x\n",
pifheader.hdrflags1, pifheader.hdrflags2, pifheader.hdrflags3);
ReadFile( hFile, &rhead, sizeof(recordhead_t), &nread, NULL);
if( strncmp( rhead.recordname, "MICROSOFT PIFEX", 15)) {
WINE_ERR("Invalid pif file: magic string not found\n");
return FALSE;
}
/* now process the following records */
while( 1) {
WORD nextrecord = rhead.posofnextrecord;
if( (nextrecord & 0x8000) ||
filesize.QuadPart <( nextrecord + sizeof(recordhead_t))) break;
if( !SetFilePointer( hFile, nextrecord, NULL, FILE_BEGIN) ||
!ReadFile( hFile, &rhead, sizeof(recordhead_t), &nread, NULL))
return FALSE;
if( !rhead.recordname[0]) continue; /* deleted record */
WINE_TRACE("reading record %s size %d next 0x%x\n",
wine_dbgstr_a(rhead.recordname), rhead.sizeofdata,
rhead.posofnextrecord );
if( !strncmp( rhead.recordname, "WINDOWS 386", 11)) {
found386rec = TRUE;
ReadFile( hFile, &pif386rec, sizeof(pif386rec_t), &nread, NULL);
WINE_TRACE("386rec: memory req'd %d des'd %d EMS req'd %d des'd %d XMS req'd %d des'd %d\n",
pif386rec.memmin, pif386rec.memmax,
pif386rec.emsmin, pif386rec.emsmax,
pif386rec.xmsmin, pif386rec.xmsmax);
WINE_TRACE("386rec: option 0x%x memory 0x%x video 0x%x\n",
pif386rec.optflags, pif386rec.memflags,
pif386rec.videoflags);
WINE_TRACE("386rec: optional parameters %s\n",
wine_dbgstr_a(pif386rec.optparams));
}
}
/* prepare the return data */
lstrcpynA( progname, pifheader.program, sizeof(pifheader.program)+1);
lstrcpynA( title, pifheader.windowtitle, sizeof(pifheader.windowtitle)+1);
if( found386rec)
lstrcpynA( optparams, pif386rec.optparams, sizeof( pif386rec.optparams)+1);
else
lstrcpynA( optparams, pifheader.optparams, sizeof(pifheader.optparams)+1);
lstrcpynA( startdir, pifheader.startdir, sizeof(pifheader.startdir)+1);
*closeonexit = pifheader.hdrflags1 & 0x10;
*textmode = found386rec ? pif386rec.videoflags & 0x0010
: pifheader.hdrflags1 & 0x0002;
return TRUE;
}
