// PCDMTransfer.cpp : Implementation of CPCDMTransfer
#include "stdafx.h"
#include "PCDMDLL.h"
#include "PCDMTransfer.h"

/////////////////////////////////////////////////////////////////////////////
// CPCDMTransfer

// <BOOK_ADDON Chapter 9.6.2> ******************************************
STDMETHODIMP CPCDMTransfer::SendString(BSTR Text)
{
#define NumRetries	500

SOCKET			sock;
SOCKADDR_IRDA	address = {AF_IRDA, 0,0,0,0, "PCDMIrDA"};
DEVICELIST		devList;    
SOCKERR			serr   = 0;
int				devListLen = sizeof(devList),
				cnt = 0,idx=0,len;
PACKET_FILE 	filePacket;
INT				cbWritten;
HRESULT			ret=S_OK;
BYTE			*Buffer;

	if (wsainit!=0) 
		return S_FALSE;	// Could not init WINSOCK
	len=(lstrlen(Text)+1)*sizeof(BSTR);
	Buffer=(BYTE *)Text;

	if ((sock = socket(AF_IRDA, SOCK_STREAM, 0))==INVALID_SOCKET)
		return S_FALSE;	// Could not init WINSOCK
    devList.numDevice = 0; // initialize number of devices to zero

    while ((devList.numDevice == 0) && (cnt <= NumRetries))    
	{
       	getsockopt(sock, SOL_IRLMP, IRLMP_ENUMDEVICES,
                   (char *)&devList, &devListLen);   
		cnt++;	// This time no wait !
	}
	if  (cnt > NumRetries)    
		return S_FALSE;
	else // We found a server
	{        // Get socket address of server
		for (idx = 0; idx <= 3; idx++)             
			address.irdaDeviceID[idx] =	devList.Device[0].irdaDeviceID[idx];
		serr=connect(sock, (struct sockaddr *)&address,	sizeof(SOCKADDR_IRDA));
		serr=( serr == SOCKET_ERROR ) ? WSAGetLastError() : 0;		      
		if( serr != 0 )	ret=S_FALSE;
		
		memset(filePacket.szFile,0,sizeof(filePacket.szFile));
		filePacket.type   = PACKET_TYPE_FILE;
		filePacket.cbFile = len;
		filePacket.PakSize= len+(4*sizeof(DWORD));
		filePacket.Code	= WM_SOCKET_SELECT;
		memcpy( filePacket.szFile, Buffer, len);
		cbWritten = send( sock,(CHAR FAR *)&filePacket,
				      len+(4*sizeof(DWORD)), 0 );
		serr=( cbWritten == SOCKET_ERROR ) ? WSAGetLastError() : 0;		      
		if( serr != 0 )	ret=S_FALSE;

		closesocket(sock);    
	}
	return ret;
}

STDMETHODIMP CPCDMTransfer::ReceiveString(BSTR *Text)
{
SOCKET          ClientSock; 
SOCKADDR_IRDA   address = {AF_IRDA, 0, 0, 0, 0, "PCDMIrDA"};
BYTE		   *tBuffer=NULL;
int				endless;
PACKET_FILE	    filePacket;
BYTE		   *recBuf;
INT				cbRead;
SOCKERR			serr;
HRESULT			ret=S_FALSE;
TCHAR tStr[200];

	if (wsainit!=0) 
	{
		wsprintf(tStr,TEXT("ERR: WsaInit Failed code=<%d>,<%d>,<%d>"),WSAGetLastError(),wsainit, wsadata.wVersion);
		*Text=SysAllocString(tStr);
		return S_FALSE;	
	}

    if ((sCommand = socket(AF_IRDA, SOCK_STREAM, 0))==SOCKET_ERROR)
	{
		wsprintf(tStr,TEXT("ERR: Socket code=<%d>"),WSAGetLastError());
		*Text=SysAllocString(tStr);
		return S_FALSE;	
	}
	if (bind(sCommand, (struct sockaddr *)&address, sizeof(address))==SOCKET_ERROR)
	{
		wsprintf(tStr,TEXT("ERR: Bind Failed code=<%d>"),WSAGetLastError());
		*Text=SysAllocString(tStr);
		return S_FALSE;	
	}
	listen(sCommand, 1);

	endless=TRUE;
	while (endless==TRUE)
	{
		ClientSock = accept(sCommand, 0, 0);
		if (ClientSock==SOCKET_ERROR) 
		{
			endless=FALSE;
			serr=WSAGetLastError();
		}
		recBuf=(BYTE *)&filePacket;
		cbRead=recv(ClientSock,(char *)recBuf,sizeof(filePacket), 0);
		if (ClientSock==INVALID_SOCKET)
			endless=FALSE;
		EnterCriticalSection(&m_csec);	
		switch (filePacket.type)
		{
			case PACKET_TYPE_FILE:
				if (filePacket.cbFile>0)
				{
					*Text=SysAllocString((TCHAR*)filePacket.szFile);
					endless=FALSE;
					ret=S_OK;
				}
				break;
			default:
				// Ignore all other Packets
				break;
		}
		LeaveCriticalSection(&m_csec);
	    closesocket(ClientSock); // Close Client Socket
	}
	return ret;
}

STDMETHODIMP CPCDMTransfer::CancelReceive()
{
LINGER linger;

	if (wsainit!=0) return S_FALSE;	// Could not init WINSOCK	if( sCommand != INVALID_SOCKET )
	if( sCommand != INVALID_SOCKET )
	{
		linger.l_onoff  = TRUE;
		linger.l_linger = 0;
		setsockopt(sCommand,SOL_SOCKET, SO_LINGER,
			     (CHAR FAR *)&linger,sizeof(linger) );
		closesocket( sCommand );
	}

	return S_OK;
}

// </BOOK_ADDON Chapter 9.6.2> ******************************************