//+------------------------------------------------------------------------- // // Microsoft Windows // // Copyright (C) Microsoft Corporation, 1997 - 1999 // // File: xfer.cxx // //-------------------------------------------------------------------------- #include "precomp.h" #include "ssdp.h" error_status_t MapWinsockErrorToWin32( error_status_t status ); DWORD MdWork( WCHAR *arg ); DWORD ReportFileError( DWORD mc, WCHAR * file, DWORD error ) { DWORD dwEventStatus = 0; EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus); if (!dwEventStatus) { TCHAR ErrorDescription[ERROR_DESCRIPTION_LENGTH]; if (!FormatMessage( FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM, 0, // ignored error, 0, // try default language ids ErrorDescription, ERROR_DESCRIPTION_LENGTH, 0 // ignored )) { wsprintf(ErrorDescription, L"0x%x", ErrorDescription); } WCHAR * Strings[2]; Strings[0] = file; Strings[1] = ErrorDescription; dwEventStatus = EventLog.ReportError(CAT_IRXFER, mc, 2, Strings); } return dwEventStatus; } #if 0 DWORD FILE_TRANSFER::Init() { DWORD Status = 0; ActiveTransferMutex = new MUTEX( &Status ); if (!ActiveTransferMutex) { Status = ERROR_NOT_ENOUGH_MEMORY; } if (Status) { goto lErr; } ArrayLength = 2; ActiveTransfers = new PFILE_TRANSFER[ ArrayLength ]; if (!ActiveTransfers) { Status = ERROR_NOT_ENOUGH_MEMORY; goto lErr; } memset(ActiveTransfers, 0, sizeof(PFILE_TRANSFER) * ArrayLength); return 0; lErr: delete ActiveTransfers; delete ActiveTransferMutex; return Status; } #endif FILE_TRANSFER::FILE_TRANSFER( ) { _refs = 1; _event = 0; _socket = INVALID_SOCKET; _cookie = 0; m_StopListening=FALSE; // for sock.c _fWriteable = FALSE; // for xfer.c _dataFileRecv.hFile = INVALID_HANDLE_VALUE; // for progress.c _fCancelled = FALSE; _fInUiReceiveList = FALSE; _CurrentPercentage = 0; _files = 0; _mutex = 0; _dataXferRecv.dwFileSent = 0; DbgLog2(SEV_INFO, "[0] %p: refs = %d\n", this, _refs); } FILE_TRANSFER::~FILE_TRANSFER() { if (_socket != INVALID_SOCKET) { // // Drain any remaining receive data to ensure our sent data is sent across the link. // #if 0 int bytes; do { bytes = recv( _socket, (char *) _buffer, cbSOCK_BUFFER_SIZE, 0 ); } while ( bytes != 0 && bytes != SOCKET_ERROR ); #endif closesocket( _socket ); _socket = INVALID_SOCKET; } if (_event) { CloseHandle( _event ); _event = 0; } if (_fInUiReceiveList) { ReceiveFinished( rpcBinding, _cookie, 0 ); } DeleteCriticalSection(&m_Lock); } unsigned long __stdcall SendFilesWrapper( PVOID arg ) { PFILE_TRANSFER(arg)->Send(); return 0; } #if 0 BOOL FILE_TRANSFER::Shutdown() { unsigned i; if (IrFileTransfer1 != NULL) { IrFileTransfer1->StopListening(); } if (IrFileTransfer2 != NULL) { IrFileTransfer2->StopListening(); } do { for (i=0; i < ArrayLength; ++i) { if (ActiveTransfers[i]) { Sleep(1000); break; } } } while ( i < ArrayLength ); return TRUE; } BOOL FILE_TRANSFER::AreThereActiveTransfers() { CLAIM_MUTEX Lock(ActiveTransferMutex); unsigned i; for (i=0; i < ArrayLength; ++i) { if (ActiveTransfers[i] && ActiveTransfers[i]->_state != ACCEPTING) { return TRUE; } } return FALSE; } #endif void FILE_TRANSFER::BeginSend( DWORD DeviceId, OBEX_DEVICE_TYPE DeviceType, error_status_t * pStatus, FAILURE_LOCATION * pLocation ) { DWORD status; DWORD dwFiles = 0L; DWORD dwFolders = 0L; __int64 dwTotalSize = 0L; status = Sock_EstablishConnection( DeviceId,DeviceType ); if( status ) { *pLocation = locConnect; goto lExit; } status = _GetObjListStats( _files, &dwFiles, &dwFolders, &dwTotalSize ); if (status) { *pLocation = locFileOpen; goto lExit; } _dataXferRecv.dwTotalSize = (DWORD) dwTotalSize; if( 0 == dwFiles && 0 == dwFolders ) goto lExit; // nothing to send status = Obex_Connect( dwTotalSize ); if (status) { *pLocation = locConnect; goto lExit; } _Send_StartXfer( dwTotalSize, 0 ); DWORD ThreadId; HANDLE ThreadHandle; ThreadHandle = CreateThread( 0, 0, SendFilesWrapper, this, 0, &ThreadId ); if (!ThreadHandle) { *pLocation = locStartup; status = GetLastError(); goto lExit; } CloseHandle( ThreadHandle ); lExit: if (status) { DecrementRefCount(); } *pStatus = status; } void FILE_TRANSFER::Send() { error_status_t status = 0; wchar_t * szObj; // // Protect ourselves from login or logout notifications while using the token. // { CLAIM_MUTEX Lock( g_Mutex ); if (g_UserToken == 0) { // // the send was aborted due to logging out. // return; } if (!ImpersonateLoggedOnUser(g_UserToken)) { DWORD dwEventStatus = 0; EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus); if (!dwEventStatus) { EventLog.ReportError(CAT_IRXFER, MC_IRXFER_SEND_IMP_FAILED, GetLastError()); } DbgLog1(SEV_ERROR, "can't impersonate, %d", GetLastError()); return; } } // // Avoid idle-time shutdowns. If the call fails, we want to continue anyway. // SetThreadExecutionState( ES_SYSTEM_REQUIRED | ES_CONTINUOUS ); // send the files one at a time for( szObj = _files; *szObj != 0; szObj += lstrlen(szObj)+1 ) { DbgLog1( SEV_INFO, "Sending %S", szObj ); UpdateSendProgress( rpcBinding, _cookie, szObj, _dataXferRecv.dwTotalSize, _completedFilesSize, &status ); if( DirectoryExists(szObj) ) { status = _SendFolder( szObj ); } else { status = _SendFile( szObj ); } if( status || g_fShutdown) { break; } } // // Re-enable idle-time shutdowns. // SetThreadExecutionState( ES_CONTINUOUS ); // // Make sure we show 100% for a completed transfer. // if (!status) { UpdateSendProgress( rpcBinding, _cookie, _dataFileRecv.szFileName, _dataXferRecv.dwTotalSize, _dataXferRecv.dwTotalSize, &status ); } if (status != ERROR_CANCELLED) { // don't overwrite the error unless there isn't one error_status_t errTemp; _Send_EndXfer(); errTemp = Obex_Disconnect( status ); if( !status ) { status = errTemp; } } RevertToSelf(); if( status ) { // status = MapWinsockErrorToWin32( status ); OneSendFileFailed( rpcBinding, _cookie, szObj, status, locFileSend, &status ); } SendComplete( rpcBinding, _cookie, _dataXferRecv.dwTotalSent, &status ); RemoveFromTransferList(this); DecrementRefCount(); } error_status_t MapWinsockErrorToWin32( error_status_t status ) { if (status) { DbgLog2(SEV_ERROR, "mapping error 0x%x (%d)", status, status); } if (status < WSABASEERR || status > WSABASEERR + 1000) { return status; } switch (status) { case WSAECONNREFUSED: return ERROR_CONNECTION_REFUSED; default: return ERROR_REQUEST_ABORTED; } } error_status_t _GetObjListStats( LPWSTR lpszObjList, LPDWORD lpdwFiles, LPDWORD lpdwFolders, __int64 * lpdwTotalSize ) { error_status_t status = 0; LPWSTR szObj; HANDLE hFile; // // Protect ourselves from login or logout notifications while using the token. // { CLAIM_MUTEX Lock( g_Mutex ); if (g_UserToken == 0) { // // the send was aborted due to logging out. // return ERROR_NOT_LOGGED_ON; } if (!ImpersonateLoggedOnUser(g_UserToken)) { DWORD dwEventStatus = 0; EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus); if (!dwEventStatus) { EventLog.ReportError(CAT_IRXFER, MC_IRXFER_SEND_IMP_FAILED, GetLastError()); } DbgLog1(SEV_ERROR, "can't impersonate, %d", GetLastError()); return GetLastError(); } } // get (a) number of files, (b) total file size for( szObj = lpszObjList; *szObj != 0; szObj += lstrlen(szObj)+1 ) { hFile = CreateFile( szObj, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); if( INVALID_HANDLE_VALUE == hFile ) { // if it's a directory, get the total size of its files if( DirectoryExists(szObj) ) { *lpdwTotalSize += GetDirectorySize( szObj ); (*lpdwFolders)++; continue; } else { DbgLog2(SEV_ERROR, "open file \'%S\' failed %d", szObj, GetLastError()); RevertToSelf(); ReportFileError( MC_IRXFER_OPEN_FAILED, szObj, GetLastError() ); return GetLastError(); } } *lpdwTotalSize += GetFileSize( hFile, NULL ); (*lpdwFiles)++; CloseHandle( hFile ); } RevertToSelf(); return 0; } BOOL FILE_TRANSFER::Xfer_Init( wchar_t * files, unsigned length, OBEX_DIALECT dialect, OBEX_DEVICE_TYPE DeviceType, BOOL CreateSocket, SOCKET ListenSocket ) { unsigned Timeout = 500; DWORD status = 0; m_ListenSocket=ListenSocket; _dialect = dialect; InitializeCriticalSection(&m_Lock); if (length) { _xferType = xferSEND; _files = new wchar_t[ length ]; if (!_files) { goto cleanup; } memcpy(_files, files, sizeof(wchar_t) * length ); } else { _xferType = xferRECV; _files = 0; } _mutex = new MUTEX( &status ); if (!_mutex) { goto cleanup; } _dataXferRecv.fXferInProgress = FALSE; m_DeviceType=DeviceType; if (CreateSocket) { if (DeviceType == TYPE_IRDA) { _socket = socket( AF_IRDA, SOCK_STREAM, 0); } else { _socket = socket( AF_INET, SOCK_STREAM, 0); } if (!_socket) { goto cleanup; } setsockopt( _socket, SOL_SOCKET, SO_RCVTIMEO, (char *) &Timeout, sizeof(Timeout)); } else { _socket = INVALID_SOCKET; } _event = CreateEvent( NULL, // no security TRUE, // manual-reset FALSE, // initially not set NULL // no name ); if (!_event) { goto cleanup; } _state = BLANK; _overlapped.hEvent = _event; _buffers.buf = (char *) _buffer; _buffers.len = cbSOCK_BUFFER_SIZE; _guard = GUARD_MAGIC; if ( !Obex_Init()) { goto cleanup; } #if 0 if ( !Activate()) { goto cleanup; } #endif return TRUE; cleanup: if (_files) { delete _files; } if (_mutex) { delete _mutex; } if (_socket != INVALID_SOCKET ) { closesocket( _socket ); } if (_event) { CloseHandle( _event ); } return FALSE; } error_status_t FILE_TRANSFER::Xfer_ConnStart() { _uObjsReceived = 0; _dataXferRecv.fXferInProgress = TRUE; _dataXferRecv.dwTotalSize = 0; _dataXferRecv.dwTotalSent = 0; return _SetReceiveFolder( NULL ); } VOID FILE_TRANSFER::Xfer_ConnEnd( VOID ) { _dataXferRecv.fXferInProgress = FALSE; } error_status_t FILE_TRANSFER::Xfer_SetPath( LPWSTR szPath ) { error_status_t status = 0; if( !szPath || lstrlen(szPath) == 0 ) { // set default receive folder return _SetReceiveFolder( NULL ); } if( lstrcmp(szPath, szPREVDIR) == 0 ) { // pop up a level WCHAR sz[MAX_PATH]; lstrcpy( sz, _szRecvFolder ); // remove trailing backslash if(bHasTrailingSlash(sz)) sz[lstrlen(sz)-1] = cNIL; // strip last folder off path StripFile( sz ); return _SetReceiveFolder( sz ); } // format szPath and append it to the current receive folder WCHAR szRFF[MAX_PATH]; LPWSTR lpsz; // remove preceding backslashes while( *szPath == cBACKSLASH ) szPath++; // remove anything after a backslash lpsz = szPath; while( *lpsz != cNIL && *lpsz != cBACKSLASH ) lpsz++; *lpsz = cNIL; lstrcpy( szRFF, _szRecvFolder ); GetUniqueName( szRFF, szPath, FALSE ); _uObjsReceived++; return _SetReceiveFolder( szRFF ); } VOID FILE_TRANSFER::Xfer_FileInit( VOID ) { _dataXferRecv.dwFileSize = 0; _dataXferRecv.dwFileSent = 0; FillMemory( &_dataFileRecv.filetime, sizeof(_dataFileRecv.filetime), (BYTE)-1 ); lstrcpy( _dataFileRecv.szFileName, L"" ); lstrcpy( _dataFileRecv.szFileSave, L"" ); lstrcpy( _dataFileRecv.szFileTemp, L"" ); } error_status_t FILE_TRANSFER::Xfer_FileSetName( LPWSTR szName ) { lstrcpy( _dataFileRecv.szFileName, szName ); return _FileStart(); } BOOL FILE_TRANSFER::Xfer_FileSetSize( BYTE4 b4Size ) { _dataXferRecv.dwFileSize = b4Size; return ( IsRoomForFile(_dataXferRecv.dwFileSize, _szRecvFolder) ); } error_status_t FILE_TRANSFER::Xfer_FileWriteBody( LPVOID lpvData, BYTE2 b2Size, BOOL fFinal ) { error_status_t status = 0; DWORD dwSize = b2Size; DWORD dwBytesWritten; DbgLog1( SEV_FUNCTION, "Xfer_WriteBody: %ld bytes", dwSize ); // has this file been opened yet? if( INVALID_HANDLE_VALUE == _dataFileRecv.hFile ) { ASSERT( 0 ); return ERROR_CANTOPEN; } // write the data to the file while( dwSize > 0 ) { BOOL fRet; fRet = WriteFile( _dataFileRecv.hFile, lpvData, dwSize, &dwBytesWritten, NULL ); if( !fRet ) { status = GetLastError(); break; } lpvData = (LPVOID)( (DWORD_PTR)lpvData + dwBytesWritten ); dwSize -= dwBytesWritten; _dataXferRecv.dwTotalSent += dwBytesWritten; _dataXferRecv.dwFileSent += dwBytesWritten; } if( fFinal ) { if (!status) { status = _FileEnd( TRUE ); } else { _FileEnd( TRUE ); } } return status; } VOID FILE_TRANSFER::Xfer_FileAbort( VOID ) { _FileEnd( FALSE ); } error_status_t FILE_TRANSFER::_FileStart() { WCHAR szFullPath[MAX_PATH]; WCHAR szBaseFile[MAX_PATH]; if (IsWorkstationLocked()) { DbgLog1(SEV_ERROR, "rejecting file %S because the workstation is locked", _dataFileRecv.szFileName ); return ERROR_ACCESS_DENIED; } // // Protect ourselves from login or logout notifications while using the token. // { CLAIM_MUTEX Lock( g_Mutex ); if (g_UserToken == 0) { // // the send was aborted due to logging out. // return ERROR_NOT_LOGGED_ON; } if (!ImpersonateLoggedOnUser(g_UserToken)) { DWORD dwEventStatus = 0; EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus); if (!dwEventStatus) { EventLog.ReportError(CAT_IRXFER, MC_IRXFER_MOVE_FAILED, GetLastError()); } DbgLog1(SEV_ERROR, "move: can't impersonate, %d", GetLastError()); return GetLastError(); } } // get path of file lstrcpy( szFullPath, _szRecvFolder ); // strip path to get the base filename lstrcpy( szBaseFile, _dataFileRecv.szFileName ); StripPath( szBaseFile ); GetUniqueName( szFullPath, szBaseFile, TRUE ); lstrcpy( _dataFileRecv.szFileSave, szFullPath ); DbgLog1( SEV_INFO, "Save file: [%S]", szFullPath ); GetTempPath( sizeof(szBaseFile)/sizeof(WCHAR), szBaseFile ); GetTempFileName( szBaseFile, TEMP_FILE_PREFIX, 0, szFullPath ); lstrcpy( _dataFileRecv.szFileTemp, szFullPath ); DbgLog1( SEV_INFO, "Temp file: [%S]", szFullPath ); { wchar_t RFF[1+MAX_PATH]; GetReceivedFilesFolder(RFF, MAX_PATH); wchar_t * PromptPath = _dataFileRecv.szFileSave + lstrlen(RFF); DbgLog2( SEV_INFO, "need to ask permission: \n new file = [%S]\n prompt file = [%S]", _dataFileRecv.szFileSave, PromptPath ); error_status_t status = GetPermission( rpcBinding, _cookie, PromptPath, FALSE ); if (status) { DbgLog2( SEV_ERROR, "permission check failed, cookie %p error %d", (void *) _cookie, status ); return status; } } // // Create the temporary file. // _dataFileRecv.hFile = CreateFile( szFullPath, GENERIC_WRITE, 0L, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); RevertToSelf(); if ( INVALID_HANDLE_VALUE == _dataFileRecv.hFile ) { ReportFileError( MC_IRXFER_OPEN_FAILED, szFullPath, GetLastError() ); return GetLastError(); } return 0; } error_status_t FILE_TRANSFER::_FileEnd( BOOL fSave ) { error_status_t status = 0; // set the date stamp if( _dataFileRecv.filetime.dwLowDateTime != (DWORD)-1 || _dataFileRecv.filetime.dwHighDateTime != (DWORD)-1 ) { if( INVALID_HANDLE_VALUE != _dataFileRecv.hFile ) SetFileTime( _dataFileRecv.hFile, NULL, NULL, &_dataFileRecv.filetime ); } if( INVALID_HANDLE_VALUE != _dataFileRecv.hFile ) { CloseHandle( _dataFileRecv.hFile ); _dataFileRecv.hFile = INVALID_HANDLE_VALUE; } if( fSave ) { _uObjsReceived++; // // Protect ourselves from login or logout notifications while using the token. // { CLAIM_MUTEX Lock( g_Mutex ); if (g_UserToken == 0) { // // the send was aborted due to logging out. // return ERROR_NOT_LOGGED_ON; } if (!ImpersonateLoggedOnUser(g_UserToken)) { DWORD dwEventStatus = 0; EVENT_LOG EventLog(WS_EVENT_SOURCE,&dwEventStatus); if (!dwEventStatus) { EventLog.ReportError(CAT_IRXFER, MC_IRXFER_MOVE_FAILED, GetLastError()); } DbgLog1(SEV_ERROR, "move: can't impersonate, %d", GetLastError()); return GetLastError(); } } if (!MoveFile( _dataFileRecv.szFileTemp, _dataFileRecv.szFileSave )) { status = GetLastError(); ReportFileError( MC_IRXFER_MOVE_FAILED, _dataFileRecv.szFileSave, status ); DbgLog3(SEV_ERROR, "%d moving %S -> %S", status, _dataFileRecv.szFileTemp, _dataFileRecv.szFileSave); } else { DbgLog2(SEV_INFO, "moved %S -> %S", _dataFileRecv.szFileTemp, _dataFileRecv.szFileSave); } RevertToSelf(); } else { DeleteFile( _dataFileRecv.szFileTemp ); } Xfer_FileInit(); return status; } error_status_t FILE_TRANSFER::_SetReceiveFolder( LPWSTR szFolder ) { error_status_t status = 0; WCHAR sz[MAX_PATH]; DbgLog1( SEV_FUNCTION, "_SetReceiveFolder: [%S]", (szFolder?szFolder : L"NULL") ); if (IsWorkstationLocked()) { DbgLog1(SEV_ERROR, "rejecting directory %S because the workstation is locked", szFolder ); return ERROR_ACCESS_DENIED; } GetReceivedFilesFolder( sz, sizeof(sz) ); // // Make sure the requested folder is within the root RFF, for security reasons. // if( szFolder && lstrlen(szFolder) > 0 ) { if( 0 == wcsncmp(sz, szFolder, lstrlen(sz)) ) { lstrcpy( _szRecvFolder, szFolder ); } else { // can't go outside the RFF tree; use the root RFF. // lstrcpy( _szRecvFolder, sz ); } } else { lstrcpy( _szRecvFolder, sz ); } // always end path with a backslash '\' if( bNoTrailingSlash(_szRecvFolder) ) lstrcat( _szRecvFolder, szBACKSLASH ); // // Get permission to create this directory, unless we have not yet called ReceiveInProgress. // This latter will be true only during the connect. This seems harmless: a malicious // client can only create a couple of empty directories in my desktop w/o authorization. // if (_fInUiReceiveList) { wchar_t * PromptPath = _szRecvFolder + lstrlen(sz); DbgLog2( SEV_INFO, "need to ask permission: \n new dir = [%S]\n prompt dir = [%S]", _szRecvFolder, PromptPath ); status = GetPermission( rpcBinding, _cookie, PromptPath, TRUE ); if (status) { DbgLog1( SEV_ERROR, "permission check failed %d", status ); return status; } } DbgLog1( SEV_INFO, "Setting Receive Folder: [%S]", _szRecvFolder ); if( !DirectoryExists( _szRecvFolder ) ) { status = MdWork( _szRecvFolder ); if (status) { ReportFileError( MC_IRXFER_CREATE_DIR_FAILED, _szRecvFolder, status ); } } DbgLog1( SEV_FUNCTION, "_SetReceiveFolder leave %d", status); return status; } VOID FILE_TRANSFER::_Send_StartXfer( __int64 dwTotalSize, LPWSTR szDst ) { _dataXferRecv.fXferInProgress = TRUE; _dataXferRecv.dwTotalSize = dwTotalSize; _dataXferRecv.dwTotalSent = 0; _completedFilesSize = 0; } VOID FILE_TRANSFER::_Send_EndXfer( VOID ) { _dataXferRecv.fXferInProgress = FALSE; } error_status_t FILE_TRANSFER::_SendFile( LPWSTR wszFile ) { error_status_t status = 0; DWORD dwFileTime = (DWORD)-1; HANDLE hFile; FILETIME filetime; DbgLog1(SEV_FUNCTION, "_SendFile( %S )", wszFile); lstrcpy( _dataFileRecv.szFileName, wszFile ); hFile = CreateFileW( wszFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); if( INVALID_HANDLE_VALUE == hFile ) goto lExit; if( !GetFileTime(hFile, NULL, NULL, &filetime) ) goto lExit; _dataXferRecv.dwFileSize = GetFileSize( hFile, NULL ); _dataXferRecv.dwFileSent = 0; status = Obex_PutBegin( wszFile, _dataXferRecv.dwFileSize, &filetime ); ExitOnErr( status ); status = _PutFileBody( hFile, wszFile ); ExitOnErr( status ); _completedFilesSize += _dataXferRecv.dwFileSize; lExit: DbgLog1( SEV_FUNCTION, "_SendFile leave [%d]", status ); CloseHandle( hFile ); return status; } error_status_t FILE_TRANSFER::_SendFolder( LPWSTR wszFolder ) { error_status_t status = 0; BOOL bContinue; HANDLE hFind = INVALID_HANDLE_VALUE; WCHAR wszDir[MAX_PATH]; WCHAR wszSpec[MAX_PATH]; WIN32_FIND_DATAW findData; // send this directory so it's created status = Obex_SetPath( wszFolder ); ExitOnErr( status ); // get base directory ending with backslash lstrcpy( wszDir, wszFolder ); if( bNoTrailingSlash(wszDir) ) lstrcatW( wszDir, szBACKSLASH ); // form search string lstrcpyW( wszSpec, wszDir ); lstrcatW( wszSpec, L"*.*" ); hFind = FindFirstFileW( wszSpec, &findData ); bContinue = ( hFind != INVALID_HANDLE_VALUE ); while( bContinue ) { WCHAR wszObj[cbMAX_SZ]; lstrcpyW( wszObj, wszDir ); lstrcatW( wszObj, findData.cFileName ); if( findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) { // weed out "." and ".." if( *(findData.cFileName) != cPERIOD ) { status = _SendFolder( wszObj ); } } else { status = _SendFile( wszObj ); } if( status ) break; bContinue = FindNextFileW( hFind, &findData ); } // pop out of this directory { error_status_t errTemp = Obex_SetPath( NULL ); // only set the error if there isn't one already if( !status ) status = errTemp; } ExitOnErr( status ); lExit: if ( hFind != INVALID_HANDLE_VALUE ) { FindClose( hFind ); } return status; } // if we have a file size of 0, we still want to write a // blank body once, hence fPutOnce error_status_t FILE_TRANSFER::_PutFileBody( HANDLE hFile, wchar_t FileName[] ) { error_status_t status = 0; BOOL fPutOnce = FALSE; DWORD dwRead; BYTE1 b1Send[cbSOCK_BUFFER_SIZE]; DWORD Extra = sizeof(b1Send) % (_dataRecv.b2MaxPacket-16); DbgLog( SEV_FUNCTION, "_PutFileBody" ); while( !status && !g_fShutdown) { BOOL fRet = ReadFile( hFile, b1Send, sizeof(b1Send) - Extra, &dwRead, NULL ); if( !fRet ) return GetLastError(); if( dwRead == 0 && fPutOnce ) break; _dataXferRecv.dwTotalSent += dwRead; _dataXferRecv.dwFileSent += dwRead; // NOTE: casting dwRead from 4 bytes to 2 bytes requires // cbSOCK_BUFFER_SIZE to fit into 2 bytes status = Obex_PutBody( FileName, b1Send, (BYTE2)dwRead, _dataXferRecv.dwFileSent == _dataXferRecv.dwFileSize ); fPutOnce = TRUE; } DbgLog1( SEV_FUNCTION, "_PutFileBody leave [%d]", status ); return status; } VOID FILE_TRANSFER::Xfer_SetSize( BYTE4 b4Size ) { _dataXferRecv.dwTotalSize = b4Size; } #if 0 PFILE_TRANSFER * FILE_TRANSFER::ActiveTransfers = 0; unsigned FILE_TRANSFER::ArrayLength = 0; MUTEX * FILE_TRANSFER::ActiveTransferMutex = 0; BOOL FILE_TRANSFER::Activate() { CLAIM_MUTEX Lock(ActiveTransferMutex); unsigned i; for (i=0; i < ArrayLength; ++i) { if (ActiveTransfers[i] == 0) { ActiveTransfers[i] = this; return TRUE; } } PFILE_TRANSFER * NewArray = new PFILE_TRANSFER[ 2 * ArrayLength ]; if (!NewArray) { return FALSE; } memcpy(NewArray, ActiveTransfers, sizeof(PFILE_TRANSFER) * ArrayLength); memset(NewArray+ArrayLength, 0, sizeof(PFILE_TRANSFER) * ArrayLength); NewArray[ArrayLength] = this; delete ActiveTransfers; ActiveTransfers = NewArray; ArrayLength *= 2; return TRUE; } void FILE_TRANSFER::Deactivate() { CLAIM_MUTEX Lock(ActiveTransferMutex); unsigned i; for (i=0; i < ArrayLength; ++i) { if (ActiveTransfers[i] == this) { ActiveTransfers[i] = 0; } } } FILE_TRANSFER * FILE_TRANSFER::FromCookie( __int64 cookie ) { CLAIM_MUTEX Lock(ActiveTransferMutex); unsigned i; for (i=0; i < ArrayLength; ++i) { if( ActiveTransfers[i] && // ActiveTransfers[i]->_xferType == xferSEND && ActiveTransfers[i]->_cookie == cookie) { if ( ActiveTransfers[i]->_fCancelled) { return 0; } ActiveTransfers[i]->IncrementRefCount(); return ActiveTransfers[i]; } } return 0; } #endif void FILE_TRANSFER::RecordDeviceName( SOCKADDR_IRDA * s ) { char buffer[sizeof(DEVICELIST) + 8*sizeof(IRDA_DEVICE_INFO)]; DEVICELIST * list = (DEVICELIST *) buffer; int size = sizeof(buffer); if (SOCKET_ERROR == getsockopt( _socket, SOL_IRLMP, IRLMP_ENUMDEVICES, buffer, &size)) { wcscpy( _DeviceName, g_UnknownDeviceName ); return; } for (unsigned i=0; i < list->numDevice; ++i) { if (0 == memcmp(list->Device[i].irdaDeviceID, s->irdaDeviceID, sizeof(s->irdaDeviceID))) { wchar_t * UnicodeDeviceName = SzToWsz(list->Device[i].irdaDeviceName); if (!UnicodeDeviceName) { break; } wcscpy( _DeviceName, UnicodeDeviceName ); MemFree( UnicodeDeviceName ); return; } } wcscpy( _DeviceName, g_UnknownDeviceName ); } void FILE_TRANSFER::RecordIpDeviceName( sockaddr_in * Address ) { char* IpAddressString; HOSTENT* HostName; // // try to resolve the address // HostName=gethostbyaddr((char*)&Address->sin_addr,sizeof(Address->sin_addr),AF_INET); if (HostName != NULL) { IpAddressString=HostName->h_name; } else { // // could not resolve the ip address // IpAddressString=inet_ntoa(Address->sin_addr); } wchar_t * UnicodeDeviceName = SzToWsz(IpAddressString); if (UnicodeDeviceName != NULL) { wcscpy( _DeviceName, UnicodeDeviceName ); MemFree( UnicodeDeviceName ); return; } wcscpy( _DeviceName, g_UnknownDeviceName ); return; } // // Code that I took from CMD.EXE // #define COLON ':' #define NULLC '\0' #define BSLASH '\\' BOOL IsValidDrv(TCHAR drv); /**************** START OF SPECIFICATIONS ***********************/ /* */ /* SUBROUTINE NAME: MdWork */ /* */ /* DESCRIPTIVE NAME: Make a directory */ /* */ /* FUNCTION: MdWork creates a new directory. */ /* */ /* INPUT: arg - a pointer to a NULL terminated string of the */ /* new directory to create. */ /* */ /* EXIT-NORMAL: returns zero if the directory is made */ /* successfully */ /* */ /* EXIT-ERROR: returns an error code otherwise */ /* */ /* EFFECTS: None. */ /* */ /**************** END OF SPECIFICATIONS *************************/ DWORD MdWork( WCHAR *arg ) { ULONG Status; WCHAR *lpw; WCHAR TempBuffer[MAX_PATH]; /* Check if drive is valid because Dosmkdir does not return invalid drive @@5 */ if ((arg[1] == COLON) && !IsValidDrv(*arg)) { return ERROR_INVALID_DRIVE; } if (!GetFullPathName(arg, MAX_PATH, TempBuffer, &lpw)) { return GetLastError(); } if (CreateDirectory( arg, NULL )) { return 0; } Status = GetLastError(); if (Status == ERROR_ALREADY_EXISTS) { return 0; } else if (Status != ERROR_PATH_NOT_FOUND) { return Status; } // // loop over input path and create any needed intermediary directories. // // Find the point in the string to begin the creation. Note, for UNC // names, we must skip the machine and the share // if (TempBuffer[1] == COLON) { // // Skip D:\ // lpw = TempBuffer+3; } else if (TempBuffer[0] == BSLASH && TempBuffer[1] == BSLASH) { // // Skip \\server\share\ // lpw = TempBuffer+2; while (*lpw && *lpw != BSLASH) { lpw++; } if (*lpw) { lpw++; } while (*lpw && *lpw != BSLASH) { lpw++; } if (*lpw) { lpw++; } } else { // // For some reason, GetFullPath has given us something we can't understand // return ERROR_CANNOT_MAKE; } // // Walk through the components creating them // while (*lpw) { // // Move forward until the next path separator // while (*lpw && *lpw != BSLASH) { lpw++; } // // If we've encountered a path character, then attempt to // make the given path. // if (*lpw == BSLASH) { *lpw = NULLC; if (!CreateDirectory( TempBuffer, NULL )) { Status = GetLastError(); if (Status != ERROR_ALREADY_EXISTS) { return ERROR_CANNOT_MAKE; } } *lpw++ = BSLASH; } } if (!CreateDirectory( TempBuffer, NULL )) { Status = GetLastError( ); if (Status != ERROR_ALREADY_EXISTS) { return Status; } } return 0; } /*** IsValidDrv - Check drive validity * * Purpose: * Check validity of passed drive letter. * * int IsValidDrv(WCHAR drv) * * Args: * drv - The letter of the drive to check * * Returns: * TRUE if drive is valid * FALSE if not * * Notes: * */ BOOL IsValidDrv(WCHAR drv) { WCHAR temp[4]; temp[ 0 ] = drv; temp[ 1 ] = COLON; temp[ 2 ] = BSLASH; temp[ 3 ] = NULLC; // // return of 0 or 1 mean can't determine or root // does not exists. // if (GetDriveType(temp) <= 1) return( FALSE ); else { return( TRUE ); } }