GSSCredential::~GSSCredential() {
if (credential != GSS_C_NO_CREDENTIAL) {
OM_uint32 majstat, minstat;
majstat = gss_release_cred(&minstat, &credential);
if (GSS_ERROR(majstat)) {
logger.msg(DEBUG, "Failed to release GSS credential "
"(major: %d, minor: %d):%s", majstat, minstat, ErrorStr(majstat, minstat));
return;
}
}
}
GSSCredential::GSSCredential(const std::string& proxyPath,
const std::string& certificatePath,
const std::string& keyPath)
: credential(GSS_C_NO_CREDENTIAL) {
std::string credbuf;
if (!proxyPath.empty()) {
std::ifstream is(proxyPath.c_str());
getline(is, credbuf, '\0');
if(!is || credbuf.empty()) {
logger.msg(ERROR, "Failed to read proxy file: %s", proxyPath);
return;
}
}
else if (!certificatePath.empty() && !keyPath.empty()) {
std::ifstream is(certificatePath.c_str());
getline(is, credbuf, '\0');
if(!is || credbuf.empty()) {
logger.msg(ERROR, "Failed to read certificate file: %s",
certificatePath);
return;
}
std::string keybuf;
std::ifstream ik(keyPath.c_str());
getline(ik, keybuf, '\0');
if(!ik || keybuf.empty()) {
logger.msg(ERROR, "Failed to read private key file: %s", keyPath);
return;
}
credbuf += "\n";
credbuf += keybuf;
}
if(!credbuf.empty()) {
//Convert to GSS credental only if find credential content
OM_uint32 majstat, minstat;
gss_buffer_desc gbuf;
gbuf.value = (void*)credbuf.c_str();
gbuf.length = credbuf.length();
majstat = gss_import_cred(&minstat, &credential, NULL, 0,
&gbuf, GSS_C_INDEFINITE, NULL);
if (GSS_ERROR(majstat)) {
credential = GSS_C_NO_CREDENTIAL;
logger.msg(ERROR, "Failed to convert GSI credential to "
"GSS credential (major: %d, minor: %d)%s", majstat, minstat, ErrorStr(majstat, minstat));
return;
}
}
}
void I2C_SerialDongle::PacketReceived( PKT_Packet *packet )
{
uint8_t *pd = &packet->data[ 0 ];
PacketType packetType = (PacketType)*pd++;
uint8_t crc = 0;
uint8_t len = 0;
if ( m_debugDongleData )
{
DumpMem( "PktRcvd", 0, packet->data, packet->len );
}
if ( packetType == ErrorPacket )
{
m_response.m_errorCode = *pd;
LogError( "Rcvd Error packet, error code:%d '%s'\n", m_response.m_errorCode, ErrorStr( m_response.m_errorCode ));
}
else
if ( packetType == m_response.m_responseType )
{
// This is the type of packet that the caller is waiting for.
crc = m_response.m_partialCrc;
if ( packet->len > 1 )
{
// Check the CRC to see if it's valid
len = *pd; crc = Crc8( crc, *pd ); pd++;
// Sanity check the length. The packet length should equal the i2c len
// plus 3 (1 for packet type, 1 for len, 1 for CRC)
if (( len + 3 ) != packet->len )
{
LogError( "I2C_SerialDongle::PacketReceived Inconsistent packet length. Serial packetLen = %d, i2c packetLen = %d (expecting %d)\n",
packet->len, len, packet->len - 3 );
m_response.m_errorCode = I2C_ERROR_BAD_LEN;
packetType = ErrorPacket;
}
else
{
for ( int i = 0; i < len; i++ )
{
crc = Crc8( crc, pd[ i ]);
}
if ( crc != pd[ len ] )
{
LogError( "I2C_SerialDongle::PacketReceived CRC failure. Found 0x%02x, expecting 0x%02x\n", pd[ len ], crc );
m_response.m_errorCode = I2C_ERROR_BAD_CRC;
packetType = ErrorPacket;
}
}
// We've received a good packet, and we're waiting for this type
// of packet. Wakeup the reader
if ( len < 1 )
{
LogError( "I2C_SerialDongle::PacketReceived packet len too small (%d). Needs to be at least 1 to store address of sender\n", len );
len = 1;
}
if ( len > m_response.m_buf->dataLen )
{
LogError( "I2C_SerialDongle::PacketReceived packet buffer too small. bufferSize = %d, received %d\n", m_response.m_buf->dataLen, len );
len = m_response.m_buf->dataLen;
}
m_response.m_buf->dataLen = len;
if (( len > 0 ) && ( m_response.m_buf != NULL ))
{
memcpy( &m_response.m_buf->data[ 0 ], &pd[ 0 ], len );
}
}
}
if (( packetType == m_response.m_responseType ) || ( packetType == ErrorPacket ))
{
// Setting m_responseType to NoPacket signals that we're no longer
// waiting for a packet.
m_response.m_responseType = NoPacket;
sem_post( &m_response.m_semaphore );
return;
}
// Call the registered callback to report the received packet
if ( m_callback != NULL )
{
m_callback->PacketReceived( m_response.m_buf );
}
else
{
LogError( "m_callback == NULL\n" );
LogError( "packetType:%d m_response.m_responseType:%d\n", packetType, m_response.m_responseType );
LogError( "packet len: %d\n", packet->len );
DumpMem( " pkt", 0, packet->data, packet->len );
}
} // PacketReceived