int main(int argc, const char *argv[]) { CdIo_t *p_cdio; const char *psz_drive = NULL; if (argc > 1) psz_drive = argv[1]; p_cdio = cdio_open (psz_drive, DRIVER_UNKNOWN); if (NULL == p_cdio) { printf("Couldn't find CD\n"); return 1; } else { int i_status; /* Result of MMC command */ char buf[36] = { 0, }; /* Place to hold returned data */ mmc_cdb_t cdb = {{0, }}; /* Command Descriptor Buffer */ CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_INQUIRY); cdb.field[4] = sizeof(buf); i_status = mmc_run_cmd(p_cdio, DEFAULT_TIMEOUT_MS, &cdb, SCSI_MMC_DATA_READ, sizeof(buf), &buf); if (i_status == 0) { char psz_vendor[CDIO_MMC_HW_VENDOR_LEN+1]; char psz_model[CDIO_MMC_HW_MODEL_LEN+1]; char psz_rev[CDIO_MMC_HW_REVISION_LEN+1]; memcpy(psz_vendor, buf + 8, sizeof(psz_vendor)-1); psz_vendor[sizeof(psz_vendor)-1] = '\0'; memcpy(psz_model, buf + 8 + CDIO_MMC_HW_VENDOR_LEN, sizeof(psz_model)-1); psz_model[sizeof(psz_model)-1] = '\0'; memcpy(psz_rev, buf + 8 + CDIO_MMC_HW_VENDOR_LEN +CDIO_MMC_HW_MODEL_LEN, sizeof(psz_rev)-1); psz_rev[sizeof(psz_rev)-1] = '\0'; printf("Vendor: %s\nModel: %s\nRevision: %s\n", psz_vendor, psz_model, psz_rev); } else { printf("Couldn't get INQUIRY data (vendor, model, and revision).\n"); } } cdio_destroy(p_cdio); return 0; }
int main(int argc, const char *argv[]) { CdIo_t *p_cdio; const char *psz_drive = NULL; if (argc > 1) psz_drive = argv[1]; p_cdio = cdio_open (psz_drive, DRIVER_UNKNOWN); if (!p_cdio) { printf("-- Couldn't find CD\n"); return 77; } else { int i_status; /* Result of MMC command */ mmc_cdb_t cdb = {{0, }}; /* Command Descriptor Buffer */ char buf[36] = { 0, }; /* Place to hold returned data */ CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_INQUIRY); cdb.field[4] = sizeof(buf); i_status = mmc_run_cmd(p_cdio, DEFAULT_TIMEOUT_MS, &cdb, SCSI_MMC_DATA_READ, sizeof(buf), &buf); if (i_status == 0) { char psz_vendor[CDIO_MMC_HW_VENDOR_LEN+1]; char psz_model[CDIO_MMC_HW_MODEL_LEN+1]; char psz_rev[CDIO_MMC_HW_REVISION_LEN+1]; memcpy(psz_vendor, buf + 8, sizeof(psz_vendor)-1); psz_vendor[sizeof(psz_vendor)-1] = '\0'; memcpy(psz_model, buf + 8 + CDIO_MMC_HW_VENDOR_LEN, sizeof(psz_model)-1); psz_model[sizeof(psz_model)-1] = '\0'; memcpy(psz_rev, buf + 8 + CDIO_MMC_HW_VENDOR_LEN +CDIO_MMC_HW_MODEL_LEN, sizeof(psz_rev)-1); psz_rev[sizeof(psz_rev)-1] = '\0'; printf("-- Vendor: %s\n-- Model: %s\n-- Revision: %s\n", psz_vendor, psz_model, psz_rev); } else { printf("-- Couldn't get INQUIRY data (vendor, model, and revision).\n"); } { driver_return_code_t i_status; bool b_erasable; i_status = mmc_get_disc_erasable(p_cdio, &b_erasable); cdio_mmc_feature_profile_t disctype; if (DRIVER_OP_SUCCESS == i_status) printf("-- Disc is %serasable.\n", b_erasable ? "" : "not "); else printf("-- Can't determine if disc is erasable.\n"); i_status = mmc_get_disctype(p_cdio, 0, &disctype); if (DRIVER_OP_SUCCESS == i_status) { printf("-- disc type: profile is %s (0x%X)\n", mmc_feature_profile2str(disctype), disctype); } } } cdio_destroy(p_cdio); return 0; }
/** Run an MMC command. @param p_cdio CD structure set by cdio_open(). @param i_timeout_ms time in milliseconds we will wait for the command to complete. @param p_cdb CDB bytes. All values that are needed should be set on input. We'll figure out what the right CDB length should be. @param e_direction direction the transfer is to go. @param i_buf Size of buffer @param p_buf Buffer for data, both sending and receiving. @return 0 if command completed successfully. */ int mmcRunCmd( unsigned int i_timeout_ms, const mmc_cdb_t *p_cdb, cdio_mmc_direction_t e_direction, unsigned int i_buf, /*in/out*/ void *p_buf ) { return mmc_run_cmd( p_cdio, i_timeout_ms, p_cdb, e_direction, i_buf, p_buf ); }
int main(int argc, const char *argv[]) { CdIo_t *p_cdio; p_cdio = cdio_open (NULL, DRIVER_UNKNOWN); if (NULL == p_cdio) { printf("Couldn't find CD\n"); return 1; } else { int i_status; /* Result of MMC command */ uint8_t buf[500] = { 0, }; /* Place to hold returned data */ mmc_cdb_t cdb = {{0, }}; /* Command Descriptor Buffer */ CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_GET_CONFIGURATION); CDIO_MMC_SET_READ_LENGTH8(cdb.field, sizeof(buf)); cdb.field[1] = CDIO_MMC_GET_CONF_ALL_FEATURES; cdb.field[3] = 0x0; i_status = mmc_run_cmd(p_cdio, 0, &cdb, SCSI_MMC_DATA_READ, sizeof(buf), &buf); if (i_status == 0) { uint8_t *p; uint32_t i_data; uint8_t *p_max = buf + 65530; i_data = (unsigned int) CDIO_MMC_GET_LEN32(buf); /* set to first sense feature code, and then walk through the masks */ p = buf + 8; while( (p < &(buf[i_data])) && (p < p_max) ) { uint16_t i_feature; uint8_t i_feature_additional = p[3]; i_feature = CDIO_MMC_GET_LEN16(p); { uint8_t *q; const char *feature_str = mmc_feature2str(i_feature); printf("%s Feature\n", feature_str); switch( i_feature ) { case CDIO_MMC_FEATURE_PROFILE_LIST: for ( q = p+4 ; q < p + i_feature_additional ; q += 4 ) { int i_profile=CDIO_MMC_GET_LEN16(q); const char *feature_profile_str = mmc_feature_profile2str(i_profile); printf( "\t%s", feature_profile_str ); if (q[2] & 1) { printf(" - on"); } printf("\n"); } printf("\n"); break; case CDIO_MMC_FEATURE_CORE: { uint8_t *q = p+4; uint32_t i_interface_standard = CDIO_MMC_GET_LEN32(q); switch(i_interface_standard) { case 0: printf("\tunspecified interface\n"); break; case 1: printf("\tSCSI interface\n"); break; case 2: printf("\tATAPI interface\n"); break; case 3: printf("\tIEEE 1394 interface\n"); break; case 4: printf("\tIEEE 1394A interface\n"); break; case 5: printf("\tFibre Channel interface\n"); } printf("\n"); break; } case CDIO_MMC_FEATURE_REMOVABLE_MEDIUM: switch(p[4] >> 5) { case 0: printf("\tCaddy/Slot type loading mechanism\n"); break; case 1: printf("\tTray type loading mechanism\n"); break; case 2: printf("\tPop-up type loading mechanism\n"); break; case 4: printf("\tEmbedded changer with individually changeable discs\n"); break; case 5: printf("\tEmbedded changer using a magazine mechanism\n"); break; default: printf("\tUnknown changer mechanism\n"); } printf("\tcan%s eject the medium or magazine via the normal " "START/STOP command\n", (p[4] & 8) ? "": "not"); printf("\tcan%s be locked into the Logical Unit\n", (p[4] & 1) ? "": "not"); printf("\n"); break; case CDIO_MMC_FEATURE_CD_READ: printf("CD Read Feature\n"); printf("\tC2 Error pointers are %ssupported\n", (p[4] & 2) ? "": "not "); printf("\tCD-Text is %ssupported\n", (p[4] & 1) ? "": "not "); printf("\n"); break; case CDIO_MMC_FEATURE_CDDA_EXT_PLAY: printf("\tSCAN command is %ssupported\n", (p[4] & 4) ? "": "not "); printf("\taudio channels can %sbe muted separately\n", (p[4] & 2) ? "": "not "); printf("\taudio channels can %shave separate volume levels\n", (p[4] & 1) ? "": "not "); { uint8_t *q = p+6; uint16_t i_vol_levels = CDIO_MMC_GET_LEN16(q); printf("\t%d volume levels can be set\n", i_vol_levels); } printf("\n"); break; case CDIO_MMC_FEATURE_LU_SN: { uint8_t i_serial = *(p+3); char serial[257] = { '\0', }; memcpy(serial, p+4, i_serial); printf("\t%s\n\n", serial); break; } default: printf("\n"); break; } p += i_feature_additional + 4; } } } else {
int libunieject_togglelock(struct unieject_opts *opts, int lock) { if ( opts->caps ) { // TODO: tell libcdio author about this cdio_drive_misc_cap_t unused, misc_cap; cdio_get_drive_cap((CdIo_t*)opts->cdio, &unused, &unused, &misc_cap); #ifdef __FreeBSD__ if ( strncmp("/dev/cd", opts->device, 7) != 0 ) misc_cap = 0xFFFFFFFF; #endif if ( ! (misc_cap & CDIO_DRIVE_CAP_MISC_LOCK) ) { unieject_error(*opts, _("the selected device doesn't have locking capabilities.\n")); return -2; } } if ( opts->fake ) return 0; /* * On Linux the allow medium removal command is a priviledged command that * cannot be instanced by userspace. * Until this changes, use a workaround with syscalls instead. */ #if defined(__linux__) && defined(USE_LOCK_WORKAROUND) cdio_destroy(opts->cdio); opts->cdio = NULL; int devfd = open(opts->device, O_RDONLY|O_NONBLOCK); if ( UNLIKELY(devfd == -1) ) { unieject_error(*opts, _("unable to open device descriptor [%s].\n"), strerror(errno)); return -4; } if ( UNLIKELY(ioctl(devfd, CDROM_LOCKDOOR, lock ? 1 : 0) == -1) ) { unieject_error(*opts, _("error in ioctl [%s].\n"), strerror(errno)); return -5; } close(devfd); return 0; #else mmc_cdb_t lockcmd = { {0, } }; /* Command description buffer */ uint8_t buf[1]; /* Fake buffer */ CDIO_MMC_SET_COMMAND(lockcmd.field, CDIO_MMC_GPCMD_ALLOW_MEDIUM_REMOVAL); lockcmd.field[4] = lock ? 1 : 0; driver_return_code_t sts = mmc_run_cmd( (CdIo_t*)opts->cdio, DEFAULT_TIMEOUT_MS, /* Should this be configurable? */ &lockcmd, SCSI_MMC_DATA_READ, 0, buf ); return unieject_status(*opts, sts); #endif }