int SDL_SYS_CDInit(void)
{
static char *checklist[] = {
#if defined(__OPENBSD__)
"?0 cd?c", "cdrom", NULL
#elif defined(__NETBSD__)
"?0 cd?d", "?0 cd?c", "cdrom", NULL
#else
"?0 cd?c", "?0 acd?c", "cdrom", NULL
#endif
};
char *SDLcdrom;
int i, j, exists;
char drive[32];
struct stat stbuf;
/* Fill in our driver capabilities */
SDL_CDcaps.Name = SDL_SYS_CDName;
SDL_CDcaps.Open = SDL_SYS_CDOpen;
SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
SDL_CDcaps.Status = SDL_SYS_CDStatus;
SDL_CDcaps.Play = SDL_SYS_CDPlay;
SDL_CDcaps.Pause = SDL_SYS_CDPause;
SDL_CDcaps.Resume = SDL_SYS_CDResume;
SDL_CDcaps.Stop = SDL_SYS_CDStop;
SDL_CDcaps.Eject = SDL_SYS_CDEject;
SDL_CDcaps.Close = SDL_SYS_CDClose;
/* Look in the environment for our CD-ROM drive list */
SDLcdrom = SDL_getenv("SDL_CDROM"); /* ':' separated list of devices */
if ( SDLcdrom != NULL ) {
char *cdpath, *delim;
size_t len = SDL_strlen(SDLcdrom)+1;
cdpath = SDL_stack_alloc(char, len);
if ( cdpath != NULL ) {
SDL_strlcpy(cdpath, SDLcdrom, len);
SDLcdrom = cdpath;
do {
delim = SDL_strchr(SDLcdrom, ':');
if ( delim ) {
*delim++ = '\0';
}
if ( CheckDrive(SDLcdrom, &stbuf) > 0 ) {
AddDrive(SDLcdrom, &stbuf);
}
if ( delim ) {
SDLcdrom = delim;
} else {
SDLcdrom = NULL;
}
} while ( SDLcdrom );
SDL_stack_free(cdpath);
}
/* If we found our drives, there's nothing left to do */
if ( SDL_numcds > 0 ) {
return(0);
}
}
int SDL_SYS_CDInit(void)
{
struct {
char *dir;
char *name;
} checklist[] = {
{"/dev/rdisk", "cdrom"},
{"/dev", "rrz"},
{NULL, NULL}};
char drive[32];
char *SDLcdrom;
int i, j, exists;
struct stat stbuf;
SDL_CDcaps.Name = SDL_SYS_CDName;
SDL_CDcaps.Open = SDL_SYS_CDOpen;
SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
SDL_CDcaps.Status = SDL_SYS_CDStatus;
SDL_CDcaps.Play = SDL_SYS_CDPlay;
SDL_CDcaps.Pause = SDL_SYS_CDPause;
SDL_CDcaps.Resume = SDL_SYS_CDResume;
SDL_CDcaps.Stop = SDL_SYS_CDStop;
SDL_CDcaps.Eject = SDL_SYS_CDEject;
SDL_CDcaps.Close = SDL_SYS_CDClose;
SDLcdrom = SDL_getenv("SDL_CDROM");
if ( SDLcdrom != NULL ) {
char *cdpath, *delim;
size_t len = SDL_strlen(SDLcdrom)+1;
cdpath = SDL_stack_alloc(char, len);
if ( cdpath != NULL ) {
SDL_strlcpy(cdpath, SDLcdrom, len);
SDLcdrom = cdpath;
do {
delim = SDL_strchr(SDLcdrom, ':');
if ( delim ) {
*delim++ = '\0';
}
if ( CheckDrive(SDLcdrom, &stbuf) > 0 ) {
AddDrive(SDLcdrom, &stbuf);
}
if ( delim ) {
SDLcdrom = delim;
} else {
SDLcdrom = NULL;
}
} while ( SDLcdrom );
SDL_stack_free(cdpath);
}
if ( SDL_numcds > 0 ) {
return(0);
}
}
int SDL_SYS_CDInit(void)
{
char *SDLcdrom;
struct stat stbuf;
/* Fill in our driver capabilities */
SDL_CDcaps.Name = SDL_SYS_CDName;
SDL_CDcaps.Open = SDL_SYS_CDOpen;
SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
SDL_CDcaps.Status = SDL_SYS_CDStatus;
SDL_CDcaps.Play = SDL_SYS_CDPlay;
SDL_CDcaps.Pause = SDL_SYS_CDPause;
SDL_CDcaps.Resume = SDL_SYS_CDResume;
SDL_CDcaps.Stop = SDL_SYS_CDStop;
SDL_CDcaps.Eject = SDL_SYS_CDEject;
SDL_CDcaps.Close = SDL_SYS_CDClose;
/* Look in the environment for our CD-ROM drive list */
SDLcdrom = getenv("SDL_CDROM"); /* ':' separated list of devices */
if ( SDLcdrom != NULL ) {
char *cdpath, *delim;
cdpath = malloc(strlen(SDLcdrom)+1);
if ( cdpath != NULL ) {
strcpy(cdpath, SDLcdrom);
SDLcdrom = cdpath;
do {
delim = strchr(SDLcdrom, ':');
if ( delim ) {
*delim++ = '\0';
}
#ifdef DEBUG_CDROM
fprintf(stderr, "Checking CD-ROM drive from SDL_CDROM: %s\n", SDLcdrom);
#endif
if ( CheckDrive(SDLcdrom, &stbuf) > 0 ) {
AddDrive(SDLcdrom, &stbuf);
}
if ( delim ) {
SDLcdrom = delim;
} else {
SDLcdrom = NULL;
}
} while ( SDLcdrom );
free(cdpath);
}
/* If we found our drives, there's nothing left to do */
if ( SDL_numcds > 0 ) {
return(0);
}
}
CheckMounts();
CheckNonmounts();
return 0;
}
static void CheckMounts(const char *mtab)
{
FILE *mntfp;
struct mntent *mntent;
struct stat stbuf;
mntfp = setmntent(mtab, "r");
if ( mntfp != NULL ) {
char *tmp, mnt_type[32], mnt_dev[1024];
while ( (mntent=getmntent(mntfp)) != NULL ) {
/* Warning, possible buffer overflow.. */
strcpy(mnt_type, mntent->mnt_type);
strcpy(mnt_dev, mntent->mnt_fsname);
/* Handle "supermount" filesystem mounts */
if ( strcmp(mnt_type, MNTTYPE_SUPER) == 0 ) {
tmp = strstr(mntent->mnt_opts, "fs=");
if ( tmp ) {
strcpy(mnt_type, tmp+strlen("fs="));
tmp = strchr(mnt_type, ',');
if ( tmp ) {
*tmp = '\0';
}
}
tmp = strstr(mntent->mnt_opts, "dev=");
if ( tmp ) {
strcpy(mnt_dev, tmp+strlen("dev="));
tmp = strchr(mnt_dev, ',');
if ( tmp ) {
*tmp = '\0';
}
}
}
if ( strcmp(mnt_type, MNTTYPE_CDROM) == 0 ) {
#ifdef DEBUG_CDROM
fprintf(stderr, "Checking mount path from %s: %s mounted on %s of %s\n",
mtab, mnt_dev, mntent->mnt_dir, mnt_type);
#endif
if (CheckDrive(mnt_dev, mnt_type, &stbuf) > 0) {
AddDrive(mnt_dev, &stbuf);
}
}
}
endmntent(mntfp);
}
}
void SetWin32Handler(HINSTANCE hInstance)
{
static bool called = false;
if (called)
return;
called = true;
s_win32Displayer.SetInstance(hInstance);
InfoProviders::Win32ThreadIdInfoProvider::SetMainThreadId(GetCurrentThreadId());
AddInfoProvider(&s_lastErrorInfoProvider);
AddHook(&s_lastErrorHook);
AddInfoProvider(&s_threadIdInfoProvider);
AddInfoProvider(&s_timeInfoProvider);
AddInfoProvider(&s_processIdInfoProvider);
AddInfoProvider(&s_OSVersionInfoProvider);
AddInfoProvider(&s_processorInfoProvider);
AddInfoProvider(&s_currentDirectoryInfoProvider);
AddInfoProvider(&s_userNameInfoProvider);
AddInfoProvider(&s_computerNameInfoProvider);
AddInfoProvider(&s_totalMemoryInfoProvider);
AddInfoProvider(&s_freeMemoryInfoProvider);
// Add a Win32DiskInfoProvider and Win32FreeDiskSpaceInfoProvider
// for every drive.
for (char drive='a'; drive<='z'; ++drive)
{
if (UseDrive(drive))
CheckDrive(drive);
}
// this loop supposes that the number of elements in
// s_diskInfoProviders and s_freeDiskSpaceInfoProviders
// are the same - adjust if this would no longer be the case!
for (size_t idx=0; idx<s_diskInfoProviders.size(); ++idx)
{
AddInfoProvider(&s_diskInfoProviders[idx]);
AddInfoProvider(&s_freeDiskSpaceInfoProviders[idx]);
}
// add logger after infoproviders, so the information in them
// is logged to it
AddLogger(&s_win32Trace);
}
static void SetDynamic( gui_window *gui, vhandle var_handle, bool *drive_checked )
/*******************************************************************************/
{
char buff[256];
const char *p;
p = VarGetStrVal( var_handle );
if( !*drive_checked ) {
while( *p ) {
if( *p == '%' ) {
if( strnicmp( p, "%DriveFree", 10 ) == 0 ) {
CheckDrive( FALSE );
*drive_checked = TRUE;
}
}
++p;
}
}
ReplaceVars( buff, VarGetStrVal( var_handle ) );
AddInstallName( buff, FALSE );
GUISetText( gui, VarGetId( var_handle ), buff );
}
void MainScreen(char *InstallName) {
char fromdrive[2], todrive[3], tmp1[3], topath[9], tmp[9], drive[2];
EditClass EditToDrive(WINDOW_LEFT+26,WINDOW_TOP+3,1, DEF_DRIVE);
EditClass EditPath(WINDOW_LEFT+32,WINDOW_TOP+4,8, DEF_DIRECTORY);
char ok;
sprintf(fromdrive, "%c", getdisk()+'A');
strcpy(todrive, "C");
strcpy(tmp, "\\EDIR");
_setcursortype(_NORMALCURSOR);
putxy(WINDOW_LEFT+3,WINDOW_TOP+2,0,STANDARD,"Installing from drive %c:", fromdrive[0]);
putxy(WINDOW_LEFT+3,WINDOW_TOP+3,0,STANDARD,"Install to what drive? :");
putxy(WINDOW_LEFT+3,WINDOW_TOP+4,0,STANDARD,"Install to what directory? :", topath);
EditToDrive.Display();
EditPath.Display();
putxy(WINDOW_LEFT+30, WINDOW_TOP+4, 0, STANDARD, "%c", toupper(todrive[0]));
strcpy(todrive, EditToDrive.GetInput());
putxy(WINDOW_LEFT+30, WINDOW_TOP+4, 0, STANDARD, "%c", toupper(todrive[0]));
strcpy(tmp, EditPath.GetInput());
descr(NULL);
sprintf(topath, "%c:%s", todrive[0], tmp);
putxy(WINDOW_LEFT+3,WINDOW_TOP+5,0,STANDARD,"Is this ok (Y/N/Q)? ");
ok = (int) tolower((char) getch());
if(ok == 121) {
if(CheckDrive(todrive[0], "Invalid disk drive to copy files to") == 1) {
_setcursortype(_NOCURSOR);
putxy(WINDOW_LEFT+3,WINDOW_TOP+5,0,STANDARD,"Please wait...installing files...");
sprintf(tmp1, "%c:", fromdrive[0]);
docopy(tmp1, topath, InstallName);
getch();
}
else MainScreen(InstallName);
}
else if(ok == 113);
else {
putxy(WINDOW_LEFT+3,WINDOW_TOP+5,0,STANDARD,"%s", space(20));
MainScreen(InstallName);
}
}
extern bool DoMainLoop( dlg_state * state )
/*****************************************/
{
const char *diag_list[MAX_DIAGS + 1];
const char *diags;
const char *dstdir;
int dstlen;
bool got_disk_sizes = FALSE;
int i;
char newdst[_MAX_PATH];
char *next;
bool ret = FALSE;
SetupTitle();
// display initial dialog
diags = GetVariableStrVal( "DialogOrder" );
if( stricmp( diags, "" ) == 0 ) {
diags = "Welcome";
}
i = 0;
for( ;; ) {
diag_list[i] = diags;
next = strchr( diags, ',' );
if( next == NULL ) break;
*next = '\0';
diags = next + 1;
++i;
}
diag_list[i + 1] = NULL;
/* process installation dialogs */
i = 0;
for( ;; ) {
if( i < 0 ) break;
if( diag_list[i] == NULL ) {
if( GetVariableIntVal( "DoCopyFiles" ) == 1 ) {
if( !CheckDrive( TRUE ) ) {
i = 0;
}
}
if( GetVariableByName( "SetupPath" ) != NO_VAR ) {
ret = TRUE;
break;
}
if( diag_list[i] == NULL ) {
StatusShow( TRUE );
ret = SetupOperations();
StatusShow( FALSE );
if( ret ) DoDialog( "Finished" );
break;
}
}
if( stricmp( diag_list[i], "GetDiskSizesHere" ) == 0 ) {
if( *state == DLG_NEXT ) {
dstdir = GetVariableStrVal( "DstDir" );
dstlen = strlen( dstdir );
if( dstlen != 0 &&
(dstdir[dstlen - 1] == '\\' || dstdir[dstlen - 1] == '/') ) {
strcpy( newdst, dstdir );
if( dstlen == 3 && dstdir[1] == ':' ) {
newdst[dstlen] = '.';
newdst[dstlen + 1] = '\0';
} else {
newdst[dstlen - 1] = '\0';
}
SetVariableByName( "DstDir", newdst );
}
SimSetNeedGetDiskSizes();
ResetDiskInfo();
got_disk_sizes = TRUE;
}
} else {
*state = DoDialog( diag_list[i] );
GUIWndDirty( NULL );
StatusCancelled();
}
if( *state == DLG_CAN ) {
if( MsgBox( NULL, "IDS_QUERYABORT", GUI_YES_NO ) == GUI_RET_YES ) {
CancelSetup = TRUE;
break;
}
} else if( *state == DLG_DONE ) {
CancelSetup = TRUE;
break;
}
if( got_disk_sizes ) {
if( !CheckDrive( FALSE ) ) {
break;
}
}
if( *state == DLG_SAME ) {
/* nothing */
} else if( *state == DLG_NEXT || *state == DLG_SKIP ) {
if( SkipDialogs ) {
++i;
} else {
for( ;; ) {
++i;
if( diag_list[i] == NULL ) break;
if( CheckDialog( diag_list[i] ) ) break;
}
}
} else if( *state == DLG_PREV ) {
for( ;; ) {
--i;
if( i < 0 ) break;
if( CheckDialog( diag_list[i] ) ) break;
}
} else if( *state == DLG_START ) {
i = 0;
}
} /* for */
return( ret );
}
int SDL_SYS_CDInit(void)
{
/* checklist: /dev/cdrom, /dev/hd?, /dev/scd? /dev/sr? */
static char *checklist[] = {
"cdrom", "?a hd?", "?0 scd?", "?0 sr?", NULL
};
char *SDLcdrom;
int i, j, exists;
char drive[32];
struct stat stbuf;
/* Fill in our driver capabilities */
SDL_CDcaps.Name = SDL_SYS_CDName;
SDL_CDcaps.Open = SDL_SYS_CDOpen;
SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
SDL_CDcaps.Status = SDL_SYS_CDStatus;
SDL_CDcaps.Play = SDL_SYS_CDPlay;
SDL_CDcaps.Pause = SDL_SYS_CDPause;
SDL_CDcaps.Resume = SDL_SYS_CDResume;
SDL_CDcaps.Stop = SDL_SYS_CDStop;
SDL_CDcaps.Eject = SDL_SYS_CDEject;
SDL_CDcaps.Close = SDL_SYS_CDClose;
/* Look in the environment for our CD-ROM drive list */
SDLcdrom = getenv("SDL_CDROM"); /* ':' separated list of devices */
if ( SDLcdrom != NULL ) {
char *cdpath, *delim;
cdpath = malloc(strlen(SDLcdrom)+1);
if ( cdpath != NULL ) {
strcpy(cdpath, SDLcdrom);
SDLcdrom = cdpath;
do {
delim = strchr(SDLcdrom, ':');
if ( delim ) {
*delim++ = '\0';
}
#ifdef DEBUG_CDROM
fprintf(stderr, "Checking CD-ROM drive from SDL_CDROM: %s\n", SDLcdrom);
#endif
if ( CheckDrive(SDLcdrom, NULL, &stbuf) > 0 ) {
AddDrive(SDLcdrom, &stbuf);
}
if ( delim ) {
SDLcdrom = delim;
} else {
SDLcdrom = NULL;
}
} while ( SDLcdrom );
free(cdpath);
}
/* If we found our drives, there's nothing left to do */
if ( SDL_numcds > 0 ) {
return(0);
}
}
#ifdef USE_MNTENT
/* Check /dev/cdrom first :-) */
if (CheckDrive("/dev/cdrom", NULL, &stbuf) > 0) {
AddDrive("/dev/cdrom", &stbuf);
}
/* Now check the currently mounted CD drives */
CheckMounts(_PATH_MOUNTED);
/* Finally check possible mountable drives in /etc/fstab */
CheckMounts(_PATH_MNTTAB);
/* If we found our drives, there's nothing left to do */
if ( SDL_numcds > 0 ) {
return(0);
}
#endif /* USE_MNTENT */
/* Scan the system for CD-ROM drives.
Not always 100% reliable, so use the USE_MNTENT code above first.
*/
for ( i=0; checklist[i]; ++i ) {
if ( checklist[i][0] == '?' ) {
char *insert;
exists = 1;
for ( j=checklist[i][1]; exists; ++j ) {
sprintf(drive, "/dev/%s", &checklist[i][3]);
insert = strchr(drive, '?');
if ( insert != NULL ) {
*insert = j;
}
#ifdef DEBUG_CDROM
fprintf(stderr, "Checking possible CD-ROM drive: %s\n", drive);
#endif
switch (CheckDrive(drive, NULL, &stbuf)) {
/* Drive exists and is a CD-ROM */
case 1:
AddDrive(drive, &stbuf);
break;
/* Drive exists, but isn't a CD-ROM */
case 0:
break;
/* Drive doesn't exist */
case -1:
exists = 0;
break;
}
}
} else {
sprintf(drive, "/dev/%s", checklist[i]);
#ifdef DEBUG_CDROM
fprintf(stderr, "Checking possible CD-ROM drive: %s\n", drive);
#endif
if ( CheckDrive(drive, NULL, &stbuf) > 0 ) {
AddDrive(drive, &stbuf);
}
}
}
return(0);
}
static void CheckMounts()
{
char* buffer;
int bufsz;
struct vmount* ptr;
int ret;
buffer = (char*)malloc(10);
bufsz = 10;
if ( buffer==NULL )
{
fprintf(stderr, "Could not allocate 10 bytes in aix/SDL_syscdrom.c:CheckMounts\n" );
exit ( -10 );
}
do
{
/* mntctrl() returns an array of all mounted filesystems */
ret = mntctl ( MCTL_QUERY, bufsz, buffer );
if ( ret == 0 )
{
/* Buffer was too small, realloc. */
bufsz = *(int*)buffer; /* Required size is in first word. */
/* (whatever a word is in AIX 4.3.3) */
/* int seems to be OK in 32bit mode. */
free(buffer);
buffer = (char*)malloc(bufsz);
if ( buffer==NULL )
{
fprintf(stderr,
"Could not allocate %d bytes in aix/SDL_syscdrom.c:CheckMounts\n",
bufsz );
exit ( -10 );
}
}
else if ( ret < 0 )
{
#ifdef DEBUG_CDROM
fprintf(stderr, "Error reading vmount structures\n");
#endif
return;
}
}
while ( ret == 0 );
#ifdef DEBUG_CDROM
fprintf ( stderr, "Read %d vmount structures\n",ret );
#endif
ptr = (struct vmount*)buffer;
do
{
switch(ptr->vmt_gfstype)
{
case MNT_CDROM :
{
struct stat stbuf;
char* text;
text = (char*)ptr + ptr->vmt_data[VMT_OBJECT].vmt_off;
#ifdef DEBUG_CDROM
fprintf(stderr, "Checking mount path: %s mounted on %s\n",
text, (char*)ptr + ptr->vmt_data[VMT_STUB].vmt_off );
#endif
if ( CheckDrive( text, &stbuf) > 0)
{
AddDrive( text, &stbuf);
}
}
break;
default :
break;
}
ptr = (struct vmount*)((char*)ptr + ptr->vmt_length);
ret--;
}
while ( ret > 0 );
free ( buffer );
}
int SDL_SYS_CDInit(void)
{
/* checklist: /dev/cdrom, /dev/cd?, /dev/scd? */
static char *checklist[]={"cdrom", "?0 cd?", "?1 cd?", "?0 scd?", NULL};
char *SDLcdrom;
int i, j, exists;
char drive[32];
struct stat stbuf;
/* Fill in our driver capabilities */
SDL_CDcaps.Name = SDL_SYS_CDName;
SDL_CDcaps.Open = SDL_SYS_CDOpen;
SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
SDL_CDcaps.Status = SDL_SYS_CDStatus;
SDL_CDcaps.Play = SDL_SYS_CDPlay;
SDL_CDcaps.Pause = SDL_SYS_CDPause;
SDL_CDcaps.Resume = SDL_SYS_CDResume;
SDL_CDcaps.Stop = SDL_SYS_CDStop;
SDL_CDcaps.Eject = SDL_SYS_CDEject;
SDL_CDcaps.Close = SDL_SYS_CDClose;
/* clearing device open status */
for (i=0; i<MAX_DRIVES; i++)
{
SDL_cdopen[i]=0;
}
/* Look in the environment for our CD-ROM drive list */
SDLcdrom = SDL_getenv("SDL_CDROM"); /* ':' separated list of devices */
if ( SDLcdrom != NULL )
{
char *cdpath, *delim;
size_t len = SDL_strlen(SDLcdrom)+1;
cdpath = SDL_stack_alloc(char, len);
if (cdpath != NULL)
{
SDL_strlcpy(cdpath, SDLcdrom, len);
SDLcdrom = cdpath;
do {
delim = SDL_strchr(SDLcdrom, ':');
if (delim)
{
*delim++ = '\0';
}
if (CheckDrive(SDLcdrom, &stbuf) > 0)
{
AddDrive(SDLcdrom, &stbuf);
}
if (delim)
{
SDLcdrom = delim;
}
else
{
SDLcdrom = NULL;
}
} while (SDLcdrom);
SDL_stack_free(cdpath);
}
/* If we found our drives, there's nothing left to do */
if (SDL_numcds > 0)
{
return(0);
}
}
const char *CdromDriverLinux::DeviceName(int drive)
{
if (!drives_scanned)
{
/* checklist: /dev/cdrom, /dev/hd?, /dev/scd? /dev/sr? */
static const char *const checklist[] = {
"cdrom", "?a hd?", "?0 scd?", "?0 sr?", NULL
};
struct stat stbuf;
#ifdef USE_MNTENT
/* Check /dev/cdrom first :-) */
if (CheckDrive("/dev/cdrom", NULL, &stbuf) > 0) {
AddDrive("/dev/cdrom", &stbuf);
}
/* Now check the currently mounted CD drives */
CheckMounts(_PATH_MOUNTED);
/* Finally check possible mountable drives in /etc/fstab */
CheckMounts(_PATH_MNTTAB);
/* If we found our drives, there's nothing left to do */
#endif /* USE_MNTENT */
if ( numcds == 0 )
{
char drive[32];
int i, j, exists;
/* Scan the system for CD-ROM drives.
Not always 100% reliable, so use the USE_MNTENT code above first.
*/
for ( i=0; checklist[i]; ++i ) {
if ( checklist[i][0] == '?' ) {
char *insert;
exists = 1;
for ( j=checklist[i][1]; exists; ++j ) {
sprintf(drive, "/dev/%s", &checklist[i][3]);
insert = strchr(drive, '?');
if ( insert != NULL ) {
*insert = j;
}
switch (CheckDrive(drive, NULL, &stbuf)) {
/* Drive exists and is a CD-ROM */
case 1:
AddDrive(drive, &stbuf);
break;
/* Drive exists, but isn't a CD-ROM */
case 0:
break;
/* Drive doesn't exist */
case -1:
exists = 0;
break;
}
}
} else {
sprintf(drive, "/dev/%s", checklist[i]);
if ( CheckDrive(drive, NULL, &stbuf) > 0 ) {
AddDrive(drive, &stbuf);
}
}
}
}
drives_scanned = true;
}
return cddrives[drive].device;
}
void CdromDriverLinux::CheckMounts(const char *mtab)
{
FILE *mntfp;
struct mntent *mntent;
struct stat stbuf;
mntfp = setmntent(mtab, "r");
if ( mntfp != NULL ) {
char *tmp;
char *mnt_type;
size_t mnt_type_len;
char *mnt_dev;
size_t mnt_dev_len;
while ( (mntent=getmntent(mntfp)) != NULL ) {
mnt_type_len = strlen(mntent->mnt_type) + 1;
mnt_type = (char *)malloc(mnt_type_len);
if (mnt_type == NULL)
continue; /* maybe you'll get lucky next time. */
mnt_dev_len = strlen(mntent->mnt_fsname) + 1;
mnt_dev = (char *)malloc(mnt_dev_len);
if (mnt_dev == NULL) {
free(mnt_type);
continue;
}
strcpy(mnt_type, mntent->mnt_type);
strcpy(mnt_dev, mntent->mnt_fsname);
/* Handle "supermount" filesystem mounts */
if ( strcmp(mnt_type, MNTTYPE_SUPER) == 0 ) {
tmp = strstr(mntent->mnt_opts, "fs=");
if ( tmp ) {
free(mnt_type);
mnt_type = strdup(tmp + strlen("fs="));
if ( mnt_type ) {
tmp = strchr(mnt_type, ',');
if ( tmp ) {
*tmp = '\0';
}
}
}
tmp = strstr(mntent->mnt_opts, "dev=");
if ( tmp ) {
free(mnt_dev);
mnt_dev = strdup(tmp + strlen("dev="));
if ( mnt_dev ) {
tmp = strchr(mnt_dev, ',');
if ( tmp ) {
*tmp = '\0';
}
}
}
}
if ( strcmp(mnt_type, MNTTYPE_CDROM) == 0 ) {
if (CheckDrive(mnt_dev, mnt_type, &stbuf) > 0) {
AddDrive(mnt_dev, &stbuf);
}
}
free(mnt_dev);
free(mnt_type);
}
endmntent(mntfp);
}
}
int
SDL_SYS_CDInit(void)
{
/* checklist:
*
* Tru64 5.X (/dev/rdisk/cdrom?c)
* dir: /dev/rdisk, name: cdrom
*
* Digital UNIX 4.0X (/dev/rrz?c)
* dir: /dev, name: rrz
*
*/
struct
{
char *dir;
char *name;
} checklist[] = {
{
"/dev/rdisk", "cdrom"}, {
"/dev", "rrz"}, {
NULL, NULL}};
char drive[32];
char *SDLcdrom;
int i, j, exists;
struct stat stbuf;
/* Fill in our driver capabilities */
SDL_CDcaps.Name = SDL_SYS_CDName;
SDL_CDcaps.Open = SDL_SYS_CDOpen;
SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
SDL_CDcaps.Status = SDL_SYS_CDStatus;
SDL_CDcaps.Play = SDL_SYS_CDPlay;
SDL_CDcaps.Pause = SDL_SYS_CDPause;
SDL_CDcaps.Resume = SDL_SYS_CDResume;
SDL_CDcaps.Stop = SDL_SYS_CDStop;
SDL_CDcaps.Eject = SDL_SYS_CDEject;
SDL_CDcaps.Close = SDL_SYS_CDClose;
/* Look in the environment for our CD-ROM drive list */
SDLcdrom = SDL_getenv("SDL_CDROM"); /* ':' separated list of devices */
if (SDLcdrom != NULL) {
char *cdpath, *delim;
size_t len = SDL_strlen(SDLcdrom) + 1;
cdpath = SDL_stack_alloc(char, len);
if (cdpath != NULL) {
SDL_strlcpy(cdpath, SDLcdrom, len);
SDLcdrom = cdpath;
do {
delim = SDL_strchr(SDLcdrom, ':');
if (delim) {
*delim++ = '\0';
}
if (CheckDrive(SDLcdrom, &stbuf) > 0) {
AddDrive(SDLcdrom, &stbuf);
}
if (delim) {
SDLcdrom = delim;
} else {
SDLcdrom = NULL;
}
} while (SDLcdrom);
SDL_stack_free(cdpath);
}
/* If we found our drives, there's nothing left to do */
if (SDL_numcds > 0) {
return (0);
}
}
static int CheckNonmounts()
{
#ifdef _THREAD_SAFE
AFILE_t fsFile = NULL;
int passNo = 0;
int ret;
struct fstab entry;
struct stat stbuf;
ret = setfsent_r( &fsFile, &passNo );
if ( ret != 0 ) return -1;
do
{
ret = getfsent_r ( &entry, &fsFile, &passNo );
if ( ret == 0 ) {
char* l = strrchr(entry.fs_spec,'/');
if ( l != NULL ) {
if ( !strncmp("cd",++l,2) ) {
#ifdef DEBUG_CDROM
fprintf(stderr,
"Found unmounted CD ROM drive with device name %s\n",
entry.fs_spec);
#endif
if ( CheckDrive( entry.fs_spec, &stbuf) > 0)
{
AddDrive( entry.fs_spec, &stbuf);
}
}
}
}
}
while ( ret == 0 );
ret = endfsent_r ( &fsFile );
if ( ret != 0 ) return -1;
return 0;
#else
struct fstab* entry;
struct stat stbuf;
setfsent();
do
{
entry = getfsent();
if ( entry != NULL ) {
char* l = strrchr(entry->fs_spec,'/');
if ( l != NULL ) {
if ( !strncmp("cd",++l,2) ) {
#ifdef DEBUG_CDROM
fprintf(stderr,"Found unmounted CD ROM drive with device name %s", entry->fs_spec);
#endif
if ( CheckDrive( entry->fs_spec, &stbuf) > 0)
{
AddDrive( entry->fs_spec, &stbuf);
}
}
}
}
}
while ( entry != NULL );
endfsent();
#endif
}
int SDL_SYS_CDInit(void)
{
/* checklist: /dev/cdrom,/dev/cd?c /dev/acd?c
* /dev/matcd?c /dev/mcd?c /dev/scd?c
*
*/
static char *checklist[] = {
"?0 rdisk/cdrom?",NULL};
char drive[32];
char *SDLcdrom;
int i, j, exists;
struct stat stbuf;
/* Fill in our driver capabilities */
SDL_CDcaps.Name = SDL_SYS_CDName;
SDL_CDcaps.Open = SDL_SYS_CDOpen;
SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
SDL_CDcaps.Status = SDL_SYS_CDStatus;
SDL_CDcaps.Play = SDL_SYS_CDPlay;
SDL_CDcaps.Pause = SDL_SYS_CDPause;
SDL_CDcaps.Resume = SDL_SYS_CDResume;
SDL_CDcaps.Stop = SDL_SYS_CDStop;
SDL_CDcaps.Eject = SDL_SYS_CDEject;
SDL_CDcaps.Close = SDL_SYS_CDClose;
/* Look in the environment for our CD-ROM drive list */
SDLcdrom = getenv("SDL_CDROM"); /* ':' separated list of devices */
if ( SDLcdrom != NULL ) {
char *cdpath, *delim;
cdpath = malloc(strlen(SDLcdrom)+1);
if ( cdpath != NULL ) {
strcpy(cdpath, SDLcdrom);
SDLcdrom = cdpath;
do {
delim = strchr(SDLcdrom, ':');
if ( delim ) {
*delim++ = '\0';
}
if ( CheckDrive(SDLcdrom, &stbuf) > 0 ) {
AddDrive(SDLcdrom, &stbuf);
}
if ( delim ) {
SDLcdrom = delim;
} else {
SDLcdrom = NULL;
}
} while ( SDLcdrom );
free(cdpath);
}
/* If we found our drives, there's nothing left to do */
if ( SDL_numcds > 0 ) {
return(0);
}
}
/* Scan the system for CD-ROM drives */
for ( i=0; checklist[i]; ++i ) {
if ( checklist[i][0] == '?' ) {
char *insert;
exists = 1;
for ( j=checklist[i][1]; exists; ++j ) {
sprintf(drive, "/dev/%sc", &checklist[i][3]);
insert = strchr(drive, '?');
if ( insert != NULL ) {
*insert = j;
}
switch (CheckDrive(drive, &stbuf)) {
/* Drive exists and is a CD-ROM */
case 1:
AddDrive(drive, &stbuf);
break;
/* Drive exists, but isn't a CD-ROM */
case 0:
break;
/* Drive doesn't exist */
case -1:
exists = 0;
break;
}
}
} else {
sprintf(drive, "/dev/%s", checklist[i]);
if ( CheckDrive(drive, &stbuf) > 0 ) {
AddDrive(drive, &stbuf);
}
}
}
/*
SDLcdrom=malloc(sizeof(char) * 32);
strcpy(SDLcdrom,"/dev/rdisk/cdrom0c");
SDL_cdlist[0] = SDLcdrom;
stat(SDLcdrom, &stbuf);
SDL_cdmode[0] = stbuf.st_rdev;
SDL_numcds = 1;
*/
return (0);
}
static void CheckMounts(const char *mtab)
{
FILE *mntfp;
struct mntent *mntent;
struct stat stbuf;
mntfp = setmntent(mtab, "r");
if ( mntfp != NULL ) {
char *tmp;
char *mnt_type;
size_t mnt_type_len;
char *mnt_dev;
size_t mnt_dev_len;
while ( (mntent=getmntent(mntfp)) != NULL ) {
mnt_type_len = SDL_strlen(mntent->mnt_type) + 1;
mnt_type = SDL_stack_alloc(char, mnt_type_len);
if (mnt_type == NULL)
continue; /* maybe you'll get lucky next time. */
mnt_dev_len = SDL_strlen(mntent->mnt_fsname) + 1;
mnt_dev = SDL_stack_alloc(char, mnt_dev_len);
if (mnt_dev == NULL) {
SDL_stack_free(mnt_type);
continue;
}
SDL_strlcpy(mnt_type, mntent->mnt_type, mnt_type_len);
SDL_strlcpy(mnt_dev, mntent->mnt_fsname, mnt_dev_len);
/* Handle "supermount" filesystem mounts */
if ( SDL_strcmp(mnt_type, MNTTYPE_SUPER) == 0 ) {
tmp = SDL_strstr(mntent->mnt_opts, "fs=");
if ( tmp ) {
SDL_stack_free(mnt_type);
mnt_type = SDL_strdup(tmp + SDL_strlen("fs="));
if ( mnt_type ) {
tmp = SDL_strchr(mnt_type, ',');
if ( tmp ) {
*tmp = '\0';
}
}
}
tmp = SDL_strstr(mntent->mnt_opts, "dev=");
if ( tmp ) {
SDL_stack_free(mnt_dev);
mnt_dev = SDL_strdup(tmp + SDL_strlen("dev="));
if ( mnt_dev ) {
tmp = SDL_strchr(mnt_dev, ',');
if ( tmp ) {
*tmp = '\0';
}
}
}
}
if ( SDL_strcmp(mnt_type, MNTTYPE_CDROM) == 0 ) {
#ifdef DEBUG_CDROM
fprintf(stderr, "Checking mount path from %s: %s mounted on %s of %s\n",
mtab, mnt_dev, mntent->mnt_dir, mnt_type);
#endif
if (CheckDrive(mnt_dev, mnt_type, &stbuf) > 0) {
AddDrive(mnt_dev, &stbuf);
}
}
SDL_stack_free(mnt_dev);
SDL_stack_free(mnt_type);
}
endmntent(mntfp);
}
TEST(Components, CurveDriveTestLinear)
{
RedBotSpeedController lMotor(0);
RedBotSpeedController rMotor(1);
frc::DifferentialDrive drive(lMotor, rMotor);
// Stationary
CheckDrive(
drive,
myPackets,
0.0,
0.0,
MotorDrivePacket(
MotorDrivePacket::MOTOR_RIGHT,
0,
MotorDrivePacket::DIR_FORWARD
),
MotorDrivePacket(
MotorDrivePacket::MOTOR_LEFT,
0,
MotorDrivePacket::DIR_FORWARD
),
false
);
// Drive forward
CheckDrive(
drive,
myPackets,
1.0,
0.0,
MotorDrivePacket(
MotorDrivePacket::MOTOR_RIGHT,
255,
MotorDrivePacket::DIR_FORWARD
),
MotorDrivePacket(
MotorDrivePacket::MOTOR_LEFT,
255,
MotorDrivePacket::DIR_FORWARD
),
false
);
// Drive forward at half speed
CheckDrive(
drive,
myPackets,
0.5,
0.0,
MotorDrivePacket(
MotorDrivePacket::MOTOR_RIGHT,
127,
MotorDrivePacket::DIR_FORWARD
),
MotorDrivePacket(
MotorDrivePacket::MOTOR_LEFT,
127,
MotorDrivePacket::DIR_FORWARD
),
false
);
// Drive backward
CheckDrive(
drive,
myPackets,
-1.0,
0.0,
MotorDrivePacket(
MotorDrivePacket::MOTOR_RIGHT,
255,
MotorDrivePacket::DIR_BACKWARD
),
MotorDrivePacket(
MotorDrivePacket::MOTOR_LEFT,
255,
MotorDrivePacket::DIR_BACKWARD
),
false
);
// Drive backward at half speed
CheckDrive(
drive,
myPackets,
-0.5,
0.0,
MotorDrivePacket(
MotorDrivePacket::MOTOR_RIGHT,
127,
MotorDrivePacket::DIR_BACKWARD
),
MotorDrivePacket(
MotorDrivePacket::MOTOR_LEFT,
127,
MotorDrivePacket::DIR_BACKWARD
),
false
);
// Pivot right
CheckDrive(
drive,
myPackets,
0.0,
1.0,
MotorDrivePacket(
MotorDrivePacket::MOTOR_RIGHT,
255,
MotorDrivePacket::DIR_BACKWARD
),
MotorDrivePacket(
MotorDrivePacket::MOTOR_LEFT,
255,
MotorDrivePacket::DIR_FORWARD
),
false
);
// Pivot right at half speed
CheckDrive(
drive,
myPackets,
0.0,
0.5,
MotorDrivePacket(
MotorDrivePacket::MOTOR_RIGHT,
127,
MotorDrivePacket::DIR_BACKWARD
),
MotorDrivePacket(
MotorDrivePacket::MOTOR_LEFT,
127,
MotorDrivePacket::DIR_FORWARD
),
false
);
// Pivot left
CheckDrive(
drive,
myPackets,
0.0,
-1.0,
MotorDrivePacket(
MotorDrivePacket::MOTOR_RIGHT,
255,
MotorDrivePacket::DIR_FORWARD
),
MotorDrivePacket(
MotorDrivePacket::MOTOR_LEFT,
255,
MotorDrivePacket::DIR_BACKWARD
),
false
);
// Pivot left at half speed
CheckDrive(
drive,
myPackets,
0.0,
-0.5,
MotorDrivePacket(
MotorDrivePacket::MOTOR_RIGHT,
127,
MotorDrivePacket::DIR_FORWARD
),
MotorDrivePacket(
MotorDrivePacket::MOTOR_LEFT,
127,
MotorDrivePacket::DIR_BACKWARD
),
false
);
}
