+Thu Apr 13 16:20:28 1995 Keith Vetter (keithv@fusion.com)
+
+ * windows.in: compile with stdc extensions enabled versus
+ strict stdc adherence.
+
Tue Mar 28 17:58:55 1995 John Gilmore (gnu at toad.com)
* mac-config.cache: Correct some entries.
# /* The name of the C compiler for the target */
CC=cl /nologo
CL=
-CCOPTS=/ALw /Zpa /GD2s /Os /Zi /Od /W3 $(XTRA)
-CCOPTS2=/AL /Zpa /G2s /Os /Zi /Od /W3 -DINTERFACE= -DINTERFACE_C= $(XTRA)
+CCOPTS=/ALw /Zp /GD2s /Os /Zi /Od /W3 $(XTRA)
+CCOPTS2=/AL /Zp /G2s /Os /Zi /Od /W3 -DINTERFACE= -DINTERFACE_C= $(XTRA)
CPPFLAGS = -I$(SRCTOP)/include -I$(SRCTOP)/include/krb5
DEFS = $(CPPFLAGS)
CFLAGS2 = $(CCOPTS2) $(DEFS)
+Thu Apr 13 16:05:08 1995 Keith Vetter (keithv@fusion.com)
+
+ * bsdlib.h, bstring.h, fake-std.h, syslog.h: __STDC__ conditionals
+ also check for the _WINDOWS define.
+ * krb5.h: added FAR to pointers visible to the world.
+
Tue Mar 28 18:12:32 1995 John Gilmore (gnu at toad.com)
* Makefile.in (KRB5_HEADERS, install): `Make install' now works.
*/
#ifndef __BSDLIB__
#define __BSDLIB__
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
/* compat-4.3 */
extern char *ecvt (double , int , int *, int *);
extern char *fcvt (double , int , int *, int *);
*/
#ifndef __BSTRING__
#define __BSTRING__
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
/* compat-sys5 */
/* these are in <string.h> */
extern int bcmp (const char *, const char *, int );
-#ifdef __STDC__
-# define P(s) s
+#if defined(__STDC__) || defined(_WINDOWS)
#else
# define P(s) ()
#endif
int isatty P((int ));
double ldexp P((double , int ));
int longjmperror P((void ));
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
void *malloc P((size_t ));
#else
char *malloc P((unsigned ));
struct ttyent *getttynam P((const char * ));
unsigned long inet_network P((const char * ));
int initgroups P((char * , int ));
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
void *malloc P((unsigned ));
#else
char *malloc P((unsigned ));
typedef struct _krb5_context {
krb5_magic magic;
- krb5_enctype * etypes;
+ krb5_enctype FAR *etypes;
int etype_count;
- void * os_context;
-} * krb5_context;
+ void FAR *os_context;
+} FAR * krb5_context;
struct _krb5_auth_context;
typedef struct _krb5_auth_context krb5_auth_context;
krb5_magic magic;
krb5_authdatatype ad_type;
int length;
- krb5_octet *contents;
+ krb5_octet FAR *contents;
} krb5_authdata;
/* structure for transited encoding */
krb5_magic magic;
/* to-be-encrypted portion */
krb5_flags flags; /* flags */
- krb5_keyblock *session; /* session key: includes keytype */
+ krb5_keyblock FAR *session; /* session key: includes keytype */
krb5_principal client; /* client name/realm */
krb5_transited transited; /* list of transited realms */
krb5_ticket_times times; /* auth, start, end, renew_till */
- krb5_address **caddrs; /* array of ptrs to addresses */
- krb5_authdata **authorization_data; /* auth data */
+ krb5_address FAR * FAR *caddrs; /* array of ptrs to addresses */
+ krb5_authdata FAR * FAR *authorization_data; /* auth data */
} krb5_enc_tkt_part;
typedef struct _krb5_ticket {
krb5_principal server; /* server name/realm */
krb5_enc_data enc_part; /* encryption type, kvno, encrypted
encoding */
- krb5_enc_tkt_part *enc_part2; /* ptr to decrypted version, if
+ krb5_enc_tkt_part FAR *enc_part2; /* ptr to decrypted version, if
available */
} krb5_ticket;
typedef struct _krb5_authenticator {
krb5_magic magic;
krb5_principal client; /* client name/realm */
- krb5_checksum *checksum; /* checksum, includes type, optional */
+ krb5_checksum FAR *checksum; /* checksum, includes type, optional */
krb5_int32 cusec; /* client usec portion */
krb5_timestamp ctime; /* client sec portion */
- krb5_keyblock *subkey; /* true session key, optional */
+ krb5_keyblock FAR *subkey; /* true session key, optional */
krb5_int32 seq_number; /* sequence #, optional */
- krb5_authdata **authorization_data; /* New add by Ari, auth data */
+ krb5_authdata FAR * FAR *authorization_data; /* New add by Ari, auth data */
} krb5_authenticator;
typedef struct _krb5_tkt_authent {
krb5_magic magic;
- krb5_ticket *ticket;
- krb5_authenticator *authenticator;
+ krb5_ticket FAR *ticket;
+ krb5_authenticator FAR *authenticator;
krb5_flags ap_options;
} krb5_tkt_authent;
krb5_boolean is_skey; /* true if ticket is encrypted in
another ticket's skey */
krb5_flags ticket_flags; /* flags in ticket */
- krb5_address **addresses; /* addrs in ticket */
+ krb5_address FAR * FAR *addresses; /* addrs in ticket */
krb5_data ticket; /* ticket string itself */
krb5_data second_ticket; /* second ticket, if related to
ticket (via DUPLICATE-SKEY or
ENC-TKT-IN-SKEY) */
- krb5_authdata **authdata; /* authorization data */
+ krb5_authdata FAR * FAR *authdata; /* authorization data */
} krb5_creds;
/* Last request fields */
krb5_magic magic;
krb5_ui_2 pa_type;
int length;
- krb5_octet *contents;
+ krb5_octet FAR *contents;
} krb5_pa_data;
typedef struct _krb5_kdc_req {
krb5_magic magic;
krb5_msgtype msg_type; /* AS_REQ or TGS_REQ? */
- krb5_pa_data **padata; /* e.g. encoded AP_REQ */
+ krb5_pa_data FAR * FAR *padata; /* e.g. encoded AP_REQ */
/* real body */
krb5_flags kdc_options; /* requested options */
krb5_principal client; /* includes realm; optional */
krb5_timestamp rtime; /* (optional) requested renew_till */
krb5_int32 nonce; /* nonce to match request/response */
int netypes; /* # of etypes, must be positive */
- krb5_enctype *etype; /* requested encryption type(s) */
- krb5_address **addresses; /* requested addresses, optional */
+ krb5_enctype FAR *etype; /* requested encryption type(s) */
+ krb5_address FAR * FAR *addresses; /* requested addresses, optional */
krb5_enc_data authorization_data; /* encrypted auth data; OPTIONAL */
- krb5_authdata **unenc_authdata; /* unencrypted auth data,
+ krb5_authdata FAR * FAR *unenc_authdata; /* unencrypted auth data,
if available */
- krb5_ticket **second_ticket; /* second ticket array; OPTIONAL */
+ krb5_ticket FAR * FAR *second_ticket;/* second ticket array; OPTIONAL */
} krb5_kdc_req;
typedef struct _krb5_enc_kdc_rep_part {
krb5_magic magic;
/* encrypted part: */
krb5_msgtype msg_type; /* krb5 message type */
- krb5_keyblock *session; /* session key */
- krb5_last_req_entry **last_req; /* array of ptrs to entries */
+ krb5_keyblock FAR *session; /* session key */
+ krb5_last_req_entry FAR * FAR *last_req; /* array of ptrs to entries */
krb5_int32 nonce; /* nonce from request */
krb5_timestamp key_exp; /* expiration date */
krb5_flags flags; /* ticket flags */
krb5_ticket_times times; /* lifetime info */
krb5_principal server; /* server's principal identifier */
- krb5_address **caddrs; /* array of ptrs to addresses,
+ krb5_address FAR * FAR *caddrs; /* array of ptrs to addresses,
optional */
} krb5_enc_kdc_rep_part;
krb5_magic magic;
/* cleartext part: */
krb5_msgtype msg_type; /* AS_REP or KDC_REP? */
- krb5_pa_data **padata; /* preauthentication data from KDC */
+ krb5_pa_data FAR * FAR *padata; /* preauthentication data from KDC */
krb5_principal client; /* client's principal identifier */
- krb5_ticket *ticket; /* ticket */
+ krb5_ticket FAR *ticket; /* ticket */
krb5_enc_data enc_part; /* encryption type, kvno, encrypted
encoding */
- krb5_enc_kdc_rep_part *enc_part2; /* unencrypted version, if available */
+ krb5_enc_kdc_rep_part FAR *enc_part2;/* unencrypted version, if available */
} krb5_kdc_rep;
/* error message structure */
typedef struct _krb5_ap_req {
krb5_magic magic;
krb5_flags ap_options; /* requested options */
- krb5_ticket *ticket; /* ticket */
+ krb5_ticket FAR *ticket; /* ticket */
krb5_enc_data authenticator; /* authenticator (already encrypted) */
} krb5_ap_req;
krb5_magic magic;
krb5_timestamp ctime; /* client time, seconds portion */
krb5_int32 cusec; /* client time, microseconds portion */
- krb5_keyblock *subkey; /* true session key, optional */
+ krb5_keyblock FAR *subkey; /* true session key, optional */
krb5_int32 seq_number; /* sequence #, optional */
} krb5_ap_rep_enc_part;
krb5_int32 usec; /* microsecond portion of time,
optional */
krb5_int32 seq_number; /* sequence #, optional */
- krb5_address *s_address; /* sender address */
- krb5_address *r_address; /* recipient address, optional */
- krb5_checksum *checksum; /* data integrity checksum */
+ krb5_address FAR *s_address; /* sender address */
+ krb5_address FAR *r_address; /* recipient address, optional */
+ krb5_checksum FAR *checksum; /* data integrity checksum */
} krb5_safe;
typedef struct _krb5_priv {
krb5_timestamp timestamp; /* client time, optional */
krb5_int32 usec; /* microsecond portion of time, opt. */
krb5_int32 seq_number; /* sequence #, optional */
- krb5_address *s_address; /* sender address */
- krb5_address *r_address; /* recipient address, optional */
+ krb5_address FAR *s_address; /* sender address */
+ krb5_address FAR *r_address; /* recipient address, optional */
} krb5_priv_enc_part;
typedef struct _krb5_cred_info {
krb5_magic magic;
- krb5_keyblock* session; /* session key used to encrypt */
+ krb5_keyblock FAR *session; /* session key used to encrypt */
/* ticket */
krb5_principal client; /* client name/realm, optional */
krb5_principal server; /* server name/realm, optional */
krb5_flags flags; /* ticket flags, optional */
krb5_ticket_times times; /* auth, start, end, renew_till, */
/* optional */
- krb5_address **caddrs; /* array of ptrs to addresses */
+ krb5_address FAR * FAR *caddrs; /* array of ptrs to addresses */
} krb5_cred_info;
typedef struct _krb5_cred_enc_part {
krb5_int32 nonce; /* nonce, optional */
krb5_timestamp timestamp; /* client time */
krb5_int32 usec; /* microsecond portion of time */
- krb5_address *s_address; /* sender address, optional */
- krb5_address *r_address; /* recipient address, optional */
- krb5_cred_info **ticket_info;
+ krb5_address FAR *s_address; /* sender address, optional */
+ krb5_address FAR *r_address; /* recipient address, optional */
+ krb5_cred_info FAR * FAR *ticket_info;
} krb5_cred_enc_part;
typedef struct _krb5_cred {
krb5_magic magic;
- krb5_ticket **tickets; /* tickets */
+ krb5_ticket FAR * FAR *tickets; /* tickets */
krb5_enc_data enc_part; /* encrypted part */
- krb5_cred_enc_part *enc_part2; /* unencrypted version, if available*/
+ krb5_cred_enc_part FAR *enc_part2; /* unencrypted version, if available*/
} krb5_cred;
/* Sandia password generation structures */
typedef struct _passwd_phrase_element {
krb5_magic magic;
- krb5_data *passwd;
- krb5_data *phrase;
+ krb5_data FAR *passwd;
+ krb5_data FAR *phrase;
} passwd_phrase_element;
typedef struct _krb5_pwd_data {
krb5_magic magic;
int sequence_count;
- passwd_phrase_element **element;
+ passwd_phrase_element FAR * FAR *element;
} krb5_pwd_data;
/* these need to be here so the typedefs are available for the prototypes */
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * asn1.h, ccache.h, encryption.h, func-pro.h, hostaddr.h, keytab.h,
+ los-prot.h, preauth.h, rcache.h:
+ removed unneeded INTERFACE from non-api functions.
+ * adm_defs.h, ccache.h, encryption.h, hostaddr.h, k5-free.h, keytab.h,
+ macros.h, rcache.h:
+ Added FAR to pointers visible to the world.
+ * base-def.h, ext-prot.h, rsa-md5.h: __STDC__ condition also
+ checks for the _WINDOWS define.
+
Wed Apr 5 16:41:41 1995 Keith Vetter (keithv@fusion.com)
* los-proto.h, func-proto.h: moved krb5_us_timeofday and
char appl_code;
char oper_code;
char retn_code;
- char *message;
+ char FAR *message;
} kadmin_requests;
#if 0
-static char *oper_type[] = {
+static char FAR *oper_type[] = {
"complete", /* 0 */
"addition", /* 1 */
"deletion", /* 2 */
#if 0
-static char *ksrvutil_message[] = {
+static char FAR *ksrvutil_message[] = {
"Service Key Changed", /* 0 */
"New Key and Version Received" /* 1 */
};
#define KADMSAG 0x01
#if 0
-static char *kadmind_general_response[] = {
+static char FAR *kadmind_general_response[] = {
"Success", /* 0 */
"Service Access Granted" /* 1 */
};
#define KPASSBAD 0x01
#if 0
-static char *kadmind_kpasswd_response[] = {
+static char FAR *kadmind_kpasswd_response[] = {
"Password Changed", /* 0 */
"Password NOT Changed!" /* 1 */
};
#define KSRVCATASTROPHE 0x02
#if 0
-static char *kadmind_ksrvutil_response[] = {
+static char FAR *kadmind_ksrvutil_response[] = {
"Service Password Change Complete", /* 0 */
"One or More Service Password Change(s) Failed!", /* 1 */
"Database Update Failure - Possible Catastrophe!!" /* 2 */
#define KADMBAD 0x01
#if 0
-static char *kadmind_kadmin_response[] = {
+static char FAR *kadmind_kadmin_response[] = {
"Administrative Service Completed", /* 0 */
"Principal Unknown!", /* 1 */
"Principal Already Exists!", /* 2 */
Returns ENOMEM if memory runs out.
*/
-krb5_error_code INTERFACE encode_krb5_authenticator
+krb5_error_code encode_krb5_authenticator
PROTOTYPE((const krb5_authenticator *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_ticket
+krb5_error_code encode_krb5_ticket
PROTOTYPE((const krb5_ticket *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_encryption_key
+krb5_error_code encode_krb5_encryption_key
PROTOTYPE((const krb5_keyblock *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_enc_tkt_part
+krb5_error_code encode_krb5_enc_tkt_part
PROTOTYPE((const krb5_enc_tkt_part *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_enc_kdc_rep_part
+krb5_error_code encode_krb5_enc_kdc_rep_part
PROTOTYPE((const krb5_enc_kdc_rep_part *rep, krb5_data **code));
/* yes, the translation is identical to that used for KDC__REP */
-krb5_error_code INTERFACE encode_krb5_as_rep
+krb5_error_code encode_krb5_as_rep
PROTOTYPE((const krb5_kdc_rep *rep, krb5_data **code));
/* yes, the translation is identical to that used for KDC__REP */
-krb5_error_code INTERFACE encode_krb5_tgs_rep
+krb5_error_code encode_krb5_tgs_rep
PROTOTYPE((const krb5_kdc_rep *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_ap_req
+krb5_error_code encode_krb5_ap_req
PROTOTYPE((const krb5_ap_req *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_ap_rep
+krb5_error_code encode_krb5_ap_rep
PROTOTYPE((const krb5_ap_rep *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_ap_rep_enc_part
+krb5_error_code encode_krb5_ap_rep_enc_part
PROTOTYPE((const krb5_ap_rep_enc_part *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_as_req
+krb5_error_code encode_krb5_as_req
PROTOTYPE((const krb5_kdc_req *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_tgs_req
+krb5_error_code encode_krb5_tgs_req
PROTOTYPE((const krb5_kdc_req *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_kdc_req_body
+krb5_error_code encode_krb5_kdc_req_body
PROTOTYPE((const krb5_kdc_req *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_safe
+krb5_error_code encode_krb5_safe
PROTOTYPE((const krb5_safe *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_priv
+krb5_error_code encode_krb5_priv
PROTOTYPE((const krb5_priv *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_enc_priv_part
+krb5_error_code encode_krb5_enc_priv_part
PROTOTYPE((const krb5_priv_enc_part *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_cred
+krb5_error_code encode_krb5_cred
PROTOTYPE((const krb5_cred *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_enc_cred_part
+krb5_error_code encode_krb5_enc_cred_part
PROTOTYPE((const krb5_cred_enc_part *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_error
+krb5_error_code encode_krb5_error
PROTOTYPE((const krb5_error *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_authdata
+krb5_error_code encode_krb5_authdata
PROTOTYPE((const krb5_authdata **rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_pwd_sequence
+krb5_error_code encode_krb5_pwd_sequence
PROTOTYPE((const passwd_phrase_element *rep, krb5_data **code));
-krb5_error_code INTERFACE encode_krb5_pwd_data
+krb5_error_code encode_krb5_pwd_data
PROTOTYPE((const krb5_pwd_data *rep, krb5_data **code));
/*************************************************************************
Returns asn1 and krb5 errors.
*/
-krb5_error_code INTERFACE decode_krb5_authenticator
+krb5_error_code decode_krb5_authenticator
PROTOTYPE((const krb5_data *code, krb5_authenticator **rep));
-krb5_error_code INTERFACE decode_krb5_ticket
+krb5_error_code decode_krb5_ticket
PROTOTYPE((const krb5_data *code, krb5_ticket **rep));
-krb5_error_code INTERFACE decode_krb5_encryption_key
+krb5_error_code decode_krb5_encryption_key
PROTOTYPE((const krb5_data *output, krb5_keyblock **rep));
-krb5_error_code INTERFACE decode_krb5_enc_tkt_part
+krb5_error_code decode_krb5_enc_tkt_part
PROTOTYPE((const krb5_data *output, krb5_enc_tkt_part **rep));
-krb5_error_code INTERFACE decode_krb5_enc_kdc_rep_part
+krb5_error_code decode_krb5_enc_kdc_rep_part
PROTOTYPE((const krb5_data *output, krb5_enc_kdc_rep_part **rep));
-krb5_error_code INTERFACE decode_krb5_as_rep
+krb5_error_code decode_krb5_as_rep
PROTOTYPE((const krb5_data *output, krb5_kdc_rep **rep));
-krb5_error_code INTERFACE decode_krb5_tgs_rep
+krb5_error_code decode_krb5_tgs_rep
PROTOTYPE((const krb5_data *output, krb5_kdc_rep **rep));
-krb5_error_code INTERFACE decode_krb5_ap_req
+krb5_error_code decode_krb5_ap_req
PROTOTYPE((const krb5_data *output, krb5_ap_req **rep));
-krb5_error_code INTERFACE decode_krb5_ap_rep
+krb5_error_code decode_krb5_ap_rep
PROTOTYPE((const krb5_data *output, krb5_ap_rep **rep));
-krb5_error_code INTERFACE decode_krb5_ap_rep_enc_part
+krb5_error_code decode_krb5_ap_rep_enc_part
PROTOTYPE((const krb5_data *output, krb5_ap_rep_enc_part **rep));
-krb5_error_code INTERFACE decode_krb5_as_req
+krb5_error_code decode_krb5_as_req
PROTOTYPE((const krb5_data *output, krb5_kdc_req **rep));
-krb5_error_code INTERFACE decode_krb5_tgs_req
+krb5_error_code decode_krb5_tgs_req
PROTOTYPE((const krb5_data *output, krb5_kdc_req **rep));
-krb5_error_code INTERFACE decode_krb5_kdc_req_body
+krb5_error_code decode_krb5_kdc_req_body
PROTOTYPE((const krb5_data *output, krb5_kdc_req **rep));
-krb5_error_code INTERFACE decode_krb5_safe
+krb5_error_code decode_krb5_safe
PROTOTYPE((const krb5_data *output, krb5_safe **rep));
-krb5_error_code INTERFACE decode_krb5_priv
+krb5_error_code decode_krb5_priv
PROTOTYPE((const krb5_data *output, krb5_priv **rep));
-krb5_error_code INTERFACE decode_krb5_enc_priv_part
+krb5_error_code decode_krb5_enc_priv_part
PROTOTYPE((const krb5_data *output, krb5_priv_enc_part **rep));
-krb5_error_code INTERFACE decode_krb5_cred
+krb5_error_code decode_krb5_cred
PROTOTYPE((const krb5_data *output, krb5_cred **rep));
-krb5_error_code INTERFACE decode_krb5_enc_cred_part
+krb5_error_code decode_krb5_enc_cred_part
PROTOTYPE((const krb5_data *output, krb5_cred_enc_part **rep));
-krb5_error_code INTERFACE decode_krb5_error
+krb5_error_code decode_krb5_error
PROTOTYPE((const krb5_data *output, krb5_error **rep));
-krb5_error_code INTERFACE decode_krb5_authdata
+krb5_error_code decode_krb5_authdata
PROTOTYPE((const krb5_data *output, krb5_authdata ***rep));
-krb5_error_code INTERFACE decode_krb5_pwd_sequence
+krb5_error_code decode_krb5_pwd_sequence
PROTOTYPE((const krb5_data *output, passwd_phrase_element **rep));
-krb5_error_code INTERFACE decode_krb5_pwd_data
+krb5_error_code decode_krb5_pwd_data
PROTOTYPE((const krb5_data *output, krb5_pwd_data **rep));
/*************************************************************************
/* make const & volatile available without effect */
-#if !defined(__STDC__) && !defined(HAS_ANSI_CONST)
+#if !defined(__STDC__) && !defined(HAS_ANSI_CONST) && !defined(_WINDOWS)
#define const
#endif
-#if !defined(__STDC__) && !defined(HAS_ANSI_VOLATILE)
+#if !defined(__STDC__) && !defined(HAS_ANSI_VOLATILE) && !defined(_WINDOWS)
#define volatile
#endif
-#if defined(__STDC__) || defined(HAS_VOID_TYPE)
+#if defined(__STDC__) || defined(HAS_VOID_TYPE) || defined(_WINDOWS)
typedef void FAR * krb5_pointer;
typedef void const FAR * krb5_const_pointer;
#else
typedef char const FAR * krb5_const_pointer;
#endif
-#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES)
+#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES) || defined(_WINDOWS)
#define PROTOTYPE(x) x
-#if defined(__STDC__) || defined(HAVE_STDARG_H)
+#if defined(__STDC__) || defined(HAVE_STDARG_H) || defined(_WINDOWS)
#define STDARG_P(x) x
#else
#define STDARG_P(x) ()
typedef struct _krb5_ccache {
krb5_magic magic;
- struct _krb5_cc_ops *ops;
+ struct _krb5_cc_ops FAR *ops;
krb5_pointer data;
-} *krb5_ccache;
+} FAR *krb5_ccache;
typedef struct _krb5_cc_ops {
krb5_magic magic;
- char *prefix;
- char *(INTERFACE *get_name) NPROTOTYPE((krb5_context, krb5_ccache));
- krb5_error_code (INTERFACE *resolve) NPROTOTYPE((krb5_context, krb5_ccache *,
- char *));
- krb5_error_code (INTERFACE *gen_new) NPROTOTYPE((krb5_context, krb5_ccache *));
+ char FAR *prefix;
+ char FAR * (INTERFACE *get_name) NPROTOTYPE((krb5_context, krb5_ccache));
+ krb5_error_code (INTERFACE *resolve) NPROTOTYPE((krb5_context, krb5_ccache FAR *,
+ char FAR *));
+ krb5_error_code (INTERFACE *gen_new) NPROTOTYPE((krb5_context, krb5_ccache FAR *));
krb5_error_code (INTERFACE *init) NPROTOTYPE((krb5_context, krb5_ccache,
krb5_principal));
krb5_error_code (INTERFACE *destroy) NPROTOTYPE((krb5_context, krb5_ccache));
krb5_error_code (INTERFACE *close) NPROTOTYPE((krb5_context, krb5_ccache));
krb5_error_code (INTERFACE *store) NPROTOTYPE((krb5_context, krb5_ccache,
- krb5_creds *));
+ krb5_creds FAR *));
krb5_error_code (INTERFACE *retrieve) NPROTOTYPE((krb5_context, krb5_ccache,
- krb5_flags, krb5_creds *,
- krb5_creds *));
+ krb5_flags, krb5_creds FAR *,
+ krb5_creds FAR *));
krb5_error_code (INTERFACE *get_princ) NPROTOTYPE((krb5_context, krb5_ccache,
- krb5_principal *));
+ krb5_principal FAR *));
krb5_error_code (INTERFACE *get_first) NPROTOTYPE((krb5_context, krb5_ccache,
- krb5_cc_cursor *));
+ krb5_cc_cursor FAR *));
krb5_error_code (INTERFACE *get_next) NPROTOTYPE((krb5_context, krb5_ccache,
- krb5_cc_cursor *, krb5_creds *));
+ krb5_cc_cursor FAR *, krb5_creds FAR *));
krb5_error_code (INTERFACE *end_get) NPROTOTYPE((krb5_context, krb5_ccache,
- krb5_cc_cursor *));
+ krb5_cc_cursor FAR *));
krb5_error_code (INTERFACE *remove_cred) NPROTOTYPE((krb5_context, krb5_ccache,
- krb5_flags, krb5_creds *));
+ krb5_flags, krb5_creds FAR *));
krb5_error_code (INTERFACE *set_flags) NPROTOTYPE((krb5_context, krb5_ccache,
krb5_flags));
} krb5_cc_ops;
#define krb5_cc_set_flags(context, cache, flags) (*(cache)->ops->set_flags)(context, cache, flags)
#define krb5_cc_get_name(context, cache) (*(cache)->ops->get_name)(context, cache)
-extern krb5_cc_ops *krb5_cc_dfl_ops;
+extern krb5_cc_ops FAR *krb5_cc_dfl_ops;
#endif /* KRB5_CCACHE__ */
krb5_keytype keytype;
krb5_enctype etype; /* hint of what encryption type to use */
int length;
- krb5_octet *contents;
+ krb5_octet FAR *contents;
} krb5_keyblock;
typedef struct _krb5_checksum {
krb5_magic magic;
krb5_cksumtype checksum_type; /* checksum type */
int length;
- krb5_octet *contents;
+ krb5_octet FAR *contents;
} krb5_checksum;
typedef struct _krb5_encrypt_block {
krb5_magic magic;
- struct _krb5_cryptosystem_entry *crypto_entry;
- krb5_keyblock *key;
+ struct _krb5_cryptosystem_entry FAR *crypto_entry;
+ krb5_keyblock FAR *key;
krb5_pointer priv; /* for private use, e.g. DES
key schedules */
} krb5_encrypt_block;
/* could be used in a table to find an etype and initialize a block */
typedef struct _krb5_cryptosystem_entry {
krb5_magic magic;
- krb5_error_code (INTERFACE *encrypt_func) NPROTOTYPE(( krb5_const_pointer /* in */,
+ krb5_error_code (*encrypt_func) NPROTOTYPE(( krb5_const_pointer /* in */,
krb5_pointer /* out */,
const size_t,
- krb5_encrypt_block *,
+ krb5_encrypt_block FAR *,
krb5_pointer));
- krb5_error_code (INTERFACE *decrypt_func) NPROTOTYPE(( krb5_const_pointer /* in */,
+ krb5_error_code (*decrypt_func) NPROTOTYPE(( krb5_const_pointer /* in */,
krb5_pointer /* out */,
const size_t,
- krb5_encrypt_block *,
+ krb5_encrypt_block FAR *,
krb5_pointer));
- krb5_error_code (INTERFACE *process_key) NPROTOTYPE(( krb5_encrypt_block *,
- const krb5_keyblock *));
- krb5_error_code (INTERFACE *finish_key) NPROTOTYPE(( krb5_encrypt_block *));
- krb5_error_code (INTERFACE *string_to_key) NPROTOTYPE(( const krb5_encrypt_block *,
+ krb5_error_code (*process_key) NPROTOTYPE(( krb5_encrypt_block FAR *,
+ const krb5_keyblock FAR *));
+ krb5_error_code (*finish_key) NPROTOTYPE(( krb5_encrypt_block FAR *));
+ krb5_error_code (*string_to_key) NPROTOTYPE((const krb5_encrypt_block FAR *,
const krb5_keytype,
- krb5_keyblock *,
- const krb5_data *,
- const krb5_data *));
- krb5_error_code (INTERFACE *init_random_key) NPROTOTYPE(( const krb5_keyblock *,
- krb5_pointer *));
- krb5_error_code (INTERFACE *finish_random_key) NPROTOTYPE(( krb5_pointer *));
- krb5_error_code (INTERFACE *random_key) NPROTOTYPE(( const krb5_encrypt_block *,
+ krb5_keyblock FAR *,
+ const krb5_data FAR *,
+ const krb5_data FAR *));
+ krb5_error_code (*init_random_key) NPROTOTYPE((const krb5_keyblock FAR *,
+ krb5_pointer FAR *));
+ krb5_error_code (*finish_random_key) NPROTOTYPE(( krb5_pointer FAR *));
+ krb5_error_code (*random_key) NPROTOTYPE(( const krb5_encrypt_block FAR *,
krb5_pointer,
- krb5_keyblock **));
+ krb5_keyblock FAR * FAR *));
int block_length;
int pad_minimum; /* needed for cksum size computation */
int keysize;
typedef struct _krb5_cs_table_entry {
krb5_magic magic;
- krb5_cryptosystem_entry *system;
+ krb5_cryptosystem_entry FAR *system;
krb5_pointer random_sequence; /* from init_random_key() */
} krb5_cs_table_entry;
/* could be used in a table to find a sumtype */
-typedef krb5_error_code (INTERFACE *SUM_FUNC) NPROTOTYPE (
+typedef krb5_error_code (*SUM_FUNC) NPROTOTYPE (
(krb5_pointer /* in */,
size_t /* in_length */,
krb5_pointer /* key/seed */,
#ifdef HAS_STDLIB_H
#include <stdlib.h>
#else
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
#ifdef NO_STDLIB_H
#include <fake-stdlib.h>
#else
krb5_error_code INTERFACE krb5_init_context
PROTOTYPE((krb5_context FAR *));
-void INTERFACE krb5_free_context
+void krb5_free_context
PROTOTYPE((krb5_context));
-krb5_error_code INTERFACE krb5_set_default_in_tkt_etypes
+krb5_error_code krb5_set_default_in_tkt_etypes
PROTOTYPE((krb5_context,
const krb5_enctype *));
-krb5_error_code INTERFACE krb5_get_default_in_tkt_etypes
+krb5_error_code krb5_get_default_in_tkt_etypes
PROTOTYPE((krb5_context,
krb5_enctype **));
extern krb5_context global_context;
/* libkrb.spec */
-krb5_error_code INTERFACE krb5_kdc_rep_decrypt_proc
+krb5_error_code krb5_kdc_rep_decrypt_proc
PROTOTYPE((krb5_context,
const krb5_keyblock *,
krb5_const_pointer,
krb5_kdc_rep * ));
-krb5_error_code INTERFACE krb5_encode_ticket
+krb5_error_code krb5_encode_ticket
PROTOTYPE((krb5_context,
const krb5_ticket *,
krb5_data ** ));
-krb5_error_code INTERFACE krb5_encrypt_tkt_part
+krb5_error_code krb5_encrypt_tkt_part
PROTOTYPE((krb5_context,
krb5_encrypt_block *,
const krb5_keyblock *,
krb5_ticket * ));
-krb5_error_code INTERFACE krb5_decrypt_tkt_part
+krb5_error_code krb5_decrypt_tkt_part
PROTOTYPE((krb5_context,
const krb5_keyblock *,
krb5_ticket * ));
-krb5_error_code INTERFACE krb5_get_cred_from_kdc
+krb5_error_code krb5_get_cred_from_kdc
PROTOTYPE((krb5_context,
krb5_ccache, /* not const, as reading may save
state */
krb5_creds *,
krb5_creds **,
krb5_creds *** ));
-void INTERFACE krb5_free_tgt_creds
+void krb5_free_tgt_creds
PROTOTYPE((krb5_context,
krb5_creds ** )); /* XXX too hard to do with const */
krb5_ccache,
krb5_creds FAR *,
krb5_creds FAR * FAR *));
-krb5_error_code INTERFACE krb5_get_for_creds
+krb5_error_code krb5_get_for_creds
PROTOTYPE((krb5_context,
const krb5_cksumtype,
char *,
krb5_keyblock *,
int,
krb5_data * ));
-krb5_error_code INTERFACE krb5_mk_req
+krb5_error_code krb5_mk_req
PROTOTYPE((krb5_context,
krb5_auth_context **,
const krb5_flags,
krb5_data FAR *,
krb5_creds FAR *,
krb5_data FAR * ));
-krb5_error_code INTERFACE krb5_mk_rep
+krb5_error_code krb5_mk_rep
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_data *));
krb5_auth_context FAR *,
const krb5_data FAR *,
krb5_ap_rep_enc_part FAR * FAR *));
-krb5_error_code INTERFACE krb5_mk_error
+krb5_error_code krb5_mk_error
PROTOTYPE((krb5_context,
const krb5_error *,
krb5_data * ));
-krb5_error_code INTERFACE krb5_rd_error
+krb5_error_code krb5_rd_error
PROTOTYPE((krb5_context,
const krb5_data *,
krb5_error ** ));
-krb5_error_code INTERFACE krb5_rd_safe
+krb5_error_code krb5_rd_safe
PROTOTYPE((krb5_context,
krb5_auth_context *,
const krb5_data *,
krb5_data *,
krb5_replay_data *));
-krb5_error_code INTERFACE krb5_rd_priv
+krb5_error_code krb5_rd_priv
PROTOTYPE((krb5_context,
krb5_auth_context *,
const krb5_data *,
PROTOTYPE((krb5_context,
krb5_const_principal,
char FAR * FAR * ));
-krb5_error_code INTERFACE krb5_unparse_name_ext
+krb5_error_code krb5_unparse_name_ext
PROTOTYPE((krb5_context,
krb5_const_principal,
char **,
int *));
-krb5_boolean INTERFACE krb5_address_search
+krb5_boolean krb5_address_search
PROTOTYPE((krb5_context,
const krb5_address *,
krb5_address * const *));
-krb5_boolean INTERFACE krb5_address_compare
+krb5_boolean krb5_address_compare
PROTOTYPE((krb5_context,
const krb5_address *,
const krb5_address *));
-int INTERFACE krb5_address_order
+int krb5_address_order
PROTOTYPE((krb5_context,
const krb5_address *,
const krb5_address *));
-krb5_boolean INTERFACE krb5_realm_compare
+krb5_boolean krb5_realm_compare
PROTOTYPE((krb5_context,
krb5_const_principal,
krb5_const_principal));
-krb5_boolean INTERFACE krb5_principal_compare
+krb5_boolean krb5_principal_compare
PROTOTYPE((krb5_context,
krb5_const_principal,
krb5_const_principal));
-int INTERFACE krb5_fulladdr_order
+int krb5_fulladdr_order
PROTOTYPE((krb5_context,
const krb5_fulladdr *,
const krb5_fulladdr *));
-krb5_error_code INTERFACE krb5_copy_keyblock
+krb5_error_code krb5_copy_keyblock
PROTOTYPE((krb5_context,
const krb5_keyblock *,
krb5_keyblock **));
-krb5_error_code INTERFACE krb5_copy_keyblock_contents
+krb5_error_code krb5_copy_keyblock_contents
PROTOTYPE((krb5_context,
const krb5_keyblock *,
krb5_keyblock *));
-krb5_error_code INTERFACE krb5_copy_creds
+krb5_error_code krb5_copy_creds
PROTOTYPE((krb5_context,
const krb5_creds *,
krb5_creds **));
-krb5_error_code INTERFACE krb5_copy_data
+krb5_error_code krb5_copy_data
PROTOTYPE((krb5_context,
const krb5_data *,
krb5_data **));
-krb5_error_code INTERFACE krb5_copy_principal
+krb5_error_code krb5_copy_principal
PROTOTYPE((krb5_context,
krb5_const_principal,
krb5_principal *));
-krb5_error_code INTERFACE krb5_copy_addresses
+krb5_error_code krb5_copy_addresses
PROTOTYPE((krb5_context,
krb5_address * const *,
krb5_address ***));
-krb5_error_code INTERFACE krb5_copy_ticket
+krb5_error_code krb5_copy_ticket
PROTOTYPE((krb5_context,
const krb5_ticket *, krb5_ticket **));
-krb5_error_code INTERFACE krb5_copy_authdata
+krb5_error_code krb5_copy_authdata
PROTOTYPE((krb5_context,
krb5_authdata * const *,
krb5_authdata ***));
-krb5_error_code INTERFACE krb5_copy_authenticator
+krb5_error_code krb5_copy_authenticator
PROTOTYPE((krb5_context,
const krb5_authenticator *,
krb5_authenticator **));
-krb5_error_code INTERFACE krb5_copy_checksum
+krb5_error_code krb5_copy_checksum
PROTOTYPE((krb5_context,
const krb5_checksum *,
krb5_checksum **));
void INTERFACE krb5_init_ets PROTOTYPE((krb5_context));
-krb5_error_code INTERFACE krb5_generate_subkey
+krb5_error_code krb5_generate_subkey
PROTOTYPE((krb5_context,
const krb5_keyblock *, krb5_keyblock **));
-krb5_error_code INTERFACE krb5_generate_seq_number
+krb5_error_code krb5_generate_seq_number
PROTOTYPE((krb5_context,
const krb5_keyblock *, krb5_int32 *));
-krb5_error_code INTERFACE krb5_get_server_rcache
+krb5_error_code krb5_get_server_rcache
PROTOTYPE((krb5_context,
const krb5_data *, krb5_rcache *));
krb5_error_code INTERFACE_C krb5_build_principal_ext
STDARG_P((krb5_context, krb5_principal FAR *, int, const char FAR *, ...));
-krb5_error_code INTERFACE_C krb5_build_principal
+krb5_error_code krb5_build_principal
STDARG_P((krb5_context, krb5_principal *, int, const char *, ...));
#ifdef va_start
/* XXX depending on varargs include file defining va_start... */
-krb5_error_code INTERFACE_C krb5_build_principal_va
+krb5_error_code krb5_build_principal_va
PROTOTYPE((krb5_context,
krb5_principal *, int, const char *, va_list));
#endif
-krb5_error_code INTERFACE krb5_425_conv_principal
+krb5_error_code krb5_425_conv_principal
PROTOTYPE((krb5_context,
const char *name, const char *instance, const char *realm,
krb5_principal *princ));
-krb5_error_code INTERFACE krb5_obtain_padata
+krb5_error_code krb5_obtain_padata
PROTOTYPE((krb5_context,
int type, krb5_principal client, krb5_address **src_addr,
krb5_keyblock *encrypt_key, krb5_pa_data **data));
-krb5_error_code INTERFACE krb5_verify_padata
+krb5_error_code krb5_verify_padata
PROTOTYPE((krb5_context,
krb5_pa_data * data, krb5_principal client,
krb5_address **src_addr, krb5_keyblock *decrypt_key,
int *req_id, int *flags));
/* libkt.spec */
-krb5_error_code INTERFACE krb5_kt_register
+krb5_error_code krb5_kt_register
PROTOTYPE((krb5_context,
krb5_kt_ops * ));
-krb5_error_code INTERFACE krb5_kt_resolve
+krb5_error_code krb5_kt_resolve
PROTOTYPE((krb5_context,
const char *,
krb5_keytab * ));
-krb5_error_code INTERFACE krb5_kt_default_name
+krb5_error_code krb5_kt_default_name
PROTOTYPE((krb5_context,
char *,
int ));
-krb5_error_code INTERFACE krb5_kt_default
+krb5_error_code krb5_kt_default
PROTOTYPE((krb5_context,
krb5_keytab * ));
-krb5_error_code INTERFACE krb5_kt_free_entry
+krb5_error_code krb5_kt_free_entry
PROTOTYPE((krb5_context,
krb5_keytab_entry * ));
/* remove and add are functions, so that they can return NOWRITE
if not a writable keytab */
-krb5_error_code INTERFACE krb5_kt_remove_entry
+krb5_error_code krb5_kt_remove_entry
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_keytab_entry * ));
-krb5_error_code INTERFACE krb5_kt_add_entry
+krb5_error_code krb5_kt_add_entry
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_keytab_entry * ));
-krb5_error_code INTERFACE krb5_principal2salt
+krb5_error_code krb5_principal2salt
PROTOTYPE((krb5_context,
krb5_const_principal, krb5_data *));
-krb5_error_code INTERFACE krb5_principal2salt_norealm
+krb5_error_code krb5_principal2salt_norealm
PROTOTYPE((krb5_context,
krb5_const_principal, krb5_data *));
/* librc.spec--see rcache.h */
/* libcc.spec */
-krb5_error_code INTERFACE krb5_cc_resolve
+krb5_error_code krb5_cc_resolve
PROTOTYPE((krb5_context,
char *,
krb5_ccache * ));
-krb5_error_code INTERFACE krb5_cc_generate_new
+krb5_error_code krb5_cc_generate_new
PROTOTYPE((krb5_context,
krb5_cc_ops *,
krb5_ccache * ));
-char * INTERFACE krb5_cc_default_name
+char * krb5_cc_default_name
PROTOTYPE((krb5_context));
krb5_error_code INTERFACE krb5_cc_default
PROTOTYPE((krb5_context,
PROTOTYPE((void));
/* chk_trans.c */
-krb5_error_code INTERFACE krb5_check_transited_list
+krb5_error_code krb5_check_transited_list
PROTOTYPE((krb5_context,
krb5_data *trans, krb5_data *realm1, krb5_data *realm2));
/* free_rtree.c */
-void INTERFACE krb5_free_realm_tree
+void krb5_free_realm_tree
PROTOTYPE((krb5_context,
krb5_principal *));
void INTERFACE krb5_free_principal
PROTOTYPE((krb5_context,
krb5_principal ));
-void INTERFACE krb5_free_authenticator
+void krb5_free_authenticator
PROTOTYPE((krb5_context,
krb5_authenticator * ));
-void INTERFACE krb5_free_authenticator_contents
+void krb5_free_authenticator_contents
PROTOTYPE((krb5_context,
krb5_authenticator * ));
void INTERFACE krb5_free_addresses
PROTOTYPE((krb5_context,
krb5_address FAR * FAR * ));
-void INTERFACE krb5_free_address
+void krb5_free_address
PROTOTYPE((krb5_context,
krb5_address * ));
-void INTERFACE krb5_free_authdata
+void krb5_free_authdata
PROTOTYPE((krb5_context,
krb5_authdata ** ));
-void INTERFACE krb5_free_enc_tkt_part
+void krb5_free_enc_tkt_part
PROTOTYPE((krb5_context,
krb5_enc_tkt_part * ));
-void INTERFACE krb5_free_ticket
+void krb5_free_ticket
PROTOTYPE((krb5_context,
krb5_ticket * ));
-void INTERFACE krb5_free_tickets
+void krb5_free_tickets
PROTOTYPE((krb5_context,
krb5_ticket ** ));
-void INTERFACE krb5_free_kdc_req
+void krb5_free_kdc_req
PROTOTYPE((krb5_context,
krb5_kdc_req * ));
-void INTERFACE krb5_free_kdc_rep
+void krb5_free_kdc_rep
PROTOTYPE((krb5_context,
krb5_kdc_rep * ));
-void INTERFACE krb5_free_last_req
+void krb5_free_last_req
PROTOTYPE((krb5_context,
krb5_last_req_entry ** ));
-void INTERFACE krb5_free_enc_kdc_rep_part
+void krb5_free_enc_kdc_rep_part
PROTOTYPE((krb5_context,
krb5_enc_kdc_rep_part * ));
-void INTERFACE krb5_free_error
+void krb5_free_error
PROTOTYPE((krb5_context,
krb5_error * ));
-void INTERFACE krb5_free_ap_req
+void krb5_free_ap_req
PROTOTYPE((krb5_context,
krb5_ap_req * ));
-void INTERFACE krb5_free_ap_rep
+void krb5_free_ap_rep
PROTOTYPE((krb5_context,
krb5_ap_rep * ));
-void INTERFACE krb5_free_safe
+void krb5_free_safe
PROTOTYPE((krb5_context,
krb5_safe * ));
-void INTERFACE krb5_free_priv
+void krb5_free_priv
PROTOTYPE((krb5_context,
krb5_priv * ));
-void INTERFACE krb5_free_priv_enc_part
+void krb5_free_priv_enc_part
PROTOTYPE((krb5_context,
krb5_priv_enc_part * ));
-void INTERFACE krb5_free_kdc_req
+void krb5_free_kdc_req
PROTOTYPE((krb5_context,
krb5_kdc_req * ));
-void INTERFACE krb5_free_cred
+void krb5_free_cred
PROTOTYPE((krb5_context,
krb5_cred *));
void INTERFACE krb5_free_creds
void INTERFACE krb5_free_cred_contents
PROTOTYPE((krb5_context,
krb5_creds FAR *));
-void INTERFACE krb5_free_cred_enc_part
+void krb5_free_cred_enc_part
PROTOTYPE((krb5_context,
krb5_cred_enc_part *));
-void INTERFACE krb5_free_checksum
+void krb5_free_checksum
PROTOTYPE((krb5_context,
krb5_checksum *));
-void INTERFACE krb5_free_keyblock
+void krb5_free_keyblock
PROTOTYPE((krb5_context,
krb5_keyblock *));
-void INTERFACE krb5_free_pa_data
+void krb5_free_pa_data
PROTOTYPE((krb5_context,
krb5_pa_data **));
void INTERFACE krb5_free_ap_rep_enc_part
PROTOTYPE((krb5_context,
krb5_ap_rep_enc_part FAR *));
-void INTERFACE krb5_free_tkt_authent
+void krb5_free_tkt_authent
PROTOTYPE((krb5_context,
krb5_tkt_authent *));
-void INTERFACE krb5_free_pwd_data
+void krb5_free_pwd_data
PROTOTYPE((krb5_context,
krb5_pwd_data *));
-void INTERFACE krb5_free_pwd_sequences
+void krb5_free_pwd_sequences
PROTOTYPE((krb5_context,
passwd_phrase_element **));
/* Only put things which don't have pointers to the narrow types in this
section */
-krb5_error_code INTERFACE krb5_encode_kdc_rep
+krb5_error_code krb5_encode_kdc_rep
PROTOTYPE((krb5_context,
const krb5_msgtype,
const krb5_enc_kdc_rep_part *,
krb5_kdc_rep *,
krb5_data ** ));
-krb5_error_code INTERFACE krb5_send_tgs
+krb5_error_code krb5_send_tgs
PROTOTYPE((krb5_context,
const krb5_flags,
const krb5_ticket_times *,
krb5_creds *,
krb5_response * ));
-krb5_error_code INTERFACE krb5_get_in_tkt
+krb5_error_code krb5_get_in_tkt
PROTOTYPE((krb5_context,
const krb5_flags,
krb5_address * const *,
krb5_enctype *,
krb5_preauthtype *,
- krb5_error_code (INTERFACE * )(krb5_context,
+ krb5_error_code ( * )(krb5_context,
const krb5_keytype,
krb5_data *,
krb5_const_pointer,
krb5_keyblock **),
krb5_const_pointer,
- krb5_error_code (INTERFACE * )(krb5_context,
+ krb5_error_code ( * )(krb5_context,
const krb5_keyblock *,
krb5_const_pointer,
krb5_kdc_rep * ),
krb5_creds FAR *,
krb5_kdc_rep FAR * FAR * ));
-krb5_error_code INTERFACE krb5_get_in_tkt_with_skey
+krb5_error_code krb5_get_in_tkt_with_skey
PROTOTYPE((krb5_context,
const krb5_flags,
krb5_address * const *,
krb5_creds *,
krb5_kdc_rep ** ));
-krb5_error_code INTERFACE krb5_get_in_tkt_with_keytab
+krb5_error_code krb5_get_in_tkt_with_keytab
PROTOTYPE((krb5_context,
const krb5_flags,
krb5_address * const *,
krb5_kdc_rep ** ));
-krb5_error_code INTERFACE krb5_decode_kdc_rep
+krb5_error_code krb5_decode_kdc_rep
PROTOTYPE((krb5_context,
krb5_data *,
const krb5_keyblock *,
const krb5_enctype,
krb5_kdc_rep ** ));
-krb5_error_code INTERFACE krb5_rd_req
+krb5_error_code krb5_rd_req
PROTOTYPE((krb5_context,
krb5_auth_context **,
const krb5_data *,
krb5_flags *,
krb5_ticket **));
-krb5_error_code INTERFACE krb5_rd_req_decoded
+krb5_error_code krb5_rd_req_decoded
PROTOTYPE((krb5_context,
krb5_auth_context **,
const krb5_ap_req *,
krb5_flags *,
krb5_ticket **));
-krb5_error_code INTERFACE krb5_kt_read_service_key
+krb5_error_code krb5_kt_read_service_key
PROTOTYPE((krb5_context,
krb5_pointer,
krb5_principal,
krb5_kvno,
krb5_keytype,
krb5_keyblock **));
-krb5_error_code INTERFACE krb5_mk_safe
+krb5_error_code krb5_mk_safe
PROTOTYPE((krb5_context,
krb5_auth_context *,
const krb5_data *,
krb5_data *,
krb5_replay_data *));
-krb5_error_code INTERFACE krb5_mk_priv
+krb5_error_code krb5_mk_priv
PROTOTYPE((krb5_context,
krb5_auth_context *,
const krb5_data *,
krb5_data *,
krb5_replay_data *));
-krb5_error_code INTERFACE krb5_cc_register
+krb5_error_code krb5_cc_register
PROTOTYPE((krb5_context,
krb5_cc_ops *,
krb5_boolean ));
-krb5_error_code INTERFACE krb5_sendauth
+krb5_error_code krb5_sendauth
PROTOTYPE((krb5_context,
krb5_auth_context **,
krb5_pointer,
krb5_ap_rep_enc_part **,
krb5_creds **));
-krb5_error_code INTERFACE krb5_recvauth PROTOTYPE((krb5_context,
+krb5_error_code krb5_recvauth PROTOTYPE((krb5_context,
krb5_auth_context **,
krb5_pointer,
char *,
krb5_keytab,
krb5_ticket **));
-krb5_error_code INTERFACE krb5_walk_realm_tree
+krb5_error_code krb5_walk_realm_tree
PROTOTYPE((krb5_context,
const krb5_data *,
const krb5_data *,
krb5_principal **,
int));
-krb5_error_code INTERFACE krb5_mk_cred
+krb5_error_code krb5_mk_cred
PROTOTYPE((krb5_context,
krb5_kdc_rep *,
krb5_enctype,
krb5_address *,
krb5_data *));
-krb5_error_code INTERFACE krb5_auth_con_init
+krb5_error_code krb5_auth_con_init
PROTOTYPE((krb5_context,
krb5_auth_context **));
-krb5_error_code INTERFACE krb5_auth_con_free
+krb5_error_code krb5_auth_con_free
PROTOTYPE((krb5_context,
krb5_auth_context *));
-krb5_error_code INTERFACE krb5_auth_con_setflags
+krb5_error_code krb5_auth_con_setflags
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_int32));
-krb5_error_code INTERFACE krb5_auth_con_getflags
+krb5_error_code krb5_auth_con_getflags
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_int32 *));
-krb5_error_code INTERFACE krb5_auth_con_setaddrs
+krb5_error_code krb5_auth_con_setaddrs
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_address *,
krb5_address *));
-krb5_error_code INTERFACE krb5_auth_con_getaddrs
+krb5_error_code krb5_auth_con_getaddrs
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_address **,
krb5_address **));
-krb5_error_code INTERFACE krb5_auth_con_setuseruserkey
+krb5_error_code krb5_auth_con_setuseruserkey
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_keyblock *));
-krb5_error_code INTERFACE krb5_auth_con_getlocalsubkey
+krb5_error_code krb5_auth_con_getlocalsubkey
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_keyblock **));
-krb5_error_code INTERFACE krb5_auth_con_setcksumtype
+krb5_error_code krb5_auth_con_setcksumtype
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_cksumtype));
-krb5_error_code INTERFACE krb5_auth_con_getcksumtype
+krb5_error_code krb5_auth_con_getcksumtype
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_cksumtype *));
-krb5_error_code INTERFACE krb5_auth_con_getlocalseqnumber
+krb5_error_code krb5_auth_con_getlocalseqnumber
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_int32 *));
-krb5_error_code INTERFACE krb5_auth_con_getremoteseqnumber
+krb5_error_code krb5_auth_con_getremoteseqnumber
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_int32 *));
-krb5_error_code INTERFACE krb5_auth_con_setivector
+krb5_error_code krb5_auth_con_setivector
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_pointer));
-krb5_error_code INTERFACE krb5_auth_con_getivector
+krb5_error_code krb5_auth_con_getivector
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_pointer *));
-krb5_error_code INTERFACE krb5_auth_con_setrcache
+krb5_error_code krb5_auth_con_setrcache
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_rcache));
-krb5_error_code INTERFACE krb5_auth_con_getrcache
+krb5_error_code krb5_auth_con_getrcache
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_rcache *));
-krb5_error_code INTERFACE krb5_auth_con_getauthenticator
+krb5_error_code krb5_auth_con_getauthenticator
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_authenticator **));
-krb5_error_code INTERFACE krb5_auth_con_getremotesubkey
+krb5_error_code krb5_auth_con_getremotesubkey
PROTOTYPE((krb5_context,
krb5_auth_context *,
krb5_keyblock **));
krb5_magic magic;
krb5_addrtype addrtype;
int length;
- krb5_octet *contents;
+ krb5_octet FAR *contents;
} krb5_address;
/* per Kerberos v5 protocol spec */
/* implementation-specific stuff: */
typedef struct _krb5_fulladdr {
- krb5_address *address;
+ krb5_address FAR *address;
unsigned long port; /* port, for some address types.
large enough for most protos? */
} krb5_fulladdr;
#define KRB5_FREE__
/* to keep lint happy */
-#define krb5_xfree(val) free((char *)(val))
+#define krb5_xfree(val) free((char FAR *)(val))
#define krb5_free_data(context, val) { krb5_xfree((val)->data); krb5_xfree(val);}
typedef struct _krb5_kt {
krb5_magic magic;
- struct _krb5_kt_ops *ops;
+ struct _krb5_kt_ops FAR *ops;
krb5_pointer data;
-} *krb5_keytab;
+} FAR *krb5_keytab;
typedef struct _krb5_kt_ops {
krb5_magic magic;
- char *prefix;
+ char FAR *prefix;
/* routines always present */
- krb5_error_code (INTERFACE *resolve)
+ krb5_error_code (*resolve)
NPROTOTYPE((krb5_context,
- const char *,
- krb5_keytab *));
- krb5_error_code (INTERFACE *get_name)
+ const char FAR *,
+ krb5_keytab FAR *));
+ krb5_error_code (*get_name)
NPROTOTYPE((krb5_context,
krb5_keytab,
- char *,
+ char FAR *,
int));
- krb5_error_code (INTERFACE *close)
+ krb5_error_code (*close)
NPROTOTYPE((krb5_context,
krb5_keytab));
- krb5_error_code (INTERFACE *get)
+ krb5_error_code (*get)
NPROTOTYPE((krb5_context,
krb5_keytab,
krb5_principal,
krb5_kvno,
krb5_keytype,
- krb5_keytab_entry *));
- krb5_error_code (INTERFACE *start_seq_get)
+ krb5_keytab_entry FAR *));
+ krb5_error_code (*start_seq_get)
NPROTOTYPE((krb5_context,
krb5_keytab,
- krb5_kt_cursor *));
- krb5_error_code (INTERFACE *get_next)
+ krb5_kt_cursor FAR *));
+ krb5_error_code (*get_next)
NPROTOTYPE((krb5_context,
krb5_keytab,
- krb5_keytab_entry *,
- krb5_kt_cursor *));
- krb5_error_code (INTERFACE *end_get)
+ krb5_keytab_entry FAR *,
+ krb5_kt_cursor FAR *));
+ krb5_error_code (*end_get)
NPROTOTYPE((krb5_context,
krb5_keytab,
- krb5_kt_cursor *));
+ krb5_kt_cursor FAR *));
/* routines to be included on extended version (write routines) */
- krb5_error_code (INTERFACE *add)
+ krb5_error_code (*add)
NPROTOTYPE((krb5_context,
krb5_keytab,
- krb5_keytab_entry *));
- krb5_error_code (INTERFACE *remove)
+ krb5_keytab_entry FAR *));
+ krb5_error_code (*remove)
NPROTOTYPE((krb5_context,
krb5_keytab,
- krb5_keytab_entry *));
+ krb5_keytab_entry FAR *));
} krb5_kt_ops;
#define krb5_kt_get_name(context, keytab, name, namelen) (*(keytab)->ops->get_name)(context, keytab,name,namelen)
#include <stdio.h>
-krb5_error_code INTERFACE krb5_init_os_context
+krb5_error_code krb5_init_os_context
PROTOTYPE((krb5_context));
-void INTERFACE krb5_free_os_context
+void krb5_free_os_context
PROTOTYPE((krb5_context));
/* libos.spec */
-krb5_error_code INTERFACE krb5_read_password
+krb5_error_code krb5_read_password
PROTOTYPE((krb5_context,
char *,
char *,
char *,
int * ));
-krb5_error_code INTERFACE krb5_lock_file
+krb5_error_code krb5_lock_file
PROTOTYPE((krb5_context,
FILE *,
char *,
int ));
-krb5_error_code INTERFACE krb5_unlock_file
+krb5_error_code krb5_unlock_file
PROTOTYPE((krb5_context,
FILE *,
char * ));
-int INTERFACE krb5_net_read
+int krb5_net_read
PROTOTYPE((krb5_context,
int ,
char *,
int ));
-int INTERFACE krb5_net_write
+int krb5_net_write
PROTOTYPE((krb5_context,
int ,
const char *,
int ));
-krb5_error_code INTERFACE krb5_sendto_kdc
+krb5_error_code krb5_sendto_kdc
PROTOTYPE((krb5_context,
const krb5_data *,
const krb5_data *,
krb5_data * ));
-krb5_error_code INTERFACE krb5_get_krbhst
+krb5_error_code krb5_get_krbhst
PROTOTYPE((krb5_context,
const krb5_data *,
char *** ));
-krb5_error_code INTERFACE krb5_free_krbhst
+krb5_error_code krb5_free_krbhst
PROTOTYPE((krb5_context,
char * const * ));
-krb5_error_code INTERFACE krb5_aname_to_localname
+krb5_error_code krb5_aname_to_localname
PROTOTYPE((krb5_context,
krb5_const_principal,
const int,
char * ));
-krb5_error_code INTERFACE krb5_get_host_realm
+krb5_error_code krb5_get_host_realm
PROTOTYPE((krb5_context,
const char *,
char *** ));
-krb5_error_code INTERFACE krb5_free_host_realm
+krb5_error_code krb5_free_host_realm
PROTOTYPE((krb5_context,
char * const * ));
-krb5_error_code INTERFACE krb5_get_realm_domain
+krb5_error_code krb5_get_realm_domain
PROTOTYPE((krb5_context,
const char *,
char ** ));
-krb5_boolean INTERFACE krb5_kuserok
+krb5_boolean krb5_kuserok
PROTOTYPE((krb5_context,
krb5_principal, const char *));
-krb5_error_code INTERFACE krb5_random_confounder
+krb5_error_code krb5_random_confounder
PROTOTYPE((int,
krb5_pointer ));
-krb5_error_code INTERFACE krb5_gen_replay_name
+krb5_error_code krb5_gen_replay_name
PROTOTYPE((krb5_context,
const krb5_address *,
const char *,
char **));
-krb5_error_code INTERFACE krb5_gen_portaddr
+krb5_error_code krb5_gen_portaddr
PROTOTYPE((krb5_context,
const krb5_address *,
krb5_const_pointer,
krb5_address **));
-krb5_error_code INTERFACE krb5_create_secure_file
+krb5_error_code krb5_create_secure_file
PROTOTYPE((krb5_context,
const char * pathname));
-krb5_error_code INTERFACE krb5_sync_disk_file
+krb5_error_code krb5_sync_disk_file
PROTOTYPE((krb5_context,
FILE *fp));
-krb5_error_code INTERFACE krb5_read_message
+krb5_error_code krb5_read_message
PROTOTYPE((krb5_context,
krb5_pointer,
krb5_data *));
-krb5_error_code INTERFACE krb5_write_message
+krb5_error_code krb5_write_message
PROTOTYPE((krb5_context,
krb5_pointer,
krb5_data *));
-krb5_error_code INTERFACE krb5_os_init_context
+krb5_error_code krb5_os_init_context
PROTOTYPE((krb5_context));
-void INTERFACE krb5_os_free_context
+void krb5_os_free_context
PROTOTYPE((krb5_context));
krb5_error_code krb5_find_config_files
#ifndef KRB5_MACROS__
#define KRB5_MACROS__
-#define krb5_princ_aref(princ, n, plen) (char *)(*plen = princ[n]->length, princ[n]->data)
+#define krb5_princ_aref(princ, n, plen) (char FAR *)(*plen = princ[n]->length, princ[n]->data)
#endif /* KRB5_MACROS__ */
/*
* Note: these typedefs are subject to change.... [tytso:19920903.1609EDT]
*/
-typedef krb5_error_code (INTERFACE krb5_preauth_obtain_proc)
+typedef krb5_error_code (krb5_preauth_obtain_proc)
PROTOTYPE((krb5_context, krb5_principal client, krb5_address **src_addr,
krb5_pa_data *pa_data));
-typedef krb5_error_code (INTERFACE krb5_preauth_verify_proc)
+typedef krb5_error_code (krb5_preauth_verify_proc)
PROTOTYPE((krb5_context, krb5_principal client, krb5_address **src_addr,
krb5_data *data));
krb5_data *data));
#endif
-krb5_error_code INTERFACE get_unixtime_padata
+krb5_error_code get_unixtime_padata
PROTOTYPE((krb5_context, krb5_principal client,
krb5_address **src_addr, krb5_pa_data *data));
-krb5_error_code INTERFACE verify_unixtime_padata
+krb5_error_code verify_unixtime_padata
PROTOTYPE((krb5_context, krb5_principal client, krb5_address **src_addr,
krb5_data *data));
-krb5_error_code INTERFACE get_securid_padata
+krb5_error_code get_securid_padata
PROTOTYPE((krb5_context, krb5_principal client, krb5_address **src_addr,
krb5_pa_data *data));
-krb5_error_code INTERFACE verify_securid_padata
+krb5_error_code verify_securid_padata
PROTOTYPE((krb5_context, krb5_principal client, krb5_address **src_addr,
krb5_data *data));
typedef struct krb5_rc_st {
krb5_magic magic;
- struct _krb5_rc_ops *ops;
+ struct _krb5_rc_ops FAR *ops;
krb5_pointer data;
-} *krb5_rcache;
+} FAR *krb5_rcache;
typedef struct _krb5_donot_replay {
krb5_magic magic;
- char *server; /* null-terminated */
- char *client; /* null-terminated */
+ char FAR *server; /* null-terminated */
+ char FAR *client; /* null-terminated */
krb5_int32 cusec;
krb5_timestamp ctime;
} krb5_donot_replay;
typedef struct _krb5_rc_ops {
krb5_magic magic;
- char *type;
- krb5_error_code (INTERFACE *init)NPROTOTYPE((krb5_context, krb5_rcache,krb5_deltat)); /* create */
- krb5_error_code (INTERFACE *recover)NPROTOTYPE((krb5_context, krb5_rcache)); /* open */
- krb5_error_code (INTERFACE *destroy)NPROTOTYPE((krb5_context, krb5_rcache));
- krb5_error_code (INTERFACE *close)NPROTOTYPE((krb5_context, krb5_rcache));
- krb5_error_code (INTERFACE *store)NPROTOTYPE((krb5_context, krb5_rcache,krb5_donot_replay *));
- krb5_error_code (INTERFACE *expunge)NPROTOTYPE((krb5_context, krb5_rcache));
- krb5_error_code (INTERFACE *get_span)NPROTOTYPE((krb5_context, krb5_rcache,krb5_deltat *));
- char *(INTERFACE *get_name)NPROTOTYPE((krb5_context, krb5_rcache));
- krb5_error_code (INTERFACE *resolve)NPROTOTYPE((krb5_context, krb5_rcache, char *));
+ char FAR *type;
+ krb5_error_code (*init)NPROTOTYPE((krb5_context, krb5_rcache,krb5_deltat)); /* create */
+ krb5_error_code (*recover)NPROTOTYPE((krb5_context, krb5_rcache)); /* open */
+ krb5_error_code (*destroy)NPROTOTYPE((krb5_context, krb5_rcache));
+ krb5_error_code (*close)NPROTOTYPE((krb5_context, krb5_rcache));
+ krb5_error_code (*store)NPROTOTYPE((krb5_context, krb5_rcache,krb5_donot_replay FAR *));
+ krb5_error_code (*expunge)NPROTOTYPE((krb5_context, krb5_rcache));
+ krb5_error_code (*get_span)NPROTOTYPE((krb5_context, krb5_rcache,krb5_deltat FAR *));
+ char FAR *(*get_name)NPROTOTYPE((krb5_context, krb5_rcache));
+ krb5_error_code (*resolve)NPROTOTYPE((krb5_context, krb5_rcache, char FAR *));
} krb5_rc_ops;
-krb5_error_code INTERFACE krb5_rc_default
+krb5_error_code krb5_rc_default
PROTOTYPE((krb5_context,
- krb5_rcache *));
-krb5_error_code INTERFACE krb5_rc_register_type
+ krb5_rcache FAR *));
+krb5_error_code krb5_rc_register_type
PROTOTYPE((krb5_context,
- krb5_rc_ops *));
-krb5_error_code INTERFACE krb5_rc_resolve_type
+ krb5_rc_ops FAR *));
+krb5_error_code krb5_rc_resolve_type
PROTOTYPE((krb5_context,
- krb5_rcache *,char *));
-krb5_error_code INTERFACE krb5_rc_resolve_full
+ krb5_rcache FAR *,char FAR *));
+krb5_error_code krb5_rc_resolve_full
PROTOTYPE((krb5_context,
- krb5_rcache *,char *));
-char * INTERFACE krb5_rc_get_type
+ krb5_rcache FAR *,char FAR *));
+char FAR * krb5_rc_get_type
PROTOTYPE((krb5_context,
krb5_rcache));
-char * INTERFACE krb5_rc_default_type
+char FAR * krb5_rc_default_type
PROTOTYPE((krb5_context));
-char * INTERFACE krb5_rc_default_name
+char FAR * krb5_rc_default_name
PROTOTYPE((krb5_context));
-krb5_error_code INTERFACE krb5_auth_to_rep
+krb5_error_code krb5_auth_to_rep
PROTOTYPE((krb5_context,
- krb5_tkt_authent *,
- krb5_donot_replay *));
+ krb5_tkt_authent FAR *,
+ krb5_donot_replay FAR *));
#define krb5_rc_initialize(context, id, span) (*(id)->ops->init)(context, id, span)
#define krb5_rc_recover(context, id) (*(id)->ops->recover)(context, id)
unsigned char digest[16]; /* actual digest after MD5Final call */
} MD5_CTX;
-#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES)
-extern void INTERFACE MD5Init(MD5_CTX FAR *);
-extern void INTERFACE MD5Update (MD5_CTX FAR *, unsigned char FAR *, unsigned int);
-extern void INTERFACE MD5Final (MD5_CTX FAR *);
+#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES) || defined(_WINDOWS)
+extern void MD5Init(MD5_CTX FAR *);
+extern void MD5Update (MD5_CTX FAR *, unsigned char FAR *, unsigned int);
+extern void MD5Final (MD5_CTX FAR *);
#else
-extern void INTERFACE MD5Init();
-extern void INTERFACE MD5Update ();
-extern void INTERFACE MD5Final ();
+extern void MD5Init();
+extern void MD5Update ();
+extern void MD5Final ();
#endif
#define RSA_MD5_CKSUM_LENGTH 16
--- /dev/null
+Thu Apr 13 16:05:08 1995 Keith Vetter (keithv@fusion.com)
+
+ * syslog.h: __STDC__ conditionals also check for the _WINDOWS define.
#define LOG_NOWAIT 0x10 /* if forking to log on console, don't wait() */
#ifndef KERNEL
-#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES)
+#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES) || defined(_WINDOWS)
extern void syslog (int , const char *, ... );
#ifdef va_start
/* XXX depending on #define of va_start in <stdarg.h> */
#define LOG_NOWAIT 0x10 /* if forking to log on console, don't wait() */
#ifndef KERNEL
-#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES)
+#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES) || defined(_WINDOWS)
extern void syslog (int , const char *, ... );
#ifdef va_start
/* XXX depending on #define of va_start in <stdarg.h> */
+Thu Apr 13 16:56:50 1995 Keith Vetter (keithv@fusion.com)
+
+ * Makefile.in, libkrb5.def, gssapi.def (new):
+ Spec says we need a gssapi.dll & gssapi.lib.
+ * Makefile.in: re-inserted make-$(ALL) rule.
+
Wed Apr 5 16:27:53 1995 Keith Vetter (keithv@fusion.com)
* libkrb5.def: added krb5_us_timeofday to export list
##DOSBUILDTOP = ..
##DOS!include $(BUILDTOP)\config\windows.in
-all::
+all:: all-$(WHAT)
all-unix::
clean-windows::
$(RM) libkrb5.dll libkrb5.lib libkrb5.bak libkrb5.map winsock.lib
+ $(RM) gssapi.dll gssapi.lib gssapi.bak gssapi.map
#
# Windows stuff to make libkrb5.dll and libkrb5.lib. Currently it
# combines crypto, krb5 and the util/et directories.
WLIB = .\winsock.lib
LIBS = $(CLIB) $(KLIB) $(GLIB) $(ETLIB) $(WLIB)
-#
-# Fast: is a faster way to make things on the PC. Unfortunately it requires
-# the unix utility sed so it can't be part of the final production release.
-#
-fast: win_glue.obj winsock.lib
- $(RM) libkrb5.lib libkrb5.dll
- cd crypto
- $(MAKE) -$(MFLAGS) LIBCMD=rem
- libdir crypto.lib
- cd ..\krb5
- $(MAKE) -$(MFLAGS) LIBCMD=rem
- libdir krb5.lib
- cd ..
- cd $(BUILDTOP)\util\et
- $(MAKE) -$(MFLAGS)
- cd ..\..\lib\gssapi
- $(MAKE) -$(MFLAGS)
- cd ..
- link /co /seg:400 /noe /nologo win_glue, libkrb5.dll, libkrb5.map, \
- $(LIBS) ldllcew libw, libkrb5.def
- rc /nologo /p /k libkrb5.dll
- implib /nologo libkrb5.lib libkrb5.dll
-
+lib-windows: winsock.lib libkrb5.lib gssapi.lib
+
+gssapi.lib:: gssapi.dll
+ implib /nologo gssapi.lib gssapi.dll
+
+gssapi.dll:: $(GLIB) $(LIBS) gssapi.def
+ link /co /seg:400 /noe /nol win_glue, gssapi.dll, gssapi.map, \
+ $(LIBS) ldllcew libw, gssapi.def
+ rc /nologo /p /k gssapi.dll
+
libkrb5.lib:: libkrb5.dll
implib /nologo libkrb5.lib libkrb5.dll
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+ * *.h added FAR to pointers visible at to the world.
+
Tue Mar 28 20:00:00 1995 Keith Vetter (keithv@fusion.com)
* Makefile.in: more of nmake's strange behavior. Problem goes
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+ * *.h added FAR to pointers visible at to the world.
+
Thu Mar 16 21:14:15 1995 John Gilmore (gnu at toad.com)
* Makefile.in (crctest, crctest.exe): Replace crctest-unix and
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
-krb5_error_code INTERFACE
+krb5_error_code
crc32_sum_func NPROTOTYPE((krb5_pointer in, size_t in_length,
krb5_pointer seed, size_t seed_length, krb5_checksum *outcksum));
-krb5_error_code INTERFACE
+krb5_error_code
crc32_sum_func(in, in_length, seed, seed_length, outcksum)
krb5_pointer in;
size_t in_length;
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+ * *.h added FAR to pointers visible at to the world.
+ * f_tables.h: __STDC__ condition also checks _WINDOWS
+
Tue Mar 28 15:09:43 1995 John Gilmore (gnu at toad.com)
Bring in portability fixes from Cygnus K4 release.
returns: errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
mit_des_cbc_checksum(in, in_length, key, key_size, cksum)
krb5_pointer in;
size_t in_length;
#include "k5-int.h"
#include "des_int.h"
-extern krb5_error_code INTERFACE mit_des_cbc_checksum PROTOTYPE ((
+extern krb5_error_code mit_des_cbc_checksum PROTOTYPE ((
krb5_pointer ,
size_t ,
krb5_pointer ,
#include "mit-des.h" /* From include/krb5 */
/* cbc_cksum.c */
-extern krb5_error_code INTERFACE mit_des_cbc_checksum
+extern krb5_error_code mit_des_cbc_checksum
PROTOTYPE((krb5_pointer, size_t,krb5_pointer,size_t, krb5_checksum FAR * ));
/* cksum.c */
-extern long INTERFACE mit_des_cbc_cksum
- PROTOTYPE((krb5_octet *, krb5_octet *, long , mit_des_key_schedule ,
- krb5_octet *));
+extern long mit_des_cbc_cksum
+ PROTOTYPE((krb5_octet FAR *, krb5_octet FAR *, long , mit_des_key_schedule ,
+ krb5_octet FAR *));
/* des.c */
-extern int INTERFACE mit_des_ecb_encrypt
- PROTOTYPE((unsigned long *, unsigned long *, mit_des_key_schedule , int ));
+extern int mit_des_ecb_encrypt
+ PROTOTYPE((unsigned long FAR *, unsigned long FAR *, mit_des_key_schedule , int ));
/* f_cbc.c */
-extern int INTERFACE mit_des_cbc_encrypt
- PROTOTYPE((const mit_des_cblock *in, mit_des_cblock *out, long length,
+extern int mit_des_cbc_encrypt
+ PROTOTYPE((const mit_des_cblock FAR *in, mit_des_cblock FAR *out, long length,
mit_des_key_schedule schedule, mit_des_cblock ivec,
int encrypt));
/* fin_rndkey.c */
-extern krb5_error_code INTERFACE mit_des_finish_random_key
- PROTOTYPE(( krb5_pointer *));
+extern krb5_error_code mit_des_finish_random_key
+ PROTOTYPE(( krb5_pointer FAR *));
/* finish_key.c */
-extern krb5_error_code INTERFACE mit_des_finish_key
+extern krb5_error_code mit_des_finish_key
PROTOTYPE(( krb5_encrypt_block FAR *));
/* init_rkey.c */
-extern krb5_error_code INTERFACE mit_des_init_random_key
- PROTOTYPE(( const krb5_keyblock *, krb5_pointer *));
+extern krb5_error_code mit_des_init_random_key
+ PROTOTYPE(( const krb5_keyblock FAR *, krb5_pointer FAR *));
/* key_parity.c */
-extern void INTERFACE mit_des_fixup_key_parity PROTOTYPE((mit_des_cblock ));
-extern int INTERFACE mit_des_check_key_parity PROTOTYPE((mit_des_cblock ));
+extern void mit_des_fixup_key_parity PROTOTYPE((mit_des_cblock ));
+extern int mit_des_check_key_parity PROTOTYPE((mit_des_cblock ));
/* key_sched.c */
-extern int INTERFACE mit_des_key_sched
+extern int mit_des_key_sched
PROTOTYPE((mit_des_cblock , mit_des_key_schedule ));
/* new_rnd_key.c */
-extern int INTERFACE mit_des_new_random_key
- PROTOTYPE((mit_des_cblock , mit_des_random_key_seed *));
-extern void INTERFACE mit_des_init_random_number_generator
- PROTOTYPE((mit_des_cblock, mit_des_random_key_seed *));
-extern void INTERFACE mit_des_set_random_generator_seed
- PROTOTYPE((mit_des_cblock , mit_des_random_key_seed *));
-extern void INTERFACE mit_des_set_sequence_number
- PROTOTYPE((mit_des_cblock , mit_des_random_key_seed *));
-extern void INTERFACE mit_des_generate_random_block
- PROTOTYPE((mit_des_cblock , mit_des_random_key_seed *));
+extern int mit_des_new_random_key
+ PROTOTYPE((mit_des_cblock , mit_des_random_key_seed FAR *));
+extern void mit_des_init_random_number_generator
+ PROTOTYPE((mit_des_cblock, mit_des_random_key_seed FAR *));
+extern void mit_des_set_random_generator_seed
+ PROTOTYPE((mit_des_cblock , mit_des_random_key_seed FAR *));
+extern void mit_des_set_sequence_number
+ PROTOTYPE((mit_des_cblock , mit_des_random_key_seed FAR *));
+extern void mit_des_generate_random_block
+ PROTOTYPE((mit_des_cblock , mit_des_random_key_seed FAR *));
/* process_ky.c */
-extern krb5_error_code INTERFACE mit_des_process_key
- PROTOTYPE(( krb5_encrypt_block *, const krb5_keyblock *));
+extern krb5_error_code mit_des_process_key
+ PROTOTYPE(( krb5_encrypt_block FAR *, const krb5_keyblock FAR *));
/* random_key.c */
-extern krb5_error_code INTERFACE mit_des_random_key
- PROTOTYPE(( const krb5_encrypt_block *, krb5_pointer , krb5_keyblock **));
+extern krb5_error_code mit_des_random_key
+ PROTOTYPE(( const krb5_encrypt_block FAR *, krb5_pointer ,
+ krb5_keyblock FAR * FAR *));
/* string2key.c */
-extern krb5_error_code INTERFACE mit_des_string_to_key
- PROTOTYPE(( const krb5_encrypt_block *, const krb5_keytype,
- krb5_keyblock *, const krb5_data *, const krb5_data *));
+extern krb5_error_code mit_des_string_to_key
+ PROTOTYPE(( const krb5_encrypt_block FAR *, const krb5_keytype,
+ krb5_keyblock FAR *, const krb5_data FAR *, const krb5_data FAR *));
/* weak_key.c */
-extern int INTERFACE mit_des_is_weak_key PROTOTYPE((mit_des_cblock ));
+extern int mit_des_is_weak_key PROTOTYPE((mit_des_cblock ));
/* cmb_keys.c */
krb5_error_code mit_des_combine_subkeys
- PROTOTYPE((const krb5_keyblock *, const krb5_keyblock *,
- krb5_keyblock **));
+ PROTOTYPE((const krb5_keyblock FAR *, const krb5_keyblock FAR *,
+ krb5_keyblock FAR * FAR *));
/* f_pcbc.c */
-int INTERFACE mit_des_pcbc_encrypt ();
+int mit_des_pcbc_encrypt ();
/* f_sched.c */
-int INTERFACE make_key_sched PROTOTYPE((mit_des_cblock, mit_des_key_schedule));
+int make_key_sched PROTOTYPE((mit_des_cblock, mit_des_key_schedule));
/* misc.c */
-extern void swap_bits PROTOTYPE((char *));
+extern void swap_bits PROTOTYPE((char FAR *));
extern unsigned long long_swap_bits PROTOTYPE((unsigned long ));
extern unsigned long swap_six_bits_to_ansi PROTOTYPE((unsigned long ));
extern unsigned long swap_four_bits_to_ansi PROTOTYPE((unsigned long ));
* cleartext.
*/
-int INTERFACE
+int
mit_des_cbc_encrypt(in, out, length, schedule, ivec, encrypt)
const des_cblock *in;
des_cblock *out;
* multiple of eight bytes.
*/
-unsigned long INTERFACE
+unsigned long
mit_des_cbc_cksum(in, out, length, schedule, ivec)
des_cblock *in;
des_cblock *out;
/*
* des_ecb_encrypt - {en,de}crypt a block in ECB mode
*/
-int INTERFACE
+int
mit_des_ecb_encrypt(in, out, schedule, encrypt)
des_cblock *in;
des_cblock *out;
#define pstep(x,step) (((x)&smask(step))^(((x)>>step)&smask(step)))
#define parity_char(x) pstep(pstep(pstep((x),4),2),1)
-void INTERFACE
+void
mit_des_fixup_key_parity(key)
register des_cblock key;
{
* See des_fix_key_parity for the definition of
* correct des parity.
*/
-int INTERFACE
+int
mit_des_check_key_parity(key)
register des_cblock key;
{
/*
* des_pcbc_encrypt - {en,de}crypt a stream in PCBC mode
*/
-int INTERFACE
+int
mit_des_pcbc_encrypt(in, out, length, schedule, ivec, encrypt)
des_cblock *in;
des_cblock *out;
/*
* Permute the key to give us our key schedule.
*/
-int INTERFACE
+int
make_key_sched(key, schedule)
mit_des_cblock key;
mit_des_key_schedule schedule;
#define __DES_TABLES_H__ /* nothing */
#ifndef const
-#ifndef __STDC__
+#if !defined(__STDC__) && !defined(_WINDOWS)
#define const /* nothing */
#endif
#endif
free any resources held by "seed" and assigned by init_random_key()
*/
-krb5_error_code INTERFACE mit_des_finish_random_key (seed)
+krb5_error_code mit_des_finish_random_key (seed)
krb5_pointer * seed;
{
memset((char *)*seed, 0, sizeof(mit_des_random_key_seed) );
returns: errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
mit_des_finish_key (eblock)
krb5_encrypt_block FAR * eblock;
{
sequence information.
*/
-krb5_error_code INTERFACE
+krb5_error_code
mit_des_init_random_key (seedblock, seed)
const krb5_keyblock * seedblock;
krb5_pointer * seed;
#include "k5-int.h"
#include "des_int.h"
-int INTERFACE
+int
mit_des_key_sched(k,schedule)
mit_des_cblock k;
mit_des_key_schedule schedule;
* to be a weak des key. Mit_Des_generate_random_block is used to
* provide the random bits.
*/
-int INTERFACE
+int
mit_des_new_random_key(key, p_seed)
mit_des_cblock key;
mit_des_random_key_seed *p_seed;
* Note: this routine calls mit_des_set_random_generator_seed.
*/
-void INTERFACE
+void
mit_des_init_random_number_generator(key,p_seed)
mit_des_cblock key;
mit_des_random_key_seed *p_seed;
* Requires: key is a valid des key. I.e., has correct parity and is not a
* weak des key.
*/
-void INTERFACE
+void
mit_des_set_random_generator_seed(key, p_seed)
mit_des_cblock key;
mit_des_random_key_seed *p_seed;
*
* Note that mit_des_set_random_generator_seed resets the sequence number to 0.
*/
-void INTERFACE
+void
mit_des_set_sequence_number(new_sequence_number, p_seed)
mit_des_cblock new_sequence_number;
mit_des_random_key_seed *p_seed;
* Requires: mit_des_set_random_generator_seed must have been called at least once
* before this routine is called.
*/
-void INTERFACE
+void
mit_des_generate_random_block(block, p_seed)
mit_des_cblock block;
mit_des_random_key_seed *p_seed;
returns: errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
mit_des_process_key (eblock, keyblock)
krb5_encrypt_block * eblock;
const krb5_keyblock * keyblock;
filling in the keyblock address in *keyblock
*/
-krb5_error_code INTERFACE
+krb5_error_code
mit_des_random_key (eblock, seed, keyblock)
const krb5_encrypt_block * eblock;
krb5_pointer seed;
returns: errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
mit_des_string_to_key (eblock, keytype, keyblock, data, salt)
const krb5_encrypt_block FAR * eblock;
const krb5_keytype keytype;
char k_char[64];
mit_des_key_schedule key_sked;
+#ifndef min
#define min(A, B) ((A) < (B) ? (A): (B))
+#endif
if ( keytype != KEYTYPE_DES )
return (KRB5_PROG_KEYTYPE_NOSUPP);
*
* Requires: key has correct odd parity.
*/
-int INTERFACE
+int
mit_des_is_weak_key(key)
mit_des_cblock key;
{
#include "crc-32.h"
#include "des_int.h"
-krb5_error_code INTERFACE mit_des_crc_encrypt_func
+krb5_error_code mit_des_crc_encrypt_func
PROTOTYPE(( krb5_const_pointer, krb5_pointer, const size_t,
krb5_encrypt_block *, krb5_pointer ));
-krb5_error_code INTERFACE mit_des_crc_decrypt_func
+krb5_error_code mit_des_crc_decrypt_func
PROTOTYPE(( krb5_const_pointer, krb5_pointer, const size_t,
krb5_encrypt_block *, krb5_pointer ));
};
-krb5_error_code INTERFACE
+krb5_error_code
mit_des_crc_encrypt_func(in, out, size, key, ivec)
krb5_const_pointer in;
krb5_pointer out;
}
-krb5_error_code INTERFACE
+krb5_error_code
mit_des_crc_decrypt_func(in, out, size, key, ivec)
krb5_const_pointer in;
krb5_pointer out;
#include "rsa-md5.h"
#include "des_int.h"
-krb5_error_code INTERFACE mit_des_md5_encrypt_func
+krb5_error_code mit_des_md5_encrypt_func
PROTOTYPE(( krb5_const_pointer, krb5_pointer, const size_t,
krb5_encrypt_block *, krb5_pointer ));
-krb5_error_code INTERFACE mit_des_md5_decrypt_func
+krb5_error_code mit_des_md5_decrypt_func
PROTOTYPE(( krb5_const_pointer, krb5_pointer, const size_t,
krb5_encrypt_block *, krb5_pointer ));
};
-krb5_error_code INTERFACE
+krb5_error_code
mit_des_md5_encrypt_func(in, out, size, key, ivec)
krb5_const_pointer in;
krb5_pointer out;
}
-krb5_error_code INTERFACE
+krb5_error_code
mit_des_md5_decrypt_func(in, out, size, key, ivec)
krb5_const_pointer in;
krb5_pointer out;
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+ * *.h added FAR to pointers visible at to the world.
+ * rsa-md4.h: __STDC__ condition also checks _WINDOWS
+
Thu Mar 16 21:19:55 1995 John Gilmore (gnu at toad.com)
* Makefile.in (CFLAGS): Tweak for Unix->MPW converter.
#include "k5-int.h"
#include "rsa-md4.h"
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
#define UL(x) x##UL
#else
#define UL(x) ((krb5_ui_4) x)
#endif
/* forward declaration */
-#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES)
+#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES) || defined(_WINDOWS)
static void Transform (krb5_ui_4 FAR *, krb5_ui_4 FAR *);
#else
static void Transform ();
{(a) += H ((b), (c), (d)) + (x) + UL(015666365641); \
(a) = ROTATE_LEFT ((a), (s));}
-void INTERFACE
+void
MD4Init (mdContext)
MD4_CTX FAR *mdContext;
{
mdContext->buf[3] = UL(0x10325476);
}
-void INTERFACE
+void
MD4Update (mdContext, inBuf, inLen)
MD4_CTX FAR *mdContext;
unsigned char FAR *inBuf;
}
}
-void INTERFACE
+void
MD4Final (mdContext)
MD4_CTX FAR *mdContext;
{
#include "rsa-md4.h"
#include "des_int.h" /* we cheat a bit and call it directly... */
-krb5_error_code INTERFACE
+krb5_error_code
md4_crypto_sum_func NPROTOTYPE((krb5_pointer in, size_t in_length,
krb5_pointer seed, size_t seed_length, krb5_checksum *outcksum));
-krb5_error_code INTERFACE
+krb5_error_code
md4_crypto_sum_func(in, in_length, seed, seed_length, outcksum)
krb5_pointer in;
size_t in_length;
#include "k5-int.h"
#include "rsa-md4.h"
-krb5_error_code INTERFACE
+krb5_error_code
md4_sum_func NPROTOTYPE((krb5_pointer in, size_t in_length,
krb5_pointer seed, size_t seed_length, krb5_checksum *outcksum));
-krb5_error_code INTERFACE
+krb5_error_code
md4_sum_func(in, in_length, seed, seed_length, outcksum)
krb5_pointer in;
size_t in_length;
unsigned char digest[16]; /* actual digest after MD4Final call */
} MD4_CTX;
-#ifdef __STDC__
-extern void INTERFACE MD4Init(MD4_CTX FAR *);
-extern void INTERFACE MD4Update(MD4_CTX FAR *, unsigned char FAR *, unsigned int);
-extern void INTERFACE MD4Final(MD4_CTX FAR *);
+#if defined(__STDC__) || defined(_WINDOWS)
+extern void MD4Init(MD4_CTX FAR *);
+extern void MD4Update(MD4_CTX FAR *, unsigned char FAR *, unsigned int);
+extern void MD4Final(MD4_CTX FAR *);
#else
-void INTERFACE MD4Init ();
-void INTERFACE MD4Update ();
-void INTERFACE MD4Final ();
+void MD4Init ();
+void MD4Update ();
+void MD4Final ();
#endif
/*
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+ * *.h added FAR to pointers visible at to the world.
+
Thu Mar 16 21:23:03 1995 John Gilmore (gnu at toad.com)
* Makefile.in (LDFLAGS): Remove, conflicts with pre.in.
#include "k5-int.h"
#include "rsa-md5.h"
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
#define UL(x) x##UL
#else
#define UL(x) ((krb5_ui_4) x)
/* The routine MD5Init initializes the message-digest context
mdContext. All fields are set to zero.
*/
-void INTERFACE
+void
MD5Init (mdContext)
MD5_CTX FAR *mdContext;
{
account for the presence of each of the characters inBuf[0..inLen-1]
in the message whose digest is being computed.
*/
-void INTERFACE
+void
MD5Update (mdContext, inBuf, inLen)
MD5_CTX FAR *mdContext;
unsigned char FAR *inBuf;
/* The routine MD5Final terminates the message-digest computation and
ends with the desired message digest in mdContext->digest[0...15].
*/
-void INTERFACE
+void
MD5Final (mdContext)
MD5_CTX FAR *mdContext;
{
#include "rsa-md5.h"
#include "des_int.h" /* we cheat a bit and call it directly... */
-krb5_error_code INTERFACE
+krb5_error_code
md5_crypto_sum_func NPROTOTYPE((krb5_pointer in, size_t in_length,
krb5_pointer seed, size_t seed_length, krb5_checksum *outcksum));
-krb5_error_code INTERFACE
+krb5_error_code
md5_crypto_sum_func(in, in_length, seed, seed_length, outcksum)
krb5_pointer in;
size_t in_length;
#include "k5-int.h"
#include "rsa-md5.h"
-krb5_error_code INTERFACE
+krb5_error_code
md5_sum_func NPROTOTYPE((krb5_pointer in, size_t in_length,
krb5_pointer seed, size_t seed_length, krb5_checksum *outcksum));
-krb5_error_code INTERFACE
+krb5_error_code
md5_sum_func(in, in_length, seed, seed_length, outcksum)
krb5_pointer in;
size_t in_length;
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+
Sat Mar 25 15:38:23 1995 Mark Eichin <eichin@cygnus.com>
* Makefile.in (memmove.c): memmove.c is in krb5/posix, not krb5/os.
/*
* Generate a random confounder
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_random_confounder(size, fillin)
int size;
krb5_pointer fillin;
#include "k5-int.h"
#include "des_int.h"
-krb5_error_code INTERFACE mit_raw_des_encrypt_func
+krb5_error_code mit_raw_des_encrypt_func
PROTOTYPE(( krb5_const_pointer, krb5_pointer, const size_t,
krb5_encrypt_block *, krb5_pointer ));
-krb5_error_code INTERFACE mit_raw_des_decrypt_func
+krb5_error_code mit_raw_des_decrypt_func
PROTOTYPE(( krb5_const_pointer, krb5_pointer, const size_t,
krb5_encrypt_block *, krb5_pointer ));
0
};
-krb5_error_code INTERFACE
+krb5_error_code
mit_raw_des_decrypt_func(in, out, size, key, ivec)
krb5_const_pointer in;
krb5_pointer out;
MIT_DES_DECRYPT));
}
-krb5_error_code INTERFACE
+krb5_error_code
mit_raw_des_encrypt_func(in, out, size, key, ivec)
krb5_const_pointer in;
krb5_pointer out;
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+
Wed Mar 22 11:21:38 1995 Keith Vetter (keithv@fusion.com)
* read_passwd.c: changed return value to krb5_error_code
* multiple of eight bytes.
*/
-void INTERFACE
+void
des_cbc_cksum(in,out,length,key,iv)
krb5_octet *in; /* >= length bytes of inputtext */
krb5_octet *out; /* >= length bytes of outputtext */
#include "des.h"
-int INTERFACE
+int
des_ecb_encrypt(clear, cipher, schedule, encrypt)
unsigned long *clear;
unsigned long *cipher;
/*
* Windows needs everything prototyped because we're exporting all the fuctions.
*/
-void INTERFACE des_cbc_cksum();
-int INTERFACE des_ecb_encrypt();
-int INTERFACE des_cbc_encrypt();
-void INTERFACE des_fixup_key_parity();
-int INTERFACE des_check_key_parity();
-int INTERFACE des_key_sched();
-int INTERFACE des_new_random_key();
-void INTERFACE des_init_random_number_generator();
-void INTERFACE des_set_random_generator_seed();
-void INTERFACE des_set_sequence_number();
-void INTERFACE des_generate_random_block();
-int INTERFACE des_pcbc_encrypt();
-unsigned long INTERFACE des_quad_cksum();
-int INTERFACE des_random_key();
-krb5_error_code INTERFACE des_read_password();
-int INTERFACE des_string_to_key();
-int INTERFACE des_is_weak_key();
+void des_cbc_cksum();
+int des_ecb_encrypt();
+int des_cbc_encrypt();
+void des_fixup_key_parity();
+int des_check_key_parity();
+int des_key_sched();
+int des_new_random_key();
+void des_init_random_number_generator();
+void des_set_random_generator_seed();
+void des_set_sequence_number();
+void des_generate_random_block();
+int des_pcbc_encrypt();
+unsigned long des_quad_cksum();
+int des_random_key();
+krb5_error_code des_read_password();
+int des_string_to_key();
+int des_is_weak_key();
#endif /* DES_DEFS */
* cleartext.
*/
-int INTERFACE
+int
des_cbc_encrypt(in,out,length,key,iv,encrypt)
krb5_octet *in; /* >= length bytes of input text */
krb5_octet *out; /* >= length bytes of output text */
* 8,16,...64 in des order, implies 0, 8, 16, ...
* vax order.
*/
-void INTERFACE
+void
des_fixup_key_parity(key)
register mit_des_cblock key;
{
* See des_fix_key_parity for the definition of
* correct des parity.
*/
-int INTERFACE
+int
des_check_key_parity(key)
register mit_des_cblock key;
{
#include <stdio.h>
#include "des.h"
-int INTERFACE
+int
des_key_sched(k,schedule)
register mit_des_cblock k; /* r11 */
mit_des_key_schedule schedule;
* to be a weak des key. Des_generate_random_block is used to
* provide the random bits.
*/
-int INTERFACE
+int
des_new_random_key(key)
mit_des_cblock key;
{
*
* Note: this routine calls des_set_random_generator_seed.
*/
-void INTERFACE
+void
des_init_random_number_generator(key)
mit_des_cblock key;
{
* Requires: key is a valid des key. I.e., has correct parity and is not a
* weak des key.
*/
-void INTERFACE
+void
des_set_random_generator_seed(key)
mit_des_cblock key;
{
*
* Note that des_set_random_generator_seed resets the sequence number to 0.
*/
-void INTERFACE
+void
des_set_sequence_number(new_sequence_number)
mit_des_cblock new_sequence_number;
{
* Requires: des_set_random_generator_seed must have been called at least once
* before this routine is called.
*/
-void INTERFACE
+void
des_generate_random_block(block)
mit_des_cblock block;
{
/*
* des_pcbc_encrypt - {en,de}crypt a stream in PCBC mode
*/
-int INTERFACE
+int
des_pcbc_encrypt(in, out, length, schedule, ivec, encrypt)
des_cblock *in;
des_cblock *out;
/*** Routines ***************************************************** */
-unsigned long INTERFACE
+unsigned long
des_quad_cksum(in,out,length,out_count,c_seed)
mit_des_cblock *c_seed; /* secret seed, 8 bytes */
unsigned char *in; /* input block */
#include "des.h"
/* random_key */
-int INTERFACE
+int
des_random_key(key)
mit_des_cblock *key;
{
static krb5_context krb4_global_context = 0;
/*** Routines ****************************************************** */
-krb5_error_code INTERFACE
+krb5_error_code
des_read_password/*_v4_compat_crock*/(k,prompt,verify)
mit_des_cblock *k;
char *prompt;
/*
* convert an arbitrary length string to a DES key
*/
-int INTERFACE
+int
des_string_to_key(str,key)
char *str;
register mit_des_cblock *key;
register char *p_char;
static char k_char[64];
static mit_des_key_schedule key_sked;
- extern void INTERFACE des_cbc_cksum();
+ extern void des_cbc_cksum();
in_str = str;
forward = 1;
#ifndef _MSDOS
#include <sys/time.h>
-krb5_ui_4 INTERFACE
+krb5_ui_4
unix_time_gmt_unixsec (usecptr)
krb5_ui_4 *usecptr;
{
*/
static long win_time_get_epoch(void);
-krb5_ui_4 INTERFACE
+krb5_ui_4
unix_time_gmt_unixsec (usecptr)
krb5_ui_4 *usecptr;
{
*
* Requires: key has correct odd parity.
*/
-int INTERFACE
+int
des_is_weak_key(key)
mit_des_cblock key;
{
--- /dev/null
+;----------------------------------------------------
+; GSSAPI.DEF - GSSAPI.DLL module definition file
+;----------------------------------------------------
+
+LIBRARY GSSAPI
+DESCRIPTION 'Base Generic Security Service API'
+EXETYPE WINDOWS
+CODE PRELOAD MOVEABLE DISCARDABLE
+DATA PRELOAD MOVEABLE SINGLE
+HEAPSIZE 8192
+
+EXPORTS
+ WEP @1001 RESIDENTNAME
+ LIBMAIN @1002
+ GSS_ACQUIRE_CRED @1
+ GSS_RELEASE_CRED @2
+ GSS_INIT_SEC_CONTEXT @3
+ GSS_ACCEPT_SEC_CONTEXT @4
+ GSS_PROCESS_CONTEXT_TOKEN @5
+ GSS_DELETE_SEC_CONTEXT @6
+ GSS_CONTEXT_TIME @7
+ GSS_SIGN @8
+ GSS_VERIFY @9
+ GSS_SEAL @10
+ GSS_UNSEAL @11
+ GSS_DISPLAY_STATUS @12
+ GSS_INDICATE_MECHS @13
+ GSS_COMPARE_NAME @14
+ GSS_DISPLAY_NAME @15
+ GSS_IMPORT_NAME @16
+ GSS_RELEASE_NAME @17
+ GSS_RELEASE_BUFFER @18
+ GSS_RELEASE_OID_SET @19
+ GSS_INQUIRE_CRED @20
+
+Thu Apr 13 16:27:56 1995 Keith Vetter (keithv@fusion.com)
+
+ * gssapi_e.c: __STDC__ conditional also checks the _WINDOWS define.
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+ * *.h added FAR to pointers visible at to the world.
+
Tue Mar 28 18:28:03 1995 John Gilmore (gnu at toad.com)
* Makefile.in (unixmac): Add to build header files.
if status_type == GSS_C_MECH_CODE, return the output from error_message()
*/
-OM_uint32 INTERFACE
+OM_uint32
g_display_com_err_status(minor_status, status_value, status_string)
OM_uint32 *minor_status;
OM_uint32 status_value;
message_context > 2 : print supplementary info bit (message_context-2)
*/
-OM_uint32 INTERFACE g_display_major_status(minor_status, status_value,
+OM_uint32 g_display_major_status(minor_status, status_value,
message_context, status_string)
OM_uint32 *minor_status;
OM_uint32 status_value;
* First, define the platform-dependent types.
*/
typedef krb5_ui_4 OM_uint32;
-typedef void * gss_name_t;
-typedef void * gss_cred_id_t;
-typedef void * gss_ctx_id_t;
+typedef void FAR * gss_name_t;
+typedef void FAR * gss_cred_id_t;
+typedef void FAR * gss_ctx_id_t;
/*
* Note that a platform supporting the xom.h X/Open header file
typedef struct gss_OID_desc_struct {
OM_uint32 length;
- void *elements;
-} gss_OID_desc, *gss_OID;
+ void FAR *elements;
+} gss_OID_desc, FAR *gss_OID;
-typedef const gss_OID_desc * const const_gss_OID;
+typedef const gss_OID_desc FAR * const const_gss_OID;
typedef struct gss_OID_set_desc_struct {
int count;
gss_OID elements;
-} gss_OID_set_desc, *gss_OID_set;
+} gss_OID_set_desc, FAR *gss_OID_set;
typedef struct gss_buffer_desc_struct {
size_t length;
- void *value;
-} gss_buffer_desc, *gss_buffer_t;
+ void FAR *value;
+} gss_buffer_desc, FAR *gss_buffer_t;
typedef struct gss_channel_bindings_struct {
OM_uint32 initiator_addrtype;
OM_uint32 acceptor_addrtype;
gss_buffer_desc acceptor_address;
gss_buffer_desc application_data;
-} *gss_channel_bindings_t;
+} FAR *gss_channel_bindings_t;
/*
*/
OM_uint32 INTERFACE gss_acquire_cred
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_name_t, /* desired_name */
- OM_uint32, /* time_req */
- gss_OID_set, /* desired_mechs */
- int, /* cred_usage */
- gss_cred_id_t*, /* output_cred_handle */
- gss_OID_set*, /* actual_mechs */
- OM_uint32* /* time_rec */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_name_t, /* desired_name */
+ OM_uint32, /* time_req */
+ gss_OID_set, /* desired_mechs */
+ int, /* cred_usage */
+ gss_cred_id_t FAR *,/* output_cred_handle */
+ gss_OID_set FAR *, /* actual_mechs */
+ OM_uint32 FAR * /* time_rec */
));
OM_uint32 INTERFACE gss_release_cred
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_cred_id_t* /* cred_handle */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_cred_id_t FAR * /* cred_handle */
));
OM_uint32 INTERFACE gss_init_sec_context
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_cred_id_t, /* claimant_cred_handle */
- gss_ctx_id_t*, /* context_handle */
- gss_name_t, /* target_name */
- const_gss_OID, /* mech_type */
- int, /* req_flags */
- OM_uint32, /* time_req */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_cred_id_t, /* claimant_cred_handle */
+ gss_ctx_id_t FAR *, /* context_handle */
+ gss_name_t, /* target_name */
+ const_gss_OID, /* mech_type */
+ int, /* req_flags */
+ OM_uint32, /* time_req */
gss_channel_bindings_t,
- /* input_chan_bindings */
- gss_buffer_t, /* input_token */
- gss_OID*, /* actual_mech_type */
- gss_buffer_t, /* output_token */
- int*, /* ret_flags */
- OM_uint32* /* time_rec */
+ /* input_chan_bindings */
+ gss_buffer_t, /* input_token */
+ gss_OID FAR *, /* actual_mech_type */
+ gss_buffer_t, /* output_token */
+ int FAR *, /* ret_flags */
+ OM_uint32 FAR * /* time_rec */
));
OM_uint32 INTERFACE gss_accept_sec_context
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_ctx_id_t*, /* context_handle */
- gss_cred_id_t, /* verifier_cred_handle */
- gss_buffer_t, /* input_token_buffer */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_ctx_id_t FAR *, /* context_handle */
+ gss_cred_id_t, /* verifier_cred_handle */
+ gss_buffer_t, /* input_token_buffer */
gss_channel_bindings_t,
- /* input_chan_bindings */
- gss_name_t*, /* src_name */
- gss_OID*, /* mech_type */
- gss_buffer_t, /* output_token */
- int*, /* ret_flags */
- OM_uint32*, /* time_rec */
- gss_cred_id_t* /* delegated_cred_handle */
+ /* input_chan_bindings */
+ gss_name_t FAR *, /* src_name */
+ gss_OID FAR *, /* mech_type */
+ gss_buffer_t, /* output_token */
+ int FAR *, /* ret_flags */
+ OM_uint32 FAR *, /* time_rec */
+ gss_cred_id_t FAR * /* delegated_cred_handle */
));
OM_uint32 INTERFACE gss_process_context_token
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_ctx_id_t, /* context_handle */
- gss_buffer_t /* token_buffer */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_ctx_id_t, /* context_handle */
+ gss_buffer_t /* token_buffer */
));
OM_uint32 INTERFACE gss_delete_sec_context
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_ctx_id_t*, /* context_handle */
- gss_buffer_t /* output_token */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_ctx_id_t FAR *, /* context_handle */
+ gss_buffer_t /* output_token */
));
OM_uint32 INTERFACE gss_context_time
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_ctx_id_t, /* context_handle */
- OM_uint32* /* time_rec */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_ctx_id_t, /* context_handle */
+ OM_uint32 FAR * /* time_rec */
));
OM_uint32 INTERFACE gss_sign
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_ctx_id_t, /* context_handle */
- int, /* qop_req */
- gss_buffer_t, /* message_buffer */
- gss_buffer_t /* message_token */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_ctx_id_t, /* context_handle */
+ int, /* qop_req */
+ gss_buffer_t, /* message_buffer */
+ gss_buffer_t /* message_token */
));
-OM_uint32 INTERFACE INTERFACE gss_verify
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_ctx_id_t, /* context_handle */
- gss_buffer_t, /* message_buffer */
- gss_buffer_t, /* token_buffer */
- int* /* qop_state */
+OM_uint32 INTERFACE gss_verify
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_ctx_id_t, /* context_handle */
+ gss_buffer_t, /* message_buffer */
+ gss_buffer_t, /* token_buffer */
+ int FAR * /* qop_state */
));
OM_uint32 INTERFACE gss_seal
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_ctx_id_t, /* context_handle */
- int, /* conf_req_flag */
- int, /* qop_req */
- gss_buffer_t, /* input_message_buffer */
- int*, /* conf_state */
- gss_buffer_t /* output_message_buffer */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_ctx_id_t, /* context_handle */
+ int, /* conf_req_flag */
+ int, /* qop_req */
+ gss_buffer_t, /* input_message_buffer */
+ int FAR *, /* conf_state */
+ gss_buffer_t /* output_message_buffer */
));
OM_uint32 INTERFACE gss_unseal
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_ctx_id_t, /* context_handle */
- gss_buffer_t, /* input_message_buffer */
- gss_buffer_t, /* output_message_buffer */
- int*, /* conf_state */
- int* /* qop_state */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_ctx_id_t, /* context_handle */
+ gss_buffer_t, /* input_message_buffer */
+ gss_buffer_t, /* output_message_buffer */
+ int FAR *, /* conf_state */
+ int FAR * /* qop_state */
));
OM_uint32 INTERFACE gss_display_status
-PROTOTYPE( (OM_uint32*, /* minor_status */
- OM_uint32, /* status_value */
- int, /* status_type */
- const_gss_OID, /* mech_type */
- int*, /* message_context */
- gss_buffer_t /* status_string */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ OM_uint32, /* status_value */
+ int, /* status_type */
+ const_gss_OID, /* mech_type */
+ int FAR *, /* message_context */
+ gss_buffer_t /* status_string */
));
OM_uint32 INTERFACE gss_indicate_mechs
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_OID_set* /* mech_set */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_OID_set FAR * /* mech_set */
));
OM_uint32 INTERFACE gss_compare_name
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_name_t, /* name1 */
- gss_name_t, /* name2 */
- int* /* name_equal */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_name_t, /* name1 */
+ gss_name_t, /* name2 */
+ int FAR * /* name_equal */
));
OM_uint32 INTERFACE gss_display_name
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_name_t, /* input_name */
- gss_buffer_t, /* output_name_buffer */
- gss_OID* /* output_name_type */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_name_t, /* input_name */
+ gss_buffer_t, /* output_name_buffer */
+ gss_OID FAR * /* output_name_type */
));
OM_uint32 INTERFACE gss_import_name
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_buffer_t, /* input_name_buffer */
- const_gss_OID, /* input_name_type */
- gss_name_t* /* output_name */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_buffer_t, /* input_name_buffer */
+ const_gss_OID, /* input_name_type */
+ gss_name_t FAR * /* output_name */
));
OM_uint32 INTERFACE gss_release_name
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_name_t* /* input_name */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_name_t FAR * /* input_name */
));
OM_uint32 INTERFACE gss_release_buffer
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_buffer_t /* buffer */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_buffer_t /* buffer */
));
OM_uint32 INTERFACE gss_release_oid_set
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_OID_set* /* set */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_OID_set FAR * /* set */
));
OM_uint32 INTERFACE gss_inquire_cred
-PROTOTYPE( (OM_uint32 *, /* minor_status */
- gss_cred_id_t, /* cred_handle */
- gss_name_t *, /* name */
- OM_uint32 *, /* lifetime */
- int *, /* cred_usage */
- gss_OID_set * /* mechanisms */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_cred_id_t, /* cred_handle */
+ gss_name_t FAR *, /* name */
+ OM_uint32 FAR *, /* lifetime */
+ int FAR *, /* cred_usage */
+ gss_OID_set FAR * /* mechanisms */
));
OM_uint32 INTERFACE gss_inquire_context
-PROTOTYPE( (OM_uint32*, /* minor_status */
- gss_ctx_id_t, /* context_handle */
- gss_name_t*, /* initiator_name */
- gss_name_t*, /* acceptor_name */
- OM_uint32*, /* lifetime_rec */
- gss_OID*, /* mech_type */
- int*, /* ret_flags */
- int* /* locally_initiated */
+PROTOTYPE( (OM_uint32 FAR *, /* minor_status */
+ gss_ctx_id_t, /* context_handle */
+ gss_name_t FAR *, /* initiator_name */
+ gss_name_t FAR *, /* acceptor_name */
+ OM_uint32 FAR *, /* lifetime_rec */
+ gss_OID FAR *, /* mech_type */
+ int FAR *, /* ret_flags */
+ int FAR * /* locally_initiated */
));
/** helper functions **/
-int INTERFACE g_save_name PROTOTYPE((void **vdb, gss_name_t *name));
-int INTERFACE g_save_cred_id PROTOTYPE((void **vdb, gss_cred_id_t *cred));
-int INTERFACE g_save_ctx_id PROTOTYPE((void **vdb, gss_ctx_id_t *ctx));
+int g_save_name PROTOTYPE((void **vdb, gss_name_t *name));
+int g_save_cred_id PROTOTYPE((void **vdb, gss_cred_id_t *cred));
+int g_save_ctx_id PROTOTYPE((void **vdb, gss_ctx_id_t *ctx));
-int INTERFACE g_validate_name PROTOTYPE((void **vdb, gss_name_t *name));
-int INTERFACE g_validate_cred_id PROTOTYPE((void **vdb, gss_cred_id_t *cred));
-int INTERFACE g_validate_ctx_id PROTOTYPE((void **vdb, gss_ctx_id_t *ctx));
+int g_validate_name PROTOTYPE((void **vdb, gss_name_t *name));
+int g_validate_cred_id PROTOTYPE((void **vdb, gss_cred_id_t *cred));
+int g_validate_ctx_id PROTOTYPE((void **vdb, gss_ctx_id_t *ctx));
-int INTERFACE g_delete_name PROTOTYPE((void **vdb, gss_name_t *name));
-int INTERFACE g_delete_cred_id PROTOTYPE((void **vdb, gss_cred_id_t *cred));
-int INTERFACE g_delete_ctx_id PROTOTYPE((void **vdb, gss_ctx_id_t *ctx));
+int g_delete_name PROTOTYPE((void **vdb, gss_name_t *name));
+int g_delete_cred_id PROTOTYPE((void **vdb, gss_cred_id_t *cred));
+int g_delete_ctx_id PROTOTYPE((void **vdb, gss_ctx_id_t *ctx));
-int INTERFACE g_make_string_buffer PROTOTYPE((const char *str, gss_buffer_t buffer));
+int g_make_string_buffer PROTOTYPE((const char *str, gss_buffer_t buffer));
-int INTERFACE g_copy_OID_set PROTOTYPE((const gss_OID_set_desc * const in, gss_OID_set *out));
+int g_copy_OID_set PROTOTYPE((const gss_OID_set_desc * const in, gss_OID_set *out));
-int INTERFACE g_token_size PROTOTYPE((const_gss_OID mech, unsigned int body_size));
+int g_token_size PROTOTYPE((const_gss_OID mech, unsigned int body_size));
-void INTERFACE g_make_token_header PROTOTYPE((const_gss_OID mech, int body_size,
+void g_make_token_header PROTOTYPE((const_gss_OID mech, int body_size,
unsigned char **buf, int tok_type));
-int INTERFACE g_verify_token_header PROTOTYPE((const_gss_OID mech, int *body_size,
+int g_verify_token_header PROTOTYPE((const_gss_OID mech, int *body_size,
unsigned char **buf, int tok_type, int toksize));
-OM_uint32 INTERFACE g_display_major_status PROTOTYPE((OM_uint32 *minor_status,
+OM_uint32 g_display_major_status PROTOTYPE((OM_uint32 *minor_status,
OM_uint32 status_value,
int *message_context,
gss_buffer_t status_string));
-OM_uint32 INTERFACE INTERFACE g_display_com_err_status PROTOTYPE((OM_uint32 *minor_status,
+OM_uint32 g_display_com_err_status PROTOTYPE((OM_uint32 *minor_status,
OM_uint32 status_value,
gss_buffer_t status_string));
-char * INTERFACE g_canonicalize_host PROTOTYPE((char *hostname));
+char * g_canonicalize_host PROTOTYPE((char *hostname));
-char * INTERFACE g_strdup PROTOTYPE((char *str));
+char * g_strdup PROTOTYPE((char *str));
/** declarations of internal name mechanism functions **/
-OM_uint32 INTERFACE generic_gss_release_buffer
+OM_uint32 generic_gss_release_buffer
PROTOTYPE( (OM_uint32*, /* minor_status */
gss_buffer_t /* buffer */
));
-OM_uint32 INTERFACE generic_gss_release_oid_set
+OM_uint32 generic_gss_release_oid_set
PROTOTYPE( (OM_uint32*, /* minor_status */
gss_OID_set* /* set */
));
#include <gssapi/gssapi.h>
-extern const gss_OID_desc * const gss_nt_user_name;
-extern const gss_OID_desc * const gss_nt_machine_uid_name;
-extern const gss_OID_desc * const gss_nt_string_uid_name;
-extern const gss_OID_desc * const gss_nt_service_name;
+extern const gss_OID_desc FAR * const gss_nt_user_name;
+extern const gss_OID_desc FAR * const gss_nt_machine_uid_name;
+extern const gss_OID_desc FAR * const gss_nt_string_uid_name;
+extern const gss_OID_desc FAR * const gss_nt_service_name;
#endif /* _GSSAPI_GENERIC_H_ */
#include "gssapiP_generic.h"
-OM_uint32 INTERFACE generic_gss_release_buffer(minor_status, buffer)
+OM_uint32 generic_gss_release_buffer(minor_status, buffer)
OM_uint32 *minor_status;
gss_buffer_t buffer;
{
#include "gssapiP_generic.h"
-OM_uint32 INTERFACE generic_gss_release_oid_set(minor_status, set)
+OM_uint32 generic_gss_release_oid_set(minor_status, set)
OM_uint32 *minor_status;
gss_OID_set *set;
{
make sure that buffer is consistent (release'able) when this
function exits, no matter what the exit value */
-int INTERFACE g_make_string_buffer(str, buffer)
+int g_make_string_buffer(str, buffer)
const char *str;
gss_buffer_t buffer;
{
#include <ctype.h>
#include <string.h>
-char * INTERFACE
+char *
g_canonicalize_host(hostname)
char *hostname;
{
#include "gssapiP_generic.h"
#include <string.h>
-char * INTERFACE g_strdup(str)
+char * g_strdup(str)
char *str;
{
char *ret;
#include "gssapiP_generic.h"
-int INTERFACE
+int
g_copy_OID_set(in, out)
const gss_OID_set_desc * const in;
gss_OID_set *out;
/* returns the length of a token, given the mech oid and the body size */
-int INTERFACE g_token_size(mech, body_size)
+int g_token_size(mech, body_size)
const_gss_OID mech;
unsigned int body_size;
{
/* fills in a buffer with the token header. The buffer is assumed to
be the right size. buf is advanced past the token header */
-void INTERFACE g_make_token_header(mech, body_size, buf, tok_type)
+void g_make_token_header(mech, body_size, buf, tok_type)
const_gss_OID mech;
int body_size;
unsigned char **buf;
leaving buf advanced past the token header, and setting body_size
to the number of remaining bytes */
-int INTERFACE g_verify_token_header(mech, body_size, buf, tok_type, toksize)
+int g_verify_token_header(mech, body_size, buf, tok_type, toksize)
const_gss_OID mech;
int *body_size;
unsigned char **buf;
/* save */
-int INTERFACE g_save_name(void **vdb, gss_name_t *name)
+int g_save_name(void **vdb, gss_name_t *name)
{
return(g_save((DB **) vdb, V_NAME, (void *) name));
}
-int INTERFACE g_save_cred_id(void **vdb, gss_cred_id_t *cred)
+int g_save_cred_id(void **vdb, gss_cred_id_t *cred)
{
return(g_save((DB **) vdb, V_CRED_ID, (void *) cred));
}
-int INTERFACE g_save_ctx_id(void **vdb, gss_ctx_id_t *ctx)
+int g_save_ctx_id(void **vdb, gss_ctx_id_t *ctx)
{
return(g_save((DB **) vdb, V_CTX_ID, (void *) ctx));
}
/* validate */
-int INTERFACE g_validate_name(void **vdb, gss_name_t *name)
+int g_validate_name(void **vdb, gss_name_t *name)
{
return(g_validate((DB **) vdb, V_NAME, (void *) name));
}
-int INTERFACE g_validate_cred_id(void **vdb, gss_cred_id_t *cred)
+int g_validate_cred_id(void **vdb, gss_cred_id_t *cred)
{
return(g_validate((DB **) vdb, V_CRED_ID, (void *) cred));
}
-int INTERFACE g_validate_ctx_id(void **vdb, gss_ctx_id_t *ctx)
+int g_validate_ctx_id(void **vdb, gss_ctx_id_t *ctx)
{
return(g_validate((DB **) vdb, V_CTX_ID, (void *) ctx));
}
/* delete */
-int INTERFACE g_delete_name(void **vdb, gss_name_t *name)
+int g_delete_name(void **vdb, gss_name_t *name)
{
return(g_delete((DB **) vdb, V_NAME, (void *) name));
}
-int INTERFACE g_delete_cred_id(void **vdb, gss_cred_id_t *cred)
+int g_delete_cred_id(void **vdb, gss_cred_id_t *cred)
{
return(g_delete((DB **) vdb, V_CRED_ID, (void *) cred));
}
-int INTERFACE g_delete_ctx_id(void **vdb, gss_ctx_id_t *ctx)
+int g_delete_ctx_id(void **vdb, gss_ctx_id_t *ctx)
{
return(g_delete((DB **) vdb, V_CTX_ID, (void *) ctx));
}
/* save */
-int INTERFACE g_save_name(vdb, name)
+int g_save_name(vdb, name)
void **vdb;
gss_name_t *name;
{
return 1;
}
-int INTERFACE g_save_cred_id(vdb, cred)
+int g_save_cred_id(vdb, cred)
void **vdb;
gss_cred_id_t *cred;
{
return 1;
}
-int INTERFACE g_save_ctx_id(vdb, ctx)
+int g_save_ctx_id(vdb, ctx)
void **vdb;
gss_ctx_id_t *ctx;
{
/* validate */
-int INTERFACE g_validate_name(vdb, name)
+int g_validate_name(vdb, name)
void **vdb;
gss_name_t *name;
{
return 1;
}
-int INTERFACE g_validate_cred_id(vdb, cred)
+int g_validate_cred_id(vdb, cred)
void **vdb;
gss_cred_id_t *cred;
{
return 1;
}
-int INTERFACE g_validate_ctx_id(vdb, ctx)
+int g_validate_ctx_id(vdb, ctx)
void **vdb;
gss_ctx_id_t *ctx;
{
/* delete */
-int INTERFACE g_delete_name(vdb, name)
+int g_delete_name(vdb, name)
void **vdb;
gss_name_t *name;
{
return 1;
}
-int INTERFACE g_delete_cred_id(vdb, cred)
+int g_delete_cred_id(vdb, cred)
void **vdb;
gss_cred_id_t *cred;
{
return 1;
}
-int INTERFACE g_delete_ctx_id(vdb, ctx)
+int g_delete_ctx_id(vdb, ctx)
void **vdb;
gss_ctx_id_t *ctx;
{
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+ * *.h added FAR to pointers visible at to the world.
+ * gssapi_e.c: __STDC__ conditional also checks the _WINDOWS define.
+
Thu Mar 30 16:00:30 1995 Keith Vetter (keithv@fusion.com)
* accept_sec_context.c: fixed wrong level of indirection on a
#include <krb5/rsa-md5.h>
#include <memory.h>
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_accept_sec_context(context, minor_status, context_handle,
verifier_cred_handle, input_token,
input_chan_bindings, src_name, mech_type,
}
/*ARGSUSED*/
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_acquire_cred(context, minor_status, desired_name, time_req,
desired_mechs, cred_usage, output_cred_handle,
actual_mechs, time_rec)
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_compare_name(context, minor_status, name1, name2, name_equal)
krb5_context context;
OM_uint32 *minor_status;
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_context_time(context, minor_status, context_handle, time_rec)
krb5_context context;
OM_uint32 *minor_status;
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_delete_sec_context(context, minor_status, context_handle, output_token)
krb5_context context;
OM_uint32 *minor_status;
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_display_name(context, minor_status, input_name, output_name_buffer,
output_name_type)
krb5_context context;
/**/
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_display_status(context, minor_status, status_value, status_type,
mech_type, message_context, status_string)
krb5_context context;
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
gss_krb5_get_tkt_flags(minor_status, context_handle, ticket_flags)
OM_uint32 *minor_status;
gss_ctx_id_t context_handle;
/** helper functions **/
-OM_uint32 INTERFACE kg_get_defcred
+OM_uint32 kg_get_defcred
PROTOTYPE((OM_uint32 *minor_status,
gss_cred_id_t *cred));
-OM_uint32 INTERFACE kg_release_defcred PROTOTYPE((OM_uint32 *minor_status));
+OM_uint32 kg_release_defcred PROTOTYPE((OM_uint32 *minor_status));
-krb5_error_code INTERFACE kg_checksum_channel_bindings
+krb5_error_code kg_checksum_channel_bindings
PROTOTYPE((gss_channel_bindings_t cb,
krb5_checksum *cksum,
int bigend));
-krb5_error_code INTERFACE kg_make_seq_num PROTOTYPE((krb5_gss_enc_desc *ed,
+krb5_error_code kg_make_seq_num PROTOTYPE((krb5_gss_enc_desc *ed,
int direction, krb5_int32 seqnum, unsigned char *cksum,
unsigned char *buf));
-krb5_error_code INTERFACE kg_make_seed PROTOTYPE((krb5_keyblock *key,
+krb5_error_code kg_make_seed PROTOTYPE((krb5_keyblock *key,
unsigned char *seed));
-int INTERFACE kg_confounder_size PROTOTYPE((krb5_gss_enc_desc *ed));
+int kg_confounder_size PROTOTYPE((krb5_gss_enc_desc *ed));
-krb5_error_code INTERFACE kg_make_confounder PROTOTYPE((krb5_gss_enc_desc *ed,
+krb5_error_code kg_make_confounder PROTOTYPE((krb5_gss_enc_desc *ed,
unsigned char *buf));
-int INTERFACE kg_encrypt_size PROTOTYPE((krb5_gss_enc_desc *ed, int n));
+int kg_encrypt_size PROTOTYPE((krb5_gss_enc_desc *ed, int n));
-krb5_error_code INTERFACE kg_encrypt PROTOTYPE((krb5_gss_enc_desc *ed,
+krb5_error_code kg_encrypt PROTOTYPE((krb5_gss_enc_desc *ed,
krb5_pointer iv, krb5_pointer in, krb5_pointer out, int length));
-krb5_error_code INTERFACE kg_decrypt PROTOTYPE((krb5_gss_enc_desc *ed,
+krb5_error_code kg_decrypt PROTOTYPE((krb5_gss_enc_desc *ed,
krb5_pointer iv, krb5_pointer in, krb5_pointer out, int length));
-OM_uint32 INTERFACE kg_seal PROTOTYPE((OM_uint32 *minor_status,
+OM_uint32 kg_seal PROTOTYPE((OM_uint32 *minor_status,
gss_ctx_id_t context_handle,
int conf_req_flag,
int qop_req,
gss_buffer_t output_message_buffer,
int toktype));
-OM_uint32 INTERFACE kg_unseal PROTOTYPE((OM_uint32 *minor_status,
+OM_uint32 kg_unseal PROTOTYPE((OM_uint32 *minor_status,
gss_ctx_id_t context_handle,
gss_buffer_t input_token_buffer,
gss_buffer_t message_buffer,
/** declarations of internal name mechanism functions **/
-OM_uint32 INTERFACE krb5_gss_acquire_cred
+OM_uint32 krb5_gss_acquire_cred
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_name_t, /* desired_name */
OM_uint32* /* time_rec */
));
-OM_uint32 INTERFACE krb5_gss_release_cred
+OM_uint32 krb5_gss_release_cred
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_cred_id_t* /* cred_handle */
));
-OM_uint32 INTERFACE krb5_gss_init_sec_context
+OM_uint32 krb5_gss_init_sec_context
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_cred_id_t, /* claimant_cred_handle */
OM_uint32* /* time_rec */
));
-OM_uint32 INTERFACE krb5_gss_accept_sec_context
+OM_uint32 krb5_gss_accept_sec_context
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_ctx_id_t*, /* context_handle */
gss_cred_id_t* /* delegated_cred_handle */
));
-OM_uint32 INTERFACE krb5_gss_process_context_token
+OM_uint32 krb5_gss_process_context_token
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_ctx_id_t, /* context_handle */
gss_buffer_t /* token_buffer */
));
-OM_uint32 INTERFACE krb5_gss_delete_sec_context
+OM_uint32 krb5_gss_delete_sec_context
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_ctx_id_t*, /* context_handle */
gss_buffer_t /* output_token */
));
-OM_uint32 INTERFACE krb5_gss_context_time
+OM_uint32 krb5_gss_context_time
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_ctx_id_t, /* context_handle */
OM_uint32* /* time_rec */
));
-OM_uint32 INTERFACE krb5_gss_sign
+OM_uint32 krb5_gss_sign
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_ctx_id_t, /* context_handle */
gss_buffer_t /* message_token */
));
-OM_uint32 INTERFACE krb5_gss_verify
+OM_uint32 krb5_gss_verify
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_ctx_id_t, /* context_handle */
int* /* qop_state */
));
-OM_uint32 INTERFACE krb5_gss_seal
+OM_uint32 krb5_gss_seal
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_ctx_id_t, /* context_handle */
gss_buffer_t /* output_message_buffer */
));
-OM_uint32 INTERFACE krb5_gss_unseal
+OM_uint32 krb5_gss_unseal
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_ctx_id_t, /* context_handle */
int* /* qop_state */
));
-OM_uint32 INTERFACE krb5_gss_display_status
+OM_uint32 krb5_gss_display_status
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
OM_uint32, /* status_value */
gss_buffer_t /* status_string */
));
-OM_uint32 INTERFACE krb5_gss_indicate_mechs
+OM_uint32 krb5_gss_indicate_mechs
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_OID_set* /* mech_set */
));
-OM_uint32 INTERFACE krb5_gss_compare_name
+OM_uint32 krb5_gss_compare_name
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_name_t, /* name1 */
int* /* name_equal */
));
-OM_uint32 INTERFACE krb5_gss_display_name
+OM_uint32 krb5_gss_display_name
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_name_t, /* input_name */
gss_OID* /* output_name_type */
));
-OM_uint32 INTERFACE krb5_gss_import_name
+OM_uint32 krb5_gss_import_name
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_buffer_t, /* input_name_buffer */
gss_name_t* /* output_name */
));
-OM_uint32 INTERFACE krb5_gss_release_name
+OM_uint32 krb5_gss_release_name
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_name_t* /* input_name */
));
-OM_uint32 INTERFACE krb5_gss_inquire_cred
+OM_uint32 krb5_gss_inquire_cred
PROTOTYPE( (krb5_context,
OM_uint32 *, /* minor_status */
gss_cred_id_t, /* cred_handle */
gss_OID_set * /* mechanisms */
));
-OM_uint32 INTERFACE krb5_gss_inquire_context
+OM_uint32 krb5_gss_inquire_context
PROTOTYPE( (krb5_context,
OM_uint32*, /* minor_status */
gss_ctx_id_t, /* context_handle */
int* /* locally_initiated */
));
-OM_uint32 INTERFACE kg_get_context();
+OM_uint32 kg_get_context();
#endif /* _GSSAPIP_KRB5_H_ */
/* XXX what happens when the default credentials expire or are invalidated? */
-OM_uint32 INTERFACE
+OM_uint32
kg_get_defcred(minor_status, cred)
OM_uint32 *minor_status;
gss_cred_id_t *cred;
return(GSS_S_COMPLETE);
}
-OM_uint32 INTERFACE
+OM_uint32
kg_release_defcred(minor_status)
OM_uint32 *minor_status;
{
return(krb5_gss_release_cred(kg_context, minor_status, &defcred));
}
-OM_uint32 INTERFACE
+OM_uint32
kg_get_context()
{
if (kg_context)
#define gss_krb5_nt_machine_uid_name gss_nt_machine_uid_name
#define gss_krb5_nt_string_uid_name gss_nt_string_uid_name
-OM_uint32 INTERFACE gss_krb5_get_tkt_flags
+OM_uint32 gss_krb5_get_tkt_flags
PROTOTYPE((OM_uint32 *minor_status,
gss_ctx_id_t context_handle,
krb5_flags *ticket_flags));
* GSS_S_FAILURE if memory allocation fails
*/
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_import_name(context, minor_status, input_name_buffer,
input_name_type, output_name)
krb5_context context;
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_indicate_mechs(context, minor_status, mech_set)
krb5_context context;
OM_uint32 *minor_status;
return(0);
}
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_init_sec_context(context, minor_status, claimant_cred_handle,
context_handle, target_name, mech_type,
req_flags, time_req, input_chan_bindings,
gss_buffer_desc token;
int i;
/* Remove this when server is fixed and this function goes away */
-krb5_error_code INTERFACE krb5_auth_con_setkey ();
+krb5_error_code krb5_auth_con_setkey ();
/* set up return values so they can be "freed" successfully */
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_inquire_context(context, minor_status, context_handle, initiator_name,
acceptor_name, lifetime_rec, mech_type, ret_flags,
locally_initiated)
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_inquire_cred(context, minor_status, cred_handle, name, lifetime_ret,
cred_usage, mechanisms)
krb5_context context;
/* if signonly is true, ignore conf_req, conf_state,
and do not encode the ENC_TYPE, MSG_LENGTH, or MSG_TEXT fields */
-OM_uint32 INTERFACE
+OM_uint32
kg_seal(minor_status, context_handle, conf_req_flag, qop_req,
input_message_buffer, conf_state, output_message_buffer, toktype)
OM_uint32 *minor_status;
conf_state is only valid if SEAL.
*/
-OM_uint32 INTERFACE
+OM_uint32
kg_unseal(minor_status, context_handle, input_token_buffer, message_buffer,
conf_state, qop_state, toktype)
OM_uint32 *minor_status;
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_process_context_token(context, minor_status, context_handle,
token_buffer)
krb5_context context;
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_release_cred(context, minor_status, cred_handle)
krb5_context context;
OM_uint32 *minor_status;
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_release_name(context, minor_status, input_name)
krb5_context context;
OM_uint32 *minor_status;
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_seal(context, minor_status, context_handle, conf_req_flag,
qop_req, input_message_buffer, conf_state,
output_message_buffer)
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_sign(context, minor_status, context_handle,
qop_req, message_buffer,
message_token)
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_unseal(context, minor_status, context_handle,
input_message_buffer, output_message_buffer,
conf_state, qop_state)
#include "gssapiP_krb5.h"
#include <memory.h>
-krb5_error_code INTERFACE
+krb5_error_code
kg_checksum_channel_bindings(cb, cksum, bigend)
gss_channel_bindings_t cb;
krb5_checksum *cksum;
static unsigned char zeros[8] = {0,0,0,0,0,0,0,0};
-int INTERFACE
+int
kg_confounder_size(ed)
krb5_gss_enc_desc *ed;
{
return(ed->eblock.crypto_entry->block_length);
}
-krb5_error_code INTERFACE
+krb5_error_code
kg_make_confounder(ed, buf)
krb5_gss_enc_desc *ed;
unsigned char *buf;
return(krb5_random_confounder( ed->eblock.crypto_entry->block_length, buf));
}
-int INTERFACE
+int
kg_encrypt_size(ed, n)
krb5_gss_enc_desc *ed;
int n;
return(krb5_encrypt_size(n, ed->eblock.crypto_entry));
}
-krb5_error_code INTERFACE
+krb5_error_code
kg_encrypt(ed, iv, in, out, length)
krb5_gss_enc_desc *ed;
krb5_pointer iv;
/* length is the length of the cleartext. */
-krb5_error_code INTERFACE
+krb5_error_code
kg_decrypt(ed, iv, in, out, length)
krb5_gss_enc_desc *ed;
krb5_pointer iv;
static unsigned char zeros[16] = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0};
-krb5_error_code INTERFACE
+krb5_error_code
kg_make_seed(key, seed)
krb5_keyblock *key;
unsigned char *seed;
#include "gssapiP_krb5.h"
-krb5_error_code INTERFACE
+krb5_error_code
kg_make_seq_num(ed, direction, seqnum, cksum, buf)
krb5_gss_enc_desc *ed;
int direction;
#include "gssapiP_krb5.h"
-OM_uint32 INTERFACE
+OM_uint32
krb5_gss_verify(context, minor_status, context_handle,
message_buffer, token_buffer,
qop_state)
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+
Wed Mar 22 09:39:55 1995 <tytso@rsx-11.mit.edu>
* asn1_k_decode.c (setup, next_tag, apptag, get_field_body,
time_t gmt_mktime PROTOTYPE((struct tm *));
-asn1_error_code INTERFACE asn1_decode_integer(buf, val)
+asn1_error_code asn1_decode_integer(buf, val)
asn1buf * buf;
long * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_unsigned_integer(buf, val)
+asn1_error_code asn1_decode_unsigned_integer(buf, val)
asn1buf * buf;
unsigned long * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_octetstring(buf, retlen, val)
+asn1_error_code asn1_decode_octetstring(buf, retlen, val)
asn1buf * buf;
int * retlen;
asn1_octet ** val;
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_charstring(buf, retlen, val)
+asn1_error_code asn1_decode_charstring(buf, retlen, val)
asn1buf * buf;
int * retlen;
char ** val;
}
-asn1_error_code INTERFACE asn1_decode_generalstring(buf, retlen, val)
+asn1_error_code asn1_decode_generalstring(buf, retlen, val)
asn1buf * buf;
int * retlen;
char ** val;
}
-asn1_error_code INTERFACE asn1_decode_null(buf)
+asn1_error_code asn1_decode_null(buf)
asn1buf * buf;
{
setup();
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_printablestring(buf, retlen, val)
+asn1_error_code asn1_decode_printablestring(buf, retlen, val)
asn1buf * buf;
int * retlen;
char ** val;
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_ia5string(buf, retlen, val)
+asn1_error_code asn1_decode_ia5string(buf, retlen, val)
asn1buf * buf;
int * retlen;
char ** val;
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_generaltime(buf, val)
+asn1_error_code asn1_decode_generaltime(buf, val)
asn1buf * buf;
time_t * val;
{
Returns ENOMEM if memory is exhausted.
Returns asn1 errors. */
-asn1_error_code INTERFACE asn1_decode_integer
+asn1_error_code asn1_decode_integer
PROTOTYPE((asn1buf *buf, long *val));
-asn1_error_code INTERFACE asn1_decode_unsigned_integer
+asn1_error_code asn1_decode_unsigned_integer
PROTOTYPE((asn1buf *buf, unsigned long *val));
-asn1_error_code INTERFACE asn1_decode_null
+asn1_error_code asn1_decode_null
PROTOTYPE((asn1buf *buf));
-asn1_error_code INTERFACE asn1_decode_octetstring
+asn1_error_code asn1_decode_octetstring
PROTOTYPE((asn1buf *buf, int *retlen, asn1_octet **val));
-asn1_error_code INTERFACE asn1_decode_generalstring
+asn1_error_code asn1_decode_generalstring
PROTOTYPE((asn1buf *buf, int *retlen, char **val));
-asn1_error_code INTERFACE asn1_decode_charstring
+asn1_error_code asn1_decode_charstring
PROTOTYPE((asn1buf *buf, int *retlen, char **val));
/* Note: A charstring is a special hack to account for the fact that
krb5 structures store some OCTET STRING values in krb5_octet
PROTOTYPE((which use char arrays).
From the ASN.1 point of view, the two string types are the same,
only the receptacles differ. */
-asn1_error_code INTERFACE asn1_decode_printablestring
+asn1_error_code asn1_decode_printablestring
PROTOTYPE((asn1buf *buf, int *retlen, char **val));
-asn1_error_code INTERFACE asn1_decode_ia5string
+asn1_error_code asn1_decode_ia5string
PROTOTYPE((asn1buf *buf, int *retlen, char **val));
-asn1_error_code INTERFACE asn1_decode_generaltime
+asn1_error_code asn1_decode_generaltime
PROTOTYPE((asn1buf *buf, time_t *val));
#endif
#include "asn1_encode.h"
#include "asn1_make.h"
-asn1_error_code INTERFACE asn1_encode_integer(buf, val, retlen)
+asn1_error_code asn1_encode_integer(buf, val, retlen)
asn1buf * buf;
const long val;
int * retlen;
return 0;
}
-asn1_error_code INTERFACE asn1_encode_unsigned_integer(buf, val, retlen)
+asn1_error_code asn1_encode_unsigned_integer(buf, val, retlen)
asn1buf * buf;
const unsigned long val;
int * retlen;
return 0;
}
-asn1_error_code INTERFACE asn1_encode_octetstring(buf, len, val, retlen)
+asn1_error_code asn1_encode_octetstring(buf, len, val, retlen)
asn1buf * buf;
const int len;
const asn1_octet * val;
return 0;
}
-asn1_error_code INTERFACE asn1_encode_charstring(buf, len, val, retlen)
+asn1_error_code asn1_encode_charstring(buf, len, val, retlen)
asn1buf * buf;
const int len;
const char * val;
return 0;
}
-asn1_error_code INTERFACE asn1_encode_null(buf, retlen)
+asn1_error_code asn1_encode_null(buf, retlen)
asn1buf * buf;
int * retlen;
{
return 0;
}
-asn1_error_code INTERFACE asn1_encode_printablestring(buf, len, val, retlen)
+asn1_error_code asn1_encode_printablestring(buf, len, val, retlen)
asn1buf * buf;
const int len;
const char * val;
return 0;
}
-asn1_error_code INTERFACE asn1_encode_ia5string(buf, len, val, retlen)
+asn1_error_code asn1_encode_ia5string(buf, len, val, retlen)
asn1buf * buf;
const int len;
const char * val;
return 0;
}
-asn1_error_code INTERFACE asn1_encode_generaltime(buf, val, retlen)
+asn1_error_code asn1_encode_generaltime(buf, val, retlen)
asn1buf * buf;
const time_t val;
int * retlen;
return 0;
}
-asn1_error_code INTERFACE asn1_encode_generalstring(buf, len, val, retlen)
+asn1_error_code asn1_encode_generalstring(buf, len, val, retlen)
asn1buf * buf;
const int len;
const char * val;
asn1_encode_generalstring
*/
-asn1_error_code INTERFACE asn1_encode_integer
+asn1_error_code asn1_encode_integer
PROTOTYPE((asn1buf *buf, const long val, int *retlen));
/* requires *buf is allocated
modifies *buf, *retlen
Returns ENOMEM to signal an unsuccesful attempt
to expand the buffer. */
-asn1_error_code INTERFACE asn1_encode_unsigned_integer
+asn1_error_code asn1_encode_unsigned_integer
PROTOTYPE((asn1buf *buf, const unsigned long val, int *retlen));
/* requires *buf is allocated
modifies *buf, *retlen
Returns ENOMEM to signal an unsuccesful attempt
to expand the buffer. */
-asn1_error_code INTERFACE asn1_encode_octetstring
+asn1_error_code asn1_encode_octetstring
PROTOTYPE((asn1buf *buf,
const int len, const asn1_octet *val,
int *retlen));
Returns ENOMEM to signal an unsuccesful attempt
to expand the buffer. */
-asn1_error_code INTERFACE asn1_encode_charstring
+asn1_error_code asn1_encode_charstring
PROTOTYPE((asn1buf *buf,
const int len, const char *val,
int *retlen));
Returns ENOMEM to signal an unsuccesful attempt
to expand the buffer. */
-asn1_error_code INTERFACE asn1_encode_null
+asn1_error_code asn1_encode_null
PROTOTYPE((asn1buf *buf, int *retlen));
/* requires *buf is allocated
modifies *buf, *retlen
Returns ENOMEM to signal an unsuccesful attempt
to expand the buffer. */
-asn1_error_code INTERFACE asn1_encode_printablestring
+asn1_error_code asn1_encode_printablestring
PROTOTYPE((asn1buf *buf,
const int len, const char *val,
int *retlen));
Returns ENOMEM to signal an unsuccesful attempt
to expand the buffer. */
-asn1_error_code INTERFACE asn1_encode_ia5string
+asn1_error_code asn1_encode_ia5string
PROTOTYPE((asn1buf *buf,
const int len, const char *val,
int *retlen));
Returns ENOMEM to signal an unsuccesful attempt
to expand the buffer. */
-asn1_error_code INTERFACE asn1_encode_generaltime
+asn1_error_code asn1_encode_generaltime
PROTOTYPE((asn1buf *buf, const time_t val, int *retlen));
/* requires *buf is allocated
modifies *buf, *retlen
to expand the buffer.
Note: The encoding of GeneralizedTime is YYYYMMDDhhmmZ */
-asn1_error_code INTERFACE asn1_encode_generalstring
+asn1_error_code asn1_encode_generalstring
PROTOTYPE((asn1buf *buf,
const int len, const char *val,
int *retlen));
#include "asn1_get.h"
-asn1_error_code INTERFACE asn1_get_tag(buf, class, construction, tagnum, retlen)
+asn1_error_code asn1_get_tag(buf, class, construction, tagnum, retlen)
asn1buf * buf;
asn1_class * class;
asn1_construction * construction;
return 0;
}
-asn1_error_code INTERFACE asn1_get_sequence(buf, retlen)
+asn1_error_code asn1_get_sequence(buf, retlen)
asn1buf * buf;
int * retlen;
{
/****************************************************************/
/* Private Procedures */
-asn1_error_code INTERFACE asn1_get_id(buf, class, construction, tagnum)
+asn1_error_code asn1_get_id(buf, class, construction, tagnum)
asn1buf * buf;
asn1_class * class;
asn1_construction * construction;
return 0;
}
-asn1_error_code INTERFACE asn1_get_length(buf, retlen)
+asn1_error_code asn1_get_length(buf, retlen)
asn1buf * buf;
int * retlen;
{
#include "krbasn1.h"
#include "asn1buf.h"
-asn1_error_code INTERFACE asn1_get_tag
+asn1_error_code asn1_get_tag
PROTOTYPE((asn1buf *buf,
asn1_class *class,
asn1_construction *construction,
*tagnum is set to ASN1_TAGNUM_CEILING.
Returns ASN1_OVERRUN if *buf is exhausted during the parse. */
-asn1_error_code INTERFACE asn1_get_sequence
+asn1_error_code asn1_get_sequence
PROTOTYPE((asn1buf *buf, int *retlen));
/* requires *buf is allocated
effects Decodes a tag from *buf and returns ASN1_BAD_ID if it
/****************************************************************/
/* Private Procedures */
-asn1_error_code INTERFACE asn1_get_id
+asn1_error_code asn1_get_id
PROTOTYPE((asn1buf *buf,
asn1_class *class,
asn1_construction *construction,
are returned in *construction and *tagnum, respectively.
Returns ASN1_OVERRUN if *buf is exhausted. */
-asn1_error_code INTERFACE asn1_get_length
+asn1_error_code asn1_get_length
PROTOTYPE((asn1buf *buf, int *retlen));
/* requires *buf is allocated
effects Decodes the group of length octets at *buf's
/* scalars */
-asn1_error_code INTERFACE asn1_decode_kerberos_time(buf, val)
+asn1_error_code asn1_decode_kerberos_time(buf, val)
asn1buf * buf;
krb5_timestamp * val;
{
}
#define integer_convert(fname,ktype)\
-asn1_error_code INTERFACE fname(buf, val)\
+asn1_error_code fname(buf, val)\
asn1buf * buf;\
ktype * val;\
{\
return 0;\
}
#define unsigned_integer_convert(fname,ktype)\
-asn1_error_code INTERFACE fname(buf, val)\
+asn1_error_code fname(buf, val)\
asn1buf * buf;\
ktype * val;\
{\
unsigned_integer_convert(asn1_decode_ui_2,krb5_ui_2)
unsigned_integer_convert(asn1_decode_ui_4,krb5_ui_4)
-asn1_error_code INTERFACE asn1_decode_msgtype(buf, val)
+asn1_error_code asn1_decode_msgtype(buf, val)
asn1buf * buf;
krb5_msgtype * val;
{
/* structures */
-asn1_error_code INTERFACE asn1_decode_realm(buf, val)
+asn1_error_code asn1_decode_realm(buf, val)
asn1buf * buf;
krb5_principal * val;
{
&((*val)->realm.data));
}
-asn1_error_code INTERFACE asn1_decode_principal_name(buf, val)
+asn1_error_code asn1_decode_principal_name(buf, val)
asn1buf * buf;
krb5_principal * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_checksum(buf, val)
+asn1_error_code asn1_decode_checksum(buf, val)
asn1buf * buf;
krb5_checksum * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_encryption_key(buf, val)
+asn1_error_code asn1_decode_encryption_key(buf, val)
asn1buf * buf;
krb5_keyblock * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_encrypted_data(buf, val)
+asn1_error_code asn1_decode_encrypted_data(buf, val)
asn1buf * buf;
krb5_enc_data * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_krb5_flags(buf, val)
+asn1_error_code asn1_decode_krb5_flags(buf, val)
asn1buf * buf;
krb5_flags * val;
{
return 0;
}
-asn1_error_code INTERFACE asn1_decode_ticket_flags(buf, val)
+asn1_error_code asn1_decode_ticket_flags(buf, val)
asn1buf * buf;
krb5_flags * val;
{ return asn1_decode_krb5_flags(buf,val); }
-asn1_error_code INTERFACE asn1_decode_ap_options(buf, val)
+asn1_error_code asn1_decode_ap_options(buf, val)
asn1buf * buf;
krb5_flags * val;
{ return asn1_decode_krb5_flags(buf,val); }
-asn1_error_code INTERFACE asn1_decode_kdc_options(buf, val)
+asn1_error_code asn1_decode_kdc_options(buf, val)
asn1buf * buf;
krb5_flags * val;
{ return asn1_decode_krb5_flags(buf,val); }
-asn1_error_code INTERFACE asn1_decode_transited_encoding(buf, val)
+asn1_error_code asn1_decode_transited_encoding(buf, val)
asn1buf * buf;
krb5_transited * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_enc_kdc_rep_part(buf, val)
+asn1_error_code asn1_decode_enc_kdc_rep_part(buf, val)
asn1buf * buf;
krb5_enc_kdc_rep_part * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_ticket(buf, val)
+asn1_error_code asn1_decode_ticket(buf, val)
asn1buf * buf;
krb5_ticket * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_kdc_req(buf, val)
+asn1_error_code asn1_decode_kdc_req(buf, val)
asn1buf * buf;
krb5_kdc_req * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_kdc_req_body(buf, val)
+asn1_error_code asn1_decode_kdc_req_body(buf, val)
asn1buf * buf;
krb5_kdc_req * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_krb_safe_body(buf, val)
+asn1_error_code asn1_decode_krb_safe_body(buf, val)
asn1buf * buf;
krb5_safe * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_host_address(buf, val)
+asn1_error_code asn1_decode_host_address(buf, val)
asn1buf * buf;
krb5_address * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_kdc_rep(buf, val)
+asn1_error_code asn1_decode_kdc_rep(buf, val)
asn1buf * buf;
krb5_kdc_rep * val;
{
cleanup()
-asn1_error_code INTERFACE asn1_decode_authorization_data(buf, val)
+asn1_error_code asn1_decode_authorization_data(buf, val)
asn1buf * buf;
krb5_authdata *** val;
{
decode_array_body(krb5_authdata,asn1_decode_authdata_elt);
}
-asn1_error_code INTERFACE asn1_decode_authdata_elt(buf, val)
+asn1_error_code asn1_decode_authdata_elt(buf, val)
asn1buf * buf;
krb5_authdata * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_host_addresses(buf, val)
+asn1_error_code asn1_decode_host_addresses(buf, val)
asn1buf * buf;
krb5_address *** val;
{
decode_array_body(krb5_address,asn1_decode_host_address);
}
-asn1_error_code INTERFACE asn1_decode_sequence_of_ticket(buf, val)
+asn1_error_code asn1_decode_sequence_of_ticket(buf, val)
asn1buf * buf;
krb5_ticket *** val;
{
decode_array_body(krb5_ticket,asn1_decode_ticket);
}
-asn1_error_code INTERFACE asn1_decode_sequence_of_krb_cred_info(buf, val)
+asn1_error_code asn1_decode_sequence_of_krb_cred_info(buf, val)
asn1buf * buf;
krb5_cred_info *** val;
{
decode_array_body(krb5_cred_info,asn1_decode_krb_cred_info);
}
-asn1_error_code INTERFACE asn1_decode_krb_cred_info(buf, val)
+asn1_error_code asn1_decode_krb_cred_info(buf, val)
asn1buf * buf;
krb5_cred_info * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_sequence_of_pa_data(buf, val)
+asn1_error_code asn1_decode_sequence_of_pa_data(buf, val)
asn1buf * buf;
krb5_pa_data *** val;
{
decode_array_body(krb5_pa_data,asn1_decode_pa_data);
}
-asn1_error_code INTERFACE asn1_decode_pa_data(buf, val)
+asn1_error_code asn1_decode_pa_data(buf, val)
asn1buf * buf;
krb5_pa_data * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_last_req(buf, val)
+asn1_error_code asn1_decode_last_req(buf, val)
asn1buf * buf;
krb5_last_req_entry *** val;
{
decode_array_body(krb5_last_req_entry,asn1_decode_last_req_entry);
}
-asn1_error_code INTERFACE asn1_decode_last_req_entry(buf, val)
+asn1_error_code asn1_decode_last_req_entry(buf, val)
asn1buf * buf;
krb5_last_req_entry * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_sequence_of_enctype(buf, num, val)
+asn1_error_code asn1_decode_sequence_of_enctype(buf, num, val)
asn1buf * buf;
int * num;
krb5_enctype ** val;
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_passwdsequence(buf, val)
+asn1_error_code asn1_decode_passwdsequence(buf, val)
asn1buf * buf;
passwd_phrase_element * val;
{
cleanup();
}
-asn1_error_code INTERFACE asn1_decode_sequence_of_passwdsequence(buf, val)
+asn1_error_code asn1_decode_sequence_of_passwdsequence(buf, val)
asn1buf * buf;
passwd_phrase_element *** val;
{
the bounds of *buf */
/* scalars */
-asn1_error_code INTERFACE asn1_decode_int
+asn1_error_code asn1_decode_int
PROTOTYPE((asn1buf *buf, int *val));
-asn1_error_code INTERFACE asn1_decode_int32
+asn1_error_code asn1_decode_int32
PROTOTYPE((asn1buf *buf, krb5_int32 *val));
-asn1_error_code INTERFACE asn1_decode_kvno
+asn1_error_code asn1_decode_kvno
PROTOTYPE((asn1buf *buf, krb5_kvno *val));
-asn1_error_code INTERFACE asn1_decode_keytype
+asn1_error_code asn1_decode_keytype
PROTOTYPE((asn1buf *buf, krb5_keytype *val));
-asn1_error_code INTERFACE asn1_decode_msgtype
+asn1_error_code asn1_decode_msgtype
PROTOTYPE((asn1buf *buf, krb5_msgtype *val));
-asn1_error_code INTERFACE asn1_decode_cksumtype
+asn1_error_code asn1_decode_cksumtype
PROTOTYPE((asn1buf *buf, krb5_cksumtype *val));
-asn1_error_code INTERFACE asn1_decode_enctype
+asn1_error_code asn1_decode_enctype
PROTOTYPE((asn1buf *buf, krb5_enctype *val));
-asn1_error_code INTERFACE asn1_decode_octet
+asn1_error_code asn1_decode_octet
PROTOTYPE((asn1buf *buf, krb5_octet *val));
-asn1_error_code INTERFACE asn1_decode_addrtype
+asn1_error_code asn1_decode_addrtype
PROTOTYPE((asn1buf *buf, krb5_addrtype *val));
-asn1_error_code INTERFACE asn1_decode_authdatatype
+asn1_error_code asn1_decode_authdatatype
PROTOTYPE((asn1buf *buf, krb5_authdatatype *val));
-asn1_error_code INTERFACE asn1_decode_ui_2
+asn1_error_code asn1_decode_ui_2
PROTOTYPE((asn1buf *buf, krb5_ui_2 *val));
-asn1_error_code INTERFACE asn1_decode_ui_4
+asn1_error_code asn1_decode_ui_4
PROTOTYPE((asn1buf *buf, krb5_ui_4 *val));
-asn1_error_code INTERFACE asn1_decode_kerberos_time
+asn1_error_code asn1_decode_kerberos_time
PROTOTYPE((asn1buf *buf, krb5_timestamp *val));
/* structures */
-asn1_error_code INTERFACE asn1_decode_realm
+asn1_error_code asn1_decode_realm
PROTOTYPE((asn1buf *buf, krb5_principal *val));
-asn1_error_code INTERFACE asn1_decode_principal_name
+asn1_error_code asn1_decode_principal_name
PROTOTYPE((asn1buf *buf, krb5_principal *val));
-asn1_error_code INTERFACE asn1_decode_checksum
+asn1_error_code asn1_decode_checksum
PROTOTYPE((asn1buf *buf, krb5_checksum *val));
-asn1_error_code INTERFACE asn1_decode_encryption_key
+asn1_error_code asn1_decode_encryption_key
PROTOTYPE((asn1buf *buf, krb5_keyblock *val));
-asn1_error_code INTERFACE asn1_decode_encrypted_data
+asn1_error_code asn1_decode_encrypted_data
PROTOTYPE((asn1buf *buf, krb5_enc_data *val));
-asn1_error_code INTERFACE asn1_decode_ticket_flags
+asn1_error_code asn1_decode_ticket_flags
PROTOTYPE((asn1buf *buf, krb5_flags *val));
-asn1_error_code INTERFACE asn1_decode_transited_encoding
+asn1_error_code asn1_decode_transited_encoding
PROTOTYPE((asn1buf *buf, krb5_transited *val));
-asn1_error_code INTERFACE asn1_decode_enc_kdc_rep_part
+asn1_error_code asn1_decode_enc_kdc_rep_part
PROTOTYPE((asn1buf *buf, krb5_enc_kdc_rep_part *val));
-asn1_error_code INTERFACE asn1_decode_krb5_flags
+asn1_error_code asn1_decode_krb5_flags
PROTOTYPE((asn1buf *buf, krb5_flags *val));
-asn1_error_code INTERFACE asn1_decode_ap_options
+asn1_error_code asn1_decode_ap_options
PROTOTYPE((asn1buf *buf, krb5_flags *val));
-asn1_error_code INTERFACE asn1_decode_kdc_options
+asn1_error_code asn1_decode_kdc_options
PROTOTYPE((asn1buf *buf, krb5_flags *val));
-asn1_error_code INTERFACE asn1_decode_ticket
+asn1_error_code asn1_decode_ticket
PROTOTYPE((asn1buf *buf, krb5_ticket *val));
-asn1_error_code INTERFACE asn1_decode_kdc_req
+asn1_error_code asn1_decode_kdc_req
PROTOTYPE((asn1buf *buf, krb5_kdc_req *val));
-asn1_error_code INTERFACE asn1_decode_kdc_req_body
+asn1_error_code asn1_decode_kdc_req_body
PROTOTYPE((asn1buf *buf, krb5_kdc_req *val));
-asn1_error_code INTERFACE asn1_decode_krb_safe_body
+asn1_error_code asn1_decode_krb_safe_body
PROTOTYPE((asn1buf *buf, krb5_safe *val));
-asn1_error_code INTERFACE asn1_decode_host_address
+asn1_error_code asn1_decode_host_address
PROTOTYPE((asn1buf *buf, krb5_address *val));
-asn1_error_code INTERFACE asn1_decode_kdc_rep
+asn1_error_code asn1_decode_kdc_rep
PROTOTYPE((asn1buf *buf, krb5_kdc_rep *val));
-asn1_error_code INTERFACE asn1_decode_last_req_entry
+asn1_error_code asn1_decode_last_req_entry
PROTOTYPE((asn1buf *buf, krb5_last_req_entry *val));
-asn1_error_code INTERFACE asn1_decode_authdata_elt
+asn1_error_code asn1_decode_authdata_elt
PROTOTYPE((asn1buf *buf, krb5_authdata *val));
-asn1_error_code INTERFACE asn1_decode_krb_cred_info
+asn1_error_code asn1_decode_krb_cred_info
PROTOTYPE((asn1buf *buf, krb5_cred_info *val));
-asn1_error_code INTERFACE asn1_decode_pa_data
+asn1_error_code asn1_decode_pa_data
PROTOTYPE((asn1buf *buf, krb5_pa_data *val));
-asn1_error_code INTERFACE asn1_decode_passwdsequence
+asn1_error_code asn1_decode_passwdsequence
PROTOTYPE((asn1buf *buf, passwd_phrase_element *val));
/* arrays */
-asn1_error_code INTERFACE asn1_decode_authorization_data
+asn1_error_code asn1_decode_authorization_data
PROTOTYPE((asn1buf *buf, krb5_authdata ***val));
-asn1_error_code INTERFACE asn1_decode_host_addresses
+asn1_error_code asn1_decode_host_addresses
PROTOTYPE((asn1buf *buf, krb5_address ***val));
-asn1_error_code INTERFACE asn1_decode_sequence_of_ticket
+asn1_error_code asn1_decode_sequence_of_ticket
PROTOTYPE((asn1buf *buf, krb5_ticket ***val));
-asn1_error_code INTERFACE asn1_decode_sequence_of_krb_cred_info
+asn1_error_code asn1_decode_sequence_of_krb_cred_info
PROTOTYPE((asn1buf *buf, krb5_cred_info ***val));
-asn1_error_code INTERFACE asn1_decode_sequence_of_pa_data
+asn1_error_code asn1_decode_sequence_of_pa_data
PROTOTYPE((asn1buf *buf, krb5_pa_data ***val));
-asn1_error_code INTERFACE asn1_decode_last_req
+asn1_error_code asn1_decode_last_req
PROTOTYPE((asn1buf *buf, krb5_last_req_entry ***val));
-asn1_error_code INTERFACE asn1_decode_sequence_of_enctype
+asn1_error_code asn1_decode_sequence_of_enctype
PROTOTYPE((asn1buf *buf, int *num, krb5_enctype **val));
-asn1_error_code INTERFACE asn1_decode_sequence_of_passwdsequence
+asn1_error_code asn1_decode_sequence_of_passwdsequence
PROTOTYPE((asn1buf *buf, passwd_phrase_element ***val));
*retlen = sum;\
return 0
-asn1_error_code INTERFACE asn1_encode_ui_4(buf, val, retlen)
+asn1_error_code asn1_encode_ui_4(buf, val, retlen)
asn1buf * buf;
const krb5_ui_4 val;
int *retlen;
}
-asn1_error_code INTERFACE asn1_encode_realm(buf, val, retlen)
+asn1_error_code asn1_encode_realm(buf, val, retlen)
asn1buf * buf;
const krb5_principal val;
int * retlen;
retlen);
}
-asn1_error_code INTERFACE asn1_encode_principal_name(buf, val, retlen)
+asn1_error_code asn1_encode_principal_name(buf, val, retlen)
asn1buf * buf;
const krb5_principal val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_kerberos_time(buf, val, retlen)
+asn1_error_code asn1_encode_kerberos_time(buf, val, retlen)
asn1buf * buf;
const krb5_timestamp val;
int * retlen;
return asn1_encode_generaltime(buf,val,retlen);
}
-asn1_error_code INTERFACE asn1_encode_host_address(buf, val, retlen)
+asn1_error_code asn1_encode_host_address(buf, val, retlen)
asn1buf * buf;
const krb5_address * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_host_addresses(buf, val, retlen)
+asn1_error_code asn1_encode_host_addresses(buf, val, retlen)
asn1buf * buf;
const krb5_address ** val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_encrypted_data(buf, val, retlen)
+asn1_error_code asn1_encode_encrypted_data(buf, val, retlen)
asn1buf * buf;
const krb5_enc_data * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_krb5_flags(buf, val, retlen)
+asn1_error_code asn1_encode_krb5_flags(buf, val, retlen)
asn1buf * buf;
const krb5_flags val;
int * retlen;
return 0;
}
-asn1_error_code INTERFACE asn1_encode_ap_options(buf, val, retlen)
+asn1_error_code asn1_encode_ap_options(buf, val, retlen)
asn1buf * buf;
const krb5_flags val;
int * retlen;
return asn1_encode_krb5_flags(buf,val,retlen);
}
-asn1_error_code INTERFACE asn1_encode_ticket_flags(buf, val, retlen)
+asn1_error_code asn1_encode_ticket_flags(buf, val, retlen)
asn1buf * buf;
const krb5_flags val;
int * retlen;
return asn1_encode_krb5_flags(buf,val,retlen);
}
-asn1_error_code INTERFACE asn1_encode_kdc_options(buf, val, retlen)
+asn1_error_code asn1_encode_kdc_options(buf, val, retlen)
asn1buf * buf;
const krb5_flags val;
int * retlen;
return asn1_encode_krb5_flags(buf,val,retlen);
}
-asn1_error_code INTERFACE asn1_encode_authorization_data(buf, val, retlen)
+asn1_error_code asn1_encode_authorization_data(buf, val, retlen)
asn1buf * buf;
const krb5_authdata ** val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_krb5_authdata_elt(buf, val, retlen)
+asn1_error_code asn1_encode_krb5_authdata_elt(buf, val, retlen)
asn1buf * buf;
const krb5_authdata * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_kdc_rep(msg_type, buf, val, retlen)
+asn1_error_code asn1_encode_kdc_rep(msg_type, buf, val, retlen)
int msg_type;
asn1buf * buf;
const krb5_kdc_rep * val;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_enc_kdc_rep_part(buf, val, retlen)
+asn1_error_code asn1_encode_enc_kdc_rep_part(buf, val, retlen)
asn1buf * buf;
const krb5_enc_kdc_rep_part * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_kdc_req_body(buf, rep, retlen)
+asn1_error_code asn1_encode_kdc_req_body(buf, rep, retlen)
asn1buf * buf;
const krb5_kdc_req * rep;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_encryption_key(buf, val, retlen)
+asn1_error_code asn1_encode_encryption_key(buf, val, retlen)
asn1buf * buf;
const krb5_keyblock * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_checksum(buf, val, retlen)
+asn1_error_code asn1_encode_checksum(buf, val, retlen)
asn1buf * buf;
const krb5_checksum * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_transited_encoding(buf, val, retlen)
+asn1_error_code asn1_encode_transited_encoding(buf, val, retlen)
asn1buf * buf;
const krb5_transited * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_last_req(buf, val, retlen)
+asn1_error_code asn1_encode_last_req(buf, val, retlen)
asn1buf * buf;
const krb5_last_req_entry ** val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_last_req_entry(buf, val, retlen)
+asn1_error_code asn1_encode_last_req_entry(buf, val, retlen)
asn1buf * buf;
const krb5_last_req_entry * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_sequence_of_pa_data(buf, val, retlen)
+asn1_error_code asn1_encode_sequence_of_pa_data(buf, val, retlen)
asn1buf * buf;
const krb5_pa_data ** val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_pa_data(buf, val, retlen)
+asn1_error_code asn1_encode_pa_data(buf, val, retlen)
asn1buf * buf;
const krb5_pa_data * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_sequence_of_ticket(buf, val, retlen)
+asn1_error_code asn1_encode_sequence_of_ticket(buf, val, retlen)
asn1buf * buf;
const krb5_ticket ** val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_ticket(buf, val, retlen)
+asn1_error_code asn1_encode_ticket(buf, val, retlen)
asn1buf * buf;
const krb5_ticket * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_sequence_of_enctype(buf, len, val, retlen)
+asn1_error_code asn1_encode_sequence_of_enctype(buf, len, val, retlen)
asn1buf * buf;
const int len;
const krb5_enctype * val;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_kdc_req(msg_type, buf, val, retlen)
+asn1_error_code asn1_encode_kdc_req(msg_type, buf, val, retlen)
int msg_type;
asn1buf * buf;
const krb5_kdc_req * val;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_krb_safe_body(buf, val, retlen)
+asn1_error_code asn1_encode_krb_safe_body(buf, val, retlen)
asn1buf * buf;
const krb5_safe * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_sequence_of_krb_cred_info(buf, val, retlen)
+asn1_error_code asn1_encode_sequence_of_krb_cred_info(buf, val, retlen)
asn1buf * buf;
const krb5_cred_info ** val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_krb_cred_info(buf, val, retlen)
+asn1_error_code asn1_encode_krb_cred_info(buf, val, retlen)
asn1buf * buf;
const krb5_cred_info * val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_sequence_of_passwdsequence(buf, val, retlen)
+asn1_error_code asn1_encode_sequence_of_passwdsequence(buf, val, retlen)
asn1buf * buf;
const passwd_phrase_element ** val;
int * retlen;
asn1_cleanup();
}
-asn1_error_code INTERFACE asn1_encode_passwdsequence(buf, val, retlen)
+asn1_error_code asn1_encode_passwdsequence(buf, val, retlen)
asn1buf * buf;
const passwd_phrase_element * val;
int * retlen;
Returns ENOMEM if memory runs out.
*/
-asn1_error_code INTERFACE asn1_encode_ui_4 PROTOTYPE((asn1buf *buf,
+asn1_error_code asn1_encode_ui_4 PROTOTYPE((asn1buf *buf,
const krb5_ui_4 val,
int *retlen));
-asn1_error_code INTERFACE asn1_encode_msgtype PROTOTYPE((asn1buf *buf,
+asn1_error_code asn1_encode_msgtype PROTOTYPE((asn1buf *buf,
const /*krb5_msgtype*/int val,
int *retlen));
-asn1_error_code INTERFACE asn1_encode_realm
+asn1_error_code asn1_encode_realm
PROTOTYPE((asn1buf *buf, const krb5_principal val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_principal_name
+asn1_error_code asn1_encode_principal_name
PROTOTYPE((asn1buf *buf, const krb5_principal val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_encrypted_data
+asn1_error_code asn1_encode_encrypted_data
PROTOTYPE((asn1buf *buf, const krb5_enc_data *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_krb5_flags
+asn1_error_code asn1_encode_krb5_flags
PROTOTYPE((asn1buf *buf, const krb5_flags val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_ap_options
+asn1_error_code asn1_encode_ap_options
PROTOTYPE((asn1buf *buf, const krb5_flags val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_ticket_flags
+asn1_error_code asn1_encode_ticket_flags
PROTOTYPE((asn1buf *buf, const krb5_flags val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_kdc_options
+asn1_error_code asn1_encode_kdc_options
PROTOTYPE((asn1buf *buf, const krb5_flags val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_authorization_data
+asn1_error_code asn1_encode_authorization_data
PROTOTYPE((asn1buf *buf, const krb5_authdata **val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_krb5_authdata_elt
+asn1_error_code asn1_encode_krb5_authdata_elt
PROTOTYPE((asn1buf *buf, const krb5_authdata *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_kdc_rep
+asn1_error_code asn1_encode_kdc_rep
PROTOTYPE((int msg_type, asn1buf *buf, const krb5_kdc_rep *val,
int *retlen));
-asn1_error_code INTERFACE asn1_encode_enc_kdc_rep_part
+asn1_error_code asn1_encode_enc_kdc_rep_part
PROTOTYPE((asn1buf *buf, const krb5_enc_kdc_rep_part *val,
int *retlen));
-asn1_error_code INTERFACE asn1_encode_ticket
+asn1_error_code asn1_encode_ticket
PROTOTYPE((asn1buf *buf, const krb5_ticket *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_encryption_key
+asn1_error_code asn1_encode_encryption_key
PROTOTYPE((asn1buf *buf, const krb5_keyblock *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_kerberos_time
+asn1_error_code asn1_encode_kerberos_time
PROTOTYPE((asn1buf *buf, const krb5_timestamp val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_checksum
+asn1_error_code asn1_encode_checksum
PROTOTYPE((asn1buf *buf, const krb5_checksum *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_host_address
+asn1_error_code asn1_encode_host_address
PROTOTYPE((asn1buf *buf, const krb5_address *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_host_addresses
+asn1_error_code asn1_encode_host_addresses
PROTOTYPE((asn1buf *buf, const krb5_address **val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_transited_encoding
+asn1_error_code asn1_encode_transited_encoding
PROTOTYPE((asn1buf *buf, const krb5_transited *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_last_req
+asn1_error_code asn1_encode_last_req
PROTOTYPE((asn1buf *buf, const krb5_last_req_entry **val,
int *retlen));
-asn1_error_code INTERFACE asn1_encode_sequence_of_pa_data
+asn1_error_code asn1_encode_sequence_of_pa_data
PROTOTYPE((asn1buf *buf, const krb5_pa_data **val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_sequence_of_ticket
+asn1_error_code asn1_encode_sequence_of_ticket
PROTOTYPE((asn1buf *buf, const krb5_ticket **val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_sequence_of_enctype
+asn1_error_code asn1_encode_sequence_of_enctype
PROTOTYPE((asn1buf *buf,
const int len, const krb5_enctype *val,
int *retlen));
-asn1_error_code INTERFACE asn1_encode_kdc_req
+asn1_error_code asn1_encode_kdc_req
PROTOTYPE((int msg_type,
asn1buf *buf,
const krb5_kdc_req *val,
int *retlen));
-asn1_error_code INTERFACE asn1_encode_kdc_req_body
+asn1_error_code asn1_encode_kdc_req_body
PROTOTYPE((asn1buf *buf, const krb5_kdc_req *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_krb_safe_body
+asn1_error_code asn1_encode_krb_safe_body
PROTOTYPE((asn1buf *buf, const krb5_safe *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_sequence_of_krb_cred_info
+asn1_error_code asn1_encode_sequence_of_krb_cred_info
PROTOTYPE((asn1buf *buf, const krb5_cred_info **val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_krb_cred_info
+asn1_error_code asn1_encode_krb_cred_info
PROTOTYPE((asn1buf *buf, const krb5_cred_info *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_last_req_entry
+asn1_error_code asn1_encode_last_req_entry
PROTOTYPE((asn1buf *buf, const krb5_last_req_entry *val,
int *retlen));
-asn1_error_code INTERFACE asn1_encode_pa_data
+asn1_error_code asn1_encode_pa_data
PROTOTYPE((asn1buf *buf, const krb5_pa_data *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_passwdsequence
+asn1_error_code asn1_encode_passwdsequence
PROTOTYPE((asn1buf *buf, const passwd_phrase_element *val, int *retlen));
-asn1_error_code INTERFACE asn1_encode_sequence_of_passwdsequence
+asn1_error_code asn1_encode_sequence_of_passwdsequence
PROTOTYPE((asn1buf *buf, const passwd_phrase_element **val, int *retlen));
#endif
#include "asn1_make.h"
-asn1_error_code INTERFACE asn1_make_etag(buf, class, tagnum, in_len, retlen)
+asn1_error_code asn1_make_etag(buf, class, tagnum, in_len, retlen)
asn1buf * buf;
const asn1_class class;
const asn1_tagnum tagnum;
return asn1_make_tag(buf,class,CONSTRUCTED,tagnum,in_len,retlen);
}
-asn1_error_code INTERFACE asn1_make_tag(buf, class, construction, tagnum, in_len, retlen)
+asn1_error_code asn1_make_tag(buf, class, construction, tagnum, in_len, retlen)
asn1buf * buf;
const asn1_class class;
const asn1_construction construction;
return 0;
}
-asn1_error_code INTERFACE asn1_make_length(buf, in_len, retlen)
+asn1_error_code asn1_make_length(buf, in_len, retlen)
asn1buf * buf;
const int in_len;
int * retlen;
return 0;
}
-asn1_error_code INTERFACE asn1_make_id(buf, class, construction, tagnum, retlen)
+asn1_error_code asn1_make_id(buf, class, construction, tagnum, retlen)
asn1buf * buf;
const asn1_class class;
const asn1_construction construction;
return 0;
}
-asn1_error_code INTERFACE asn1_make_sequence(buf, seq_len, retlen)
+asn1_error_code asn1_make_sequence(buf, seq_len, retlen)
asn1buf * buf;
const int seq_len;
int * retlen;
return 0;
}
-asn1_error_code INTERFACE asn1_make_set(buf, set_len, retlen)
+asn1_error_code asn1_make_set(buf, set_len, retlen)
asn1buf * buf;
const int set_len;
int * retlen;
return 0;
}
-asn1_error_code INTERFACE asn1_make_string(buf, length, string, retlen)
+asn1_error_code asn1_make_string(buf, length, string, retlen)
asn1buf * buf;
const int length;
const char * string;
asn1_make_string
*/
-asn1_error_code INTERFACE asn1_make_etag
+asn1_error_code asn1_make_etag
PROTOTYPE((asn1buf *buf,
const asn1_class class,
const asn1_tagnum tagnum,
Returns the length of this encoding in *retlen.
Returns ENOMEM if memory runs out. */
-asn1_error_code INTERFACE asn1_make_tag
+asn1_error_code asn1_make_tag
PROTOTYPE((asn1buf *buf, const asn1_class class,
const asn1_construction construction,
const asn1_tagnum tagnum,
Returns ASN1_OVERFLOW if tagnum exceeds the limits of
the implementation. */
-asn1_error_code INTERFACE asn1_make_sequence
+asn1_error_code asn1_make_sequence
PROTOTYPE((asn1buf *buf, const int seq_len, int *len));
/* requires *buf is allocated, seq_len is the length of a series of
sequence components which have just been inserted in *buf
in *buf. Returns the length of this encoding in *retlen.
Returns ENOMEM if memory runs out. */
-asn1_error_code INTERFACE asn1_make_set
+asn1_error_code asn1_make_set
PROTOTYPE((asn1buf *buf, const int set_len, int *retlen));
/* requires *buf is allocated, seq_len is the length of a series of
sequence components which have just been inserted in *buf
Returns the length of this encoding in *retlen.
Returns ENOMEM if memory runs out. */
-asn1_error_code INTERFACE asn1_make_string
+asn1_error_code asn1_make_string
PROTOTYPE((asn1buf *buf,
const int len, const char *string,
int *retlen));
/* Private procedures */
/* "helper" procedure for asn1_make_tag */
-asn1_error_code INTERFACE asn1_make_length
+asn1_error_code asn1_make_length
PROTOTYPE((asn1buf *buf, const int in_len, int *retlen));
/* requires *buf is allocated, in_len is the length of an ASN.1 encoding
which has just been inserted in *buf
PROTOTYPE((s) for in_len into *buf */
/* "helper" procedure for asn1_make_tag */
-asn1_error_code INTERFACE asn1_make_id
+asn1_error_code asn1_make_id
PROTOTYPE((asn1buf *buf,
const asn1_class class,
const asn1_construction construction,
#include "asn1_misc.h"
-asn1_error_code INTERFACE asn1_krb5_realm_copy(target, source)
+asn1_error_code asn1_krb5_realm_copy(target, source)
krb5_principal target;
krb5_principal source;
{
#include "k5-int.h"
#include "krbasn1.h"
-asn1_error_code INTERFACE asn1_krb5_realm_copy
+asn1_error_code asn1_krb5_realm_copy
PROTOTYPE((krb5_principal target, krb5_principal source));
/* requires target, source, and source->realm are allocated
effects Copies source->realm into target->realm.
#include "asn1buf.h"
#include <stdio.h>
-asn1_error_code INTERFACE asn1buf_create(buf)
+asn1_error_code asn1buf_create(buf)
asn1buf ** buf;
{
*buf = (asn1buf*)calloc(1,sizeof(asn1buf));
return 0;
}
-asn1_error_code INTERFACE asn1buf_wrap_data(buf, code)
+asn1_error_code asn1buf_wrap_data(buf, code)
asn1buf * buf;
const krb5_data * code;
{
return 0;
}
-asn1_error_code INTERFACE asn1buf_imbed(subbuf, buf, length)
+asn1_error_code asn1buf_imbed(subbuf, buf, length)
asn1buf * subbuf;
const asn1buf * buf;
const int length;
return 0;
}
-void INTERFACE asn1buf_sync(buf, subbuf)
+void asn1buf_sync(buf, subbuf)
asn1buf * buf;
asn1buf * subbuf;
{
buf->next = subbuf->next;
}
-asn1_error_code INTERFACE asn1buf_destroy(buf)
+asn1_error_code asn1buf_destroy(buf)
asn1buf ** buf;
{
if (*buf != NULL) {
return 0;
}
-asn1_error_code INTERFACE asn1buf_insert_octet(buf, o)
+asn1_error_code asn1buf_insert_octet(buf, o)
asn1buf * buf;
const int o;
{
return 0;
}
-asn1_error_code INTERFACE asn1buf_insert_octetstring(buf, len, s)
+asn1_error_code asn1buf_insert_octetstring(buf, len, s)
asn1buf * buf;
const int len;
const krb5_octet * s;
return 0;
}
-asn1_error_code INTERFACE asn1buf_insert_charstring(buf, len, s)
+asn1_error_code asn1buf_insert_charstring(buf, len, s)
asn1buf * buf;
const int len;
const char * s;
return 0;
}
-asn1_error_code INTERFACE asn1buf_remove_octet(buf, o)
+asn1_error_code asn1buf_remove_octet(buf, o)
asn1buf * buf;
asn1_octet * o;
{
return 0;
}
-asn1_error_code INTERFACE asn1buf_remove_octetstring(buf, len, s)
+asn1_error_code asn1buf_remove_octetstring(buf, len, s)
asn1buf * buf;
const int len;
asn1_octet ** s;
return 0;
}
-asn1_error_code INTERFACE asn1buf_remove_charstring(buf, len, s)
+asn1_error_code asn1buf_remove_charstring(buf, len, s)
asn1buf * buf;
const int len;
char ** s;
else return remain;
}
-
-asn1_error_code INTERFACE asn12krb5_buf(buf, code)
+asn1_error_code asn12krb5_buf(buf, code)
const asn1buf * buf;
krb5_data ** code;
{
/* These parse and unparse procedures should be moved out. They're
useful only for debugging and superfluous in the production version. */
-asn1_error_code INTERFACE asn1buf_unparse(buf, s)
+asn1_error_code asn1buf_unparse(buf, s)
const asn1buf * buf;
char ** s;
{
return 0;
}
-asn1_error_code INTERFACE asn1buf_hex_unparse(buf, s)
+asn1_error_code asn1buf_hex_unparse(buf, s)
const asn1buf * buf;
char ** s;
{
/****************************************************************/
/* Private Procedures */
-int INTERFACE asn1buf_size(buf)
+int asn1buf_size(buf)
const asn1buf * buf;
{
if(buf == NULL || buf->base == NULL) return 0;
return buf->bound - buf->base + 1;
}
-int INTERFACE asn1buf_free(buf)
+int asn1buf_free(buf)
const asn1buf * buf;
{
if(buf == NULL || buf->base == NULL) return 0;
else return buf->bound - buf->next + 1;
}
-asn1_error_code INTERFACE asn1buf_ensure_space(buf, amount)
+asn1_error_code asn1buf_ensure_space(buf, amount)
asn1buf * buf;
const int amount;
{
return 0;
}
-asn1_error_code INTERFACE asn1buf_expand(buf, inc)
+asn1_error_code asn1buf_expand(buf, inc)
asn1buf * buf;
const int inc;
{
return 0;
}
-int INTERFACE asn1buf_len(buf)
+int asn1buf_len(buf)
const asn1buf * buf;
{
return buf->next - buf->base;
(asn1buf_len)
*/
-asn1_error_code INTERFACE asn1buf_create
+asn1_error_code asn1buf_create
PROTOTYPE((asn1buf **buf));
/* effects Creates a new encoding buffer pointed to by *buf.
Returns ENOMEM if the buffer can't be created. */
-asn1_error_code INTERFACE asn1buf_wrap_data
+asn1_error_code asn1buf_wrap_data
PROTOTYPE((asn1buf *buf, const krb5_data *code));
/* requires *buf has already been allocated
effects Turns *buf into a "wrapper" for *code. i.e. *buf is set up
is the top of *code.
Returns ASN1_MISSING_FIELD if code is empty. */
-asn1_error_code INTERFACE asn1buf_imbed
+asn1_error_code asn1buf_imbed
PROTOTYPE((asn1buf *subbuf, const asn1buf *buf, const int length));
/* requires *subbuf and *buf are allocated
effects *subbuf becomes a sub-buffer of *buf. *subbuf begins
that case, ASN1_OVERRUN is returned) *subbuf's current
position starts at the beginning of *subbuf. */
-void INTERFACE asn1buf_sync
+void asn1buf_sync
PROTOTYPE((asn1buf *buf, asn1buf *subbuf));
/* requires *subbuf is a sub-buffer of *buf, as created by asn1buf_imbed.
effects Synchronizes *buf's current position to match that of *subbuf. */
-asn1_error_code INTERFACE asn1buf_destroy
+asn1_error_code asn1buf_destroy
PROTOTYPE((asn1buf **buf));
/* effects Deallocates **buf, sets *buf to NULL. */
-asn1_error_code INTERFACE asn1buf_insert_octet
+asn1_error_code asn1buf_insert_octet
PROTOTYPE((asn1buf *buf, const int o));
/* requires *buf is allocated
effects Inserts o into the buffer *buf, expanding the buffer if
necessary. Returns ENOMEM memory is exhausted. */
-asn1_error_code INTERFACE asn1buf_insert_octetstring
+asn1_error_code asn1buf_insert_octetstring
PROTOTYPE((asn1buf *buf, const int len, const asn1_octet *s));
/* requires *buf is allocated
modifies *buf
into the buffer *buf, expanding the buffer if necessary.
Returns ENOMEM if memory is exhausted. */
-asn1_error_code INTERFACE asn1buf_insert_charstring
+asn1_error_code asn1buf_insert_charstring
PROTOTYPE((asn1buf *buf, const int len, const char *s));
/* requires *buf is allocated
modifies *buf
into the buffer *buf, expanding the buffer if necessary.
Returns ENOMEM if memory is exhuasted. */
-asn1_error_code INTERFACE asn1buf_remove_octet
+asn1_error_code asn1buf_remove_octet
PROTOTYPE((asn1buf *buf, asn1_octet *o));
/* requires *buf is allocated
effects Returns *buf's current octet in *o and advances to
the next octet.
Returns ASN1_OVERRUN if *buf has already been exhuasted. */
-asn1_error_code INTERFACE asn1buf_remove_octetstring
+asn1_error_code asn1buf_remove_octetstring
PROTOTYPE((asn1buf *buf, const int len, asn1_octet **s));
/* requires *buf is allocated
effects Removes the next len octets of *buf and returns them in **s.
left in *buf.
Returns ENOMEM if *s could not be allocated. */
-asn1_error_code INTERFACE asn1buf_remove_charstring
+asn1_error_code asn1buf_remove_charstring
PROTOTYPE((asn1buf *buf, const int len,
char **s));
/* requires *buf is allocated
left in *buf.
Returns ENOMEM if *s could not be allocated. */
-asn1_error_code INTERFACE asn1buf_unparse
+asn1_error_code asn1buf_unparse
PROTOTYPE((const asn1buf *buf, char **s));
/* modifies *s
effects Returns a human-readable representation of *buf in *s,
where each octet in *buf is represented by a character in *s. */
-asn1_error_code INTERFACE asn1buf_hex_unparse
+asn1_error_code asn1buf_hex_unparse
PROTOTYPE((const asn1buf *buf, char **s));
/* modifies *s
effects Returns a human-readable representation of *buf in *s,
where each octet in *buf is represented by a 2-digit
hexadecimal number in *s. */
-asn1_error_code INTERFACE asn12krb5_buf
+asn1_error_code asn12krb5_buf
PROTOTYPE((const asn1buf *buf, krb5_data **code));
/* modifies *code
effects Instantiates **code with the krb5_data representation of **buf. */
-int INTERFACE asn1buf_remains
+int asn1buf_remains
PROTOTYPE((asn1buf *buf));
/* requires *buf is a buffer containing an asn.1 structure or array
modifies *buf
/**************** Private Procedures ****************/
-int INTERFACE asn1buf_size
+int asn1buf_size
PROTOTYPE((const asn1buf *buf));
/* requires *buf has been created and not destroyed
effects Returns the total size
PROTOTYPE((in octets) of buf's octet buffer. */
-int INTERFACE asn1buf_free
+int asn1buf_free
PROTOTYPE((const asn1buf *buf));
/* requires *buf is allocated
effects Returns the number of unused, allocated octets in *buf. */
-asn1_error_code INTERFACE asn1buf_ensure_space
+asn1_error_code asn1buf_ensure_space
PROTOTYPE((asn1buf *buf, const int amount));
/* requires *buf is allocated
modifies *buf
expanded to have at least amount octets of free space.
Returns ENOMEM memory is exhausted. */
-asn1_error_code INTERFACE asn1buf_expand
+asn1_error_code asn1buf_expand
PROTOTYPE((asn1buf *buf, const int inc));
/* requires *buf is allocated
modifies *buf
effects Expands *buf by allocating space for inc more octets.
Returns ENOMEM if memory is exhausted. */
-int INTERFACE asn1buf_len
+int asn1buf_len
PROTOTYPE((const asn1buf *buf));
/* requires *buf is allocated
effects Returns the length of the encoding in *buf. */
#define cleanup()\
return 0
-krb5_error_code INTERFACE decode_krb5_authenticator(code, rep)
+krb5_error_code decode_krb5_authenticator(code, rep)
const krb5_data * code;
krb5_authenticator ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_ticket(code, rep)
+krb5_error_code decode_krb5_ticket(code, rep)
const krb5_data * code;
krb5_ticket ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_encryption_key(code, rep)
+krb5_error_code decode_krb5_encryption_key(code, rep)
const krb5_data * code;
krb5_keyblock ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_enc_tkt_part(code, rep)
+krb5_error_code decode_krb5_enc_tkt_part(code, rep)
const krb5_data * code;
krb5_enc_tkt_part ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_enc_kdc_rep_part(code, rep)
+krb5_error_code decode_krb5_enc_kdc_rep_part(code, rep)
const krb5_data * code;
krb5_enc_kdc_rep_part ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_as_rep(code, rep)
+krb5_error_code decode_krb5_as_rep(code, rep)
const krb5_data * code;
krb5_kdc_rep ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_tgs_rep(code, rep)
+krb5_error_code decode_krb5_tgs_rep(code, rep)
const krb5_data * code;
krb5_kdc_rep ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_ap_req(code, rep)
+krb5_error_code decode_krb5_ap_req(code, rep)
const krb5_data * code;
krb5_ap_req ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_ap_rep(code, rep)
+krb5_error_code decode_krb5_ap_rep(code, rep)
const krb5_data * code;
krb5_ap_rep ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_ap_rep_enc_part(code, rep)
+krb5_error_code decode_krb5_ap_rep_enc_part(code, rep)
const krb5_data * code;
krb5_ap_rep_enc_part ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_as_req(code, rep)
+krb5_error_code decode_krb5_as_req(code, rep)
const krb5_data * code;
krb5_kdc_req ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_tgs_req(code, rep)
+krb5_error_code decode_krb5_tgs_req(code, rep)
const krb5_data * code;
krb5_kdc_req ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_kdc_req_body(code, rep)
+krb5_error_code decode_krb5_kdc_req_body(code, rep)
const krb5_data * code;
krb5_kdc_req ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_safe(code, rep)
+krb5_error_code decode_krb5_safe(code, rep)
const krb5_data * code;
krb5_safe ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_priv(code, rep)
+krb5_error_code decode_krb5_priv(code, rep)
const krb5_data * code;
krb5_priv ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_enc_priv_part(code, rep)
+krb5_error_code decode_krb5_enc_priv_part(code, rep)
const krb5_data * code;
krb5_priv_enc_part ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_cred(code, rep)
+krb5_error_code decode_krb5_cred(code, rep)
const krb5_data * code;
krb5_cred ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_enc_cred_part(code, rep)
+krb5_error_code decode_krb5_enc_cred_part(code, rep)
const krb5_data * code;
krb5_cred_enc_part ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_error(code, rep)
+krb5_error_code decode_krb5_error(code, rep)
const krb5_data * code;
krb5_error ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_authdata(code, rep)
+krb5_error_code decode_krb5_authdata(code, rep)
const krb5_data * code;
krb5_authdata *** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_pwd_sequence(code, rep)
+krb5_error_code decode_krb5_pwd_sequence(code, rep)
const krb5_data * code;
passwd_phrase_element ** rep;
{
cleanup();
}
-krb5_error_code INTERFACE decode_krb5_pwd_data(code, rep)
+krb5_error_code decode_krb5_pwd_data(code, rep)
const krb5_data * code;
krb5_pwd_data ** rep;
{
\
return 0
-krb5_error_code INTERFACE encode_krb5_authenticator(rep, code)
+krb5_error_code encode_krb5_authenticator(rep, code)
const krb5_authenticator * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_ticket(rep, code)
+krb5_error_code encode_krb5_ticket(rep, code)
const krb5_ticket * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_encryption_key(rep, code)
+krb5_error_code encode_krb5_encryption_key(rep, code)
const krb5_keyblock * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_enc_tkt_part(rep, code)
+krb5_error_code encode_krb5_enc_tkt_part(rep, code)
const krb5_enc_tkt_part * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_enc_kdc_rep_part(rep, code)
+krb5_error_code encode_krb5_enc_kdc_rep_part(rep, code)
const krb5_enc_kdc_rep_part * rep;
krb5_data ** code;
{
}
/* yes, the translation is identical to that used for KDC__REP */
-krb5_error_code INTERFACE encode_krb5_as_rep(rep, code)
+krb5_error_code encode_krb5_as_rep(rep, code)
const krb5_kdc_rep * rep;
krb5_data ** code;
{
}
/* yes, the translation is identical to that used for KDC__REP */
-krb5_error_code INTERFACE encode_krb5_tgs_rep( rep, code)
+krb5_error_code encode_krb5_tgs_rep( rep, code)
const krb5_kdc_rep * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_ap_req(rep, code)
+krb5_error_code encode_krb5_ap_req(rep, code)
const krb5_ap_req * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_ap_rep(rep, code)
+krb5_error_code encode_krb5_ap_rep(rep, code)
const krb5_ap_rep * rep;
krb5_data ** code;
{
}
-krb5_error_code INTERFACE encode_krb5_ap_rep_enc_part(rep, code)
+krb5_error_code encode_krb5_ap_rep_enc_part(rep, code)
const krb5_ap_rep_enc_part * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_as_req(rep, code)
+krb5_error_code encode_krb5_as_req(rep, code)
const krb5_kdc_req * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_tgs_req(rep, code)
+krb5_error_code encode_krb5_tgs_req(rep, code)
const krb5_kdc_req * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_kdc_req_body(rep, code)
+krb5_error_code encode_krb5_kdc_req_body(rep, code)
const krb5_kdc_req * rep;
krb5_data ** code;
{
}
-krb5_error_code INTERFACE encode_krb5_safe(rep, code)
+krb5_error_code encode_krb5_safe(rep, code)
const krb5_safe * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_priv(rep, code)
+krb5_error_code encode_krb5_priv(rep, code)
const krb5_priv * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_enc_priv_part(rep, code)
+krb5_error_code encode_krb5_enc_priv_part(rep, code)
const krb5_priv_enc_part * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_cred(rep, code)
+krb5_error_code encode_krb5_cred(rep, code)
const krb5_cred * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_enc_cred_part(rep, code)
+krb5_error_code encode_krb5_enc_cred_part(rep, code)
const krb5_cred_enc_part * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_error(rep, code)
+krb5_error_code encode_krb5_error(rep, code)
const krb5_error * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_authdata(rep, code)
+krb5_error_code encode_krb5_authdata(rep, code)
const krb5_authdata ** rep;
krb5_data ** code;
{
}
/* Sandia Additions */
-krb5_error_code INTERFACE encode_krb5_pwd_sequence( rep, code)
+krb5_error_code encode_krb5_pwd_sequence( rep, code)
const passwd_phrase_element * rep;
krb5_data ** code;
{
krb5_cleanup();
}
-krb5_error_code INTERFACE encode_krb5_pwd_data(rep, code)
+krb5_error_code encode_krb5_pwd_data(rep, code)
const krb5_pwd_data * rep;
krb5_data ** code;
{
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * ccbase.c: removed unneeded INTERFACE from non-api functions.
+
Wed Mar 22 11:47:49 1995 <tytso@rsx-11.mit.edu>
* Makefile.in (CFLAGS): Make -I options work when the build and
* If override is set, replace any existing ccache with that type tag
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_cc_register(context, ops, override)
krb5_context context;
krb5_cc_ops *ops;
* particular cache type.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_cc_resolve (context, name, cache)
krb5_context context;
char *name;
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+
Wed Mar 22 11:24:07 1995 Keith Vetter (keithv@fusion.com)
* fcc-proto.h: added prototype for cache changing hook,
PROTOTYPE((krb5_context, krb5_ccache id ));
/* fcc_defnam.c */
-char * INTERFACE krb5_fcc_default_name
+char * krb5_fcc_default_name
PROTOTYPE((krb5_context));
/* fcc_destry.c */
krb5_creds *creds ));
/* fcc_read.c */
-krb5_error_code INTERFACE krb5_fcc_read_principal
+krb5_error_code krb5_fcc_read_principal
PROTOTYPE((krb5_context, krb5_ccache id , krb5_principal *princ ));
-krb5_error_code INTERFACE krb5_fcc_read_keyblock
+krb5_error_code krb5_fcc_read_keyblock
PROTOTYPE((krb5_context, krb5_ccache id , krb5_keyblock *keyblock ));
-krb5_error_code INTERFACE krb5_fcc_read_data
+krb5_error_code krb5_fcc_read_data
PROTOTYPE((krb5_context, krb5_ccache id , krb5_data *data ));
-krb5_error_code INTERFACE krb5_fcc_read_int32
+krb5_error_code krb5_fcc_read_int32
PROTOTYPE((krb5_context, krb5_ccache id , krb5_int32 *i ));
-krb5_error_code INTERFACE krb5_fcc_read_ui_2
+krb5_error_code krb5_fcc_read_ui_2
PROTOTYPE((krb5_context, krb5_ccache id , krb5_ui_2 *i ));
-krb5_error_code INTERFACE krb5_fcc_read_octet
+krb5_error_code krb5_fcc_read_octet
PROTOTYPE((krb5_context, krb5_ccache id , krb5_octet *i ));
-krb5_error_code INTERFACE krb5_fcc_read_times
+krb5_error_code krb5_fcc_read_times
PROTOTYPE((krb5_context, krb5_ccache id , krb5_ticket_times *t ));
-krb5_error_code INTERFACE krb5_fcc_read_addrs
+krb5_error_code krb5_fcc_read_addrs
PROTOTYPE((krb5_context, krb5_ccache, krb5_address ***));
-krb5_error_code INTERFACE krb5_fcc_read_addr
+krb5_error_code krb5_fcc_read_addr
PROTOTYPE((krb5_context, krb5_ccache, krb5_address *));
-krb5_error_code INTERFACE krb5_fcc_read_authdata
+krb5_error_code krb5_fcc_read_authdata
PROTOTYPE((krb5_context, krb5_ccache , krb5_authdata ***));
-krb5_error_code INTERFACE krb5_fcc_read_authdatum
+krb5_error_code krb5_fcc_read_authdatum
PROTOTYPE((krb5_context, krb5_ccache , krb5_authdata *));
/* fcc_reslv.c */
PROTOTYPE((krb5_context, krb5_ccache id , krb5_creds *creds ));
/* fcc_skip.c */
-krb5_error_code INTERFACE krb5_fcc_skip_principal
+krb5_error_code krb5_fcc_skip_principal
PROTOTYPE((krb5_context, krb5_ccache id ));
/* fcc_sflags.c */
/* fcc_write.c */
-krb5_error_code INTERFACE krb5_fcc_write
+krb5_error_code krb5_fcc_write
PROTOTYPE((krb5_context, krb5_ccache id , krb5_pointer buf , int len ));
-krb5_error_code INTERFACE krb5_fcc_store_principal
+krb5_error_code krb5_fcc_store_principal
PROTOTYPE((krb5_context, krb5_ccache id , krb5_principal princ ));
-krb5_error_code INTERFACE krb5_fcc_store_keyblock
+krb5_error_code krb5_fcc_store_keyblock
PROTOTYPE((krb5_context, krb5_ccache id , krb5_keyblock *keyblock ));
-krb5_error_code INTERFACE krb5_fcc_store_data
+krb5_error_code krb5_fcc_store_data
PROTOTYPE((krb5_context, krb5_ccache id , krb5_data *data ));
-krb5_error_code INTERFACE krb5_fcc_store_int32
+krb5_error_code krb5_fcc_store_int32
PROTOTYPE((krb5_context, krb5_ccache id , krb5_int32 i ));
-krb5_error_code INTERFACE krb5_fcc_store_ui_2
+krb5_error_code krb5_fcc_store_ui_2
PROTOTYPE((krb5_context, krb5_ccache id , krb5_int32 i ));
-krb5_error_code INTERFACE krb5_fcc_store_octet
+krb5_error_code krb5_fcc_store_octet
PROTOTYPE((krb5_context, krb5_ccache id , krb5_int32 i ));
-krb5_error_code INTERFACE krb5_fcc_store_times
+krb5_error_code krb5_fcc_store_times
PROTOTYPE((krb5_context, krb5_ccache id , krb5_ticket_times *t ));
-krb5_error_code INTERFACE krb5_fcc_store_addrs
+krb5_error_code krb5_fcc_store_addrs
PROTOTYPE((krb5_context, krb5_ccache , krb5_address ** ));
-krb5_error_code INTERFACE krb5_fcc_store_addr
+krb5_error_code krb5_fcc_store_addr
PROTOTYPE((krb5_context, krb5_ccache , krb5_address * ));
-krb5_error_code INTERFACE krb5_fcc_store_authdata
+krb5_error_code krb5_fcc_store_authdata
PROTOTYPE((krb5_context, krb5_ccache , krb5_authdata **));
-krb5_error_code INTERFACE krb5_fcc_store_authdatum
+krb5_error_code krb5_fcc_store_authdatum
PROTOTYPE((krb5_context, krb5_ccache , krb5_authdata *));
/* fcc_errs.c */
-krb5_error_code INTERFACE krb5_fcc_interpret
+krb5_error_code krb5_fcc_interpret
PROTOTYPE((krb5_context, int ));
/* fcc_maybe.c */
-krb5_error_code INTERFACE krb5_fcc_close_file
+krb5_error_code krb5_fcc_close_file
PROTOTYPE((krb5_context, krb5_ccache));
-krb5_error_code INTERFACE krb5_fcc_open_file
+krb5_error_code krb5_fcc_open_file
PROTOTYPE((krb5_context, krb5_ccache, int));
#endif /* KRB5_FCC_PROTO__ */
#include "fcc.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_interpret(context, errnum)
krb5_context context;
int errnum;
#endif
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_close_file (context, id)
krb5_context context;
krb5_ccache id;
return (ret == -1) ? krb5_fcc_interpret (context, errno) : 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_open_file (context, id, mode)
krb5_context context;
krb5_ccache id;
* KRB5_CC_END - there were not len bytes available
* system errors (read)
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read(context, id, buf, len)
krb5_context context;
krb5_ccache id;
* KRB5_CC_NOMEM
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_principal(context, id, princ)
krb5_context context;
krb5_ccache id;
return kret;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_addrs(context, id, addrs)
krb5_context context;
krb5_ccache id;
return kret;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_keyblock(context, id, keyblock)
krb5_context context;
krb5_ccache id;
return kret;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_data(context, id, data)
krb5_context context;
krb5_ccache id;
return kret;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_addr(context, id, addr)
krb5_context context;
krb5_ccache id;
return kret;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_int32(context, id, i)
krb5_context context;
krb5_ccache id;
}
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_ui_2(context, id, i)
krb5_context context;
krb5_ccache id;
}
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_octet(context, id, i)
krb5_context context;
krb5_ccache id;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_times(context, id, t)
krb5_context context;
krb5_ccache id;
return retval;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_authdata(context, id, a)
krb5_context context;
krb5_ccache id;
return kret;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_read_authdatum(context, id, a)
krb5_context context;
krb5_ccache id;
#include "fcc.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_skip_principal(context, id)
krb5_context context;
krb5_ccache id;
* Errors:
* system errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_write(context, id, buf, len)
krb5_context context;
krb5_ccache id;
* system errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_principal(context, id, princ)
krb5_context context;
krb5_ccache id;
return KRB5_OK;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_addrs(context, id, addrs)
krb5_context context;
krb5_ccache id;
return KRB5_OK;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_keyblock(context, id, keyblock)
krb5_context context;
krb5_ccache id;
return krb5_fcc_write(context, id, (char *) keyblock->contents, keyblock->length);
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_addr(context, id, addr)
krb5_context context;
krb5_ccache id;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_data(context, id, data)
krb5_context context;
krb5_ccache id;
return krb5_fcc_write(context, id, data->data, data->length);
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_int32(context, id, i)
krb5_context context;
krb5_ccache id;
}
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_ui_2(context, id, i)
krb5_context context;
krb5_ccache id;
}
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_octet(context, id, i)
krb5_context context;
krb5_ccache id;
return krb5_fcc_write(context, id, (char *) &ibuf, 1);
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_times(context, id, t)
krb5_context context;
krb5_ccache id;
}
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_authdata(context, id, a)
krb5_context context;
krb5_ccache id;
return KRB5_OK;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_fcc_store_authdatum (context, id, a)
krb5_context context;
krb5_ccache id;
+Thu Apr 13 16:32:12 1995 Keith Vetter (keithv@fusion.com)
+
+ * scc_genn.c: __STDC__ conditional also checks the _WINDOWS define.
+
Sat Mar 25 14:42:37 1995 Tom Yu (tlyu@dragons-lair)
* scc_maybe.c (krb5_scc_open_file): fixed typo (extra & in
strcpy(((krb5_scc_data *) lid->data)->filename, scratch);
/* Make sure the file name is useable */
-#if defined(__STDC__)
+#if defined(__STDC__) || defined(_WINDOWS)
f = fopen (((krb5_scc_data *) lid->data)->filename, "wb+");
#else
f = fopen (((krb5_scc_data *) lid->data)->filename, "w+");
+Thu Apr 13 16:36:10 1995 Keith Vetter (keithv@fusion.com)
+
+ * Makefile.in: clean target was cleaning too much for the PC.
+
Wed Apr 5 16:29:25 1995 Keith Vetter (keithv@fusion.com)
* krb5_err.et: added KRB5_REALM_CANT_RESOLVE for more precise
clean:: clean-$(WHAT)
-clean-unix::
+clean-unix:: clean-hdrs
$(RM) $(HDRS) $(ETSRCS)
-clean-mac:
+clean-mac:: clean-hdrs
$(RM) $(HDRS) $(ETSRCS)
clean-windows::
(set -x; rm -f $(EHDRDIR)/$$x; cp $$x $(EHDRDIR)/$$x) \
fi; done
-clean::
+clean-hdrs::
for x in $(HDRS); do \
rm -f $(EHDRDIR)/$$x; \
done
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+
Fri Mar 17 19:45:01 1995 John Gilmore (gnu at toad.com)
* Makefile.in (LDFLAGS): Elim duplicate.
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_address(context, val)
krb5_context context;
krb5_address *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_ap_rep(context, val)
krb5_context context;
register krb5_ap_rep *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_ap_req(context, val)
krb5_context context;
register krb5_ap_req *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_authenticator_contents(context, val)
krb5_context context;
krb5_authenticator *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_authdata(context, val)
krb5_context context;
krb5_authdata **val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_authenticator(context, val)
krb5_context context;
krb5_authenticator *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_checksum(context, val)
krb5_context context;
register krb5_checksum *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_cred(context, val)
krb5_context context;
register krb5_cred *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_cred_enc_part(context, val)
krb5_context context;
register krb5_cred_enc_part *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_enc_kdc_rep_part(context, val)
krb5_context context;
register krb5_enc_kdc_rep_part *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_enc_tkt_part(context, val)
krb5_context context;
krb5_enc_tkt_part *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_error(context, val)
krb5_context context;
register krb5_error *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_kdc_rep(context, val)
krb5_context context;
krb5_kdc_rep *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_kdc_req(context, val)
krb5_context context;
krb5_kdc_req *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_keyblock(context, val)
krb5_context context;
register krb5_keyblock *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_last_req(context, val)
krb5_context context;
krb5_last_req_entry **val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_pa_data(context, val)
krb5_context context;
krb5_pa_data **val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_priv(context, val)
krb5_context context;
register krb5_priv *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_priv_enc_part(context, val)
krb5_context context;
register krb5_priv_enc_part *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_pwd_data(context, val)
krb5_context context;
krb5_pwd_data *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_pwd_sequences(context, val)
krb5_context context;
passwd_phrase_element **val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_safe(context, val)
krb5_context context;
register krb5_safe *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_ticket(context, val)
krb5_context context;
krb5_ticket *val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_tickets(context, val)
krb5_context context;
krb5_ticket **val;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_tgt_creds(context, tgts)
krb5_context context;
krb5_creds **tgts;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_tkt_authent(context, val)
krb5_context context;
krb5_tkt_authent *val;
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.c: removed unneeded INTERFACE from non-api functions.
+
Fri Mar 17 19:46:07 1995 John Gilmore (gnu at toad.com)
* Makefile.in (LDFLAGS): Zap duplicate defn.
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+
Fri Mar 17 19:46:49 1995 John Gilmore (gnu at toad.com)
* Makefile.in (LDFLAGS): Zap duplicate.
#include "k5-int.h"
#include "ktfile.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfile_add(context, id, entry)
krb5_context context;
krb5_keytab id;
#include "k5-int.h"
#include "ktfile.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfile_close(context, id)
krb5_context context;
krb5_keytab id;
#include "k5-int.h"
#include "ktfile.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfile_end_get(context, id, cursor)
krb5_context context;
krb5_keytab id;
#include "k5-int.h"
#include "ktfile.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfile_get_entry(context, id, principal, kvno, keytype, entry)
krb5_context context;
krb5_keytab id;
#include "k5-int.h"
#include "ktfile.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfile_get_name(context, id, name, len)
krb5_context context;
krb5_keytab id;
#include "k5-int.h"
#include "ktfile.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfile_get_next(context, id, entry, cursor)
krb5_context context;
krb5_keytab id;
#include "k5-int.h"
#include "ktfile.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfile_remove(context, id, entry)
krb5_context context;
krb5_keytab id;
#include "k5-int.h"
#include "ktfile.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfile_resolve(context, name, id)
krb5_context context;
const char *name;
#include "k5-int.h"
#include "ktfile.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfile_start_seq_get(context, id, cursorp)
krb5_context context;
krb5_keytab id;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfileint_openr(context, id)
krb5_context context;
krb5_keytab id;
return krb5_ktfileint_open(context, id, KRB5_LOCKMODE_SHARED);
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfileint_openw(context, id)
krb5_context context;
krb5_keytab id;
return krb5_ktfileint_open(context, id, KRB5_LOCKMODE_EXCLUSIVE);
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfileint_close(context, id)
krb5_context context;
krb5_keytab id;
return kerror;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfileint_delete_entry(context, id, delete_point)
krb5_context context;
krb5_keytab id;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfileint_internal_read_entry(context, id, ret_entry, delete_point)
krb5_context context;
krb5_keytab id;
return error;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfileint_read_entry(context, id, entryp)
krb5_context context;
krb5_keytab id;
return krb5_ktfileint_internal_read_entry(context, id, entryp, &delete_point);
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfileint_write_entry(context, id, entry)
krb5_context context;
krb5_keytab id;
* Determine the size needed for a file entry for the given
* keytab entry.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfileint_size_entry(context, entry, size_needed)
krb5_context context;
krb5_keytab_entry *entry;
* to commit the write, but that this field must indicate the size of the
* block in the file rather than the size of the actual entry)
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfileint_find_slot(context, id, size_needed, commit_point)
krb5_context context;
krb5_keytab id;
#include "k5-int.h"
#include "ktfile.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_ktfile_wresolve(context, name, id)
krb5_context context;
const char *name;
extern struct _krb5_kt_ops krb5_ktf_ops;
extern struct _krb5_kt_ops krb5_ktf_writable_ops;
-krb5_error_code INTERFACE krb5_ktfile_resolve
+krb5_error_code krb5_ktfile_resolve
PROTOTYPE((krb5_context,
const char *,
krb5_keytab *));
-krb5_error_code INTERFACE krb5_ktfile_wresolve
+krb5_error_code krb5_ktfile_wresolve
PROTOTYPE((krb5_context,
const char *,
krb5_keytab *));
-krb5_error_code INTERFACE krb5_ktfile_get_name
+krb5_error_code krb5_ktfile_get_name
PROTOTYPE((krb5_context,
krb5_keytab,
char *,
int));
-krb5_error_code INTERFACE krb5_ktfile_close
+krb5_error_code krb5_ktfile_close
PROTOTYPE((krb5_context,
krb5_keytab));
-krb5_error_code INTERFACE krb5_ktfile_get_entry
+krb5_error_code krb5_ktfile_get_entry
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_principal,
krb5_keytype,
krb5_keytab_entry *));
-krb5_error_code INTERFACE krb5_ktfile_start_seq_get
+krb5_error_code krb5_ktfile_start_seq_get
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_kt_cursor *));
-krb5_error_code INTERFACE krb5_ktfile_get_next
+krb5_error_code krb5_ktfile_get_next
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_keytab_entry *,
krb5_kt_cursor *));
-krb5_error_code INTERFACE krb5_ktfile_end_get
+krb5_error_code krb5_ktfile_end_get
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_kt_cursor *));
/* routines to be included on extended version (write routines) */
-krb5_error_code INTERFACE krb5_ktfile_add
+krb5_error_code krb5_ktfile_add
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_keytab_entry *));
-krb5_error_code INTERFACE krb5_ktfile_remove
+krb5_error_code krb5_ktfile_remove
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_keytab_entry *));
-krb5_error_code INTERFACE krb5_ktfileint_openr
+krb5_error_code krb5_ktfileint_openr
PROTOTYPE((krb5_context,
krb5_keytab));
-krb5_error_code INTERFACE krb5_ktfileint_openw
+krb5_error_code krb5_ktfileint_openw
PROTOTYPE((krb5_context,
krb5_keytab));
-krb5_error_code INTERFACE krb5_ktfileint_close
+krb5_error_code krb5_ktfileint_close
PROTOTYPE((krb5_context,
krb5_keytab));
-krb5_error_code INTERFACE krb5_ktfileint_read_entry
+krb5_error_code krb5_ktfileint_read_entry
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_keytab_entry *));
-krb5_error_code INTERFACE krb5_ktfileint_write_entry
+krb5_error_code krb5_ktfileint_write_entry
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_keytab_entry *));
-krb5_error_code INTERFACE krb5_ktfileint_delete_entry
+krb5_error_code krb5_ktfileint_delete_entry
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_int32));
-krb5_error_code INTERFACE krb5_ktfileint_internal_read_entry
+krb5_error_code krb5_ktfileint_internal_read_entry
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_keytab_entry *,
krb5_int32 *));
-krb5_error_code INTERFACE krb5_ktfileint_size_entry
+krb5_error_code krb5_ktfileint_size_entry
PROTOTYPE((krb5_context,
krb5_keytab_entry *,
krb5_int32 *));
-krb5_error_code INTERFACE krb5_ktfileint_find_slot
+krb5_error_code krb5_ktfileint_find_slot
PROTOTYPE((krb5_context,
krb5_keytab,
krb5_int32 *,
#include "k5-int.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_kt_add_entry (context, id, entry)
krb5_context context;
krb5_keytab id;
* don't replace if it already exists; return an error instead.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_kt_register(context, ops)
krb5_context context;
krb5_kt_ops *ops;
* particular keytab type.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_kt_resolve (context, name, ktid)
krb5_context context;
const char *name;
#include "k5-int.h"
#include <stdio.h>
-krb5_error_code INTERFACE
+krb5_error_code
krb5_kt_default(context, id)
krb5_context context;
krb5_keytab *id;
#include "k5-int.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_kt_free_entry (context, entry)
krb5_context context;
krb5_keytab_entry *entry;
#include "k5-int.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_kt_remove_entry (context, id, entry)
krb5_context context;
krb5_keytab id;
* returns: Either KSUCCESS or error code.
* errors: error code if not found or keyprocarg is invalid.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_kt_read_service_key(context, keyprocarg, principal, vno, keytype, key)
krb5_context context;
krb5_pointer keyprocarg;
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+
Fri Mar 31 16:45:47 1995 Keith Vetter (keithv@fusion.com)
* krb5_get_in_tkt: changed error return value for when clocks
/*
* If the two addresses are the same, return TRUE, else return FALSE
*/
-krb5_boolean INTERFACE
+krb5_boolean
krb5_address_compare(context, addr1, addr2)
krb5_context context;
const krb5_address *addr1;
* Return an ordering on two addresses: 0 if the same,
* < 0 if first is less than 2nd, > 0 if first is greater than 2nd.
*/
-int INTERFACE
+int
krb5_address_order(context, addr1, addr2)
krb5_context context;
register const krb5_address *addr1;
* if addr is listed in addrlist, or addrlist is null, return TRUE.
* if not listed, return FALSE
*/
-krb5_boolean INTERFACE
+krb5_boolean
krb5_address_search(context, addr, addrlist)
krb5_context context;
const krb5_address *addr;
#include "k5-int.h"
#include "auth_con.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_init(context, auth_context)
krb5_context context;
krb5_auth_context ** auth_context;
return ENOMEM;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_free(context, auth_context)
krb5_context context;
krb5_auth_context * auth_context;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_setaddrs(context, auth_context, local_addr, remote_addr)
krb5_context context;
krb5_auth_context * auth_context;
}
/* XXX this call is a hack. Fixed when I do the servers. */
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_setkey(context, auth_context, keyblock)
krb5_context context;
krb5_auth_context * auth_context;
* Once decrypted this key is no longer necessary and is then overwritten
* with the session key sent by the client.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_setuseruserkey(context, auth_context, keyblock)
krb5_context context;
krb5_auth_context * auth_context;
return(krb5_copy_keyblock(context, keyblock, &(auth_context->keyblock)));
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_getkey(context, auth_context, keyblock)
krb5_context context;
krb5_auth_context * auth_context;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_getlocalsubkey(context, auth_context, keyblock)
krb5_context context;
krb5_auth_context * auth_context;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_getremotesubkey(context, auth_context, keyblock)
krb5_context context;
krb5_auth_context * auth_context;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_setcksumtype(context, auth_context, cksumtype)
krb5_context context;
krb5_auth_context * auth_context;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_getlocalseqnumber(context, auth_context, seqnumber)
krb5_context context;
krb5_auth_context * auth_context;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_getauthenticator(context, auth_context, authenticator)
krb5_context context;
krb5_auth_context * auth_context;
authenticator));
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_getremoteseqnumber(context, auth_context, seqnumber)
krb5_context context;
krb5_auth_context * auth_context;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_initivector(context, auth_context)
krb5_context context;
krb5_auth_context * auth_context;
return EINVAL; /* XXX need an error for no keyblock */
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_setivector(context, auth_context, ivector)
krb5_context context;
krb5_auth_context * auth_context;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_getivector(context, auth_context, ivector)
krb5_context context;
krb5_auth_context * auth_context;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_setflags(context, auth_context, flags)
krb5_context context;
krb5_auth_context * auth_context;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_con_setrcache(context, auth_context, rcache)
krb5_context context;
krb5_auth_context * auth_context;
#include <varargs.h>
#endif
-krb5_error_code INTERFACE_C
+krb5_error_code
krb5_build_principal_va(context, princ, rlen, realm, ap)
krb5_context context;
krb5_principal princ;
return 0;
}
-krb5_error_code INTERFACE_C
+krb5_error_code
#ifdef HAVE_STDARG_H
krb5_build_principal(krb5_context context, krb5_principal * princ, int rlen,
const char * realm, ...)
#define MAX_REALM_LN 500
-krb5_error_code INTERFACE
+krb5_error_code
krb5_check_transited_list(context, trans, realm1, realm2)
krb5_context context;
krb5_data *trans;
/* XXX This calls for a new error code */
#define KRB5_INVALID_PRINCIPAL KRB5_LNAME_BADFORMAT
-krb5_error_code INTERFACE
+krb5_error_code
krb5_524_conv_principal(context, princ, name, inst, realm)
krb5_context context;
const krb5_principal princ;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_425_conv_principal(context, name, instance, realm, princ)
krb5_context context;
const char *name;
/*
* Copy an address array, with fresh allocation.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_copy_addresses(context, inaddr, outaddr)
krb5_context context;
krb5_address * const * inaddr;
* Note that this function may change the value of *outaddr even if it
* returns failure, but it will not change the contents of the list.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_append_addresses(context, inaddr, outaddr)
krb5_context context;
krb5_address * const * inaddr;
#include "k5-int.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_copy_authenticator(context, authfrom, authto)
krb5_context context;
const krb5_authenticator *authfrom;
/*
* Copy an authdata array, with fresh allocation.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_copy_authdata(context, inauthdat, outauthdat)
krb5_context context;
krb5_authdata * const * inauthdat;
#include "k5-int.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_copy_checksum(context, ckfrom, ckto)
krb5_context context;
const krb5_checksum *ckfrom;
* Copy credentials, allocating fresh storage where needed.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_copy_creds(context, incred, outcred)
krb5_context context;
const krb5_creds *incred;
/*
* Copy a data structure, with fresh allocation.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_copy_data(context, indata, outdata)
krb5_context context;
const krb5_data *indata;
/*
* Copy a keyblock, including alloc'ed storage.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_copy_keyblock(context, from, to)
krb5_context context;
const krb5_keyblock *from;
/*
* Copy a principal structure, with fresh allocation.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_copy_principal(context, inprinc, outprinc)
krb5_context context;
krb5_const_principal inprinc;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_copy_ticket(context, from, pto)
krb5_context context;
const krb5_ticket *from;
/*
* Copy a keyblock, including alloc'ed storage.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_copy_keyblock_contents(context, from, to)
krb5_context context;
const krb5_keyblock *from;
returns errors from encryption routines, system errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_decode_kdc_rep(context, enc_rep, key, etype, dec_rep)
krb5_context context;
krb5_data * enc_rep;
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_decrypt_tkt_part(context, srv_key, ticket)
krb5_context context;
const krb5_keyblock *srv_key;
*/
/* due to argument promotion rules, we need to use the DECLARG/OLDDECLARG
stuff... */
-krb5_error_code INTERFACE
+krb5_error_code
krb5_encode_kdc_rep(context, type, encpart, eblock, client_key, dec_rep, enc_rep)
krb5_context context;
const krb5_msgtype type;
enc_part->ciphertext.data allocated & filled in with encrypted stuff
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_encrypt_tkt_part(context, eblock, srv_key, dec_ticket)
krb5_context context;
krb5_encrypt_block *eblock;
* Return an ordering on the two full addresses: 0 if the same,
* < 0 if first is less than 2nd, > 0 if first is greater than 2nd.
*/
-int INTERFACE
+int
krb5_fulladdr_order(context, addr1, addr2)
krb5_context context;
register const krb5_fulladdr *addr1;
#include "k5-int.h"
-void INTERFACE
+void
krb5_free_realm_tree(context, realms)
krb5_context context;
krb5_principal *realms;
#include "k5-int.h"
#include "int-proto.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_cred_via_2tgt (context, tgt, kdcoptions, sumtype, in_cred, out_cred)
krb5_context context;
krb5_creds *tgt;
#define TGT_ETYPE \
krb5_keytype_array[tgt.keyblock.keytype]->system->proto_enctype;
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_cred_from_kdc(context, ccache, in_cred, out_cred, tgts)
krb5_context context;
krb5_ccache ccache;
#include "k5-int.h"
#include "int-proto.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_cred_via_tgt (context, tgt, kdcoptions, sumtype, in_cred, out_cred)
krb5_context context;
krb5_creds * tgt;
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#endif
-krb5_error_code INTERFACE
+krb5_error_code
krb5_generate_seq_number(context, key, seqno)
krb5_context context;
const krb5_keyblock *key;
#include "k5-int.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_generate_subkey(context, key, subkey)
krb5_context context;
const krb5_keyblock *key;
#define flags2options(flags) (flags & KDC_TKT_COMMON_MASK)
/* Get a TGT for use at the remote host */
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_for_creds(context, sumtype, rhost, client, enc_key,
forwardable, outbuf)
krb5_context context;
/* some typedef's for the function args to make things look a bit cleaner */
-typedef krb5_error_code (INTERFACE *git_key_proc) PROTOTYPE((krb5_context,
+typedef krb5_error_code (*git_key_proc) PROTOTYPE((krb5_context,
const krb5_keytype,
krb5_data *,
krb5_const_pointer,
krb5_keyblock **));
-typedef krb5_error_code (INTERFACE *git_decrypt_proc) PROTOTYPE((krb5_context,
+typedef krb5_error_code (*git_decrypt_proc) PROTOTYPE((krb5_context,
const krb5_keyblock *,
krb5_const_pointer,
krb5_kdc_rep * ));
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_in_tkt(context, options, addrs, etypes, ptypes, key_proc, keyseed,
decrypt_proc, decryptarg, creds, ccache, ret_as_reply)
krb5_context context;
* "keyseed" is actually a krb5_keytab, or NULL if we should fetch
* from system area.
*/
-krb5_error_code INTERFACE keytab_keyproc
+krb5_error_code keytab_keyproc
PROTOTYPE((krb5_context,
const krb5_keytype,
krb5_data *,
krb5_const_pointer,
krb5_keyblock **));
-krb5_error_code INTERFACE
+krb5_error_code
keytab_keyproc(context, type, salt, keyseed, key)
krb5_context context;
const krb5_keytype type;
returns system errors, encryption errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_in_tkt_with_keytab(context, options, addrs, etypes, pre_auth_types,
keytab, ccache, creds, ret_as_reply)
krb5_context context;
/*
* key-producing procedure for use by krb5_get_in_tkt_with_password.
*/
-krb5_error_code INTERFACE pwd_keyproc
+krb5_error_code pwd_keyproc
PROTOTYPE((krb5_context,
const krb5_keytype,
krb5_data *,
krb5_const_pointer,
krb5_keyblock **));
-krb5_error_code INTERFACE
+krb5_error_code
pwd_keyproc(context, type, salt, keyseed, key)
krb5_context context;
const krb5_keytype type;
* "keyseed" is actually a krb5_keyblock *, or NULL if we should fetch
* from system area.
*/
-krb5_error_code INTERFACE skey_keyproc
+krb5_error_code skey_keyproc
PROTOTYPE((krb5_context,
const krb5_keytype,
krb5_data *,
krb5_const_pointer,
krb5_keyblock **));
-krb5_error_code INTERFACE
+krb5_error_code
skey_keyproc(context, type, salt, keyseed, key)
krb5_context context;
const krb5_keytype type;
returns system errors, encryption errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_in_tkt_with_skey(context, options, addrs, etypes, pre_auth_types,
key, ccache, creds, ret_as_reply)
krb5_context context;
return retval;
}
-void INTERFACE
+void
krb5_free_context(ctx)
krb5_context ctx;
{
/*
* Set the desired default etypes, making sure they are valid.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_set_default_in_tkt_etypes(context, etypes)
krb5_context context;
const krb5_enctype *etypes;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_default_in_tkt_etypes(context, etypes)
krb5_context context;
krb5_enctype **etypes;
#ifndef KRB5_INT_FUNC_PROTO__
#define KRB5_INT_FUNC_PROTO__
-krb5_error_code INTERFACE krb5_tgtname
+krb5_error_code krb5_tgtname
PROTOTYPE((krb5_context context,
const krb5_data *,
const krb5_data *,
krb5_principal *));
-krb5_error_code INTERFACE krb5_get_cred_via_tgt
+krb5_error_code krb5_get_cred_via_tgt
PROTOTYPE((krb5_context context,
krb5_creds *,
const krb5_flags,
const krb5_cksumtype,
krb5_creds *,
krb5_creds **));
-krb5_error_code INTERFACE krb5_get_cred_via_2tgt
+krb5_error_code krb5_get_cred_via_2tgt
PROTOTYPE((krb5_context context,
krb5_creds *,
const krb5_flags,
*/
/*ARGSUSED*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_kdc_rep_decrypt_proc(context, key, decryptarg, dec_rep)
krb5_context context;
const krb5_keyblock * key;
#include "k5-int.h"
/* Create asn.1 encoded KRB-CRED message from the kdc reply. */
-krb5_error_code INTERFACE
+krb5_error_code
krb5_mk_cred(context, dec_rep, etype, key, sender_addr, recv_addr, outbuf)
krb5_context context;
krb5_kdc_rep *dec_rep;
returns system errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_mk_error(context, dec_err, enc_err)
krb5_context context;
const krb5_error *dec_err;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_mk_priv(context, auth_context, userdata, outbuf, outdata)
krb5_context context;
krb5_auth_context * auth_context;
returns system errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_mk_rep(context, auth_context, outbuf)
krb5_context context;
krb5_auth_context * auth_context;
extern krb5_flags krb5_kdc_default_options;
-krb5_error_code INTERFACE
+krb5_error_code
krb5_mk_req(context, auth_context, ap_req_options, service, hostname, in_data,
ccache, outbuf)
krb5_context context;
return retval;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_mk_safe(context, auth_context, userdata, outbuf, outdata)
krb5_context context;
krb5_auth_context * auth_context;
/*
* Convert a krb5_principal into the default salt for that principal.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_principal2salt_internal(context, pr, ret, use_realm)
krb5_context context;
register krb5_const_principal pr;
return 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_principal2salt(context, pr, ret)
krb5_context context;
register krb5_const_principal pr;
return krb5_principal2salt_internal(context, pr, ret, 1);
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_principal2salt_norealm(context, pr, ret)
krb5_context context;
register krb5_const_principal pr;
*
* Note: This is a first crack at what any preauthentication will need...
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_obtain_padata(context, type, client, src_addr, encrypt_key, ret_data)
krb5_context context;
int type; /*IN: Preauth type */
* Note: This is a first crack at what any preauthentication will need...
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_verify_padata(context, data,client,src_addr, decrypt_key, req_id, flags)
krb5_context context;
krb5_pa_data *data; /*IN: padata */
*/
int seeded = 0 ; /* Used by srand below */
-krb5_error_code INTERFACE
+krb5_error_code
get_unixtime_padata(context, client, src_addr, pa_data)
krb5_context context;
krb5_principal client;
return(0);
}
-krb5_error_code INTERFACE
+krb5_error_code
verify_unixtime_padata(context, client, src_addr, data)
krb5_context context;
krb5_principal client;
#include "sdcli.h"
#include "sdconf.c"
-krb5_error_code INTERFACE
+krb5_error_code
verify_securid_padata(client, src_addr, data)
krb5_principal client;
krb5_address **src_addr;
}
}
#else
-krb5_error_code INTERFACE
+krb5_error_code
verify_securid_padata(context, client, src_addr, data)
krb5_context context;
krb5_principal client;
*/
static char *krb5_SecureId_prompt = "\nEnter Your SecurId Access Code Prepended with Your PIN\n (or a \'#\'if Your PIN is entered on the card keypad): ";
-krb5_error_code INTERFACE
+krb5_error_code
get_securid_padata(context, client,src_addr,pa_data)
krb5_context context;
krb5_principal client;
#include "k5-int.h"
-krb5_boolean INTERFACE
+krb5_boolean
krb5_realm_compare(context, princ1, princ2)
krb5_context context;
krb5_const_principal princ1;
return TRUE;
}
-krb5_boolean INTERFACE
+krb5_boolean
krb5_principal_compare(context, princ1, princ2)
krb5_context context;
krb5_const_principal princ1;
#define in_clock_skew(date) (labs((date)-currenttime) < krb5_clockskew)
/* Decode the KRB-CRED message, and return creds */
-krb5_error_code INTERFACE
+krb5_error_code
krb5_rd_cred(context, inbuf, key, creds, sender_addr, recv_addr)
krb5_context context;
const krb5_data *inbuf;
* returns system errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_rd_error(context, enc_errbuf, dec_error)
krb5_context context;
const krb5_data *enc_errbuf;
return retval;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_rd_priv(context, auth_context, inbuf, outbuf, outdata)
krb5_context context;
krb5_auth_context * auth_context;
* returns system errors, encryption errors, replay errors
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_rd_req(context, auth_context, inbuf, server, keytab,
ap_req_options, ticket)
krb5_context context;
return retval;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_rd_req_decoded(context, auth_context, req, server, keytab,
ap_req_options, ticket)
krb5_context context;
return retval;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_rd_safe(context, auth_context, inbuf, outbuf, outdata)
krb5_context context;
krb5_auth_context * auth_context;
static char *sendauth_version = "KRB5_SENDAUTH_V1.0";
-krb5_error_code INTERFACE
+krb5_error_code
krb5_recvauth(context, auth_context,
/* IN */
fd, appl_version, server, rc_type, flags, keytab,
return retval;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_send_tgs(context, kdcoptions, timestruct, etypes, sumtype, sname, addrs,
authorization_data, padata, second_ticket, in_cred, rep)
krb5_context context;
static char *sendauth_version = "KRB5_SENDAUTH_V1.0";
-krb5_error_code INTERFACE
+krb5_error_code
krb5_sendauth(context, auth_context,
/* IN */
fd, appl_version, client, server, ap_req_options, in_data,
#include <ctype.h>
#include <stdio.h>
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_server_rcache(context, piece, rcptr)
krb5_context context;
const krb5_data *piece;
/* This is an internal-only function, used by krb5_get_cred_from_kdc() */
-krb5_error_code INTERFACE
+krb5_error_code
krb5_tgtname(context, server, client, tgtprinc)
krb5_context context;
const krb5_data *server, *client;
#define REALM_SEP '@'
#define COMPONENT_SEP '/'
-krb5_error_code INTERFACE
+krb5_error_code
krb5_unparse_name_ext(context, principal, name, size)
krb5_context context;
krb5_const_principal principal;
#define max(x,y) ((x) > (y) ? (x) : (y))
#endif
-krb5_error_code INTERFACE
+krb5_error_code
krb5_walk_realm_tree(context, client, server, tree, realm_branch_char)
krb5_context context;
const krb5_data *client, *server;
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+ * read_pwd.c: __STDC__ conditional also checks the _WINDOWS define.
+
Fri Apr 7 15:32:04 1995 Keith Vetter (keithv@fusion.com)
* ccdefname.c:
#ifdef _MSDOS
-krb5_error_code INTERFACE
+krb5_error_code
krb5_aname_to_localname(context, aname, lnsize, lname)
krb5_context context;
krb5_const_principal aname;
#include "k5-int.h"
#include <stdio.h>
-char * INTERFACE
+char *
krb5_cc_default_name(context)
krb5_context context;
{
Frees the storage taken by a realm list returned by krb5_get_local_realm.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_free_host_realm(context, realmlist)
krb5_context context;
char * const *realmlist;
Frees the storage taken by a host list returned by krb5_get_krbhst.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_free_krbhst(context, hostlist)
krb5_context context;
char * const *hostlist;
#include "os-proto.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_make_full_ipaddr(context, adr, port, outaddr)
krb5_context context;
krb5_int32 adr;
#include "k5-int.h"
#include "os-proto.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_gen_portaddr(context, addr, ptr, outaddr)
krb5_context context;
const krb5_address *addr;
#include "k5-int.h"
#include "os-proto.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_gen_replay_name(context, address, uniq, string)
krb5_context context;
const krb5_address *address;
extern char *krb5_config_file; /* extern so can be set at
load/runtime */
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_krbhst(context, realm, hostlist)
krb5_context context;
const krb5_data *realm;
#endif /* _WINDOWS */
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_host_realm(context, host, realmsp)
krb5_context context;
const char *host;
#include "k5-int.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_os_init_context(ctx)
krb5_context ctx;
{
return 0;
}
-void INTERFACE
+void
krb5_os_free_context(ctx)
krb5_context ctx;
{
# define OPEN_MODE_NOT_TRUSTWORTHY
#endif
-krb5_error_code INTERFACE
+krb5_error_code
krb5_create_secure_file(context, pathname)
krb5_context context;
const char * pathname;
}
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_sync_disk_file(context, fp)
krb5_context context;
FILE *fp;
extern char *krb5_defkeyname;
-krb5_error_code INTERFACE
+krb5_error_code
krb5_kt_default_name(context, name, namesize)
krb5_context context;
char *name;
* If the given Kerberos name "server" translates to the same name as "luser"
* (using * krb5_aname_to_lname()), returns TRUE.
*/
-krb5_boolean INTERFACE
+krb5_boolean
krb5_kuserok(context, principal, luser)
krb5_context context;
krb5_principal principal;
* returns count of number of addresses found
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_locate_kdc(context, realm, addr_pp, naddrs)
krb5_context context;
const krb5_data *realm;
}
#else /* MSDOS or Macintosh */
-krb5_error_code INTERFACE
+krb5_error_code
krb5_lock_file(context, filep, pathname, mode)
krb5_context context;
FILE *filep;
* XXX must not use non-blocking I/O
*/
-int INTERFACE
+int
krb5_net_read(context, fd, buf, len)
krb5_context context;
int fd;
* XXX must not use non-blocking I/O
*/
-int INTERFACE
+int
krb5_net_write(context, fd, buf, len)
krb5_context context;
int fd;
#define KRB5_LIBOS_INT_PROTO__
#ifdef SOCK_DGRAM /* XXX hack... */
-krb5_error_code INTERFACE krb5_locate_kdc
+krb5_error_code krb5_locate_kdc
PROTOTYPE((krb5_context,
const krb5_data *,
struct sockaddr **,
#endif
#ifdef KRB5_USE_INET
-krb5_error_code INTERFACE krb5_unpack_full_ipaddr
+krb5_error_code krb5_unpack_full_ipaddr
PROTOTYPE((krb5_context,
const krb5_address *,
krb5_int32 *,
krb5_int16 *));
#ifdef NARROW_PROTOTYPES
-krb5_error_code INTERFACE krb5_make_full_ipaddr
+krb5_error_code krb5_make_full_ipaddr
PROTOTYPE((krb5_context,
krb5_int32,
krb5_int16,
krb5_address **));
#else
-krb5_error_code INTERFACE krb5_make_full_ipaddr
+krb5_error_code krb5_make_full_ipaddr
PROTOTYPE((krb5_context,
krb5_int32,
int, /* unsigned short promotes to signed
#ifdef KRB5_USE_INET
#include "os-proto.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_unpack_full_ipaddr(context, inaddr, adr, port)
krb5_context context;
const krb5_address *inaddr;
#include "k5-int.h"
#include <errno.h>
-krb5_error_code INTERFACE
+krb5_error_code
krb5_read_message(context, fdp, inbuf)
krb5_context context;
krb5_pointer fdp;
int *size_return;
{
/* adapted from Kerberos v4 des/read_password.c */
-#if defined(__STDC__) || defined(mips)
+#if defined(__STDC__) || defined(mips) || defined(_WINDOWS)
/* readin_string is used after a longjmp, so must be volatile */
volatile
#endif
/* Don't expect to be called, just define it for sanity and the linker.
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_read_password(context, prompt, prompt2, return_pwd, size_return)
krb5_context context;
char *prompt;
#endif /* _WINDOWS */
-krb5_error_code INTERFACE
+krb5_error_code
krb5_get_realm_domain(context, realm, domain)
krb5_context context;
const char *realm;
extern int krb5_skdc_timeout_shift;
extern int krb5_skdc_timeout_1;
-krb5_error_code INTERFACE
+krb5_error_code
krb5_sendto_kdc (context, message, realm, reply)
krb5_context context;
const krb5_data * message;
#include <stdio.h>
#include "k5-int.h"
-krb5_error_code INTERFACE
+krb5_error_code
krb5_unlock_file(context, filep, pathname)
krb5_context context;
FILE *filep;
#include "k5-int.h"
#include <errno.h>
-krb5_error_code INTERFACE
+krb5_error_code
krb5_write_message(context, fdp, outbuf)
krb5_context context;
krb5_pointer fdp;
+Thu Apr 13 16:44:55 1995 Keith Vetter (keithv@fusion.com)
+
+ * syslog.c: __STDC__ conditional also checks the _WINDOWS define.
+
Tue Mar 28 18:46:55 1995 John Gilmore (gnu at toad.com)
* configure.in (AC_REPLACE_FUNCS): Add getuid to the list.
* Modified to use UNIX domain IPC by Ralph Campbell
*/
-#ifndef _MSDOS
-#ifdef __STDC__
+#ifndef _WINDOWS
+
+#if defined(__STDC__) || defined(_WINDOWS)
#include <stdarg.h>
#else
#define const
void
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
syslog(int pri, const char *fmt, ...)
#else
syslog(pri, fmt, va_alist)
{
va_list pvar;
void vsyslog();
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
va_start(pvar, fmt);
#else
va_start(pvar);
+Thu Apr 13 15:49:16 1995 Keith Vetter (keithv@fusion.com)
+
+ * *.[ch]: removed unneeded INTERFACE from non-api functions.
+
Fri Mar 31 16:44:34 1995 Theodore Y. Ts'o (tytso@dcl)
* rc_dfl.c (krb5_rc_dfl_expunage): Close the old, temporary reply
semaphore ex_typelist = 1;
#endif
-krb5_error_code INTERFACE krb5_rc_register_type(context, ops)
+krb5_error_code krb5_rc_register_type(context, ops)
krb5_context context;
krb5_rc_ops *ops;
{
return 0;
}
-krb5_error_code INTERFACE krb5_rc_resolve_type(context, id, type)
+krb5_error_code krb5_rc_resolve_type(context, id, type)
krb5_context context;
krb5_rcache *id;
char *type;
return 0;
}
-char * INTERFACE krb5_rc_get_type(context, id)
+char * krb5_rc_get_type(context, id)
krb5_context context;
krb5_rcache id;
{
return id->ops->type;
}
-char * INTERFACE krb5_rc_default_type(context)
+char * krb5_rc_default_type(context)
krb5_context context;
{
char *s;
return "dfl";
}
-char * INTERFACE krb5_rc_default_name(context)
+char * krb5_rc_default_name(context)
krb5_context context;
{
char *s;
return (char *) 0;
}
-krb5_error_code INTERFACE
+krb5_error_code
krb5_rc_default(context, id)
krb5_context context;
krb5_rcache *id;
}
-krb5_error_code INTERFACE krb5_rc_resolve_full(context, id, string_name)
+krb5_error_code krb5_rc_resolve_full(context, id, string_name)
krb5_context context;
krb5_rcache *id;
char *string_name;
given auth, take important information and make rep; return -1 if failed
*/
-krb5_error_code INTERFACE
+krb5_error_code
krb5_auth_to_rep(context, auth, rep)
krb5_context context;
krb5_tkt_authent *auth;
return CMP_HOHUM;
}
-char * INTERFACE krb5_rc_dfl_get_name(context, id)
+char * krb5_rc_dfl_get_name(context, id)
krb5_context context;
krb5_rcache id;
{
return ((struct dfl_data *) (id->data))->name;
}
-krb5_error_code INTERFACE krb5_rc_dfl_get_span(context, id, lifespan)
+krb5_error_code krb5_rc_dfl_get_span(context, id, lifespan)
krb5_context context;
krb5_rcache id;
krb5_deltat *lifespan;
return 0;
}
-krb5_error_code INTERFACE krb5_rc_dfl_init(context, id, lifespan)
+krb5_error_code krb5_rc_dfl_init(context, id, lifespan)
krb5_context context;
krb5_rcache id;
krb5_deltat lifespan;
return 0;
}
-krb5_error_code INTERFACE krb5_rc_dfl_close_no_free(context, id)
+krb5_error_code krb5_rc_dfl_close_no_free(context, id)
krb5_context context;
krb5_rcache id;
{
return 0;
}
-krb5_error_code INTERFACE krb5_rc_dfl_close(context, id)
+krb5_error_code krb5_rc_dfl_close(context, id)
krb5_context context;
krb5_rcache id;
{
return 0;
}
-krb5_error_code INTERFACE krb5_rc_dfl_destroy(context, id)
+krb5_error_code krb5_rc_dfl_destroy(context, id)
krb5_context context;
krb5_rcache id;
{
return krb5_rc_dfl_close(context, id);
}
-krb5_error_code INTERFACE krb5_rc_dfl_resolve(context, id, name)
+krb5_error_code krb5_rc_dfl_resolve(context, id, name)
krb5_context context;
krb5_rcache id;
char *name;
return retval;
}
-void INTERFACE krb5_rc_free_entry (context, rep)
+void krb5_rc_free_entry (context, rep)
krb5_context context;
krb5_donot_replay **rep;
{
-krb5_error_code INTERFACE krb5_rc_dfl_recover(context, id)
+krb5_error_code krb5_rc_dfl_recover(context, id)
krb5_context context;
krb5_rcache id;
{
return ret;
}
-krb5_error_code INTERFACE krb5_rc_dfl_store(context, id, rep)
+krb5_error_code krb5_rc_dfl_store(context, id, rep)
krb5_context context;
krb5_rcache id;
krb5_donot_replay *rep;
return 0;
}
-krb5_error_code INTERFACE krb5_rc_dfl_expunge(context, id)
+krb5_error_code krb5_rc_dfl_expunge(context, id)
krb5_context context;
krb5_rcache id;
{
extern krb5_rc_ops krb5_rc_dfl_ops; /* initialized to the following */
-krb5_error_code INTERFACE krb5_rc_dfl_init
+krb5_error_code krb5_rc_dfl_init
PROTOTYPE((krb5_context,
krb5_rcache,
krb5_deltat));
-krb5_error_code INTERFACE krb5_rc_dfl_recover
+krb5_error_code krb5_rc_dfl_recover
PROTOTYPE((krb5_context,
krb5_rcache));
-krb5_error_code INTERFACE krb5_rc_dfl_destroy
+krb5_error_code krb5_rc_dfl_destroy
PROTOTYPE((krb5_context,
krb5_rcache));
-krb5_error_code INTERFACE krb5_rc_dfl_close
+krb5_error_code krb5_rc_dfl_close
PROTOTYPE((krb5_context,
krb5_rcache));
-krb5_error_code INTERFACE krb5_rc_dfl_store
+krb5_error_code krb5_rc_dfl_store
PROTOTYPE((krb5_context,
krb5_rcache,
krb5_donot_replay *));
-krb5_error_code INTERFACE krb5_rc_dfl_expunge
+krb5_error_code krb5_rc_dfl_expunge
PROTOTYPE((krb5_context,
krb5_rcache));
-krb5_error_code INTERFACE krb5_rc_dfl_get_span
+krb5_error_code krb5_rc_dfl_get_span
PROTOTYPE((krb5_context,
krb5_rcache,
krb5_deltat *));
-char * INTERFACE krb5_rc_dfl_get_name
+char * krb5_rc_dfl_get_name
PROTOTYPE((krb5_context,
krb5_rcache));
-krb5_error_code INTERFACE krb5_rc_dfl_resolve
+krb5_error_code krb5_rc_dfl_resolve
PROTOTYPE((krb5_context,
krb5_rcache,
char *));
-krb5_error_code INTERFACE krb5_rc_dfl_close_no_free
+krb5_error_code krb5_rc_dfl_close_no_free
PROTOTYPE((krb5_context,
krb5_rcache));
-void INTERFACE krb5_rc_free_entry
+void krb5_rc_free_entry
PROTOTYPE((krb5_context,
krb5_donot_replay **));
#endif
}
}
-krb5_error_code INTERFACE krb5_rc_io_creat (context, d, fn)
+krb5_error_code krb5_rc_io_creat (context, d, fn)
krb5_context context;
krb5_rc_iostuff *d;
char **fn;
return 0;
}
-krb5_error_code INTERFACE krb5_rc_io_open (context, d, fn)
+krb5_error_code krb5_rc_io_open (context, d, fn)
krb5_context context;
krb5_rc_iostuff *d;
char *fn;
return 0;
}
-krb5_error_code INTERFACE krb5_rc_io_move (context, new, old)
+krb5_error_code krb5_rc_io_move (context, new, old)
krb5_context context;
krb5_rc_iostuff *new;
krb5_rc_iostuff *old;
return 0;
}
-krb5_error_code INTERFACE krb5_rc_io_write (context, d, buf, num)
+krb5_error_code krb5_rc_io_write (context, d, buf, num)
krb5_context context;
krb5_rc_iostuff *d;
krb5_pointer buf;
return 0;
}
-krb5_error_code INTERFACE krb5_rc_io_sync (context, d)
+krb5_error_code krb5_rc_io_sync (context, d)
krb5_context context;
krb5_rc_iostuff *d;
{
return 0;
}
-krb5_error_code INTERFACE krb5_rc_io_read (context, d, buf, num)
+krb5_error_code krb5_rc_io_read (context, d, buf, num)
krb5_context context;
krb5_rc_iostuff *d;
krb5_pointer buf;
return 0;
}
-krb5_error_code INTERFACE krb5_rc_io_close (context, d)
+krb5_error_code krb5_rc_io_close (context, d)
krb5_context context;
krb5_rc_iostuff *d;
{
return 0;
}
-krb5_error_code INTERFACE krb5_rc_io_destroy (context, d)
+krb5_error_code krb5_rc_io_destroy (context, d)
krb5_context context;
krb5_rc_iostuff *d;
{
return 0;
}
-krb5_error_code INTERFACE krb5_rc_io_mark (context, d)
+krb5_error_code krb5_rc_io_mark (context, d)
krb5_context context;
krb5_rc_iostuff *d;
{
return 0;
}
-krb5_error_code INTERFACE krb5_rc_io_unmark (context, d)
+krb5_error_code krb5_rc_io_unmark (context, d)
krb5_context context;
krb5_rc_iostuff *d;
{
return 0;
}
-long INTERFACE
+long
krb5_rc_io_size (context, d)
krb5_context context;
krb5_rc_iostuff *d;
/* first argument is always iostuff for result file */
-krb5_error_code INTERFACE krb5_rc_io_creat
+krb5_error_code krb5_rc_io_creat
PROTOTYPE((krb5_context,
krb5_rc_iostuff *,
char **));
-krb5_error_code INTERFACE krb5_rc_io_open
+krb5_error_code krb5_rc_io_open
PROTOTYPE((krb5_context,
krb5_rc_iostuff *,
char *));
-krb5_error_code INTERFACE krb5_rc_io_move
+krb5_error_code krb5_rc_io_move
PROTOTYPE((krb5_context,
krb5_rc_iostuff *,
krb5_rc_iostuff *));
-krb5_error_code INTERFACE krb5_rc_io_write
+krb5_error_code krb5_rc_io_write
PROTOTYPE((krb5_context,
krb5_rc_iostuff *,
krb5_pointer,
int));
-krb5_error_code INTERFACE krb5_rc_io_read
+krb5_error_code krb5_rc_io_read
PROTOTYPE((krb5_context,
krb5_rc_iostuff *,
krb5_pointer,
int));
-krb5_error_code INTERFACE krb5_rc_io_close
+krb5_error_code krb5_rc_io_close
PROTOTYPE((krb5_context,
krb5_rc_iostuff *));
-krb5_error_code INTERFACE krb5_rc_io_destroy
+krb5_error_code krb5_rc_io_destroy
PROTOTYPE((krb5_context,
krb5_rc_iostuff *));
-krb5_error_code INTERFACE krb5_rc_io_mark
+krb5_error_code krb5_rc_io_mark
PROTOTYPE((krb5_context,
krb5_rc_iostuff *));
-krb5_error_code INTERFACE krb5_rc_io_unmark
+krb5_error_code krb5_rc_io_unmark
PROTOTYPE((krb5_context,
krb5_rc_iostuff *));
-krb5_error_code INTERFACE krb5_rc_io_sync
+krb5_error_code krb5_rc_io_sync
PROTOTYPE((krb5_context,
krb5_rc_iostuff *));
-long INTERFACE krb5_rc_io_size
+long krb5_rc_io_size
PROTOTYPE((krb5_context,
krb5_rc_iostuff *));
#endif
-;-----------------------------
-; LIBKRB5.DEF - module definition file
-;-----------------------------
+;----------------------------------------------------
+; LIBKRB5.DEF - LIBKRB5.DLL module definition file
+;----------------------------------------------------
-LIBRARY LIBKRB5
-DESCRIPTION 'DLL for Kerberos 5'
-EXETYPE WINDOWS
-CODE PRELOAD MOVEABLE DISCARDABLE
-DATA PRELOAD MOVEABLE SINGLE
-HEAPSIZE 8192
+LIBRARY LIBKRB5
+DESCRIPTION 'DLL for Kerberos 5'
+EXETYPE WINDOWS
+CODE PRELOAD MOVEABLE DISCARDABLE
+DATA PRELOAD MOVEABLE SINGLE
+HEAPSIZE 8192
EXPORTS
- WEP @1 RESIDENTNAME
- LIBMAIN @2
+ WEP @1001 RESIDENTNAME
+ LIBMAIN @1002
+ GSS_ACQUIRE_CRED @1
+ GSS_RELEASE_CRED @2
+ GSS_INIT_SEC_CONTEXT @3
+ GSS_ACCEPT_SEC_CONTEXT @4
+ GSS_PROCESS_CONTEXT_TOKEN @5
+ GSS_DELETE_SEC_CONTEXT @6
+ GSS_CONTEXT_TIME @7
+ GSS_SIGN @8
+ GSS_VERIFY @9
+ GSS_SEAL @10
+ GSS_UNSEAL @11
+ GSS_DISPLAY_STATUS @12
+ GSS_INDICATE_MECHS @13
+ GSS_COMPARE_NAME @14
+ GSS_DISPLAY_NAME @15
+ GSS_IMPORT_NAME @16
+ GSS_RELEASE_NAME @17
+ GSS_RELEASE_BUFFER @18
+ GSS_RELEASE_OID_SET @19
+ GSS_INQUIRE_CRED @20
+; Kerberos 5
_krb5_build_principal_ext
KRB5_CC_DEFAULT
KRB5_FREE_ADDRESSES
;Com_err routines
_com_err
ERROR_MESSAGE
-;GSSAPI
- GSS_ACCEPT_SEC_CONTEXT
- GSS_ACQUIRE_CRED
- GSS_COMPARE_NAME
- GSS_CONTEXT_TIME
- GSS_DELETE_SEC_CONTEXT
- GSS_DISPLAY_NAME
- GSS_DISPLAY_STATUS
- GSS_IMPORT_NAME
- GSS_INDICATE_MECHS
- GSS_INIT_SEC_CONTEXT
- GSS_INQUIRE_CONTEXT
- GSS_INQUIRE_CRED
- GSS_PROCESS_CONTEXT_TOKEN
- GSS_RELEASE_BUFFER
- GSS_RELEASE_CRED
- GSS_RELEASE_NAME
- GSS_RELEASE_OID_SET
- GSS_SEAL
- GSS_SIGN
- GSS_UNSEAL
- GSS_VERIFY
-
+Thu Apr 13 16:02:24 1995 Keith Vetter (keithv@fusion.com)
+
+ * com_err.c, compile_et.c, error_ta.h, et_c.awk, internal.h:
+ __STDC__ conditionals also checks for the _WINDOWS define.
+
Wed Apr 5 16:25:35 1995 Keith Vetter (keithv@fusion.com)
* com_err.h: added FAR to pointers in prototypes.
* should fix up com_err.h so that it's safe to #include here
* directly.
*/
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
extern char const * INTERFACE error_message (long);
#else
extern char * INTERFACE error_message ();
#endif
static void
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
default_com_err_proc (const char *whoami, long code, const char *fmt, va_list args)
#else
default_com_err_proc (whoami, code, fmt, args)
#endif
}
-#ifdef __STDC__
+#if defined(__STDC__) || defined(_WINDOWS)
typedef void (*errf) (const char *, long, const char *, va_list);
#else
typedef void (*errf) ();
};
static const char * const krc_src_prolog[] = {
- "#ifdef __STDC__\n",
+ "#if defined(__STDC__) || defined(_WINDOWS)\n",
"#define NOARGS void\n",
"#else\n",
"#define NOARGS\n",
#define ERRCODE_RANGE 8 /* # of bits to shift table number */
#define BITS_PER_CHAR 6 /* # bits to shift per character in name */
-#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES)
+#if defined(__STDC__) || defined(KRB5_PROVIDE_PROTOTYPES) || defined(_WINDOWS)
extern const char *error_table_name (long);
#else
extern const char *error_table_name ();
print " * This file is automatically generated; please do not edit it." > outfile
print " */" > outfile
- print "#ifdef __STDC__" > outfile
+ print "#if defined(__STDC__) || defined(_WINDOWS)" > outfile
print "#define NOARGS void" > outfile
print "#else" > outfile
print "#define NOARGS" > outfile
extern const int sys_nerr;
#endif
-#if defined(__STDC__) && !defined(HDR_HAS_PERROR)
+#if defined(__STDC__) && !defined(HDR_HAS_PERROR) && !defined(_WINDOWS)
void perror (const char *);
#endif
+Thu Apr 13 16:19:01 1995 Keith Vetter (keithv@fusion.com)
+
+ * cns.c: Added better error message for incorrect password.
+ * tktlist.c: flag string gets displayed within parentheses.
+
Fri Apr 7 15:03:10 1995 Keith Vetter (keithv@fusion.com)
* cns.c, cns.h, cns.rc: added option dialog widget allowing user
krb5_principal principal;
krb5_creds creds;
krb5_principal server;
- krb5_timestamp now;
krb5_int32 sec, usec;
#endif
code = krb5_us_timeofday(k5_context, &sec, &usec);
if (code) break;
- code = krb5_timeofday(k5_context, &now);
- if (code) break;
- if (labs(now-sec) > 60*60) { // Off by more than an hour
- MessageBox (NULL, "DEBUG: timeofday != us_timeofday", NULL, 0);
- now = sec;
- }
creds.times.starttime = 0;
creds.times.endtime = sec + 60L * lifetime;
creds.times.renew_till = 0;
#ifdef KRB5
if (code) {
- com_err (NULL, code, "while logging in");
+ if (code == KRB5KRB_AP_ERR_BAD_INTEGRITY)
+ MessageBox (hwnd, "Password incorrect", NULL,
+ MB_OK | MB_ICONEXCLAMATION);
+ else
+ com_err (NULL, code, "while logging in");
return TRUE;
}
#endif
int i = 0;
buf[i++] = ' ';
+ buf[i++] = '(';
if (cred->ticket_flags & TKT_FLG_FORWARDABLE)
buf[i++] = 'F';
if (cred->ticket_flags & TKT_FLG_FORWARDED)
if (cred->ticket_flags & TKT_FLG_PRE_AUTH)
buf[i++] = 'A';
+ buf[i++] = ')';
buf[i] = '\0';
+ if (i <= 3)
+ buf[0] = '\0';
return(buf);
}
projects / krb5.git / commitdiff