* directory or online at http://www.openafs.org/dl/license10.html
*/
+#include <afsconfig.h>
#include <afs/param.h>
+
+RCSID("$Header$");
+
#include <afs/stds.h>
#include <errno.h>
#include "kauth.h"
#include "kaport.h"
#include "afs/audit.h"
-#include "../permit_xprt.h"
-
-
extern struct ubik_dbase *KA_dbase;
struct kaheader cheader;
Date cheaderReadTime; /* time cheader last read in */
if (nextAutoCPWTime == 0) { /* initialize things */
nextAutoCPWTime = time.tv_sec + autoCPWInterval;
- bcopy (&time, &random_value[0], 8);
- bcopy (&time, &random_value[2], 8);
+ memcpy(&random_value[0], &time, 8);
+ memcpy(&random_value[2], &time, 8);
}
if ((++totalUpdates >= autoCPWUpdates) &&
if (code) return code;
if (to) { /* check if auto cpw is disabled */
if (!(ntohl(tentry.flags) & KAFNOCPW)) {
- bcopy (&random_value[0], &key, sizeof(key));
+ memcpy(&key, &random_value[0], sizeof(key));
des_fixup_key_parity (&key);
code = set_password (tt, KA_ADMIN_NAME, KA_ADMIN_INST,
&key, 0, 0);
if (code) return code;
if (to) { /* check if auto cpw is disabled */
if (!(ntohl(tentry.flags) & KAFNOCPW)) {
- bcopy (&random_value[2], &key, sizeof(key));
+ memcpy(&key, &random_value[2], sizeof(key));
des_fixup_key_parity (&key);
code = set_password (tt, KA_TGS_NAME, lrealm, &key, 0, 0);
if (code == 0) {
if (code = ka_NewKey (tt, to, &tentry, key)) return code;
}
else {
- bcopy(key, &tentry.key, sizeof(tentry.key));
+ memcpy(&tentry.key, key, sizeof(tentry.key));
tentry.key_version = htonl(0);
}
tentry.user_expiration = htonl(NEVERDATE);
/* Put actual stub routines here */
-afs_int32 KAM_CreateUser (call, aname, ainstance, ainitpw)
+afs_int32 SKAM_CreateUser (call, aname, ainstance, ainitpw)
struct rx_call *call;
char *aname;
char *ainstance;
return code;
}
-afs_int32 KAA_ChangePassword (call, aname, ainstance, arequest, oanswer)
+afs_int32 SKAA_ChangePassword (call, aname, ainstance, arequest, oanswer)
struct rx_call *call;
char *aname;
char *ainstance;
oanswer->SeqLen = answer_len;
answer = oanswer->SeqBody;
request.time = htonl (request_time+1);
- bcopy ((char *)&request.time, answer, sizeof(Date));
+ memcpy(answer, (char *)&request.time, sizeof(Date));
answer += sizeof(Date);
- bcopy (KA_CPW_ANS_LABEL, answer, KA_LABELSIZE);
+ memcpy(answer, KA_CPW_ANS_LABEL, KA_LABELSIZE);
des_pcbc_encrypt (oanswer->SeqBody, oanswer->SeqBody, answer_len,
user_schedule, &tentry.key, ENCRYPT);
int code;
Date now;
int i;
- int reuse_p;
extern int MinHours;
afs_uint32 newsum;
if ((now - ntohl(tentry->change_password_time)) < MinHours*60*60)
return KATOOSOON;
- if (!bcmp(password, &(tentry->key), sizeof(EncryptionKey)))
+ if (!memcmp(password, &(tentry->key), sizeof(EncryptionKey)))
return KAREUSED;
code = ka_KeyCheckSum ((char *)password, &newsum);
if (special_name (name, instance)) { /* set key over rides key_version */
-#if SPECIAL
tentry.flags = htonl (ntohl(tentry.flags) | KAFSPECIAL);
-#endif
if (code = ka_NewKey (tt, to, &tentry, password)) return(code);
}
else {
- bcopy (password, &tentry.key, sizeof(tentry.key));
+ memcpy(&tentry.key, password, sizeof(tentry.key));
if (!kvno) {
kvno = ntohl(tentry.key_version);
if ((kvno < 1) || (kvno >= MAXKAKVNO))
return(0);
}
-afs_int32 KAM_SetPassword (call, aname, ainstance, akvno, apassword)
+afs_int32 SKAM_SetPassword (call, aname, ainstance, akvno, apassword)
struct rx_call *call;
char *aname;
char *ainstance;
answer = (struct ka_ticketAnswer *)oanswer->SeqBody;
answer->challenge = htonl(challenge);
- bcopy (sessionKey, &answer->sessionKey, sizeof(struct ktc_encryptionKey));
+ memcpy(&answer->sessionKey, sessionKey, sizeof(struct ktc_encryptionKey));
answer->startTime = htonl(start);
answer->endTime = htonl(end);
answer->kvno = server->key_version;
putstr (server->userID.name);
putstr (server->userID.instance);
if (rem < ticketLen+KA_LABELSIZE) return code;
- bcopy (ticket, ans, ticketLen);
+ memcpy(ans, ticket, ticketLen);
ans += ticketLen;
- if (label) bcopy (label, ans, KA_LABELSIZE);
- else bzero (ans, KA_LABELSIZE);
+ if (label) memcpy(ans, label, KA_LABELSIZE);
+ else memset(ans, 0, KA_LABELSIZE);
ans += KA_LABELSIZE;
oanswer->SeqLen = (ans - oanswer->SeqBody);
}
else { /* return our time if possible */
oanswer->SeqLen = sizeof(afs_int32);
request.time = htonl(now);
- bcopy (&request.time, oanswer->SeqBody, sizeof(afs_int32));
+ memcpy(oanswer->SeqBody, &request.time, sizeof(afs_int32));
}
#endif
code = KACLOCKSKEW;
if (to == 0) {code = KANOENT; goto abort; }
tgskvno = ntohl(server.key_version);
- bcopy (&server.key, &tgskey, sizeof(tgskey));
+ memcpy(&tgskey, &server.key, sizeof(tgskey));
code = des_random_key (&sessionKey);
if (code) {
oanswer->SeqLen = answer_len;
answer = oanswer->SeqBody;
answer_time = htonl(request.time+1);
- bcopy ((char *)&answer_time, answer, sizeof(Date));
+ memcpy(answer, (char *)&answer_time, sizeof(Date));
answer += sizeof(Date);
- bcopy ((char *)&sessionKey, answer, sizeof(struct ktc_encryptionKey));
+ memcpy(answer, (char *)&sessionKey, sizeof(struct ktc_encryptionKey));
answer += sizeof(struct ktc_encryptionKey);
temp = htonl(tgskvno);
- bcopy ((char *)&temp, answer, sizeof(afs_int32));
+ memcpy(answer, (char *)&temp, sizeof(afs_int32));
answer += sizeof(afs_int32);
temp = htonl(ticketLen);
- bcopy ((char *)&temp, answer, sizeof(afs_int32));
+ memcpy(answer, (char *)&temp, sizeof(afs_int32));
answer += sizeof(afs_int32);
- bcopy (ticket, answer, ticketLen);
+ memcpy(answer, ticket, ticketLen);
answer += ticketLen;
- bcopy ((tgt ? KA_GETTGT_ANS_LABEL : KA_GETADM_ANS_LABEL), answer,
- KA_LABELSIZE);
+ memcpy(answer, (tgt ? KA_GETTGT_ANS_LABEL : KA_GETADM_ANS_LABEL), KA_LABELSIZE);
break;
case 1:
case 2:
temp = pwexpires << 24; /* move it into the high byte */
pwexpires = htonl(temp);
- bcopy (&pwexpires, (char * )oanswer->SeqBody + oanswer->SeqLen, sizeof(afs_int32));
+ memcpy((char * )oanswer->SeqBody + oanswer->SeqLen, &pwexpires, sizeof(afs_int32));
oanswer->SeqLen += sizeof(afs_int32);
oanswer->SeqLen = round_up_to_ebs(oanswer->SeqLen);
if (oanswer->SeqLen > oanswer->MaxSeqLen) {
return code;
}
-afs_int32 KAA_Authenticate_old (call, aname, ainstance, start, end,
+afs_int32 SKAA_Authenticate_old (call, aname, ainstance, start, end,
arequest, oanswer)
struct rx_call *call;
char *aname;
return code;
}
-afs_int32 KAA_Authenticate (call, aname, ainstance, start, end, arequest, oanswer)
+afs_int32 SKAA_Authenticate (call, aname, ainstance, start, end, arequest, oanswer)
struct rx_call *call;
char *aname;
char *ainstance;
return code;
}
-afs_int32 KAA_AuthenticateV2 (call, aname, ainstance, start, end, arequest, oanswer)
+afs_int32 SKAA_AuthenticateV2 (call, aname, ainstance, start, end, arequest, oanswer)
struct rx_call *call;
char *aname;
char *ainstance;
return code;
}
-afs_int32 KAM_SetFields (call, aname, ainstance, aflags,
+afs_int32 SKAM_SetFields (call, aname, ainstance, aflags,
aexpiration, alifetime, amaxAssociates, misc_auth_bytes, spare2)
struct rx_call *call;
char *aname;
afs_int32 caller;
afs_int32 tentry_offset; /* offset of entry */
struct kaentry tentry;
- unsigned char newvals[4], oldvals[4];
- int i;
+ unsigned char newvals[4];
COUNT_REQ (SetFields);
if (newvals[REUSEFLAGS]) {
if (newvals[REUSEFLAGS] & KA_REUSEPW)
- bzero(tentry.pwsums, KA_NPWSUMS);
+ memset(tentry.pwsums, 0, KA_NPWSUMS);
else if ((newvals[REUSEFLAGS] & KA_NOREUSEPW) && !tentry.pwsums[0])
tentry.pwsums[0] = 0xff;
}
/* delete a user */
-afs_int32 KAM_DeleteUser(call, aname, ainstance)
+afs_int32 SKAM_DeleteUser(call, aname, ainstance)
struct rx_call *call;
char *aname;
char *ainstance;
* report that the ID is not locked, or else to find out when the ID
* will be unlocked.
*/
-afs_int32 KAM_GetEntry (call, aname, ainstance, aversion, aentry)
+afs_int32 SKAM_GetEntry (call, aname, ainstance, aversion, aentry)
struct rx_call *call;
char *aname;
char *ainstance;
get_time (0,0,0); /* generate random update */
- bzero (aentry, sizeof(*aentry));
+ memset(aentry, 0, sizeof(*aentry));
aentry->minor_version = KAMINORVERSION;
aentry->flags = ntohl(tentry.flags);
aentry->user_expiration = ntohl(tentry.user_expiration);
rxkad_GetServerInfo(call->conn, &enc_level, 0, 0, 0, 0, 0);
if ((noAuthenticationRequired) ||
(callerIsAdmin && enc_level == rxkad_crypt))
- bcopy (&tentry.key, &aentry->key, sizeof(struct ktc_encryptionKey));
- else bzero (&aentry->key, sizeof(aentry->key));
+ memcpy(&aentry->key, &tentry.key, sizeof(struct ktc_encryptionKey));
+ else memset(&aentry->key, 0, sizeof(aentry->key));
code = ka_KeyCheckSum ((char *)&tentry.key, &aentry->keyCheckSum);
if (!tentry.pwsums[0] && npwSums > 1 && !tentry.pwsums[1]) {
aentry->reserved3 = 0x12340000;
return code;
}
-afs_int32 KAM_ListEntry (call, previous_index, index, count, name)
+afs_int32 SKAM_ListEntry (call, previous_index, index, count, name)
struct rx_call *call;
afs_int32 previous_index; /* last entry ret'd or 0 for first */
afs_int32 *index; /* index of this entry */
sizeof(struct ka_getTicketAnswer) - 5*MAXKTCNAMELEN) goto abort;
answer = (struct ka_getTicketAnswer *)oanswer->SeqBody;
- bcopy (&sessionKey, &answer->sessionKey,
- sizeof(struct ktc_encryptionKey));
+ memcpy(&answer->sessionKey, &sessionKey, sizeof(struct ktc_encryptionKey));
answer->startTime = htonl(times.start);
answer->endTime = htonl(end);
answer->kvno = server.key_version;
putstr (sname);
putstr (sinstance);
if (rem < ticketLen) goto abort;
- bcopy (ticket, ans, ticketLen);
+ memcpy(ans, ticket, ticketLen);
oanswer->SeqLen = (ans - oanswer->SeqBody) + ticketLen;
}
oanswer->SeqLen = round_up_to_ebs(oanswer->SeqLen);
return code;
}
-afs_int32 KAT_GetTicket_old (call, kvno, authDomain, aticket,
+afs_int32 SKAT_GetTicket_old (call, kvno, authDomain, aticket,
sname, sinstance, atimes, oanswer)
struct rx_call *call;
afs_int32 kvno;
return code;
}
-afs_int32 KAT_GetTicket (call, kvno, authDomain, aticket,
+afs_int32 SKAT_GetTicket (call, kvno, authDomain, aticket,
sname, sinstance, atimes, oanswer)
struct rx_call *call;
afs_int32 kvno;
return code;
}
-afs_int32 KAM_GetStats (call, version, admin_accounts, statics, dynamics)
+afs_int32 SKAM_GetStats (call, version, admin_accounts, statics, dynamics)
struct rx_call *call;
afs_int32 version;
afs_int32 *admin_accounts;
}
*admin_accounts = ntohl(cheader.admin_accounts);
- /* bcopy ((char *)&cheader.stats, (char *)statics, sizeof(kasstats)); */
+ /* memcpy((char *)statics, (char *)&cheader.stats, sizeof(kasstats)); */
/* these are stored in network byte order and must be copied */
statics->allocs = ntohl(cheader.stats.allocs);
statics->frees = ntohl(cheader.stats.frees);
check that the statistics command copies all the fields
#endif
- bcopy ((char *)&dynamic_statistics, (char *)dynamics, sizeof(kadstats));
+ memcpy((char *)dynamics, (char *)&dynamic_statistics, sizeof(kadstats));
statics->minor_version = KAMINORVERSION;
dynamics->minor_version = KAMINORVERSION;
* ignore this for aix till v3.1... */
getrusage(RUSAGE_SELF, &ru);
#if (KAMAJORVERSION>5)
- bcopy (&ru.ru_utime, &dynamics->utime, sizeof(struct katimeval));
- bcopy (&ru.ru_stime, &dynamics->stime, sizeof(struct katimeval));
+ memcpy(&dynamics->utime, &ru.ru_utime, sizeof(struct katimeval));
+ memcpy(&dynamics->stime, &ru.ru_stime, sizeof(struct katimeval));
dynamics->dataSize = ru.ru_idrss;
dynamics->stackSize = ru.ru_isrss;
dynamics->pageFailts = ru.ru_majflt;
return code;
}
-afs_int32 KAM_GetPassword (call, name, password)
+afs_int32 SKAM_GetPassword (call, name, password)
struct rx_call *call;
char *name;
EncryptionKey *password;
struct rx_call *call;
char *name;
EncryptionKey *password;
-{ int code = KANOAUTH;
+{
+ int code = KANOAUTH;
+ COUNT_REQ (GetPassword);
+
+#ifdef GETPASSWORD
+ {
afs_int32 to;
struct ubik_trans *tt;
struct kaentry tentry;
- COUNT_REQ (GetPassword);
-#ifdef GETPASSWORD
if (!name_instance_legal (name, "")) return KABADNAME;
/* only requests from this host work */
if (rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))) != htonl(INADDR_LOOPBACK))
/* this isn't likely to be used because of string to key problems, so since
this is a temporary thing anyway, we'll use it here. */
- { extern char udpAuthPrincipal[256];
+ {
+ extern char udpAuthPrincipal[256];
+
save_principal (udpAuthPrincipal, name, 0, 0);
}
+
get_time (0,0,0); /* update random value */
code = FindBlock(tt, name, "", &to, &tentry);
if (code) goto abort;
return code;
}
- bcopy (&tentry.key, password, sizeof (*password));
+ memcpy(password, &tentry.key, sizeof (*password));
code = ubik_EndTrans (tt);
+ }
#endif
return code;
}
-afs_int32 KAM_GetRandomKey (call, key)
+afs_int32 SKAM_GetRandomKey (call, key)
struct rx_call *call;
EncryptionKey *key;
{
return 0;
}
-afs_int32 KAM_Debug (call, version, checkDB, info)
+afs_int32 SKAM_Debug (call, version, checkDB, info)
struct rx_call *call;
afs_int32 version;
int checkDB; /* start a transaction to examine DB */
if (sizeof(struct ka_cpwRequest) % 8) return KAINTERNALERROR;
if (version != KAMAJORVERSION) return KAOLDINTERFACE;
- bzero (info, sizeof(*info));
+ memset(info, 0, sizeof(*info));
info->minorVersion = KAMINORVERSION;
info->host = dynamic_statistics.host;
* prob'ly ought to check the noauth flag.
*/
#define ABORTIF(A) {if(code= A){goto abort;}}
-afs_int32 KAM_Unlock (call, aname, ainstance, spare1, spare2, spare3, spare4)
+afs_int32 SKAM_Unlock (call, aname, ainstance, spare1, spare2, spare3, spare4)
struct rx_call *call;
char *aname;
char *ainstance;
return code;
}
-afs_int32 KAM_LockStatus (call, aname, ainstance, lockeduntil, spare1, spare2, spare3, spare4)
+afs_int32 SKAM_LockStatus (call, aname, ainstance, lockeduntil, spare1, spare2, spare3, spare4)
struct rx_call *call;
char *aname;
char *ainstance;
git://git.openafs.org / openafs.git / blobdiff