git.sur5r.net Git - openldap/blob - libraries/macintosh/tcp/dnr.c

   1 /*
   2         DNR.c - DNR library for MPW
   3
   4         © Copyright 1988 by Apple Computer.  All rights reserved
   5
   6 */
   7
   8 #define MPW3.0
   9
  10 #include <OSUtils.h>
  11 #include <Errors.h>
  12 #include <Files.h>
  13 #include <Resources.h>
  14 #include <Memory.h>
  15 #include <Traps.h>
  16 #include <GestaltEqu.h>
  17 #include <Folders.h>
  18 #include <MixedMode.h>
  19 #include <ToolUtils.h>
  20 #include "AddressXlation.h"
  21
  22 /*
  23  * function prototypes
  24  */
  25 static void GetSystemFolder(short *vRefNumP, long *dirIDP);
  26 static void GetCPanelFolder(short *vRefNumP, long *dirIDP);
  27 static short SearchFolderForDNRP(long targetType, long targetCreator, short vRefNum,
  28                 long dirID);
  29 static short OpenOurRF( void );
  30
  31
  32 #define OPENRESOLVER    1L
  33 #define CLOSERESOLVER   2L
  34 #define STRTOADDR               3L
  35 #define ADDRTOSTR               4L
  36 #define ENUMCACHE               5L
  37 #define ADDRTONAME              6L
  38 #define HINFO                   7L
  39 #define MXINFO                  8L
  40
  41 Handle                          codeHndl = nil;
  42 UniversalProcPtr        dnr = nil;
  43
  44
  45 static TrapType GetTrapType(unsigned long theTrap)
  46 {
  47         if (BitAnd(theTrap, 0x0800) > 0)
  48                 return(ToolTrap);
  49         else
  50                 return(OSTrap);
  51         }
  52
  53 static Boolean TrapAvailable(unsigned long trap)
  54 {
  55 TrapType trapType = ToolTrap;
  56 unsigned long numToolBoxTraps;
  57
  58         if (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  59                 numToolBoxTraps = 0x200;
  60         else
  61                 numToolBoxTraps = 0x400;
  62
  63         trapType = GetTrapType(trap);
  64         if (trapType == ToolTrap) {
  65                 trap = BitAnd(trap, 0x07FF);
  66                 if (trap >= numToolBoxTraps)
  67                         trap = _Unimplemented;
  68                 }
  69         return(NGetTrapAddress(trap, trapType) != NGetTrapAddress(_Unimplemented, ToolTrap));
  70
  71 }
  72
  73 static void GetSystemFolder(short *vRefNumP, long *dirIDP)
  74 {
  75         SysEnvRec info;
  76         long wdProcID;
  77
  78         SysEnvirons(1, &info);
  79         if (GetWDInfo(info.sysVRefNum, vRefNumP, dirIDP, &wdProcID) != noErr) {
  80                 *vRefNumP = 0;
  81                 *dirIDP = 0;
  82                 }
  83         }
  84
  85 static void GetCPanelFolder(short *vRefNumP, long *dirIDP)
  86 {
  87         Boolean hasFolderMgr = false;
  88         long feature;
  89
  90         if (Gestalt(gestaltFindFolderAttr, &feature) == noErr)
  91                 hasFolderMgr = true;
  92         if (!hasFolderMgr) {
  93                 GetSystemFolder(vRefNumP, dirIDP);
  94                 return;
  95                 }
  96         else {
  97                 if (FindFolder(kOnSystemDisk, kControlPanelFolderType, kDontCreateFolder, vRefNumP, dirIDP) != noErr) {
  98                         *vRefNumP = 0;
  99                         *dirIDP = 0;
 100                         }
 101                 }
 102         }
 103
 104 /* SearchFolderForDNRP is called to search a folder for files that might
 105         contain the 'dnrp' resource */
 106 static short SearchFolderForDNRP(long targetType, long targetCreator, short vRefNum, long dirID)
 107 {
 108         HParamBlockRec fi;
 109         Str255 filename;
 110         short refnum;
 111
 112         fi.fileParam.ioCompletion = nil;
 113         fi.fileParam.ioNamePtr = filename;
 114         fi.fileParam.ioVRefNum = vRefNum;
 115         fi.fileParam.ioDirID = dirID;
 116         fi.fileParam.ioFDirIndex = 1;
 117
 118         while (PBHGetFInfoSync(&fi) == noErr) {
 119                 /* scan system folder for driver resource files of specific type & creator */
 120                 if (fi.fileParam.ioFlFndrInfo.fdType == targetType &&
 121                         fi.fileParam.ioFlFndrInfo.fdCreator == targetCreator) {
 122                         /* found the MacTCP driver file? */
 123                         refnum = HOpenResFile(vRefNum, dirID, filename, fsRdPerm);
 124                         if (GetIndResource('dnrp', 1) == NULL)
 125                                 CloseResFile(refnum);
 126                         else
 127                                 return refnum;
 128                         }
 129                 /* check next file in system folder */
 130                 fi.fileParam.ioFDirIndex++;
 131                 fi.fileParam.ioDirID = dirID;   /* PBHGetFInfo() clobbers ioDirID */
 132                 }
 133         return(-1);
 134         }
 135
 136
 137
 138 /* OpenOurRF is called to open the MacTCP driver resources */
 139
 140 static short OpenOurRF()
 141 {
 142         short refnum;
 143         short vRefNum;
 144         long dirID;
 145
 146         /* first search Control Panels for MacTCP 1.1 */
 147         GetCPanelFolder(&vRefNum, &dirID);
 148         refnum = SearchFolderForDNRP('cdev', 'ztcp', vRefNum, dirID);
 149         if (refnum != -1) return(refnum);
 150
 151         /* next search System Folder for MacTCP 1.0.x */
 152         GetSystemFolder(&vRefNum, &dirID);
 153         refnum = SearchFolderForDNRP('cdev', 'mtcp', vRefNum, dirID);
 154         if (refnum != -1) return(refnum);
 155
 156         /* finally, search Control Panels for MacTCP 1.0.x */
 157         GetCPanelFolder(&vRefNum, &dirID);
 158         refnum = SearchFolderForDNRP('cdev', 'mtcp', vRefNum, dirID);
 159         if (refnum != -1) return(refnum);
 160
 161         return -1;
 162         }
 163
 164
 165
 166
 167 typedef OSErr (*OpenResolverProcPtr)(long selector, char* fileName);
 168
 169 enum {
 170         uppOpenResolverProcInfo = kCStackBased
 171                  | RESULT_SIZE(SIZE_CODE(sizeof(short)))
 172                  | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
 173                  | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *)))
 174 };
 175
 176 #if USESROUTINEDESCRIPTORS
 177 typedef UniversalProcPtr OpenResolverUPP;
 178
 179 #define NewOpenResolverProc(userRoutine)                                                \
 180                 (OpenResolverUPP) NewRoutineDescriptor(userRoutine, uppOpenResolverProcInfo, GetCurrentISA())
 181 #define CallOpenResolverProc(userRoutine, selector, filename)   \
 182                 CallUniversalProc(userRoutine, uppOpenResolverProcInfo, selector, filename)
 183 #else
 184 typedef OpenResolverProcPtr OpenResolverUPP;
 185
 186 #define NewOpenResolverProc(userRoutine)                                        \
 187                 (OpenResolverUPP)(userRoutine)
 188 #define CallOpenResolverProc(userRoutine, selector, filename)   \
 189                 (*(OpenResolverProcPtr)userRoutine)(selector, filename)
 190 #endif
 191
 192
 193
 194 OSErr OpenResolver(char *fileName)
 195 {
 196         short                   refnum;
 197         OSErr                   rc;
 198
 199         if (dnr != nil)
 200                 /* resolver already loaded in */
 201                 return(noErr);
 202
 203         /* open the MacTCP driver to get DNR resources. Search for it based on
 204            creator & type rather than simply file name */
 205         refnum = OpenOurRF();
 206
 207         /* ignore failures since the resource may have been installed in the
 208            System file if running on a Mac 512Ke */
 209
 210         /* load in the DNR resource package */
 211         codeHndl = GetIndResource('dnrp', 1);
 212         if (codeHndl == nil) {
 213                 /* can't open DNR */
 214                 return(ResError());
 215         }
 216
 217         DetachResource(codeHndl);
 218         if (refnum != -1) {
 219                 CloseWD(refnum);
 220                 CloseResFile(refnum);
 221         }
 222
 223         /* lock the DNR resource since it cannot be relocated while opened */
 224         HLock(codeHndl);
 225         dnr = (UniversalProcPtr) *codeHndl;
 226
 227         /* call open resolver */
 228         rc = CallOpenResolverProc(dnr, OPENRESOLVER, fileName);
 229         if (rc != noErr) {
 230                 /* problem with open resolver, flush it */
 231                 HUnlock(codeHndl);
 232                 DisposeHandle(codeHndl);
 233                 dnr = nil;
 234         }
 235         return(rc);
 236 }
 237
 238
 239
 240 typedef OSErr (*CloseResolverProcPtr)(long selector);
 241
 242 enum {
 243         uppCloseResolverProcInfo = kCStackBased
 244                  | RESULT_SIZE(SIZE_CODE(sizeof(short)))
 245                  | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
 246 };
 247
 248 #if USESROUTINEDESCRIPTORS
 249 typedef UniversalProcPtr CloseResolverUPP;
 250
 251 #define NewCloseResolverProc(userRoutine)                                               \
 252                 (CloseResolverUPP) NewRoutineDescriptor(userRoutine, uppCloseResolverProcInfo, GetCurrentISA())
 253 #define CallCloseResolverProc(userRoutine, selector)    \
 254                 CallUniversalProc(userRoutine, uppCloseResolverProcInfo, selector)
 255 #else
 256 typedef CloseResolverProcPtr CloseResolverUPP;
 257
 258 #define NewCloseResolverProc(userRoutine)                                               \
 259                 (CloseResolverUPP)(userRoutine)
 260 #define CallCloseResolverProc(userRoutine, selector)    \
 261                 (*(CloseResolverProcPtr)userRoutine)(selector)
 262 #endif
 263
 264
 265
 266 OSErr CloseResolver()
 267 {
 268         if (dnr == nil)
 269                 /* resolver not loaded error */
 270                 return(notOpenErr);
 271
 272         /* call close resolver */
 273         CallCloseResolverProc(dnr, CLOSERESOLVER);
 274
 275         /* release the DNR resource package */
 276         HUnlock(codeHndl);
 277         DisposeHandle(codeHndl);
 278         dnr = nil;
 279         return(noErr);
 280 }
 281
 282
 283
 284
 285 typedef OSErr (*StrToAddrProcPtr)(long selector, char* hostName, struct hostInfo* rtnStruct,
 286                                                                         long resultProc, char* userData);
 287
 288 enum {
 289         uppStrToAddrProcInfo = kCStackBased
 290                  | RESULT_SIZE(SIZE_CODE(sizeof(short)))
 291                  | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
 292                  | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *)))
 293                  | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct hostInfo *)))
 294                  | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long)))
 295                  | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char *)))
 296 };
 297
 298 #if USESROUTINEDESCRIPTORS
 299 typedef UniversalProcPtr StrToAddrUPP;
 300
 301 #define NewStrToAddrProc(userRoutine)                                           \
 302                 (StrToAddrUPP) NewRoutineDescriptor(userRoutine, uppStrToAddrProcInfo, GetCurrentISA())
 303 #define CallStrToAddrProc(userRoutine, selector, hostName, rtnStruct, resultProc, userData)     \
 304                 CallUniversalProc(userRoutine, uppStrToAddrProcInfo, selector, hostName, rtnStruct, resultProc, userData)
 305 #else
 306 typedef StrToAddrProcPtr StrToAddrUPP;
 307
 308 #define NewStrToAddrProc(userRoutine)                                           \
 309                 (StrToAddrUPP)(userRoutine)
 310 #define CallStrToAddrProc(userRoutine, selector, hostName, rtnStruct, resultProc, userData)     \
 311                 (*(StrToAddrProcPtr)userRoutine)(selector, hostName, rtnStruct, resultProc, userData)
 312 #endif
 313
 314
 315
 316 OSErr StrToAddr(char *hostName, struct hostInfo *rtnStruct, ResultUPP resultupp, char *userDataPtr)
 317 {
 318         if (dnr == nil)
 319                 /* resolver not loaded error */
 320                 return(notOpenErr);
 321
 322         return(CallStrToAddrProc(dnr, STRTOADDR, hostName, rtnStruct, (long)resultupp, userDataPtr));
 323 }
 324
 325
 326 typedef OSErr (*AddrToStrProcPtr)(long selector, long address, char* hostName);
 327
 328 enum {
 329         uppAddrToStrProcInfo = kCStackBased
 330                  | RESULT_SIZE(SIZE_CODE(sizeof(short)))
 331                  | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
 332                  | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(unsigned long)))
 333                  | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(char *)))
 334 };
 335
 336 #if USESROUTINEDESCRIPTORS
 337 typedef UniversalProcPtr AddrToStrUPP;
 338
 339 #define NewAddrToStrProc(userRoutine)                                           \
 340                 (AddrToStrUPP) NewRoutineDescriptor(userRoutine, uppAddrToStrProcInfo, GetCurrentISA())
 341 #define CallAddrToStrProc(userRoutine, selector, address, hostName)     \
 342                 CallUniversalProc(userRoutine, uppAddrToStrProcInfo, selector, address, hostName)
 343 #else
 344 typedef AddrToStrProcPtr AddrToStrUPP;
 345
 346 #define NewAddrToStrProc(userRoutine)                                           \
 347                 (AddrToStrUPP)(userRoutine)
 348 #define CallAddrToStrProc(userRoutine, selector, address, hostName)     \
 349                 (*(AddrToStrProcPtr)userRoutine)(selector, address, hostName)
 350 #endif
 351
 352
 353 OSErr AddrToStr(unsigned long addr, char *addrStr)
 354 {
 355         if (dnr == nil)
 356                 /* resolver not loaded error */
 357                 return(notOpenErr);
 358
 359         CallAddrToStrProc(dnr, ADDRTOSTR, addr, addrStr);
 360
 361         return(noErr);
 362 }
 363
 364
 365
 366 typedef OSErr (*EnumCacheProcPtr)(long selector, long result, char* userData);
 367
 368 enum {
 369         uppEnumCacheProcInfo = kCStackBased
 370                  | RESULT_SIZE(SIZE_CODE(sizeof(short)))
 371                  | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
 372                  | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
 373                  | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(char *)))
 374 };
 375
 376 #if USESROUTINEDESCRIPTORS
 377 typedef UniversalProcPtr EnumCacheUPP;
 378
 379 #define NewEnumCacheProc(userRoutine)                                           \
 380                 (EnumCacheUPP) NewRoutineDescriptor(userRoutine, uppEnumCacheProcInfo, GetCurrentISA())
 381 #define CallEnumCacheProc(userRoutine, selector, result, userData)      \
 382                 CallUniversalProc(userRoutine, uppEnumCacheProcInfo, selector, result, userData)
 383 #else
 384 typedef EnumCacheProcPtr EnumCacheUPP;
 385
 386 #define NewEnumCacheProc(userRoutine)                                           \
 387                 (EnumCacheUPP)(userRoutine)
 388 #define CallEnumCacheProc(userRoutine, selector, result, userData)      \
 389                 (*(EnumCacheProcPtr)userRoutine)(selector, result, userData)
 390 #endif
 391
 392
 393
 394 OSErr EnumCache(EnumResultUPP resultupp, char *userDataPtr)
 395 {
 396         if (dnr == nil)
 397                 /* resolver not loaded error */
 398                 return(notOpenErr);
 399
 400         return(CallEnumCacheProc(dnr, ENUMCACHE, (long)resultupp, userDataPtr));
 401 }
 402
 403
 404
 405 typedef OSErr (*AddrToNameProcPtr)(long selector, unsigned long addr, struct hostInfo* rtnStruct,
 406                                                                         long resultProc, char* userData);
 407
 408 enum {
 409         uppAddrToNameProcInfo = kCStackBased
 410                  | RESULT_SIZE(SIZE_CODE(sizeof(short)))
 411                  | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
 412                  | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(unsigned long)))
 413                  | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct hostInfo *)))
 414                  | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long)))
 415                  | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char *)))
 416
 417 };
 418
 419 #if USESROUTINEDESCRIPTORS
 420 typedef UniversalProcPtr AddrToNameUPP;
 421
 422 #define NewAddrToNameProc(userRoutine)                                          \
 423                 (AddrToNameUPP) NewRoutineDescriptor(userRoutine, uppAddrToNameProcInfo, GetCurrentISA())
 424 #define CallAddrToNameProc(userRoutine, selector, addr, rtnStruct, resultProc, userData)        \
 425                 CallUniversalProc(userRoutine, uppAddrToNameProcInfo, selector, addr, rtnStruct, resultProc, userData)
 426 #else
 427 typedef AddrToNameProcPtr AddrToNameUPP;
 428
 429 #define NewAddrToNameProc(userRoutine)                                          \
 430                 (AddrToNameUPP)(userRoutine)
 431 #define CallAddrToNameProc(userRoutine, selector, addr, rtnStruct, resultProc, userData)        \
 432                 (*(AddrToNameProcPtr)userRoutine)(selector, addr, rtnStruct, resultProc, userData)
 433 #endif
 434
 435
 436
 437 OSErr AddrToName(unsigned long addr, struct hostInfo *rtnStruct, ResultUPP resultupp,
 438         char *userDataPtr)
 439 {
 440         if (dnr == nil)
 441                 /* resolver not loaded error */
 442                 return(notOpenErr);
 443
 444         return(CallAddrToNameProc(dnr, ADDRTONAME, addr, rtnStruct, (long)resultupp, userDataPtr));
 445 }
 446
 447
 448 typedef OSErr (*HInfoProcPtr)(long selector, char* hostName, struct returnRec* returnRecPtr,
 449                                                                 long resultProc, char* userData);
 450
 451 enum {
 452         uppHInfoProcInfo = kCStackBased
 453                  | RESULT_SIZE(SIZE_CODE(sizeof(short)))
 454                  | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
 455                  | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *)))
 456                  | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct returnRec *)))
 457                  | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long)))
 458                  | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char *)))
 459
 460 };
 461
 462 #if USESROUTINEDESCRIPTORS
 463 typedef UniversalProcPtr HInfoUPP;
 464
 465 #define NewHInfoProc(userRoutine)                                               \
 466                 (HInfoUPP) NewRoutineDescriptor(userRoutine, uppHInfoProcInfo, GetCurrentISA())
 467 #define CallHInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userData)      \
 468                 CallUniversalProc(userRoutine, uppHInfoProcInfo, selector, hostName, returnRecPtr, resultProc, userData)
 469 #else
 470 typedef HInfoProcPtr HInfoUPP;
 471
 472 #define NewHInfoProc(userRoutine)                                               \
 473                 (HInfoUPP)(userRoutine)
 474 #define CallHInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userData)      \
 475                 (*(HInfoProcPtr)userRoutine)( selector, hostName, returnRecPtr, resultProc, userData)
 476 #endif
 477
 478 extern OSErr HInfo(char *hostName, struct returnRec *returnRecPtr, ResultProc2Ptr resultProc,
 479         char *userDataPtr)
 480 {
 481         if (dnr == nil)
 482                 /* resolver not loaded error */
 483                 return(notOpenErr);
 484
 485         return(CallHInfoProc(dnr, HINFO, hostName, returnRecPtr, (long)resultProc, userDataPtr));
 486 }
 487
 488
 489
 490 typedef OSErr (*MXInfoProcPtr)(long selector, char* hostName, struct returnRec* returnRecPtr,
 491                                                                 long resultProc, char* userData);
 492
 493 enum {
 494         uppMXInfoProcInfo = kCStackBased
 495                  | RESULT_SIZE(SIZE_CODE(sizeof(short)))
 496                  | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
 497                  | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *)))
 498                  | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(struct returnRec *)))
 499                  | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long)))
 500                  | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char *)))
 501
 502 };
 503
 504 #if USESROUTINEDESCRIPTORS
 505 typedef UniversalProcPtr MXInfoUPP;
 506
 507 #define NewMXInfoProc(userRoutine)                                              \
 508                 (MXInfoUPP) NewRoutineDescriptor(userRoutine, uppMXInfoProcInfo, GetCurrentISA())
 509 #define CallMXInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userData)     \
 510                 CallUniversalProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userData)
 511 #else
 512 typedef MXInfoProcPtr MXInfoUPP;
 513
 514 #define NewMXInfoProc(userRoutine)                                              \
 515                 (MXInfoUPP)(userRoutine)
 516 #define CallMXInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userData)     \
 517                 (*(MXInfoProcPtr)userRoutine)(selector, hostName, returnRecPtr, resultProc, userData)
 518 #endif
 519
 520
 521 extern OSErr MXInfo(char *hostName, struct returnRec *returnRecPtr, ResultProc2Ptr resultProc,
 522         char *userDataPtr)
 523 {
 524         if (dnr == nil)
 525                 /* resolver not loaded error */
 526                 return(notOpenErr);
 527
 528         return(CallMXInfoProc(dnr, MXINFO, hostName, returnRecPtr, (long)resultProc, userDataPtr));
 529 }