]> git.proxmox.com Git - systemd.git/blame - src/udev/cdrom_id/cdrom_id.c
projects / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Upstream version 220
[systemd.git] / src / udev / cdrom_id / cdrom_id.c
CommitLineData
663996b3
MS		 1/*
2 * cdrom_id - optical drive and media information prober
3 *
4 * Copyright (C) 2008-2010 Kay Sievers <kay@vrfy.org>
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20#include <stdio.h>
21#include <stddef.h>
22#include <stdlib.h>
23#include <unistd.h>
24#include <string.h>
25#include <limits.h>
26#include <fcntl.h>
27#include <errno.h>
28#include <getopt.h>
29#include <time.h>
30#include <scsi/sg.h>
31#include <sys/types.h>
32#include <sys/stat.h>
33#include <sys/time.h>
34#include <sys/ioctl.h>
35#include <linux/cdrom.h>
36
37#include "libudev.h"
38#include "libudev-private.h"
e3bff60a 39#include "random-util.h"
663996b3 40
663996b3
MS		 41/* device info */
42static unsigned int cd_cd_rom;
43static unsigned int cd_cd_r;
44static unsigned int cd_cd_rw;
45static unsigned int cd_dvd_rom;
46static unsigned int cd_dvd_r;
47static unsigned int cd_dvd_rw;
48static unsigned int cd_dvd_ram;
49static unsigned int cd_dvd_plus_r;
50static unsigned int cd_dvd_plus_rw;
51static unsigned int cd_dvd_plus_r_dl;
52static unsigned int cd_dvd_plus_rw_dl;
53static unsigned int cd_bd;
54static unsigned int cd_bd_r;
55static unsigned int cd_bd_re;
56static unsigned int cd_hddvd;
57static unsigned int cd_hddvd_r;
58static unsigned int cd_hddvd_rw;
59static unsigned int cd_mo;
60static unsigned int cd_mrw;
61static unsigned int cd_mrw_w;
62
63/* media info */
64static unsigned int cd_media;
65static unsigned int cd_media_cd_rom;
66static unsigned int cd_media_cd_r;
67static unsigned int cd_media_cd_rw;
68static unsigned int cd_media_dvd_rom;
69static unsigned int cd_media_dvd_r;
70static unsigned int cd_media_dvd_rw;
71static unsigned int cd_media_dvd_rw_ro; /* restricted overwrite mode */
72static unsigned int cd_media_dvd_rw_seq; /* sequential mode */
73static unsigned int cd_media_dvd_ram;
74static unsigned int cd_media_dvd_plus_r;
75static unsigned int cd_media_dvd_plus_rw;
76static unsigned int cd_media_dvd_plus_r_dl;
77static unsigned int cd_media_dvd_plus_rw_dl;
78static unsigned int cd_media_bd;
79static unsigned int cd_media_bd_r;
80static unsigned int cd_media_bd_re;
81static unsigned int cd_media_hddvd;
82static unsigned int cd_media_hddvd_r;
83static unsigned int cd_media_hddvd_rw;
84static unsigned int cd_media_mo;
85static unsigned int cd_media_mrw;
86static unsigned int cd_media_mrw_w;
87
88static const char *cd_media_state = NULL;
89static unsigned int cd_media_session_next;
90static unsigned int cd_media_session_count;
91static unsigned int cd_media_track_count;
92static unsigned int cd_media_track_count_data;
93static unsigned int cd_media_track_count_audio;
94static unsigned long long int cd_media_session_last_offset;
95
96#define ERRCODE(s) ((((s)[2] & 0x0F) << 16) | ((s)[12] << 8) | ((s)[13]))
97#define SK(errcode) (((errcode) >> 16) & 0xF)
98#define ASC(errcode) (((errcode) >> 8) & 0xFF)
99#define ASCQ(errcode) ((errcode) & 0xFF)
100
101static bool is_mounted(const char *device)
102{
103 struct stat statbuf;
104 FILE *fp;
105 int maj, min;
106 bool mounted = false;
107
108 if (stat(device, &statbuf) < 0)
109 return -ENODEV;
110
111 fp = fopen("/proc/self/mountinfo", "re");
112 if (fp == NULL)
113 return -ENOSYS;
114 while (fscanf(fp, "%*s %*s %i:%i %*[^\n]", &maj, &min) == 2) {
115 if (makedev(maj, min) == statbuf.st_rdev) {
116 mounted = true;
117 break;
118 }
119 }
120 fclose(fp);
121 return mounted;
122}
123
124static void info_scsi_cmd_err(struct udev *udev, const char *cmd, int err)
125{
126 if (err == -1) {
60f067b4 127 log_debug("%s failed", cmd);
663996b3
MS		 128 return;
129 }
60f067b4 130 log_debug("%s failed with SK=%Xh/ASC=%02Xh/ACQ=%02Xh", cmd, SK(err), ASC(err), ASCQ(err));
663996b3
MS		 131}
132
133struct scsi_cmd {
134 struct cdrom_generic_command cgc;
135 union {
136 struct request_sense s;
137 unsigned char u[18];
138 } _sense;
139 struct sg_io_hdr sg_io;
140};
141
142static void scsi_cmd_init(struct udev *udev, struct scsi_cmd *cmd)
143{
60f067b4 144 memzero(cmd, sizeof(struct scsi_cmd));
663996b3
MS		 145 cmd->cgc.quiet = 1;
146 cmd->cgc.sense = &cmd->_sense.s;
147 cmd->sg_io.interface_id = 'S';
148 cmd->sg_io.mx_sb_len = sizeof(cmd->_sense);
149 cmd->sg_io.cmdp = cmd->cgc.cmd;
150 cmd->sg_io.sbp = cmd->_sense.u;
151 cmd->sg_io.flags = SG_FLAG_LUN_INHIBIT | SG_FLAG_DIRECT_IO;
152}
153
154static void scsi_cmd_set(struct udev *udev, struct scsi_cmd *cmd, size_t i, unsigned char arg)
155{
156 cmd->sg_io.cmd_len = i + 1;
157 cmd->cgc.cmd[i] = arg;
158}
159
160#define CHECK_CONDITION 0x01
161
162static int scsi_cmd_run(struct udev *udev, struct scsi_cmd *cmd, int fd, unsigned char *buf, size_t bufsize)
163{
164 int ret = 0;
165
166 if (bufsize > 0) {
167 cmd->sg_io.dxferp = buf;
168 cmd->sg_io.dxfer_len = bufsize;
169 cmd->sg_io.dxfer_direction = SG_DXFER_FROM_DEV;
170 } else {
171 cmd->sg_io.dxfer_direction = SG_DXFER_NONE;
172 }
173 if (ioctl(fd, SG_IO, &cmd->sg_io))
174 return -1;
175
176 if ((cmd->sg_io.info & SG_INFO_OK_MASK) != SG_INFO_OK) {
177 errno = EIO;
178 ret = -1;
179 if (cmd->sg_io.masked_status & CHECK_CONDITION) {
180 ret = ERRCODE(cmd->_sense.u);
181 if (ret == 0)
182 ret = -1;
183 }
184 }
185 return ret;
186}
187
188static int media_lock(struct udev *udev, int fd, bool lock)
189{
190 int err;
191
192 /* disable the kernel's lock logic */
193 err = ioctl(fd, CDROM_CLEAR_OPTIONS, CDO_LOCK);
194 if (err < 0)
60f067b4 195 log_debug("CDROM_CLEAR_OPTIONS, CDO_LOCK failed");
663996b3
MS		 196
197 err = ioctl(fd, CDROM_LOCKDOOR, lock ? 1 : 0);
198 if (err < 0)
60f067b4 199 log_debug("CDROM_LOCKDOOR failed");
663996b3
MS		 200
201 return err;
202}
203
204static int media_eject(struct udev *udev, int fd)
205{
206 struct scsi_cmd sc;
207 int err;
208
209 scsi_cmd_init(udev, &sc);
210 scsi_cmd_set(udev, &sc, 0, 0x1b);
211 scsi_cmd_set(udev, &sc, 4, 0x02);
212 scsi_cmd_set(udev, &sc, 5, 0);
213 err = scsi_cmd_run(udev, &sc, fd, NULL, 0);
214 if ((err != 0)) {
215 info_scsi_cmd_err(udev, "START_STOP_UNIT", err);
216 return -1;
217 }
218 return 0;
219}
220
221static int cd_capability_compat(struct udev *udev, int fd)
222{
223 int capability;
224
225 capability = ioctl(fd, CDROM_GET_CAPABILITY, NULL);
226 if (capability < 0) {
60f067b4 227 log_debug("CDROM_GET_CAPABILITY failed");
663996b3
MS		 228 return -1;
229 }
230
231 if (capability & CDC_CD_R)
232 cd_cd_r = 1;
233 if (capability & CDC_CD_RW)
234 cd_cd_rw = 1;
235 if (capability & CDC_DVD)
236 cd_dvd_rom = 1;
237 if (capability & CDC_DVD_R)
238 cd_dvd_r = 1;
239 if (capability & CDC_DVD_RAM)
240 cd_dvd_ram = 1;
241 if (capability & CDC_MRW)
242 cd_mrw = 1;
243 if (capability & CDC_MRW_W)
244 cd_mrw_w = 1;
245 return 0;
246}
247
248static int cd_media_compat(struct udev *udev, int fd)
249{
250 if (ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT) != CDS_DISC_OK) {
60f067b4 251 log_debug("CDROM_DRIVE_STATUS != CDS_DISC_OK");
663996b3
MS		 252 return -1;
253 }
254 cd_media = 1;
255 return 0;
256}
257
258static int cd_inquiry(struct udev *udev, int fd)
259{
260 struct scsi_cmd sc;
261 unsigned char inq[128];
262 int err;
263
264 scsi_cmd_init(udev, &sc);
265 scsi_cmd_set(udev, &sc, 0, 0x12);
266 scsi_cmd_set(udev, &sc, 4, 36);
267 scsi_cmd_set(udev, &sc, 5, 0);
268 err = scsi_cmd_run(udev, &sc, fd, inq, 36);
269 if ((err != 0)) {
270 info_scsi_cmd_err(udev, "INQUIRY", err);
271 return -1;
272 }
273
274 if ((inq[0] & 0x1F) != 5) {
60f067b4 275 log_debug("not an MMC unit");
663996b3
MS		 276 return -1;
277 }
278
60f067b4 279 log_debug("INQUIRY: [%.8s][%.16s][%.4s]", inq + 8, inq + 16, inq + 32);
663996b3
MS		 280 return 0;
281}
282
283static void feature_profile_media(struct udev *udev, int cur_profile)
284{
285 switch (cur_profile) {
286 case 0x03:
287 case 0x04:
288 case 0x05:
60f067b4 289 log_debug("profile 0x%02x ", cur_profile);
663996b3
MS		 290 cd_media = 1;
291 cd_media_mo = 1;
292 break;
293 case 0x08:
60f067b4 294 log_debug("profile 0x%02x media_cd_rom", cur_profile);
663996b3
MS		 295 cd_media = 1;
296 cd_media_cd_rom = 1;
297 break;
298 case 0x09:
60f067b4 299 log_debug("profile 0x%02x media_cd_r", cur_profile);
663996b3
MS		 300 cd_media = 1;
301 cd_media_cd_r = 1;
302 break;
303 case 0x0a:
60f067b4 304 log_debug("profile 0x%02x media_cd_rw", cur_profile);
663996b3
MS		 305 cd_media = 1;
306 cd_media_cd_rw = 1;
307 break;
308 case 0x10:
60f067b4 309 log_debug("profile 0x%02x media_dvd_ro", cur_profile);
663996b3
MS		 310 cd_media = 1;
311 cd_media_dvd_rom = 1;
312 break;
313 case 0x11:
60f067b4 314 log_debug("profile 0x%02x media_dvd_r", cur_profile);
663996b3
MS		 315 cd_media = 1;
316 cd_media_dvd_r = 1;
317 break;
318 case 0x12:
60f067b4 319 log_debug("profile 0x%02x media_dvd_ram", cur_profile);
663996b3
MS		 320 cd_media = 1;
321 cd_media_dvd_ram = 1;
322 break;
323 case 0x13:
60f067b4 324 log_debug("profile 0x%02x media_dvd_rw_ro", cur_profile);
663996b3
MS		 325 cd_media = 1;
326 cd_media_dvd_rw = 1;
327 cd_media_dvd_rw_ro = 1;
328 break;
329 case 0x14:
60f067b4 330 log_debug("profile 0x%02x media_dvd_rw_seq", cur_profile);
663996b3
MS		 331 cd_media = 1;
332 cd_media_dvd_rw = 1;
333 cd_media_dvd_rw_seq = 1;
334 break;
335 case 0x1B:
60f067b4 336 log_debug("profile 0x%02x media_dvd_plus_r", cur_profile);
663996b3
MS		 337 cd_media = 1;
338 cd_media_dvd_plus_r = 1;
339 break;
340 case 0x1A:
60f067b4 341 log_debug("profile 0x%02x media_dvd_plus_rw", cur_profile);
663996b3
MS		 342 cd_media = 1;
343 cd_media_dvd_plus_rw = 1;
344 break;
345 case 0x2A:
60f067b4 346 log_debug("profile 0x%02x media_dvd_plus_rw_dl", cur_profile);
663996b3
MS		 347 cd_media = 1;
348 cd_media_dvd_plus_rw_dl = 1;
349 break;
350 case 0x2B:
60f067b4 351 log_debug("profile 0x%02x media_dvd_plus_r_dl", cur_profile);
663996b3
MS		 352 cd_media = 1;
353 cd_media_dvd_plus_r_dl = 1;
354 break;
355 case 0x40:
60f067b4 356 log_debug("profile 0x%02x media_bd", cur_profile);
663996b3
MS		 357 cd_media = 1;
358 cd_media_bd = 1;
359 break;
360 case 0x41:
361 case 0x42:
60f067b4 362 log_debug("profile 0x%02x media_bd_r", cur_profile);
663996b3
MS		 363 cd_media = 1;
364 cd_media_bd_r = 1;
365 break;
366 case 0x43:
60f067b4 367 log_debug("profile 0x%02x media_bd_re", cur_profile);
663996b3
MS		 368 cd_media = 1;
369 cd_media_bd_re = 1;
370 break;
371 case 0x50:
60f067b4 372 log_debug("profile 0x%02x media_hddvd", cur_profile);
663996b3
MS		 373 cd_media = 1;
374 cd_media_hddvd = 1;
375 break;
376 case 0x51:
60f067b4 377 log_debug("profile 0x%02x media_hddvd_r", cur_profile);
663996b3
MS		 378 cd_media = 1;
379 cd_media_hddvd_r = 1;
380 break;
381 case 0x52:
60f067b4 382 log_debug("profile 0x%02x media_hddvd_rw", cur_profile);
663996b3
MS		 383 cd_media = 1;
384 cd_media_hddvd_rw = 1;
385 break;
386 default:
60f067b4 387 log_debug("profile 0x%02x <ignored>", cur_profile);
663996b3
MS		 388 break;
389 }
390}
391
392static int feature_profiles(struct udev *udev, const unsigned char *profiles, size_t size)
393{
394 unsigned int i;
395
396 for (i = 0; i+4 <= size; i += 4) {
397 int profile;
398
399 profile = profiles[i] << 8 | profiles[i+1];
400 switch (profile) {
401 case 0x03:
402 case 0x04:
403 case 0x05:
60f067b4 404 log_debug("profile 0x%02x mo", profile);
663996b3
MS		 405 cd_mo = 1;
406 break;
407 case 0x08:
60f067b4 408 log_debug("profile 0x%02x cd_rom", profile);
663996b3
MS		 409 cd_cd_rom = 1;
410 break;
411 case 0x09:
60f067b4 412 log_debug("profile 0x%02x cd_r", profile);
663996b3
MS		 413 cd_cd_r = 1;
414 break;
415 case 0x0A:
60f067b4 416 log_debug("profile 0x%02x cd_rw", profile);
663996b3
MS		 417 cd_cd_rw = 1;
418 break;
419 case 0x10:
60f067b4 420 log_debug("profile 0x%02x dvd_rom", profile);
663996b3
MS		 421 cd_dvd_rom = 1;
422 break;
423 case 0x12:
60f067b4 424 log_debug("profile 0x%02x dvd_ram", profile);
663996b3
MS		 425 cd_dvd_ram = 1;
426 break;
427 case 0x13:
428 case 0x14:
60f067b4 429 log_debug("profile 0x%02x dvd_rw", profile);
663996b3
MS		 430 cd_dvd_rw = 1;
431 break;
432 case 0x1B:
60f067b4 433 log_debug("profile 0x%02x dvd_plus_r", profile);
663996b3
MS		 434 cd_dvd_plus_r = 1;
435 break;
436 case 0x1A:
60f067b4 437 log_debug("profile 0x%02x dvd_plus_rw", profile);
663996b3
MS		 438 cd_dvd_plus_rw = 1;
439 break;
440 case 0x2A:
60f067b4 441 log_debug("profile 0x%02x dvd_plus_rw_dl", profile);
663996b3
MS		 442 cd_dvd_plus_rw_dl = 1;
443 break;
444 case 0x2B:
60f067b4 445 log_debug("profile 0x%02x dvd_plus_r_dl", profile);
663996b3
MS		 446 cd_dvd_plus_r_dl = 1;
447 break;
448 case 0x40:
449 cd_bd = 1;
60f067b4 450 log_debug("profile 0x%02x bd", profile);
663996b3
MS		 451 break;
452 case 0x41:
453 case 0x42:
454 cd_bd_r = 1;
60f067b4 455 log_debug("profile 0x%02x bd_r", profile);
663996b3
MS		 456 break;
457 case 0x43:
458 cd_bd_re = 1;
60f067b4 459 log_debug("profile 0x%02x bd_re", profile);
663996b3
MS		 460 break;
461 case 0x50:
462 cd_hddvd = 1;
60f067b4 463 log_debug("profile 0x%02x hddvd", profile);
663996b3
MS		 464 break;
465 case 0x51:
466 cd_hddvd_r = 1;
60f067b4 467 log_debug("profile 0x%02x hddvd_r", profile);
663996b3
MS		 468 break;
469 case 0x52:
470 cd_hddvd_rw = 1;
60f067b4 471 log_debug("profile 0x%02x hddvd_rw", profile);
663996b3
MS		 472 break;
473 default:
60f067b4 474 log_debug("profile 0x%02x <ignored>", profile);
663996b3
MS		 475 break;
476 }
477 }
478 return 0;
479}
480
481/* returns 0 if media was detected */
482static int cd_profiles_old_mmc(struct udev *udev, int fd)
483{
484 struct scsi_cmd sc;
485 int err;
486
487 unsigned char header[32];
488
489 scsi_cmd_init(udev, &sc);
490 scsi_cmd_set(udev, &sc, 0, 0x51);
491 scsi_cmd_set(udev, &sc, 8, sizeof(header));
492 scsi_cmd_set(udev, &sc, 9, 0);
493 err = scsi_cmd_run(udev, &sc, fd, header, sizeof(header));
494 if ((err != 0)) {
495 info_scsi_cmd_err(udev, "READ DISC INFORMATION", err);
496 if (cd_media == 1) {
60f067b4 497 log_debug("no current profile, but disc is present; assuming CD-ROM");
663996b3
MS		 498 cd_media_cd_rom = 1;
499 cd_media_track_count = 1;
500 cd_media_track_count_data = 1;
501 return 0;
502 } else {
60f067b4 503 log_debug("no current profile, assuming no media");
663996b3
MS		 504 return -1;
505 }
506 };
507
508 cd_media = 1;
509
510 if (header[2] & 16) {
511 cd_media_cd_rw = 1;
60f067b4 512 log_debug("profile 0x0a media_cd_rw");
663996b3
MS		 513 } else if ((header[2] & 3) < 2 && cd_cd_r) {
514 cd_media_cd_r = 1;
60f067b4 515 log_debug("profile 0x09 media_cd_r");
663996b3
MS		 516 } else {
517 cd_media_cd_rom = 1;
60f067b4 518 log_debug("profile 0x08 media_cd_rom");
663996b3
MS		 519 }
520 return 0;
521}
522
523/* returns 0 if media was detected */
524static int cd_profiles(struct udev *udev, int fd)
525{
526 struct scsi_cmd sc;
527 unsigned char features[65530];
528 unsigned int cur_profile = 0;
529 unsigned int len;
530 unsigned int i;
531 int err;
532 int ret;
533
534 ret = -1;
535
536 /* First query the current profile */
537 scsi_cmd_init(udev, &sc);
538 scsi_cmd_set(udev, &sc, 0, 0x46);
539 scsi_cmd_set(udev, &sc, 8, 8);
540 scsi_cmd_set(udev, &sc, 9, 0);
541 err = scsi_cmd_run(udev, &sc, fd, features, 8);
542 if ((err != 0)) {
543 info_scsi_cmd_err(udev, "GET CONFIGURATION", err);
544 /* handle pre-MMC2 drives which do not support GET CONFIGURATION */
60f067b4
JS		 545 if (SK(err) == 0x5 && (ASC(err) == 0x20 || ASC(err) == 0x24)) {
546 log_debug("drive is pre-MMC2 and does not support 46h get configuration command");
547 log_debug("trying to work around the problem");
663996b3
MS		 548 ret = cd_profiles_old_mmc(udev, fd);
549 }
550 goto out;
551 }
552
553 cur_profile = features[6] << 8 | features[7];
554 if (cur_profile > 0) {
60f067b4 555 log_debug("current profile 0x%02x", cur_profile);
663996b3
MS		 556 feature_profile_media (udev, cur_profile);
557 ret = 0; /* we have media */
558 } else {
60f067b4 559 log_debug("no current profile, assuming no media");
663996b3
MS		 560 }
561
562 len = features[0] << 24 | features[1] << 16 | features[2] << 8 | features[3];
60f067b4 563 log_debug("GET CONFIGURATION: size of features buffer 0x%04x", len);
663996b3
MS		 564
565 if (len > sizeof(features)) {
60f067b4 566 log_debug("can not get features in a single query, truncating");
663996b3
MS		 567 len = sizeof(features);
568 } else if (len <= 8) {
569 len = sizeof(features);
570 }
571
572 /* Now get the full feature buffer */
573 scsi_cmd_init(udev, &sc);
574 scsi_cmd_set(udev, &sc, 0, 0x46);
575 scsi_cmd_set(udev, &sc, 7, ( len >> 8 ) & 0xff);
576 scsi_cmd_set(udev, &sc, 8, len & 0xff);
577 scsi_cmd_set(udev, &sc, 9, 0);
578 err = scsi_cmd_run(udev, &sc, fd, features, len);
579 if ((err != 0)) {
580 info_scsi_cmd_err(udev, "GET CONFIGURATION", err);
581 return -1;
582 }
583
584 /* parse the length once more, in case the drive decided to have other features suddenly :) */
585 len = features[0] << 24 | features[1] << 16 | features[2] << 8 | features[3];
60f067b4 586 log_debug("GET CONFIGURATION: size of features buffer 0x%04x", len);
663996b3
MS		 587
588 if (len > sizeof(features)) {
60f067b4 589 log_debug("can not get features in a single query, truncating");
663996b3
MS		 590 len = sizeof(features);
591 }
592
593 /* device features */
594 for (i = 8; i+4 < len; i += (4 + features[i+3])) {
595 unsigned int feature;
596
597 feature = features[i] << 8 | features[i+1];
598
599 switch (feature) {
600 case 0x00:
60f067b4 601 log_debug("GET CONFIGURATION: feature 'profiles', with %i entries", features[i+3] / 4);
5eef597e 602 feature_profiles(udev, &features[i]+4, MIN(features[i+3], len - i - 4));
663996b3
MS		 603 break;
604 default:
60f067b4 605 log_debug("GET CONFIGURATION: feature 0x%04x <ignored>, with 0x%02x bytes", feature, features[i+3]);
663996b3
MS		 606 break;
607 }
608 }
609out:
610 return ret;
611}
612
613static int cd_media_info(struct udev *udev, int fd)
614{
615 struct scsi_cmd sc;
616 unsigned char header[32];
617 static const char *media_status[] = {
618 "blank",
619 "appendable",
620 "complete",
621 "other"
622 };
623 int err;
624
625 scsi_cmd_init(udev, &sc);
626 scsi_cmd_set(udev, &sc, 0, 0x51);
627 scsi_cmd_set(udev, &sc, 8, sizeof(header) & 0xff);
628 scsi_cmd_set(udev, &sc, 9, 0);
629 err = scsi_cmd_run(udev, &sc, fd, header, sizeof(header));
630 if ((err != 0)) {
631 info_scsi_cmd_err(udev, "READ DISC INFORMATION", err);
632 return -1;
633 };
634
635 cd_media = 1;
60f067b4
JS		 636 log_debug("disk type %02x", header[8]);
637 log_debug("hardware reported media status: %s", media_status[header[2] & 3]);
663996b3
MS		 638
639 /* exclude plain CDROM, some fake cdroms return 0 for "blank" media here */
640 if (!cd_media_cd_rom)
641 cd_media_state = media_status[header[2] & 3];
642
643 /* fresh DVD-RW in restricted overwite mode reports itself as
644 * "appendable"; change it to "blank" to make it consistent with what
645 * gets reported after blanking, and what userspace expects */
646 if (cd_media_dvd_rw_ro && (header[2] & 3) == 1)
647 cd_media_state = media_status[0];
648
649 /* DVD+RW discs (and DVD-RW in restricted mode) once formatted are
650 * always "complete", DVD-RAM are "other" or "complete" if the disc is
651 * write protected; we need to check the contents if it is blank */
652 if ((cd_media_dvd_rw_ro || cd_media_dvd_plus_rw || cd_media_dvd_plus_rw_dl || cd_media_dvd_ram) && (header[2] & 3) > 1) {
653 unsigned char buffer[32 * 2048];
e3bff60a
MP		 654 unsigned char len;
655 int offset;
663996b3
MS		 656
657 if (cd_media_dvd_ram) {
658 /* a write protected dvd-ram may report "complete" status */
659
660 unsigned char dvdstruct[8];
661 unsigned char format[12];
662
663 scsi_cmd_init(udev, &sc);
664 scsi_cmd_set(udev, &sc, 0, 0xAD);
665 scsi_cmd_set(udev, &sc, 7, 0xC0);
666 scsi_cmd_set(udev, &sc, 9, sizeof(dvdstruct));
667 scsi_cmd_set(udev, &sc, 11, 0);
668 err = scsi_cmd_run(udev, &sc, fd, dvdstruct, sizeof(dvdstruct));
669 if ((err != 0)) {
670 info_scsi_cmd_err(udev, "READ DVD STRUCTURE", err);
671 return -1;
672 }
673 if (dvdstruct[4] & 0x02) {
674 cd_media_state = media_status[2];
60f067b4 675 log_debug("write-protected DVD-RAM media inserted");
663996b3
MS		 676 goto determined;
677 }
678
679 /* let's make sure we don't try to read unformatted media */
680 scsi_cmd_init(udev, &sc);
681 scsi_cmd_set(udev, &sc, 0, 0x23);
682 scsi_cmd_set(udev, &sc, 8, sizeof(format));
683 scsi_cmd_set(udev, &sc, 9, 0);
684 err = scsi_cmd_run(udev, &sc, fd, format, sizeof(format));
685 if ((err != 0)) {
686 info_scsi_cmd_err(udev, "READ DVD FORMAT CAPACITIES", err);
687 return -1;
688 }
689
690 len = format[3];
691 if (len & 7 || len < 16) {
60f067b4 692 log_debug("invalid format capacities length");
663996b3
MS		 693 return -1;
694 }
695
696 switch(format[8] & 3) {
697 case 1:
60f067b4 698 log_debug("unformatted DVD-RAM media inserted");
663996b3
MS		 699 /* This means that last format was interrupted
700 * or failed, blank dvd-ram discs are factory
701 * formatted. Take no action here as it takes
702 * quite a while to reformat a dvd-ram and it's
703 * not automatically started */
704 goto determined;
705
706 case 2:
60f067b4 707 log_debug("formatted DVD-RAM media inserted");
663996b3
MS		 708 break;
709
710 case 3:
711 cd_media = 0; //return no media
60f067b4 712 log_debug("format capacities returned no media");
663996b3
MS		 713 return -1;
714 }
715 }
716
717 /* Take a closer look at formatted media (unformatted DVD+RW
718 * has "blank" status", DVD-RAM was examined earlier) and check
719 * for ISO and UDF PVDs or a fs superblock presence and do it
720 * in one ioctl (we need just sectors 0 and 16) */
721 scsi_cmd_init(udev, &sc);
722 scsi_cmd_set(udev, &sc, 0, 0x28);
723 scsi_cmd_set(udev, &sc, 5, 0);
724 scsi_cmd_set(udev, &sc, 8, 32);
725 scsi_cmd_set(udev, &sc, 9, 0);
726 err = scsi_cmd_run(udev, &sc, fd, buffer, sizeof(buffer));
727 if ((err != 0)) {
728 cd_media = 0;
729 info_scsi_cmd_err(udev, "READ FIRST 32 BLOCKS", err);
730 return -1;
731 }
732
733 /* if any non-zero data is found in sector 16 (iso and udf) or
734 * eventually 0 (fat32 boot sector, ext2 superblock, etc), disc
735 * is assumed non-blank */
663996b3 736
e3bff60a
MP		 737 for (offset = 32768; offset < (32768 + 2048); offset++) {
738 if (buffer [offset]) {
739 log_debug("data in block 16, assuming complete");
740 goto determined;
663996b3
MS		 741 }
742 }
743
e3bff60a
MP		 744 for (offset = 0; offset < 2048; offset++) {
745 if (buffer [offset]) {
746 log_debug("data in block 0, assuming complete");
747 goto determined;
748 }
663996b3 749 }
e3bff60a
MP		 750
751 cd_media_state = media_status[0];
752 log_debug("no data in blocks 0 or 16, assuming blank");
663996b3
MS		 753 }
754
755determined:
756 /* "other" is e. g. DVD-RAM, can't append sessions there; DVDs in
757 * restricted overwrite mode can never append, only in sequential mode */
758 if ((header[2] & 3) < 2 && !cd_media_dvd_rw_ro)
759 cd_media_session_next = header[10] << 8 | header[5];
760 cd_media_session_count = header[9] << 8 | header[4];
761 cd_media_track_count = header[11] << 8 | header[6];
762
763 return 0;
764}
765
766static int cd_media_toc(struct udev *udev, int fd)
767{
768 struct scsi_cmd sc;
769 unsigned char header[12];
770 unsigned char toc[65536];
771 unsigned int len, i, num_tracks;
772 unsigned char *p;
773 int err;
774
775 scsi_cmd_init(udev, &sc);
776 scsi_cmd_set(udev, &sc, 0, 0x43);
777 scsi_cmd_set(udev, &sc, 6, 1);
778 scsi_cmd_set(udev, &sc, 8, sizeof(header) & 0xff);
779 scsi_cmd_set(udev, &sc, 9, 0);
780 err = scsi_cmd_run(udev, &sc, fd, header, sizeof(header));
781 if ((err != 0)) {
782 info_scsi_cmd_err(udev, "READ TOC", err);
783 return -1;
784 }
785
786 len = (header[0] << 8 | header[1]) + 2;
60f067b4 787 log_debug("READ TOC: len: %d, start track: %d, end track: %d", len, header[2], header[3]);
663996b3
MS		 788 if (len > sizeof(toc))
789 return -1;
790 if (len < 2)
791 return -1;
792 /* 2: first track, 3: last track */
793 num_tracks = header[3] - header[2] + 1;
794
795 /* empty media has no tracks */
796 if (len < 8)
797 return 0;
798
799 scsi_cmd_init(udev, &sc);
800 scsi_cmd_set(udev, &sc, 0, 0x43);
801 scsi_cmd_set(udev, &sc, 6, header[2]); /* First Track/Session Number */
802 scsi_cmd_set(udev, &sc, 7, (len >> 8) & 0xff);
803 scsi_cmd_set(udev, &sc, 8, len & 0xff);
804 scsi_cmd_set(udev, &sc, 9, 0);
805 err = scsi_cmd_run(udev, &sc, fd, toc, len);
806 if ((err != 0)) {
807 info_scsi_cmd_err(udev, "READ TOC (tracks)", err);
808 return -1;
809 }
810
811 /* Take care to not iterate beyond the last valid track as specified in
812 * the TOC, but also avoid going beyond the TOC length, just in case
813 * the last track number is invalidly large */
814 for (p = toc+4, i = 4; i < len-8 && num_tracks > 0; i += 8, p += 8, --num_tracks) {
815 unsigned int block;
816 unsigned int is_data_track;
817
818 is_data_track = (p[1] & 0x04) != 0;
819
820 block = p[4] << 24 | p[5] << 16 | p[6] << 8 | p[7];
60f067b4 821 log_debug("track=%u info=0x%x(%s) start_block=%u",
663996b3
MS		 822 p[2], p[1] & 0x0f, is_data_track ? "data":"audio", block);
823
824 if (is_data_track)
825 cd_media_track_count_data++;
826 else
827 cd_media_track_count_audio++;
828 }
829
830 scsi_cmd_init(udev, &sc);
831 scsi_cmd_set(udev, &sc, 0, 0x43);
832 scsi_cmd_set(udev, &sc, 2, 1); /* Session Info */
833 scsi_cmd_set(udev, &sc, 8, sizeof(header));
834 scsi_cmd_set(udev, &sc, 9, 0);
835 err = scsi_cmd_run(udev, &sc, fd, header, sizeof(header));
836 if ((err != 0)) {
837 info_scsi_cmd_err(udev, "READ TOC (multi session)", err);
838 return -1;
839 }
840 len = header[4+4] << 24 | header[4+5] << 16 | header[4+6] << 8 | header[4+7];
60f067b4 841 log_debug("last track %u starts at block %u", header[4+2], len);
663996b3
MS		 842 cd_media_session_last_offset = (unsigned long long int)len * 2048;
843 return 0;
844}
845
846int main(int argc, char *argv[])
847{
848 struct udev *udev;
849 static const struct option options[] = {
850 { "lock-media", no_argument, NULL, 'l' },
851 { "unlock-media", no_argument, NULL, 'u' },
852 { "eject-media", no_argument, NULL, 'e' },
853 { "debug", no_argument, NULL, 'd' },
854 { "help", no_argument, NULL, 'h' },
855 {}
856 };
857 bool eject = false;
858 bool lock = false;
859 bool unlock = false;
860 const char *node = NULL;
861 int fd = -1;
862 int cnt;
863 int rc = 0;
864
5eef597e
MP		 865 log_parse_environment();
866 log_open();
867
663996b3
MS		 868 udev = udev_new();
869 if (udev == NULL)
870 goto exit;
871
663996b3
MS		 872 while (1) {
873 int option;
874
875 option = getopt_long(argc, argv, "deluh", options, NULL);
876 if (option == -1)
877 break;
878
879 switch (option) {
880 case 'l':
881 lock = true;
882 break;
883 case 'u':
884 unlock = true;
885 break;
886 case 'e':
887 eject = true;
888 break;
889 case 'd':
5eef597e 890 log_set_target(LOG_TARGET_CONSOLE);
663996b3 891 log_set_max_level(LOG_DEBUG);
5eef597e 892 log_open();
663996b3
MS		 893 break;
894 case 'h':
895 printf("Usage: cdrom_id [options] <device>\n"
e735f4d4
MP		 896 " -l,--lock-media lock the media (to enable eject request events)\n"
897 " -u,--unlock-media unlock the media\n"
898 " -e,--eject-media eject the media\n"
899 " -d,--debug debug to stderr\n"
900 " -h,--help print this help text\n\n");
663996b3
MS		 901 goto exit;
902 default:
903 rc = 1;
904 goto exit;
905 }
906 }
907
908 node = argv[optind];
909 if (!node) {
60f067b4 910 log_error("no device");
663996b3
MS		 911 fprintf(stderr, "no device\n");
912 rc = 1;
913 goto exit;
914 }
915
f47781d8 916 initialize_srand();
663996b3
MS		 917 for (cnt = 20; cnt > 0; cnt--) {
918 struct timespec duration;
919
60f067b4 920 fd = open(node, O_RDONLY|O_NONBLOCK|O_CLOEXEC|(is_mounted(node) ? 0 : O_EXCL));
663996b3
MS		 921 if (fd >= 0 || errno != EBUSY)
922 break;
923 duration.tv_sec = 0;
924 duration.tv_nsec = (100 * 1000 * 1000) + (rand() % 100 * 1000 * 1000);
925 nanosleep(&duration, NULL);
926 }
927 if (fd < 0) {
60f067b4 928 log_debug("unable to open '%s'", node);
663996b3
MS		 929 fprintf(stderr, "unable to open '%s'\n", node);
930 rc = 1;
931 goto exit;
932 }
60f067b4 933 log_debug("probing: '%s'", node);
663996b3
MS		 934
935 /* same data as original cdrom_id */
936 if (cd_capability_compat(udev, fd) < 0) {
937 rc = 1;
938 goto exit;
939 }
940
941 /* check for media - don't bail if there's no media as we still need to
942 * to read profiles */
943 cd_media_compat(udev, fd);
944
945 /* check if drive talks MMC */
946 if (cd_inquiry(udev, fd) < 0)
947 goto work;
948
949 /* read drive and possibly current profile */
950 if (cd_profiles(udev, fd) != 0)
951 goto work;
952
953 /* at this point we are guaranteed to have media in the drive - find out more about it */
954
955 /* get session/track info */
956 cd_media_toc(udev, fd);
957
958 /* get writable media state */
959 cd_media_info(udev, fd);
960
961work:
962 /* lock the media, so we enable eject button events */
963 if (lock && cd_media) {
60f067b4 964 log_debug("PREVENT_ALLOW_MEDIUM_REMOVAL (lock)");
663996b3
MS		 965 media_lock(udev, fd, true);
966 }
967
968 if (unlock && cd_media) {
60f067b4 969 log_debug("PREVENT_ALLOW_MEDIUM_REMOVAL (unlock)");
663996b3
MS		 970 media_lock(udev, fd, false);
971 }
972
973 if (eject) {
60f067b4 974 log_debug("PREVENT_ALLOW_MEDIUM_REMOVAL (unlock)");
663996b3 975 media_lock(udev, fd, false);
60f067b4 976 log_debug("START_STOP_UNIT (eject)");
663996b3
MS		 977 media_eject(udev, fd);
978 }
979
980 printf("ID_CDROM=1\n");
981 if (cd_cd_rom)
982 printf("ID_CDROM_CD=1\n");
983 if (cd_cd_r)
984 printf("ID_CDROM_CD_R=1\n");
985 if (cd_cd_rw)
986 printf("ID_CDROM_CD_RW=1\n");
987 if (cd_dvd_rom)
988 printf("ID_CDROM_DVD=1\n");
989 if (cd_dvd_r)
990 printf("ID_CDROM_DVD_R=1\n");
991 if (cd_dvd_rw)
992 printf("ID_CDROM_DVD_RW=1\n");
993 if (cd_dvd_ram)
994 printf("ID_CDROM_DVD_RAM=1\n");
995 if (cd_dvd_plus_r)
996 printf("ID_CDROM_DVD_PLUS_R=1\n");
997 if (cd_dvd_plus_rw)
998 printf("ID_CDROM_DVD_PLUS_RW=1\n");
999 if (cd_dvd_plus_r_dl)
1000 printf("ID_CDROM_DVD_PLUS_R_DL=1\n");
1001 if (cd_dvd_plus_rw_dl)
1002 printf("ID_CDROM_DVD_PLUS_RW_DL=1\n");
1003 if (cd_bd)
1004 printf("ID_CDROM_BD=1\n");
1005 if (cd_bd_r)
1006 printf("ID_CDROM_BD_R=1\n");
1007 if (cd_bd_re)
1008 printf("ID_CDROM_BD_RE=1\n");
1009 if (cd_hddvd)
1010 printf("ID_CDROM_HDDVD=1\n");
1011 if (cd_hddvd_r)
1012 printf("ID_CDROM_HDDVD_R=1\n");
1013 if (cd_hddvd_rw)
1014 printf("ID_CDROM_HDDVD_RW=1\n");
1015 if (cd_mo)
1016 printf("ID_CDROM_MO=1\n");
1017 if (cd_mrw)
1018 printf("ID_CDROM_MRW=1\n");
1019 if (cd_mrw_w)
1020 printf("ID_CDROM_MRW_W=1\n");
1021
1022 if (cd_media)
1023 printf("ID_CDROM_MEDIA=1\n");
1024 if (cd_media_mo)
1025 printf("ID_CDROM_MEDIA_MO=1\n");
1026 if (cd_media_mrw)
1027 printf("ID_CDROM_MEDIA_MRW=1\n");
1028 if (cd_media_mrw_w)
1029 printf("ID_CDROM_MEDIA_MRW_W=1\n");
1030 if (cd_media_cd_rom)
1031 printf("ID_CDROM_MEDIA_CD=1\n");
1032 if (cd_media_cd_r)
1033 printf("ID_CDROM_MEDIA_CD_R=1\n");
1034 if (cd_media_cd_rw)
1035 printf("ID_CDROM_MEDIA_CD_RW=1\n");
1036 if (cd_media_dvd_rom)
1037 printf("ID_CDROM_MEDIA_DVD=1\n");
1038 if (cd_media_dvd_r)
1039 printf("ID_CDROM_MEDIA_DVD_R=1\n");
1040 if (cd_media_dvd_ram)
1041 printf("ID_CDROM_MEDIA_DVD_RAM=1\n");
1042 if (cd_media_dvd_rw)
1043 printf("ID_CDROM_MEDIA_DVD_RW=1\n");
1044 if (cd_media_dvd_plus_r)
1045 printf("ID_CDROM_MEDIA_DVD_PLUS_R=1\n");
1046 if (cd_media_dvd_plus_rw)
1047 printf("ID_CDROM_MEDIA_DVD_PLUS_RW=1\n");
1048 if (cd_media_dvd_plus_rw_dl)
1049 printf("ID_CDROM_MEDIA_DVD_PLUS_RW_DL=1\n");
1050 if (cd_media_dvd_plus_r_dl)
1051 printf("ID_CDROM_MEDIA_DVD_PLUS_R_DL=1\n");
1052 if (cd_media_bd)
1053 printf("ID_CDROM_MEDIA_BD=1\n");
1054 if (cd_media_bd_r)
1055 printf("ID_CDROM_MEDIA_BD_R=1\n");
1056 if (cd_media_bd_re)
1057 printf("ID_CDROM_MEDIA_BD_RE=1\n");
1058 if (cd_media_hddvd)
1059 printf("ID_CDROM_MEDIA_HDDVD=1\n");
1060 if (cd_media_hddvd_r)
1061 printf("ID_CDROM_MEDIA_HDDVD_R=1\n");
1062 if (cd_media_hddvd_rw)
1063 printf("ID_CDROM_MEDIA_HDDVD_RW=1\n");
1064
1065 if (cd_media_state != NULL)
1066 printf("ID_CDROM_MEDIA_STATE=%s\n", cd_media_state);
1067 if (cd_media_session_next > 0)
e735f4d4 1068 printf("ID_CDROM_MEDIA_SESSION_NEXT=%u\n", cd_media_session_next);
663996b3 1069 if (cd_media_session_count > 0)
e735f4d4 1070 printf("ID_CDROM_MEDIA_SESSION_COUNT=%u\n", cd_media_session_count);
663996b3
MS		 1071 if (cd_media_session_count > 1 && cd_media_session_last_offset > 0)
1072 printf("ID_CDROM_MEDIA_SESSION_LAST_OFFSET=%llu\n", cd_media_session_last_offset);
1073 if (cd_media_track_count > 0)
e735f4d4 1074 printf("ID_CDROM_MEDIA_TRACK_COUNT=%u\n", cd_media_track_count);
663996b3 1075 if (cd_media_track_count_audio > 0)
e735f4d4 1076 printf("ID_CDROM_MEDIA_TRACK_COUNT_AUDIO=%u\n", cd_media_track_count_audio);
663996b3 1077 if (cd_media_track_count_data > 0)
e735f4d4 1078 printf("ID_CDROM_MEDIA_TRACK_COUNT_DATA=%u\n", cd_media_track_count_data);
663996b3
MS		 1079exit:
1080 if (fd >= 0)
1081 close(fd);
1082 udev_unref(udev);
1083 log_close();
1084 return rc;
1085}
systemd for Proxmox projects