/// <summary>
/// Assocated a sink with a given type of message
/// </summary>
/// <param name="c">the category of message</param>
/// <param name="s">the sink for this category of message</param>
public void SetSink(UserMessage.Category c, Sink s)
{
lock (m_lock_object)
{
m_sinks[c] = s;
}
}
/// <summary>
/// Log the message to the console
/// </summary>
/// <param name="m">the message</param>
public override void LogMessage(UserMessage m)
{
if (m.Code == 0)
System.Console.WriteLine(m.MType.ToString() + ": " + m.Text);
else
System.Console.WriteLine(m.MType.ToString() + " " + m.Code.ToString() + ": " + m.Text);
}
/// <summary>
/// Return the sink given the type of message
/// </summary>
/// <param name="c">the type of sink</param>
/// <returns>the sink associated with the message type</returns>
public Sink GetSink(UserMessage.Category c)
{
Sink s = null;
lock (m_lock_object)
{
m_sinks.TryGetValue(c, out s);
}
return s;
}
/// <summary>
///
/// </summary>
/// <param name="m"></param>
public override void LogMessage(UserMessage m)
{
lock (m_lock)
{
m_list.Add(m);
}
if (MessageAdded != null)
{
MessageAddedArgs args = new MessageAddedArgs(m);
MessageAdded(this, args);
}
}
/// <summary>
/// Log a message to the receiving sinks
/// </summary>
/// <param name="m">the message</param>
public override void LogMessage(UserMessage m)
{
foreach (Sink s in m_sinks)
s.LogMessage(m);
}
/// <summary>
/// This method scans the current machine for all CDROM devices found in the system.
/// </summary>
public void ScanForDevices()
{
if (BeforeScan != null)
{
DeviceManagerRescanArgs args = new DeviceManagerRescanArgs();
BeforeScan(this, args);
}
m_logger.LogMessage(new UserMessage(UserMessage.Category.Debug, 0, "Scanning for devices ... ")) ;
OperatingSystem os = Environment.OSVersion;
m_logger.LogMessage(new UserMessage(UserMessage.Category.Info, 0, "Operating System: " + os.ToString()));
m_logger.LogMessage(new UserMessage(UserMessage.Category.Info, 0, "Platform: " + os.Platform.ToString()));
int ossize = 32 ;
if (IntPtr.Size == 8)
ossize = 64 ;
m_logger.LogMessage(new UserMessage(UserMessage.Category.Debug, 0, "OS Word Size: " + ossize.ToString())) ;
m_devices_found.Clear();
for (int i = 0; i < 100; i++)
{
uint dlev = (uint)((i > 5) ? 9 : 8);
string name = "\\\\.\\CDROM" + i.ToString();
m_logger.LogMessage(new UserMessage(UserMessage.Category.Debug, dlev, "Checking device " + name + " ... "));
Device dev = new Device(m_logger) ;
if (!dev.Open(name))
{
m_logger.LogMessage(new UserMessage(UserMessage.Category.Debug, dlev, " ... device open failed"));
continue ;
}
string letter = GetLetterFromDeviceName(name);
DeviceInfo info = DeviceInfo.CreateDevice(name, letter);
if (!info.ExtractInfo(dev))
{
m_logger.LogMessage(new UserMessage(UserMessage.Category.Debug, dlev, " ... cannot extract inquiry information from the drive"));
string str = "The drive '" + letter + "' (" + name + ") is a CD/DVD driver, but is not a valid MMC device.";
m_logger.LogMessage(new UserMessage(UserMessage.Category.Error, 0, str));
str = "This drive is not supported by BwgBurn and is probably an older device.";
m_logger.LogMessage(new UserMessage(UserMessage.Category.Error, 0, str));
continue;
}
m_logger.LogMessage(new UserMessage(UserMessage.Category.Debug, dlev, " ... device added to device list"));
m_devices_found.Add(info) ;
dev.Close() ;
}
if (AfterScan != null)
{
DeviceManagerRescanArgs args = new DeviceManagerRescanArgs();
AfterScan(this, args);
}
string devlist = string.Empty;
foreach (DeviceInfo info in m_devices_found)
{
if (devlist.Length > 0)
devlist += ", ";
devlist += info.ShortDesc;
}
m_logger.LogMessage(new UserMessage(UserMessage.Category.Debug, 0, "Found devices ... " + devlist));
foreach (DeviceInfo info in m_devices_found)
{
UserMessage m = new UserMessage(UserMessage.Category.Debug, 6, "Found Device: " + info.DeviceLetter) ;
m_logger.LogMessage(m);
m = new UserMessage(UserMessage.Category.Debug, 6, " NT Name = " + info.DeviceName);
m_logger.LogMessage(m);
m = new UserMessage(UserMessage.Category.Debug, 6, " Vendor = " + info.InquiryData.VendorIdentification.Trim());
m_logger.LogMessage(m);
m = new UserMessage(UserMessage.Category.Debug, 6, " Product = " + info.InquiryData.ProductIdentification.Trim());
m_logger.LogMessage(m);
m = new UserMessage(UserMessage.Category.Debug, 6, " Revision = " + info.InquiryData.ProductRevision.Trim());
m_logger.LogMessage(m);
}
}
/// <summary>
/// Log the message
/// </summary>
/// <param name="m">the message to log</param>
public override void LogMessage(UserMessage m)
{
if (m_writer != null)
m_writer.WriteLine(m.ToString());
}
/// <summary> /// This method sends a message to a sink. /// </summary> /// <param name="m"></param> abstract public void LogMessage(UserMessage m);
/// <summary>
/// Given the category, this method returns the current
/// level for this type of message
/// </summary>
/// <param name="c">the type of message</param>
/// <returns>the current level</returns>
public int GetLevel(UserMessage.Category c)
{
int ret = 0;
lock (m_lock_object)
{
if (m_level.ContainsKey(c))
ret = m_level[c];
}
return ret;
}
/// <summary>
/// Dump a data buffer to the log file, used for debugging
/// </summary>
/// <param name="loglevel">the log level</param>
/// <param name="title">the title</param>
/// <param name="buffer">the buffer</param>
/// <param name="size">the buffer size</param>
public void DumpBuffer(uint loglevel, string title, IntPtr buffer, int size)
{
UserMessage m;
m = new UserMessage(UserMessage.Category.Debug, loglevel, "Dumping data for structure '" + title + "'");
LogMessage(m);
int index = 0;
int linebytes = 0;
string str = string.Empty;
while (index < size)
{
if (linebytes == 16)
{
m = new UserMessage(UserMessage.Category.Debug, loglevel, str);
LogMessage(m);
linebytes = 0;
str = string.Empty;
}
byte b = Marshal.ReadByte(buffer, index++);
str += b.ToString("X2") + " ";
linebytes++;
}
if (linebytes != 0)
{
m = new UserMessage(UserMessage.Category.Debug, loglevel, str);
LogMessage(m);
}
}
/// <summary>
/// Log a message
/// </summary>
/// <param name="m">the message to log</param>
public void LogMessage(UserMessage m)
{
lock (m_lock_object)
{
if (m_sinks.ContainsKey(m.MType))
{
int level = 0;
if (m_level.ContainsKey(m.MType))
level = m_level[m.MType];
if (m.Level <= level)
{
Sink s = m_sinks[m.MType];
s.LogMessage(m);
}
}
}
}
/// <summary>
/// This function returns TRUE if the logger has a message sink for the given
/// category of message. Otherwise it returns FALSE.
/// </summary>
/// <param name="c">the category of interest</param>
/// <returns>true if a sink is present, false otherwise</returns>
public bool HasSink(UserMessage.Category c)
{
return m_sinks.Keys.Contains(c);
}
/// <summary>
/// Remove the sink associated with a specific category of message.
/// </summary>
/// <param name="c">the category of message</param>
public void RemoveSink(UserMessage.Category c)
{
lock (m_lock_object)
{
m_sinks.Remove(c);
}
}
/// <summary>
///
/// </summary>
/// <param name="m"></param>
public MessageAddedArgs(UserMessage m)
{
AddedMessage = m;
}
/// <summary>
/// Sets a level, below which messages are filtered
/// </summary>
/// <param name="c">the category to filter</param>
/// <param name="level">the level to display</param>
public void SetLevel(UserMessage.Category c, int level)
{
lock (m_lock_object)
{
m_level[c] = level;
}
}
/// <summary>
/// Send the sense information to the logger
/// </summary>
private void LogSenseInformation(Command cmd)
{
if (m_ignore_long_write_error && IsLongWriteInProgress(GetSenseAsc(), GetSenseAscq()))
return;
if (m_logger != null && LogSenseState)
{
int len = GetSenseLength();
int offset = 0;
int line = 0;
UserMessage m;
string str;
Logger logger = GetLogger();
str = "SCSI Operation Failed: " ;
str += LookupSenseError(GetSenseAsc(), GetSenseAscq()) ;
m = new UserMessage(UserMessage.Category.Error, 0, str);
m_logger.LogMessage(m);
str = " SenseKey = " + GetSenseKey().ToString("X");
m = new UserMessage(UserMessage.Category.Error, 0, str);
m_logger.LogMessage(m);
str = " SenseAsc = " + GetSenseAsc().ToString("X");
m = new UserMessage(UserMessage.Category.Error, 0, str);
m_logger.LogMessage(m);
str = " SenseAscq = " + GetSenseAscq().ToString("X");
m = new UserMessage(UserMessage.Category.Error, 0, str);
m_logger.LogMessage(m);
while (offset < len)
{
line = 0;
str = " SenseData:";
while (offset < len && line < 8)
{
str += " " + GetSenseByte(offset++).ToString("X2");
line++;
}
m = new UserMessage(UserMessage.Category.Error, 0, str);
logger.LogMessage(m);
}
if (GetSenseAsc() == 0x24 && GetSenseAscq() == 0x00)
{
// This is invalid field in CDB, so dump the CDB to the log
str = "INVALID CDB:";
for (byte i = 0; i < cmd.GetCDBLength(); i++)
{
byte b = cmd.GetCDB(i);
str += " " + b.ToString("X");
}
m = new UserMessage(UserMessage.Category.Error, 0, str);
m_logger.LogMessage(m);
}
}
}
/// <summary> /// This method sends a message to a sink. /// </summary> /// <param name="m"></param> abstract public void LogMessage(UserMessage m);
