public static void UploadFile(FTPUserType ftpUserType, string destinationIP, int destinationPort, string uriTarget, string sourceFile)
{
FileInfo fileInf = new FileInfo(sourceFile);
string uri = string.Format("ftp://{0}:{1}/{2}", destinationIP, destinationPort, uriTarget, new FileInfo(sourceFile).Name);
Debug.WriteLine(uri);
FtpWebRequest reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);
switch (ftpUserType)
{
case FTPUserType.PrintQueue:
reqFTP.Credentials = new NetworkCredential("printqueue", "printqueue");
break;
case FTPUserType.RPIUpdate:
reqFTP.Credentials = new NetworkCredential("atumupdate", "@tum.Update");
break;
}
reqFTP.KeepAlive = false;
reqFTP.Method = WebRequestMethods.Ftp.UploadFile;
reqFTP.UseBinary = true;
reqFTP.ContentLength = fileInf.Length;
// The buffer size is set to 4kb
int buffLength = 4096;
byte[] buff = new byte[buffLength];
int contentLen;
// Opens a file stream (System.IO.FileStream) to read the file to be uploaded
using (FileStream fs = fileInf.OpenRead())
{
try
{
// Stream to which the file to be upload is written
using (Stream strm = reqFTP.GetRequestStream())
{
contentLen = fs.Read(buff, 0, buffLength);
while (contentLen != 0)
{
// Write Content from the file stream to the FTP Upload Stream
strm.Write(buff, 0, contentLen);
contentLen = fs.Read(buff, 0, buffLength);
}
strm.Close();
fs.Close();
}
}
catch (Exception ex)
{
LoggingManager.WriteToLog("File Connection", "Upload", ex);
}
}
}
private string AppendOperation(NetworkStream dataStream, string pathname)
{
long bytes = 0;
using (FileStream fs = new FileStream(pathname, FileMode.Append, FileAccess.Write, FileShare.None, 4096, FileOptions.SequentialScan))
{
bytes = CopyStream(dataStream, fs);
}
LoggingManager.WriteToLog("File connection", _clientIP + "(" + this._currentUser.Username + ")", "APPE");
return("226 Closing data connection, file transfer successful");
}
static void _bwUDPListener_DoWork(object sender, DoWorkEventArgs e)
{
try
{
_udpListener = new UdpClient();
var currentIPAddress = string.Empty;
_udpListener.ExclusiveAddressUse = false;
_remoteEndPoint = new IPEndPoint(IPAddress.Any, _listenPort);
_udpListener.Client.Bind(_remoteEndPoint);
UdpState state = new UdpState();
state.RemoteEndPoint = _remoteEndPoint;
state.UdpListener = _udpListener;
_udpListener.BeginReceive(new AsyncCallback(OnUDPReceive), state);
}
catch (Exception exc)
{
Debug.WriteLine("bwUDPListener_DoWork: " + exc.Message);
}
LoggingManager.WriteToLog("Network", "Broadcast", "Listener started");
Debug.WriteLine(_remoteEndPoint.Address.ToString());
}
public static void Start(int listenPort, bool broadcastListener)
{
_listenPort = listenPort;
_binFormatter = new BinaryFormatter();
if (broadcastListener)
{
_bwUDPListener = new BackgroundWorker();
_bwUDPListener.DoWork += new DoWorkEventHandler(_bwUDPListener_DoWork);
_bwUDPListener.RunWorkerAsync();
//ftp listener
_bwFTPListener = new BackgroundWorker();
_bwFTPListener.DoWork += new DoWorkEventHandler(_bwFTPListener_DoWork);
_bwFTPListener.RunWorkerAsync();
}
_bwTCPListener = new BackgroundWorker();
_bwTCPListener.DoWork += new DoWorkEventHandler(_bwTCPListener_DoWork);
_bwTCPListener.RunWorkerAsync();
LoggingManager.WriteToLog("Network", "TCP", "Listener started");
}
private string ListOperation(NetworkStream dataStream, string pathname)
{
StreamWriter dataWriter = new StreamWriter(dataStream, Encoding.ASCII);
foreach (string dirPath in Directory.GetDirectories(pathname))
{
DirectoryInfo d = new DirectoryInfo(dirPath);
string date = d.LastWriteTime < DateTime.Now - TimeSpan.FromDays(180) ?
d.LastWriteTime.ToString("MMM dd yyyy") :
d.LastWriteTime.ToString("MMM dd HH:mm");
string line = string.Format("drwxr-xr-x 2 2003 2003 {0,8} {1} {2}", "4096", date, d.Name);
dataWriter.WriteLine(line);
dataWriter.Flush();
}
foreach (string filePath in Directory.GetFiles(pathname))
{
FileInfo f = new FileInfo(filePath);
string date = f.LastWriteTime < DateTime.Now - TimeSpan.FromDays(180) ?
f.LastWriteTime.ToString("MMM dd yyyy") :
f.LastWriteTime.ToString("MMM dd HH:mm");
string line = string.Format("-rw-r--r-- 2 2003 2003 {0,8} {1} {2}", f.Length, date, f.Name);
dataWriter.WriteLine(line);
dataWriter.Flush();
}
LoggingManager.WriteToLog("File connection", _clientIP + "(" + this._currentUser.Username + ")", "LIST");
return("226 Transfer complete");
}
static void _bwFTPListener_DoWork(object sender, DoWorkEventArgs e)
{
_ftpServer = new FtpServer(IPAddress.Any, 11001);
_ftpServer.Start();
LoggingManager.WriteToLog("Network", "TCP", "File Listener started");
}
private static void OnTCPReceive(IAsyncResult ar)
{
try
{
Socket clientSocket = (Socket)ar.AsyncState;
var remoteIP = new IPEndPoint(((IPEndPoint)clientSocket.RemoteEndPoint).Address, 11000);
var bytesRead = clientSocket.EndReceive(ar);
clientSocket.Close();
var ms = new System.IO.MemoryStream(_byteData, 0, bytesRead);
ms.Position = 0;
var sr = new StreamReader(ms);
var streamAsString = sr.ReadToEnd();
// streamAsString = streamAsString.Replace("<?", "<").Replace("?>", ">");
if (streamAsString.StartsWith("<"))
{
var xmlReader = new System.IO.StringReader(streamAsString);
if (streamAsString.Contains("<PrinterRemoteControllerQuery"))
{
}
else if (streamAsString.Contains("<PendingClientLicenseRequestMessage"))
{
var clientLicenseRequestMessage = (PendingClientLicenseRequestMessage.Deserialize(xmlReader));
var clientLicenseRequest = clientLicenseRequestMessage.DecodeToXml();
clientLicenseRequest.IPAddress = remoteIP.ToString().Split(':')[0];
AtumClientLicenseRequest?.Invoke(clientLicenseRequest);
}
else if (streamAsString.Contains("<PendingClientLicenseResponseMessage"))
{
var clientLicenseResponseMessage = (PendingClientLicenseResponseMessage.Deserialize(xmlReader));
var clientLicenseResponse = clientLicenseResponseMessage.DecodeToXml();
AtumClientLicenseResponse?.Invoke(clientLicenseResponse);
}
else if (streamAsString.Contains("<RemoveActiveClientLicenseRequest"))
{
var clientRemoveLicenseRequestMessage = (RemoveActiveClientLicenseRequestMessage.Deserialize(xmlReader));
var clientRemoveLicenseRequest = clientRemoveLicenseRequestMessage.DecodeToXml();
AtumClientRemoveLicenseRequest?.Invoke(clientRemoveLicenseRequest);
}
//else if (streamAsString.Contains("<ArrayOfRemoteControlAction"))
//{
// var serializer = new System.Xml.Serialization.XmlSerializer(typeof(RemoteControlActions));
// var remoteControlActions = (RemoteControlActions)serializer.Deserialize(xmlReader);
// remoteControlActions[0].RemoteHostIP = remoteIP.Address.ToString();
// if (AtumPrinterRemoteControlActionReceived != null) AtumPrinterRemoteControlActionReceived(remoteControlActions[0]);
//}
}
else
{
ms.Position = 0;
var remoteObject = _binFormatter.Deserialize(ms);
var remoteObjectType = remoteObject.GetType().FullName;
LoggingManager.WriteToLog("TCP Listener", "Received", remoteObjectType);
switch (remoteObjectType)
{
case "Atum.DAL.Hardware.PrinterFirmwareResult":
AtumFirmwareResults?.Invoke((PrinterFirmwareResult)remoteObject);
break;
case "Atum.DAL.Hardware.PrinterFirmware":
AtumFirmwareQuery?.Invoke(remoteIP);
break;
case "Atum.DAL.Hardware.AtumV15Printer":
AtumPrinterReceived?.Invoke((AtumPrinter)remoteObject);
AtumPrinterV15Received?.Invoke((AtumPrinter)remoteObject);
break;
case "Atum.DAL.Print.PrintJob":
PrintJobReceived?.Invoke(remoteObject, null);
break;
case "Atum.DAL.Remoting.PrinterAction":
AtumPrinterActionReceived?.Invoke((PrinterAction)remoteObject);
break;
case "Atum.DAL.Hardware.PrinterControllerResult":
AtumFirmwareResults?.Invoke((PrinterFirmwareResult)remoteObject);
break;
//case "Atum.DAL.Remoting.RemoteControlActions":
// var remoteAction = (RemoteControlActions)remoteObject;
// if (remoteAction.Count > 0)
// {
// if (AtumPrinterRemoteControlActionReceived != null) AtumPrinterRemoteControlActionReceived(remoteAction[0]);
// }
// break;
//case "Atum.DAL.Remoting.RemoteControlDisplay":
// var remoteDisplay = (RemoteControlDisplay)remoteObject;
// if (AtumPrinterRemoteControlDisplayReceived != null) AtumPrinterRemoteControlDisplayReceived(remoteDisplay);
// break;
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
static void OnUDPReceive(IAsyncResult ar)
{
try
{
UdpClient u = (UdpClient)((UdpState)(ar.AsyncState)).UdpListener;
IPEndPoint e = (IPEndPoint)((UdpState)(ar.AsyncState)).RemoteEndPoint;
Byte[] receiveBytes = u.EndReceive(ar, ref e);
string receiveString = Encoding.ASCII.GetString(receiveBytes);
switch (receiveString)
{
case "10;":
var ms = new System.IO.MemoryStream();
AtumPrinter printer = new AtumNULLPrinter();
switch (PrinterFirmware.HardwareType)
{
case "{289EF7C2-3342-4EA3-AF7D-883B26454318}":
printer = new Atum.DAL.Hardware.AtumV10TDPrinter();
printer.CreateProperties();
printer.CreateProjectors();
break;
case "{967BD0EC-35C1-436A-8D92-145823F17F6E}":
case "{57E748B0-EB49-4A59-AEB3-73B2A973D55F}": //AtumV2
printer = new Atum.DAL.Hardware.AtumV15Printer();
printer.CreateProperties();
printer.CreateProjectors();
break;
}
printer.DetectConnection();
_binFormatter.Serialize(ms, printer);
if (_remoteSocket == null)
{
_remoteEndPoint = new IPEndPoint(e.Address, _listenPort);
}
try
{
_remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
connectDone = new ManualResetEvent(false);
Debug.WriteLine(string.Format("Connecting to: {0}:{1}", e.Address.ToString(), _listenPort));
_remoteSocket.BeginConnect(_remoteEndPoint, new AsyncCallback(ConnectCallback), _remoteSocket);
connectDone.WaitOne();
_remoteSocket.BeginSend(ms.ToArray(), 0, ms.ToArray().Length, SocketFlags.None, new AsyncCallback(OnTCPSend), _remoteSocket);
}
catch (Exception exc)
{
LoggingManager.WriteToLog("OnUDPReceive", "Exception2", exc.Message);
}
break;
}
UdpState s = new UdpState();
s.RemoteEndPoint = _remoteEndPoint;
s.UdpListener = _udpListener;
u.BeginReceive(OnUDPReceive, s);
}
catch (Exception exc)
{
LoggingManager.WriteToLog("OnUDPReceive", "Exception", exc.Message);
}
}
private void DoDataConnectionOperation(IAsyncResult result)
{
HandleAsyncResult(result);
if (result.AsyncState is DataConnectionStoreOperation)
{
DataConnectionStoreOperation op = result.AsyncState as DataConnectionStoreOperation;
try
{
if (File.Exists(op.Arguments))
{
File.Delete(op.Arguments);
}
}
catch (Exception exc)
{
Debug.WriteLine(exc.Message);
}
string response = string.Empty;
using (NetworkStream dataStream = _dataClient.GetStream())
{
long bytes = 0;
using (FileStream fs = new FileStream(op.Arguments, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 4096, FileOptions.SequentialScan))
{
bytes = CopyStream(dataStream, fs);
}
LoggingManager.WriteToLog("File connection", _clientIP + "(" + this._currentUser.Username + ")", "STOR");
response = "226 Closing data connection, file transfer successful";
}
this._dataClient.Close();
this._dataClient = null;
this._controlWriter.WriteLine(response);
this._controlWriter.Flush();
}
else if (result.AsyncState is DataConnectionListOperation)
{
DataConnectionListOperation op = result.AsyncState as DataConnectionListOperation;
string response;
using (NetworkStream dataStream = _dataClient.GetStream())
{
response = ListOperation(dataStream, op.Arguments);
//response = op.Operation(dataStream, op.Arguments);
}
_dataClient.Close();
_dataClient = null;
_controlWriter.WriteLine(response);
_controlWriter.Flush();
}
}
public void HandleClient(object obj)
{
_remoteEndPoint = (IPEndPoint)_controlClient.Client.RemoteEndPoint;
_clientIP = _remoteEndPoint.Address.ToString();
_controlStream = _controlClient.GetStream();
_controlReader = new StreamReader(_controlStream);
_controlWriter = new StreamWriter(_controlStream);
_controlWriter.WriteLine("220 Service Ready.");
_controlWriter.Flush();
_validCommands.AddRange(new string[] { "AUTH", "USER", "PASS", "QUIT", "HELP", "NOOP" });
string line;
_dataClient = new TcpClient();
try
{
while ((line = _controlReader.ReadLine()) != null)
{
string response = null;
string[] command = line.Split(' ');
string cmd = command[0].ToUpperInvariant();
string arguments = command.Length > 1 ? line.Substring(command[0].Length + 1) : null;
if (arguments != null && arguments.Trim().Length == 0)
{
arguments = null;
}
LoggingManager.WriteToLog("File connection", _clientIP, arguments);
if (!_validCommands.Contains(cmd))
{
response = CheckUser();
}
if (response == null)
{
switch (cmd)
{
case "USER":
response = User(arguments);
break;
case "PASS":
response = Password(arguments);
break;
case "CWD":
response = ChangeWorkingDirectory(arguments);
break;
case "CDUP":
response = ChangeWorkingDirectory("..");
break;
case "QUIT":
response = "221 Service closing control connection";
break;
case "REIN":
_currentUser = null;
_username = null;
_passiveListener = null;
_dataClient = null;
response = "220 Service ready for new user";
break;
case "PASV":
response = Passive();
break;
case "PORT":
response = Port(arguments);
// logEntry.CPort = _dataEndpoint.Port.ToString();
break;
case "TYPE":
response = Type(command[1], command.Length == 3 ? command[2] : null);
break;
case "MKD":
response = CreateDir(arguments);
break;
case "PWD":
response = PrintWorkingDirectory();
break;
case "STOR":
response = Store(arguments);
break;
case "LIST":
response = List(arguments ?? _currentDirectory);
// logEntry.Date = DateTime.Now;
break;
// Extensions defined by rfc 3659
case "EPSV":
response = EPassive();
break;
default:
response = "502 Command not implemented";
break;
}
}
LoggingManager.WriteToLog("File connection", _clientIP + "(" + this._username + ")", cmd);
if (_controlClient == null || !_controlClient.Connected)
{
break;
}
else
{
_controlWriter.WriteLine(response);
_controlWriter.Flush();
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
Dispose();
}
