/// <summary>
/// Prepare a new instance with default values but do not connect
/// to another user.
/// </summary>
internal DccFileSession( DccUserInfo dccUserInfo, DccFileInfo dccFileInfo, int bufferSize, int listenPort, string sessionID )
{
this.dccUserInfo = dccUserInfo;
this.dccFileInfo = dccFileInfo;
buffer = new byte[ bufferSize ];
this.listenPort = listenPort;
this.sessionID = sessionID;
lastActivity = DateTime.Now;
waitingOnAccept = false;
}
/// <summary>
/// Prepare a new instance with default values but do not connect
/// to another user.
/// </summary>
internal DccFileSession(DccUserInfo dccUserInfo, DccFileInfo dccFileInfo, int bufferSize, int listenPort, string sessionID)
{
this.dccUserInfo = dccUserInfo;
this.dccFileInfo = dccFileInfo;
buffer = new byte[bufferSize];
this.listenPort = listenPort;
this.sessionID = sessionID;
lastActivity = DateTime.Now;
waitingOnAccept = false;
}
/// <summary>
/// Attempt to send a file to a remote user. Start listening
/// on the given port and address. If the remote user does not accept
/// the offer within the timeout period the the session
/// will be closed.
/// </summary>
/// <remarks>
/// This method should be called from within a try/catch block
/// in case there are socket errors. This methods will also automatically
/// handle a Resume if the remote client requests it.
/// </remarks>
/// <param name="dccUserInfo">The information about the remote user.</param>
/// <param name="listenIPAddress">The IP address of the local machine in dot
/// quad format (e.g. 192.168.0.25). This is the address that will be sent to the
/// remote user. The IP address of the NAT machine must be used if the
/// client is behind a NAT/Firewall system. </param>
/// <param name="listenPort">The port that the session will listen on.</param>
/// <param name="dccFileInfo">The file to be sent. If the file name has spaces in it
/// they will be replaced with underscores when the name is sent.</param>
/// <param name="bufferSize">The size of the send buffer. Generally should
/// be between 4k and 32k.</param>
/// <param name="turbo">True to use send-ahead mode for transfers.</param>
/// <returns>A unique session instance for this file and remote user.</returns>
/// <exception cref="ArgumentException">If the listen port is already in use.</exception>
public static DccFileSession Send(
DccUserInfo dccUserInfo,
string listenIPAddress,
int listenPort,
DccFileInfo dccFileInfo,
int bufferSize,
bool turbo)
{
Debug.WriteLineIf(DccUtil.DccTrace.TraceInfo, "[" + Thread.CurrentThread.Name + "] DccFileSession::Send()");
DccFileSession session = null;
//Test if we are already using this port
if (DccFileSessionManager.DefaultInstance.ContainsSession("S" + listenPort))
{
throw new ArgumentException("Already listening on port " + listenPort);
}
try
{
session = new DccFileSession(dccUserInfo, dccFileInfo, bufferSize, listenPort, "S" + listenPort);
//set turbo mode
session.turboMode = turbo;
//Set server IP address
session.listenIPAddress = listenIPAddress;
//Add session to active sessions hashtable
DccFileSessionManager.DefaultInstance.AddSession(session);
//Create stream to file
dccFileInfo.OpenForRead();
//Start session Thread
session.thread = new Thread(new ThreadStart(session.Listen));
session.thread.Name = session.ToString();
session.thread.Start();
//Send DCC Send request to remote user
session.DccSend(IPAddress.Parse(listenIPAddress));
return(session);
}
catch (Exception e)
{
if (session != null)
{
DccFileSessionManager.DefaultInstance.RemoveSession(session);
}
throw e;
}
}
/// <summary>
/// Another user has offered to send a file. This method should be called
/// to accept the offer and save the file to the give location. The parameters
/// needed to call this method are provided by the <c>OnDccFileTransferRequest()</c>
/// event.
/// </summary>
/// <remarks>
/// This method should be called from within a try/catch block
/// in case it is unable to connect or there are other socket
/// errors.
/// </remarks>
/// <param name="dccUserInfo">Information on the remote user.</param>
/// <param name="dccFileInfo">The local file that will hold the data being sent. If the file
/// is the result of a previous incomplete download the the attempt will be made
/// to resume where the previous left off.</param>
/// <param name="turbo">Will the send ahead protocol be used.</param>
/// <returns>A unique session instance for this file and remote user.</returns>
/// <exception cref="ArgumentException">If the listen port is already in use.</exception>
public static DccFileSession Receive(DccUserInfo dccUserInfo, DccFileInfo dccFileInfo, bool turbo)
{
Debug.WriteLineIf(DccUtil.DccTrace.TraceInfo, "[" + Thread.CurrentThread.Name + "] DccFileSession::Receive()");
//Test if we are already using this port
if (DccFileSessionManager.DefaultInstance.ContainsSession("C" + dccUserInfo.remoteEndPoint.Port))
{
throw new ArgumentException("Already listening on port " + dccUserInfo.remoteEndPoint.Port);
}
DccFileSession session = null;
try
{
session = new DccFileSession(dccUserInfo, dccFileInfo, (64 * 1024),
dccUserInfo.remoteEndPoint.Port, "C" + dccUserInfo.remoteEndPoint.Port);
//Has the initiator specified the turbo protocol?
session.turboMode = turbo;
//Open file for writing
dccFileInfo.OpenForWrite();
DccFileSessionManager.DefaultInstance.AddSession(session);
//Determine if we can resume a download
if (session.dccFileInfo.ShouldResume())
{
session.waitingOnAccept = true;
session.dccFileInfo.SetResumeToFileSize();
session.SendResume();
}
else
{
session.thread = new Thread(new ThreadStart(session.Download));
session.thread.Name = session.ToString();
session.thread.Start();
}
return(session);
}
catch (Exception e)
{
if (session != null)
{
DccFileSessionManager.DefaultInstance.RemoveSession(session);
}
throw e;
}
}
/// <summary>
/// Another user has offered to send a file. This method should be called
/// to accept the offer and save the file to the give location. The parameters
/// needed to call this method are provided by the <c>OnDccFileTransferRequest()</c>
/// event.
/// </summary>
/// <remarks>
/// This method should be called from within a try/catch block
/// in case it is unable to connect or there are other socket
/// errors.
/// </remarks>
/// <param name="dccUserInfo">Information on the remote user.</param>
/// <param name="dccFileInfo">The local file that will hold the data being sent. If the file
/// is the result of a previous incomplete download the the attempt will be made
/// to resume where the previous left off.</param>
/// <param name="turbo">Will the send ahead protocol be used.</param>
/// <returns>A unique session instance for this file and remote user.</returns>
/// <exception cref="ArgumentException">If the listen port is already in use.</exception>
public static DccFileSession Receive(DccUserInfo dccUserInfo, DccFileInfo dccFileInfo, bool turbo )
{
Debug.WriteLineIf( DccUtil.DccTrace.TraceInfo, "[" + Thread.CurrentThread.Name +"] DccFileSession::Receive()");
//Test if we are already using this port
if( DccFileSessionManager.DefaultInstance.ContainsSession( "C" + dccUserInfo.remoteEndPoint.Port ) )
{
throw new ArgumentException("Already listening on port " + dccUserInfo.remoteEndPoint.Port );
}
DccFileSession session = null;
try
{
session = new DccFileSession( dccUserInfo, dccFileInfo, (64 * 1024 ),
dccUserInfo.remoteEndPoint.Port, "C" + dccUserInfo.remoteEndPoint.Port );
//Has the initiator specified the turbo protocol?
session.turboMode = turbo;
//Open file for writing
dccFileInfo.OpenForWrite();
DccFileSessionManager.DefaultInstance.AddSession( session );
//Determine if we can resume a download
if( session.dccFileInfo.ShouldResume() )
{
session.waitingOnAccept = true;
session.dccFileInfo.SetResumeToFileSize();
session.SendResume();
}
else
{
session.thread = new Thread( new ThreadStart( session.Download ) );
session.thread.Name = session.ToString();
session.thread.Start();
}
return session;
}
catch( Exception e )
{
if( session != null )
{
DccFileSessionManager.DefaultInstance.RemoveSession( session );
}
throw e;
}
}
/// <summary>
/// Attempt to send a file to a remote user. Start listening
/// on the given port and address. If the remote user does not accept
/// the offer within the timeout period the the session
/// will be closed.
/// </summary>
/// <remarks>
/// This method should be called from within a try/catch block
/// in case there are socket errors. This methods will also automatically
/// handle a Resume if the remote client requests it.
/// </remarks>
/// <param name="dccUserInfo">The information about the remote user.</param>
/// <param name="listenIPAddress">The IP address of the local machine in dot
/// quad format (e.g. 192.168.0.25). This is the address that will be sent to the
/// remote user. The IP address of the NAT machine must be used if the
/// client is behind a NAT/Firewall system. </param>
/// <param name="listenPort">The port that the session will listen on.</param>
/// <param name="dccFileInfo">The file to be sent. If the file name has spaces in it
/// they will be replaced with underscores when the name is sent.</param>
/// <param name="bufferSize">The size of the send buffer. Generally should
/// be between 4k and 32k.</param>
/// <param name="turbo">True to use send-ahead mode for transfers.</param>
/// <returns>A unique session instance for this file and remote user.</returns>
/// <exception cref="ArgumentException">If the listen port is already in use.</exception>
public static DccFileSession Send(
DccUserInfo dccUserInfo,
string listenIPAddress,
int listenPort,
DccFileInfo dccFileInfo,
int bufferSize,
bool turbo)
{
Debug.WriteLineIf( DccUtil.DccTrace.TraceInfo, "[" + Thread.CurrentThread.Name +"] DccFileSession::Send()");
DccFileSession session = null;
//Test if we are already using this port
if( DccFileSessionManager.DefaultInstance.ContainsSession( "S" + listenPort ) )
{
throw new ArgumentException("Already listening on port " + listenPort );
}
try
{
session = new DccFileSession( dccUserInfo, dccFileInfo , bufferSize, listenPort, "S" + listenPort );
//set turbo mode
session.turboMode = turbo;
//Set server IP address
session.listenIPAddress = listenIPAddress;
//Add session to active sessions hashtable
DccFileSessionManager.DefaultInstance.AddSession( session );
//Create stream to file
dccFileInfo.OpenForRead();
//Start session Thread
session.thread = new Thread(new ThreadStart( session.Listen ) );
session.thread.Name = session.ToString();
session.thread.Start();
//Send DCC Send request to remote user
session.DccSend( IPAddress.Parse( listenIPAddress) );
return session;
}
catch( Exception e )
{
if( session != null )
{
DccFileSessionManager.DefaultInstance.RemoveSession( session );
}
throw e;
}
}
public void OnDccFileTransferRequest(DccUserInfo dccUserInfo, string fileName, int size, bool turbo )
{
try
{
//We need to pass the Receive() method a DccFileInfo which tells Thresher
//where to store the file. If this is an existing file that was only partially downloaded
//then Thresher will automatically Resume the file from where it left off. Size represents the total
//size in bytes of the file and is provided by the sender.
DccFileInfo dccFileInfo = new DccFileInfo( new FileInfo( directory + "\\" + fileName ), size );
//Using the DccFileInfo we created and the parameters from the event we can Receive the file.
//A large receive buffer works the best so 32k should be good.
DccFileSession session = DccFileSession.Receive( dccUserInfo, dccFileInfo, turbo );
//Use the FileClient as the single source of delegates for the file sessions.
session.OnFileTransferCompleted += new FileTransferCompletedEventHandler( OnFileTransferCompleted );
session.OnFileTransferInterrupted += new FileTransferInterruptedEventHandler( OnFileTransferInterrupted );
session.OnFileTransferStarted += new FileTransferStartedEventHandler( OnFileTransferStarted );
session.OnFileTransferTimeout += new FileTransferTimeoutEventHandler( OnFileTransferTimeout );
}
catch( Exception e )
{
Console.WriteLine("Error trying to receive file: " + e ) ;
}
}