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); }