/* change the information for an existing volume */
static NTSTATUS set_volume_info( struct volume *volume, struct dos_drive *drive, const char *device,
const char *mount_point, enum device_type type, const GUID *guid )
{
void *id = NULL;
unsigned int id_len = 0;
struct disk_device *disk_device = volume->device;
NTSTATUS status;
if (type != disk_device->type)
{
if ((status = create_disk_device( type, &disk_device ))) return status;
if (volume->mount)
{
delete_mount_point( volume->mount );
volume->mount = NULL;
}
if (drive && drive->mount)
{
delete_mount_point( drive->mount );
drive->mount = NULL;
}
delete_disk_device( volume->device );
volume->device = disk_device;
}
else
{
RtlFreeHeap( GetProcessHeap(), 0, disk_device->unix_device );
RtlFreeHeap( GetProcessHeap(), 0, disk_device->unix_mount );
}
disk_device->unix_device = strdupA( device );
disk_device->unix_mount = strdupA( mount_point );
if (guid && memcmp( &volume->guid, guid, sizeof(volume->guid) ))
{
volume->guid = *guid;
if (volume->mount)
{
delete_mount_point( volume->mount );
volume->mount = NULL;
}
}
if (!volume->mount)
volume->mount = add_volume_mount_point( disk_device->dev_obj, &disk_device->name, &volume->guid );
if (drive && !drive->mount)
drive->mount = add_dosdev_mount_point( disk_device->dev_obj, &disk_device->name, drive->drive );
if (disk_device->unix_mount)
{
id = disk_device->unix_mount;
id_len = strlen( disk_device->unix_mount ) + 1;
}
if (volume->mount) set_mount_point_id( volume->mount, id, id_len, -1 );
if (drive && drive->mount) set_mount_point_id( drive->mount, id, id_len, drive->drive );
return STATUS_SUCCESS;
}
static BOOL appbundle_init(void)
{
WCHAR shellDesktopPath[MAX_PATH];
HRESULT hr = SHGetFolderPathW(NULL, CSIDL_DESKTOP, NULL, SHGFP_TYPE_CURRENT, shellDesktopPath);
if (SUCCEEDED(hr))
mac_desktop_dir = wine_get_unix_file_name(shellDesktopPath);
if (mac_desktop_dir == NULL)
{
WINE_ERR("error looking up the desktop directory\n");
return FALSE;
}
if (getenv("WINE_APPLICATIONS_DIR"))
wine_applications_dir = strdupA(getenv("WINE_APPLICATIONS_DIR"));
else
wine_applications_dir = heap_printf("%s/Applications/Wine", getenv("HOME"));
if (!wine_applications_dir)
return FALSE;
create_directories(wine_applications_dir);
WINE_TRACE("Applications in %s\n", wine_applications_dir);
return TRUE;
}
static BOOL set_unix_mount_point( struct dos_drive *drive, const char *mount_point )
{
char *path, *p;
BOOL modified = FALSE;
if (!(path = get_dosdevices_path( &p ))) return FALSE;
p[0] = 'a' + drive->drive;
p[2] = 0;
if (mount_point && mount_point[0])
{
/* try to avoid unlinking if already set correctly */
if (!drive->unix_mount || strcmp( drive->unix_mount, mount_point ))
{
unlink( path );
symlink( mount_point, path );
modified = TRUE;
}
RtlFreeHeap( GetProcessHeap(), 0, drive->unix_mount );
drive->unix_mount = strdupA( mount_point );
if (drive->dosdev) set_mount_point_id( drive->dosdev, mount_point, strlen(mount_point) + 1 );
if (drive->volume) set_mount_point_id( drive->volume, mount_point, strlen(mount_point) + 1 );
}
else
{
if (unlink( path ) != -1) modified = TRUE;
RtlFreeHeap( GetProcessHeap(), 0, drive->unix_mount );
drive->unix_mount = NULL;
if (drive->dosdev) set_mount_point_id( drive->dosdev, NULL, 0 );
if (drive->volume) set_mount_point_id( drive->volume, NULL, 0 );
}
HeapFree( GetProcessHeap(), 0, path );
return modified;
}
BOOL copyDrive(struct drive *pSrc, struct drive *pDst)
{
if(pDst->in_use)
{
WINE_TRACE("pDst already in use\n");
return FALSE;
}
if(!pSrc->unixpath) WINE_TRACE("!pSrc->unixpath\n");
if(!pSrc->label) WINE_TRACE("!pSrc->label\n");
if(!pSrc->serial) WINE_TRACE("!pSrc->serial\n");
pDst->unixpath = strdupA(pSrc->unixpath);
pDst->label = strdupA(pSrc->label);
pDst->serial = strdupA(pSrc->serial);
pDst->type = pSrc->type;
pDst->in_use = TRUE;
return TRUE;
}
static HRESULT WINAPI InstallEngine_SetDownloadDir(IInstallEngine2 *iface, const char *download_dir)
{
InstallEngine *This = impl_from_IInstallEngine2(iface);
TRACE("(%p)->(%s)\n", This, debugstr_a(download_dir));
if (This->downloaddir)
heap_free(This->downloaddir);
This->downloaddir = strdupA(download_dir);
return This->downloaddir ? S_OK : E_OUTOFMEMORY;
}
static HRESULT WINAPI InstallEngine_SetBaseUrl(IInstallEngine2 *iface, const char *base_name)
{
InstallEngine *This = impl_from_IInstallEngine2(iface);
TRACE("(%p)->(%s)\n", This, debugstr_a(base_name));
if (This->baseurl)
heap_free(This->baseurl);
This->baseurl = strdupA(base_name);
return This->baseurl ? S_OK : E_OUTOFMEMORY;
}
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;
}
/* set the volume udi */
static void set_volume_udi( struct volume *volume, const char *udi )
{
if (udi)
{
assert( !volume->udi );
/* having a udi means the HAL side holds an extra reference */
if ((volume->udi = strdupA( udi ))) grab_volume( volume );
}
else if (volume->udi)
{
RtlFreeHeap( GetProcessHeap(), 0, volume->udi );
volume->udi = NULL;
release_volume( volume );
}
}
/* 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;
}
char *safe_strdup(const char *orig) {
char *result = strdupA(orig);
if (result == NULL)
outOfMemory();
return result;
}
