public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize == 0)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (sectors > ushort.MaxValue)
{
ErrorMessage = "Too many sectors";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return(false);
}
imageInfo = new ImageInfo {
MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors
};
try { writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); }
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
// TODO: Check this
(ushort cylinders, byte heads, ushort sectorsPerTrack, uint bytesPerSector, MediaEncoding encoding, bool
variableSectorsPerTrack, MediaType type)geometry = Geometry.GetGeometry(mediaType);
footer = new DriFooter
{
signature = new byte[51],
bpb = new DriBpb
{
five = 5,
driveCode = DriDriveCodes.mf2ed,
cylinders = geometry.cylinders,
bps = (ushort)imageInfo.SectorSize,
sectors = (ushort)imageInfo.Sectors,
sptrack = (ushort)imageInfo.SectorsPerTrack,
heads = (ushort)imageInfo.Heads,
sptrack2 = (ushort)imageInfo.SectorsPerTrack,
unknown5 = new byte[144]
}
};
Array.Copy(Encoding.ASCII.GetBytes("DiskImage 2.01 (C) 1990,1991 Digital Research Inc"), 0,
footer.signature, 0, 49);
footer.bpbcopy = footer.bpb;
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize != 512)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return(false);
}
imageInfo = new ImageInfo {
MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors
};
try { writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); }
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize == 0)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return(false);
}
imageInfo = new ImageInfo {
MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors
};
try { writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); }
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
basepath = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path));
mediaTags = new Dictionary <MediaTagType, byte[]>();
IsWriting = true;
ErrorMessage = null;
return(true);
}
public async override Task <object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger formatterLogger)
{
try
{
if (!content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = await content.ReadAsMultipartAsync();
var mediacontent = provider.Contents.First(x =>
SupportedMediaTypes.Contains(x.Headers.ContentType));
string fileName = mediacontent.Headers.ContentDisposition.FileName;
string mediaType = mediacontent.Headers.ContentType.MediaType;
var imagebuffer = await mediacontent.ReadAsByteArrayAsync();
return(new ImageMediaModels(fileName, mediaType, imagebuffer));
}
catch (Exception Ex)
{
string Err = "Unable to upload the image ";
Log.LogError("{0}, Error: {1}", Err, Ex.Message);
throw;
}
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return(false);
}
imageInfo = new ImageInfo {
MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors
};
try
{
writingBaseName = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path));
descriptorStream = new StreamWriter(path, false, Encoding.ASCII);
dataStream = new FileStream(writingBaseName + ".img", FileMode.OpenOrCreate, FileAccess.ReadWrite,
FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
imageInfo.MediaType = mediaType;
trackFlags = new Dictionary <byte, byte>();
IsWriting = true;
ErrorMessage = null;
return(true);
}
public async override Task <object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger logger)
{
if (!content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new MultipartMemoryStreamProvider();
var formData = await content.ReadAsMultipartAsync(provider);
var imageContent = formData.Contents
.Where(c => SupportedMediaTypes.Contains(c.Headers.ContentType))
.Select(i => ReadContent(i).Result)
.ToList();
var jsonContent = formData.Contents
.Where(c => !SupportedMediaTypes.Contains(c.Headers.ContentType))
.Select(j => ReadJson(j).Result)
.ToDictionary(x => x.Key, x => x.Value);
var json = JsonConvert.SerializeObject(jsonContent);
var model = JsonConvert.DeserializeObject(json, type) as ImageContentList;
if (model == null)
{
throw new HttpResponseException(HttpStatusCode.NoContent);
}
model.Images = imageContent;
return(model);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (options != null)
{
if (options.TryGetValue("separate", out string tmpValue))
{
if (!bool.TryParse(tmpValue, out separateTracksWriting))
{
ErrorMessage = "Invalid value for split option";
return(false);
}
if (separateTracksWriting)
{
ErrorMessage = "Separate tracksnot yet implemented";
return(false);
}
}
}
else
{
separateTracksWriting = false;
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return(false);
}
imageInfo = new ImageInfo {
MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors
};
// TODO: Separate tracks
try
{
writingBaseName = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path));
descriptorStream = new StreamWriter(path, false, Encoding.ASCII);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
discimage = new CdrWinDisc
{
Disktype = mediaType, Sessions = new List <Session>(), Tracks = new List <CdrWinTrack>()
};
trackFlags = new Dictionary <byte, byte>();
trackIsrcs = new Dictionary <byte, string>();
IsWriting = true;
ErrorMessage = null;
return(true);
}
public override bool CanWriteResult(OutputFormatterCanWriteContext context)
{
var type = context.HttpContext.Request.Headers["accept"];
var ret = SupportedMediaTypes.Contains(type);
ret &= base.CanWriteResult(context);
return(ret);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (CountBits.Count(sectorSize) != 1 || sectorSize > 16384)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (sectors > 90 * 2 * 255)
{
ErrorMessage = "Too many sectors";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return(false);
}
(ushort cylinders, byte heads, ushort sectorsPerTrack, uint bytesPerSector, MediaEncoding encoding, bool
variableSectorsPerTrack, MediaType type)geometry = Geometry.GetGeometry(mediaType);
imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors,
Cylinders = geometry.cylinders,
Heads = geometry.heads,
SectorsPerTrack = geometry.sectorsPerTrack
};
if (imageInfo.Cylinders > 90)
{
ErrorMessage = "Too many cylinders";
return(false);
}
if (imageInfo.Heads > 2)
{
ErrorMessage = "Too many heads";
return(false);
}
try { writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); }
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize == 0)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (sectors > ushort.MaxValue)
{
ErrorMessage = "Too many sectors";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return(false);
}
imageInfo = new ImageInfo
{
MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors
};
try
{
writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
(ushort cylinders, byte heads, ushort sectorsPerTrack, uint bytesPerSector, MediaEncoding encoding, bool
variableSectorsPerTrack, MediaType type)geometry = Geometry.GetGeometry(mediaType);
header = new SaveDskFHeader
{
cylinders = geometry.cylinders, dataOffset = 512, heads = geometry.heads, magic = SDF_MAGIC,
sectorsCopied = (ushort)sectors, sectorsPerTrack = geometry.sectorsPerTrack,
sectorSize = (ushort)sectorSize
};
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize == 0)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (sectors * sectorSize > int.MaxValue ||
sectors > (long)int.MaxValue * 8 * 33)
{
ErrorMessage = "Too many sectors";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
_imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors
};
try
{
_writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
_fdihdr = new Anex86Header
{
hdrSize = 4096,
dskSize = (int)(sectors * sectorSize),
bps = (int)sectorSize
};
IsWriting = true;
ErrorMessage = null;
return(true);
}
public override bool CanRead(InputFormatterContext context)
{
var request = context.HttpContext.Request;
MediaTypeHeaderValue requestContentType = null;
MediaTypeHeaderValue.TryParse(request.ContentType, out requestContentType);
if (requestContentType == null)
{
return(false);
}
return(SupportedMediaTypes.Contains(requestContentType.MediaType));
}
public override bool Accept(ActionConstraintContext context)
{
var requestHeaders = context.RouteContext.HttpContext.Request.Headers;
if (!requestHeaders.ContainsKey(AcceptHeader))
{
return(false);
}
if (!MediaTypeHeaderValue.TryParseList(requestHeaders[AcceptHeader].ToString().Split(','), out var requestedTypes))
{
return(false);
}
return(requestedTypes.Any(requestedType => SupportedMediaTypes.Contains(requestedType.MediaType)));
}
public override bool Accept(ActionConstraintContext context)
{
var requestHeaders = context.RouteContext.HttpContext.Request.Headers;
if (!requestHeaders.ContainsKey(ContentTypeHeader))
{
return(false);
}
if (!MediaTypeHeaderValue.TryParse(requestHeaders[ContentTypeHeader].ToString(), out var contentType))
{
return(false);
}
return(SupportedMediaTypes.Contains(contentType.MediaType));
}
/// <summary>
/// Validates one or more of the specified media types specified in the Accept header are acceptable to this service.
/// </summary>
/// <param name="requestedMediaTypes">The media type(s) from the Accept header in the request.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="requestedMediaTypes"/> is null.</exception>
/// <exception cref="ODataException">Thrown if none of the specified media types are supported by this service.</exception>
public void Validate(IEnumerable <string> requestedMediaTypes)
{
if (requestedMediaTypes is null)
{
throw new ArgumentNullException(nameof(requestedMediaTypes));
}
foreach (string mediaType in requestedMediaTypes)
{
if (SupportedMediaTypes.Contains(mediaType))
{
return;
}
}
throw ODataException.NotAcceptable(ExceptionMessage.MediaTypeNotAcceptable(SupportedMediaTypes, SupportedMetadataLevels, requestedMediaTypes), "Accept");
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize != 512)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
_imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors
};
try
{
_writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
_chunks = new Dictionary <ulong, BlockChunk>();
_currentChunk = new BlockChunk();
_currentSector = 0;
_dataForkChecksum = new Crc32Context();
_masterChecksum = new Crc32Context();
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
_imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors
};
try
{
_dataStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
_imageInfo.MediaType = mediaType;
IsWriting = true;
IsTape = false;
ErrorMessage = null;
_lastWrittenBlock = 0;
_writtenBlockPositions = new Dictionary <ulong, ulong>();
return(true);
}
public override async Task <object> ReadFromStreamAsync(Type type, Stream stream,
HttpContent httpContent,
IFormatterLogger iFormatterLogger)
{
MultipartStreamProvider parts = await httpContent.ReadAsMultipartAsync();
IEnumerable <HttpContent> contents = parts.Contents;
HttpContent content = contents.FirstOrDefault();
foreach (HttpContent c in contents)
{
if (SupportedMediaTypes.Contains(c.Headers.ContentType))
{
content = c;
break;
}
}
using (var msgStream = await content.ReadAsStreamAsync())
{
DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(TenMsg));
TenMsg msg = (TenMsg)js.ReadObject(msgStream);
Debug.WriteLine("msgString: " + msgStream.ToString());
int sender = msg.Sender;
int receiver = msg.Receiver;
byte phoneType = msg.PhoneType;
bool isLocked = msg.IsLocked;
DateTime msgTime = msg.MsgTime;
string msgContent = msg.MsgContent;
Debug.WriteLine("Msg Content: " + msg.MsgContent);
return(new TenMsg(sender, receiver, phoneType, isLocked, msgTime, msgContent));
}
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize == 0)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
_extension = Path.GetExtension(path)?.ToLower();
switch (_extension)
{
case ".1kn" when sectorSize != 1024:
case ".2kn" when sectorSize != 2048:
case ".4kn" when sectorSize != 4096:
case ".8kn" when sectorSize != 8192:
case ".16kn" when sectorSize != 16384:
case ".32kn" when sectorSize != 32768:
case ".64kn" when sectorSize != 65536:
case ".512" when sectorSize != 515:
case ".512e" when sectorSize != 512:
case ".128" when sectorSize != 128:
case ".256" when sectorSize != 256:
case ".iso" when sectorSize != 2048:
ErrorMessage = "The specified sector size does not correspond with the requested image extension.";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
_imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors
};
try
{
_writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
_basePath = Path.Combine(Path.GetDirectoryName(path) ?? "", Path.GetFileNameWithoutExtension(path));
_mediaTags = new Dictionary <MediaTagType, byte[]>();
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
_imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors
};
try
{
_descriptorStream = new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
_imageStream =
new
FileStream(Path.Combine(Path.GetDirectoryName(path) ?? "", Path.GetFileNameWithoutExtension(path)) + ".mdf",
FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
_imageInfo.MediaType = mediaType;
switch (mediaType)
{
case MediaType.CD:
case MediaType.CDDA:
case MediaType.CDEG:
case MediaType.CDG:
case MediaType.CDI:
case MediaType.CDMIDI:
case MediaType.CDMRW:
case MediaType.CDPLUS:
case MediaType.CDR:
case MediaType.CDROM:
case MediaType.CDROMXA:
case MediaType.CDRW:
case MediaType.CDV:
case MediaType.DTSCD:
case MediaType.JaguarCD:
case MediaType.MEGACD:
case MediaType.PS1CD:
case MediaType.PS2CD:
case MediaType.SuperCDROM2:
case MediaType.SVCD:
case MediaType.SATURNCD:
case MediaType.ThreeDO:
case MediaType.VCD:
case MediaType.VCDHD:
case MediaType.NeoGeoCD:
case MediaType.PCFX:
case MediaType.CDTV:
case MediaType.CD32:
case MediaType.Nuon:
case MediaType.Playdia:
case MediaType.Pippin:
case MediaType.FMTOWNS:
case MediaType.MilCD:
case MediaType.VideoNow:
case MediaType.VideoNowColor:
case MediaType.VideoNowXp:
case MediaType.CVD:
_isDvd = false;
break;
default:
_isDvd = true;
break;
}
_trackFlags = new Dictionary <byte, byte>();
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize != 512)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
_imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors
};
try
{
_writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
DiskType diskType;
switch (mediaType)
{
case MediaType.DOS_35_DS_DD_9:
diskType = DiskType.MF2DD;
break;
case MediaType.DOS_35_HD:
diskType = DiskType.MF2HD;
break;
case MediaType.DOS_525_DS_DD_8:
diskType = DiskType.MD2DD8;
break;
case MediaType.DOS_525_DS_DD_9:
diskType = DiskType.MD2DD;
break;
case MediaType.DOS_525_HD:
diskType = DiskType.MD2HD;
break;
case MediaType.DOS_525_SS_DD_8:
diskType = DiskType.MD1DD8;
break;
case MediaType.DOS_525_SS_DD_9:
diskType = DiskType.MD1DD;
break;
default:
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
_writingStream.WriteByte((byte)diskType);
byte tracks = 0;
switch (diskType)
{
case DiskType.MD1DD8:
case DiskType.MD1DD:
case DiskType.MD2DD8:
case DiskType.MD2DD:
tracks = 80;
break;
case DiskType.MF2DD:
case DiskType.MD2HD:
case DiskType.MF2HD:
tracks = 160;
break;
}
int headStep = 1;
if (diskType == DiskType.MD1DD ||
diskType == DiskType.MD1DD8)
{
headStep = 2;
}
for (int i = 0; i < tracks; i += headStep)
{
_writingStream.WriteByte((byte)TrackType.Copied);
if (headStep == 2)
{
_writingStream.WriteByte(0);
}
}
_writingStream.WriteByte((byte)Compression.None);
_writingOffset = _writingStream.Position;
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (options != null)
{
if (options.TryGetValue("separate", out string tmpValue))
{
if (!bool.TryParse(tmpValue, out _separateTracksWriting))
{
ErrorMessage = "Invalid value for split option";
return(false);
}
if (_separateTracksWriting)
{
ErrorMessage = "Separate tracks not yet implemented";
return(false);
}
}
}
else
{
_separateTracksWriting = false;
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
_imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors
};
// TODO: Separate tracks
try
{
_writingBaseName =
Path.Combine(Path.GetDirectoryName(path) ?? "", Path.GetFileNameWithoutExtension(path));
_descriptorStream = new StreamWriter(path, false, Encoding.ASCII);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
_discImage = new CdrWinDisc
{
MediaType = mediaType,
Sessions = new List <Session>(),
Tracks = new List <CdrWinTrack>()
};
int mediaTypeAsInt = (int)_discImage.MediaType;
_isCd = (mediaTypeAsInt >= 10 && mediaTypeAsInt <= 39) || mediaTypeAsInt == 112 || mediaTypeAsInt == 113 ||
(mediaTypeAsInt >= 150 && mediaTypeAsInt <= 152) || mediaTypeAsInt == 154 ||
mediaTypeAsInt == 155 || (mediaTypeAsInt >= 171 && mediaTypeAsInt <= 179) ||
(mediaTypeAsInt >= 740 && mediaTypeAsInt <= 749);
if (_isCd)
{
_trackFlags = new Dictionary <byte, byte>();
_trackIsrcs = new Dictionary <byte, string>();
}
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize != 512)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return(false);
}
// TODO: Correct this calculation
if (sectors * sectorSize / 65536 > uint.MaxValue)
{
ErrorMessage = "Too many sectors for selected cluster size";
return(false);
}
imageInfo = new ImageInfo {
MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors
};
try { writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); }
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
qHdr = new QCowHeader
{
magic = QCOW_MAGIC,
version = QCOW_VERSION,
size = sectors * sectorSize,
cluster_bits = 12,
l2_bits = 9,
l1_table_offset = (ulong)Marshal.SizeOf <QCowHeader>()
};
int shift = qHdr.cluster_bits + qHdr.l2_bits;
clusterSize = 1 << qHdr.cluster_bits;
clusterSectors = 1 << (qHdr.cluster_bits - 9);
l1Size = (uint)((qHdr.size + (ulong)(1 << shift) - 1) >> shift);
l2Size = 1 << qHdr.l2_bits;
l1Table = new ulong[l1Size];
l1Mask = 0;
int c = 0;
l1Shift = qHdr.l2_bits + qHdr.cluster_bits;
for (int i = 0; i < 64; i++)
{
l1Mask <<= 1;
if (c >= 64 - l1Shift)
{
continue;
}
l1Mask += 1;
c++;
}
l2Mask = 0;
for (int i = 0; i < qHdr.l2_bits; i++)
{
l2Mask = (l2Mask << 1) + 1;
}
l2Mask <<= qHdr.cluster_bits;
sectorMask = 0;
for (int i = 0; i < qHdr.cluster_bits; i++)
{
sectorMask = (sectorMask << 1) + 1;
}
byte[] empty = new byte[qHdr.l1_table_offset + l1Size * 8];
writingStream.Write(empty, 0, empty.Length);
IsWriting = true;
ErrorMessage = null;
return(true);
}
/// <inheritdoc />
public override bool CanRead(InputFormatterContext context)
{
var contentType = context.HttpContext.Request.ContentType;
return(SupportedMediaTypes.Contains(contentType) && base.CanRead(context));
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize != 512)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
// TODO: Correct this calculation
if ((sectors * sectorSize) / 65536 > uint.MaxValue)
{
ErrorMessage = "Too many sectors for selected cluster size";
return(false);
}
_imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors
};
try
{
_writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
string extension = Path.GetExtension(path);
bool version3 = extension == ".qcow3" || extension == ".qc3";
_qHdr = new QCow2Header
{
magic = QCOW_MAGIC,
version = version3 ? QCOW_VERSION3 : QCOW_VERSION2,
size = sectors * sectorSize,
cluster_bits = 16,
header_length = (uint)Marshal.SizeOf <QCow2Header>()
};
_clusterSize = 1 << (int)_qHdr.cluster_bits;
_clusterSectors = 1 << ((int)_qHdr.cluster_bits - 9);
_l2Bits = (int)(_qHdr.cluster_bits - 3);
_l2Size = 1 << _l2Bits;
_l1Mask = 0;
int c = 0;
_l1Shift = (int)(_l2Bits + _qHdr.cluster_bits);
for (int i = 0; i < 64; i++)
{
_l1Mask <<= 1;
if (c >= 64 - _l1Shift)
{
continue;
}
_l1Mask += 1;
c++;
}
_l2Mask = 0;
for (int i = 0; i < _l2Bits; i++)
{
_l2Mask = (_l2Mask << 1) + 1;
}
_l2Mask <<= (int)_qHdr.cluster_bits;
_sectorMask = 0;
for (int i = 0; i < _qHdr.cluster_bits; i++)
{
_sectorMask = (_sectorMask << 1) + 1;
}
_qHdr.l1_size = (uint)(_qHdr.size >> _l1Shift);
if (_qHdr.l1_size == 0)
{
_qHdr.l1_size = 1;
}
_l1Table = new ulong[_qHdr.l1_size];
ulong clusters = _qHdr.size / (ulong)_clusterSize;
ulong refCountBlocks = (clusters * 2) / (ulong)_clusterSize;
if (refCountBlocks == 0)
{
refCountBlocks = 1;
}
_qHdr.refcount_table_offset = (ulong)_clusterSize;
_qHdr.refcount_table_clusters = (uint)((refCountBlocks * 8) / (ulong)_clusterSize);
if (_qHdr.refcount_table_clusters == 0)
{
_qHdr.refcount_table_clusters = 1;
}
_refCountTable = new ulong[refCountBlocks];
_qHdr.l1_table_offset = _qHdr.refcount_table_offset + (ulong)(_qHdr.refcount_table_clusters * _clusterSize);
ulong l1TableClusters = (_qHdr.l1_size * 8) / (ulong)_clusterSize;
if (l1TableClusters == 0)
{
l1TableClusters = 1;
}
byte[] empty = new byte[_qHdr.l1_table_offset + (l1TableClusters * (ulong)_clusterSize)];
_writingStream.Write(empty, 0, empty.Length);
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize != 512)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
// TODO: Correct this calculation
if ((sectors * sectorSize) / DEFAULT_CLUSTER_SIZE > uint.MaxValue)
{
ErrorMessage = "Too many sectors for selected cluster size";
return(false);
}
_imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors
};
try
{
_writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
_qHdr = new QedHeader
{
magic = QED_MAGIC,
cluster_size = DEFAULT_CLUSTER_SIZE,
table_size = DEFAULT_TABLE_SIZE,
header_size = 1,
l1_table_offset = DEFAULT_CLUSTER_SIZE,
image_size = sectors * sectorSize
};
_clusterSectors = _qHdr.cluster_size / 512;
_tableSize = (_qHdr.cluster_size * _qHdr.table_size) / 8;
_l1Table = new ulong[_tableSize];
_l1Mask = 0;
int c = 0;
_clusterBits = Ctz32(_qHdr.cluster_size);
_l2Mask = (_tableSize - 1) << _clusterBits;
_l1Shift = _clusterBits + Ctz32(_tableSize);
for (int i = 0; i < 64; i++)
{
_l1Mask <<= 1;
if (c >= 64 - _l1Shift)
{
continue;
}
_l1Mask += 1;
c++;
}
_sectorMask = 0;
for (int i = 0; i < _clusterBits; i++)
{
_sectorMask = (_sectorMask << 1) + 1;
}
byte[] empty = new byte[_qHdr.l1_table_offset + (_tableSize * 8)];
_writingStream.Write(empty, 0, empty.Length);
IsWriting = true;
ErrorMessage = null;
return(true);
}
// TODO: Support extended
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize != 512)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return(false);
}
if ((sectors * sectorSize) / DEFAULT_CLUSTER_SIZE > uint.MaxValue)
{
ErrorMessage = "Too many sectors for selected cluster size";
return(false);
}
imageInfo = new ImageInfo
{
MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors
};
try
{
writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
uint batEntries = (uint)((sectors * sectorSize) / DEFAULT_CLUSTER_SIZE);
if ((sectors * sectorSize) % DEFAULT_CLUSTER_SIZE > 0)
{
batEntries++;
}
uint headerSectors = (uint)Marshal.SizeOf <ParallelsHeader>() + (batEntries * 4);
if ((uint)Marshal.SizeOf <ParallelsHeader>() + (batEntries % 4) > 0)
{
headerSectors++;
}
pHdr = new ParallelsHeader
{
magic = parallelsMagic, version = PARALLELS_VERSION, sectors = sectors,
in_use = PARALLELS_CLOSED,
bat_entries = batEntries, data_off = headerSectors, cluster_size = DEFAULT_CLUSTER_SIZE / 512
};
bat = new uint[batEntries];
currentWritingPosition = headerSectors * 512;
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (sectorSize != 512)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupported media format {mediaType}";
return(false);
}
if (sectors * sectorSize / DEFAULT_BLOCK_SIZE > uint.MaxValue)
{
ErrorMessage = "Too many sectors for selected cluster size";
return(false);
}
_imageInfo = new ImageInfo
{
MediaType = mediaType,
SectorSize = sectorSize,
Sectors = sectors
};
try
{
_writingStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
uint ibmEntries = (uint)(sectors * sectorSize / DEFAULT_BLOCK_SIZE);
if (sectors * sectorSize % DEFAULT_BLOCK_SIZE > 0)
{
ibmEntries++;
}
uint headerSectors = 1 + (ibmEntries * 4 / sectorSize);
if (ibmEntries * 4 % sectorSize != 0)
{
headerSectors++;
}
_ibm = new uint[ibmEntries];
_currentWritingPosition = headerSectors * sectorSize;
_vHdr = new Header
{
creator = DIC_AARU,
magic = VDI_MAGIC,
majorVersion = 1,
minorVersion = 1,
headerSize = Marshal.SizeOf <Header>() - 72,
imageType = VdiImageType.Normal,
offsetBlocks = sectorSize,
offsetData = _currentWritingPosition,
sectorSize = sectorSize,
size = sectors * sectorSize,
blockSize = DEFAULT_BLOCK_SIZE,
blocks = ibmEntries,
uuid = Guid.NewGuid(),
snapshotUuid = Guid.NewGuid()
};
for (uint i = 0; i < ibmEntries; i++)
{
_ibm[i] = VDI_EMPTY;
}
IsWriting = true;
ErrorMessage = null;
return(true);
}
public bool Create(string path, MediaType mediaType, Dictionary <string, string> options, ulong sectors,
uint sectorSize)
{
if (options != null)
{
if (options.TryGetValue("adapter", out adapter_type))
{
switch (adapter_type.ToLowerInvariant())
{
case "ide":
case "lsilogic":
case "buslogic":
adapter_type = adapter_type.ToLowerInvariant();
break;
case "legacyesx":
adapter_type = "legacyESX";
break;
default:
ErrorMessage = $"Invalid adapter type {adapter_type}";
return(false);
}
}
else
{
adapter_type = "ide";
}
if (options.TryGetValue("hwversion", out string tmpValue))
{
if (!uint.TryParse(tmpValue, out hwversion))
{
ErrorMessage = "Invalid value for hwversion option";
return(false);
}
}
else
{
hwversion = 4;
}
if (options.TryGetValue("split", out tmpValue))
{
if (!bool.TryParse(tmpValue, out bool tmpBool))
{
ErrorMessage = "Invalid value for split option";
return(false);
}
if (tmpBool)
{
ErrorMessage = "Splitted images not yet implemented";
return(false);
}
}
if (options.TryGetValue("sparse", out tmpValue))
{
if (!bool.TryParse(tmpValue, out bool tmpBool))
{
ErrorMessage = "Invalid value for sparse option";
return(false);
}
if (tmpBool)
{
ErrorMessage = "Sparse images not yet implemented";
return(false);
}
}
}
else
{
adapter_type = "ide";
hwversion = 4;
}
if (sectorSize != 512)
{
ErrorMessage = "Unsupported sector size";
return(false);
}
if (!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return(false);
}
imageInfo = new ImageInfo {
MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors
};
try
{
writingBaseName = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path));
descriptorStream = new StreamWriter(path, false, Encoding.ASCII);
// TODO: Support split
writingStream = new FileStream(writingBaseName + "-flat.vmdk", FileMode.OpenOrCreate,
FileAccess.ReadWrite, FileShare.None);
}
catch (IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return(false);
}
IsWriting = true;
ErrorMessage = null;
return(true);
}
