void FSPath::SetItem( int n, int cs, const void* v ) // n>=0 && n<=Count(); если n == Count то в конец добавляется еще один элемент { if ( n < 0 || n > Count() ) { return; } cacheCs = -2; if ( n == Count() ) { data.append( FSString( cs, v ) ); } else { data[n] = FSString( cs, v ); } }
FSString FSWin32Net::Uri( FSPath& path ) { NETRESOURCEW* p = _res.Get(); if ( p && p->lpRemoteName ) { return FSString( Utf16ToUnicode( p->lpRemoteName ).data() ); } return FSString( "Network" ); }
bool ParzeLink( FSPath& path, FSString& link ) { FSPath t( link ); if ( !path.IsAbsolute() && !t.IsAbsolute() ) { return false; } //не абсолютный путь int first = 0; if ( t.IsAbsolute() ) { path.Clear(); path.PushStr( FSString( "" ) ); first = 1; } for ( int i = first; i < t.Count(); i++ ) { FSString p = *( t.GetItem( i ) ); if ( p.IsDot() ) { continue; } if ( p.Is2Dot() ) { if ( path.Count() > 1 ) { path.Pop(); } } else { path.PushStr( p ); } } return true; }
clPtr<FS> ParzeFtpURI( const unicode_t* uri, FSPath& path, clPtr<FS>* checkFS, int count ) { path.Set( rootPathStr ); if ( !uri[0] ) { return clPtr<FS>(); } FSFtpParam param; const unicode_t* userDelimiter = FindFirstChar( uri, '@' ); if ( *userDelimiter ) { param.user = FSString( CS_UNICODE, uri, userDelimiter - uri ).GetUnicode(); uri = userDelimiter + 1; param.anonymous = false; } else { param.anonymous = true; } const unicode_t* host_port_End = FindFirstChar( uri, '/' ); const unicode_t* host_End = FindFirstChar( uri, ':' ); FSString host( CS_UNICODE, uri, ( ( host_End < host_port_End ) ? host_End : host_port_End ) - uri ); int port = 0; for ( const unicode_t* s = host_End + 1; s < host_port_End; s++ ) if ( *s >= '0' && *s <= '9' ) { port = port * 10 + ( *s - '0' ); } else { break; } if ( port > 0 && port < 65536 ) { param.port = port; } param.server = host.GetUnicode(); uri = host_port_End; FSString link = uri; if ( !ParzeLink( path, link ) ) { return clPtr<FS>(); } for ( int i = 0; i < count; i++ ) if ( checkFS[i].Ptr() && checkFS[i]->Type() == FS::FTP ) { FSFtp* p = ( FSFtp* )checkFS[i].Ptr(); FSFtpParam checkParam; p->GetParam( &checkParam ); if ( !CmpStr<const unicode_t>( param.server.Data(), checkParam.server.Data() ) && ( param.anonymous == checkParam.anonymous && ( param.anonymous || !CmpStr<const unicode_t>( param.user.Data(), checkParam.user.Data() ) ) ) && param.port == checkParam.port ) { return checkFS[i]; } } return new FSFtp( ¶m ); }
void FSTable::setValues(const char* anArray[], int size) { values.resize(size); for (int i=0; i<size; i++) values[i] = FSString(anArray[i]); }
void KbIntCallback( const char* name, int name_len, const char* instruction, int instruction_len, int num_prompts, const LIBSSH2_USERAUTH_KBDINT_PROMPT* prompts, LIBSSH2_USERAUTH_KBDINT_RESPONSE* responses, void** anstract ) { if ( num_prompts <= 0 ) { return; } if ( !kbdIntInfo ) { return; } try { std::vector<FSPromptData> pData( num_prompts ); int i; for ( i = 0; i < num_prompts; i++ ) { pData[i].visible = prompts[i].echo != 0; pData[i].prompt = utf8_to_unicode( CopyToStrZ( prompts[i].text, prompts[i].length ).data() ).data(); } static unicode_t userSymbol = '@'; if ( !kbdIntInfo->Prompt( utf8_to_unicode( "SFTP" ).data(), carray_cat<unicode_t>( kbdIntParam->user.Data(), &userSymbol, kbdIntParam->server.Data() ).data(), pData.data(), num_prompts ) ) { return; } for ( i = 0; i < num_prompts; i++ ) { std::vector<char> str = new_char_str( ( char* )FSString( pData[i].prompt.Data() ).Get( kbdIntParam->charset ) ); if ( str.data() ) { int l = strlen( str.data() ); responses[i].length = l; responses[i].text = ( char* ) malloc( l + 1 ); if ( responses[i].text ) { strcpy( responses[i].text, str.data() ); } } } } catch ( cexception* ex ) { fprintf( stderr, "exception in kbdint callback used with libssh2: %s\n", ex->message() ); ex->destroy(); } catch ( ... ) { fprintf( stderr, "excention (...) in kbdint callback used with libssh2\n" ); } }
// 2. Delegate file Uri to baseBS. Folder Uri is tmp:///folder/name#baseFSRootUri // - appears to work FSString FSTmp::Uri(FSPath& path) { FSTmpNode* n = rootDir.findByFsPath(&path); if (n && n->nodeType == FSTmpNode::NODE_FILE) return baseFS->Uri(n->baseFSPath); else { std::string ret(std::string("tmp://") + path.GetUtf8('/') + "#" + baseFS->Uri(rootPathName).GetUtf8()); return FSString(ret.c_str()); } }
void FSPath::_Set( int cs, const void* v ) { data.clear(); cacheCs = -2; if ( cs == CS_UNICODE ) { unicode_t* p = ( unicode_t* )v; if ( !*p ) { return; } while ( *p ) { unicode_t* t = p; while ( *t != '\\' && *t != '/' && *t ) { t++; } int len = t - p; data.append( FSString( cs, p, len ) ); p = ( *t ) ? t + 1 : t; } } else { char* p = ( char* )v; if ( !p || !*p ) { return; } while ( *p ) { char* t = p; while ( *t != '\\' && *t != '/' && *t ) { t++; } int len = t - p; data.append( FSString( cs, p, len ) ); p = ( *t ) ? t + 1 : t; } } }
FSString FSWin32Net::StrError( int err ) { if ( err == ERRNOSUPPORT ) { return FSString( "Operation not supported by net fs" ); } FSString ret; sys_char_t buf[1024]; ret.SetSys( sys_error_str( err, buf, 0x100 ) ); return ret; }
static void stripPathFromLastItem(FSPath& path) { FSString* lastItem = path.GetItem(path.Count() - 1); if (lastItem) { const unicode_t* lastU = lastItem->GetUnicode(); const unicode_t* lastDelim = unicode_strrchr(lastU, DIR_SPLITTER); if (lastDelim != 0) { path.SetItemStr(path.Count() - 1,FSString(lastDelim + 1)); } } }
FSString FSSftp::Uri( FSPath& path ) { MutexLock lock( &infoMutex ); //infoMutex!!! std::vector<char> a; char port[0x100]; snprintf( port, sizeof( port ), ":%i", _infoParam.port ); FSString server( _infoParam.server.Data() ); FSString user( _infoParam.user.Data() ); a = carray_cat<char>( "sftp://", user.GetUtf8(), "@", server.GetUtf8(), port, path.GetUtf8( '/' ) ); return FSString( CS_UTF8, a.data() ); }
void FSTable::decodeFromStream(FSInputStream* aStream) { #ifdef _DEBUG aStream->startDecoding(className()); #endif FSActionObject::decodeFromStream(aStream); int attributeCount = aStream->read(FSStream::UnsignedWord, 16); if (attributeCount > 0) { #ifdef _DEBUG aStream->startDecoding("array"); #endif for (int i=0; i<attributeCount; i++) { char* str = aStream->readString(); values.push_back(FSString(str)); delete [] str; } #ifdef _DEBUG aStream->endDecoding("array"); #endif } else { /* * Reset the length as Macromedia is using the length of a * table to hide coded following an empty table. */ length = 2; } #ifdef _DEBUG aStream->endDecoding(className()); #endif }
FSString FSSmb::Uri( FSPath& path ) { MutexLock lock( &mutex ); std::vector<char> a; if ( _param.server[0] ) { if ( _param.user[0] ) { a = carray_cat<char>( "smb://", const_cast<char*>( _param.user ), "@", const_cast<char*>( _param.server ), path.GetUtf8() ); } else { a = carray_cat<char>( "smb://", const_cast<char*>( _param.server ), path.GetUtf8() ); } } else { a = carray_cat<char>( "smb:/", path.GetUtf8() ); } return FSString( CS_UTF8, a.data() ); }
FSString FSSys::Uri( FSPath& path ) { unicode_t pref[0x100]; unicode_t* p = pref; if ( _drive > 0 && _drive < 'z' - 'a' + 1 ) //+1 ??? { *( p++ ) = 'A' + _drive; *( p++ ) = ':'; } else if ( _drive == -1 ) { *( p++ ) = '\\'; } else { *( p++ ) = '?'; *( p++ ) = ':'; } *p = 0; return FSString( carray_cat<unicode_t>( pref, path.GetUnicode() ).data() ); }
virtual FSString StrError( int err ) override { return FSString( "Operation is not supported" ); }
FSString FSSftp::StrError( int err ) { const char* s = ""; if ( err < -500 ) { switch ( err + 1000 ) { case LIBSSH2_ERROR_SOCKET_NONE: s = "LIBSSH2_ERROR_SOCKET_NONE"; break; case LIBSSH2_ERROR_BANNER_RECV: s = "LIBSSH2_ERROR_BANNER_RECV"; break; case LIBSSH2_ERROR_BANNER_SEND: s = "LIBSSH2_ERROR_BANNER_SEND"; break; case LIBSSH2_ERROR_INVALID_MAC: s = "LIBSSH2_ERROR_INVALID_MAC"; break; case LIBSSH2_ERROR_KEX_FAILURE: s = "LIBSSH2_ERROR_KEX_FAILURE"; break; case LIBSSH2_ERROR_ALLOC: s = "LIBSSH2_ERROR_ALLOC"; break; case LIBSSH2_ERROR_SOCKET_SEND: s = "LIBSSH2_ERROR_SOCKET_SEND"; break; case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE: s = "LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE"; break; case LIBSSH2_ERROR_TIMEOUT: s = "LIBSSH2_ERROR_TIMEOUT"; break; case LIBSSH2_ERROR_HOSTKEY_INIT: s = "LIBSSH2_ERROR_HOSTKEY_INIT"; break; case LIBSSH2_ERROR_HOSTKEY_SIGN: s = "LIBSSH2_ERROR_HOSTKEY_SIGN"; break; case LIBSSH2_ERROR_DECRYPT: s = "LIBSSH2_ERROR_DECRYPT"; break; case LIBSSH2_ERROR_SOCKET_DISCONNECT: s = "LIBSSH2_ERROR_SOCKET_DISCONNECT"; break; case LIBSSH2_ERROR_PROTO: s = "LIBSSH2_ERROR_PROTO"; break; case LIBSSH2_ERROR_PASSWORD_EXPIRED: s = "LIBSSH2_ERROR_PASSWORD_EXPIRED"; break; case LIBSSH2_ERROR_FILE: s = "LIBSSH2_ERROR_FILE"; break; case LIBSSH2_ERROR_METHOD_NONE: s = "LIBSSH2_ERROR_METHOD_NONE"; break; case LIBSSH2_ERROR_AUTHENTICATION_FAILED: s = "Authentication failed"; break; case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED: s = "LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED"; break; case LIBSSH2_ERROR_CHANNEL_OUTOFORDER: s = "LIBSSH2_ERROR_CHANNEL_OUTOFORDER"; break; case LIBSSH2_ERROR_CHANNEL_FAILURE: s = "LIBSSH2_ERROR_CHANNEL_FAILURE"; break; case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED: s = "LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED"; break; case LIBSSH2_ERROR_CHANNEL_UNKNOWN: s = "LIBSSH2_ERROR_CHANNEL_UNKNOWN"; break; case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED: s = "LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED"; break; case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED: s = "LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED"; break; case LIBSSH2_ERROR_CHANNEL_CLOSED: s = "LIBSSH2_ERROR_CHANNEL_CLOSED"; break; case LIBSSH2_ERROR_CHANNEL_EOF_SENT: s = "LIBSSH2_ERROR_CHANNEL_EOF_SENT"; break; case LIBSSH2_ERROR_SCP_PROTOCOL: s = "LIBSSH2_ERROR_SCP_PROTOCOL"; break; case LIBSSH2_ERROR_ZLIB: s = "LIBSSH2_ERROR_ZLIB"; break; case LIBSSH2_ERROR_SOCKET_TIMEOUT: s = "LIBSSH2_ERROR_SOCKET_TIMEOUT"; break; case LIBSSH2_ERROR_SFTP_PROTOCOL: s = "LIBSSH2_ERROR_SFTP_PROTOCOL"; break; case LIBSSH2_ERROR_REQUEST_DENIED: s = "LIBSSH2_ERROR_REQUEST_DENIED"; break; case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED: s = "LIBSSH2_ERROR_METHOD_NOT_SUPPORTED"; break; case LIBSSH2_ERROR_INVAL: s = "LIBSSH2_ERROR_INVAL"; break; case LIBSSH2_ERROR_INVALID_POLL_TYPE: s = "LIBSSH2_ERROR_INVALID_POLL_TYPE"; break; case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL: s = "LIBSSH2_ERROR_PUBLICKEY_PROTOCOL"; break; case LIBSSH2_ERROR_EAGAIN: s = "LIBSSH2_ERROR_EAGAIN"; break; case LIBSSH2_ERROR_BUFFER_TOO_SMALL: s = "LIBSSH2_ERROR_BUFFER_TOO_SMALL"; break; case LIBSSH2_ERROR_BAD_USE: s = "LIBSSH2_ERROR_BAD_USE"; break; case LIBSSH2_ERROR_COMPRESS: s = "LIBSSH2_ERROR_COMPRESS"; break; case LIBSSH2_ERROR_OUT_OF_BOUNDARY: s = "LIBSSH2_ERROR_OUT_OF_BOUNDARY"; break; case LIBSSH2_ERROR_AGENT_PROTOCOL: s = "LIBSSH2_ERROR_AGENT_PROTOCOL"; break; case LIBSSH2_ERROR_SOCKET_RECV: s = "LIBSSH2_ERROR_SOCKET_RECV"; break; case LIBSSH2_ERROR_ENCRYPT: s = "LIBSSH2_ERROR_ENCRYPT"; break; case LIBSSH2_ERROR_BAD_SOCKET: s = "LIBSSH2_ERROR_BAD_SOCKET"; break; default: s = "LIBSSH2_ERROR_???"; break; } } else { switch ( err ) { case SSH_INTERROR_NOTSUPPORT: s = "not supported operation"; break; case SSH_INTERROR_X3: s = "X3"; break; case SSH_INTERROR_CONNECT: s = "connection failed"; break; case SSH_INTERROR_AUTH: s = "authorization failed"; break; case SSH_INTERROR_FATAL: s = "fatal ssh error"; break; case SSH_INTERROR_STOPPED: s = "Process stopped"; break; default: if ( err >= 0 ) { sys_char_t buf[0x100]; FSString str; str.SetSys( sys_error_str( err, buf, 0x100 ) ); return str; } char buf[0x100]; snprintf( buf, sizeof( buf ), "err : %i ???", err ); FSString str( CS_UTF8, buf ); return str; } } return FSString( CS_UTF8, s ); }
int FSSftp::CheckSession( int* err, FSCInfo* info ) { if ( sshSession ) { return 0; } try { unsigned ip; int e; if ( !GetHostIp( unicode_to_utf8( _operParam.server.Data() ).data(), &ip, &e ) ) { throw int( e ); } _sock.Create(); _sock.Connect( ntohl( ip ), _operParam.port ); sshSession = libssh2_session_init(); if ( !sshSession ) { throw int( SSH_INTERROR_X3 ); } libssh2_session_set_blocking( sshSession, 0 ); WHILE_EAGAIN_( e, libssh2_session_handshake( sshSession, _sock.Id() ) ); if ( e ) { throw int( e - 1000 ); } FSString userName = ""; if ( _operParam.user.Data()[0] ) { userName = _operParam.user.Data(); } else { #ifndef _WIN32 char* ret = getenv( "LOGNAME" ); if ( ret ) { userName = FSString( sys_charset_id, ret ); _operParam.user = userName.GetUnicode(); MutexLock infoLock( &infoMutex ); _infoParam.user = userName.GetUnicode(); } #endif }; char* authList = 0; char* charUserName = ( char* )userName.Get( _operParam.charset ); while ( true ) { authList = libssh2_userauth_list( sshSession, charUserName, strlen( charUserName ) ); if ( authList ) { break; } CheckSessionEagain(); WaitSocket( info ); } //publickey,password,keyboard-interactive static const char passId[] = "password"; static const char kInterId[] = "keyboard-interactive"; static unicode_t userSymbol = '@'; while ( true ) { if ( !strncmp( authList, passId, strlen( passId ) ) ) { FSPromptData data; data.visible = false; data.prompt = utf8_to_unicode( "Password:"******"SFTP_" ).data(), carray_cat<unicode_t>( userName.GetUnicode(), &userSymbol, _operParam.server.Data() ).data(), &data, 1 ) ) { throw int( SSH_INTERROR_STOPPED ); } int ret; WHILE_EAGAIN_( ret, libssh2_userauth_password( sshSession, ( char* )FSString( _operParam.user.Data() ).Get( _operParam.charset ), ( char* )FSString( data.prompt.Data() ).Get( _operParam.charset ) ) ); if ( ret ) { throw int( ret - 1000 ); } break; //!!! } else if ( !strncmp( authList, kInterId, strlen( kInterId ) ) ) { MutexLock lock( &kbdIntMutex ); kbdIntInfo = info; kbdIntParam = &_operParam; int ret; WHILE_EAGAIN_( ret, libssh2_userauth_keyboard_interactive( sshSession, ( char* )FSString( _operParam.user.Data() ).Get( _operParam.charset ), KbIntCallback ) ); if ( ret ) { throw int( ret - 1000 ); } break; //!!! } char* s = authList; while ( *s && *s != ',' ) { s++; } if ( !*s ) { break; } authList = s + 1; }; while ( true ) { sftpSession = libssh2_sftp_init( sshSession ); if ( sftpSession ) { break; } if ( !sftpSession ) { int e = libssh2_session_last_errno( sshSession ); if ( e != LIBSSH2_ERROR_EAGAIN ) { throw int( e - 1000 ); } } WaitSocket( info ); } return 0; } catch ( int e ) { if ( err ) { *err = e; } //if (sftpSession) ??? похоже закрытие сессии все решает if ( sshSession ) { libssh2_session_free( sshSession ); } sshSession = 0; sftpSession = 0; _sock.Close( false ); return ( e == -2 ) ? -2 : -1; } }
FSString FSSftp::StrError( int err ) { const char* s = ""; switch ( err ) { case SSH_INTERROR_NOTSUPPORT: s = "not supported operation"; break; case SSH_INTERROR_X3: s = "X3"; break; case SSH_INTERROR_CONNECT: s = "connection failed"; break; case SSH_INTERROR_AUTH: s = "authorization failed"; break; case SSH_INTERROR_FATAL: s = "fatal ssh error"; break; case SSH_INTERROR_STOPPED: s = "Process stopped"; break; case SSH_FX_OK: s = "No error"; break; case SSH_FX_EOF: s = "End-of-file encountered"; break; case SSH_FX_NO_SUCH_FILE: s = "File doesn't exist"; break; case SSH_FX_PERMISSION_DENIED: s = "Permission denied"; break; case SSH_FX_FAILURE: s = "Generic failure"; break; case SSH_FX_BAD_MESSAGE: s = "Garbage received from server"; break; case SSH_FX_NO_CONNECTION: s = "No connection has been set up"; break; case SSH_FX_CONNECTION_LOST: s = "There was a connection, but we lost it"; break; case SSH_FX_OP_UNSUPPORTED: s = "Operation not supported by the server"; break; case SSH_FX_INVALID_HANDLE: s = "Invalid file handle"; break; case SSH_FX_NO_SUCH_PATH: s = "No such file or directory path exists"; break; case SSH_FX_FILE_ALREADY_EXISTS: s = "An attempt to create an already existing file or directory has been made"; break; case SSH_FX_WRITE_PROTECT: s = "We are trying to write on a write-protected filesystem"; break; case SSH_FX_NO_MEDIA: s = "No media in remote drive"; break; /* case SSH_NO_ERROR: s = "no error"; break; case SSH_REQUEST_DENIED: s = "recoverable error"; break; case SSH_FATAL: s = "fatal ssh error"; break; case SSH_INTERROR_OUTOF: s = "out of invernal sftp vfs resources"; break; */ default: s = "???"; break; } return FSString( CS_UTF8, s ); }
int FSSftp::CheckSession( int* err, FSCInfo* info ) { if ( sshSession ) { return 0; } try { sshSession = ssh_new(); if ( !sshSession ) { throw int( SSH_INTERROR_X3 ); } if ( ssh_options_set( sshSession, SSH_OPTIONS_HOST, unicode_to_utf8( _operParam.server.Data() ).ptr() ) ) { throw int( SSH_INTERROR_X3 ); } int port = _operParam.port; if ( ssh_options_set( sshSession, SSH_OPTIONS_PORT, &port ) ) { throw int( SSH_INTERROR_X3 ); } FSString userName = ""; if ( _operParam.user.Data()[0] ) { userName = _operParam.user.Data(); } else { char* ret = getenv( "LOGNAME" ); if ( ret ) { userName = FSString( sys_charset_id, ret ); _operParam.user = userName.GetUnicode(); MutexLock infoLock( &infoMutex ); _infoParam.user = userName.GetUnicode(); } }; if ( ssh_options_set( sshSession, SSH_OPTIONS_USER, ( char* )userName.Get( _operParam.charset ) ) ) //есть сомнения, что надо все таки в utf8 { throw int( SSH_INTERROR_X3 ); } if ( ssh_connect( sshSession ) != SSH_OK ) { throw int( SSH_INTERROR_CONNECT ); } int method = ssh_userauth_list( sshSession, 0 ); int ret; static unicode_t userSymbol = '@'; if ( method & SSH_AUTH_METHOD_PASSWORD ) { FSPromptData data; data.visible = false; data.prompt = utf8_to_unicode( "Password:"******"SFTP_" ).ptr(), carray_cat<unicode_t>( userName.GetUnicode(), &userSymbol, _operParam.server.Data() ).ptr(), &data, 1 ) ) { throw int( SSH_INTERROR_STOPPED ); } ret = ssh_userauth_password( sshSession, ( char* )FSString( _operParam.user.Data() ).Get( _operParam.charset ), ( char* )FSString( data.prompt.Data() ).Get( _operParam.charset ) ); } if ( ret != SSH_AUTH_SUCCESS && ( method & SSH_AUTH_METHOD_INTERACTIVE ) != 0 ) { while ( true ) { ret = ssh_userauth_kbdint( sshSession, 0, 0 ); if ( ret != SSH_AUTH_INFO ) { break; } const char* instruction = ssh_userauth_kbdint_getinstruction( sshSession ); if ( !instruction ) { instruction = ""; } int n = ssh_userauth_kbdint_getnprompts( sshSession ); if ( n <= 0 ) { continue; } std::vector<FSPromptData> pData( n ); int i; for ( i = 0; i < n; i++ ) { char echo; const char* prompt = ssh_userauth_kbdint_getprompt( sshSession, i, &echo ); if ( !prompt ) { break; } pData[i].visible = echo != 0; pData[i].prompt = utf8_to_unicode( prompt ).ptr(); } if ( !info ) { throw int( SSH_INTERROR_AUTH ); } if ( !info->Prompt( utf8_to_unicode( "SFTP" ).ptr(), carray_cat<unicode_t>( userName.GetUnicode(), &userSymbol, _operParam.server.Data() ).ptr(), pData.ptr(), n ) ) { throw int( SSH_INTERROR_STOPPED ); } for ( i = 0; i < n; i++ ) { if ( ssh_userauth_kbdint_setanswer( sshSession, i, ( char* )FSString( pData[i].prompt.Data() ).Get( _operParam.charset ) ) < 0 ) { throw int( SSH_INTERROR_AUTH ); } } } } if ( ret != SSH_AUTH_SUCCESS ) { if ( ret == SSH_AUTH_PARTIAL ) { throw int( SSH_INTERROR_UNSUPPORTED_AUTH ); } else { throw int( SSH_INTERROR_AUTH ); } } sftpSession = sftp_new( sshSession ); if ( !sftpSession ) { throw int( SSH_INTERROR_FATAL ); } if ( sftp_init( sftpSession ) != SSH_OK ) { throw int( SSH_INTERROR_FATAL ); } } catch ( int e ) { if ( err ) { *err = e; } if ( sftpSession ) { sftp_free( sftpSession ); } if ( sshSession ) { ssh_free( sshSession ); } sshSession = 0; sftpSession = 0; return ( e == SSH_INTERROR_STOPPED ) ? -2 : -1; } return 0; }
clFileAttributesWin( NCDialogParent* parent, PanelWin* Panel ) : NCVertDialog( ::createDialogAsChild, 0, parent, utf8_to_unicode(_LT("Attributes")).data(), bListOkCancel ) , m_Panel( Panel ) , m_Node( Panel ? Panel->GetCurrent() : nullptr ) , m_URI( Panel ? Panel->UriOfCurrent() : FSString() ) , m_Layout( 17, 3 ) , m_CaptionText( 0, this, utf8_to_unicode( _LT( "" ) ).data(), nullptr, StaticLine::CENTER ) , m_FileNameText( uiValue, this, utf8_to_unicode( _LT( "" ) ).data(), nullptr, StaticLine::CENTER ) #if defined(_WIN32) , m_ReadOnly( uiVariable, this, utf8_to_unicode( _LT( "Read only" ) ).data(), 0, false ) , m_Archive( uiVariable, this, utf8_to_unicode( _LT( "Archive" ) ).data(), 0, false ) , m_Hidden( uiVariable, this, utf8_to_unicode( _LT( "Hidden" ) ).data(), 0, false ) , m_System( uiVariable, this, utf8_to_unicode( _LT( "System" ) ).data(), 0, false ) , m_Compressed( 0, this, utf8_to_unicode( _LT( "Compressed" ) ).data(), 0, false ) , m_Encrypted( 0, this, utf8_to_unicode( _LT( "Encrypted" ) ).data(), 0, false ) , m_NotIndexed( 0, this, utf8_to_unicode( _LT( "NotIndexed" ) ).data(), 0, false ) , m_Sparse( 0, this, utf8_to_unicode( _LT( "Sparse" ) ).data(), 0, false ) , m_Temporary( 0, this, utf8_to_unicode( _LT( "Temporary" ) ).data(), 0, false ) , m_Offline( 0, this, utf8_to_unicode( _LT( "Offline" ) ).data(), 0, false ) , m_ReparsePoint( 0, this, utf8_to_unicode( _LT( "ReparsePoint" ) ).data(), 0, false ) , m_Virtual( 0, this, utf8_to_unicode( _LT( "Virtual" ) ).data(), 0, false ) #else , m_UserRead( uiVariable, this, utf8_to_unicode( _LT( "User &read" ) ).data(), 0, false ) , m_UserWrite( uiVariable, this, utf8_to_unicode( _LT( "User &write" ) ).data(), 0, false ) , m_UserExecute( uiVariable, this, utf8_to_unicode( _LT( "User e&xecute" ) ).data(), 0, false ) , m_GroupRead( uiVariable, this, utf8_to_unicode( _LT( "&Group read" ) ).data(), 0, false ) , m_GroupWrite( uiVariable, this, utf8_to_unicode( _LT( "Group write" ) ).data(), 0, false ) , m_GroupExecute( uiVariable, this, utf8_to_unicode( _LT( "Group execute" ) ).data(), 0, false ) , m_OthersRead( uiVariable, this, utf8_to_unicode( _LT( "&Others read" ) ).data(), 0, false ) , m_OthersWrite( uiVariable, this, utf8_to_unicode( _LT( "Others write" ) ).data(), 0, false ) , m_OthersExecute( uiVariable, this, utf8_to_unicode( _LT( "Others execute" ) ).data(), 0, false ) #endif // time , m_LastWriteTimeLabel( 0, this, utf8_to_unicode( _LT( "Last write time" ) ).data(), nullptr, StaticLine::LEFT ) , m_CreationTimeLabel( 0, this, utf8_to_unicode( _LT( "Creation time" ) ).data(), nullptr, StaticLine::LEFT ) , m_LastAccessTimeLabel( 0, this, utf8_to_unicode( _LT( "Last access time" ) ).data(), nullptr, StaticLine::LEFT ) , m_ChangeTimeLabel( 0, this, utf8_to_unicode( _LT( "Change time" ) ).data(), nullptr, StaticLine::LEFT ) // , m_LastWriteDate( 0, this, nullptr, utf8_to_unicode( _LT( "DD.MM.YYYY" ) ).data(), 9 ) , m_CreationDate( 0, this, nullptr, utf8_to_unicode( _LT( "DD.MM.YYYY" ) ).data(), 9 ) , m_LastAccessDate( 0, this, nullptr, utf8_to_unicode( _LT( "DD.MM.YYYY" ) ).data(), 9 ) , m_ChangeDate( 0, this, nullptr, utf8_to_unicode( _LT( "DD.MM.YYYY" ) ).data(), 9 ) // , m_LastWriteTime( 0, this, nullptr, utf8_to_unicode( _LT( "HH:MM:SS" ) ).data(), 13 ) , m_CreationTime( 0, this, nullptr, utf8_to_unicode( _LT( "HH:MM:SS" ) ).data(), 13 ) , m_LastAccessTime( 0, this, nullptr, utf8_to_unicode( _LT( "HH:MM:SS" ) ).data(), 13 ) , m_ChangeTime( 0, this, nullptr, utf8_to_unicode( _LT( "HH:MM:SS" ) ).data(), 13 ) { if ( m_Panel ) { const unicode_t* FileName = m_Panel->GetCurrentFileName(); m_FileNameText.SetText( FileName ); } if ( m_Node && m_Node->IsDir() ) { m_CaptionText.SetText( utf8_to_unicode( _LT("Change attributes for folder:") ).data() ); } else { m_CaptionText.SetText( utf8_to_unicode( _LT("Change file attributes for:") ).data() ); } int Row = 0; m_Layout.AddWinAndEnable( &m_CaptionText, Row, 0, Row, 2 ); Row++; m_Layout.AddWinAndEnable( &m_FileNameText, Row, 0, Row, 2 ); Row++; int TRow = Row; #if defined(_WIN32) m_Layout.AddWinAndEnable( &m_ReadOnly, Row++, 0 ); m_Layout.AddWinAndEnable( &m_Archive, Row++, 0 ); m_Layout.AddWinAndEnable( &m_Hidden, Row++, 0 ); m_Layout.AddWinAndEnable( &m_System, Row++, 0 ); m_Layout.AddWinAndEnable( &m_Compressed, Row++, 0 ); m_Layout.AddWinAndEnable( &m_Encrypted, Row++, 0 ); Row = TRow; m_Layout.AddWinAndEnable( &m_NotIndexed, Row++, 1 ); m_Layout.AddWinAndEnable( &m_Sparse, Row++, 1 ); m_Layout.AddWinAndEnable( &m_Temporary, Row++, 1 ); m_Layout.AddWinAndEnable( &m_Offline, Row++, 1 ); m_Layout.AddWinAndEnable( &m_ReparsePoint, Row++, 1 ); m_Layout.AddWinAndEnable( &m_Virtual, Row++, 1 ); // disable editing of these properties m_Compressed.Enable( false ); m_Encrypted.Enable( false ); m_NotIndexed.Enable( false ); m_Sparse.Enable( false ); m_Temporary.Enable( false ); m_Offline.Enable( false ); m_ReparsePoint.Enable( false ); m_Virtual.Enable( false ); #else m_Layout.AddWinAndEnable( &m_UserRead, Row, 0 ); m_Layout.AddWinAndEnable( &m_UserWrite, Row, 1 ); m_Layout.AddWinAndEnable( &m_UserExecute, Row, 2 ); Row++; m_Layout.AddWinAndEnable( &m_GroupRead, Row, 0 ); m_Layout.AddWinAndEnable( &m_GroupWrite, Row, 1 ); m_Layout.AddWinAndEnable( &m_GroupExecute, Row, 2 ); Row++; m_Layout.AddWinAndEnable( &m_OthersRead, Row, 0 ); m_Layout.AddWinAndEnable( &m_OthersWrite, Row, 1 ); m_Layout.AddWinAndEnable( &m_OthersExecute, Row, 2 ); #endif m_Layout.LineSet( Row++, 5 ); TRow = Row; m_Layout.AddWinAndEnable( &m_LastWriteTimeLabel, Row++, 0 ); m_Layout.AddWinAndEnable( &m_CreationTimeLabel, Row++, 0 ); m_Layout.AddWinAndEnable( &m_LastAccessTimeLabel, Row++, 0 ); #if defined(HAS_CHANGETIME) m_Layout.AddWinAndEnable( &m_ChangeTimeLabel, Row++, 0 ); #endif Row = TRow; m_Layout.AddWinAndEnable( &m_LastWriteDate, Row++, 1 ); m_Layout.AddWinAndEnable( &m_CreationDate, Row++, 1 ); m_Layout.AddWinAndEnable( &m_LastAccessDate, Row++, 1 ); #if defined(HAS_CHANGETIME) m_Layout.AddWinAndEnable( &m_ChangeDate, Row++, 1 ); #endif Row = TRow; m_Layout.AddWinAndEnable( &m_LastWriteTime, Row++, 2 ); m_Layout.AddWinAndEnable( &m_CreationTime, Row++, 2 ); m_Layout.AddWinAndEnable( &m_LastAccessTime, Row++, 2 ); #if defined(HAS_CHANGETIME) m_Layout.AddWinAndEnable( &m_ChangeTime, Row++, 2 ); #endif m_LastWriteDate.SetValidator( new clDateValidator() ); m_LastWriteDate.SetReplaceMode( true ); m_CreationDate.SetValidator( new clDateValidator() ); m_CreationDate.SetReplaceMode( true ); m_LastAccessDate.SetValidator( new clDateValidator() ); m_LastAccessDate.SetReplaceMode( true ); #if defined(HAS_CHANGETIME) m_ChangeDate.SetValidator( new clDateValidator() ); m_ChangeDate.SetReplaceMode( true ); #endif m_LastWriteTime.SetValidator( new clTimeValidator() ); m_LastWriteTime.SetReplaceMode( true ); m_CreationTime.SetValidator( new clTimeValidator() ); m_CreationTime.SetReplaceMode( true ); m_LastAccessTime.SetValidator( new clTimeValidator() ); m_LastAccessTime.SetReplaceMode( true ); #if defined(HAS_CHANGETIME) m_ChangeTime.SetValidator( new clTimeValidator() ); m_ChangeTime.SetReplaceMode( true ); #endif UpdateAttributes( m_Node ); AddLayout( &m_Layout ); order.clear(); #if defined(_WIN32) order.append(&m_ReadOnly); order.append(&m_Archive); order.append(&m_Hidden); order.append(&m_System); #else order.append(&m_UserRead); order.append(&m_UserWrite); order.append(&m_UserExecute); order.append(&m_GroupRead); order.append(&m_GroupWrite); order.append(&m_GroupExecute); order.append(&m_OthersRead); order.append(&m_OthersWrite); order.append(&m_OthersExecute); #endif // _WIN32 order.append(&m_LastWriteDate); order.append(&m_LastWriteTime); order.append(&m_CreationDate); order.append(&m_CreationTime); order.append(&m_LastAccessDate); order.append(&m_LastAccessTime); #if defined(HAS_CHANGETIME) order.append(&m_ChangeDate); order.append(&m_ChangeTime); #endif // HAS_CHANGETIME SetEnterCmd( CMD_OK ); SetPosition(); }
FSString FSSys::Uri( FSPath& path ) { return FSString( path.GetUnicode() ); }
virtual FSString Uri( FSPath& path ) override { FSPath FilePath( m_Uri ); std::string ret( FilePath.GetItem( FilePath.Count() - 1 )->GetUtf8() + std::string( ":" ) + path.GetUtf8( '/' ) ); return FSString( ret.c_str() ); }