From 7679d12a91940657639c5550ba5e6c0fc65ba8af Mon Sep 17 00:00:00 2001 From: Sam Hartman Date: Wed, 28 Sep 2011 21:02:41 +0000 Subject: Moved Windows specific include files to src/windows/include Updated Windows specific Makefiles to search for header files in src/windows/include Signed-off-by: Alexey Melnikov git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@25279 dc483132-0cff-0310-8789-dd5450dbe970 --- src/windows/include/arpa/nameser.h | 263 +++++ src/windows/include/hesiod.h | 217 ++++ src/windows/include/leasherr.h | 32 + src/windows/include/leashinfo.h | 2 + src/windows/include/leashwin.h | 198 ++++ src/windows/include/loadfuncs-com_err.h | 44 + src/windows/include/loadfuncs-krb5.h | 1778 +++++++++++++++++++++++++++++++ src/windows/include/loadfuncs-leash.h | 413 +++++++ src/windows/include/loadfuncs-lsa.h | 45 + src/windows/include/loadfuncs-profile.h | 151 +++ src/windows/include/loadfuncs.h | 41 + src/windows/include/mitwhich.h | 84 ++ src/windows/include/resolv.h | 284 +++++ src/windows/include/wshelper.h | 148 +++ 14 files changed, 3700 insertions(+) create mode 100644 src/windows/include/arpa/nameser.h create mode 100644 src/windows/include/hesiod.h create mode 100644 src/windows/include/leasherr.h create mode 100644 src/windows/include/leashinfo.h create mode 100644 src/windows/include/leashwin.h create mode 100644 src/windows/include/loadfuncs-com_err.h create mode 100644 src/windows/include/loadfuncs-krb5.h create mode 100644 src/windows/include/loadfuncs-leash.h create mode 100644 src/windows/include/loadfuncs-lsa.h create mode 100644 src/windows/include/loadfuncs-profile.h create mode 100644 src/windows/include/loadfuncs.h create mode 100644 src/windows/include/mitwhich.h create mode 100644 src/windows/include/resolv.h create mode 100644 src/windows/include/wshelper.h (limited to 'src/windows/include') diff --git a/src/windows/include/arpa/nameser.h b/src/windows/include/arpa/nameser.h new file mode 100644 index 0000000000..f9ddafce96 --- /dev/null +++ b/src/windows/include/arpa/nameser.h @@ -0,0 +1,263 @@ +/* + * @doc + * @module nameser.h | + * Copyright (c) 1983, 1989 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)nameser.h 5.25 (Berkeley) 4/3/91 + */ + +#ifndef _NAMESER_H_ +#define _NAMESER_H_ + +/* + * Define constants based on rfc883 + */ +#define PACKETSZ 512 /* maximum packet size */ +#define MAXDNAME 256 /* maximum domain name */ +#define MAXCDNAME 255 /* maximum compressed domain name */ +#define MAXLABEL 63 /* maximum length of domain label */ + /* Number of bytes of fixed size data in query structure */ +#define QFIXEDSZ 4 + /* number of bytes of fixed size data in resource record */ +#define RRFIXEDSZ 10 + +#if !defined(MAXHOSTNAME) +#define MAXHOSTNAME MAXCDNAME +#endif + +/* + * Internet nameserver port number + */ +#define NAMESERVER_PORT 53 + +/* + * Currently defined opcodes + */ +#define QUERY 0x0 /* standard query */ +#define IQUERY 0x1 /* inverse query */ +#define STATUS 0x2 /* nameserver status query */ +/*#define xxx 0x3 /* 0x3 reserved */ + /* non standard */ +#define UPDATEA 0x9 /* add resource record */ +#define UPDATED 0xa /* delete a specific resource record */ +#define UPDATEDA 0xb /* delete all nemed resource record */ +#define UPDATEM 0xc /* modify a specific resource record */ +#define UPDATEMA 0xd /* modify all named resource record */ + +#define ZONEINIT 0xe /* initial zone transfer */ +#define ZONEREF 0xf /* incremental zone referesh */ + +/* + * Currently defined response codes + */ +#define NOERROR 0 /* no error */ +#define FORMERR 1 /* format error */ +#define SERVFAIL 2 /* server failure */ +#define NXDOMAIN 3 /* non existent domain */ +#define NOTIMP 4 /* not implemented */ +#define REFUSED 5 /* query refused */ + /* non standard */ +#define NOCHANGE 0xf /* update failed to change db */ + +/* + * Type values for resources and queries + */ +#define T_A 1 /* host address */ +#define T_NS 2 /* authoritative server */ +#define T_MD 3 /* mail destination */ +#define T_MF 4 /* mail forwarder */ +#define T_CNAME 5 /* connonical name */ +#define T_SOA 6 /* start of authority zone */ +#define T_MB 7 /* mailbox domain name */ +#define T_MG 8 /* mail group member */ +#define T_MR 9 /* mail rename name */ +#define T_NULL 10 /* null resource record */ +#define T_WKS 11 /* well known service */ +#define T_PTR 12 /* domain name pointer */ +#define T_HINFO 13 /* host information */ +#define T_MINFO 14 /* mailbox information */ +#define T_MX 15 /* mail routing information */ +#define T_TXT 16 /* text strings */ + /* non standard */ +#define T_UINFO 100 /* user (finger) information */ +#define T_UID 101 /* user ID */ +#define T_GID 102 /* group ID */ +#define T_UNSPEC 103 /* Unspecified format (binary data) */ + /* Query type values which do not appear in resource records */ +#define T_AXFR 252 /* transfer zone of authority */ +#define T_MAILB 253 /* transfer mailbox records */ +#define T_MAILA 254 /* transfer mail agent records */ +#define T_ANY 255 /* wildcard match */ + +/* + * Values for class field + */ + +#define C_IN 1 /* the arpa internet */ +#define C_CHAOS 3 /* for chaos net at MIT */ +#define C_HS 4 /* for Hesiod name server at MIT */ + /* Query class values which do not appear in resource records */ +#define C_ANY 255 /* wildcard match */ + +/* + * Status return codes for T_UNSPEC conversion routines + */ +#define CONV_SUCCESS 0 +#define CONV_OVERFLOW -1 +#define CONV_BADFMT -2 +#define CONV_BADCKSUM -3 +#define CONV_BADBUFLEN -4 + +#ifndef BYTE_ORDER +#define LITTLE_ENDIAN 1234 /* least-significant byte first (vax) */ +#define BIG_ENDIAN 4321 /* most-significant byte first (IBM, net) */ +#define PDP_ENDIAN 3412 /* LSB first in word, MSW first in long (pdp) */ + +#if defined(vax) || defined(ns32000) || defined(sun386) || defined(MIPSEL) || \ + defined(BIT_ZERO_ON_RIGHT) +#define BYTE_ORDER LITTLE_ENDIAN + +#endif +#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || \ + defined(is68k) || defined(tahoe) || defined(ibm032) || defined(ibm370) || \ + defined(MIPSEB) || defined (BIT_ZERO_ON_LEFT) +#define BYTE_ORDER BIG_ENDIAN +#endif +#endif /* BYTE_ORDER */ + +#ifndef BYTE_ORDER + /* you must determine what the correct bit order is for your compiler */ + #define BYTE_ORDER LITTLE_ENDIAN /* for Intel x86 series */ +#endif +/* + * Structure for query header, the order of the fields is machine and + * compiler dependent, in our case, the bits within a byte are assignd + * least significant first, while the order of transmition is most + * significant first. This requires a somewhat confusing rearrangement. + */ + +#if defined (_WINDLL) || (_WIN32) +/* define UNIX types */ +#include +#endif + +typedef struct { + u_short id; /* query identification number */ +#if BYTE_ORDER == BIG_ENDIAN + /* fields in third byte */ + u_char qr:1; /* response flag */ + u_char opcode:4; /* purpose of message */ + u_char aa:1; /* authoritive answer */ + u_char tc:1; /* truncated message */ + u_char rd:1; /* recursion desired */ + /* fields in fourth byte */ + u_char ra:1; /* recursion available */ + u_char pr:1; /* primary server required (non standard) */ + u_char unused:2; /* unused bits */ + u_char rcode:4; /* response code */ +#endif +#if BYTE_ORDER == LITTLE_ENDIAN || BYTE_ORDER == PDP_ENDIAN + /* fields in third byte */ + u_char rd:1; /* recursion desired */ + u_char tc:1; /* truncated message */ + u_char aa:1; /* authoritive answer */ + u_char opcode:4; /* purpose of message */ + u_char qr:1; /* response flag */ + /* fields in fourth byte */ + u_char rcode:4; /* response code */ + u_char unused:2; /* unused bits */ + u_char pr:1; /* primary server required (non standard) */ + u_char ra:1; /* recursion available */ +#endif + /* remaining bytes */ + u_short qdcount; /* number of question entries */ + u_short ancount; /* number of answer entries */ + u_short nscount; /* number of authority entries */ + u_short arcount; /* number of resource entries */ +} HEADER; + +/* + * Defines for handling compressed domain names + */ +#define INDIR_MASK 0xc0 + +/* + * Structure for passing resource records around. + */ +struct rrec { + short r_zone; /* zone number */ + short r_class; /* class number */ + short r_type; /* type number */ + u_long r_ttl; /* time to live */ + int r_size; /* size of data area */ + char *r_data; /* pointer to data */ +}; + +extern u_short _getshort(); +extern u_long _getlong(); + +/* + * Inline versions of get/put short/long. + * Pointer is advanced; we assume that both arguments + * are lvalues and will already be in registers. + * cp MUST be u_char *. + */ +#define GETSHORT(s, cp) { \ + (s) = *(cp)++ << 8; \ + (s) |= *(cp)++; \ +} + +#define GETLONG(l, cp) { \ + (l) = *(cp)++ << 8; \ + (l) |= *(cp)++; (l) <<= 8; \ + (l) |= *(cp)++; (l) <<= 8; \ + (l) |= *(cp)++; \ +} + + +#define PUTSHORT(s, cp) { \ + *(cp)++ = (s) >> 8; \ + *(cp)++ = (s); \ +} + +/* + * Warning: PUTLONG destroys its first argument. + */ +#define PUTLONG(l, cp) { \ + (cp)[3] = l; \ + (cp)[2] = (l >>= 8); \ + (cp)[1] = (l >>= 8); \ + (cp)[0] = l >> 8; \ + (cp) += sizeof(u_long); \ +} + +#endif /* !_NAMESER_H_ */ diff --git a/src/windows/include/hesiod.h b/src/windows/include/hesiod.h new file mode 100644 index 0000000000..3005929fce --- /dev/null +++ b/src/windows/include/hesiod.h @@ -0,0 +1,217 @@ +/*! \file hesiod.h + * WSHelper DNS/Hesiod Library + * + * This file contains the function declaration for: \n + * hes_to_bind() \n + * hes_resolve() \n + * hes_error() \n + * hes_free() \n + * hes_getmailhost() \n + * hes_getservbyname() \n + * hes_getpwnam() \n + * hes_getpwuid() \n +*/ + +#ifndef _HESIOD_ +#define _HESIOD_ + + +#include + +/*! \def HESIOD_CONF + * name of the hesiod configuration file. We will look at the file to determine the RHS AND LHS value before using the default. + * Here is a sample hesiod.cfg file: \n + * lhs .ns \n + * rhs .ATHENA.MIT.EDU \n + */ +#define HESIOD_CONF "c:\\net\\tcp\\hesiod.cfg" + +/*! \def DEF_RHS + * default RHS value is the hesiod configuration file is not present + */ +#define DEF_RHS ".Athena.MIT.EDU" + +/*! \def DEF_LHS + * default LHS value is the hesiod configuration file is not present + */ +#define DEF_LHS ".ns" + +/*! \def HES_ER_UNINIT + * HES error code: uninitialized + */ +#define HES_ER_UNINIT -1 + +/*! \def HES_ER_OK + * HES error code: no error + */ +#define HES_ER_OK 0 + +/*! \def HES_ER_NOTFOUND + * HES error code: Hesiod name not found by server + */ +#define HES_ER_NOTFOUND 1 + +/*! \def HES_ER_CONFIG + * HES error code: local problem (no config file?) + */ +#define HES_ER_CONFIG 2 + +/*! \def HES_ER_NET + * HES error code: network problem + */ +#define HES_ER_NET 3 + + +#ifdef __cplusplus +extern "C" { +#endif + +/*! \fn LPSTR WINAPI hes_to_bind(LPSTR HesiodName, LPSTR HesiodNameType) + * hes_to_bind function use the LHS and RHS values and + * binds them with the parameters so that a well formed DNS query may + * be performed. + * + * defined in hesiod.c + * + * \param[in] HesiodName The Hesiod name such as a username or service name + * \param[in] HesiodNameType The Hesiod name type such as pobox, passwd, or sloc + * \retval Returns NULL if there was an error. Otherwise the pointer to a string containing a valid query is returned. + * + */ +LPSTR WINAPI +hes_to_bind( + LPSTR HesiodName, + LPSTR HesiodNameType + ); + + +/*! \fn LPSTR * WINAPI hes_resolve(LPSTR HesiodName, LPSTR HesiodNameType) + * This function calls hes_to_bind to form a valid hesiod query, then queries the dns database. + * + * defined in hesiod.c + * + * \param[in] HesiodName The Hesiod name such as a username or service name + * \param[in] HesiodNameType The Hesiod name type such as pobox, passwd, or sloc + * \retval returns a NULL terminated vector of strings (a la argv), + * one for each resource record containing Hesiod data, or NULL if + * there is any error. If there is an error call hes_error() to get + * further information. You will need to call hes_free to free the result + * + */ + +LPSTR * WINAPI +hes_resolve( + LPSTR HesiodName, + LPSTR HesiodNameType + ); + +/*! \fn int WINAPI hes_error(void) + * The function hes_error may be called to determine the + * source of the error. It does not take an argument. + * + * defined in hesiod.c + * + * \retval return one of the HES_ER_* codes defined in hesiod.h. + */ + +int WINAPI +hes_error( + void + ); + + +/*! \fn void WINAPI hes_free(LPSTR* hesinfo) + * The function hes_free should be called to free up memeory returned by hes_resolve + * + * defined in hesiod.c + * + * \param[in] hesinfo a NULL terminiated array of strings returned by hes_resolve + */ +void WINAPI +hes_free( + LPSTR* hesinfo + ); + + +/*! \struct hes_postoffice + * For use in getting post-office information. + */ +struct hes_postoffice { + /*! The post office type, e.g. POP, IMAP */ + LPSTR po_type; + /*! The post office host, e.g. PO10.MIT.EDU */ + LPSTR po_host; + /*! The account name on the post office, e.g. tom */ + LPSTR po_name; +}; + +/*! \fn struct hes_postoffice * WINAPI hes_getmailhost(LPSTR user) + * This call is used to obtain a user's type of mail account and the location of that + * account. E.g. POP PO10.MIT.EDU or IMAP IMAP-TEST.MIT.EDU + * + * defined in hesmailh.c + * + * \param[in] user The username to be used when querying for the Hesiod Name Type POBOX. + * \retval NULL if there was an error or if there was no entry for the + * username. Otherwise a pointer to a hes_postoffice structure is + * returned. The caller must never attempt to modify this structure or to free + * any of its components. Furthermore, only one copy of this structure is allocated per call per thread, so the application should copy any information it needs before + * issuing another getmailhost call + */ +struct hes_postoffice * WINAPI hes_getmailhost(LPSTR user); + +/*! \fn struct servent * WINAPI hes_getservbyname(LPSTR name, LPSTR proto) + * This function will query a Hesiod server for a servent structure given + * a service name and protocol. This is a replacement for the Winsock + * getservbyname function which normally just uses a local services + * file. This allows a site to use a centralized database for adding new + * services. + * + * defined in hesservb.c + * + * \param[in] name pointer to the official name of the service, eg "POP3". + * \param[in] proto pointer to the protocol to use when contacting the service, e.g. "TCP" + * \retval NULL if there was an error or a pointer to a servent structure. The caller must + * never attempt to modify this structure or to free any of its components. + * Furthermore, only one copy of this structure is allocated per call per thread, so the application should copy any information it needs before + * issuing another hes_getservbyname call + * + */ +struct servent * WINAPI hes_getservbyname(LPSTR name, + LPSTR proto); + +/*! \fn struct passwd * WINAPI hes_getpwnam(LPSTR nam) + * Given a username this function will return the pwd information, eg + * username, uid, gid, fullname, office location, phone number, home + * directory, and default shell + * + * defined in hespwnam.c + * + * \param nam a pointer to the username + * \retval NULL if there was an error or a pointer to the passwd structure. The caller must + * never attempt to modify this structure or to free any of its components. + * Furthermore, only one copy of this structure is allocated per call per thread, so the application should copy any information it needs before + * issuing another hes_getpwnam call + * + */ +struct passwd * WINAPI hes_getpwnam(LPSTR nam); + +/*! struct passwd * WINAPI hes_getpwuid(int uid) + * Given a UID this function will return the pwd information, eg username, uid, + * gid, fullname, office location, phone number, home directory, and default shell + * + * defined in hespwnam.c + * + * \param uid The user ID + * \retval NULL if there was an error or a pointer to the passwd structure. The caller must + * never attempt to modify this structure or to free any of its components. + * Furthermore, only one copy of this structure is allocated per call per thread, so the application should copy any information it needs before + * issuing another hes_getpwuid call + */ +struct passwd * WINAPI hes_getpwuid(int uid); + +#ifdef __cplusplus +} +#endif + +#endif /* _HESIOD_ */ diff --git a/src/windows/include/leasherr.h b/src/windows/include/leasherr.h new file mode 100644 index 0000000000..834765fbb8 --- /dev/null +++ b/src/windows/include/leasherr.h @@ -0,0 +1,32 @@ +/* + * leasherr.h + * This file is the #include file for leasherr.et. + * Please do not edit it as it is automatically generated. + */ + +#define LSH_ONLYONEME (40591872L) +#define LSH_INVPRINCIPAL (40591873L) +#define LSH_FAILEDREALM (40591874L) +#define LSH_INVINSTANCE (40591875L) +#define LSH_INVREALM (40591876L) +#define LSH_EOF (40591877L) +#define LSH_EXPIRESOON (40591878L) +#define LSH_NOMATCH (40591879L) +#define LSH_BADCHARS (40591880L) +#define LSH_FATAL_ERROR (40591881L) +#define LSH_BADWINSOCK (40591882L) +#define LSH_BADTIMESERV (40591883L) +#define LSH_NOSOCKET (40591884L) +#define LSH_NOCONNECT (40591885L) +#define LSH_TIMEFAILED (40591886L) +#define LSH_GETTIMEOFDAY (40591887L) +#define LSH_SETTIMEOFDAY (40591888L) +#define LSH_RECVTIME (40591889L) +#define LSH_RECVBYTES (40591890L) +#define LSH_ALREADY_SETTIME (40591891L) +extern void initialize_lsh_error_table(struct et_list **); +#define ERROR_TABLE_BASE_lsh (40591872L) + +/* for compatibility with older versions... */ +#define init_lsh_err_tbl() initialize_lsh_error_table(&_et_list) +#define lsh_err_base ERROR_TABLE_BASE_lsh diff --git a/src/windows/include/leashinfo.h b/src/windows/include/leashinfo.h new file mode 100644 index 0000000000..7365aa1b54 --- /dev/null +++ b/src/windows/include/leashinfo.h @@ -0,0 +1,2 @@ +#define LSH_TIME_HOST 1970 +#define LSH_DEFAULT_TICKET_LIFE 1971 diff --git a/src/windows/include/leashwin.h b/src/windows/include/leashwin.h new file mode 100644 index 0000000000..6a26c43f93 --- /dev/null +++ b/src/windows/include/leashwin.h @@ -0,0 +1,198 @@ +#ifndef __LEASHWIN__ +#define __LEASHWIN__ + +////Is this sufficient? +#ifndef NO_KRB4 +#include +#else +#define ANAME_SZ 40 +#define REALM_SZ 40 +#define SNAME_SZ 40 +#define INST_SZ 40 +/* include space for '.' and '@' */ +#define MAX_K_NAME_SZ (ANAME_SZ + INST_SZ + REALM_SZ + 2) +#endif + +#define DLGTYPE_PASSWD 0 +#define DLGTYPE_CHPASSWD 1 +typedef struct { + int dlgtype; + // Tells whether dialog box is in change pwd more or init ticket mode??? + // (verify this): + int dlgstatemax; // What is this??? + // The title on the Dialog box - for Renewing or Initializing: + LPSTR title; + LPSTR principal; +} LSH_DLGINFO, FAR *LPLSH_DLGINFO; + +#define LEASH_USERNAME_SZ 64 +#define LEASH_REALM_SZ 192 +#define LEASH_TITLE_SZ 128 +#define LEASH_CCACHE_NAME_SZ 264 + +typedef struct { + DWORD size; + int dlgtype; + // Tells whether dialog box is in change pwd mode or init ticket mode + LPSTR title; // in v3, set to in.title + LPSTR username; // in v3, set to in.username + LPSTR realm; // in v3, set to in.realm + int use_defaults; + int forwardable; + int noaddresses; + int lifetime; + int renew_till; + int proxiable; + int publicip; + // Version 1 of this structure ends here + struct { + char username[LEASH_USERNAME_SZ]; + char realm[LEASH_REALM_SZ]; + // Version 2 of this structure ends here + char ccache[LEASH_CCACHE_NAME_SZ]; + } out; + struct { + char title[LEASH_TITLE_SZ]; + char username[LEASH_USERNAME_SZ]; + char realm[LEASH_REALM_SZ]; + char ccache[LEASH_CCACHE_NAME_SZ]; + } in; +} LSH_DLGINFO_EX, *LPLSH_DLGINFO_EX; + +#define LSH_DLGINFO_EX_V1_SZ (sizeof(DWORD) + 3 * sizeof(LPSTR) + 8 * sizeof(int)) +#define LSH_DLGINFO_EX_V2_SZ (LSH_DLGINFO_EX_V1_SZ + LEASH_USERNAME_SZ + LEASH_REALM_SZ) +#define LSH_DLGINFO_EX_V3_SZ (LSH_DLGINFO_EX_V2_SZ + LEASH_TITLE_SZ + LEASH_USERNAME_SZ + LEASH_REALM_SZ + 2 * LEASH_CCACHE_NAME_SZ) + +#ifndef NETIDMGR +#define NETID_USERNAME_SZ 128 +#define NETID_REALM_SZ 192 +#define NETID_TITLE_SZ 256 +#define NETID_CCACHE_NAME_SZ 264 + +#define NETID_DLGTYPE_TGT 0 +#define NETID_DLGTYPE_CHPASSWD 1 +typedef struct { + DWORD size; + DWORD dlgtype; + // Tells whether dialog box is in change pwd mode or init ticket mode + struct { + WCHAR title[NETID_TITLE_SZ]; + WCHAR username[NETID_USERNAME_SZ]; + WCHAR realm[NETID_REALM_SZ]; + WCHAR ccache[NETID_CCACHE_NAME_SZ]; + DWORD use_defaults; + DWORD forwardable; + DWORD noaddresses; + DWORD lifetime; + DWORD renew_till; + DWORD proxiable; + DWORD publicip; + DWORD must_use_specified_principal; + } in; + struct { + WCHAR username[NETID_USERNAME_SZ]; + WCHAR realm[NETID_REALM_SZ]; + WCHAR ccache[NETID_CCACHE_NAME_SZ]; + } out; + // Version 1 of this structure ends here +} NETID_DLGINFO, *LPNETID_DLGINFO; + +#define NETID_DLGINFO_V1_SZ (10 * sizeof(DWORD) \ + + sizeof(WCHAR) * (NETID_TITLE_SZ + \ + 2 * NETID_USERNAME_SZ + 2 * NETID_REALM_SZ + \ + 2 * NETID_CCACHE_NAME_SZ)) +#endif /* NETIDMGR */ + +typedef struct { + char principal[MAX_K_NAME_SZ]; /* Principal name/instance/realm */ + int btickets; /* Do we have tickets? */ + long lifetime; /* Lifetime -- needs to have + room for 255 5-minute + periods * 5 * 60 */ + long issue_date; /* The issue time */ + long renew_till; /* The Renew time (k5 only) */ +} TICKETINFO; + +int FAR Leash_kinit_dlg(HWND hParent, LPLSH_DLGINFO lpdlginfo); +int FAR Leash_kinit_dlg_ex(HWND hParent, LPLSH_DLGINFO_EX lpdlginfoex); +int FAR Leash_changepwd_dlg(HWND hParent, LPLSH_DLGINFO lpdlginfo); +int FAR Leash_changepwd_dlg_ex(HWND hParent, LPLSH_DLGINFO_EX lpdlginfo); + +long FAR Leash_checkpwd(char *principal, char *password); +long FAR Leash_changepwd(char *principal, char *password, char *newpassword, char** result_string); +long FAR Leash_kinit(char *principal, char *password, int lifetime); +long FAR Leash_kinit_ex(char * principal, char * password, int lifetime, + int forwardable, int proxiable, int renew_life, + int addressless, unsigned long publicIP); + +long FAR Leash_klist(HWND hlist, TICKETINFO FAR *ticketinfo); +long FAR Leash_kdestroy(void); +long FAR Leash_get_lsh_errno( LONG FAR *err_val); + +long FAR Leash_renew(void); +long FAR Leash_importable(void); +long FAR Leash_import(void); + +BOOL Leash_set_help_file( char FAR *szHelpFile ); +LPSTR Leash_get_help_file(void); + +void Leash_reset_defaults(void); + +#define NO_TICKETS 0 +#define EXPD_TICKETS 2 +#define GOOD_TICKETS 1 + +/* Leash Configuration functions - alters Current User Registry */ +DWORD Leash_get_default_lifetime(); +DWORD Leash_set_default_lifetime(DWORD minutes); +DWORD Leash_reset_default_lifetime(); +DWORD Leash_get_default_renew_till(); +DWORD Leash_set_default_renew_till(DWORD minutes); +DWORD Leash_reset_default_renew_till(); +DWORD Leash_get_default_renewable(); +DWORD Leash_set_default_renewable(DWORD onoff); +DWORD Leash_reset_default_renewable(); +DWORD Leash_get_default_forwardable(); +DWORD Leash_set_default_forwardable(DWORD onoff); +DWORD Leash_reset_default_forwardable(); +DWORD Leash_get_default_noaddresses(); +DWORD Leash_set_default_noaddresses(DWORD onoff); +DWORD Leash_reset_default_noaddresses(); +DWORD Leash_get_default_proxiable(); +DWORD Leash_set_default_proxiable(DWORD onoff); +DWORD Leash_reset_default_proxiable(); +DWORD Leash_get_default_publicip(); +DWORD Leash_set_default_publicip(DWORD ipv4addr); +DWORD Leash_reset_default_publicip(); +DWORD Leash_get_default_use_krb4(); +DWORD Leash_set_default_use_krb4(DWORD onoff); +DWORD Leash_reset_default_use_krb4(); +DWORD Leash_get_hide_kinit_options(); +DWORD Leash_set_hide_kinit_options(DWORD onoff); +DWORD Leash_reset_hide_kinit_options(); +DWORD Leash_get_default_life_min(); +DWORD Leash_set_default_life_min(DWORD minutes); +DWORD Leash_reset_default_life_min(); +DWORD Leash_get_default_life_max(); +DWORD Leash_set_default_life_max(DWORD minutes); +DWORD Leash_reset_default_life_max(); +DWORD Leash_get_default_renew_min(); +DWORD Leash_set_default_renew_min(DWORD minutes); +DWORD Leash_reset_default_renew_min(); +DWORD Leash_get_default_renew_max(); +DWORD Leash_set_default_renew_max(DWORD minutes); +DWORD Leash_reset_default_renew_max(); +DWORD Leash_get_lock_file_locations(); +DWORD Leash_set_lock_file_locations(DWORD onoff); +DWORD Leash_reset_lock_file_locations(); +DWORD Leash_get_default_uppercaserealm(); +DWORD Leash_set_default_uppercaserealm(DWORD onoff); +DWORD Leash_reset_default_uppercaserealm(); +DWORD Leash_get_default_mslsa_import(); +DWORD Leash_set_default_mslsa_import(DWORD onoffmatch); +DWORD Leash_reset_default_mslsa_import(); +DWORD Leash_get_default_preserve_kinit_settings(); +DWORD Leash_set_default_preserve_kinit_settings(DWORD onoff); +DWORD Leash_reset_default_preserve_kinit_settings(); + +#endif /* LEASHWIN */ diff --git a/src/windows/include/loadfuncs-com_err.h b/src/windows/include/loadfuncs-com_err.h new file mode 100644 index 0000000000..a579749c17 --- /dev/null +++ b/src/windows/include/loadfuncs-com_err.h @@ -0,0 +1,44 @@ +#ifndef __LOADFUNCS_COM_ERR_H__ +#define __LOADFUNCS_COM_ERR_H__ + +#include "loadfuncs.h" +#include + +#if defined(_WIN64) +#define COMERR_DLL "comerr64.dll" +#else +#define COMERR_DLL "comerr32.dll" +#endif + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV_C, + com_err, + (const char FAR *, errcode_t, const char FAR *, ...) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + com_err_va, + (const char FAR *whoami, errcode_t code, const char FAR *fmt, va_list ap) + ); +TYPEDEF_FUNC( + const char FAR *, + KRB5_CALLCONV, + error_message, + (errcode_t) + ); +TYPEDEF_FUNC( + errcode_t, + KRB5_CALLCONV, + add_error_table, + (const struct error_table FAR *) + ); +TYPEDEF_FUNC( + errcode_t, + KRB5_CALLCONV, + remove_error_table, + (const struct error_table FAR *) + ); + +#endif /* __LOADFUNCS_COM_ERR_H__ */ diff --git a/src/windows/include/loadfuncs-krb5.h b/src/windows/include/loadfuncs-krb5.h new file mode 100644 index 0000000000..58ff443bff --- /dev/null +++ b/src/windows/include/loadfuncs-krb5.h @@ -0,0 +1,1778 @@ +#ifndef __LOADFUNCS_KRB5_H__ +#define __LOADFUNCS_KRB5_H__ + +#include "loadfuncs.h" +#include + +#if defined(_WIN64) +#define KRB5_DLL "krb5_64.dll" +#else +#define KRB5_DLL "krb5_32.dll" +#endif + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_principal, + (krb5_context, krb5_principal) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_authenticator, + (krb5_context, krb5_authenticator * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_authenticator_contents, + (krb5_context, krb5_authenticator * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_addresses, + (krb5_context, krb5_address * * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_address, + (krb5_context, krb5_address * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_authdata, + (krb5_context, krb5_authdata * * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_enc_tkt_part, + (krb5_context, krb5_enc_tkt_part * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_ticket, + (krb5_context, krb5_ticket * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_tickets, + (krb5_context, krb5_ticket * * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_kdc_req, + (krb5_context, krb5_kdc_req * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_kdc_rep, + (krb5_context, krb5_kdc_rep * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_last_req, + (krb5_context, krb5_last_req_entry * * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_enc_kdc_rep_part, + (krb5_context, krb5_enc_kdc_rep_part * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_error, + (krb5_context, krb5_error * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_ap_req, + (krb5_context, krb5_ap_req * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_ap_rep, + (krb5_context, krb5_ap_rep * ) + ); + +/* Removed around the time of krb5_rc_* change... */ +#if 0 +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_safe, + (krb5_context, krb5_safe * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_priv, + (krb5_context, krb5_priv * ) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_priv_enc_part, + (krb5_context, krb5_priv_enc_part * ) + ); +#endif + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_cred, + (krb5_context, krb5_cred *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_creds, + (krb5_context, krb5_creds *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_cred_contents, + (krb5_context, krb5_creds *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_cred_enc_part, + (krb5_context, krb5_cred_enc_part *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_checksum, + (krb5_context, krb5_checksum *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_checksum_contents, + (krb5_context, krb5_checksum *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_keyblock, + (krb5_context, krb5_keyblock *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_keyblock_contents, + (krb5_context, krb5_keyblock *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_pa_data, + (krb5_context, krb5_pa_data * *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_ap_rep_enc_part, + (krb5_context, krb5_ap_rep_enc_part *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_tkt_authent, + (krb5_context, krb5_tkt_authent *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_pwd_data, + (krb5_context, krb5_pwd_data *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_pwd_sequences, + (krb5_context, passwd_phrase_element * *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_data, + (krb5_context, krb5_data *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_data_contents, + (krb5_context, krb5_data *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_unparsed_name, + (krb5_context, char *) + ); +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_cksumtypes, + (krb5_context, krb5_cksumtype *) + ); + +/* ------------------------------------------------------------------------- */ + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_encrypt, + (krb5_context context, const krb5_keyblock *key, + krb5_keyusage usage, const krb5_data *ivec, + const krb5_data *input, krb5_enc_data *output) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_decrypt, + (krb5_context context, const krb5_keyblock *key, + krb5_keyusage usage, const krb5_data *ivec, + const krb5_enc_data *input, krb5_data *output) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_encrypt_length, + (krb5_context context, krb5_enctype enctype, + size_t inputlen, size_t *length) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_block_size, + (krb5_context context, krb5_enctype enctype, + size_t *blocksize) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_make_random_key, + (krb5_context context, krb5_enctype enctype, + krb5_keyblock *random_key) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_random_make_octets, + (krb5_context context, krb5_data *data) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_random_seed, + (krb5_context context, krb5_data *data) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_string_to_key, + (krb5_context context, krb5_enctype enctype, + const krb5_data *string, const krb5_data *salt, + krb5_keyblock *key) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_enctype_compare, + (krb5_context context, krb5_enctype e1, krb5_enctype e2, + krb5_boolean *similar) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_make_checksum, + (krb5_context context, krb5_cksumtype cksumtype, + const krb5_keyblock *key, krb5_keyusage usage, + const krb5_data *input, krb5_checksum *cksum) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_verify_checksum, + (krb5_context context, + const krb5_keyblock *key, krb5_keyusage usage, + const krb5_data *data, + const krb5_checksum *cksum, + krb5_boolean *valid) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_checksum_length, + (krb5_context context, krb5_cksumtype cksumtype, + size_t *length) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_c_keyed_checksum_types, + (krb5_context context, krb5_enctype enctype, + unsigned int *count, krb5_cksumtype **cksumtypes) + ); + +/* ------------------------------------------------------------------------- */ + +TYPEDEF_FUNC( + krb5_boolean, + KRB5_CALLCONV, + valid_enctype, + (const krb5_enctype ktype) + ); + +TYPEDEF_FUNC( + krb5_boolean, + KRB5_CALLCONV, + valid_cksumtype, + (const krb5_cksumtype ctype) + ); + +TYPEDEF_FUNC( + krb5_boolean, + KRB5_CALLCONV, + is_coll_proof_cksum, + (const krb5_cksumtype ctype) + ); + +TYPEDEF_FUNC( + krb5_boolean, + KRB5_CALLCONV, + is_keyed_cksum, + (const krb5_cksumtype ctype) + ); + +/* ------------------------------------------------------------------------- */ + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_init_context, + (krb5_context *) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_context, + (krb5_context) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_decrypt_tkt_part, + (krb5_context, + const krb5_keyblock *, + krb5_ticket * ) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_tgt_creds, + (krb5_context, + krb5_creds ** ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_credentials, + (krb5_context, + const krb5_flags, + krb5_ccache, + krb5_creds *, + krb5_creds * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_credentials_validate, + (krb5_context, + const krb5_flags, + krb5_ccache, + krb5_creds *, + krb5_creds * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_credentials_renew, + (krb5_context, + const krb5_flags, + krb5_ccache, + krb5_creds *, + krb5_creds * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_mk_req, + (krb5_context, + krb5_auth_context *, + const krb5_flags, + char *, + char *, + krb5_data *, + krb5_ccache, + krb5_data * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_mk_req_extended, + (krb5_context, + krb5_auth_context *, + const krb5_flags, + krb5_data *, + krb5_creds *, + krb5_data * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_mk_rep, + (krb5_context, + krb5_auth_context, + krb5_data *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_rd_rep, + (krb5_context, + krb5_auth_context, + const krb5_data *, + krb5_ap_rep_enc_part * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_mk_error, + (krb5_context, + const krb5_error *, + krb5_data * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_rd_error, + (krb5_context, + const krb5_data *, + krb5_error * * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_rd_safe, + (krb5_context, + krb5_auth_context, + const krb5_data *, + krb5_data *, + krb5_replay_data *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_rd_priv, + (krb5_context, + krb5_auth_context, + const krb5_data *, + krb5_data *, + krb5_replay_data *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_parse_name, + (krb5_context, + const char *, + krb5_principal * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_unparse_name, + (krb5_context, + krb5_const_principal, + char * * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_unparse_name_ext, + (krb5_context, + krb5_const_principal, + char * *, + int *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_set_principal_realm, + (krb5_context, krb5_principal, const char *) + ); + +TYPEDEF_FUNC( + krb5_boolean, + KRB5_CALLCONV, + krb5_principal_compare, + (krb5_context, + krb5_const_principal, + krb5_const_principal) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_keyblock, + (krb5_context, + const krb5_keyblock *, + krb5_keyblock * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_keyblock_contents, + (krb5_context, + const krb5_keyblock *, + krb5_keyblock *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_creds, + (krb5_context, + const krb5_creds *, + krb5_creds * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_data, + (krb5_context, + const krb5_data *, + krb5_data * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_principal, + (krb5_context, + krb5_const_principal, + krb5_principal *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_addr, + (krb5_context, + const krb5_address *, + krb5_address * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_addresses, + (krb5_context, + krb5_address * const *, + krb5_address * * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_ticket, + (krb5_context, + const krb5_ticket *, + krb5_ticket * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_authdata, + (krb5_context, + krb5_authdata * const *, + krb5_authdata * * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_authenticator, + (krb5_context, + const krb5_authenticator *, + krb5_authenticator * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_copy_checksum, + (krb5_context, + const krb5_checksum *, + krb5_checksum * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_server_rcache, + (krb5_context, + const krb5_data *, krb5_rcache *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV_C, + krb5_build_principal_ext, + (krb5_context, krb5_principal *, int, const char *, ...) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV_C, + krb5_build_principal, + (krb5_context, krb5_principal *, int, const char *, ...) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_425_conv_principal, + (krb5_context, + const char *name, + const char *instance, const char *realm, + krb5_principal *princ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_524_conv_principal, + (krb5_context context, const krb5_principal princ, + char *name, char *inst, char *realm) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_mk_chpw_req, + (krb5_context context, krb5_auth_context auth_context, + krb5_data *ap_req, char *passwd, krb5_data *packet) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_rd_chpw_rep, + (krb5_context context, krb5_auth_context auth_context, + krb5_data *packet, int *result_code, + krb5_data *result_data) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_chpw_result_code_string, + (krb5_context context, int result_code, + char **result_codestr) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_register, + (krb5_context, + struct _krb5_kt_ops * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_resolve, + (krb5_context, + const char *, + krb5_keytab * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_default_name, + (krb5_context, + char *, + int ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_default, + (krb5_context, + krb5_keytab * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_free_entry, + (krb5_context, + krb5_keytab_entry * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_remove_entry, + (krb5_context, + krb5_keytab, + krb5_keytab_entry * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_add_entry, + (krb5_context, + krb5_keytab, + krb5_keytab_entry * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_resolve, + (krb5_context, + const char *, + krb5_ccache * ) + ); + +TYPEDEF_FUNC( + const char*, + KRB5_CALLCONV, + krb5_cc_default_name, + (krb5_context) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_set_default_name, + (krb5_context, const char *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_default, + (krb5_context, + krb5_ccache *) + ); + +TYPEDEF_FUNC( + unsigned int, + KRB5_CALLCONV, + krb5_get_notification_message, + (void) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_copy_creds, + (krb5_context context, + krb5_ccache incc, + krb5_ccache outcc) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_us_timeofday, + (krb5_context, + krb5_int32 *, + krb5_int32 * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_timeofday, + (krb5_context, + krb5_int32 * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_os_localaddr, + (krb5_context, + krb5_address * * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_default_realm, + (krb5_context, + char * * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_set_default_realm, + (krb5_context, + const char * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_free_default_realm, + (krb5_context, + const char * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_sname_to_principal, + (krb5_context, + const char *, + const char *, + krb5_int32, + krb5_principal *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_change_password, + (krb5_context context, krb5_creds *creds, char *newpw, + int *result_code, krb5_data *result_code_string, + krb5_data *result_string) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_default_config_files, + (char ***filenames) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_config_files, + (char **filenames) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_in_tkt, + (krb5_context, + const krb5_flags, + krb5_address * const *, + krb5_enctype *, + krb5_preauthtype *, + krb5_error_code ( * )(krb5_context, + const krb5_enctype, + krb5_data *, + krb5_const_pointer, + krb5_keyblock * *), + krb5_const_pointer, + krb5_error_code ( * )(krb5_context, + const krb5_keyblock *, + krb5_const_pointer, + krb5_kdc_rep * ), + krb5_const_pointer, + krb5_creds *, + krb5_ccache, + krb5_kdc_rep * * ) + ); + + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_in_tkt_with_password, + (krb5_context, + const krb5_flags, + krb5_address * const *, + krb5_enctype *, + krb5_preauthtype *, + const char *, + krb5_ccache, + krb5_creds *, + krb5_kdc_rep * * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_in_tkt_with_skey, + (krb5_context, + const krb5_flags, + krb5_address * const *, + krb5_enctype *, + krb5_preauthtype *, + const krb5_keyblock *, + krb5_ccache, + krb5_creds *, + krb5_kdc_rep * * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_in_tkt_with_keytab, + (krb5_context, + const krb5_flags, + krb5_address * const *, + krb5_enctype *, + krb5_preauthtype *, + const krb5_keytab, + krb5_ccache, + krb5_creds *, + krb5_kdc_rep * * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_rd_req, + (krb5_context, + krb5_auth_context *, + const krb5_data *, + krb5_const_principal, + krb5_keytab, + krb5_flags *, + krb5_ticket * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_read_service_key, + (krb5_context, + krb5_pointer, + krb5_principal, + krb5_kvno, + krb5_enctype, + krb5_keyblock * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_mk_safe, + (krb5_context, + krb5_auth_context, + const krb5_data *, + krb5_data *, + krb5_replay_data *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_mk_priv, + (krb5_context, + krb5_auth_context, + const krb5_data *, + krb5_data *, + krb5_replay_data *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_register, + (krb5_context, + krb5_cc_ops *, + krb5_boolean ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_sendauth, + (krb5_context, + krb5_auth_context *, + krb5_pointer, + char *, + krb5_principal, + krb5_principal, + krb5_flags, + krb5_data *, + krb5_creds *, + krb5_ccache, + krb5_error * *, + krb5_ap_rep_enc_part * *, + krb5_creds * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_recvauth, + (krb5_context, + krb5_auth_context *, + krb5_pointer, + char *, + krb5_principal, + krb5_int32, + krb5_keytab, + krb5_ticket * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_mk_ncred, + (krb5_context, + krb5_auth_context, + krb5_creds * *, + krb5_data * *, + krb5_replay_data *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_mk_1cred, + (krb5_context, + krb5_auth_context, + krb5_creds *, + krb5_data * *, + krb5_replay_data *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_rd_cred, + (krb5_context, + krb5_auth_context, + krb5_data *, + krb5_creds * * *, + krb5_replay_data *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_fwd_tgt_creds, + (krb5_context, + krb5_auth_context, + char *, + krb5_principal, + krb5_principal, + krb5_ccache, + int forwardable, + krb5_data *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_init, + (krb5_context, + krb5_auth_context *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_free, + (krb5_context, + krb5_auth_context) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_setflags, + (krb5_context, + krb5_auth_context, + krb5_int32) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_getflags, + (krb5_context, + krb5_auth_context, + krb5_int32 *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_setuseruserkey, + (krb5_context, + krb5_auth_context, + krb5_keyblock *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_getkey, + (krb5_context, + krb5_auth_context, + krb5_keyblock **) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_getlocalsubkey, + (krb5_context, + krb5_auth_context, + krb5_keyblock * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_set_req_cksumtype, + (krb5_context, + krb5_auth_context, + krb5_cksumtype) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_getlocalseqnumber, + (krb5_context, + krb5_auth_context, + krb5_int32 *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_getremoteseqnumber, + (krb5_context, + krb5_auth_context, + krb5_int32 *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_setrcache, + (krb5_context, + krb5_auth_context, + krb5_rcache) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_getauthenticator, + (krb5_context, + krb5_auth_context, + krb5_authenticator * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_getremotesubkey, + (krb5_context, + krb5_auth_context, + krb5_keyblock * *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_read_password, + (krb5_context, + const char *, + const char *, + char *, + int * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_host_realm, + (krb5_context, + const char *, + char * * * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_free_host_realm, + (krb5_context, + char * const * ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_realm_domain, + (krb5_context, + const char *, + char ** ) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_auth_con_genaddrs, + (krb5_context, + krb5_auth_context, + int, int) + ); + +/* ------------------------------------------------------------------------- */ + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_string_to_enctype, + (char *, krb5_enctype *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_string_to_salttype, + (char *, krb5_int32 *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_string_to_cksumtype, + (char *, krb5_cksumtype *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_string_to_timestamp, + (char *, krb5_timestamp *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_string_to_deltat, + (char *, krb5_deltat *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_enctype_to_string, + (krb5_enctype, char *, size_t) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_salttype_to_string, + (krb5_int32, char *, size_t) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cksumtype_to_string, + (krb5_cksumtype, char *, size_t) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_timestamp_to_string, + (krb5_timestamp, char *, size_t) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_timestamp_to_sfstring, + (krb5_timestamp, char *, size_t, char *) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_deltat_to_string, + (krb5_deltat, char *, size_t) + ); + +/* ------------------------------------------------------------------------- */ + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_prompter_posix, + (krb5_context context, + void *data, + const char *name, + const char *banner, + int num_prompts, + krb5_prompt prompts[]) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_get_init_creds_opt_init, + (krb5_get_init_creds_opt *opt) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_get_init_creds_opt_set_tkt_life, + (krb5_get_init_creds_opt *opt, + krb5_deltat tkt_life) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_get_init_creds_opt_set_renew_life, + (krb5_get_init_creds_opt *opt, + krb5_deltat renew_life) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_get_init_creds_opt_set_forwardable, + (krb5_get_init_creds_opt *opt, + int forwardable) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_get_init_creds_opt_set_proxiable, + (krb5_get_init_creds_opt *opt, + int proxiable) + ); + + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_get_init_creds_opt_set_etype_list, + (krb5_get_init_creds_opt *opt, + krb5_enctype *etype_list, + int etype_list_length) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_get_init_creds_opt_set_address_list, + (krb5_get_init_creds_opt *opt, + krb5_address **addresses) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_get_init_creds_opt_set_preauth_list, + (krb5_get_init_creds_opt *opt, + krb5_preauthtype *preauth_list, + int preauth_list_length) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_get_init_creds_opt_set_salt, + (krb5_get_init_creds_opt *opt, + krb5_data *salt) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_get_init_creds_opt_set_change_password_prompt, + (krb5_get_init_creds_opt *opt, + int prompt) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_init_creds_password, + (krb5_context context, + krb5_creds *creds, + krb5_principal client, + char *password, + krb5_prompter_fct prompter, + void *data, + krb5_deltat start_time, + char *in_tkt_service, + krb5_get_init_creds_opt *options) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_init_creds_keytab, + (krb5_context context, + krb5_creds *creds, + krb5_principal client, + krb5_keytab arg_keytab, + krb5_deltat start_time, + char *in_tkt_service, + krb5_get_init_creds_opt *options) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_verify_init_creds_opt_init, + (krb5_verify_init_creds_opt *options) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_verify_init_creds_opt_set_ap_req_nofail, + (krb5_verify_init_creds_opt *options, + int ap_req_nofail) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_verify_init_creds, + (krb5_context context, + krb5_creds *creds, + krb5_principal ap_req_server, + krb5_keytab ap_req_keytab, + krb5_ccache *ccache, + krb5_verify_init_creds_opt *options) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_validated_creds, + (krb5_context context, + krb5_creds *creds, + krb5_principal client, + krb5_ccache ccache, + char *in_tkt_service) + ); + + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_get_renewed_creds, + (krb5_context context, + krb5_creds *creds, + krb5_principal client, + krb5_ccache ccache, + char *in_tkt_service) + ); + +/* ------------------------------------------------------------------------- */ + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_realm_iterator_create, + (krb5_context context, void **iter_p) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_realm_iterator, + (krb5_context context, void **iter_p, char **ret_realm) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_realm_iterator_free, + (krb5_context context, void **iter_p) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_realm_string, + (krb5_context context, char *str) + ); + +TYPEDEF_FUNC( + krb5_prompt_type*, + KRB5_CALLCONV, + krb5_get_prompt_types, + (krb5_context context) + ); + +/* NOT IN krb5.h HEADER: */ + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_decode_ticket, + (const krb5_data *code, krb5_ticket **rep) + ); + +/* --- more --- */ + +TYPEDEF_FUNC( + char *, + KRB5_CALLCONV, + krb5_cc_get_name, + (krb5_context context, krb5_ccache cache) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_gen_new, + (krb5_context context, krb5_ccache *cache) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_initialize, + (krb5_context context, krb5_ccache cache, krb5_principal principal) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_destroy, + (krb5_context context, krb5_ccache cache) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_close, + (krb5_context context, krb5_ccache cache) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_store_cred, + (krb5_context context, krb5_ccache cache, krb5_creds *creds) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_retrieve_cred, + (krb5_context context, krb5_ccache cache, + krb5_flags flags, krb5_creds *mcreds, + krb5_creds *creds) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_get_principal, + (krb5_context context, krb5_ccache cache, krb5_principal *principal) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_start_seq_get, + (krb5_context context, krb5_ccache cache, krb5_cc_cursor *cursor) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_next_cred, + (krb5_context context, krb5_ccache cache, krb5_cc_cursor *cursor, + krb5_creds *creds) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_end_seq_get, + (krb5_context context, krb5_ccache cache, krb5_cc_cursor *cursor) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_remove_cred, + (krb5_context context, krb5_ccache cache, krb5_flags flags, + krb5_creds *creds) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_cc_set_flags, + (krb5_context context, krb5_ccache cache, krb5_flags flags) + ); + +TYPEDEF_FUNC( + const char *, + KRB5_CALLCONV, + krb5_cc_get_type, + (krb5_context context, krb5_ccache cache) + ); + +TYPEDEF_FUNC( + char *, + KRB5_CALLCONV, + krb5_kt_get_type, + (krb5_context, krb5_keytab keytab) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_get_name, + (krb5_context context, krb5_keytab keytab, char *name, + unsigned int namelen) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_close, + (krb5_context context, krb5_keytab keytab) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_get_entry, + (krb5_context context, krb5_keytab keytab, + krb5_const_principal principal, krb5_kvno vno, + krb5_enctype enctype, krb5_keytab_entry *entry) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_start_seq_get, + (krb5_context context, krb5_keytab keytab, krb5_kt_cursor *cursor) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_next_entry, + (krb5_context context, krb5_keytab keytab, + krb5_keytab_entry *entry, krb5_kt_cursor *cursor) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_kt_end_seq_get, + (krb5_context context, krb5_keytab keytab, krb5_kt_cursor *cursor) + ); + +TYPEDEF_FUNC( + krb5_error_code, + KRB5_CALLCONV, + krb5_locate_kdc, + (krb5_context context, const krb5_data *realm, + struct addrlist *addrlist, + int get_masters, int socktype, int family) + ); + +TYPEDEF_FUNC( + const char *, + KRB5_CALLCONV, + krb5_get_error_message, + (krb5_context, krb5_error_code) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_free_error_message, + (krb5_context, const char *) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + krb5_clear_error_message, + (krb5_context) + ); +#endif /* __LOADFUNCS_KRB5_H__ */ diff --git a/src/windows/include/loadfuncs-leash.h b/src/windows/include/loadfuncs-leash.h new file mode 100644 index 0000000000..38b1decbb0 --- /dev/null +++ b/src/windows/include/loadfuncs-leash.h @@ -0,0 +1,413 @@ +#ifndef __LOADFUNCS_LEASH_H__ +#define __LOADFUNCS_LEASH_H__ + +#include "loadfuncs.h" +#include + +#if defined(_WIN64) +#define LEASH_DLL "leashw64.dll" +#else +#define LEASH_DLL "leashw32.dll" +#endif + +#define CALLCONV_C + +TYPEDEF_FUNC( + int, + CALLCONV_C, + Leash_kinit_dlg, + (HWND, LPLSH_DLGINFO) + ); +TYPEDEF_FUNC( + int, + CALLCONV_C, + Leash_kinit_dlg_ex, + (HWND, LPLSH_DLGINFO_EX) + ); +TYPEDEF_FUNC( + int, + CALLCONV_C, + Leash_changepwd_dlg, + (HWND, LPLSH_DLGINFO) + ); +TYPEDEF_FUNC( + int, + CALLCONV_C, + Leash_changepwd_dlg_ex, + (HWND, LPLSH_DLGINFO_EX) + ); +TYPEDEF_FUNC( + long, + CALLCONV_C, + Leash_checkpwd, + (char *, char *) + ); +TYPEDEF_FUNC( + long, + CALLCONV_C, + Leash_changepwd, + (char *, char *, char*, char*) + ); +TYPEDEF_FUNC( + long, + CALLCONV_C, + Leash_kinit, + (char *, char *, int) + ); +TYPEDEF_FUNC( + long, + CALLCONV_C, + Leash_kinit_ex, + (char *, char *, int,int, int, int, int, unsigned long) + ); +TYPEDEF_FUNC( + long, + CALLCONV_C, + Leash_klist, + (HWND, TICKETINFO*) + ); +TYPEDEF_FUNC( + long, + CALLCONV_C, + Leash_kdestroy, + (void) + ); +TYPEDEF_FUNC( + long, + CALLCONV_C, + Leash_get_lsh_errno, + (LONG *) + ); +TYPEDEF_FUNC( + BOOL, + CALLCONV_C, + Leash_set_help_file, + (char *) + ); +TYPEDEF_FUNC( + char *, + CALLCONV_C, + Leash_get_help_file, + (void) + ); +TYPEDEF_FUNC( + long, + CALLCONV_C, + Leash_timesync, + (int) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_lifetime, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_lifetime, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_lifetime, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_renew_till, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_renew_till, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_renew_till, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_forwardable, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_forwardable, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_forwardable, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_noaddresses, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_noaddresses, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_noaddresses, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_proxiable, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_proxiable, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_proxiable, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_publicip, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_publicip, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_publicip, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_use_krb4, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_use_krb4, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_use_krb4, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_life_min, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_life_min, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_life_min, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_life_max, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_life_max, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_life_max, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_renew_min, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_renew_min, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_renew_min, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_renew_max, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_renew_max, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_renew_max, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_renewable, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_renewable, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_renewable, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_lock_file_locations, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_lock_file_locations, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_lock_file_locations, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_uppercaserealm, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_uppercaserealm, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_uppercaserealm, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_mslsa_import, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_mslsa_import, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_mslsa_import, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_get_default_preserve_kinit_settings, + (void) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_set_default_preserve_kinit_settings, + (DWORD) + ); +TYPEDEF_FUNC( + DWORD, + CALLCONV_C, + Leash_reset_default_preserve_kinit_settings, + (void) + ); +TYPEDEF_FUNC( + BOOL, + CALLCONV_C, + Leash_import, + (void) + ); +TYPEDEF_FUNC( + long, + CALLCONV_C, + Leash_importable, + (void) + ); +TYPEDEF_FUNC( + int, + CALLCONV_C, + Leash_renew, + (void) + ); +TYPEDEF_FUNC( + void, + CALLCONV_C, + Leash_reset_defaults, + (void) + ); +/* They are not yet all here... */ + +#endif /* __LOADFUNCS_LEASH_H__ */ diff --git a/src/windows/include/loadfuncs-lsa.h b/src/windows/include/loadfuncs-lsa.h new file mode 100644 index 0000000000..40138f5de8 --- /dev/null +++ b/src/windows/include/loadfuncs-lsa.h @@ -0,0 +1,45 @@ +#ifndef __LOADFUNCS_LSA_H__ +#define __LOADFUNCS_LSA_H__ + +#include "loadfuncs.h" + +#define SECUR32_DLL "secur32.dll" +#define ADVAPI32_DLL "advapi32.dll" + +TYPEDEF_FUNC( + NTSTATUS, + NTAPI, + LsaConnectUntrusted, + (PHANDLE) + ); +TYPEDEF_FUNC( + NTSTATUS, + NTAPI, + LsaLookupAuthenticationPackage, + (HANDLE, PLSA_STRING, PULONG) + ); +TYPEDEF_FUNC( + NTSTATUS, + NTAPI, + LsaCallAuthenticationPackage, + (HANDLE, ULONG, PVOID, ULONG, PVOID *, PULONG, PNTSTATUS) + ); +TYPEDEF_FUNC( + NTSTATUS, + NTAPI, + LsaFreeReturnBuffer, + (PVOID) + ); +TYPEDEF_FUNC( + ULONG, + NTAPI, + LsaNtStatusToWinError, + (NTSTATUS) + ); +TYPEDEF_FUNC( + NTSTATUS, + NTAPI, + LsaGetLogonSessionData, + (PLUID, PSECURITY_LOGON_SESSION_DATA*) + ); +#endif /* __LOADFUNCS_LSA_H__ */ diff --git a/src/windows/include/loadfuncs-profile.h b/src/windows/include/loadfuncs-profile.h new file mode 100644 index 0000000000..ef7f6b7c85 --- /dev/null +++ b/src/windows/include/loadfuncs-profile.h @@ -0,0 +1,151 @@ +#ifndef __LOADFUNCS_PROFILE_H__ +#define __LOADFUNCS_PROFILE_H__ + +#include "loadfuncs.h" +#include + +#if defined(_WIN64) +#define PROFILE_DLL "xpprof64.dll" +#else +#define PROFILE_DLL "xpprof32.dll" +#endif + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_init, + (const_profile_filespec_t *files, profile_t *ret_profile) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_init_path, + (const_profile_filespec_list_t filelist, profile_t *ret_profile) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_flush, + (profile_t profile) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + profile_abandon, + (profile_t profile) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + profile_release, + (profile_t profile) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_get_values, + (profile_t profile, const char **names, char ***ret_values) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + profile_free_list, + (char **list) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_get_string, + (profile_t profile, const char *name, const char *subname, + const char *subsubname, const char *def_val, + char **ret_string) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_get_integer, + (profile_t profile, const char *name, const char *subname, + const char *subsubname, int def_val, + int *ret_default) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_get_relation_names, + (profile_t profile, const char **names, char ***ret_names) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_get_subsection_names, + (profile_t profile, const char **names, char ***ret_names) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_iterator_create, + (profile_t profile, const char **names, int flags, void **ret_iter) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + profile_iterator_free, + (void **iter_p) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_iterator, + (void **iter_p, char **ret_name, char **ret_value) + ); + +TYPEDEF_FUNC( + void, + KRB5_CALLCONV, + profile_release_string, + (char *str) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_update_relation, + (profile_t profile, const char **names, const char *old_value, const char *new_value) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_clear_relation, + (profile_t profile, const char **names) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_rename_section, + (profile_t profile, const char **names, const char *new_name) + ); + +TYPEDEF_FUNC( + long, + KRB5_CALLCONV, + profile_add_relation, + (profile_t profile, const char **names, const char *new_value) + ); + + +#endif /* __LOADFUNCS_PROFILE_H__ */ diff --git a/src/windows/include/loadfuncs.h b/src/windows/include/loadfuncs.h new file mode 100644 index 0000000000..7aef62d21c --- /dev/null +++ b/src/windows/include/loadfuncs.h @@ -0,0 +1,41 @@ +#ifndef __LOADFUNCS_H__ +#define __LOADFUNCS_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +typedef struct _FUNC_INFO { + void** func_ptr_var; + char* func_name; +} FUNC_INFO; + +#define DECL_FUNC_PTR(x) FP_##x p##x +#define MAKE_FUNC_INFO(x) { (void**) &p##x, #x } +#define END_FUNC_INFO { 0, 0 } +#define TYPEDEF_FUNC(ret, call, name, args) typedef ret (call *FP_##name) args + +void +UnloadFuncs( + FUNC_INFO fi[], + HINSTANCE h + ); + +int +LoadFuncs( + const char* dll_name, + FUNC_INFO fi[], + HINSTANCE* ph, // [out, optional] - DLL handle + int* pindex, // [out, optional] - index of last func loaded (-1 if none) + int cleanup, // cleanup function pointers and unload on error + int go_on, // continue loading even if some functions cannot be loaded + int silent // do not pop-up a system dialog if DLL cannot be loaded + ); + +#ifdef __cplusplus +} +#endif + +#endif /* __LOADFUNCS_H__ */ diff --git a/src/windows/include/mitwhich.h b/src/windows/include/mitwhich.h new file mode 100644 index 0000000000..47ee5dab63 --- /dev/null +++ b/src/windows/include/mitwhich.h @@ -0,0 +1,84 @@ +/*! \file mitwhich.h + * some defines so that we can figure out which MS OS and subsystem an + * application is running under. Also support for finding out which + * TCP/IP stack is being used. This is useful when you need to find out + * about the domain or the nameservers. + */ + +#if !defined( __MIT_WHICH_H ) +#define __MIT_WHICH_H + +// these should become resources and loaded at run time +#define NT_32 "Winsock 2.0" +#define NT_16 "Windows NT 16-bit Windows Sockets" +#define W95_32 "Microsoft Windows Sockets Version 1.1." +#define W95_16 "Microsoft Windows Sockets Version 1.1." +#define LWP_16 "Novell Winsock version 1.1" +// Note that these are currently in wshelper.h and should be somewhere else +#define MS_NT_32 1 +#define MS_NT_16 2 +#define MS_95_32 3 +#define MS_95_16 4 +#define NOVELL_LWP_16 5 + +#define MS_OS_WIN 1 +#define MS_OS_95 2 +#define MS_OS_NT 4 +#define MS_OS_2000 12 +#define MS_OS_XP 28 +#define MS_OS_2003 60 +#define MS_OS_NT_UNKNOWN 124 +#define MS_OS_UNKNOWN 0 + +#define STACK_UNKNOWN 0 +#define UNKNOWN_16_UNDER_32 -2 +#define UNKNOWN_16_UNDER_16 -3 +#define UNKNOWN_32_UNDER_32 -4 +#define UNKNOWN_32_UNDER_16 -5 + + +/* + @comm these are the current MIT DNS servers, the wshelper and + wshelp32 DLLs will do their best to find the correct DNS servers + for the local machine however, if all else fails these will be used + as a last resort. Site administrators outside of the MIT domain + should change these defaults to their own defaults either by + editing this file and recompiling or by editing the string tables + of the binaries. Don't use App Studio to edit the .RC files. +\n + #define DNS1 "18.70.0.160" \n + #define DNS2 "18.71.0.151" \n + #define DNS3 "18.72.0.3" \n +\n + #define DEFAULT_DOMAIN "mit.edu" \n +*/ + +#define DNS1 "18.70.0.160" +#define DNS2 "18.71.0.151" +#define DNS3 "18.72.0.3" + +#define DEFAULT_DOMAIN "mit.edu" + + +#ifndef _PATH_RESCONF +#if !defined(WINDOWS) && !defined(_WINDOWS) && !defined(_WIN32) +#define _PATH_RESCONF "/etc/resolv.conf" +#else +#define _PATH_RESCONF "c:/net/tcp/resolv.cfg" +#endif +#endif + + +/* Microsoft TCP/IP registry values that we care about */ +#define NT_TCP_PATH "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters" +#define NT_TCP_PATH_TRANS "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Transient" +#define W95_TCP_PATH "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP" + +#define NT_DOMAIN_KEY "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Domain" +#define NT_NS_KEY "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\NameServer" + +#define W95_DOMAIN_KEY "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP\\Domain" +#define W95_NS_KEY "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP\\NameServer" + + +#endif // __MIT_WHICH_H diff --git a/src/windows/include/resolv.h b/src/windows/include/resolv.h new file mode 100644 index 0000000000..929795957d --- /dev/null +++ b/src/windows/include/resolv.h @@ -0,0 +1,284 @@ +/*! \file resolv.h + * WSHelper DNS/Hesiod Library header + * This file contains the function declaration for:\n + * res_init() \n + * res_search() \n + * dn_comp() \n + * rdn_expand() \n \n + * and unsupported functions: \n + * res_setopts() \n + * res_getopts() \n + * res_querydomain() \n + * res_mkquery() \n + * res_send() \n +*/ + +#ifndef _RESOLV_H_ +#define _RESOLV_H_ + +#include +#ifndef MAXDNAME +#include +#endif + +/*! \def MAXNS + * max # name servers we'll track + */ +#define MAXNS 3 + +/*! \def MAXDFLSRCH + * # default domain levels to try + */ +#define MAXDFLSRCH 3 + +/*! \def MAXDNSRCH + * max # domains in search path + */ +#define MAXDNSRCH 6 + +/*! \def LOCALDOMAINPARTS + * min levels in name that is "local" + */ +#define LOCALDOMAINPARTS 2 + +/*! \def RES_TIMEOUT + * min. seconds between retries + */ +#define RES_TIMEOUT 5 + +/*! \def MAXMXRECS + * number of records in the preference array in the MX record + */ +#define MAXMXRECS 8 + +/*! \struct mxent + * structure to hold the MX record + */ +struct mxent { + /*! number of records in the preference field */ + int numrecs; + /*! holds a 16 bit integer which specifies the preference given to this RR */ + u_short pref[MAXMXRECS]; + /*! a host willing to act as a mail exchange */ + char ** hostname; +}; + + +/*! \struct state + * This structure holds the state for the resolver query + */ +struct state { + /*! retransmition time interval */ + int retrans; + /*! number of times to retransmit */ + int retry; + /*! field option flags - see below. */ + long options; + /*! field number of name servers */ + int nscount; + /*! address of name server */ + struct sockaddr_in nsaddr_list[MAXNS]; +#define nsaddr nsaddr_list[0] + /*! current packet id */ + u_short id; + /*! field default domain */ + char defdname[MAXDNAME]; + /*! field components of domain to search */ + char *dnsrch[MAXDNSRCH+1]; +}; + +/*! \def RES_INIT + * resolver option: address initialized + */ +#define RES_INIT 0x0001 + +/*! \def RES_DEBUG + * resolver option: print debug messages + */ +#define RES_DEBUG 0x0002 + +/*! \def RES_AAONLY + * resolver option: authoritative answers only + */ +#define RES_AAONLY 0x0004 + +/*! \def RES_USEVC + * resolver option: use virtual circuit + */ +#define RES_USEVC 0x0008 + +/*! \def RES_PRIMARY + * resolver option: query primary server only + */ +#define RES_PRIMARY 0x0010 + +/*! \def RES_IGNTC + * resolver option: ignore trucation errors + */ +#define RES_IGNTC 0x0020 + +/*! \def RES_RECURSE + * resolver option: recursion desired + */ +#define RES_RECURSE 0x0040 + +/*! \def RES_DEFNAMES + * resolver option: use default domain name + */ +#define RES_DEFNAMES 0x0080 + +/*! \def RES_STAYOPEN + * resolver option: Keep TCP socket ope + */ +#define RES_STAYOPEN 0x0100 + +/*! \def RES_DNSRCH + * resolver option: search up local domain tree + */ +#define RES_DNSRCH 0x0200 + +/*! \def RES_DEFAULT + * resolver option: Default RES options (RES_RECURSE + RES_DEFNAMES + RES_DNSRCH) + */ +#define RES_DEFAULT (RES_RECURSE | RES_DEFNAMES | RES_DNSRCH) + +extern struct state _res; + +#include + +/* Private routines shared between libc/net, named, nslookup and others. */ +#define fp_query __fp_query +#define hostalias __hostalias +#define putlong __putlong +#define putshort __putshort +#define p_class __p_class +#define p_time __p_time +#define p_type __p_type + + +#ifdef __cplusplus +extern "C" { +#endif + +/*! \fn int WINAPI res_init() + * \brief retrieves the default domain name and search order. It will look to see if an environment variable LOCALDOMAIN is defined. Otherwise, + * the domain associated with the local host is used. Otherwise, it will try to find the domain name from the registry + * + * defined in res_init.c + * + * \retval The return value is 0 if the operation was successful. Otherwise the value -1 is returned. + */ +int WINAPI res_init(); + + +/*! \fn int WINAPI res_search(const char* name, int qclass, int type, u_char* answer, int anslen) + * \brief a generic query interface to the DNS name space. The query is performed with the dnsapi and + * the answer buffer is populated based on the returned RR set. + * + * defined in res_quer.c + + * \param[in] name domain name + * \param[in] qclass class of query(such as DNS_CLASS_INTERNET, DNS_CLASS_CSNET, DNS_CLASS_CHAOS, + * DNS_CLASS_HESIOD. Defined in windns.h) + * \param[in] type type of query(such as DNS_TYPE_A, DNS_TYPE_NS, DNS_TYPE_MX, DNS_TYPE_SRV. Defined in + * windns.h) + * \param[in] answer buffer to put answer in + * \param[in] anslen size of the answer buffer. compare the anslen with the return value, if the return + * value is bigger than anslen, it means the answer buffer doesn't contain the complete + * response. You will need to call this function again with a bigger answer buffer if + * you care about the complete response + * + * \retval return the size of the response on success, -1 on error + * + */ +int WINAPI res_search(const char *name, + int qclass, int type, + u_char *answer, int anslen); + +/*! \fn int WINAPI dn_comp(const u_char* exp_dn, u_char* comp_dn, int length, u_char** dnptrs, u_char** lastdnptr) + * \brief Compress domain name 'exp_dn' into 'comp_dn' + * + * defined in res_comp.c + * + * \param[in] exp_dn name to compress + * \param[in, out] comp_dn result of the compression + * \param[in] length the size of the array pointed to by 'comp_dn'. + * \param[in, out] dnptrs a list of pointers to previous compressed names. dnptrs[0] + * is a pointer to the beginning of the message. The list ends with NULL. + * \param[in] lastdnptr a pointer to the end of the arrary pointed to by 'dnptrs'. Side effect + * is to update the list of pointers for labels inserted into the + * message as we compress the name. If 'dnptr' is NULL, we don't try to + * compress names. If 'lastdnptr' is NULL, we don't update the list. + * \retval Return the size of the compressed name or -1 + */ +int WINAPI dn_comp(const u_char *exp_dn, + u_char *comp_dn, + int length, u_char **dnptrs, + u_char * *lastdnptr); + +/*! \fn int WINAPI rdn_expand(const u_char *msg, const u_char *eomorig, const u_char *comp_dn, u_char *exp_dn, + int length); + * \brief replacement for dn_expand called rdn_expand. Older versions of the DLL used to this as dn_expand + * but this has caused some conflict with more recent versions of the MSDEV libraries. rdn_expand() + * expands the compressed domain name comp_dn to a full domain name. Expanded names are converted to upper case. + * + * defined in res_comp.c + * + * \param[in] msg msg is a pointer to the beginning of the message + * \param[in] eomorig + * \param[in] comp_dn the compressed domain name. + * \param[in, out] exp_dn a pointer to the result buffer + * \param[in] length size of the result in expn_dn + * \retval the size of compressed name is returned or -1 if there was an error. +*/ +int WINAPI rdn_expand(const u_char *msg, + const u_char *eomorig, + const u_char *comp_dn, + u_char *exp_dn, + int length); +/* Microsoft includes an implementation of dn_expand() in winsock */ +/* Make sure we do not use it. jaltman@columbia.edu */ +#define dn_expand(a,b,c,d,e) rdn_expand(a,b,c,d,e) + + +/*! \fn void WINAPI res_setopts(long opts) + * unsupported +*/ +void WINAPI res_setopts(long opts); + +/*! \fn long WINAPI res_getopts(void) + * unsupported +*/ +long WINAPI res_getopts(void); + +/*! \fn int WINAPI res_mkquery(int op, const char *dname, int qclass, int type, const char *data, int datalen, + * const struct rrec *newrr, char *buf, int buflen) + * unsupported + */ +int WINAPI res_mkquery(int op, const char *dname, + int qclass, int type, + const char *data, int datalen, + const struct rrec *newrr, + char *buf, int buflen); + +/*! \fn int WINAPI res_send(const char *msg, int msglen, char *answer, int anslen) + * unsupported +*/ +int WINAPI res_send(const char *msg, int msglen, + char *answer, int anslen); + +/*! \fn int WINAPI res_querydomain(const char *name, const char *domain, int qclass, int type, + u_char *answer, int anslen); +* unsupported +*/ +int WINAPI res_querydomain(const char *name, + const char *domain, + int qclass, int type, + u_char *answer, int anslen); + + +#ifdef __cplusplus +} +#endif + +#endif /* !_RESOLV_H_ */ diff --git a/src/windows/include/wshelper.h b/src/windows/include/wshelper.h new file mode 100644 index 0000000000..1bd31f0468 --- /dev/null +++ b/src/windows/include/wshelper.h @@ -0,0 +1,148 @@ +/*! \file wshelper.h + * WSHelper DNS/Hesiod Library + * + * This file contains the function declaration for: \n + * rgethostbyname() \n + * rgethostbyaddr() \n + * rgetservbyname() \n + * inet_aton() \n + * wsh_gethostname() \n + * wsh_getdomainname() \n \n + * and unsupported functions: \n + * gethinfobyname() \n + * getmxbyname() \n + * getrecordbyname() \n + * rrhost() \n + */ + +#ifndef _WSHELPER_ +#define _WSHELPER_ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif +/*! \fn struct hostent * WINAPI rgethostbyname(char *name) + * retrieves host information corresponding to a host name in the DNS database + * + * defined in gethna.c + * + * \param[in] name Pointer to the null-terminated name of the host to resolve. It can be a fully qualified host name such as x.mit.edu + * or it can be a simple host name such as x. If it is a simple host name, the default domain name is + * appended to do the search. + * \retval a pointer to the structure hostent. a structure allocated by the library. The hostent structure contains + * the results of a successful search for the host specified in the name parameter. The caller must never + * attempt to modify this structure or to free any of its components. Furthermore, only one copy of this + * structure is allocated per call per thread, so the application should copy any information it needs before + * issuing another rgethostbyname. + * NULL if the search has failed + * +*/ +struct hostent * WINAPI rgethostbyname(char *name); + +/*! \fn struct hostent * WINAPI rgethostbyaddr(char *addr, int len, int type) + * retrieves the host information corresponding to a network address in the DNS database + * + * defined in gethna.c + * + * \param[in] addr Pointer to an address in network byte order + * \param[in] len Length of the address, in bytes + * \param[in] type Type of the address, such as the AF_INET address family type (defined as TCP, + * UDP, and other associated Internet protocols). Address family types and their corresponding + * values are defined in the Winsock2.h header file. + * \retval returns a pointer to the hostent structure that contains the name and address corresponding + * to the given network address. The structure is allocated by the library. The caller must never + * attempt to modify this structure or to free any of its components. Furthermore, only one copy of this + * structure is allocated per call per thread, so the application should copy any information it needs before + * issuing another rgethostbyaddr. + * NULL if the search has failed + * +*/ +struct hostent * WINAPI rgethostbyaddr(char *addr, int len, int type); + +/*! \fn struct servent * WINAPI rgetservbyname(LPSTR name, LPSTR proto) + * retrieves service information corresponding to a service name and protocol. + * + * defined in gethna.c + * + * \param[in] name Pointer to a null-terminated service name. + * \param[in] proto pointer to a null-terminated protocol name. getservbyname should match both + * the name and the proto. + * \retval a pointer to the servent structure containing the name(s) and service number that match the name and proto + * parameters. The structure is allocated by the library. The caller must never + * attempt to modify this structure or to free any of its components. Furthermore, only one copy of this + * structure is allocated per call per thread, so the application should copy any information it needs before + * issuing another rgetservbyname. + * NULL if the search has failed + * + */ +struct servent * WINAPI rgetservbyname(LPSTR name, LPSTR proto); + +/*! \fn LPSTR WINAPI gethinfobyname(LPSTR name) + * unsupported + */ +LPSTR WINAPI gethinfobyname(LPSTR name); + +/*! \fn LPSTR WINAPI getmxbyname(LPSTR name) + * unsupported + */ +LPSTR WINAPI getmxbyname(LPSTR name); + +/*! \fn LPSTR WINAPI getrecordbyname(LPSTR name, int rectype) + * unsupported + */ +LPSTR WINAPI getrecordbyname(LPSTR name, int rectype); + +/*! \fn DWORD WINAPI rrhost( LPSTR lpHost ) + * unsupported + */ +DWORD WINAPI rrhost( LPSTR lpHost ); + +/*! \fn unsigned long WINAPI inet_aton(register const char *cp, struct in_addr *addr) + * converts a string containing an (Ipv4) Internet Protocol dotted address into a proper address for the in_addr structure + * + * defined in inetaton.c + * + * \param[in] cp Null-terminated character string representing a number expressed in the + * Internet standard ".'' (dotted) notation. + * \param[in, out] addr pointer to the in_addr structure. The s_addr memeber will be populated + * \retval Returns 1 if the address is valid, 0 if not. + */ +unsigned long WINAPI inet_aton(register const char *cp, struct in_addr *addr); + + +/*! \fn int WINAPI wsh_gethostname(char* name, int size) + * Gets the base part of the hostname + * + * defined in res_init.c + * + * \param[in, out] name pointer to a buffer that receives a null-terminated string containing the computer name + * \param[in] size specifies the size of the buffer, in chars (must be large + * enough to hold NULL-terminated host name) + * \retval return 0 ifsuccess, -1 on error. +*/ +int WINAPI wsh_gethostname(char* name, int size); + +/*! \fn int WINAPI wsh_getdomainname(char* name, int size) + * Gets the machine's domain name + * + * defined in res_init.c + * + * \param[in, out] name pointer to a buffer that receives a null-terminated string containing the domain name + * \param[in] size specifies the size of the buffer, in chars (must be large + * enough to hold NULL-terminated domain name) + * + * \retval return 0 ifsuccess, -1 on error. + */ +int WINAPI wsh_getdomainname(char* name, int size); + + +#ifdef __cplusplus +} +#endif + +#endif /* _WSHELPER_ */ -- cgit