public SftpMkDirRequest(uint protocolVersion, uint requestId, string path, Encoding encoding, SftpFileAttributes attributes, Action<SftpStatusResponse> statusAction) : base(protocolVersion, requestId, statusAction) { this.Path = path; this.Encoding = encoding; this.Attributes = attributes; }
public SftpOpenRequest(uint requestId, string fileName, Flags flags, SftpFileAttributes attributes, Action<SftpHandleResponse> handleAction, Action<SftpStatusResponse> statusAction) : base(requestId, statusAction) { this.Filename = fileName; this.Flags = flags; this.Attributes = attributes; this.SetAction(handleAction); }
public SftpOpenRequest(uint protocolVersion, uint requestId, string fileName, Encoding encoding, Flags flags, SftpFileAttributes attributes, Action<SftpHandleResponse> handleAction, Action<SftpStatusResponse> statusAction) : base(protocolVersion, requestId, statusAction) { this.Filename = fileName; this.Flags = flags; this.Attributes = attributes; this.Encoding = encoding; this.SetAction(handleAction); }
public void LastWriteTimeTest() { SftpSession sftpSession = null; // TODO: Initialize to an appropriate value string fullName = string.Empty; // TODO: Initialize to an appropriate value SftpFileAttributes attributes = null; // TODO: Initialize to an appropriate value SftpFile target = new SftpFile(sftpSession, fullName, attributes); // TODO: Initialize to an appropriate value DateTime expected = new DateTime(); // TODO: Initialize to an appropriate value DateTime actual; target.LastWriteTime = expected; actual = target.LastWriteTime; Assert.AreEqual(expected, actual); Assert.Inconclusive("Verify the correctness of this test method."); }
public void GroupCanReadTest() { SftpSession sftpSession = null; // TODO: Initialize to an appropriate value string fullName = string.Empty; // TODO: Initialize to an appropriate value SftpFileAttributes attributes = null; // TODO: Initialize to an appropriate value SftpFile target = new SftpFile(sftpSession, fullName, attributes); // TODO: Initialize to an appropriate value bool expected = false; // TODO: Initialize to an appropriate value bool actual; target.GroupCanRead = expected; actual = target.GroupCanRead; Assert.AreEqual(expected, actual); Assert.Inconclusive("Verify the correctness of this test method."); }
public bool IsExist(string absolutePath) { bool IsExist = false; try { SftpFileAttributes fileAttr = Sftp.GetAttributes(absolutePath); IsExist = true; } catch { IsExist = false; } return(IsExist); }
///// <summary> ///// download online maps ///// </summary> ///// <param name="_selectedCityName"></param> public void DownloadOnlineMaps(string _selectedCityName) { string cityName = _selectedCityName + ".csv"; var deviceDocumentsPath = Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryDocuments); string cityPath = deviceDocumentsPath.AbsolutePath + "/OHDM_MAP/" + cityName; using (SftpClient sftp = new SftpClient(@serverName, login, password)) { try { sftp.Connect(); using (Stream fileStream = File.OpenWrite(cityPath)) { SftpFileAttributes attributes = sftp.GetAttributes(directory + cityName); //recover the file size progress.Max = (int)attributes.Size; // Set progress bar maximum on foreground thread sftp.DownloadFile(directory + cityName, fileStream, downloadProgressBar); fileStream.Close(); } sftp.Disconnect(); } catch (Exception er) { Console.WriteLine("Error " + er); if (!sftp.IsConnected) { RunOnUiThread(() => { //enable/disable widgets spinner.Enabled = true; switchSlider.Enabled = true; datePickerText.Enabled = false; displayMessage(5); // Display message if the connection to the FTP server Failed }); } } } processCsv(csvLocalPath); mapView = FindViewById <MapView>(Resource.Id.mapView); MapView.RegisterLicense(LICENSE, this); mapView.SetZoom(18f, 0f); }
public bool DirectoryExists(string server, int port, string directory) { directory = AdjustPath(server, directory); SftpClient client = null; try { client = OpenSftpClient(server, port); try { SftpFileAttributes a = client.GetAttributes(directory); if (a.IsDirectory) { return(true); } } catch { } finally { RecycleClient(client); client = null; } } catch (Exception ex) { try { client.Disconnect(); } catch { } try { client.Dispose(); } catch { } STEM.Sys.EventLog.WriteEntry("Authentication.DirectoryExists", ex.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error); } return(false); }
protected void Arrange() { _random = new Random(); _path = _random.Next().ToString(CultureInfo.InvariantCulture); _handle = new[] { (byte)_random.Next(byte.MinValue, byte.MaxValue) }; _fileAttributes = SftpFileAttributes.Empty; _bufferSize = (uint)_random.Next(1, 1000); _readBufferSize = (uint)_random.Next(0, 1000); _writeBufferSize = (uint)_random.Next(500, 1000); _data = new byte[(_writeBufferSize * 2) + 15]; _random.NextBytes(_data); _offset = _random.Next(1, 5); // to get multiple SSH_FXP_WRITE messages (and verify the offset is updated correctly), we make sure // the number of bytes to write is at least two times the write buffer size; we write a few extra bytes to // ensure the buffer is not empty after the writes so we can verify whether Length, Dispose and Flush // flush the buffer _count = ((int)_writeBufferSize * 2) + _random.Next(1, 5); _expectedWrittenByteCount = (2 * _writeBufferSize); _expectedBufferedByteCount = (int)(_count - _expectedWrittenByteCount); _expectedBufferedBytes = _data.Take(_offset + (int)_expectedWrittenByteCount, _expectedBufferedByteCount); _sftpSessionMock = new Mock <ISftpSession>(MockBehavior.Strict); _sequence = new MockSequence(); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestOpen(_path, Flags.Write | Flags.Truncate, true)) .Returns(_handle); _sftpSessionMock.InSequence(_sequence).Setup(p => p.RequestFStat(_handle)).Returns(_fileAttributes); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.CalculateOptimalReadLength(_bufferSize)) .Returns(_readBufferSize); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.CalculateOptimalWriteLength(_bufferSize, _handle)) .Returns(_writeBufferSize); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.IsOpen) .Returns(true); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestWrite(_handle, 0, _data, _offset, (int)_writeBufferSize, It.IsAny <AutoResetEvent>(), null)); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestWrite(_handle, _writeBufferSize, _data, _offset + (int)_writeBufferSize, (int)_writeBufferSize, It.IsAny <AutoResetEvent>(), null)); _sftpFileStream = new SftpFileStream(_sftpSessionMock.Object, _path, FileMode.Create, FileAccess.Write, (int)_bufferSize); }
private SftpFileInfo CreateDirectoryRecursively(string path) { path = NormalizePath(path); string current = ""; if (path[0] == PathSeparator) { path = path.Substring(1); } while (!string.IsNullOrEmpty(path)) { int p = path.IndexOf(PathSeparator); current += PathSeparator; if (p >= 0) { current += path.Substring(0, p); path = path.Substring(p + 1); } else { current += path; path = ""; } try { SftpFileAttributes attrs = Client.GetAttributes(current); if (!attrs.IsDirectory) { return(null); } } catch (SftpPathNotFoundException) { Client.CreateDirectory(current); } } var file = Client.Get(current); return(new SftpFileInfo(this, file)); }
private bool ShouldDownloadNewFile(FileSystemInfo existingFileInfo, SftpFileAttributes newFileInfo) { try { // If the file on the FTP site is not newer than our current file, the file won't be downloaded if (newFileInfo.LastWriteTime < existingFileInfo.LastWriteTime) { _logger.Information("File already exists and does not need to be re-downloaded.", existingFileInfo, newFileInfo); return(false); } } catch (Exception ex) { _logger.Error(ex, "Unable to compare the existing file to the file to download."); return(false); } return(true); }
protected override void SetupData() { base.SetupData(); _random = new Random(); _path = _random.Next().ToString(); _fileMode = FileMode.Append; _fileAccess = FileAccess.Write; _bufferSize = _random.Next(5, 1000); _readBufferSize = (uint)_random.Next(5, 1000); _writeBufferSize = (uint)_random.Next(5, 1000); _handle = GenerateRandom(_random.Next(1, 10), _random); _fileAttributes = new SftpFileAttributesBuilder().WithLastAccessTime(DateTime.Now.AddSeconds(_random.Next())) .WithLastWriteTime(DateTime.Now.AddSeconds(_random.Next())) .WithSize(_random.Next()) .WithUserId(_random.Next()) .WithGroupId(_random.Next()) .WithPermissions((uint)_random.Next()) .Build(); }
public NtStatus SetFileTime(string fileName, DateTime?creationTime, DateTime?lastAccessTime, DateTime?lastWriteTime, DokanFileInfo info) { fileName = ToUnixStylePath(fileName); SftpFileAttributes attr = sftpClient.GetAttributes(fileName); if (lastAccessTime != null) { attr.LastAccessTime = lastAccessTime.Value; } if (lastWriteTime != null) { attr.LastWriteTime = lastWriteTime.Value; } sftpClient.SetAttributes(fileName, attr); return(DokanResult.Success); }
public void DownloadFile(string remoteFileName, string localFileName, Action <double> downloadAction = null) { using (FileStream stream = File.Open(localFileName, FileMode.OpenOrCreate)) { try { using (SftpClient client = new SftpClient(_ConnectionInfo)) { client.Connect(); SftpFileAttributes attributes = client.GetAttributes(remoteFileName); client.DownloadFile(remoteFileName, stream, delegate(ulong i) { downloadAction?.Invoke(i / (double)attributes.Size); }); } } catch (Exception) { } } }
protected override void SetupMocks() { _sequence = new MockSequence(); SftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestOpen(_path, Flags.Read | Flags.Write, false)) .Returns(_handle); SftpSessionMock.InSequence(_sequence) .Setup(p => p.CalculateOptimalReadLength(_bufferSize)) .Returns(_readBufferSize); SftpSessionMock.InSequence(_sequence) .Setup(p => p.CalculateOptimalWriteLength(_bufferSize, _handle)) .Returns(_writeBufferSize); SftpSessionMock.InSequence(_sequence) .Setup(p => p.IsOpen) .Returns(true); SftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestRead(_handle, 0, _readBufferSize)) .Returns(_actualReadBytes); SftpSessionMock.InSequence(_sequence) .Setup(p => p.IsOpen) .Returns(true); SftpSessionMock.InSequence(_sequence) .Setup(p => p.IsOpen) .Returns(true); SftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestWrite(_handle, (uint)_readBytes.Length, It.IsAny <byte[]>(), 0, _writeBytes.Length, It.IsAny <AutoResetEvent>(), null)) .Callback <byte[], ulong, byte[], int, int, AutoResetEvent, Action <SftpStatusResponse> >((handle, serverOffset, data, offset, length, wait, writeCompleted) => { _actualWrittenBytes = data.Take(offset, length); wait.Set(); }); SftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestFStat(_handle, false)) .Returns(_fileAttributes); SftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestFSetStat(_handle, _fileAttributes)) .Callback <byte[], SftpFileAttributes>((bytes, attributes) => _newFileAttributes = attributes.Clone()); }
public void LengthShouldFlushBufferAndReturnSizeOfFile() { var lengthFileAttributes = new SftpFileAttributes(DateTime.Now, DateTime.Now, _random.Next(), _random.Next(), _random.Next(), (uint)_random.Next(0, int.MaxValue), null); byte[] actualFlushedData = null; _sftpSessionMock.InSequence(_sequence) .Setup(p => p.IsOpen) .Returns(true); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestWrite(_handle, _expectedWrittenByteCount, It.IsAny <byte[]>(), 0, _expectedBufferedByteCount, It.IsAny <AutoResetEvent>(), null)) .Callback <byte[], ulong, byte[], int, int, AutoResetEvent, Action <SftpStatusResponse> >((handle, serverFileOffset, data, offset, length, wait, writeCompleted) => actualFlushedData = data.Take(offset, length)); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestFStat(_handle)) .Returns(lengthFileAttributes); Assert.AreEqual(lengthFileAttributes.Size, _sftpFileStream.Length); Assert.IsTrue(actualFlushedData.IsEqualTo(_expectedBufferedBytes)); _sftpSessionMock.Verify(p => p.RequestWrite(_handle, _expectedWrittenByteCount, It.IsAny <byte[]>(), 0, _expectedBufferedByteCount, It.IsAny <AutoResetEvent>(), null), Times.Once); }
private void CreateDirectoryRecursively(SftpClient client, string path) { string current = ""; if (path[0] == '/') { path = path.Substring(1); } while (!string.IsNullOrEmpty(path)) { int p = path.IndexOf('/'); current += '/'; if (p >= 0) { current += path.Substring(0, p); path = path.Substring(p + 1); } else { current += path; path = ""; } try { SftpFileAttributes attrs = client.GetAttributes(current); if (!attrs.IsDirectory) { throw new Exception("not directory"); } } catch (SftpPathNotFoundException) { client.CreateDirectory(current); } } }
///<summary>Loops through the entire path and sees if any directory along the way doesn't exist. If any don't exist, they get created.</summary> public static void CreateDirectoriesIfNeeded(this SftpClient client, string path) { bool hadToConnect = client.ConnectIfNeeded(); if (string.IsNullOrEmpty(path)) { return; } if (path[0] == '/') { path = path.Substring(1); } string currentDir = ""; string[] directories = path.Split('/'); for (int i = 0; i < directories.Length; i++) { if (i > 0) { currentDir += "/"; } currentDir += directories[i]; try { //This will throw an exception of SftpPathNotFoundException if the directory does not exist SftpFileAttributes attributes = client.GetAttributes(currentDir); //Check to see if it's a directory. This will not throw an exception of SftpPathNotFoundException, so we want to break out if it's a file path. //This would be a weird permission issue or implementation error, but it doesn't hurt anything. if (!attributes.IsDirectory) { break; } } catch (SftpPathNotFoundException) { client.CreateDirectory(currentDir); } } client.DisconnectIfNeeded(hadToConnect); }
protected override async Task PerformIO() { bool hadToConnect = _client.ConnectIfNeeded(); string fullFilePath = ODFileUtils.CombinePaths(Folder, FileName, '/'); SftpFileAttributes attribute = _client.GetAttributes(fullFilePath); using (MemoryStream stream = new MemoryStream()) { SftpDownloadAsyncResult res = (SftpDownloadAsyncResult)_client.BeginDownloadFile(fullFilePath, stream); while (!res.AsyncWaitHandle.WaitOne(100)) { if (DoCancel) { res.IsDownloadCanceled = true; _client.DisconnectIfNeeded(hadToConnect); return; } OnProgress((double)res.DownloadedBytes / (double)1024 / (double)1024, "?currentVal MB of ?maxVal MB downloaded", (double)attribute.Size / (double)1024 / (double)1024, ""); } _client.EndDownloadFile(res); FileContent = stream.ToArray(); } _client.DisconnectIfNeeded(hadToConnect); await Task.Run(() => { }); //Gets rid of a compiler warning and does nothing. }
protected void Arrange() { var random = new Random(); _path = random.Next().ToString(CultureInfo.InvariantCulture); _handle = new[] { (byte)random.Next(byte.MinValue, byte.MaxValue) }; _fileAttributes = SftpFileAttributes.Empty; _bufferSize = (uint)random.Next(1, 1000); _readBufferSize = (uint)random.Next(0, 1000); _writeBufferSize = (uint)random.Next(0, 1000); _length = random.Next(); _sftpSessionMock = new Mock <ISftpSession>(MockBehavior.Strict); _sequence = new MockSequence(); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.RequestOpen(_path, Flags.Read | Flags.Truncate, true)) .Returns(_handle); _sftpSessionMock.InSequence(_sequence).Setup(p => p.RequestFStat(_handle)).Returns(_fileAttributes); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.CalculateOptimalReadLength(_bufferSize)) .Returns(_readBufferSize); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.CalculateOptimalWriteLength(_bufferSize, _handle)) .Returns(_writeBufferSize); _sftpSessionMock.InSequence(_sequence) .Setup(p => p.IsOpen) .Returns(true); _sftpFileStream = new SftpFileStream( _sftpSessionMock.Object, _path, FileMode.Create, FileAccess.Read, (int)_bufferSize); }
protected override void LoadData() { base.LoadData(); this.Attributes = this.ReadAttributes(); }
internal SftpContextStream(SftpSession session, string path, FileMode mode, FileAccess access, SftpFileAttributes attributes) { Flags flags = Flags.None; switch (access) { case FileAccess.Read: flags = Flags.Read; break; case FileAccess.Write: flags = Flags.Write; break; case FileAccess.ReadWrite: flags = Flags.Read | Flags.Write; break; } switch (mode) { case FileMode.Append: flags |= Flags.Append; break; case FileMode.Create: if (attributes == null) { flags |= Flags.CreateNew; } else { flags |= Flags.Truncate; } break; case FileMode.CreateNew: flags |= Flags.CreateNew; break; case FileMode.Open: break; case FileMode.OpenOrCreate: flags |= Flags.CreateNewOrOpen; break; case FileMode.Truncate: flags |= Flags.Truncate; break; } _session = session; _handle = _session.RequestOpen(path, flags); _attributes = attributes ?? _session.RequestFStat(_handle); if (access.HasFlag(FileAccess.Write)) { _writeBuffer = new byte[WRITE_BUFFER_SIZE]; _writeMode = true; } _position = mode != FileMode.Append ? 0 : _attributes.Size; }
public SftpMkDirRequest(uint requestId, string path, SftpFileAttributes attributes, Action<SftpStatusResponse> statusAction) : base(requestId, statusAction) { this.Path = path; this.Attributes = attributes; }
protected override void LoadData() { base.LoadData(); Attributes = ReadAttributes(); }
public object ReadProperty(SshPropertyInfo p) { Type type = p.Information.PropertyType; // ordered by most common type. if (typeof(Enum).IsAssignableFrom(type) && Enum.GetUnderlyingType(type).Equals(typeof(byte))) { return(Enum.ToObject(type, this.ReadByte())); } else if (type.Equals(typeof(string[]))) { return(this.ReadStringAsString().Split(',')); } else if (type.Equals(typeof(string))) { return(this.ReadStringAsString()); } else if (type.Equals(typeof(uint))) { return(this.ReadUInt32()); } else if (type.Equals(typeof(byte[]))) { if (p.Attributes.Raw) { return(this.ReadBytes(p.Attributes.RawLength)); } else { return(this.ReadString()); } } else if (type.Equals(typeof(bool))) { return(this.ReadBoolean()); } else if (typeof(Enum).IsAssignableFrom(type) && Enum.GetUnderlyingType(type).Equals(typeof(uint))) { return(Enum.ToObject(type, this.ReadUInt32())); } else if (type.Equals(typeof(short))) { return(this.ReadInt16()); } else if (type.Equals(typeof(int))) { return(this.ReadInt32()); } else if (type.Equals(typeof(long))) { return(this.ReadInt64()); } else if (type.Equals(typeof(ulong))) { return(this.ReadUInt64()); } else if (type.Equals(typeof(Dictionary <string, string>))) { var d = new Dictionary <string, string>(); while (this.Position < this.Length) { d.Add(this.ReadStringAsString(), this.ReadStringAsString()); } return(d); } else if (type.Equals(typeof(SftpFileAttributes))) { var v = new SftpFileAttributes(); v.Flags = (FileInfoFlags)this.ReadUInt32(); if (v.Flags.HasFlag(FileInfoFlags.SSH_FILEXFER_ATTR_PERMISSIONS)) { v.Permissions = (PermissionsFlags)this.ReadUInt32(); } } else if (type.Equals(typeof(SftpFileInfo))) { return(new SftpFileInfo(this, string.Empty, string.Empty, string.Empty)); } else if (type.Equals(typeof(SftpFileInfo[]))) { var d = new List <SftpFileInfo>(); while (this.Position < this.Length) { d.Add(new SftpFileInfo(this, string.Empty)); } return(d.ToArray()); } return(null); }
protected override void LoadData() { base.LoadData(); this.Path = this.ReadString(this.Encoding); this.Attributes = this.ReadAttributes(); }
public SftpContext(SftpFileAttributes attributes, bool aDeleteOnCloseWorkaround) { _attributes = attributes; this.deleteOnCloseWorkaround = aDeleteOnCloseWorkaround; }
public SftpContext(SftpFileAttributes attributes) { _attributes = attributes; }
private void download_sftp(string remote_path, string local_path) { // https://stackoverflow.com/questions/43555982/displaying-progress-of-file-upload-in-a-progressbar-with-ssh-net // https://stackoverflow.com/questions/44442714/displaying-progress-of-file-download-in-a-progressbar-with-ssh-net download_status = DOWNLOAD_STATUS.start; update_ui(); Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); SftpClient sftp = new SftpClient(Constants.SFTP_ADDR, Constants.SFTP_ID, Constants.SFTP_PWD); try { using (var stream = new FileStream(local_path, FileMode.Create)) using (sftp) { if (!sftp.IsConnected) { sftp.Connect(); } SftpFileAttributes attributes = sftp.GetAttributes(remote_path); // Set progress bar maximum on foreground thread Application.Current.Dispatcher.Invoke(() => { var file_size = ByteSize.FromBytes((double)attributes.Size); prgbDownload.Value = 0; prgbDownload.Maximum = (int)file_size.Bytes; prgbDownloadText.Text = string.Format("{0} / {1:F1} MB", 0, file_size.MegaBytes); }); sftp.DownloadFile(remote_path, stream, download_sftp_progress); extract_zipfile(local_path); download_status = DOWNLOAD_STATUS.end; update_ui(); } } catch (Exception e) { download_status = DOWNLOAD_STATUS.ini; update_ui(); MessageBox.Show(e.Message); } stopWatch.Stop(); TimeSpan ts = stopWatch.Elapsed; string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); if (download_status == DOWNLOAD_STATUS.end) { Application.Current.Dispatcher.Invoke(() => { prgbDownloadText.Text += "(" + elapsedTime + ")"; }); } sftp.Dispose(); }
protected override void LoadData() { base.LoadData(); this.Path = this.ReadString(); this.Attributes = this.ReadAttributes(); }
public SftpFSetStatRequest(uint protocolVersion, uint requestId, byte[] handle, SftpFileAttributes attributes, Action <SftpStatusResponse> statusAction) : base(protocolVersion, requestId, statusAction) { this.Handle = handle; this.Attributes = attributes; }
public SftpFSetStatRequest(uint protocolVersion, uint requestId, byte[] handle, SftpFileAttributes attributes, Action<SftpStatusResponse> statusAction) : base(protocolVersion, requestId, statusAction) { this.Handle = handle; this.Attributes = attributes; }
public SftpOpenRequest(uint protocolVersion, uint requestId, string fileName, Encoding encoding, Flags flags, SftpFileAttributes attributes, Action <SftpHandleResponse> handleAction, Action <SftpStatusResponse> statusAction) : base(protocolVersion, requestId, statusAction) { this.Filename = fileName; this.Flags = flags; this.Attributes = attributes; this.Encoding = encoding; this.SetAction(handleAction); }
protected override void LoadData() { base.LoadData(); this.Handle = this.ReadBinaryString(); this.Attributes = this.ReadAttributes(); }
private bool UserCanExecute(SftpFileAttributes attributes) { return(_userId == -1 || (attributes.OwnerCanExecute && attributes.UserId == _userId || (attributes.GroupCanExecute && _userGroups.Contains(attributes.GroupId) || attributes.OthersCanExecute))); }
public SftpSetStatRequest(uint protocolVersion, uint requestId, string path, Encoding encoding, SftpFileAttributes attributes, Action <SftpStatusResponse> statusAction) : base(protocolVersion, requestId, statusAction) { this.Encoding = encoding; this.Path = path; this.Attributes = attributes; }
private SftpOpenRequest(uint protocolVersion, uint requestId, string fileName, Encoding encoding, Flags flags, SftpFileAttributes attributes, Action <SftpHandleResponse> handleAction, Action <SftpStatusResponse> statusAction) : base(protocolVersion, requestId, statusAction) { Encoding = encoding; Filename = fileName; Flags = flags; Attributes = attributes; _handleAction = handleAction; }
public void DoRemoteSetFileAttributes(AbstractFileInfo[] files, SftpFileAttributes attr, bool recursive) { ((ClientSample.Sftp.SftpClientPlugin)_clientPlugin).DoSetFileAttributes(files, attr, recursive); }