1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
|
/*
File: AddressXlation.h
Contains: TCP Manager interfaces for dnr.c
Version: Use with MacTCP 2.0.6 and Universal Interfaces 2.1b1
in ÒMPW PrereleaseÓ on ETO #17
Copyright: © 1984-1995 by Apple Computer, Inc.
All rights reserved.
Bugs?: If you find a problem with this file, send the file and version
information (from above) and the problem description to:
Internet: apple.bugs@applelink.apple.com
AppleLink: APPLE.BUGS
*/
#ifndef __ADDRESSXLATION__
#define __ADDRESSXLATION__
#ifndef __TYPES__
#include <Types.h>
#endif
/* #include <ConditionalMacros.h> */
#ifndef __MACTCP__
#include <MacTCP.h>
#endif
/* #include <AppleTalk.h> */
/* #include <OSUtils.h> */
/* #include <MixedMode.h> */
/* #include <Memory.h> */
#ifdef __cplusplus
extern "C" {
#endif
#if STRUCTALIGNMENTSUPPORTED
#pragma options align=mac68k
#endif
#if PRAGMA_IMPORT_SUPPORTED
#pragma import on
#endif
/*
Developer Notes:
When the various calls are made to the dnr code, you must set up
a NewRoutineDescriptor for every non-nil completion routine and/or
notifyProc parameter. Otherwise, the 68K dnr code, will not
correctly call your routine.
1. For the call to EnumCache, use NewEnumResultProc to set up a
universal procptr to pass as the enumResultProc parameter.
2. For the calls to StrToAddr and AddrToName, use NewResultProc to
set up a ResultUPP universal procptr to pass as the ResultProc
parameter.
3. For the calls to HInfo and MXInfo, use NewResultProc2Proc to
set up a ResultProc2UPP universal procptr to pass as the ResultProc
parameter.
4. The DNR selector symbol HINFO has been changed to HXINFO due to
conflict with the same symbol in the AddressXLation.h header
*/
enum {
NUM_ALT_ADDRS = 4
};
struct hostInfo {
long rtnCode;
char cname[255];
SInt8 filler; /* Filler for proper byte alignment */
unsigned long addr[NUM_ALT_ADDRS];
};
typedef struct hostInfo hostInfo;
enum {
A = 1,
NS = 2,
CNAME = 5,
HINFO = 13,
MX = 15,
lastClass = 32767
};
typedef unsigned short AddrClasses;
/* Domain Name Resolver code selectors */
enum {
OPENRESOLVER = 1,
CLOSERESOLVER = 2,
STRTOADDR = 3,
ADDRTOSTR = 4,
ENUMCACHE = 5,
ADDRTONAME = 6,
HXINFO = 7, /* changed from HINFO due to symbol conflict*/
MXINFO = 8
};
struct HInfoRec {
char cpuType[30];
char osType[30];
};
typedef struct HInfoRec HInfoRec;
struct MXRec {
unsigned short preference;
char exchange[255];
};
typedef struct MXRec MXRec;
struct returnRec {
long rtnCode;
char cname[255];
SInt8 filler; /* Filler for proper byte alignment */
union {
unsigned long addr[NUM_ALT_ADDRS];
struct HInfoRec hinfo;
struct MXRec mx;
} rdata;
};
typedef struct returnRec returnRec;
struct cacheEntryRecord {
char *cname;
unsigned short ctype;
unsigned short cacheClass;
unsigned long ttl;
union {
char *name;
ip_addr addr;
} rdata;
};
typedef struct cacheEntryRecord cacheEntryRecord;
typedef pascal void (*EnumResultProcPtr)(struct cacheEntryRecord *cacheEntryRecordPtr, Ptr userDataPtr);
typedef pascal void (*ResultProcPtr)(struct hostInfo *hostInfoPtr, Ptr userDataPtr);
typedef pascal void (*ResultProc2ProcPtr)(struct returnRec *returnRecPtr, Ptr userDataPtr);
#if GENERATINGCFM
typedef UniversalProcPtr EnumResultUPP;
typedef UniversalProcPtr ResultUPP;
typedef UniversalProcPtr ResultProc2UPP;
#else
typedef EnumResultProcPtr EnumResultUPP;
typedef ResultProcPtr ResultUPP;
typedef ResultProc2ProcPtr ResultProc2UPP;
#endif
enum {
uppEnumResultProcInfo = kPascalStackBased
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct cacheEntryRecord*)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr))),
uppResultProcInfo = kPascalStackBased
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct hostInfo*)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr))),
uppResultProc2ProcInfo = kPascalStackBased
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct returnRec*)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr)))
};
#if GENERATINGCFM
#define NewEnumResultProc(userRoutine) \
(EnumResultUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppEnumResultProcInfo, GetCurrentArchitecture())
#define NewResultProc(userRoutine) \
(ResultUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppResultProcInfo, GetCurrentArchitecture())
#define NewResultProc2Proc(userRoutine) \
(ResultProc2UPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppResultProc2ProcInfo, GetCurrentArchitecture())
#else
#define NewEnumResultProc(userRoutine) \
((EnumResultUPP) (userRoutine))
#define NewResultProc(userRoutine) \
((ResultUPP) (userRoutine))
#define NewResultProc2Proc(userRoutine) \
((ResultProc2UPP) (userRoutine))
#endif
#if GENERATINGCFM
#define CallEnumResultProc(userRoutine, cacheEntryRecordPtr, userDataPtr) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppEnumResultProcInfo, (cacheEntryRecordPtr), (userDataPtr))
#define CallResultProc(userRoutine, hostInfoPtr, userDataPtr) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppResultProcInfo, (hostInfoPtr), (userDataPtr))
#define CallResultProc2Proc(userRoutine, returnRecPtr, userDataPtr) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppResultProc2ProcInfo, (returnRecPtr), (userDataPtr))
#else
#define CallEnumResultProc(userRoutine, cacheEntryRecordPtr, userDataPtr) \
(*(userRoutine))((cacheEntryRecordPtr), (userDataPtr))
#define CallResultProc(userRoutine, hostInfoPtr, userDataPtr) \
(*(userRoutine))((hostInfoPtr), (userDataPtr))
#define CallResultProc2Proc(userRoutine, returnRecPtr, userDataPtr) \
(*(userRoutine))((returnRecPtr), (userDataPtr))
#endif
extern OSErr OpenResolver(char *fileName);
extern OSErr StrToAddr(char *hostName, struct hostInfo *hostInfoPtr, ResultUPP ResultProc, char *userDataPtr);
extern OSErr AddrToStr(unsigned long addr, char *addrStr);
extern OSErr EnumCache(EnumResultUPP enumResultProc, Ptr userDataPtr);
extern OSErr AddrToName(ip_addr addr, struct hostInfo *hostInfoPtr, ResultUPP ResultProc, Ptr userDataPtr);
extern OSErr HInfo(char *hostName, struct returnRec *returnRecPtr, ResultProc2UPP resultProc, Ptr userDataPtr);
extern OSErr MXInfo(char *hostName, struct returnRec *returnRecPtr, ResultProc2UPP resultProc, Ptr userDataPtr);
extern OSErr CloseResolver(void);
/*
Universal ProcPtrs declaration for each of the dnr selector code calls.
*/
typedef OSErr (*OpenResolverProcPtr)(UInt32 selector, char *filename);
typedef OSErr (*CloseResolverProcPtr)(UInt32 selector);
typedef OSErr (*StrToAddrProcPtr)(UInt32 selector, char *hostName, struct hostInfo *rtnStruct, ResultUPP resultproc, Ptr userDataPtr);
typedef OSErr (*AddrToStrProcPtr)(UInt32 selector, unsigned long addr, char *addrStr);
typedef OSErr (*EnumCacheProcPtr)(UInt32 selector, EnumResultUPP resultproc, Ptr userDataPtr);
typedef OSErr (*AddrToNameProcPtr)(UInt32 selector, UInt32 addr, struct hostInfo *rtnStruct, ResultUPP resultproc, Ptr userDataPtr);
typedef OSErr (*HInfoProcPtr)(UInt32 selector, char *hostName, struct returnRec *returnRecPtr, ResultProc2UPP resultProc, Ptr userDataPtr);
typedef OSErr (*MXInfoProcPtr)(UInt32 selector, char *hostName, struct returnRec *returnRecPtr, ResultProc2UPP resultProc, Ptr userDataPtr);
#if GENERATINGCFM
typedef UniversalProcPtr OpenResolverUPP;
typedef UniversalProcPtr CloseResolverUPP;
typedef UniversalProcPtr StrToAddrUPP;
typedef UniversalProcPtr AddrToStrUPP;
typedef UniversalProcPtr EnumCacheUPP;
typedef UniversalProcPtr AddrToNameUPP;
typedef UniversalProcPtr HInfoUPP;
typedef UniversalProcPtr MXInfoUPP;
#else
typedef OpenResolverProcPtr OpenResolverUPP;
typedef CloseResolverProcPtr CloseResolverUPP;
typedef StrToAddrProcPtr StrToAddrUPP;
typedef AddrToStrProcPtr AddrToStrUPP;
typedef EnumCacheProcPtr EnumCacheUPP;
typedef AddrToNameProcPtr AddrToNameUPP;
typedef HInfoProcPtr HInfoUPP;
typedef MXInfoProcPtr MXInfoUPP;
#endif
enum {
uppOpenResolverProcInfo = kCStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*))),
uppCloseResolverProcInfo = kCStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32))),
uppStrToAddrProcInfo = kCStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct hostInfo*)))
| STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ResultUPP)))
| STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Ptr))),
uppAddrToStrProcInfo = kCStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(unsigned long)))
| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(char*))),
uppEnumCacheProcInfo = kCStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(EnumResultUPP)))
| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Ptr))),
uppAddrToNameProcInfo = kCStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(UInt32)))
| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct hostInfo*)))
| STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ResultUPP)))
| STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Ptr))),
uppHInfoProcInfo = kCStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct returnRec*)))
| STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ResultProc2UPP)))
| STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Ptr))),
uppMXInfoProcInfo = kCStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(UInt32)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct returnRec*)))
| STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ResultProc2UPP)))
| STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Ptr)))
};
#if GENERATINGCFM
#define CallOpenResolverProc(userRoutine, selector, filename) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppOpenResolverProcInfo, (selector), (filename))
#define CallCloseResolverProc(userRoutine, selector) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppCloseResolverProcInfo, (selector))
#define CallStrToAddrProc(userRoutine, selector, hostName, rtnStruct, resultproc, userDataPtr) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppStrToAddrProcInfo, (selector), (hostName), (rtnStruct), (resultproc), (userDataPtr))
#define CallAddrToStrProc(userRoutine, selector, addr, addrStr) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppAddrToStrProcInfo, (selector), (addr), (addrStr))
#define CallEnumCacheProc(userRoutine, selector, resultproc, userDataPtr) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppEnumCacheProcInfo, (selector), (resultproc), (userDataPtr))
#define CallAddrToNameProc(userRoutine, selector, addr, rtnStruct, resultproc, userDataPtr) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppAddrToNameProcInfo, (selector), (addr), (rtnStruct), (resultproc), (userDataPtr))
#define CallHInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userDataPtr) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppHInfoProcInfo, (selector), (hostName), (returnRecPtr), (resultProc), (userDataPtr))
#define CallMXInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userDataPtr) \
CallUniversalProc((UniversalProcPtr)(userRoutine), uppMXInfoProcInfo, (selector), (hostName), (returnRecPtr), (resultProc), (userDataPtr))
#else
#define CallOpenResolverProc(userRoutine, selector, filename) \
(*(userRoutine))((selector), (filename))
#define CallCloseResolverProc(userRoutine, selector) \
(*(userRoutine))((selector))
#define CallStrToAddrProc(userRoutine, selector, hostName, rtnStruct, resultproc, userDataPtr) \
(*(userRoutine))((selector), (hostName), (rtnStruct), (resultproc), (userDataPtr))
#define CallAddrToStrProc(userRoutine, selector, addr, addrStr) \
(*(userRoutine))((selector), (addr), (addrStr))
#define CallEnumCacheProc(userRoutine, selector, resultproc, userDataPtr) \
(*(userRoutine))((selector), (resultproc), (userDataPtr))
#define CallAddrToNameProc(userRoutine, selector, addr, rtnStruct, resultproc, userDataPtr) \
(*(userRoutine))((selector), (addr), (rtnStruct), (resultproc), (userDataPtr))
#define CallHInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userDataPtr) \
(*(userRoutine))((selector), (hostName), (returnRecPtr), (resultProc), (userDataPtr))
#define CallMXInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userDataPtr) \
(*(userRoutine))((selector), (hostName), (returnRecPtr), (resultProc), (userDataPtr))
#endif
#if PRAGMA_IMPORT_SUPPORTED
#pragma import off
#endif
#if STRUCTALIGNMENTSUPPORTED
#pragma options align=reset
#endif
#ifdef __cplusplus
}
#endif
#endif /* __ADDRESSXLATION__ */
|
