int FSSftp::Close ( int fd, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
if ( fd < 0 || fd >= MAX_FILES || !fileTable[fd] )
{
if ( err ) { *err = EINVAL; }
return -1;
}
ret = sftp_close( fileTable[fd] );
fileTable[fd] = 0;
if ( ret != SSH_NO_ERROR )
{
if ( err ) { *err = sftp_get_error( sftpSession ); }
return -1;
}
return 0;
}
int FSSftp::SetFileTime ( FSPath& path, FSTime aTime, FSTime mTime, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
LIBSSH2_SFTP_ATTRIBUTES attr;
attr.flags = LIBSSH2_SFTP_ATTR_ACMODTIME;
attr.atime = aTime;
attr.mtime = mTime;
try
{
int ret;
WHILE_EAGAIN_( ret, libssh2_sftp_setstat( sftpSession, ( char* )path.GetString( _operParam.charset, '/' ), &attr ) );
CheckSFTP( ret );
}
catch ( int e )
{
if ( err ) { *err = e; }
return ( e == -2 ) ? -2 : -1;
}
return 0;
}
int FSSftp::OpenRead ( FSPath& path, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
int n = 0;
for ( ; n < MAX_FILES; n++ )
if ( !fileTable[n] ) { break; }
if ( n >= MAX_FILES )
{
if ( err ) { *err = SSH_INTERROR_OUTOF; }
return -1;
}
sftp_file f = sftp_open( sftpSession, ( char* ) path.GetString( _operParam.charset, '/' ), O_RDONLY, 0 );
if ( !f )
{
if ( err ) { *err = sftp_get_error( sftpSession ); }
return -1;
}
fileTable[n] = f;
return n;
}
SensorThresholdsGet)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId,
SAHPI_IN SaHpiResourceIdT ResourceId,
SAHPI_IN SaHpiSensorNumT SensorNum,
SAHPI_OUT SaHpiSensorThresholdsT *SensorThresholds )
{
if ( SensorThresholds == 0 )
return SA_ERR_HPI_INVALID_PARAMS;
CheckSession();
PreMarshal( eFsaHpiSensorThresholdsGet );
request_header.m_len = HpiMarshalRequest3( hm, request, &SessionId, &ResourceId, &SensorNum );
Send();
// this is to pass test sf_202.test of hpitest
memset( SensorThresholds, 0, sizeof( SaHpiSensorThresholdsT ) );
int mr = HpiDemarshalReply1( reply_header.m_flags & dMhEndianBit, hm, reply, &err,
SensorThresholds );
PostMarshal();
return err;
}
EventGet)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId,
SAHPI_IN SaHpiTimeoutT Timeout,
SAHPI_OUT SaHpiEventT *Event,
SAHPI_INOUT SaHpiRdrT *Rdr,
SAHPI_INOUT SaHpiRptEntryT *RptEntry )
{
if ( Event == 0 )
return SA_ERR_HPI_INVALID_PARAMS;
CheckSession();
PreMarshal( eFsaHpiEventGet );
request_header.m_len = HpiMarshalRequest2( hm, request, &SessionId, &Timeout );
Send();
SaHpiRdrT rdr;
SaHpiRptEntryT rpt_entry;
if ( Rdr == 0 )
Rdr = &rdr;
if ( RptEntry == 0 )
RptEntry = &rpt_entry;
int mr = HpiDemarshalReply3( reply_header.m_flags & dMhEndianBit, hm, reply, &err,
Event, &Rdr, &RptEntry );
PostMarshal();
return err;
}
SensorReadingConvert)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId,
SAHPI_IN SaHpiResourceIdT ResourceId,
SAHPI_IN SaHpiSensorNumT SensorNum,
SAHPI_IN SaHpiSensorReadingT *ReadingInput,
SAHPI_OUT SaHpiSensorReadingT *ConvertedReading )
{
if ( ReadingInput == 0 || ConvertedReading == 0 )
return SA_ERR_HPI_INVALID_PARAMS;
CheckSession();
PreMarshal( eFsaHpiSensorReadingConvert );
request_header.m_len = HpiMarshalRequest4( hm, request, &SessionId, &ResourceId,
&SensorNum, ReadingInput );
Send();
int mr = HpiDemarshalReply1( reply_header.m_flags & dMhEndianBit, hm, reply, &err,
ConvertedReading );
PostMarshal();
return err;
}
int FSSftp::Read ( int fd, void* buf, int size, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
if ( fd < 0 || fd >= MAX_FILES || !fileTable[fd] )
{
if ( err ) { *err = EINVAL; }
return -1;
}
try
{
int bytes;
WHILE_EAGAIN_( bytes, libssh2_sftp_read( fileTable[fd], ( char* )buf, size ) );
if ( bytes < 0 ) { CheckSFTP( bytes ); }
return bytes;
}
catch ( int e )
{
if ( err ) { *err = e; }
return ( e == -2 ) ? -2 : -1;
}
}
SessionClose)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId )
{
CheckSession();
PreMarshal( eFsaHpiSessionClose );
request_header.m_len = HpiMarshalRequest1( hm, request, &SessionId );
Send();
int mr = HpiDemarshalReply0( reply_header.m_flags & dMhEndianBit, hm, reply, &err );
PostMarshal();
if ( err == SA_OK )
{
config->m_num_sessions--;
assert( config->m_num_sessions >= 0 );
if ( config->m_num_sessions < 0 )
config->m_num_sessions = 0;
if ( config->m_num_sessions == 0 )
CleanupClient( config );
}
return err;
}
int FSSftp::Close ( int fd, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
if ( fd < 0 || fd >= MAX_FILES || !fileTable[fd] )
{
if ( err ) { *err = EINVAL; }
return -1;
}
try
{
int ret;
WHILE_EAGAIN_( ret, libssh2_sftp_close( fileTable[fd] ) );
CheckSFTP( ret );
}
catch ( int e )
{
if ( err ) { *err = e; }
return ( e == -2 ) ? -2 : -1;
}
fileTable[fd] = 0;
return 0;
}
int FSSftp::SetFileTime ( FSPath& path, FSTime aTime, FSTime mTime, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
struct timeval tv[2];
tv[0].tv_sec = aTime;
tv[0].tv_usec = 0;
tv[1].tv_sec = mTime;
tv[1].tv_usec = 0;
if ( sftp_utimes( sftpSession, ( char* )path.GetString( _operParam.charset ), tv ) )
{
if ( err ) { *err = sftp_get_error( sftpSession ); }
return -1;
}
return 0;
}
int FSSftp::Seek( int fd, SEEK_FILE_MODE mode, seek_t pos, seek_t* pRet, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
if ( fd < 0 || fd >= MAX_FILES || !fileTable[fd] )
{
if ( err ) { *err = EINVAL; }
return -1;
}
//???
if ( mode == FSEEK_BEGIN )
{
libssh2_sftp_seek64( fileTable[fd], pos );
if ( pRet ) { *pRet = pos; }
return 0;
}
if ( err )
{
*err = EINVAL;
}
return -1;
}
int FSSftp::Stat ( FSPath& path, FSStat* st, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
char* fullPath = ( char* ) path.GetString( _operParam.charset );
sftp_attributes la = sftp_lstat( sftpSession, fullPath );
if ( !la )
{
if ( err ) { *err = sftp_get_error( sftpSession ); }
return -1;
}
if ( la->type == SSH_FILEXFER_TYPE_SYMLINK )
{
char* s = sftp_readlink( sftpSession, fullPath );
if ( s ) { st->link.Set( _operParam.charset, s ); }
sftp_attributes_free( la ); //!!!
}
else
{
st->mode = la->permissions;
st->size = la->size;
st->uid = la->uid;
st->gid = la->gid;
st->mtime = la->mtime;
sftp_attributes_free( la ); //!!!
return 0;
}
sftp_attributes a = sftp_stat( sftpSession, fullPath );
if ( !a )
{
if ( err ) { *err = sftp_get_error( sftpSession ); }
return -1;
}
st->mode = la->permissions;
st->size = la->size;
st->uid = la->uid;
st->gid = la->gid;
st->mtime = la->mtime;
sftp_attributes_free( a ); //!!!
return 0;
}
int FSSftp::Write ( int fd, void* buf, int size, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info ); //???
if ( ret ) { return ret; }
if ( fd < 0 || fd >= MAX_FILES || !fileTable[fd] )
{
if ( err ) { *err = EINVAL; }
return -1;
}
/*
Бля, libssh похоже какие-то уроды пишут
при size 65536 портит данные, если 16к то нормально, пришлось уменьшить,
а вот читать такие блоки - читает.
хотя надо и там уменьшить, кто этих пидоров знает
а было - так
int bytes = sftp_write(fileTable[fd], buf, size);
*/
int bytes = 0;
char* s = ( char* )buf;
while ( size > 0 )
{
int n = size;
if ( n > 0x4000 )
{
n = 0x4000;
}
int ret = sftp_write( fileTable[fd], s, n );
if ( ret < 0 )
{
if ( err ) { *err = sftp_get_error( sftpSession ); }
return -1;
}
if ( !ret ) { break; }
s += ret;
size -= ret;
bytes += ret;
}
return bytes;
}
int FSSftp::OpenCreate ( FSPath& path, bool overwrite, int mode, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
if ( !overwrite )
{
/*
заебался выяснять почему sftp_open с O_EXCL выдает "generc error" при наличии файла, а не EEXIST какой нибудь
поэтому встанил эту дурацкую проверку на наличие
*/
sftp_attributes a = sftp_lstat( sftpSession, ( char* ) path.GetString( _operParam.charset, '/' ) );
if ( a )
{
sftp_attributes_free( a ); //!!!
if ( err ) { *err = SSH_FX_FILE_ALREADY_EXISTS; }
return -1;
}
}
int n = 0;
for ( ; n < MAX_FILES; n++ )
if ( !fileTable[n] ) { break; }
if ( n >= MAX_FILES )
{
if ( err ) { *err = SSH_INTERROR_OUTOF; }
return -1;
}
sftp_file f = sftp_open( sftpSession, ( char* ) path.GetString( _operParam.charset, '/' ),
O_CREAT | O_WRONLY | ( overwrite ? O_TRUNC : O_EXCL ),
mode );
if ( !f )
{
//printf("ssh-err:'%s'\n",ssh_get_error(sshSession));
if ( err ) { *err = sftp_get_error( sftpSession ); }
return -1;
}
fileTable[n] = f;
return n;
}
int FSSftp::Stat ( FSPath& path, FSStat* st, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
char* fullPath = ( char* ) path.GetString( _operParam.charset, '/' );
try
{
SftpAttr attr;
int ret;
WHILE_EAGAIN_( ret, libssh2_sftp_lstat( sftpSession, fullPath, &attr.attr ) );
CheckSFTP( ret );
if ( attr.IsLink() )
{
char buf[4096];
int len;
WHILE_EAGAIN_( len, libssh2_sftp_readlink( sftpSession, fullPath, buf, sizeof( buf ) ) );
if ( len < 0 ) { CheckSFTP( len ); };
st->link.Set( _operParam.charset, buf );
int ret;
WHILE_EAGAIN_( ret, libssh2_sftp_stat( sftpSession, fullPath, &attr.attr ) );
if ( ret ) { attr.attr.permissions = 0; }
}
st->mode = attr.Permissions();
st->size = attr.Size();
st->uid = attr.Uid();
st->gid = attr.Gid();
st->mtime = attr.MTime();
}
catch ( int e )
{
st->mode = 0;
if ( err ) { *err = e; }
return ( e == -2 ) ? -2 : -1;
}
return 0;
}
EntityInventoryDataRead)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId,
SAHPI_IN SaHpiResourceIdT ResourceId,
SAHPI_IN SaHpiEirIdT EirId,
SAHPI_IN SaHpiUint32T BufferSize,
SAHPI_OUT SaHpiInventoryDataT *InventData,
SAHPI_OUT SaHpiUint32T *ActualSize )
{
if ( ActualSize == 0 )
return SA_ERR_HPI_INVALID_PARAMS;
CheckSession();
PreMarshal( eFsaHpiEntityInventoryDataRead );
request_header.m_len = HpiMarshalRequest4( hm, request, &SessionId, &ResourceId, &EirId, &BufferSize );
Send();
const cMarshalType *types[4];
types[0] = &SaErrorType; // SA_OK
types[1] = &SaHpiUint32Type; // actual size
types[2] = 0;
void *params[3];
params[0] = &err;
params[1] = ActualSize;
int mr = DemarshalArray( reply_header.m_flags & dMhEndianBit, types, params, reply );
if ( mr < 0 )
{
if ( reply )
free( reply );
return SA_ERR_HPI_INVALID_PARAMS;
}
if ( err == SA_OK && InventData )
{
types[2] = &SaHpiInventoryDataType;
types[3] = 0;
params[2] = InventData;
mr = DemarshalArray( reply_header.m_flags & dMhEndianBit, types, params, reply );
}
PostMarshal();
return err;
}
ResourcesDiscover)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId )
{
CheckSession();
PreMarshal( eFsaHpiResourcesDiscover );
request_header.m_len = HpiMarshalRequest1( hm, request, &SessionId );
Send();
int mr = HpiDemarshalReply0( reply_header.m_flags & dMhEndianBit, hm, reply, &err );
PostMarshal();
return err;
}
int FSSftp::OpenRead ( FSPath& path, int flags, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
int n = 0;
for ( ; n < MAX_FILES; n++ )
if ( !fileTable[n] ) { break; }
if ( n >= MAX_FILES )
{
if ( err ) { *err = SSH_INTERROR_OUTOF; }
return -1;
}
try
{
LIBSSH2_SFTP_HANDLE* fd = 0;
while ( true )
{
fd = libssh2_sftp_open( sftpSession, ( char* )path.GetString( _operParam.charset, '/' ),
LIBSSH2_FXF_READ,
0 );
if ( fd ) { break; }
CheckSFTPEagain();
WaitSocket( info );
}
fileTable[n] = fd;
}
catch ( int e )
{
if ( err ) { *err = e; }
return ( e == -2 ) ? -2 : -1;
}
return n;
}
AutoInsertTimeoutSet)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId,
SAHPI_IN SaHpiTimeoutT Timeout )
{
CheckSession();
PreMarshal( eFsaHpiAutoInsertTimeoutSet );
request_header.m_len = HpiMarshalRequest2( hm, request, &SessionId, &Timeout );
Send();
int mr = HpiDemarshalReply0( reply_header.m_flags & dMhEndianBit, hm, reply, &err );
PostMarshal();
return err;
}
int FSSftp::MkDir ( FSPath& path, int mode, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
if ( sftp_mkdir( sftpSession, ( char* )path.GetString( _operParam.charset ), mode ) )
{
if ( err ) { *err = sftp_get_error( sftpSession ); }
return -1;
}
return 0;
}
int FSSftp::Symlink ( FSPath& path, FSString& str, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
if ( sftp_symlink( sftpSession, ( char* )str.Get( _operParam.charset ), ( char* )path.GetString( _operParam.charset ) ) )
{
if ( err ) { *err = sftp_get_error( sftpSession ); }
return -1;
}
return 0;
}
static void
TermSession(
TermNode *term)
{
SessionData *data;
char buff[SIZE_TERM+1];
RecvnString(term->fp,SIZE_TERM,buff);
data = CheckSession(term->fp,buff);
if (data != NULL) {
data = ReadTerminal(term->fp,data);
data->term = term;
data->retry = 0;
TermMain(term,data);
}
CloseNet(term->fp);
}
Subscribe)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId,
SAHPI_IN SaHpiBoolT ProvideActiveAlarms )
{
CheckSession();
PreMarshal( eFsaHpiSubscribe );
request_header.m_len = HpiMarshalRequest2( hm, request, &SessionId, &ProvideActiveAlarms );
Send();
int mr = HpiDemarshalReply0( reply_header.m_flags & dMhEndianBit, hm, reply, &err );
PostMarshal();
return err;
}
EventLogTimeSet)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId,
SAHPI_IN SaHpiResourceIdT ResourceId,
SAHPI_IN SaHpiTimeT Time )
{
CheckSession();
PreMarshal( eFsaHpiEventLogTimeSet );
request_header.m_len = HpiMarshalRequest3( hm, request, &SessionId, &ResourceId, &Time );
Send();
int mr = HpiDemarshalReply0( reply_header.m_flags & dMhEndianBit, hm, reply, &err );
PostMarshal();
return err;
}
ParmControl)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId,
SAHPI_IN SaHpiResourceIdT ResourceId,
SAHPI_IN SaHpiParmActionT Action )
{
CheckSession();
PreMarshal( eFsaHpiParmControl );
request_header.m_len = HpiMarshalRequest3( hm, request, &SessionId, &ResourceId, &Action );
Send();
int mr = HpiDemarshalReply0( reply_header.m_flags & dMhEndianBit, hm, reply, &err );
PostMarshal();
return err;
}
int FSSftp::Rename ( FSPath& oldpath, FSPath& newpath, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
if ( sftp_rename( sftpSession, ( char* ) oldpath.GetString( _operParam.charset, '/' ), ( char* ) newpath.GetString( _operParam.charset, '/' ) ) )
{
if ( err ) { *err = sftp_get_error( sftpSession ); }
return -1;
}
return 0;
}
RptInfoGet)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId,
SAHPI_OUT SaHpiRptInfoT *RptInfo )
{
if ( RptInfo == 0 )
return SA_ERR_HPI_INVALID_PARAMS;
CheckSession();
PreMarshal( eFsaHpiRptInfoGet );
request_header.m_len = HpiMarshalRequest1( hm, request, &SessionId );
Send();
int mr = HpiDemarshalReply1( reply_header.m_flags & dMhEndianBit, hm, reply, &err, RptInfo );
PostMarshal();
return err;
}
int FSSftp::Write ( int fd, void* buf, int size, int* err, FSCInfo* info )
{
MutexLock lock( &mutex );
int ret = CheckSession( err, info );
if ( ret ) { return ret; }
if ( fd < 0 || fd >= MAX_FILES || !fileTable[fd] )
{
if ( err ) { *err = EINVAL; }
return -1;
}
try
{
int bytes = 0;
char* s = ( char* )buf;
while ( size > 0 )
{
int ret;
WHILE_EAGAIN_( ret, libssh2_sftp_write( fileTable[fd], s, size ) );
if ( ret < 0 ) { CheckSFTP( ret ); }
if ( !ret ) { break; }
bytes += ret;
size -= ret;
s += ret;
}
return bytes;
}
catch ( int e )
{
if ( err ) { *err = e; }
return ( e == -2 ) ? -2 : -1;
}
}
CK_RV PKCS_11_Token::Login(SSL_secure_varvector32 &password)
{
if(!CheckSession())
return CKR_FUNCTION_FAILED;
if(!logged_in)
{
CK_RV status;
status = functions->C_Login(session, CKU_USER, password.GetDirect(), password.GetLength());
if(status != CKR_OK)
return status;
logged_in = TRUE;
logged_in_time = prefsManager->CurrentTime();
}
return CKR_OK;
}
EventLogEntryGet)dOpenHpiClientParam( SAHPI_IN SaHpiSessionIdT SessionId,
SAHPI_IN SaHpiResourceIdT ResourceId,
SAHPI_IN SaHpiSelEntryIdT EntryId,
SAHPI_OUT SaHpiSelEntryIdT *PrevEntryId,
SAHPI_OUT SaHpiSelEntryIdT *NextEntryId,
SAHPI_OUT SaHpiSelEntryT *EventLogEntry,
SAHPI_INOUT SaHpiRdrT *Rdr,
SAHPI_INOUT SaHpiRptEntryT *RptEntry )
{
if ( PrevEntryId == 0
|| NextEntryId == 0
|| EventLogEntry == 0
|| Rdr == 0
|| RptEntry == 0 )
return SA_ERR_HPI_INVALID_PARAMS;
CheckSession();
PreMarshal( eFsaHpiEventLogEntryGet );
request_header.m_len = HpiMarshalRequest3( hm, request, &SessionId, &ResourceId, &EntryId );
Send();
SaHpiRdrT rdr;
SaHpiRptEntryT rpt_entry;
int mr = HpiDemarshalReply5( reply_header.m_flags & dMhEndianBit, hm, reply, &err,
PrevEntryId, NextEntryId, EventLogEntry,
&rdr, &rpt_entry );
if ( Rdr )
*Rdr = rdr;
if ( RptEntry )
*RptEntry = rpt_entry;
PostMarshal();
return err;
}
