#define MAX_DRIVES	16

static int SDL_SYS_CDOpen(int drive);

static int SDL_SYS_CDGetTOC(SDL_CD * cdrom);

static CDstatus SDL_SYS_CDStatus(SDL_CD * cdrom, int *position);

static int SDL_SYS_CDPlay(SDL_CD * cdrom, int start, int length);

static int SDL_SYS_CDPause(SDL_CD * cdrom);

static int SDL_SYS_CDResume(SDL_CD * cdrom);

static int SDL_SYS_CDStop(SDL_CD * cdrom);

static int SDL_SYS_CDEject(SDL_CD * cdrom);

static void SDL_SYS_CDClose(SDL_CD * cdrom);

static int SDL_SYS_CDioctl(int id, int command, void *arg);

static int

CheckDrive(char *drive, struct stat *stbuf)

    if (stat(drive, stbuf) < 0) {

    if (S_ISCHR(stbuf->st_mode) || S_ISBLK(stbuf->st_mode)) {

        cdfd = open(drive, (O_RDONLY | O_EXCL | O_NONBLOCK), 0);

        if (cdfd >= 0) {

            ret = SDL_SYS_CDioctl(cdfd, IOCINFO, &info);

            if (ret < 0) {

                /* Some kind of error */

                is_cd = 0;

            } else {

                if (info.devtype == DD_CDROM) {

                    is_cd = 1;

                } else {

                    is_cd = 0;

                }

            }

        }

        else {

            fprintf(stderr, "Could not open drive %s (%s)\n", drive,

                    strerror(errno));

        }

static void

AddDrive(char *drive, struct stat *stbuf)

    int i;

    if (SDL_numcds < MAX_DRIVES) {

        /* Check to make sure it's not already in our list.

           This can happen when we see a drive via symbolic link.

         */

        for (i = 0; i < SDL_numcds; ++i) {

            if (stbuf->st_rdev == SDL_cdmode[i]) {

                fprintf(stderr, "Duplicate drive detected: %s == %s\n",

                        drive, SDL_cdlist[i]);

                return;

            }

        }

        /* Add this drive to our list */

        i = SDL_numcds;

        SDL_cdlist[i] = SDL_strdup(drive);

        if (SDL_cdlist[i] == NULL) {

            SDL_OutOfMemory();

            return;

        }

        SDL_cdmode[i] = stbuf->st_rdev;

        ++SDL_numcds;

        fprintf(stderr, "Added CD-ROM drive: %s\n", drive);

    }

static void

CheckMounts()

    char *buffer;

    int bufsz;

    struct vmount *ptr;

    int ret;

    buffer = (char *) SDL_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. */

            buffer = (char *) SDL_malloc(bufsz);

            if (buffer == NULL) {

                        "Could not allocate %d bytes in aix/SDL_syscdrom.c:CheckMounts\n",

                        bufsz);

                exit(-10);

        } else if (ret < 0) {

            return;

        }

    while (ret == 0);

    fprintf(stderr, "Read %d vmount structures\n", ret);

    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;

                fprintf(stderr,

                        "Checking mount path: %s mounted on %s\n", text,

                        (char *) ptr + ptr->vmt_data[VMT_STUB].vmt_off);

                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);

static int

CheckNonmounts()

    AFILE_t fsFile = NULL;

    int passNo = 0;

    int ret;

    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 = SDL_strrchr(entry.fs_spec, '/');

            if (l != NULL) {

                if (!SDL_strncmp("cd", ++l, 2)) {

                            "Found unmounted CD ROM drive with device name %s\n",

                            entry.fs_spec);

                    if (CheckDrive(entry.fs_spec, &stbuf) > 0) {

                        AddDrive(entry.fs_spec, &stbuf);

                    }

    while (ret == 0);

    ret = endfsent_r(&fsFile);

    if (ret != 0)

        return -1;

    struct fstab *entry;

    struct stat stbuf;

    do {

        if (entry != NULL) {

            char *l = SDL_strrchr(entry->fs_spec, '/');

            if (l != NULL) {

                if (!SDL_strncmp("cd", ++l, 2)) {

                    fprintf(stderr,

                            "Found unmounted CD ROM drive with device name %s",

                            entry->fs_spec);

                    if (CheckDrive(entry->fs_spec, &stbuf) > 0) {

                        AddDrive(entry->fs_spec, &stbuf);

                    }

    while (entry != NULL);

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 = 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';

                }

                fprintf(stderr,

                        "Checking CD-ROM drive from SDL_CDROM: %s\n",

                        SDLcdrom);

                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);

        }

    }

    CheckMounts();

    CheckNonmounts();

    return 0;

static int

SDL_SYS_CDioctl(int id, int command, void *arg)

    if (retval < 0) {

static const char *

SDL_SYS_CDName(int drive)

    return (SDL_cdlist[drive]);

static int

SDL_SYS_CDOpen(int drive)

    int fd;

    char *lastsl;

    char *cdromname;

    len = SDL_strlen(SDL_cdlist[drive]) + 2;

    cdromname = (char *) SDL_malloc(len);

    SDL_strlcpy(cdromname, SDL_cdlist[drive], len);

    lastsl = SDL_strrchr(cdromname, '/');

        *lastsl = 0;

        SDL_strlcat(cdromname, "/r", len);

        lastsl = SDL_strrchr(SDL_cdlist[drive], '/');

        if (lastsl) {

            lastsl++;

            SDL_strlcat(cdromname, lastsl, len);

        }

    fprintf(stderr, "Should open drive %s, opening %s\n", SDL_cdlist[drive],

            cdromname);

    if (fd < 0) {

        fprintf(stderr, "Could not open drive %s (%s)\n", cdromname,

                strerror(errno));

    } else {

        struct mode_form_op cdMode;

        int ret;

        cdMode.action = CD_GET_MODE;

        ret = SDL_SYS_CDioctl(fd, DK_CD_MODE, &cdMode);

        if (ret < 0) {

                    "Could not get drive mode for %s (%s)\n",

                    cdromname, strerror(errno));

        } else {

            switch (cdMode.cd_mode_form) {

            case CD_MODE1:

                fprintf(stderr,

                        "Drive mode for %s is %s\n",

                        cdromname, "CD-ROM Data Mode 1");

                break;

            case CD_MODE2_FORM1:

                fprintf(stderr,

                        "Drive mode for %s is %s\n",

                        cdromname, "CD-ROM XA Data Mode 2 Form 1");

                break;

            case CD_MODE2_FORM2:

                fprintf(stderr,

                        "Drive mode for %s is %s\n",

                        cdromname, "CD-ROM XA Data Mode 2 Form 2");

                break;

            case CD_DA:

                fprintf(stderr,

                        "Drive mode for %s is %s\n", cdromname, "CD-DA");

                break;

            default:

                fprintf(stderr,

                        "Drive mode for %s is %s\n", cdromname, "unknown");

                break;

            }

        }

        cdMode.action = CD_CHG_MODE;

        cdMode.cd_mode_form = CD_DA;

        ret = SDL_SYS_CDioctl(fd, DK_CD_MODE, &cdMode);

        if (ret < 0) {

                    "Could not set drive mode for %s (%s)\n",

                    cdromname, strerror(errno));

            SDL_SetError

                ("ioctl() error: Could not set CD drive mode, %s",

                 strerror(errno));

        } else {

            fprintf(stderr, "Drive mode for %s set to CD_DA\n", cdromname);

        }

static int

SDL_SYS_CDGetTOC(SDL_CD * cdrom)

    int i;

    int okay;

    cmd.msf_flag = FALSE;

    if (SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd) < 0) {

        return -1;

        - cmd.indexing.track_index.first_track + 1;

    if (cdrom->numtracks > SDL_MAX_TRACKS) {

    for (i = 0; i <= cdrom->numtracks; ++i) {

        if (i == cdrom->numtracks) {

            cdrom->track[i].id = cmd.indexing.track_index.first_track + i;

        entry.audio_cmds = CD_GET_TRK_MSF;

        entry.indexing.track_msf.track = cdrom->track[i].id;