EXPORT_C TInt RSCPClient::CheckConfiguration( TInt aMode )
{
Dprint( (_L("--> RSCPClient::CheckConfiguration()") ));
TInt status = 0;
TPckg<TInt> retPackage(status);
TInt ret = SendReceive(ESCPServCheckConfig, TIpcArgs( aMode, &retPackage ) );
if ( ret == KErrNone )
{
ret = status;
if ( status == KErrNone )
{
Dprint( (_L("RSCPClient::CheckConfiguration(): Configuration OK") ));
}
else if ( status == KErrAccessDenied )
{
if ( aMode == KSCPInitial )
{
Dprint( (_L("RSCPClient::CheckConfiguration(): Initial check failed") ));
}
else
{
Dprint( (_L("RSCPClient::CheckConfiguration(): WARNING:\
Configuration Out of sync") ));
}
}
}
// ---------------------------------------------------------
// void CSCPTimer::DoCancel()
// Cancel the call using the RTimer member
//
// Status : Approved
// ---------------------------------------------------------
//
void CSCPTimer::DoCancel()
{
Dprint( (_L("--> CSCPTimer::DoCancel()") ));
iTimer.Cancel();
Dprint( (_L("<-- CSCPTimer::DoCancel()") ));
}
// ---------------------------------------------------------
// TInt RSCPClient::SetParamValue( TInt aParamID, TDes& aValue )
// The server contains all the logic for the parameters, just
// propagate the call.
//
// Status : Approved
// ---------------------------------------------------------
//
EXPORT_C TInt RSCPClient::SetParamValue( TInt aParamID, TDes& aValue )
{
Dprint( (_L("--> RSCPClient::SetParamValue()") ));
TInt ret = SendReceive( ESCPServSetParam, TIpcArgs( aParamID, &aValue ) );
Dprint( (_L("<-- RSCPClient::SetParamValue(): %d"), ret ));
return ret;
}
// ---------------------------------------------------------
// TInt RSCPClient::SetPhoneLock()
// Propagates the lock/unlock phone -request to the server
//
// Status : Approved
// ---------------------------------------------------------
//
EXPORT_C TInt RSCPClient::SetPhoneLock( TBool aLocked )
{
Dprint( (_L("--> RSCPClient::SetPhoneLock( %d)"), aLocked ));
TInt ret = SendReceive(ESCPServSetPhoneLock, TIpcArgs( aLocked ) );
Dprint( (_L("<-- RSCPClient::SetPhoneLock(): %d"), ret ));
return ret;
}
// ---------------------------------------------------------
// TInt RSCPClient::ChangeCode( TDes& aNewCode )
// Propagates the change code -request to the server, along with
// the code parameter.
//
// Status : Approved
// ---------------------------------------------------------
//
EXPORT_C TInt RSCPClient::ChangeCode( TDes& aNewCode )
{
Dprint( (_L("--> RSCPClient::ChangeCode()") ));
TInt ret = SendReceive(ESCPServChangeCode, TIpcArgs( &aNewCode ) );
Dprint( (_L("<-- RSCPClient::ChangeCode(): %d"), ret ));
return ret;
}
// ---------------------------------------------------------
// TInt RSCPClient::StoreCode( TSCPSecCode& aCode )
// Propagates the store code -request to the server along
// with the buffer parameter.
//
// Status : Approved
// ---------------------------------------------------------
//
EXPORT_C TInt RSCPClient::StoreCode( TSCPSecCode& aCode )
{
Dprint( (_L("--> RSCPClient::StoreCode()") ));
TInt ret = SendReceive(ESCPServSetCode, TIpcArgs( &aCode ) );
Dprint( (_L("<-- RSCPClient::StoreCode(): %d"), ret ));
return ret;
}
// ---------------------------------------------------------
// void CSCPTimer::RunL()
// Handle the timeout by calling the callback method
//
// Status : Approved
// ---------------------------------------------------------
//
void CSCPTimer::RunL()
{
Dprint( (_L("--> CSCPTimer::RunL()") ));
Dprint( (_L("--> CSCPTimer::RunL(): TIMEOUT occured, signalling the handler") ));
iHandler->Timeout( iParam );
Dprint( (_L("<-- CSCPTimer::RunL()") ));
}
// Static constructor.
CSCPTimer* CSCPTimer::NewL( TUint aTimeout, TAny* aParam, MSCPTimeoutHandler* aHandler )
{
Dprint( (_L("--> CSCPTimer::NewL()") ));
CSCPTimer* self = CSCPTimer::NewLC( aTimeout, aParam, aHandler );
CleanupStack::Pop( self );
Dprint( (_L("<-- CSCPTimer::NewL()") ));
return self;
}
// ---------------------------------------------------------
// TInt RSCPClient::GetLockState( TBool& aState )
// Package the parameter, and send it to the server.
//
// Status : Approved
// ---------------------------------------------------------
//
EXPORT_C TInt RSCPClient::GetLockState( TBool& aState )
{
Dprint( (_L("--> RSCPClient::GetLockState()") ));
TPckg<TBool> retPackage(aState);
TInt ret = SendReceive( ESCPServGetLockState, TIpcArgs( &retPackage ) );
Dprint( (_L("<-- RSCPClient::GetLockState(): %d"), retPackage() ));
return ret;
}
// C++ default constructor can NOT contain any code, that
// might leave.
//
CSCPTimer::CSCPTimer( TAny* aParam, MSCPTimeoutHandler* aHandler )
: CActive( EPriorityNormal ),
iParam( aParam ),
iHandler( aHandler )
{
Dprint( (_L("--> CSCPTimer::CSCPTimer()") ));
// No implementation required
Dprint( (_L("<-- CSCPTimer::CSCPTimer()") ));
}
// Static constructor, leaves object pointer to the cleanup stack.
CSCPTimer* CSCPTimer::NewLC( TUint aTimeout, TAny* aParam, MSCPTimeoutHandler* aHandler )
{
Dprint( (_L("--> CSCPTimer::NewLC()") ));
CSCPTimer* self = new (ELeave) CSCPTimer( aParam, aHandler );
CleanupStack::PushL( self );
self->ConstructL( aTimeout );
Dprint( (_L("<-- CSCPTimer::NewLC()") ));
return self;
}
// ----------------------------------------------------------------------------
// CSCPHistoryPlugin::NewL
// Two-phased contructor
// (static, may leave)
// Status : Approved
// ----------------------------------------------------------------------------
//
CSCPHistoryPlugin* CSCPHistoryPlugin::NewL()
{
Dprint ( ( _L( "CSCPHistoryPlugin::NewL()" ) ) );
CSCPHistoryPlugin* self = new ( ELeave ) CSCPHistoryPlugin();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
Dprint ( ( _L( "( 0x%x ) CSCPHistoryPlugin::NewL()" ), self ) );
return self;
}
// ---------------------------------------------------------
// TBool RSCPClient::QueryAdminCmd( TSCPAdminCommand aCommand )
// Packs the command parameter into a buffer, and propagates
// the call to the server, the response is received in the
// same buffer.
//
// Status : Approved
// ---------------------------------------------------------
//
EXPORT_C TBool RSCPClient::QueryAdminCmd( TSCPAdminCommand aCommand )
{
Dprint( (_L("--> RSCPClient::QueryAdminCmd()") ));
TInt status = 0;
TPckg<TInt> retPackage(status);
TInt ret = SendReceive( ESCPServQueryAdminCmd, TIpcArgs( aCommand, &retPackage ) );
Dprint( (_L("<-- RSCPClient::QueryAdminCmd(): %d"), retPackage() ));
return static_cast<TBool>( status );
}
// Symbian 2nd phase constructor can leave.
void CSCPTimer::ConstructL( TUint aTimeout )
{
Dprint( (_L("--> CSCPTimer::ConstructL()") ));
CActiveScheduler::Add( this );
iTimer.CreateLocal();
// Start the timer
iTimer.After( iStatus, aTimeout );
// No need to check for isActive, this is the constructor
SetActive();
Dprint( (_L("<-- CSCPTimer::ConstructL()") ));
}
// ---------------------------------------------------------
// TVersion RSCPClient::Version()
// Constructs a TVersion object containing the defined version
// numbers, and returns it
//
// Status : Approved
// ---------------------------------------------------------
//
EXPORT_C TVersion RSCPClient::Version() const
{
Dprint( (_L("<--> RSCPClient::Version()") ));
return( TVersion( KSCPServMajorVersionNumber,
KSCPServMinorVersionNumber,
KSCPServBuildVersionNumber ) );
}
int
readmouse(Point *p, uint *button) {
XEvent ev;
for(;;) {
XMaskEvent(display, MouseMask|ExposureMask|PropertyChangeMask, &ev);
debug_event(&ev);
switch(ev.type) {
case Expose:
case NoExpose:
case PropertyNotify:
event_dispatch(&ev);
default:
Dprint(DEvent, "readmouse(): ignored: %E\n", &ev);
continue;
case ButtonPress:
case ButtonRelease:
*button = ev.xbutton.button;
case MotionNotify:
p->x = ev.xmotion.x_root;
p->y = ev.xmotion.y_root;
if(p->x == scr.rect.max.x - 1)
p->x = scr.rect.max.x;
if(p->y == scr.rect.max.y - 1)
p->y = scr.rect.max.y;
break;
}
return ev.type;
}
}
// Destructor
CSCPTimer::~CSCPTimer()
{
Dprint( (_L("--> CSCPTimer::~CSCPTimer()") ));
if ( IsActive() )
{
Cancel();
}
iParam = NULL;
iHandler = NULL;
iTimer.Close();
Dprint( (_L("<-- CSCPTimer::~CSCPTimer()") ));
}
PUBLIC int drv_start(int channel, int DmaMode) {
Dprint(("drv_start():\n"));
drv_reset();
dsp_dma_setup(DmaPhys, DspFragmentSize * sub_dev[channel].NrOfDmaFragments, DmaMode);
dsp_set_speed(DspSpeed);
/* Put the speaker on */
if(DmaMode == DEV_WRITE_S) {
dsp_command (DSP_CMD_SPKON); /* put speaker on */
/* Program DSP with dma mode */
dsp_command((DspBits == 8 ? DSP_CMD_8BITAUTO_OUT : DSP_CMD_16BITAUTO_OUT));
} else {
dsp_command (DSP_CMD_SPKOFF); /* put speaker off */
/* Program DSP with dma mode */
dsp_command((DspBits == 8 ? DSP_CMD_8BITAUTO_IN : DSP_CMD_16BITAUTO_IN));
}
/* Program DSP with transfer mode */
if (!DspSign) {
dsp_command((DspStereo == 1 ? DSP_MODE_STEREO_US : DSP_MODE_MONO_US));
} else {
dsp_command((DspStereo == 1 ? DSP_MODE_STEREO_S : DSP_MODE_MONO_S));
}
/* Give length of fragment to DSP */
if (DspBits == 8) { /* 8 bit transfer */
/* #bytes - 1 */
dsp_command((DspFragmentSize - 1) >> 0);
dsp_command((DspFragmentSize - 1) >> 8);
} else { /* 16 bit transfer */
/*=========================================================================*
* mixer_init
*=========================================================================*/
int mixer_init() {
/* Try to detect the mixer by writing to MIXER_DAC_LEVEL if the
* value written can be read back the mixer is there
*/
mixer_set(MIXER_DAC_LEVEL, 0x10); /* write something to it */
if(mixer_get(MIXER_DAC_LEVEL) != 0x10) {
Dprint(("sb16: Mixer not detected\n"));
return EIO;
}
/* Enable Automatic Gain Control */
mixer_set(MIXER_AGC, 0x01);
Dprint(("Mixer detected\n"));
return OK;
}
// ---------------------------------------------------------
// CreateServerProcess() Server starter function
// Starts the SCP server
// Returns: TInt: Operation status, a standard error code
//
// Status : Approved
// ---------------------------------------------------------
//
static TInt CreateServerProcess()
{
Dprint( (_L("--> SCPClient::CreateServerProcess()") ));
TInt result;
const TUidType serverUid( KNullUid, KNullUid, KServerUid3 );
RProcess server;
_LIT( KEmpty, "");
result = server.Create( KSCPServerFileName, KEmpty );
if ( result != KErrNone )
{
Dprint( (_L("<-- SCPClient::CreateServerProcess(), process creation error!") ));
return result;
}
TRequestStatus stat;
server.Rendezvous(stat);
if ( stat != KRequestPending )
{
server.Kill(0); // abort startup
}
else
{
server.Resume(); // logon OK - start the server
}
User::WaitForRequest(stat); // wait for start or death
// we can't use the 'exit reason' if the server panicked as this
// is the panic 'reason' and may be '0' which cannot be distinguished
// from KErrNone
result = ( server.ExitType() == EExitPanic ) ? KErrGeneral : stat.Int();
server.Close();
Dprint( (_L("<-- SCPClient::CreateServerProcess(): %d"), result ));
return result;
}
// ---------------------------------------------------------
// StartServer() Server starter check
// Determines if the server is running, if not, calls the starter function
// Returns: TInt: Operation status, a standard error code
//
// Status : Approved
// ---------------------------------------------------------
//
static TInt StartServer()
{
Dprint( (_L("--> SCPClient::StartServer()") ));
TInt result;
TFindServer findSCPServer( KSCPServerName );
TFullName name;
result = findSCPServer.Next( name );
if ( result != KErrNone )
{
// The server is not running, try to create the server process
result = CreateServerProcess();
}
Dprint( (_L("<-- SCPClient::StartServer(): Exit code: %d"), result ));
return result;
}
static bool
enter_event(Window *w, void *aux, XCrossingEvent *e) {
Client *c;
Frame *f;
c = aux;
f = c->sel;
if(disp.focus != c || selclient() != c) {
Dprint(DFocus, "%E\n", e);
Dprint(DFocus, "enter_notify(f) => [%#C]%s%s\n",
f->client, f->client->name,
e->serial <= event_lastconfigure ? " (ignored)" : "");
if(e->detail != NotifyInferior)
if(e->serial > event_lastconfigure && !f->collapsed)
focus(f->client, false);
}
mouse_checkresize(f, Pt(e->x, e->y), false);
return false;
}
PUBLIC int drv_init_hw(void) {
int i;
int DspVersion[2];
Dprint(("drv_init_hw():\n"));
if(drv_reset () != OK) {
Dprint(("sb16: No SoundBlaster card detected\n"));
return -1;
}
DspVersion[0] = DspVersion[1] = 0;
dsp_command(DSP_GET_VERSION); /* Get DSP version bytes */
for(i = 1000; i; i--) {
if(sb16_inb(DSP_DATA_AVL) & 0x80) {
if(DspVersion[0] == 0) {
DspVersion[0] = sb16_inb(DSP_READ);
} else {
DspVersion[1] = sb16_inb(DSP_READ);
break;
}
}
}
if(DspVersion[0] < 4) {
Dprint(("sb16: No SoundBlaster 16 compatible card detected\n"));
return -1;
}
Dprint(("sb16: SoundBlaster DSP version %d.%d detected!\n", DspVersion[0], DspVersion[1]));
/* set SB to use our IRQ and DMA channels */
mixer_set(MIXER_SET_IRQ, (1 << (SB_IRQ / 2 - 1)));
mixer_set(MIXER_SET_DMA, (1 << SB_DMA_8 | 1 << SB_DMA_16));
DspFragmentSize = sub_dev[AUDIO].DmaSize / sub_dev[AUDIO].NrOfDmaFragments;
return OK;
}
PUBLIC int drv_reset(void) {
int i;
Dprint(("drv_reset():\n"));
sb16_outb(DSP_RESET, 1);
for(i = 0; i < 1000; i++); /* wait a while */
sb16_outb(DSP_RESET, 0);
for(i = 0; i < 1000 && !(sb16_inb(DSP_DATA_AVL) & 0x80); i++);
if(sb16_inb(DSP_READ) != 0xAA) return EIO; /* No SoundBlaster */
return OK;
}
static void
_backtrace(int pid, char *btarg) {
char *proc, *spid, *gdbcmd;
int fd[3], p[2];
int status, cmdfd;
gdbcmd = estrdup("/tmp/gdbcmd.XXXXXX");
if(pipe(p) < 0)
goto done;
closeexec(p[0]);
cmdfd = mkstemp(gdbcmd);
if(cmdfd < 0)
goto done;
fprint(cmdfd, "bt %s\n", btarg);
fprint(cmdfd, "detach\n");
close(cmdfd);
fd[0] = open("/dev/null", O_RDONLY);
fd[1] = p[1];
fd[2] = dup(2);
proc = sxprint("/proc/%d/" PROGTXT, pid);
spid = sxprint("%d", pid);
if(spawn3l(fd, "gdb", "gdb", "-batch", "-x", gdbcmd, proc, spid, nil) < 0) {
unlink(gdbcmd);
goto done;
}
Biobuf bp;
char *s;
Binit(&bp, p[0], OREAD);
while((s = Brdstr(&bp, '\n', 1))) {
Dprint(DStack, "%s\n", s);
free(s);
}
unlink(gdbcmd);
done:
free(gdbcmd);
kill(pid, SIGKILL);
waitpid(pid, &status, 0);
}
// ----------------------------------------------------------------------------
// CSCPHistoryPlugin::HandleEvent
//
//
// Status : Approved
// ----------------------------------------------------------------------------
//
void CSCPHistoryPlugin :: HandleEventL( TInt aID, CSCPParamObject& aParam, CSCPParamObject& aOutParam)
{
Dprint ( ( _L( "CSCPHistoryPlugin::HandleEvent()" ) ) );
if ( iFs == NULL )
{
return ; // Eventhandler not available
}
// check for Case
switch ( aID )
{
case ( KSCPEventValidate ) :
{
// Obtain the paramValue
Dprint ( ( _L( "CSCPHistoryPlugin::KSCPEventValidate" ) ) );
TInt passhistoryParamValue;
passhistoryParamValue = GetHistoryCountParamValue();
Dprint ( ( _L( "CSCPHistoryPlugin::HandleEvent passhistoryParamValue = %d" ), passhistoryParamValue ) );
// if all required bounds are zero, there is nothing to do.
if ( passhistoryParamValue != 0)
{
// Get the configFile's path.
// If this fails, there is something badly wrong(Private folder is not there)
TInt errSCF = SetConfigFile ();
if (errSCF != KErrNone)
{
break; // Break out from Case
}
// Get the historyItemCount, If the err is raised, the file is not there
// This will lead to KSCPEventPasswordChanged event and new history file will
// be created
TInt historyItemCounter;
TInt errHC = GetHistoryItemCount( historyItemCounter );
Dprint ( ( _L( "CSCPHistoryPlugin::HandleEvent historyItemCounter = %d" ), historyItemCounter ) );
if (errHC != KErrNone)
{
break; // Break out from Case
}
// continue with the KSCPEventValidate Check
// Get the password from the paramObject
TBuf<KSCPPasscodeMaxLength> seccode;
if ( aParam.Get( KSCPParamPassword, seccode ) != KErrNone )
{
// Nothing to do anymore
Dprint( (_L("CSCPHistoryPlugin::HandleEvent()\
ERROR: KSCPEventValidate/KSCPParamPassword is != KErrNone") ));
break; // Break out from Case
}
// Hash the securitycode
TBuf<KSCPPasscodeMaxLength> securityhash;
iEventHandler->HashInput(seccode,securityhash);
// get history
CDesCArrayFlat* array = NULL;
TInt errGH = KErrNone;
array = new CDesCArrayFlat(1);
if ( array != NULL )
{
TRAPD( err2, errGH = GetHistoryArrayL( *array ) );
if ( err2 != KErrNone )
{
errGH = err2;
}
}
else
{
errGH = KErrNoMemory;
}
// If for some reason err is raised, break out
// If the Historyonfig file get deleted on the fly ex
if (errGH != KErrNone)
{
array->Reset();
delete array;
break; // Break out from Case
}
TInt correction;
correction = 0;
if ( array->Count() >= passhistoryParamValue )
{
correction = array->Count() - passhistoryParamValue;
}
// check for match
TBuf<KSCPPasscodeMaxLength> arrayItem;
// Set the historyobject
for (TInt i= 0 + correction; i < array->Count(); i++)
{
arrayItem = array->MdcaPoint(i);
if (arrayItem.Compare(securityhash) == KErrNone)
{
aOutParam.Set( KSCPParamStatus, KErrSCPInvalidCode );
Dprint ( ( _L( "EDeviceLockHistoryBuffer Failed" ) ) );
aOutParam.AddtoFailedPolices(EDeviceLockHistoryBuffer);
break;
} // End of compare IF
} // End of For
// kill the local
array->Reset();
delete array;
} // passhistoryParamValue
break;
} // end of KSCPEventValidate
// ----------------------------------------------------------------------------
// CSCPHistoryPlugin::ConstructL
// 2nd phase construction
// (may leave)
// Status : Approved
// ----------------------------------------------------------------------------
//
void CSCPHistoryPlugin::ConstructL()
{
Dprint ( ( _L( "CSCPHistoryPlugin::ConstructL()" ) ) );
return;
}
/*% res_nsendsigned */
int
res_nsendsigned(res_state statp, const u_char *msg, int msglen,
ns_tsig_key *key, u_char *answer, int anslen)
{
res_state nstatp;
DST_KEY *dstkey;
int usingTCP = 0;
u_char *newmsg;
int newmsglen, bufsize, siglen;
u_char sig[64];
HEADER *hp;
time_t tsig_time;
int ret;
int len;
dst_init();
nstatp = (res_state) malloc(sizeof(*statp));
if (nstatp == NULL) {
errno = ENOMEM;
return (-1);
}
memcpy(nstatp, statp, sizeof(*statp));
bufsize = msglen + 1024;
newmsg = (u_char *) malloc(bufsize);
if (newmsg == NULL) {
free(nstatp);
errno = ENOMEM;
return (-1);
}
memcpy(newmsg, msg, msglen);
newmsglen = msglen;
if (ns_samename(key->alg, NS_TSIG_ALG_HMAC_MD5) != 1)
dstkey = NULL;
else
dstkey = dst_buffer_to_key(key->name, KEY_HMAC_MD5,
NS_KEY_TYPE_AUTH_ONLY,
NS_KEY_PROT_ANY,
key->data, key->len);
if (dstkey == NULL) {
errno = EINVAL;
free(nstatp);
free(newmsg);
return (-1);
}
nstatp->nscount = 1;
siglen = sizeof(sig);
ret = ns_sign(newmsg, &newmsglen, bufsize, NOERROR, dstkey, NULL, 0,
sig, &siglen, 0);
if (ret < 0) {
free (nstatp);
free (newmsg);
dst_free_key(dstkey);
if (ret == NS_TSIG_ERROR_NO_SPACE)
errno = EMSGSIZE;
else if (ret == -1)
errno = EINVAL;
return (ret);
}
if (newmsglen > PACKETSZ || nstatp->options & RES_USEVC)
usingTCP = 1;
if (usingTCP == 0)
nstatp->options |= RES_IGNTC;
else
nstatp->options |= RES_USEVC;
/*
* Stop res_send printing the answer.
*/
nstatp->options &= ~RES_DEBUG;
nstatp->pfcode &= ~RES_PRF_REPLY;
retry:
len = res_nsend(nstatp, newmsg, newmsglen, answer, anslen);
if (len < 0) {
free (nstatp);
free (newmsg);
dst_free_key(dstkey);
return (len);
}
ret = ns_verify(answer, &len, dstkey, sig, siglen,
NULL, NULL, &tsig_time, nstatp->options & RES_KEEPTSIG);
if (ret != 0) {
Dprint((statp->options & RES_DEBUG) ||
((statp->pfcode & RES_PRF_REPLY) &&
(statp->pfcode & RES_PRF_HEAD1)),
(stdout, ";; got answer:\n"));
DprintQ((statp->options & RES_DEBUG) ||
(statp->pfcode & RES_PRF_REPLY),
(stdout, "%s", ""),
answer, (anslen > len) ? len : anslen);
if (ret > 0) {
Dprint(statp->pfcode & RES_PRF_REPLY,
(stdout, ";; server rejected TSIG (%s)\n",
p_rcode(ret)));
} else {
Dprint(statp->pfcode & RES_PRF_REPLY,
(stdout, ";; TSIG invalid (%s)\n",
p_rcode(-ret)));
}
free (nstatp);
free (newmsg);
dst_free_key(dstkey);
if (ret == -1)
errno = EINVAL;
else
errno = ENOTTY;
return (-1);
}
hp = (HEADER *) answer;
if (hp->tc && !usingTCP && (statp->options & RES_IGNTC) == 0U) {
nstatp->options &= ~RES_IGNTC;
usingTCP = 1;
goto retry;
}
Dprint((statp->options & RES_DEBUG) ||
((statp->pfcode & RES_PRF_REPLY) &&
(statp->pfcode & RES_PRF_HEAD1)),
(stdout, ";; got answer:\n"));
DprintQ((statp->options & RES_DEBUG) ||
(statp->pfcode & RES_PRF_REPLY),
(stdout, "%s", ""),
answer, (anslen > len) ? len : anslen);
Dprint(statp->pfcode & RES_PRF_REPLY, (stdout, ";; TSIG ok\n"));
free (nstatp);
free (newmsg);
dst_free_key(dstkey);
return (len);
}
// ----------------------------------------------------------------------------
// CSCPHistoryPlugin::CSCPHistoryPlugin
// Constructor
// Status : Approved
// ----------------------------------------------------------------------------
//
CSCPHistoryPlugin::CSCPHistoryPlugin()
{
Dprint ( ( _L( "CSCPHistoryPlugin::CSCPHistoryPlugin()" ) ) );
return;
}
/* res_nsendsigned */
int
res_nsendsigned(res_state statp, const u_char *msg, int msglen,
ns_tsig_key *key, u_char *answer, int anslen)
{
res_state nstatp;
DST_KEY *dstkey;
int usingTCP = 0;
u_char *newmsg;
int newmsglen, bufsize, siglen;
u_char sig[64];
HEADER *hp;
time_t tsig_time;
int ret;
dst_init();
nstatp = (res_state) malloc(sizeof(*statp));
if (nstatp == NULL) {
errno = ENOMEM;
return (-1);
}
memcpy(nstatp, statp, sizeof(*statp));
bufsize = msglen + 1024;
newmsg = (u_char *) malloc(bufsize);
if (newmsg == NULL) {
errno = ENOMEM;
return (-1);
}
memcpy(newmsg, msg, msglen);
newmsglen = msglen;
if (ns_samename(key->alg, NS_TSIG_ALG_HMAC_MD5) != 1)
dstkey = NULL;
else
dstkey = dst_buffer_to_key(key->name, KEY_HMAC_MD5,
NS_KEY_TYPE_AUTH_ONLY,
NS_KEY_PROT_ANY,
key->data, key->len);
if (dstkey == NULL) {
errno = EINVAL;
free(nstatp);
free(newmsg);
return (-1);
}
nstatp->nscount = 1;
siglen = sizeof(sig);
ret = ns_sign(newmsg, &newmsglen, bufsize, ns_r_noerror, dstkey, NULL, 0,
sig, &siglen, 0);
if (ret < 0) {
free (nstatp);
free (newmsg);
dst_free_key(dstkey);
if (ret == NS_TSIG_ERROR_NO_SPACE)
errno = EMSGSIZE;
else if (ret == -1)
errno = EINVAL;
return (ret);
}
if (newmsglen > NS_PACKETSZ || (nstatp->options & RES_IGNTC))
usingTCP = 1;
if (usingTCP == 0)
nstatp->options |= RES_IGNTC;
else
nstatp->options |= RES_USEVC;
retry:
ret = res_nsend(nstatp, newmsg, newmsglen, answer, anslen);
if (ret < 0) {
free (nstatp);
free (newmsg);
dst_free_key(dstkey);
return (ret);
}
anslen = ret;
ret = ns_verify(answer, &anslen, dstkey, sig, siglen,
NULL, NULL, &tsig_time, nstatp->options & RES_KEEPTSIG);
if (ret != 0) {
Dprint(nstatp->pfcode & RES_PRF_REPLY,
(stdout, ";; TSIG invalid (%s)\n", p_rcode(ret)));
free (nstatp);
free (newmsg);
dst_free_key(dstkey);
if (ret == -1)
errno = EINVAL;
else
errno = ENOTTY;
return (-1);
}
Dprint(nstatp->pfcode & RES_PRF_REPLY, (stdout, ";; TSIG ok\n"));
hp = (HEADER *) answer;
if (hp->tc && usingTCP == 0) {
nstatp->options &= ~RES_IGNTC;
usingTCP = 1;
goto retry;
}
free (nstatp);
free (newmsg);
dst_free_key(dstkey);
return (anslen);
}
