Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-06 11:22:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers into modules, and delete rossubsys.

Browse source
This commit is contained in:
Colin Finck 2017-10-03 07:45:34 +00:00
parent b94e2d8ca0
commit c2c66aff7d
24198 changed files with 0 additions and 37285 deletions
Download patch file Download diff file Expand all files Collapse all files

263
drivers/filesystems/udfs/Include/format_common.cpp Normal file
View file

@ -0,0 +1,263 @@
////////////////////////////////////////////////////////////////////
// Copyright (C) Alexander Telyatnikov, Ivan Keliukh, Yegor Anchishkin, SKIF Software, 1999-2013. Kiev, Ukraine
// All rights reserved
// This file was released under the GPLv2 on June 2015.
////////////////////////////////////////////////////////////////////
/// Initial drive selection from command line.
CHAR szDisc[4] = "";
BOOL bChanger = FALSE;
/// Return CD-RW device type
JS_DEVICE_TYPE
CheckCDType(
PCHAR m_szFile,
PCHAR VendorId
)
{
HANDLE hDevice;
CHAR szDeviceName[256];
CHAR ioBuf[4096];
ULONG RC;
BOOL DvdRW = false;
BOOL DvdpRW = false;
BOOL DvdRAM = false;
BOOL DvdpR = false;
BOOL DvdR = false;
bChanger = FALSE;
// Make string representing full path
sprintf(szDeviceName, "\\\\.\\%s", m_szFile);
if (szDeviceName[strlen(szDeviceName)-1] == '\\') szDeviceName[strlen(szDeviceName)-1] = '\0';
// Open device volume
hDevice = OpenOurVolume(szDeviceName);
if (hDevice == ((HANDLE)-1)) {
strcpy(VendorId,"");
return BUSY;
} else {
// Get our cdrw.sys signature
RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_SIGNATURE,hDevice,
&ioBuf,sizeof(GET_SIGNATURE_USER_OUT),
&ioBuf,sizeof(GET_SIGNATURE_USER_OUT),FALSE,NULL);
if (RC == 1) {
// Get device information
RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_DEVICE_INFO,hDevice,
&ioBuf,sizeof(GET_DEVICE_INFO_USER_OUT),
&ioBuf,sizeof(GET_DEVICE_INFO_USER_OUT),FALSE,NULL);
if (RC != 1) {
strcpy(VendorId,"Unknown Vendor");
} else {
if(((PGET_DEVICE_INFO_USER_OUT)&ioBuf)->Features & CDRW_FEATURE_CHANGER)
bChanger = TRUE;
strcpy(VendorId,(PCHAR)&(((PGET_DEVICE_INFO_USER_OUT)&ioBuf)->VendorId[0]));
if (((PGET_DEVICE_INFO_USER_OUT)&ioBuf)->Features & CDRW_FEATURE_GET_CFG) {
DvdRW = (((PGET_DEVICE_INFO_USER_OUT)&ioBuf)->Features2[0] >> PFNUM_DVDRW_RESTRICTED_OVERWRITE) & 1;
DvdRAM = (((PGET_DEVICE_INFO_USER_OUT)&ioBuf)->Features2[0] >> PFNUM_DVDRAM) & 1;
DvdpRW = (((PGET_DEVICE_INFO_USER_OUT)&ioBuf)->Features2[0] >> PFNUM_DVDpRW) & 1;
DvdR = (((PGET_DEVICE_INFO_USER_OUT)&ioBuf)->Features2[0] >> PFNUM_DVDR) & 1;
DvdpR = (((PGET_DEVICE_INFO_USER_OUT)&ioBuf)->Features2[0] >> PFNUM_DVDpR) & 1;
}
}
// Get device capabilities
RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_CAPABILITIES,hDevice,
&ioBuf,sizeof(GET_CAPABILITIES_USER_OUT),
&ioBuf,sizeof(GET_CAPABILITIES_USER_OUT),FALSE,NULL);
if(RC != 1) {
CloseHandle(hDevice);
return OTHER;
}
// Check capabilities
if(((PGET_CAPABILITIES_USER_OUT)&ioBuf)->WriteCap & (DevCap_write_cd_r | DevCap_write_cd_rw | DevCap_write_dvd_ram | DevCap_write_dvd_r) ||
DvdRW || DvdpRW || DvdRAM) {
if (DvdRAM || ((PGET_CAPABILITIES_USER_OUT)&ioBuf)->WriteCap & DevCap_write_dvd_ram) {
CloseHandle(hDevice);
return DVDRAM;
}
/* if (DvdR) {
CloseHandle(hDevice);
return DVDR;
}*/
if (DvdRW) {
CloseHandle(hDevice);
return DVDRW;
}
if (DvdpRW) {
CloseHandle(hDevice);
return DVDPRW;
}
/* if (DvdpR) {
CloseHandle(hDevice);
return DVDPR;
}*/
if (((PGET_CAPABILITIES_USER_OUT)&ioBuf)->WriteCap & DevCap_write_dvd_r) {
CloseHandle(hDevice);
return DVDR;
}
if (((PGET_CAPABILITIES_USER_OUT)&ioBuf)->WriteCap & DevCap_write_cd_rw) {
CloseHandle(hDevice);
return CDRW;
}
if (((PGET_CAPABILITIES_USER_OUT)&ioBuf)->WriteCap & DevCap_write_cd_r) {
CloseHandle(hDevice);
return CDR;
}
}
else {
CloseHandle(hDevice);
return OTHER;
}
} else {
strcpy(VendorId,"Unknown Vendor");
}
CloseHandle(hDevice);
}
return OTHER;
} // end CheckCDType()
/** Intialize asbtract device list via calls to CallBack function.
\param hDlg Not used.
\param hwndControl Passed to the CallBack function. See #PADD_DEVICE.
\param CallBack Callback function. Called on each CD device in system.
*/
void
InitDeviceList(
HWND hDlg,
HWND hwndControl,
PADD_DEVICE CallBack
)
{
char Buffer[MAX_PATH] = "";
char VendorId[25];
char seps[] = ",";
char* token;
char info[MAX_PATH];
bool add_drive = false;
JS_DEVICE_TYPE drive_type;
// Get all device letter in system
GetLogicalDriveStrings((DWORD)MAX_PATH,(LPTSTR)&Buffer);
token = (char *)&Buffer;
// Replace all zeroes with comma.
while (token != NULL) {
token = (char *)memchr(Buffer,'\0',MAX_PATH);
if (token) {
if (*(token-1) == ',') {
token = NULL;
} else {
*token=',';
}
}
}
// Parse string of drive letters separated by comma
token = strtok((char *)&Buffer,seps);
while (token != NULL) {
add_drive = false;
switch (GetDriveType(token)) {
/*
case DRIVE_FIXED:
add_drive = true;
break;
*/
case DRIVE_CDROM:
// Determine CD/DVD-ROM type (R,RW,RAM,other)
drive_type = CheckCDType(token,&VendorId[0]);
add_drive = true;
break;
}
if (add_drive) {
// Append to drive letter VendorId
strncpy(info,token,strlen(token)-1);
info[strlen(token)-1]='\0';
strcat(info," ");
strcat(info,VendorId);
BOOL bSelect = !strcmp(strupr(szDisc),strupr(token));
if (drive_type != OTHER) {
CallBack(hwndControl,token,info,MediaTypeStrings[drive_type],bSelect);
} else {
CallBack(hwndControl,token,info,"[Unsupported]",FALSE);
}
}
// Move to the next drive letter in string
token = strtok(NULL,seps);
}
} // end InitDeviceList()
HANDLE
FmtAcquireDrive_(
PCHAR _Drive,
CHAR Level
)
{
WCHAR LockName[32];
HANDLE evt;
WCHAR Drive[1];
Drive[0] = _Drive[0] & ~('a' ^ 'A');
swprintf(LockName, L"DwFmtLock_%1.1S%d", Drive, Level);
evt = CreatePublicEvent(LockName);
if(!evt) {
return NULL;
}
if(GetLastError() == ERROR_ALREADY_EXISTS) {
CloseHandle(evt);
return INVALID_HANDLE_VALUE;
}
return evt;
} // end FmtAcquireDrive_()
HANDLE
FmtAcquireDrive(
PCHAR Drive,
CHAR Level
)
{
HANDLE evt;
evt = FmtAcquireDrive_(Drive, Level);
if(!evt || evt == INVALID_HANDLE_VALUE) {
return NULL;
}
return evt;
} // end FmtAcquireDrive()
BOOLEAN
FmtIsDriveAcquired(
PCHAR Drive,
CHAR Level
)
{
HANDLE evt;
evt = FmtAcquireDrive_(Drive, Level);
if(evt == INVALID_HANDLE_VALUE) {
return TRUE;
}
if(evt) {
CloseHandle(evt);
}
return FALSE;
} // end FmtIsDriveAcquired()
VOID
FmtReleaseDrive(
HANDLE evt
)
{
if(evt) {
CloseHandle(evt);
}
} // end FmtReleaseDrive()