public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
requestStream.ReadUInt8(); // Pad
ushort volumeId = requestStream.ReadUInt16();
uint fileId = requestStream.ReadUInt32();
AfpFileDirectoryBitmap fileBitmap = requestStream.ReadEnum <AfpFileDirectoryBitmap>();
IAfpVolume volume = session.GetVolume(volumeId);
if (volume == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageFile item = volume.GetNode(fileId) as IStorageFile;
if (item == null)
{
return(AfpResultCode.FPObjectNotFound);
}
responseStream.WriteEnum(fileBitmap);
responseStream.WriteStorageFileInfo(volume, item, fileBitmap, false);
return(AfpResultCode.FPNoErr);
}
public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
requestStream.ReadUInt8(); // Pad
AfpVolumeBitmap volumeBitmap = requestStream.ReadEnum <AfpVolumeBitmap>();
string volumeName = requestStream.ReadPascalString();
IStorageProvider provider = session.Server.Shares
.Where(s => s.Name == volumeName)
.FirstOrDefault();
if (provider == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IAfpVolume volume = session.OpenVolume(provider);
if (volume == null)
{
return(AfpResultCode.FPAccessDenied);
}
responseStream.WriteEnum(volumeBitmap);
responseStream.WriteVolumeInfo(volume, volumeBitmap);
return(AfpResultCode.FPNoErr);
}
public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
byte hardCreate = requestStream.ReadUInt8();
ushort volumeId = requestStream.ReadUInt16();
uint directoryId = requestStream.ReadUInt32();
AfpPathType pathType = requestStream.ReadEnum <AfpPathType>();
string pathName = null;
switch (pathType)
{
case AfpPathType.kFPLongName:
case AfpPathType.kFPShortName:
pathName = requestStream.ReadPascalString();
break;
case AfpPathType.kFPUTF8Name:
pathName = requestStream.ReadUTF8StringWithHint();
break;
}
IAfpVolume volume = session.GetVolume(volumeId);
if (volume == null)
{
throw new StorageItemNotFoundException();
}
IStorageContainer container = null;
if (directoryId == 2)
{
container = volume.StorageProvider;
}
else
{
container = (volume.GetNode(directoryId) as IStorageContainer);
}
if (container == null)
{
throw new StorageItemNotFoundException();
}
IStorageFile existingFile = container.Content(pathName) as IStorageFile;
if (existingFile != null && hardCreate == 0)
{
return(AfpResultCode.FPObjectExists);
}
IStorageFile newFile = container.CreateFile(pathName);
return(AfpResultCode.FPNoErr);
}
public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
requestStream.ReadUInt8(); // Padding
ushort volumeId = requestStream.ReadUInt16();
uint directoryId = requestStream.ReadUInt32();
AfpPathType pathType = requestStream.ReadEnum <AfpPathType>();
string pathName = null;
switch (pathType)
{
case AfpPathType.kFPLongName:
case AfpPathType.kFPShortName:
pathName = requestStream.ReadPascalString();
break;
case AfpPathType.kFPUTF8Name:
pathName = requestStream.ReadUTF8StringWithHint();
break;
}
IAfpVolume volume = session.GetVolume(volumeId);
if (volume == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageContainer container = null;
if (directoryId == 2)
{
container = volume.StorageProvider;
}
else
{
container = (volume.GetNode(directoryId) as IStorageContainer);
}
if (container == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageContainer newContainer = container.CreateContainer(pathName);
uint newContainerId = volume.GetNode(newContainer);
responseStream.WriteUInt32(newContainerId);
return(AfpResultCode.FPNoErr);
}
public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
requestStream.ReadUInt8(); // Padding
ushort volumeId = requestStream.ReadUInt16();
IAfpVolume volume = session.GetVolume(volumeId);
if (volume == null)
{
return(AfpResultCode.FPObjectNotFound);
}
volume.Close();
return(AfpResultCode.FPNoErr);
}
public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
requestStream.ReadUInt8(); // Pad
ushort volumeId = requestStream.ReadUInt16();
AfpVolumeBitmap bitmap = requestStream.ReadEnum <AfpVolumeBitmap>();
IAfpVolume volume = session.GetVolume(volumeId);
if (volume == null)
{
return(AfpResultCode.FPObjectNotFound);
}
responseStream.WriteEnum(bitmap);
responseStream.WriteVolumeInfo(volume, bitmap);
return(AfpResultCode.FPNoErr);
}
public void WriteVolumeInfo(IAfpVolume volume, AfpVolumeBitmap bitmap)
{
this.BeginMarking();
foreach (AfpVolumeBitmap flag in bitmap.EnumerateFlags())
{
switch (flag)
{
case AfpVolumeBitmap.kFPVolAttributeBit:
AfpVolumeAttributesBitmap volBitmap =
AfpVolumeAttributesBitmap.kSupportsUTF8Names |
AfpVolumeAttributesBitmap.kSupportsACLs |
AfpVolumeAttributesBitmap.kSupportsFileIDs |
AfpVolumeAttributesBitmap.kSupportsTMLockSteal;
ISearchable searchable = (volume.StorageProvider as ISearchable);
if (searchable != null && searchable.SearchProvider != null)
{
volBitmap |= AfpVolumeAttributesBitmap.kSupportsCatSearch;
}
this.WriteEnum <AfpVolumeAttributesBitmap>(volBitmap);
break;
case AfpVolumeBitmap.kFPVolSignatureBit:
this.WriteUInt16(2); // Fixed directory ID
break;
case AfpVolumeBitmap.kFPVolCreateDateBit:
case AfpVolumeBitmap.kFPVolModDateBit:
case AfpVolumeBitmap.kFPVolBackupDateBit:
this.WriteMacintoshDate(DateTime.Now);
break;
case AfpVolumeBitmap.kFPVolIDBit:
this.WriteUInt16(volume.Identifier);
break;
case AfpVolumeBitmap.kFPVolBytesFreeBit:
this.WriteUInt32((uint)volume.StorageProvider.AvailableBytes);
break;
case AfpVolumeBitmap.kFPVolBytesTotalBit:
this.WriteUInt32((uint)volume.StorageProvider.TotalBytes);
break;
case AfpVolumeBitmap.kFPVolNameBit:
this.WriteMark("Name");
break;
case AfpVolumeBitmap.kFPVolExtBytesFreeBit:
this.WriteUInt64(volume.StorageProvider.AvailableBytes);
break;
case AfpVolumeBitmap.kFPVolExtBytesTotalBit:
this.WriteUInt64(volume.StorageProvider.TotalBytes);
break;
case AfpVolumeBitmap.kFPVolBlockSizeBit:
this.WriteUInt32(4096); // I guess?
break;
}
}
foreach (AfpVolumeBitmap flag in bitmap.EnumerateFlags())
{
switch (flag)
{
case AfpVolumeBitmap.kFPVolNameBit:
this.BeginMark("Name");
this.WritePascalString(volume.StorageProvider.Name);
break;
}
}
this.EndMarking();
}
public void WriteStorageFileInfo(IAfpVolume volume, IStorageFile file, AfpFileDirectoryBitmap bitmap, bool writeFileByte = true)
{
if (writeFileByte)
{
this.WriteUInt8(0);
}
while ((this.Stream.Length % 2) != 0)
{
this.WriteUInt8(0);
}
this.BeginMarking();
foreach (AfpFileDirectoryBitmap flag in bitmap.EnumerateFlags())
{
switch (flag)
{
case AfpFileDirectoryBitmap.kFPAttributeBit:
AfpFileDirectoryAttributes attrs = 0;
if ((file.Attributes & StorageItemAttributes.Hidden) != 0)
{
attrs |= AfpFileDirectoryAttributes.kFPInvisibleBit;
}
this.WriteEnum <AfpFileDirectoryAttributes>(attrs);
break;
case AfpFileDirectoryBitmap.kFPParentDirIDBit:
if (file.Parent == null)
{
this.WriteUInt32(1);
}
else if (file.Parent is IStorageProvider)
{
this.WriteUInt32(2);
}
else
{
this.WriteUInt32(volume.GetNode(file.Parent));
}
break;
case AfpFileDirectoryBitmap.kFPCreateDateBit:
this.WriteMacintoshDate(file.DateCreated);
break;
case AfpFileDirectoryBitmap.kFPModDateBit:
this.WriteMacintoshDate(file.DateModified);
break;
case AfpFileDirectoryBitmap.kFPBackupDateBit:
this.WriteUInt32(0x80000000);
break;
case AfpFileDirectoryBitmap.kFPFinderInfoBit:
this.WriteBytes(new byte[32]);
break;
case AfpFileDirectoryBitmap.kFPLongNameBit:
this.WriteMark("LongName");
break;
case AfpFileDirectoryBitmap.kFPShortNameBit:
this.WriteMark("ShortName");
break;
case AfpFileDirectoryBitmap.kFPUTF8NameBit:
this.WriteMark("UTF8Name");
this.WriteBytes(new byte[4]);
break;
case AfpFileDirectoryBitmap.kFPNodeIDBit:
this.WriteUInt32(volume.GetNode(file));
break;
case AfpFileDirectoryBitmap.kFPAccessRightsBit:
this.WriteEnum <AfpAccessRightsBitmap>(AfpAccessRightsBitmap.All);
break;
case AfpFileDirectoryBitmap.kFPExtDataForkLenBit:
this.WriteUInt64((ulong)file.Length);
break;
case AfpFileDirectoryBitmap.kFPDataForkLenBit:
this.WriteUInt32((uint)file.Length);
break;
case AfpFileDirectoryBitmap.kFPRsrcForkLenBit:
this.WriteUInt32(0);
break;
case AfpFileDirectoryBitmap.kFPExtRsrcForkLenBit:
this.WriteUInt64(0);
break;
default:
Console.WriteLine("Unrecog file flag: {0}", flag);
break;
}
}
foreach (AfpFileDirectoryBitmap flag in bitmap.EnumerateFlags())
{
switch (flag)
{
case AfpFileDirectoryBitmap.kFPLongNameBit:
this.BeginMark("LongName");
this.WritePascalString(file.Name, 32);
break;
case AfpFileDirectoryBitmap.kFPShortNameBit:
this.BeginMark("ShortName");
this.WritePascalString(file.Name, 12);
break;
case AfpFileDirectoryBitmap.kFPUTF8NameBit:
this.BeginMark("UTF8Name");
this.WriteUTF8StringWithHint(file.Name);
break;
}
}
this.EndMarking();
}
public void WriteStorageContainerInfo(IAfpVolume volume, IStorageContainer container, AfpFileDirectoryBitmap bitmap)
{
this.WriteUInt8(1 << 7);
while ((this.Stream.Length % 2) != 0)
{
this.WriteUInt8(0);
}
this.BeginMarking();
foreach (AfpFileDirectoryBitmap flag in bitmap.EnumerateFlags())
{
switch (flag)
{
case AfpFileDirectoryBitmap.kFPAttributeBit:
AfpFileDirectoryAttributes attrs = 0;
if ((container.Attributes & StorageItemAttributes.Hidden) != 0)
{
attrs |= AfpFileDirectoryAttributes.kFPInvisibleBit;
}
this.WriteEnum <AfpFileDirectoryAttributes>(attrs);
break;
case AfpFileDirectoryBitmap.kFPParentDirIDBit:
if (container.Parent == null)
{
this.WriteUInt32(1);
}
else if (container.Parent is IStorageProvider)
{
this.WriteUInt32(2);
}
else
{
this.WriteUInt32(volume.GetNode(container.Parent));
}
break;
case AfpFileDirectoryBitmap.kFPOffspringCountBit:
this.WriteUInt16((ushort)container.Contents().Count());
break;
case AfpFileDirectoryBitmap.kFPCreateDateBit:
this.WriteMacintoshDate(container.DateCreated);
break;
case AfpFileDirectoryBitmap.kFPModDateBit:
this.WriteMacintoshDate(container.DateModified);
break;
case AfpFileDirectoryBitmap.kFPBackupDateBit:
this.WriteUInt32(0x80000000);
break;
case AfpFileDirectoryBitmap.kFPFinderInfoBit:
this.WriteBytes(new byte[32]);
break;
case AfpFileDirectoryBitmap.kFPLongNameBit:
this.WriteMark("LongName");
break;
case AfpFileDirectoryBitmap.kFPShortNameBit:
this.WriteMark("ShortName");
break;
case AfpFileDirectoryBitmap.kFPUTF8NameBit:
this.WriteMark("UTF8Name");
this.WriteBytes(new byte[4]);
break;
case AfpFileDirectoryBitmap.kFPNodeIDBit:
if (container is IStorageProvider)
{
this.WriteUInt32(2);
}
else
{
this.WriteUInt32(volume.GetNode(container));
}
break;
case AfpFileDirectoryBitmap.kFPOwnerIDBit:
this.WriteUInt32(0);
break;
case AfpFileDirectoryBitmap.kFPGroupIDBit:
this.WriteUInt32(0);
break;
case AfpFileDirectoryBitmap.kFPAccessRightsBit:
this.WriteEnum <AfpAccessRightsBitmap>(AfpAccessRightsBitmap.All);
break;
default:
Console.WriteLine("Unrecog flag: {0}", flag);
break;
}
}
//this.WriteUInt32(0); // Pad
foreach (AfpFileDirectoryBitmap flag in bitmap.EnumerateFlags())
{
switch (flag)
{
case AfpFileDirectoryBitmap.kFPLongNameBit:
this.BeginMark("LongName");
this.WritePascalString(container.Name, 32);
break;
case AfpFileDirectoryBitmap.kFPShortNameBit:
this.BeginMark("ShortName");
this.WritePascalString(container.Name, 12);
break;
case AfpFileDirectoryBitmap.kFPUTF8NameBit:
this.BeginMark("UTF8Name");
this.WriteUTF8StringWithHint(container.Name);
break;
}
}
this.EndMarking();
}
public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
requestStream.ReadUInt8(); // Padding
ushort volumeId = requestStream.ReadUInt16();
uint directoryId = requestStream.ReadUInt32();
AfpPathType pathType = requestStream.ReadEnum <AfpPathType>();
string pathName = null;
switch (pathType)
{
case AfpPathType.kFPLongName:
case AfpPathType.kFPShortName:
pathName = requestStream.ReadPascalString();
break;
case AfpPathType.kFPUTF8Name:
pathName = requestStream.ReadUTF8StringWithHint();
break;
}
IAfpVolume volume = session.GetVolume(volumeId);
if (volume == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageContainer container = null;
if (directoryId == 2)
{
container = volume.StorageProvider;
}
else
{
container = (volume.GetNode(directoryId) as IStorageContainer);
}
if (container == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageItem deleteItem = null;
if (!string.IsNullOrEmpty(pathName))
{
deleteItem = container.Content(pathName);
}
if (deleteItem == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageContainer deleteContainer = (deleteItem as IStorageContainer);
if (deleteContainer != null && deleteContainer.Contents().Count() > 0)
{
return(AfpResultCode.FPDirNotEmpty);
}
deleteItem.Delete();
return(AfpResultCode.FPNoErr);
}
public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
requestStream.ReadUInt8(); // Pad
ushort volumeId = requestStream.ReadUInt16();
uint directoryID = requestStream.ReadUInt32();
AfpFileDirectoryBitmap fileBitmap = requestStream.ReadEnum <AfpFileDirectoryBitmap>();
AfpFileDirectoryBitmap directoryBitmap = requestStream.ReadEnum <AfpFileDirectoryBitmap>();
AfpPathType pathType = requestStream.ReadEnum <AfpPathType>();
string pathname = null;
switch (pathType)
{
case AfpPathType.kFPLongName:
case AfpPathType.kFPShortName:
pathname = requestStream.ReadPascalString();
break;
case AfpPathType.kFPUTF8Name:
pathname = requestStream.ReadUTF8StringWithHint();
break;
}
IAfpVolume volume = session.GetVolume(volumeId);
if (volume == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageContainer container = null;
if (directoryID == 2)
{
container = volume.StorageProvider;
}
else if (directoryID == 1)
{
if (pathname == volume.StorageProvider.Name)
{
container = volume.StorageProvider;
}
}
else
{
container = volume.GetNode(directoryID) as IStorageContainer;
}
if (container == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageItem item = null;
if (directoryID == 1)
{
item = container;
}
else
{
if (string.IsNullOrEmpty(pathname))
{
item = container;
}
else
{
item = container.Content(pathname);
}
}
if (item == null)
{
return(AfpResultCode.FPObjectNotFound);
}
responseStream.WriteEnum(fileBitmap);
responseStream.WriteEnum(directoryBitmap);
if (item is IStorageContainer)
{
responseStream.WriteStorageContainerInfo(volume, (IStorageContainer)item, directoryBitmap);
}
else
{
responseStream.WriteStorageFileInfo(volume, (IStorageFile)item, fileBitmap);
}
return(AfpResultCode.FPNoErr);
}
public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
requestStream.ReadUInt8(); // Padding
ushort volumeId = requestStream.ReadUInt16();
uint sourceDirId = requestStream.ReadUInt32();
uint destDirId = requestStream.ReadUInt32();
AfpPathType sourcePathType = requestStream.ReadEnum <AfpPathType>();
string sourcePathName = null;
switch (sourcePathType)
{
case AfpPathType.kFPLongName:
case AfpPathType.kFPShortName:
sourcePathName = requestStream.ReadPascalString();
break;
case AfpPathType.kFPUTF8Name:
sourcePathName = requestStream.ReadUTF8StringWithHint();
break;
}
AfpPathType destPathType = requestStream.ReadEnum <AfpPathType>();
string destPathName = null;
switch (destPathType)
{
case AfpPathType.kFPLongName:
case AfpPathType.kFPShortName:
destPathName = requestStream.ReadPascalString();
break;
case AfpPathType.kFPUTF8Name:
destPathName = requestStream.ReadUTF8StringWithHint();
break;
}
AfpPathType newPathType = requestStream.ReadEnum <AfpPathType>();
string newPathName = null;
switch (newPathType)
{
case AfpPathType.kFPLongName:
case AfpPathType.kFPShortName:
newPathName = requestStream.ReadPascalString();
break;
case AfpPathType.kFPUTF8Name:
newPathName = requestStream.ReadUTF8StringWithHint();
break;
}
IAfpVolume volume = session.GetVolume(volumeId);
IStorageContainer sourceContainer = sourceDirId == 2 ? volume.StorageProvider : (IStorageContainer)volume.GetNode(sourceDirId);
IStorageContainer destinationContainer = destDirId == 2 ? volume.StorageProvider : (IStorageContainer)volume.GetNode(destDirId);
if (sourceContainer == null || destinationContainer == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageItem sourceItem = null;
if (!string.IsNullOrEmpty(destPathName))
{
destinationContainer = destinationContainer.Content(destPathName) as IStorageContainer;
if (destinationContainer == null)
{
return(AfpResultCode.FPObjectNotFound);
}
}
if (!string.IsNullOrEmpty(sourcePathName))
{
sourceItem = sourceContainer.Content(sourcePathName);
}
else
{
sourceItem = sourceContainer;
}
if (sourceItem == null)
{
return(AfpResultCode.FPObjectNotFound);
}
if (string.IsNullOrEmpty(newPathName))
{
newPathName = sourceItem.Name;
}
if (destinationContainer.Content(newPathName) != null)
{
return(AfpResultCode.FPObjectExists);
}
sourceItem.Move(destinationContainer);
sourceItem.Rename(newPathName);
return(AfpResultCode.FPNoErr);
}
public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
byte flag = requestStream.ReadUInt8();
ushort volumeId = requestStream.ReadUInt16();
uint directoryId = requestStream.ReadUInt32();
bool resourceFork = (flag == 0x80);
if (resourceFork)
{
Log.Add(this, EntryType.Error, "Session '{0}' attempted to open resource fork, failing...", session);
return(AfpResultCode.FPMiscErr);
}
AfpFileDirectoryBitmap bitmap = requestStream.ReadEnum <AfpFileDirectoryBitmap>();
AfpAccessModes accessMode = requestStream.ReadEnum <AfpAccessModes>();
AfpPathType pathType = requestStream.ReadEnum <AfpPathType>();
string path = null;
switch (pathType)
{
case AfpPathType.kFPLongName:
case AfpPathType.kFPShortName:
path = requestStream.ReadPascalString();
break;
case AfpPathType.kFPUTF8Name:
path = requestStream.ReadUTF8StringWithHint();
break;
}
IAfpVolume volume = session.GetVolume(volumeId);
if (volume == null)
{
throw new StorageItemNotFoundException();
}
IStorageContainer container = null;
if (directoryId == 2)
{
container = volume.StorageProvider;
}
else
{
container = (volume.GetNode(directoryId) as IStorageContainer);
}
if (container == null)
{
throw new StorageItemNotFoundException();
}
IStorageFile file = (container.Content(path) as IStorageFile);
if (file == null)
{
throw new StorageItemNotFoundException();
}
IAfpFork info = session.OpenFork(file, accessMode);
if (info == null)
{
throw new StorageItemNotFoundException();
}
responseStream.WriteEnum <AfpFileDirectoryBitmap>(bitmap);
responseStream.WriteInt16(info.Identifier);
responseStream.WriteStorageFileInfo(volume, file, bitmap);
return(AfpResultCode.FPNoErr);
}
public AfpResultCode Process(IAfpSession session, DsiHeader dsiHeader, AfpStream requestStream, AfpStream responseStream)
{
requestStream.ReadUInt8(); // Padding
ushort volumeId = requestStream.ReadUInt16();
uint directoryId = requestStream.ReadUInt32();
AfpFileDirectoryBitmap fileBitmap = requestStream.ReadEnum <AfpFileDirectoryBitmap>();
AfpFileDirectoryBitmap directoryBitmap = requestStream.ReadEnum <AfpFileDirectoryBitmap>();
short reqCount = requestStream.ReadInt16();
int startIndex = requestStream.ReadInt32();
int maxReplySize = requestStream.ReadInt32();
AfpPathType pathType = requestStream.ReadEnum <AfpPathType>();
string path = null;
switch (pathType)
{
case AfpPathType.kFPLongName:
case AfpPathType.kFPShortName:
path = requestStream.ReadPascalString();
break;
case AfpPathType.kFPUTF8Name:
path = requestStream.ReadUTF8StringWithHint();
break;
}
IAfpVolume volume = session.GetVolume(volumeId);
if (volume == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageContainer container = null;
if (directoryId == 2)
{
container = volume.StorageProvider;
}
else
{
container = (volume.GetNode(directoryId) as IStorageContainer);
}
if (container == null)
{
return(AfpResultCode.FPObjectNotFound);
}
IStorageContainer lookAtContainer = null;
if (string.IsNullOrEmpty(path))
{
lookAtContainer = container;
}
else
{
lookAtContainer = (container.Content(path) as IStorageContainer);
}
if (lookAtContainer == null)
{
return(AfpResultCode.FPObjectNotFound);
}
var useContents = lookAtContainer.Contents();
if (fileBitmap == 0)
{
useContents = useContents.OfType <IStorageContainer>();
}
else if (directoryBitmap == 0)
{
useContents = useContents.OfType <IStorageFile>();
}
useContents = useContents
.Skip(startIndex - 1)
.Take(reqCount);
var contents = useContents.ToList();
if (contents.Count == 0)
{
return(AfpResultCode.FPObjectNotFound);
}
responseStream.WriteEnum <AfpFileDirectoryBitmap>(fileBitmap);
responseStream.WriteEnum <AfpFileDirectoryBitmap>(directoryBitmap);
responseStream.WriteInt16((short)contents.Count);
foreach (IStorageItem item in contents)
{
AfpStream resultRecord = new AfpStream();
resultRecord.WriteUInt16(0); // Length
if (item is IStorageContainer)
{
resultRecord.WriteStorageContainerInfo(volume, (IStorageContainer)item, directoryBitmap);
}
else
{
resultRecord.WriteStorageFileInfo(volume, (IStorageFile)item, fileBitmap);
}
resultRecord.WritePadding();
resultRecord.Stream.Position = 0;
resultRecord.WriteUInt16((byte)resultRecord.Stream.Length);
byte[] recordData = resultRecord.ToByteArray();
responseStream.WriteBytes(recordData);
}
return(AfpResultCode.FPNoErr);
}
