+/* SPDX-License-Identifier: GPL-2.0+ */
/*
* cdrom_id - optical drive and media information prober
- *
- * Copyright (C) 2008-2010 Kay Sievers <kay@vrfy.org>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <errno.h>
#include <time.h>
#include <unistd.h>
-#include "libudev.h"
-
-#include "libudev-private.h"
+#include "log.h"
+#include "memory-util.h"
#include "random-util.h"
+#include "udev-util.h"
/* device info */
-static unsigned int cd_cd_rom;
-static unsigned int cd_cd_r;
-static unsigned int cd_cd_rw;
-static unsigned int cd_dvd_rom;
-static unsigned int cd_dvd_r;
-static unsigned int cd_dvd_rw;
-static unsigned int cd_dvd_ram;
-static unsigned int cd_dvd_plus_r;
-static unsigned int cd_dvd_plus_rw;
-static unsigned int cd_dvd_plus_r_dl;
-static unsigned int cd_dvd_plus_rw_dl;
-static unsigned int cd_bd;
-static unsigned int cd_bd_r;
-static unsigned int cd_bd_re;
-static unsigned int cd_hddvd;
-static unsigned int cd_hddvd_r;
-static unsigned int cd_hddvd_rw;
-static unsigned int cd_mo;
-static unsigned int cd_mrw;
-static unsigned int cd_mrw_w;
+static unsigned cd_cd_rom;
+static unsigned cd_cd_r;
+static unsigned cd_cd_rw;
+static unsigned cd_dvd_rom;
+static unsigned cd_dvd_r;
+static unsigned cd_dvd_rw;
+static unsigned cd_dvd_ram;
+static unsigned cd_dvd_plus_r;
+static unsigned cd_dvd_plus_rw;
+static unsigned cd_dvd_plus_r_dl;
+static unsigned cd_dvd_plus_rw_dl;
+static unsigned cd_bd;
+static unsigned cd_bd_r;
+static unsigned cd_bd_re;
+static unsigned cd_hddvd;
+static unsigned cd_hddvd_r;
+static unsigned cd_hddvd_rw;
+static unsigned cd_mo;
+static unsigned cd_mrw;
+static unsigned cd_mrw_w;
/* media info */
-static unsigned int cd_media;
-static unsigned int cd_media_cd_rom;
-static unsigned int cd_media_cd_r;
-static unsigned int cd_media_cd_rw;
-static unsigned int cd_media_dvd_rom;
-static unsigned int cd_media_dvd_r;
-static unsigned int cd_media_dvd_rw;
-static unsigned int cd_media_dvd_rw_ro; /* restricted overwrite mode */
-static unsigned int cd_media_dvd_rw_seq; /* sequential mode */
-static unsigned int cd_media_dvd_ram;
-static unsigned int cd_media_dvd_plus_r;
-static unsigned int cd_media_dvd_plus_rw;
-static unsigned int cd_media_dvd_plus_r_dl;
-static unsigned int cd_media_dvd_plus_rw_dl;
-static unsigned int cd_media_bd;
-static unsigned int cd_media_bd_r;
-static unsigned int cd_media_bd_re;
-static unsigned int cd_media_hddvd;
-static unsigned int cd_media_hddvd_r;
-static unsigned int cd_media_hddvd_rw;
-static unsigned int cd_media_mo;
-static unsigned int cd_media_mrw;
-static unsigned int cd_media_mrw_w;
+static unsigned cd_media;
+static unsigned cd_media_cd_rom;
+static unsigned cd_media_cd_r;
+static unsigned cd_media_cd_rw;
+static unsigned cd_media_dvd_rom;
+static unsigned cd_media_dvd_r;
+static unsigned cd_media_dvd_rw;
+static unsigned cd_media_dvd_rw_ro; /* restricted overwrite mode */
+static unsigned cd_media_dvd_rw_seq; /* sequential mode */
+static unsigned cd_media_dvd_ram;
+static unsigned cd_media_dvd_plus_r;
+static unsigned cd_media_dvd_plus_rw;
+static unsigned cd_media_dvd_plus_r_dl;
+static unsigned cd_media_dvd_plus_rw_dl;
+static unsigned cd_media_bd;
+static unsigned cd_media_bd_r;
+static unsigned cd_media_bd_re;
+static unsigned cd_media_hddvd;
+static unsigned cd_media_hddvd_r;
+static unsigned cd_media_hddvd_rw;
+static unsigned cd_media_mo;
+static unsigned cd_media_mrw;
+static unsigned cd_media_mrw_w;
static const char *cd_media_state = NULL;
-static unsigned int cd_media_session_next;
-static unsigned int cd_media_session_count;
-static unsigned int cd_media_track_count;
-static unsigned int cd_media_track_count_data;
-static unsigned int cd_media_track_count_audio;
+static unsigned cd_media_session_next;
+static unsigned cd_media_session_count;
+static unsigned cd_media_track_count;
+static unsigned cd_media_track_count_data;
+static unsigned cd_media_track_count_audio;
static unsigned long long int cd_media_session_last_offset;
#define ERRCODE(s) ((((s)[2] & 0x0F) << 16) | ((s)[12] << 8) | ((s)[13]))
#define ASC(errcode) (((errcode) >> 8) & 0xFF)
#define ASCQ(errcode) ((errcode) & 0xFF)
-static bool is_mounted(const char *device)
-{
+static bool is_mounted(const char *device) {
struct stat statbuf;
FILE *fp;
int maj, min;
return mounted;
}
-static void info_scsi_cmd_err(struct udev *udev, const char *cmd, int err)
-{
+static void info_scsi_cmd_err(const char *cmd, int err) {
if (err == -1) {
log_debug("%s failed", cmd);
return;
struct sg_io_hdr sg_io;
};
-static void scsi_cmd_init(struct udev *udev, struct scsi_cmd *cmd)
-{
+static void scsi_cmd_init(struct scsi_cmd *cmd) {
memzero(cmd, sizeof(struct scsi_cmd));
cmd->cgc.quiet = 1;
cmd->cgc.sense = &cmd->_sense.s;
cmd->sg_io.flags = SG_FLAG_LUN_INHIBIT | SG_FLAG_DIRECT_IO;
}
-static void scsi_cmd_set(struct udev *udev, struct scsi_cmd *cmd, size_t i, unsigned char arg)
-{
+static void scsi_cmd_set(struct scsi_cmd *cmd, size_t i, unsigned char arg) {
cmd->sg_io.cmd_len = i + 1;
cmd->cgc.cmd[i] = arg;
}
#define CHECK_CONDITION 0x01
-static int scsi_cmd_run(struct udev *udev, struct scsi_cmd *cmd, int fd, unsigned char *buf, size_t bufsize)
-{
+static int scsi_cmd_run(struct scsi_cmd *cmd, int fd, unsigned char *buf, size_t bufsize) {
int ret = 0;
if (bufsize > 0) {
return ret;
}
-static int media_lock(struct udev *udev, int fd, bool lock)
-{
+static int media_lock(int fd, bool lock) {
int err;
/* disable the kernel's lock logic */
return err;
}
-static int media_eject(struct udev *udev, int fd)
-{
+static int media_eject(int fd) {
struct scsi_cmd sc;
int err;
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x1b);
- scsi_cmd_set(udev, &sc, 4, 0x02);
- scsi_cmd_set(udev, &sc, 5, 0);
- err = scsi_cmd_run(udev, &sc, fd, NULL, 0);
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x1b);
+ scsi_cmd_set(&sc, 4, 0x02);
+ scsi_cmd_set(&sc, 5, 0);
+ err = scsi_cmd_run(&sc, fd, NULL, 0);
if ((err != 0)) {
- info_scsi_cmd_err(udev, "START_STOP_UNIT", err);
+ info_scsi_cmd_err("START_STOP_UNIT", err);
return -1;
}
return 0;
}
-static int cd_capability_compat(struct udev *udev, int fd)
-{
+static int cd_capability_compat(int fd) {
int capability;
capability = ioctl(fd, CDROM_GET_CAPABILITY, NULL);
return 0;
}
-static int cd_media_compat(struct udev *udev, int fd)
-{
+static int cd_media_compat(int fd) {
if (ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT) != CDS_DISC_OK) {
log_debug("CDROM_DRIVE_STATUS != CDS_DISC_OK");
return -1;
return 0;
}
-static int cd_inquiry(struct udev *udev, int fd)
-{
+static int cd_inquiry(int fd) {
struct scsi_cmd sc;
unsigned char inq[128];
int err;
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x12);
- scsi_cmd_set(udev, &sc, 4, 36);
- scsi_cmd_set(udev, &sc, 5, 0);
- err = scsi_cmd_run(udev, &sc, fd, inq, 36);
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x12);
+ scsi_cmd_set(&sc, 4, 36);
+ scsi_cmd_set(&sc, 5, 0);
+ err = scsi_cmd_run(&sc, fd, inq, 36);
if ((err != 0)) {
- info_scsi_cmd_err(udev, "INQUIRY", err);
+ info_scsi_cmd_err("INQUIRY", err);
return -1;
}
return 0;
}
-static void feature_profile_media(struct udev *udev, int cur_profile)
-{
+static void feature_profile_media(int cur_profile) {
switch (cur_profile) {
case 0x03:
case 0x04:
}
}
-static int feature_profiles(struct udev *udev, const unsigned char *profiles, size_t size)
-{
- unsigned int i;
+static int feature_profiles(const unsigned char *profiles, size_t size) {
+ unsigned i;
for (i = 0; i+4 <= size; i += 4) {
int profile;
}
/* returns 0 if media was detected */
-static int cd_profiles_old_mmc(struct udev *udev, int fd)
-{
+static int cd_profiles_old_mmc(int fd) {
struct scsi_cmd sc;
int err;
unsigned char header[32];
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x51);
- scsi_cmd_set(udev, &sc, 8, sizeof(header));
- scsi_cmd_set(udev, &sc, 9, 0);
- err = scsi_cmd_run(udev, &sc, fd, header, sizeof(header));
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x51);
+ scsi_cmd_set(&sc, 8, sizeof(header));
+ scsi_cmd_set(&sc, 9, 0);
+ err = scsi_cmd_run(&sc, fd, header, sizeof(header));
if ((err != 0)) {
- info_scsi_cmd_err(udev, "READ DISC INFORMATION", err);
+ info_scsi_cmd_err("READ DISC INFORMATION", err);
if (cd_media == 1) {
log_debug("no current profile, but disc is present; assuming CD-ROM");
cd_media_cd_rom = 1;
}
/* returns 0 if media was detected */
-static int cd_profiles(struct udev *udev, int fd)
-{
+static int cd_profiles(int fd) {
struct scsi_cmd sc;
unsigned char features[65530];
- unsigned int cur_profile = 0;
- unsigned int len;
- unsigned int i;
+ unsigned cur_profile = 0;
+ unsigned len;
+ unsigned i;
int err;
int ret;
ret = -1;
/* First query the current profile */
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x46);
- scsi_cmd_set(udev, &sc, 8, 8);
- scsi_cmd_set(udev, &sc, 9, 0);
- err = scsi_cmd_run(udev, &sc, fd, features, 8);
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x46);
+ scsi_cmd_set(&sc, 8, 8);
+ scsi_cmd_set(&sc, 9, 0);
+ err = scsi_cmd_run(&sc, fd, features, 8);
if ((err != 0)) {
- info_scsi_cmd_err(udev, "GET CONFIGURATION", err);
+ info_scsi_cmd_err("GET CONFIGURATION", err);
/* handle pre-MMC2 drives which do not support GET CONFIGURATION */
- if (SK(err) == 0x5 && (ASC(err) == 0x20 || ASC(err) == 0x24)) {
+ if (SK(err) == 0x5 && IN_SET(ASC(err), 0x20, 0x24)) {
log_debug("drive is pre-MMC2 and does not support 46h get configuration command");
log_debug("trying to work around the problem");
- ret = cd_profiles_old_mmc(udev, fd);
+ ret = cd_profiles_old_mmc(fd);
}
goto out;
}
cur_profile = features[6] << 8 | features[7];
if (cur_profile > 0) {
log_debug("current profile 0x%02x", cur_profile);
- feature_profile_media (udev, cur_profile);
+ feature_profile_media(cur_profile);
ret = 0; /* we have media */
} else {
log_debug("no current profile, assuming no media");
log_debug("GET CONFIGURATION: size of features buffer 0x%04x", len);
if (len > sizeof(features)) {
- log_debug("can not get features in a single query, truncating");
+ log_debug("cannot get features in a single query, truncating");
len = sizeof(features);
} else if (len <= 8)
len = sizeof(features);
/* Now get the full feature buffer */
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x46);
- scsi_cmd_set(udev, &sc, 7, ( len >> 8 ) & 0xff);
- scsi_cmd_set(udev, &sc, 8, len & 0xff);
- scsi_cmd_set(udev, &sc, 9, 0);
- err = scsi_cmd_run(udev, &sc, fd, features, len);
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x46);
+ scsi_cmd_set(&sc, 7, ( len >> 8 ) & 0xff);
+ scsi_cmd_set(&sc, 8, len & 0xff);
+ scsi_cmd_set(&sc, 9, 0);
+ err = scsi_cmd_run(&sc, fd, features, len);
if ((err != 0)) {
- info_scsi_cmd_err(udev, "GET CONFIGURATION", err);
+ info_scsi_cmd_err("GET CONFIGURATION", err);
return -1;
}
log_debug("GET CONFIGURATION: size of features buffer 0x%04x", len);
if (len > sizeof(features)) {
- log_debug("can not get features in a single query, truncating");
+ log_debug("cannot get features in a single query, truncating");
len = sizeof(features);
}
/* device features */
for (i = 8; i+4 < len; i += (4 + features[i+3])) {
- unsigned int feature;
+ unsigned feature;
feature = features[i] << 8 | features[i+1];
switch (feature) {
case 0x00:
log_debug("GET CONFIGURATION: feature 'profiles', with %i entries", features[i+3] / 4);
- feature_profiles(udev, &features[i]+4, MIN(features[i+3], len - i - 4));
+ feature_profiles(&features[i]+4, MIN(features[i+3], len - i - 4));
break;
default:
log_debug("GET CONFIGURATION: feature 0x%04x <ignored>, with 0x%02x bytes", feature, features[i+3]);
return ret;
}
-static int cd_media_info(struct udev *udev, int fd)
-{
+static int cd_media_info(int fd) {
struct scsi_cmd sc;
unsigned char header[32];
- static const char *media_status[] = {
+ static const char *const media_status[] = {
"blank",
"appendable",
"complete",
};
int err;
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x51);
- scsi_cmd_set(udev, &sc, 8, sizeof(header) & 0xff);
- scsi_cmd_set(udev, &sc, 9, 0);
- err = scsi_cmd_run(udev, &sc, fd, header, sizeof(header));
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x51);
+ scsi_cmd_set(&sc, 8, sizeof(header) & 0xff);
+ scsi_cmd_set(&sc, 9, 0);
+ err = scsi_cmd_run(&sc, fd, header, sizeof(header));
if ((err != 0)) {
- info_scsi_cmd_err(udev, "READ DISC INFORMATION", err);
+ info_scsi_cmd_err("READ DISC INFORMATION", err);
return -1;
};
if (!cd_media_cd_rom)
cd_media_state = media_status[header[2] & 3];
- /* fresh DVD-RW in restricted overwite mode reports itself as
+ /* fresh DVD-RW in restricted overwrite mode reports itself as
* "appendable"; change it to "blank" to make it consistent with what
* gets reported after blanking, and what userspace expects */
if (cd_media_dvd_rw_ro && (header[2] & 3) == 1)
unsigned char dvdstruct[8];
unsigned char format[12];
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0xAD);
- scsi_cmd_set(udev, &sc, 7, 0xC0);
- scsi_cmd_set(udev, &sc, 9, sizeof(dvdstruct));
- scsi_cmd_set(udev, &sc, 11, 0);
- err = scsi_cmd_run(udev, &sc, fd, dvdstruct, sizeof(dvdstruct));
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0xAD);
+ scsi_cmd_set(&sc, 7, 0xC0);
+ scsi_cmd_set(&sc, 9, sizeof(dvdstruct));
+ scsi_cmd_set(&sc, 11, 0);
+ err = scsi_cmd_run(&sc, fd, dvdstruct, sizeof(dvdstruct));
if ((err != 0)) {
- info_scsi_cmd_err(udev, "READ DVD STRUCTURE", err);
+ info_scsi_cmd_err("READ DVD STRUCTURE", err);
return -1;
}
if (dvdstruct[4] & 0x02) {
}
/* let's make sure we don't try to read unformatted media */
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x23);
- scsi_cmd_set(udev, &sc, 8, sizeof(format));
- scsi_cmd_set(udev, &sc, 9, 0);
- err = scsi_cmd_run(udev, &sc, fd, format, sizeof(format));
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x23);
+ scsi_cmd_set(&sc, 8, sizeof(format));
+ scsi_cmd_set(&sc, 9, 0);
+ err = scsi_cmd_run(&sc, fd, format, sizeof(format));
if ((err != 0)) {
- info_scsi_cmd_err(udev, "READ DVD FORMAT CAPACITIES", err);
+ info_scsi_cmd_err("READ DVD FORMAT CAPACITIES", err);
return -1;
}
* has "blank" status", DVD-RAM was examined earlier) and check
* for ISO and UDF PVDs or a fs superblock presence and do it
* in one ioctl (we need just sectors 0 and 16) */
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x28);
- scsi_cmd_set(udev, &sc, 5, 0);
- scsi_cmd_set(udev, &sc, 8, 32);
- scsi_cmd_set(udev, &sc, 9, 0);
- err = scsi_cmd_run(udev, &sc, fd, buffer, sizeof(buffer));
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x28);
+ scsi_cmd_set(&sc, 5, 0);
+ scsi_cmd_set(&sc, 8, 32);
+ scsi_cmd_set(&sc, 9, 0);
+ err = scsi_cmd_run(&sc, fd, buffer, sizeof(buffer));
if ((err != 0)) {
cd_media = 0;
- info_scsi_cmd_err(udev, "READ FIRST 32 BLOCKS", err);
+ info_scsi_cmd_err("READ FIRST 32 BLOCKS", err);
return -1;
}
return 0;
}
-static int cd_media_toc(struct udev *udev, int fd)
-{
+static int cd_media_toc(int fd) {
struct scsi_cmd sc;
unsigned char header[12];
unsigned char toc[65536];
- unsigned int len, i, num_tracks;
+ unsigned len, i, num_tracks;
unsigned char *p;
int err;
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x43);
- scsi_cmd_set(udev, &sc, 6, 1);
- scsi_cmd_set(udev, &sc, 8, sizeof(header) & 0xff);
- scsi_cmd_set(udev, &sc, 9, 0);
- err = scsi_cmd_run(udev, &sc, fd, header, sizeof(header));
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x43);
+ scsi_cmd_set(&sc, 6, 1);
+ scsi_cmd_set(&sc, 8, sizeof(header) & 0xff);
+ scsi_cmd_set(&sc, 9, 0);
+ err = scsi_cmd_run(&sc, fd, header, sizeof(header));
if ((err != 0)) {
- info_scsi_cmd_err(udev, "READ TOC", err);
+ info_scsi_cmd_err("READ TOC", err);
return -1;
}
if (len < 8)
return 0;
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x43);
- scsi_cmd_set(udev, &sc, 6, header[2]); /* First Track/Session Number */
- scsi_cmd_set(udev, &sc, 7, (len >> 8) & 0xff);
- scsi_cmd_set(udev, &sc, 8, len & 0xff);
- scsi_cmd_set(udev, &sc, 9, 0);
- err = scsi_cmd_run(udev, &sc, fd, toc, len);
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x43);
+ scsi_cmd_set(&sc, 6, header[2]); /* First Track/Session Number */
+ scsi_cmd_set(&sc, 7, (len >> 8) & 0xff);
+ scsi_cmd_set(&sc, 8, len & 0xff);
+ scsi_cmd_set(&sc, 9, 0);
+ err = scsi_cmd_run(&sc, fd, toc, len);
if ((err != 0)) {
- info_scsi_cmd_err(udev, "READ TOC (tracks)", err);
+ info_scsi_cmd_err("READ TOC (tracks)", err);
return -1;
}
* the TOC, but also avoid going beyond the TOC length, just in case
* the last track number is invalidly large */
for (p = toc+4, i = 4; i < len-8 && num_tracks > 0; i += 8, p += 8, --num_tracks) {
- unsigned int block;
- unsigned int is_data_track;
+ unsigned block;
+ unsigned is_data_track;
is_data_track = (p[1] & 0x04) != 0;
cd_media_track_count_audio++;
}
- scsi_cmd_init(udev, &sc);
- scsi_cmd_set(udev, &sc, 0, 0x43);
- scsi_cmd_set(udev, &sc, 2, 1); /* Session Info */
- scsi_cmd_set(udev, &sc, 8, sizeof(header));
- scsi_cmd_set(udev, &sc, 9, 0);
- err = scsi_cmd_run(udev, &sc, fd, header, sizeof(header));
+ scsi_cmd_init(&sc);
+ scsi_cmd_set(&sc, 0, 0x43);
+ scsi_cmd_set(&sc, 2, 1); /* Session Info */
+ scsi_cmd_set(&sc, 8, sizeof(header));
+ scsi_cmd_set(&sc, 9, 0);
+ err = scsi_cmd_run(&sc, fd, header, sizeof(header));
if ((err != 0)) {
- info_scsi_cmd_err(udev, "READ TOC (multi session)", err);
+ info_scsi_cmd_err("READ TOC (multi session)", err);
return -1;
}
len = header[4+4] << 24 | header[4+5] << 16 | header[4+6] << 8 | header[4+7];
return 0;
}
-int main(int argc, char *argv[])
-{
- struct udev *udev;
+int main(int argc, char *argv[]) {
static const struct option options[] = {
{ "lock-media", no_argument, NULL, 'l' },
{ "unlock-media", no_argument, NULL, 'u' },
int cnt;
int rc = 0;
+ log_set_target(LOG_TARGET_AUTO);
+ udev_parse_config();
log_parse_environment();
log_open();
- udev = udev_new();
- if (udev == NULL)
- goto exit;
-
for (;;) {
int option;
node = argv[optind];
if (!node) {
log_error("no device");
- fprintf(stderr, "no device\n");
rc = 1;
goto exit;
}
}
if (fd < 0) {
log_debug("unable to open '%s'", node);
- fprintf(stderr, "unable to open '%s'\n", node);
rc = 1;
goto exit;
}
log_debug("probing: '%s'", node);
/* same data as original cdrom_id */
- if (cd_capability_compat(udev, fd) < 0) {
+ if (cd_capability_compat(fd) < 0) {
rc = 1;
goto exit;
}
/* check for media - don't bail if there's no media as we still need to
* to read profiles */
- cd_media_compat(udev, fd);
+ cd_media_compat(fd);
/* check if drive talks MMC */
- if (cd_inquiry(udev, fd) < 0)
+ if (cd_inquiry(fd) < 0)
goto work;
/* read drive and possibly current profile */
- if (cd_profiles(udev, fd) != 0)
+ if (cd_profiles(fd) != 0)
goto work;
/* at this point we are guaranteed to have media in the drive - find out more about it */
/* get session/track info */
- cd_media_toc(udev, fd);
+ cd_media_toc(fd);
/* get writable media state */
- cd_media_info(udev, fd);
+ cd_media_info(fd);
work:
/* lock the media, so we enable eject button events */
if (lock && cd_media) {
log_debug("PREVENT_ALLOW_MEDIUM_REMOVAL (lock)");
- media_lock(udev, fd, true);
+ media_lock(fd, true);
}
if (unlock && cd_media) {
log_debug("PREVENT_ALLOW_MEDIUM_REMOVAL (unlock)");
- media_lock(udev, fd, false);
+ media_lock(fd, false);
}
if (eject) {
log_debug("PREVENT_ALLOW_MEDIUM_REMOVAL (unlock)");
- media_lock(udev, fd, false);
+ media_lock(fd, false);
log_debug("START_STOP_UNIT (eject)");
- media_eject(udev, fd);
+ media_eject(fd);
}
printf("ID_CDROM=1\n");
exit:
if (fd >= 0)
close(fd);
- udev_unref(udev);
log_close();
return rc;
}
projects / thirdparty / systemd.git / blobdiff