Logo Search packages:      
Sourcecode: cyrus-sasl2 version File versions  Download package

KClient.c

/*
      KClient.c -- Application library for KClient

       Copyright 1994,1995 by Cornell University
      
      Initial coding 8/94 by Peter Bosanko.
*/

#ifndef _KrbDriver_
#include "krbdriver.h"
#endif

#ifndef _DEVICES_
#include    <Devices.h>
#endif

#include "kcglue_des.h"

#define KC_SESSION ((KClientRec *)session)
#define KC_PB (&(((KClientRec *)session)->hiParm))
#define OLD_KC_PB ((krbHiParmBlock *)session)
#define PICK_PARM (kcRec ? (void*) kcRec : (void*) pb)
#define KCLIENTDRIVER "\p.Kerberos"

/* Forward Declarations */

OSErr KClientSendMessage(short msg, void *parm);
OSErr KClientSetPassword(  KClientSessionInfo *session, char *password  );
krbHiParmBlock *KClientSessionKind(  KClientSessionInfo *session, KClientRec **kcRec );
OSErr _KClientVersion( StringPtr driver, short *majorVersion, short *minorVersion, char *versionString );

/*
 * call into des ecb_encrypt
 */
/* created by n3liw+@cmu.edu to support SASL, need to be able to specify checksum */
int KClient_des_ecb_encrypt(KClientSessionInfo  *session,des_cblock v1,des_cblock v2,int do_encrypt)
{
      KClientKey sessionKey;
      Key_schedule schedule;
      
      int rc=KClientGetSessionKey(session,&sessionKey);
      if(rc!=0)
            return rc;
      rc=kcglue_des_key_sched(&sessionKey,schedule);
      if(rc!=0)
            return rc;
      kcglue_des_ecb_encrypt(v1,v2,schedule,do_encrypt);
      return rc;
}

/*
 * call into des pcbc_encrypt
 */
/* created by n3liw+@cmu.edu to support SASL, need to be able to specify checksum */
int KClient_des_pcbc_encrypt(KClientSessionInfo  *session,des_cblock v1,des_cblock v2,long len,int do_encrypt)
{
      KClientKey sessionKey;
      Key_schedule schedule;
      
      int rc=KClientGetSessionKey(session,&sessionKey);
      if(rc!=0)
            return rc;
      rc=kcglue_des_key_sched(&sessionKey,schedule);
      if(rc!=0)
            return rc;
      kcglue_des_pcbc_encrypt(v1,v2,len,schedule,&sessionKey,do_encrypt);
      return rc;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientSendMessage(short msg, void *parm)
{
      ParamBlockRec aPBR;
      short refNum = 0;
      
/************************************************** 
      OK to "open" driver everytime because driver
      just returns if it's already open.
      This saves us from having to pass around refNum
      or store it in a global.                     
***************************************************/
      
      OSErr err = OpenDriver(KCLIENTDRIVER,&refNum);
      if (err) return err;

      aPBR.cntrlParam.ioCompletion = nil;
      aPBR.cntrlParam.ioVRefNum = 0;
      aPBR.cntrlParam.ioCRefNum = refNum;
      aPBR.cntrlParam.csCode = msg;
      BlockMove(&parm,aPBR.cntrlParam.csParam,sizeof(parm));
            
      (void) PBControlImmed( &aPBR );

      err = aPBR.cntrlParam.ioResult;
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
krbHiParmBlock *KClientSessionKind(  KClientSessionInfo *session, KClientRec **kcRec )
{
      if (KC_SESSION->tag==NEW_KCLIENT_TAG) {
            /* Newer driver, use newer session record */
            if (kcRec)
                  *kcRec            = KC_SESSION;
            return KC_PB;
      }
      else {
            if (kcRec)
                  *kcRec            = NULL;
            return OLD_KC_PB;
      }
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientSetPassword(  KClientSessionInfo *session, char *password  )
{
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);
      
      pb->user = password;
      return KClientSendMessage(cKrbSetPassword,PICK_PARM);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientNewSession(KClientSessionInfo *session, unsigned long lAddr,unsigned short lPort,unsigned long fAddr,unsigned short fPort)
{
      OSErr err;

      err = KClientSendMessage(cKrbNewClientSession,KC_SESSION);
      
      if (err==cKrbBadSelector) {
            /* old driver, so initialize by hand */
            short i,e = sizeof(KClientSessionInfo) / sizeof(long);
            long *s = (long *) session;
            for (i=0;i<e;i++) *s++ = 0;
            err = noErr;
      }

      KC_SESSION->libVersion        = 2;
      KC_PB->lAddr                        = lAddr;
      KC_PB->lPort                        = lPort;
      KC_PB->fAddr                        = fAddr;
      KC_PB->fPort                        = fPort;
            
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientDisposeSession(KClientSessionInfo *session)
{
      KClientRec *kcRec;
      (void) KClientSessionKind(session,&kcRec);
      
      if (kcRec)
            return KClientSendMessage(cKrbDisposeSession,session);

      return noErr;
}

/*---------------------------------------------------------------------------------------------------*/
/*
 * modified by n3liw+@cmu.edu to support SASL, need to be able to specify checksum
 */
OSErr KClientGetTicketForService(KClientSessionInfo *session, char *service,void *buf,unsigned long *buflen)
{
      return KClientGetTicketForServiceFull(session,service,buf,buflen,0);
}

#include <stdio.h>
#include <string.h>

/*
 * store the passed long in network byte order
 */
static char *put_long(char *dst,long aval)
{
      *dst++=aval>>24;
      *dst++=aval>>16;
      *dst++=aval>>8;
      *dst++=aval;
      return dst;
}

/*
 * - int = 1 byte
 * - long = 4 bytes
 * long length of all the following [kclientism]
 * ticket format, from reading mk_req.c
 * int KRB_PROT_VERSION      
 * int AUTH_MSG_APPL_REQUEST
 * int key version numbner
 * string realm
 * int ticket length
 * int authenticator length
 * ticket
 * authenticator [
 *   string name
 *   string instance
 *   string realm
 *   long checksum
 *   byte GMT microseconds/5
 *   int GMT time
 * ] encrypted in session key
 */

/*---------------------------------------------------------------------------------------------------*/
/*
 * created by n3liw+@cmu.edu to support SASL, need to be able to specify checksum
 */
OSErr KClientGetTicketForServiceFull(KClientSessionInfo *session, char *service,void *buf,unsigned long *buflen,long cks)
{
      char *p=(char *)buf;
      long tkt_len;
      long auth_len;
      char wbuf[1500];

      OSErr err;  
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);

      pb->service = service;
      pb->buf = (char *) buf;
      pb->buflen = *buflen;
      pb->checksum = cks;
      err = KClientSendMessage(cKrbGetTicketForService,PICK_PARM);
      *buflen = pb->buflen;
      if(err!=0)
            return err;
      /*
       * if checksum is zero, buth kclientman and kclient will correctly get the ticket
       * if checksum is non zero, then kclientman will have incorrectly encoded 0 in the checksum
       * field of the authenticator, kclient will have encoded the correct checksum...
       * rather than check the underlying authentication package (kclient vs kclientman)
       * we will go ahead and decrypt the authenticator and fix the checksum.  this is unessary but
       * harmless for kclient.
     */
      if(cks==0)
            return 0;
      p+=4+3+strlen(p+7)+1; /*4 byte kclient len, vers,req, kvno*/
      tkt_len= (*p++)&0x0ff;
      auth_len= (*p++)&0x0ff;
      p+=tkt_len;
      err=KClient_des_pcbc_encrypt(session,(unsigned char *)p,(unsigned char *)wbuf,auth_len,0);
      if(err!=0)
            return err;
      {
            char *w=wbuf;
            /* printf("name='%s'\n",w); */
            w+=strlen(w)+1;   /*skip name */
            /* printf("instance='%s'\n",w); */
            w+=strlen(w)+1;   /*skip instance */
            /* printf("realm='%s'\n",w); */
            w+=strlen(w)+1; /*realm*/
            w=put_long(w,cks);
      }
      err=KClient_des_pcbc_encrypt(session,(unsigned char *)wbuf,(unsigned char *)wbuf,auth_len,1);
      memcpy(p,wbuf,auth_len);
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientLogin(  KClientSessionInfo *session, KClientKey *privateKey )
{     
      OSErr err;
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);
      
      pb->service = (char *) privateKey; /* pointer to private key in first 4 bytes */
      err = KClientSendMessage(cKrbLogin,PICK_PARM);
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientSetPrompt(  KClientSessionInfo *session, char *prompt )
{     
      KClientRec *kcRec;
      (void) KClientSessionKind(session,&kcRec);

      if (kcRec)
            kcRec->prompt = prompt;
      else return cKrbBadSelector;
      
      return noErr;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientPasswordLogin(  KClientSessionInfo *session, char *password, KClientKey *privateKey )
{
      OSErr err;
      
      if ( ( err = KClientSetPassword(session,password) ) != noErr )
             return err;
      
      return KClientLogin(session,privateKey);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientPasswordToKey( char *password, KClientKey *privateKey )
{
      ParamBlockRec aPBR;
      short refNum;
      OSErr err;
      
      if ( (err = OpenDriver(KCLIENTDRIVER,&refNum)) != noErr)
            return err;

      aPBR.cntrlParam.ioCompletion = nil;
      aPBR.cntrlParam.ioVRefNum = 0;
      aPBR.cntrlParam.ioCRefNum = refNum;
      aPBR.cntrlParam.csCode = cKrbPasswordToKey;
      ((long *)aPBR.cntrlParam.csParam)[0] = (long)password;
      ((long *)aPBR.cntrlParam.csParam)[1] = (long)privateKey;
            
      (void) PBControl( &aPBR, false );
      return aPBR.cntrlParam.ioResult;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientKeyLogin( KClientSessionInfo *session, KClientKey *privateKey )
{
      OSErr err;

      err = KClientSendMessage(cKrbSetKey,privateKey);
      if (err) return err;
      
      return KClientLogin(session,privateKey);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientLogout( )
{
      krbHiParmBlock    cpb;

      return KClientSendMessage(cKrbDeleteAllSessions, &cpb);
}
            
/*---------------------------------------------------------------------------------------------------*/
short KClientStatus( )
{
      char user[40];
      
      user[0] = '\0';
      (void) KClientGetUserName(user);
      if (*user != 0)
            return KClientLoggedIn;
      return KClientNotLoggedIn;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr _KClientVersion( StringPtr driver, short *majorVersion, short *minorVersion, char *versionString )
{
      ParamBlockRec aPBR;
      short refNum;
      OSErr err;
      
      if ( (err = OpenDriver(driver,&refNum)) != noErr)
            return err;

      aPBR.cntrlParam.ioCompletion = nil;
      aPBR.cntrlParam.ioVRefNum = 0;
      aPBR.cntrlParam.ioCRefNum = refNum;
      aPBR.cntrlParam.csCode = cKrbDriverVersion;
      ((long *)aPBR.cntrlParam.csParam)[1] = (long)versionString;
            
      (void) PBControl( &aPBR, false );
      err = aPBR.cntrlParam.ioResult;
      
      /* For pre-2.0, do some detective work */
      if (err==cKrbBadSelector) {
            *majorVersion = 1;
            aPBR.cntrlParam.csCode = cKrbGetDesPointers;
            ((long *)aPBR.cntrlParam.csParam)[1] = 11; /* so it doesn't return anything */
            (void) PBControl( &aPBR, false );
            if (aPBR.cntrlParam.ioResult==cKrbOldDriver) {
                  *minorVersion = 1;
                  if (versionString)
                        *((long *)versionString) = '1.1\0';
            }
            else {
                  *minorVersion = 0;
                  if (versionString)
                        *((long *)versionString) = '1.0\0';
            }
            err = 0;
      }
      else {
            *majorVersion = aPBR.cntrlParam.csParam[0];
            *minorVersion = aPBR.cntrlParam.csParam[1];
      }
      
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientVersion( short *majorVersion, short *minorVersion, char *versionString )
{
      return _KClientVersion(KCLIENTDRIVER,majorVersion,minorVersion,versionString);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetUserName(char *user)
{
      OSErr err;
      KClientSessionInfo s,*session = &s;
      
      KC_SESSION->tag = 0;
      OLD_KC_PB->user = user;
      err = KClientSendMessage(cKrbGetUserName,session);
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetSessionUserName(KClientSessionInfo *session, char *user, short nameType )
{
      OSErr err;
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);

      pb->user = user;
      kcRec->nameType = nameType;
      err = KClientSendMessage(cKrbGetSessionUserName,PICK_PARM);
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientSetUserName(char *user)
{
      OSErr err;
      KClientSessionInfo s,*session = &s;
      
      KC_SESSION->tag = 0;
      OLD_KC_PB->user = user;
      err = KClientSendMessage(cKrbSetUserName,session);
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientCacheInitialTicket(KClientSessionInfo *session, char *service)
{
      OSErr err;  
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);
            
      pb->service = service;
      err = KClientSendMessage(cKrbCacheInitialTicket,PICK_PARM);
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetSessionKey(KClientSessionInfo *session, KClientKey *sessionKey)
{     
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);

      /* Not logged in and no server context */
      if ((!kcRec || !kcRec->serverContext) && KClientStatus()==KClientNotLoggedIn)
            return cKrbNotLoggedIn;
      
      BlockMove(&(pb->sessionKey),sessionKey,sizeof(KClientKey));
      return 0;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientMakeSendAuth(KClientSessionInfo *session, char *service,void *buf,unsigned long *buflen,long checksum, char *applicationVersion)
{
      OSErr err;
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);
            
      pb->service = service;
      pb->buf = (char *) buf;
      pb->buflen = *buflen;
      pb->checksum = checksum;
      pb->applicationVersion = applicationVersion;
      err = KClientSendMessage(cKrbGetAuthForService,PICK_PARM);
      *buflen = pb->buflen;
      return err;
}                       
/*---------------------------------------------------------------------------------------------------*/
OSErr KClientVerifyReplyTicket(KClientSessionInfo *session, void *buf,unsigned long *buflen )
{
      OSErr err;
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);
      
      pb->buf = (char *) buf;
      pb->buflen = *buflen;
      err = KClientSendMessage(cKrbCheckServiceResponse,PICK_PARM);
      *buflen = pb->buflen;
      return err;
}
            
/*---------------------------------------------------------------------------------------------------*/
OSErr KClientEncrypt(KClientSessionInfo *session, void *buf,unsigned long buflen,void *encryptBuf,unsigned long *encryptLength)
{
      OSErr err;
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);

      pb->buf = (char *) buf;
      pb->buflen = buflen;
      pb->encryptBuf = (char *) encryptBuf;
      err = KClientSendMessage(cKrbEncrypt,PICK_PARM);
      *encryptLength = pb->encryptLength;
      return err;
}
            
/*---------------------------------------------------------------------------------------------------*/
OSErr KClientDecrypt(KClientSessionInfo *session, void *buf,unsigned long buflen,
                              unsigned long *decryptOffset,unsigned long *decryptLength)
{
      OSErr err;
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);

      pb->buf = (char *) buf;
      pb->buflen = buflen;
      err = KClientSendMessage(cKrbDecrypt,PICK_PARM);
      *decryptOffset = pb->decryptOffset;
      *decryptLength = pb->decryptLength;
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
void KClientErrorText(OSErr err, char *text)
{
      ParamBlockRec aPBR;
      short refNum;
      OSErr oerr;
      
      if ( (oerr = OpenDriver(KCLIENTDRIVER,&refNum)) != noErr)
            return;

      aPBR.cntrlParam.ioCompletion = nil;
      aPBR.cntrlParam.ioVRefNum = 0;
      aPBR.cntrlParam.ioCRefNum = refNum;
      aPBR.cntrlParam.csCode = cKrbGetErrorText;
      ((long *)aPBR.cntrlParam.csParam)[0] = (long)err;
      ((long *)aPBR.cntrlParam.csParam)[1] = (long)text;
            
      (void) PBControl( &aPBR, false );
      
      /* In case driver is old, at least return something */
      if (aPBR.cntrlParam.ioResult==cKrbBadSelector) {
            BlockMove("Kerberos error",text,15);            
      }
}

/*---------------------------------------------------------------------------------------------------*/
/* Kerberized Server routines                                                                        */
/*---------------------------------------------------------------------------------------------------*/
OSErr KServerNewSession( KClientSessionInfo *session, char *service,unsigned long lAddr, 
                                    unsigned short lPort,unsigned long fAddr,unsigned short fPort)
{
      OSErr err;

      KC_PB->service                      = service;

      err = KClientSendMessage(cKrbNewServerSession,KC_SESSION);
      
      if (err)
            return err;

      KC_SESSION->libVersion        = 2;
      KC_PB->lAddr                        = lAddr;
      KC_PB->lPort                        = lPort;
      KC_PB->fAddr                        = fAddr;
      KC_PB->fPort                        = fPort;
            
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KServerVerifyTicket( KClientSessionInfo *session, void *buf, char *filename )
{
      OSErr err;
      KC_PB->buf = (char *) buf;
      KC_SESSION->filename = filename;

      err = KClientSendMessage(cKrbServerVerifyTicket,KC_SESSION);
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KServerGetReplyTicket( KClientSessionInfo *session, void *buf, unsigned long *buflen )
{
      OSErr err;
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);
      
      pb->buf           = (char *) buf;
      pb->buflen  = *buflen;

      err = KClientSendMessage(cKrbServerGetReplyTkt,PICK_PARM);
      if (err) return err;
      
      *buflen = pb->buflen;
      return noErr;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KServerAddKey( KClientSessionInfo *session, KClientKey *privateKey, char *service, long version, char *filename )
{
      OSErr err;
      KClientKey key;
      char srv[128];
      char tkt[1250];
      unsigned long len;
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);

      if (!kcRec)
            return cKrbBadSelector; /* old driver */
      
      KC_SESSION->filename    = filename;
      KC_PB->service                = service;

      if (!service) {
            /* No service, build from scratch, prompt the user */
 
            /* Get the user to log in, using service principle and password */
            KClientLogout();
            err = KClientLogin( session, &key );
            if (err) return err;
            
            err = KClientGetUserName(srv);
            if (err) return err;

            /* Get a service ticket for the service so that we can obtain key version number */
            err = KClientGetTicketForService(session, srv,tkt,&len);
            if (err) return err;
                        
            KC_PB->service = srv;
            BlockMove(&key,KC_SESSION->serverKey,8);
            KC_SESSION->keyVersion  = tkt[6];         /* tkt contains private key's version in the seventh byte */
      }
      else {
            KC_SESSION->keyVersion  = version;
            BlockMove(privateKey,KC_SESSION->serverKey,8);
            KC_PB->service          = service;
      }
      
      return KClientSendMessage(cKrbAddServiceKey,session);

}

/*---------------------------------------------------------------------------------------------------*/
OSErr KServerGetKey( KClientSessionInfo *session, KClientKey *privateKey,char *service, long version, char *filename )
{
      OSErr err;
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);
            
      if (!kcRec)
            return cKrbBadSelector; /* old driver */

      KC_SESSION->keyVersion  = version;
      KC_SESSION->filename    = filename;
      KC_PB->service                = service;

      err = KClientSendMessage(cKrbGetServiceKey,KC_SESSION);
      if (err) return err;

      BlockMove(KC_SESSION->serverKey,privateKey,8);
      return noErr;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KServerGetSessionTimeRemaining( KClientSessionInfo *session, long *seconds )
{
      OSErr err;
      KClientRec *kcRec;
      krbHiParmBlock *pb = KClientSessionKind(session,&kcRec);

      err = KClientSendMessage(cKrbGetSessionTimeRemaining,PICK_PARM);
      *seconds = pb->checksum;
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
/* Configuration routines                                                                            */
/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetLocalRealm( char *realm )
{
      krbParmBlock pb;
      pb.uRealm = realm;
      return KClientSendMessage(cKrbGetLocalRealm,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientSetLocalRealm( char *realm )
{
      krbParmBlock pb;
      pb.uRealm = realm;
      return KClientSendMessage(cKrbSetLocalRealm,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetRealm( char *host, char *realm )
{
      krbParmBlock pb;
      pb.uRealm = realm;
      pb.host = host;
      return KClientSendMessage(cKrbGetRealm,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientAddRealmMap( char *host, char *realm )
{
      krbParmBlock pb;
      pb.uRealm = realm;
      pb.host = host;
      return KClientSendMessage(cKrbAddRealmMap,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientDeleteRealmMap( char *host )
{
      krbParmBlock pb;
      pb.host = host;
      return KClientSendMessage(cKrbDeleteRealmMap,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetNthRealmMap( long n, char *host, char *realm )
{
      krbParmBlock pb;  
      pb.host = host;
      pb.uRealm = realm;
      pb.itemNumber = &n;
      return KClientSendMessage(cKrbGetNthRealmMap,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetNthServer( long n, char *host, char *realm, Boolean admin )
{
      krbParmBlock pb;
      
      pb.host = host;
      pb.uRealm = realm;
      pb.itemNumber = &n;
      pb.admin = (long) admin;
      return KClientSendMessage(cKrbGetNthServer,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientAddServerMap( char *host, char *realm, Boolean admin )
{
      krbParmBlock pb;
      pb.uRealm = realm;
      pb.host = host;
      pb.admin = admin ? 1 : 0;
      return KClientSendMessage(cKrbAddServerMap,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientDeleteServerMap( char *host, char *realm )
{
      krbParmBlock pb;
      pb.uRealm = realm;
      pb.host = host;
      return KClientSendMessage(cKrbDeleteServerMap,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetNthServerMap( long n, char *host, char *realm, Boolean *admin )
{
      OSErr err;
      long ladmin;
      krbParmBlock pb;
      
      pb.uRealm = realm;
      pb.host = host;
      pb.adminReturn = &ladmin;
      pb.itemNumber = &n;
      err = KClientSendMessage(cKrbGetNthServerMap,&pb);
      *admin = (ladmin==1);
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetNthServerPort( long n, short *port )
{
      OSErr err;
      krbParmBlock pb;
      pb.itemNumber = &n;
      err = KClientSendMessage(cKrbGetNthServerPort,&pb);
      *port = pb.port;
      return err;
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientSetNthServerPort( long n, short port )
{
      krbParmBlock pb;
      pb.itemNumber = &n;
      pb.port = port;
      return KClientSendMessage(cKrbSetNthServerPort,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetNumSessions( long *n )
{
      krbParmBlock pb;
      pb.itemNumber = n;
      return KClientSendMessage(cKrbGetNumSessions,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetNthSession( long n, char *name, char *instance, char *realm )
{
      krbParmBlock pb;
      pb.itemNumber = &n;
      pb.uName = name;
      pb.uInstance = instance;
      pb.uRealm = realm;
      return KClientSendMessage(cKrbGetNthSession,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientDeleteSession( char *name, char *instance, char *realm )
{
      krbParmBlock pb;
      pb.uName = name;
      pb.uInstance = instance;
      pb.uRealm = realm;
      return KClientSendMessage(cKrbDeleteSession,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetCredentials( char *name, char *instance, char *realm, CREDENTIALS *cred )
{
      krbParmBlock pb;
      pb.uName = name;
      pb.uInstance = instance;
      pb.uRealm = realm;
      pb.cred = cred;
      return KClientSendMessage(cKrbGetCredentials,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientAddCredentials( char *name, char *instance, char *realm, CREDENTIALS *cred )
{
      krbParmBlock pb;
      pb.uName = name;
      pb.uInstance = instance;
      pb.uRealm = realm;
      pb.cred = cred;
      return KClientSendMessage(cKrbAddCredentials,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientDeleteCredentials( char *name, char *instance, char *realm, 
                                                char *sname, char *sinstance, char *srealm )
{
      krbParmBlock pb;
      pb.uName = name;
      pb.uInstance = instance;
      pb.uRealm = realm;
      pb.sName = sname;
      pb.sInstance = sinstance;
      pb.sRealm = srealm;
      return KClientSendMessage(cKrbDeleteCredentials,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetNumCredentials( long *n, char *name, char *instance, char *realm )
{
      krbParmBlock pb;
      pb.uName = name;
      pb.uInstance = instance;
      pb.uRealm = realm;
      pb.itemNumber = n;
      return KClientSendMessage(cKrbGetNumCredentials,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetNthCredential( long n, char *name, char *instance, char *realm,
                                                char *sname, char *sinstance, char *srealm )
{
      krbParmBlock pb;
      pb.uName = name;
      pb.uInstance = instance;
      pb.uRealm = realm;
      pb.sName = sname;
      pb.sInstance = sinstance;
      pb.sRealm = srealm;
      pb.itemNumber = &n;
      return KClientSendMessage(cKrbGetNthCredentials,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientAddSpecial( char *service, char *name )
{
      krbParmBlock pb;
      pb.uName = name;
      pb.sName = service;
      return KClientSendMessage(cKrbAddSpecial,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientDeleteSpecial( char *service )
{
      krbParmBlock pb;
      pb.sName = service;
      return KClientSendMessage(cKrbDeleteSpecial,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetNumSpecials( long *n )
{
      krbParmBlock pb;
      pb.itemNumber = n;
      return KClientSendMessage(cKrbGetNumSpecials,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetNthSpecial( long n, char *name, char *service )
{
      krbParmBlock pb;
      pb.uName = name;
      pb.sName = service;
      pb.itemNumber = &n;
      return KClientSendMessage(cKrbGetNthSpecial,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientSetOption( short option, void *value )
{
      krbParmBlock pb;
      pb.uName = (char *) value;
      pb.port = option;
      return KClientSendMessage(cKrbSetOption,&pb);
}

/*---------------------------------------------------------------------------------------------------*/
OSErr KClientGetOption( short option, void *value )
{
      krbParmBlock pb;
      pb.uName = (char *) value;
      pb.port = option;
      return KClientSendMessage(cKrbGetOption,&pb);
}


Generated by  Doxygen 1.6.0   Back to index