NetWare/nwperlsys.h

   1 /*
   2  * Copyright © 2001 Novell, Inc. All Rights Reserved.
   3  *
   4  * You may distribute under the terms of either the GNU General Public
   5  * License or the Artistic License, as specified in the README file.
   6  *
   7  */
   8
   9 /*
  10  * FILENAME     :  nwperlsys.h
  11  * DESCRIPTION  :  Derives from iperlsys.h and define the
  12  *                 platform specific function
  13  * Author       :  SGP
  14  * Date Created :  June 12th 2001.
  15  * Date Modified:  June 30th 2001.
  16  */
  17
  18 #ifndef ___NWPerlSys_H___
  19 #define ___NWPerlSys_H___
  20
  21
  22 #include "iperlsys.h"
  23 #include "nwstdio.h"
  24
  25 #include "nw5iop.h"
  26 #include <fcntl.h>
  27
  28 //Socket related calls
  29 #include "nw5sck.h"
  30
  31 //Store the Watcom hash list
  32 #include "nwtinfo.h"
  33
  34 //Watcom hash list
  35 #include <wchash.h>
  36
  37 #include "win32ish.h"
  38
  39 START_EXTERN_C
  40 extern int do_spawn2(char *cmd, int exectype);
  41 extern int do_aspawn(void *vreally, void **vmark, void **vsp);
  42 extern void Perl_init_os_extras(void);
  43 BOOL fnGetHashListAddrs(void *addrs, BOOL *dontTouchHashList);
  44 END_EXTERN_C
  45
  46 /* IPerlMem - Memory management functions - Begin ========================================*/
  47
  48 void*
  49 PerlMemMalloc(struct IPerlMem* piPerl, size_t size)
  50 {
  51         void *ptr = NULL;
  52         ptr = malloc(size);
  53         if (ptr) {
  54                 void **listptr;
  55                 BOOL m_dontTouchHashLists;
  56                 if(fnGetHashListAddrs(&listptr,&m_dontTouchHashLists)) {
  57                         if (listptr) {
  58                                 WCValHashTable<void*>* m_allocList= (WCValHashTable<void*>*)listptr;
  59                                 (WCValHashTable<void*>*)m_allocList->insert(ptr);
  60                         }
  61                 }
  62         }
  63         return(ptr);
  64 }
  65
  66 void*
  67 PerlMemRealloc(struct IPerlMem* piPerl, void* ptr, size_t size)
  68 {
  69         void *newptr = NULL;
  70         WCValHashTable<void*>* m_allocList;
  71
  72         newptr = realloc(ptr, size);
  73
  74         if (ptr)
  75         {
  76                 void **listptr;
  77                 BOOL m_dontTouchHashLists;
  78                 if(fnGetHashListAddrs(&listptr,&m_dontTouchHashLists)) {
  79                         m_allocList= (WCValHashTable<void*>*)listptr;
  80                         (WCValHashTable<void*>*)m_allocList->remove(ptr);
  81                 }
  82         }
  83         if (newptr)
  84         {
  85                 if (m_allocList)
  86                         (WCValHashTable<void*>*)m_allocList->insert(newptr);
  87         }
  88
  89         return(newptr);
  90 }
  91
  92 void
  93 PerlMemFree(struct IPerlMem* piPerl, void* ptr)
  94 {
  95         BOOL m_dontTouchHashLists;
  96         WCValHashTable<void*>* m_allocList;
  97
  98         void **listptr;
  99         if(fnGetHashListAddrs(&listptr,&m_dontTouchHashLists)) {
 100                 m_allocList= (WCValHashTable<void*>*)listptr;
 101                 // Final clean up, free all the nodes from the hash list
 102                 if (m_dontTouchHashLists)
 103                 {
 104                         if(ptr)
 105                         {
 106                                 free(ptr);
 107                                 ptr = NULL;
 108                         }
 109                 }
 110                 else
 111                 {
 112                         if(ptr && m_allocList)
 113                         {
 114                                 if ((WCValHashTable<void*>*)m_allocList->remove(ptr))
 115                                 {
 116                                         free(ptr);
 117                                         ptr = NULL;
 118                                 }
 119                                 else
 120                                 {
 121                                         // If it comes here, that means that the memory pointer is not contained in the hash list.
 122                                         // But no need to free now, since if is deleted here, it will result in an abend!!
 123                                         // If the memory is still there, it will be cleaned during final cleanup anyway.
 124                                 }
 125                         }
 126                 }
 127         }
 128         return;
 129 }
 130
 131 void*
 132 PerlMemCalloc(struct IPerlMem* piPerl, size_t num, size_t size)
 133 {
 134         void *ptr = NULL;
 135
 136         ptr = calloc(num, size);
 137         if (ptr) {
 138                 void **listptr;
 139                 BOOL m_dontTouchHashLists;
 140                 if(fnGetHashListAddrs(&listptr,&m_dontTouchHashLists)) {
 141                         if (listptr) {
 142                                 WCValHashTable<void*>* m_allocList= (WCValHashTable<void*>*)listptr;
 143                                 (WCValHashTable<void*>*)m_allocList->insert(ptr);
 144                         }
 145                 }
 146         }
 147         return(ptr);
 148 }
 149
 150 struct IPerlMem perlMem =
 151 {
 152     PerlMemMalloc,
 153     PerlMemRealloc,
 154     PerlMemFree,
 155     PerlMemCalloc,
 156 };
 157
 158 /* IPerlMem - Memory management functions - End   ========================================*/
 159
 160 /* IPerlDir     - Directory Manipulation functions - Begin ===================================*/
 161
 162 int
 163 PerlDirMakedir(struct IPerlDir* piPerl, const char *dirname, int mode)
 164 {
 165         return mkdir(dirname);
 166 }
 167
 168 int
 169 PerlDirChdir(struct IPerlDir* piPerl, const char *dirname)
 170 {
 171         return nw_chdir(dirname);
 172 }
 173
 174 int
 175 PerlDirRmdir(struct IPerlDir* piPerl, const char *dirname)
 176 {
 177         return nw_rmdir(dirname);
 178 }
 179
 180 int
 181 PerlDirClose(struct IPerlDir* piPerl, DIR *dirp)
 182 {
 183         return nw_closedir(dirp);
 184 }
 185
 186 DIR*
 187 PerlDirOpen(struct IPerlDir* piPerl, const char *filename)
 188 {
 189         return nw_opendir(filename);
 190 }
 191
 192 struct direct *
 193 PerlDirRead(struct IPerlDir* piPerl, DIR *dirp)
 194 {
 195         return nw_readdir(dirp);
 196 }
 197
 198 void
 199 PerlDirRewind(struct IPerlDir* piPerl, DIR *dirp)
 200 {
 201     nw_rewinddir(dirp);
 202 }
 203
 204 void
 205 PerlDirSeek(struct IPerlDir* piPerl, DIR *dirp, long loc)
 206 {
 207     nw_seekdir(dirp, loc);
 208 }
 209
 210 long
 211 PerlDirTell(struct IPerlDir* piPerl, DIR *dirp)
 212 {
 213     return nw_telldir(dirp);
 214 }
 215
 216 struct IPerlDir perlDir =
 217 {
 218         PerlDirMakedir,
 219     PerlDirChdir,
 220     PerlDirRmdir,
 221     PerlDirClose,
 222     PerlDirOpen,
 223     PerlDirRead,
 224     PerlDirRewind,
 225     PerlDirSeek,
 226     PerlDirTell,
 227 };
 228
 229 /* IPerlDir     - Directory Manipulation functions - End   ===================================*/
 230
 231 /* IPerlEnv     - Environment related functions - Begin ======================================*/
 232
 233 char*
 234 PerlEnvGetenv(struct IPerlEnv* piPerl, const char *varname)
 235 {
 236         return(getenv(varname));
 237 };
 238
 239 int
 240 PerlEnvPutenv(struct IPerlEnv* piPerl, const char *envstring)
 241 {
 242         return(putenv(envstring));
 243 };
 244
 245 char*
 246 PerlEnvGetenv_len(struct IPerlEnv* piPerl, const char* varname, unsigned long* len)
 247 {
 248         *len = 0;
 249         char *e = getenv(varname);
 250         if (e)
 251             *len = strlen(e);
 252         return e;
 253 }
 254
 255 int
 256 PerlEnvUname(struct IPerlEnv* piPerl, struct utsname *name)
 257 {
 258     return nw_uname(name);
 259 }
 260
 261 void
 262 PerlEnvClearenv(struct IPerlEnv* piPerl)
 263 {
 264
 265 }
 266
 267 struct IPerlEnv perlEnv =
 268 {
 269         PerlEnvGetenv,
 270         PerlEnvPutenv,
 271     PerlEnvGetenv_len,
 272     PerlEnvUname,
 273     PerlEnvClearenv,
 274 /*    PerlEnvGetChildenv,
 275     PerlEnvFreeChildenv,
 276     PerlEnvGetChilddir,
 277     PerlEnvFreeChilddir,*/
 278 };
 279
 280 /* IPerlEnv     - Environment related functions - End   ======================================*/
 281
 282 /* IPerlStdio   - Stdio functions - Begin ================================================*/
 283
 284 FILE*
 285 PerlStdIOStdin(struct IPerlStdIO* piPerl)
 286 {
 287     return nw_stdin();
 288 }
 289
 290 FILE*
 291 PerlStdIOStdout(struct IPerlStdIO* piPerl)
 292 {
 293     return nw_stdout();
 294 }
 295
 296 FILE*
 297 PerlStdIOStderr(struct IPerlStdIO* piPerl)
 298 {
 299     return nw_stderr();
 300 }
 301
 302 FILE*
 303 PerlStdIOOpen(struct IPerlStdIO* piPerl, const char *path, const char *mode)
 304 {
 305     return nw_fopen(path, mode);
 306 }
 307
 308 int
 309 PerlStdIOClose(struct IPerlStdIO* piPerl, FILE* pf)
 310 {
 311     return nw_fclose(pf);
 312 }
 313
 314 int
 315 PerlStdIOEof(struct IPerlStdIO* piPerl, FILE* pf)
 316 {
 317     return nw_feof(pf);
 318 }
 319
 320 int
 321 PerlStdIOError(struct IPerlStdIO* piPerl, FILE* pf)
 322 {
 323     return nw_ferror(pf);
 324 }
 325
 326 void
 327 PerlStdIOClearerr(struct IPerlStdIO* piPerl, FILE* pf)
 328 {
 329     nw_clearerr(pf);
 330 }
 331
 332 int
 333 PerlStdIOGetc(struct IPerlStdIO* piPerl, FILE* pf)
 334 {
 335     return nw_getc(pf);
 336 }
 337
 338 STDCHAR*
 339 PerlStdIOGetBase(struct IPerlStdIO* piPerl, FILE* pf)
 340 {
 341 #ifdef FILE_base
 342     FILE *f = pf;
 343     return FILE_base(f);
 344 #else
 345     return NULL;
 346 #endif
 347 }
 348
 349 int
 350 PerlStdIOGetBufsiz(struct IPerlStdIO* piPerl, FILE* pf)
 351 {
 352 #ifdef FILE_bufsiz
 353     FILE *f = pf;
 354     return FILE_bufsiz(f);
 355 #else
 356     return (-1);
 357 #endif
 358 }
 359
 360 int
 361 PerlStdIOGetCnt(struct IPerlStdIO* piPerl, FILE* pf)
 362 {
 363 #ifdef USE_STDIO_PTR
 364     FILE *f = pf;
 365     return FILE_cnt(f);
 366 #else
 367     return (-1);
 368 #endif
 369 }
 370
 371 STDCHAR*
 372 PerlStdIOGetPtr(struct IPerlStdIO* piPerl, FILE* pf)
 373 {
 374 #ifdef USE_STDIO_PTR
 375     FILE *f = pf;
 376     return FILE_ptr(f);
 377 #else
 378     return NULL;
 379 #endif
 380 }
 381
 382 char*
 383 PerlStdIOGets(struct IPerlStdIO* piPerl, FILE* pf, char* s, int n)
 384 {
 385     return nw_fgets(s, n, pf);
 386 }
 387
 388 int
 389 PerlStdIOPutc(struct IPerlStdIO* piPerl, FILE* pf, int c)
 390 {
 391     return nw_fputc(c, pf);
 392 }
 393
 394 int
 395 PerlStdIOPuts(struct IPerlStdIO* piPerl, FILE* pf, const char *s)
 396 {
 397     return nw_fputs(s, pf);
 398 }
 399
 400 int
 401 PerlStdIOFlush(struct IPerlStdIO* piPerl, FILE* pf)
 402 {
 403     return nw_fflush(pf);
 404 }
 405
 406 int
 407 PerlStdIOUngetc(struct IPerlStdIO* piPerl, int c, FILE* pf)
 408 {
 409     return nw_ungetc(c, pf);
 410 }
 411
 412 int
 413 PerlStdIOFileno(struct IPerlStdIO* piPerl, FILE* pf)
 414 {
 415     return nw_fileno(pf);
 416 }
 417
 418 FILE*
 419 PerlStdIOFdopen(struct IPerlStdIO* piPerl, int fd, const char *mode)
 420 {
 421     return nw_fdopen(fd, mode);
 422 }
 423
 424 FILE*
 425 PerlStdIOReopen(struct IPerlStdIO* piPerl, const char*path, const char*mode, FILE* pf)
 426 {
 427     return nw_freopen(path, mode, pf);
 428 }
 429
 430 SSize_t
 431 PerlStdIORead(struct IPerlStdIO* piPerl, void *buffer, Size_t size, Size_t count, FILE* pf)
 432 {
 433     return nw_fread(buffer, size, count, pf);
 434 }
 435
 436 SSize_t
 437 PerlStdIOWrite(struct IPerlStdIO* piPerl, const void *buffer, Size_t size, Size_t count, FILE* pf)
 438 {
 439     return nw_fwrite(buffer, size, count, pf);
 440 }
 441
 442 void
 443 PerlStdIOSetBuf(struct IPerlStdIO* piPerl, FILE* pf, char* buffer)
 444 {
 445     nw_setbuf(pf, buffer);
 446 }
 447
 448 int
 449 PerlStdIOSetVBuf(struct IPerlStdIO* piPerl, FILE* pf, char* buffer, int type, Size_t size)
 450 {
 451     return nw_setvbuf(pf, buffer, type, size);
 452 }
 453
 454 void
 455 PerlStdIOSetCnt(struct IPerlStdIO* piPerl, FILE* pf, int n)
 456 {
 457 #ifdef STDIO_CNT_LVALUE
 458     FILE *f = pf;
 459     FILE_cnt(f) = n;
 460 #endif
 461 }
 462
 463 void
 464 PerlStdIOSetPtr(struct IPerlStdIO* piPerl, FILE* pf, STDCHAR * ptr)
 465 {
 466 #ifdef STDIO_PTR_LVALUE
 467     FILE *f = pf;
 468     FILE_ptr(f) = ptr;
 469 #endif
 470 }
 471
 472 void
 473 PerlStdIOSetlinebuf(struct IPerlStdIO* piPerl, FILE* pf)
 474 {
 475     nw_setvbuf(pf, NULL, _IOLBF, 0);
 476 }
 477
 478 int
 479 PerlStdIOPrintf(struct IPerlStdIO* piPerl, FILE* pf, const char *format,...)
 480 {
 481     va_list(arglist);
 482     va_start(arglist, format);
 483     return nw_vfprintf(pf, format, arglist);
 484 }
 485
 486 int
 487 PerlStdIOVprintf(struct IPerlStdIO* piPerl, FILE* pf, const char *format, va_list arglist)
 488 {
 489     return nw_vfprintf(pf, format, arglist);
 490 }
 491
 492 long
 493 PerlStdIOTell(struct IPerlStdIO* piPerl, FILE* pf)
 494 {
 495     return nw_ftell(pf);
 496 }
 497
 498 int
 499 PerlStdIOSeek(struct IPerlStdIO* piPerl, FILE* pf, off_t offset, int origin)
 500 {
 501     return nw_fseek(pf, offset, origin);
 502 }
 503
 504 void
 505 PerlStdIORewind(struct IPerlStdIO* piPerl, FILE* pf)
 506 {
 507     nw_rewind(pf);
 508 }
 509
 510 FILE*
 511 PerlStdIOTmpfile(struct IPerlStdIO* piPerl)
 512 {
 513     return nw_tmpfile();
 514 }
 515
 516 int
 517 PerlStdIOGetpos(struct IPerlStdIO* piPerl, FILE* pf, Fpos_t *p)
 518 {
 519     return nw_fgetpos(pf, p);
 520 }
 521
 522 int
 523 PerlStdIOSetpos(struct IPerlStdIO* piPerl, FILE* pf, const Fpos_t *p)
 524 {
 525     return nw_fsetpos(pf, p);
 526 }
 527
 528 void
 529 PerlStdIOInit(struct IPerlStdIO* piPerl)
 530 {
 531 }
 532
 533 void
 534 PerlStdIOInitOSExtras(struct IPerlStdIO* piPerl)
 535 {
 536     Perl_init_os_extras();
 537 }
 538
 539
 540 int
 541 PerlStdIOOpenOSfhandle(struct IPerlStdIO* piPerl, long osfhandle, int flags)
 542 {
 543     return nw_open_osfhandle(osfhandle, flags);
 544 }
 545
 546 int
 547 PerlStdIOGetOSfhandle(struct IPerlStdIO* piPerl, int filenum)
 548 {
 549     return nw_get_osfhandle(filenum);
 550 }
 551
 552 FILE*
 553 PerlStdIOFdupopen(struct IPerlStdIO* piPerl, FILE* pf)
 554 {
 555     FILE* pfdup=NULL;
 556     fpos_t pos=0;
 557     char mode[3]={'\0'};
 558     int fileno = nw_dup(nw_fileno(pf));
 559
 560     /* open the file in the same mode */
 561     if(((FILE*)pf)->_flag & _IOREAD) {
 562         mode[0] = 'r';
 563         mode[1] = 0;
 564     }
 565     else if(((FILE*)pf)->_flag & _IOWRT) {
 566         mode[0] = 'a';
 567         mode[1] = 0;
 568     }
 569     else if(((FILE*)pf)->_flag & _IORW) {
 570         mode[0] = 'r';
 571         mode[1] = '+';
 572         mode[2] = 0;
 573     }
 574
 575     /* it appears that the binmode is attached to the
 576      * file descriptor so binmode files will be handled
 577      * correctly
 578      */
 579     pfdup = nw_fdopen(fileno, mode);
 580
 581     /* move the file pointer to the same position */
 582     if (!fgetpos(pf, &pos)) {
 583         fsetpos(pfdup, &pos);
 584     }
 585     return pfdup;
 586 }
 587
 588 struct IPerlStdIO perlStdIO =
 589 {
 590         PerlStdIOStdin,
 591     PerlStdIOStdout,
 592     PerlStdIOStderr,
 593     PerlStdIOOpen,
 594     PerlStdIOClose,
 595     PerlStdIOEof,
 596     PerlStdIOError,
 597     PerlStdIOClearerr,
 598     PerlStdIOGetc,
 599     PerlStdIOGetBase,
 600     PerlStdIOGetBufsiz,
 601     PerlStdIOGetCnt,
 602     PerlStdIOGetPtr,
 603     PerlStdIOGets,
 604     PerlStdIOPutc,
 605     PerlStdIOPuts,
 606     PerlStdIOFlush,
 607     PerlStdIOUngetc,
 608     PerlStdIOFileno,
 609     PerlStdIOFdopen,
 610     PerlStdIOReopen,
 611     PerlStdIORead,
 612     PerlStdIOWrite,
 613     PerlStdIOSetBuf,
 614     PerlStdIOSetVBuf,
 615     PerlStdIOSetCnt,
 616     PerlStdIOSetPtr,
 617     PerlStdIOSetlinebuf,
 618     PerlStdIOPrintf,
 619     PerlStdIOVprintf,
 620     PerlStdIOTell,
 621     PerlStdIOSeek,
 622     PerlStdIORewind,
 623     PerlStdIOTmpfile,
 624     PerlStdIOGetpos,
 625     PerlStdIOSetpos,
 626     PerlStdIOInit,
 627     PerlStdIOInitOSExtras,
 628     PerlStdIOFdupopen,
 629 };
 630
 631 /* IPerlStdio   - Stdio functions - End   ================================================*/
 632
 633 /* IPerlLIO     - Low-level IO functions - Begin =============================================*/
 634
 635 int
 636 PerlLIOAccess(struct IPerlLIO* piPerl, const char *path, int mode)
 637 {
 638     return nw_access(path, mode);
 639 }
 640
 641 int
 642 PerlLIOChmod(struct IPerlLIO* piPerl, const char *filename, int pmode)
 643 {
 644     return nw_chmod(filename, pmode);
 645 }
 646
 647 int
 648 PerlLIOChown(struct IPerlLIO* piPerl, const char *filename, uid_t owner, gid_t group)
 649 {
 650         dTHX;
 651     Perl_croak(aTHX_ "chown not implemented!\n");
 652         return 0;
 653 }
 654
 655 int
 656 PerlLIOChsize(struct IPerlLIO* piPerl, int handle, long size)
 657 {
 658         return (nw_chsize(handle,size));
 659 }
 660
 661 int
 662 PerlLIOClose(struct IPerlLIO* piPerl, int handle)
 663 {
 664     return nw_close(handle);
 665 }
 666
 667 int
 668 PerlLIODup(struct IPerlLIO* piPerl, int handle)
 669 {
 670     return nw_dup(handle);
 671 }
 672
 673 int
 674 PerlLIODup2(struct IPerlLIO* piPerl, int handle1, int handle2)
 675 {
 676     return nw_dup2(handle1, handle2);
 677 }
 678
 679 int
 680 PerlLIOFlock(struct IPerlLIO* piPerl, int fd, int oper)
 681 {
 682         //On NetWare simulate flock by locking a range on the file
 683     return nw_flock(fd, oper);
 684 }
 685
 686 int
 687 PerlLIOFileStat(struct IPerlLIO* piPerl, int handle, struct stat *buffer)
 688 {
 689     return fstat(handle, buffer);
 690 }
 691
 692 int
 693 PerlLIOIOCtl(struct IPerlLIO* piPerl, int i, unsigned int u, char *data)
 694 {
 695         return 0;
 696 }
 697
 698 int
 699 PerlLIOIsatty(struct IPerlLIO* piPerl, int fd)
 700 {
 701     return nw_isatty(fd);
 702 }
 703
 704 int
 705 PerlLIOLink(struct IPerlLIO* piPerl, const char*oldname, const char *newname)
 706 {
 707     return nw_link(oldname, newname);
 708 }
 709
 710 long
 711 PerlLIOLseek(struct IPerlLIO* piPerl, int handle, long offset, int origin)
 712 {
 713     return nw_lseek(handle, offset, origin);
 714 }
 715
 716 int
 717 PerlLIOLstat(struct IPerlLIO* piPerl, const char *path, struct stat *buffer)
 718 {
 719     return nw_stat(path, buffer);
 720 }
 721
 722 char*
 723 PerlLIOMktemp(struct IPerlLIO* piPerl, char *Template)
 724 {
 725         return(nw_mktemp(Template));
 726 }
 727
 728 int
 729 PerlLIOOpen(struct IPerlLIO* piPerl, const char *filename, int oflag)
 730 {
 731     return nw_open(filename, oflag);
 732 }
 733
 734 int
 735 PerlLIOOpen3(struct IPerlLIO* piPerl, const char *filename, int oflag, int pmode)
 736 {
 737     return nw_open(filename, oflag, pmode);
 738 }
 739
 740 int
 741 PerlLIORead(struct IPerlLIO* piPerl, int handle, void *buffer, unsigned int count)
 742 {
 743     return nw_read(handle, buffer, count);
 744 }
 745
 746 int
 747 PerlLIORename(struct IPerlLIO* piPerl, const char *OldFileName, const char *newname)
 748 {
 749     return nw_rename(OldFileName, newname);
 750 }
 751
 752 int
 753 PerlLIOSetmode(struct IPerlLIO* piPerl, FILE *fp, int mode)
 754 {
 755     return nw_setmode(fp, mode);
 756 }
 757
 758 int
 759 PerlLIONameStat(struct IPerlLIO* piPerl, const char *path, struct stat *buffer)
 760 {
 761     return nw_stat(path, buffer);
 762 }
 763
 764 char*
 765 PerlLIOTmpnam(struct IPerlLIO* piPerl, char *string)
 766 {
 767     return tmpnam(string);
 768 }
 769
 770 int
 771 PerlLIOUmask(struct IPerlLIO* piPerl, int pmode)
 772 {
 773     return umask(pmode);
 774 }
 775
 776 int
 777 PerlLIOUnlink(struct IPerlLIO* piPerl, const char *filename)
 778 {
 779     return nw_unlink(filename);
 780 }
 781
 782 int
 783 PerlLIOUtime(struct IPerlLIO* piPerl, const char *filename, struct utimbuf *times)
 784 {
 785     return nw_utime(filename, times);
 786 }
 787
 788 int
 789 PerlLIOWrite(struct IPerlLIO* piPerl, int handle, const void *buffer, unsigned int count)
 790 {
 791     return nw_write(handle, buffer, count);
 792 }
 793
 794 struct IPerlLIO perlLIO =
 795 {
 796         PerlLIOAccess,
 797     PerlLIOChmod,
 798     PerlLIOChown,
 799     PerlLIOChsize,
 800     PerlLIOClose,
 801     PerlLIODup,
 802     PerlLIODup2,
 803     PerlLIOFlock,
 804     PerlLIOFileStat,
 805     PerlLIOIOCtl,
 806     PerlLIOIsatty,
 807     PerlLIOLink,
 808     PerlLIOLseek,
 809     PerlLIOLstat,
 810     PerlLIOMktemp,
 811     PerlLIOOpen,
 812     PerlLIOOpen3,
 813     PerlLIORead,
 814     PerlLIORename,
 815     PerlLIOSetmode,
 816     PerlLIONameStat,
 817     PerlLIOTmpnam,
 818     PerlLIOUmask,
 819     PerlLIOUnlink,
 820     PerlLIOUtime,
 821     PerlLIOWrite,
 822 };
 823
 824 /* IPerlLIO     - Low-level IO functions - End   =============================================*/
 825
 826 /* IPerlProc - Process control functions - Begin =========================================*/
 827
 828 #define EXECF_EXEC 1
 829 #define EXECF_SPAWN 2
 830
 831 void
 832 PerlProcAbort(struct IPerlProc* piPerl)
 833 {
 834     nw_abort();
 835 }
 836
 837 char *
 838 PerlProcCrypt(struct IPerlProc* piPerl, const char* clear, const char* salt)
 839 {
 840     return nw_crypt(clear, salt);
 841 }
 842
 843 void
 844 PerlProcExit(struct IPerlProc* piPerl, int status)
 845 {
 846 //    exit(status);
 847         dTHX;
 848         dJMPENV;
 849         JMPENV_JUMP(2);
 850 }
 851
 852 void
 853 PerlProc_Exit(struct IPerlProc* piPerl, int status)
 854 {
 855 //    _exit(status);
 856         dTHX;
 857         dJMPENV;
 858         JMPENV_JUMP(2);
 859 }
 860
 861 int
 862 PerlProcExecl(struct IPerlProc* piPerl, const char *cmdname, const char *arg0, const char *arg1, const char *arg2, const char *arg3)
 863 {
 864         dTHX;
 865     Perl_croak(aTHX_ "execl not implemented!\n");
 866         return 0;
 867 }
 868
 869 int
 870 PerlProcExecv(struct IPerlProc* piPerl, const char *cmdname, const char *const *argv)
 871 {
 872     return nw_execvp((char *)cmdname, (char **)argv);
 873 }
 874
 875 int
 876 PerlProcExecvp(struct IPerlProc* piPerl, const char *cmdname, const char *const *argv)
 877 {
 878     return nw_execvp((char *)cmdname, (char **)argv);
 879 }
 880
 881 uid_t
 882 PerlProcGetuid(struct IPerlProc* piPerl)
 883 {
 884         return 0;
 885 }
 886
 887 uid_t
 888 PerlProcGeteuid(struct IPerlProc* piPerl)
 889 {
 890         return 0;
 891 }
 892
 893 gid_t
 894 PerlProcGetgid(struct IPerlProc* piPerl)
 895 {
 896         return 0;
 897 }
 898
 899 gid_t
 900 PerlProcGetegid(struct IPerlProc* piPerl)
 901 {
 902         return 0;
 903 }
 904
 905 char *
 906 PerlProcGetlogin(struct IPerlProc* piPerl)
 907 {
 908         return NULL;
 909 }
 910
 911 int
 912 PerlProcKill(struct IPerlProc* piPerl, int pid, int sig)
 913 {
 914     return nw_kill(pid, sig);
 915 }
 916
 917 int
 918 PerlProcKillpg(struct IPerlProc* piPerl, int pid, int sig)
 919 {
 920     dTHX;
 921     Perl_croak(aTHX_ "killpg not implemented!\n");
 922     return 0;
 923 }
 924
 925 int
 926 PerlProcPauseProc(struct IPerlProc* piPerl)
 927 {
 928     return nw_sleep((32767L << 16) + 32767);
 929 }
 930
 931 PerlIO*
 932 PerlProcPopen(struct IPerlProc* piPerl, const char *command, const char *mode)
 933 {
 934     dTHX;
 935     PERL_FLUSHALL_FOR_CHILD;
 936
 937         return (PerlIO*)nw_Popen((char *)command, (char *)mode, (int *)errno);
 938 }
 939
 940 int
 941 PerlProcPclose(struct IPerlProc* piPerl, PerlIO *stream)
 942 {
 943     return nw_Pclose((FILE*)stream, (int *)errno);
 944 }
 945
 946 int
 947 PerlProcPipe(struct IPerlProc* piPerl, int *phandles)
 948 {
 949     return nw_Pipe((int *)phandles, (int *)errno);
 950 }
 951
 952 int
 953 PerlProcSetuid(struct IPerlProc* piPerl, uid_t u)
 954 {
 955         return 0;
 956 }
 957
 958 int
 959 PerlProcSetgid(struct IPerlProc* piPerl, gid_t g)
 960 {
 961         return 0;
 962 }
 963
 964 int
 965 PerlProcSleep(struct IPerlProc* piPerl, unsigned int s)
 966 {
 967     return nw_sleep(s);
 968 }
 969
 970 int
 971 PerlProcTimes(struct IPerlProc* piPerl, struct tms *timebuf)
 972 {
 973     return nw_times(timebuf);
 974 }
 975
 976 int
 977 PerlProcWait(struct IPerlProc* piPerl, int *status)
 978 {
 979     return nw_wait(status);
 980 }
 981
 982 int
 983 PerlProcWaitpid(struct IPerlProc* piPerl, int pid, int *status, int flags)
 984 {
 985     return nw_waitpid(pid, status, flags);
 986 }
 987
 988 Sighandler_t
 989 PerlProcSignal(struct IPerlProc* piPerl, int sig, Sighandler_t subcode)
 990 {
 991     return 0;
 992 }
 993
 994 int
 995 PerlProcFork(struct IPerlProc* piPerl)
 996 {
 997         return 0;
 998 }
 999
1000 int
1001 PerlProcGetpid(struct IPerlProc* piPerl)
1002 {
1003     return nw_getpid();
1004 }
1005
1006 /*BOOL
1007 PerlProcDoCmd(struct IPerlProc* piPerl, char *cmd)
1008 {
1009     do_spawn2(cmd, EXECF_EXEC);
1010     return FALSE;
1011 }*/
1012
1013 int
1014 PerlProcSpawn(struct IPerlProc* piPerl, char* cmds)
1015 {
1016     return do_spawn2(cmds, EXECF_SPAWN);
1017 }
1018
1019 int
1020 PerlProcSpawnvp(struct IPerlProc* piPerl, int mode, const char *cmdname, const char *const *argv)
1021 {
1022     return nw_spawnvp(mode, (char *)cmdname, (char **)argv);
1023 }
1024
1025 int
1026 PerlProcASpawn(struct IPerlProc* piPerl, void *vreally, void **vmark, void **vsp)
1027 {
1028     return do_aspawn(vreally, vmark, vsp);
1029 }
1030
1031 struct IPerlProc perlProc =
1032 {
1033     PerlProcAbort,
1034     PerlProcCrypt,
1035     PerlProcExit,
1036     PerlProc_Exit,
1037     PerlProcExecl,
1038     PerlProcExecv,
1039     PerlProcExecvp,
1040     PerlProcGetuid,
1041     PerlProcGeteuid,
1042     PerlProcGetgid,
1043     PerlProcGetegid,
1044     PerlProcGetlogin,
1045     PerlProcKill,
1046     PerlProcKillpg,
1047     PerlProcPauseProc,
1048     PerlProcPopen,
1049     PerlProcPclose,
1050     PerlProcPipe,
1051     PerlProcSetuid,
1052     PerlProcSetgid,
1053     PerlProcSleep,
1054     PerlProcTimes,
1055     PerlProcWait,
1056     PerlProcWaitpid,
1057     PerlProcSignal,
1058     PerlProcFork,
1059     PerlProcGetpid,
1060     //PerlProcLastHost;
1061     //PerlProcPopenList;
1062 };
1063
1064 /* IPerlProc - Process control functions - End   =========================================*/
1065
1066 /* IPerlSock - Socket functions - Begin ==================================================*/
1067
1068 u_long
1069 PerlSockHtonl(struct IPerlSock* piPerl, u_long hostlong)
1070 {
1071         return(nw_htonl(hostlong));
1072 }
1073
1074 u_short
1075 PerlSockHtons(struct IPerlSock* piPerl, u_short hostshort)
1076 {
1077         return(nw_htons(hostshort));
1078 }
1079
1080 u_long
1081 PerlSockNtohl(struct IPerlSock* piPerl, u_long netlong)
1082 {
1083         return nw_ntohl(netlong);
1084 }
1085
1086 u_short
1087 PerlSockNtohs(struct IPerlSock* piPerl, u_short netshort)
1088 {
1089         return nw_ntohs(netshort);
1090 }
1091
1092 SOCKET PerlSockAccept(struct IPerlSock* piPerl, SOCKET s, struct sockaddr* addr, int* addrlen)
1093 {
1094         return nw_accept(s, addr, addrlen);
1095 }
1096
1097 int
1098 PerlSockBind(struct IPerlSock* piPerl, SOCKET s, const struct sockaddr* name, int namelen)
1099 {
1100         return nw_bind(s, name, namelen);
1101 }
1102
1103 int
1104 PerlSockConnect(struct IPerlSock* piPerl, SOCKET s, const struct sockaddr* name, int namelen)
1105 {
1106         return nw_connect(s, name, namelen);
1107 }
1108
1109 void
1110 PerlSockEndhostent(struct IPerlSock* piPerl)
1111 {
1112     nw_endhostent();
1113 }
1114
1115 void
1116 PerlSockEndnetent(struct IPerlSock* piPerl)
1117 {
1118     nw_endnetent();
1119 }
1120
1121 void
1122 PerlSockEndprotoent(struct IPerlSock* piPerl)
1123 {
1124     nw_endprotoent();
1125 }
1126
1127 void
1128 PerlSockEndservent(struct IPerlSock* piPerl)
1129 {
1130     nw_endservent();
1131 }
1132
1133 struct hostent*
1134 PerlSockGethostbyaddr(struct IPerlSock* piPerl, const char* addr, int len, int type)
1135 {
1136         return(nw_gethostbyaddr(addr,len,type));
1137 }
1138
1139 struct hostent*
1140 PerlSockGethostbyname(struct IPerlSock* piPerl, const char* name)
1141 {
1142     return nw_gethostbyname(name);
1143 }
1144
1145 struct hostent*
1146 PerlSockGethostent(struct IPerlSock* piPerl)
1147 {
1148         return(nw_gethostent());
1149 }
1150
1151 int
1152 PerlSockGethostname(struct IPerlSock* piPerl, char* name, int namelen)
1153 {
1154         return nw_gethostname(name,namelen);
1155 }
1156
1157 struct netent *
1158 PerlSockGetnetbyaddr(struct IPerlSock* piPerl, long net, int type)
1159 {
1160     return nw_getnetbyaddr(net, type);
1161 }
1162
1163 struct netent *
1164 PerlSockGetnetbyname(struct IPerlSock* piPerl, const char *name)
1165 {
1166     return nw_getnetbyname((char*)name);
1167 }
1168
1169 struct netent *
1170 PerlSockGetnetent(struct IPerlSock* piPerl)
1171 {
1172     return nw_getnetent();
1173 }
1174
1175 int PerlSockGetpeername(struct IPerlSock* piPerl, SOCKET s, struct sockaddr* name, int* namelen)
1176 {
1177     return nw_getpeername(s, name, namelen);
1178 }
1179
1180 struct protoent*
1181 PerlSockGetprotobyname(struct IPerlSock* piPerl, const char* name)
1182 {
1183     return nw_getprotobyname(name);
1184 }
1185
1186 struct protoent*
1187 PerlSockGetprotobynumber(struct IPerlSock* piPerl, int number)
1188 {
1189     return nw_getprotobynumber(number);
1190 }
1191
1192 struct protoent*
1193 PerlSockGetprotoent(struct IPerlSock* piPerl)
1194 {
1195     return nw_getprotoent();
1196 }
1197
1198 struct servent*
1199 PerlSockGetservbyname(struct IPerlSock* piPerl, const char* name, const char* proto)
1200 {
1201     return nw_getservbyname((char*)name, (char*)proto);
1202 }
1203
1204 struct servent*
1205 PerlSockGetservbyport(struct IPerlSock* piPerl, int port, const char* proto)
1206 {
1207         return nw_getservbyport(port, proto);
1208 }
1209
1210 struct servent*
1211 PerlSockGetservent(struct IPerlSock* piPerl)
1212 {
1213         return nw_getservent();
1214 }
1215
1216 int
1217 PerlSockGetsockname(struct IPerlSock* piPerl, SOCKET s, struct sockaddr* name, int* namelen)
1218 {
1219         return nw_getsockname(s, name, namelen);
1220 }
1221
1222 int
1223 PerlSockGetsockopt(struct IPerlSock* piPerl, SOCKET s, int level, int optname, char* optval, int* optlen)
1224 {
1225         return nw_getsockopt(s, level, optname, optval, optlen);
1226 }
1227
1228 unsigned long
1229 PerlSockInetAddr(struct IPerlSock* piPerl, const char* cp)
1230 {
1231         return(nw_inet_addr(cp));
1232 }
1233
1234 char*
1235 PerlSockInetNtoa(struct IPerlSock* piPerl, struct in_addr in)
1236 {
1237         return NULL;
1238 }
1239
1240 int
1241 PerlSockListen(struct IPerlSock* piPerl, SOCKET s, int backlog)
1242 {
1243         return (nw_listen(s, backlog));
1244 }
1245
1246 int
1247 PerlSockRecv(struct IPerlSock* piPerl, SOCKET s, char* buffer, int len, int flags)
1248 {
1249         return (nw_recv(s, buffer, len, flags));
1250 }
1251
1252 int
1253 PerlSockRecvfrom(struct IPerlSock* piPerl, SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen)
1254 {
1255         return nw_recvfrom(s, buffer, len, flags, from, fromlen);
1256 }
1257
1258 int
1259 PerlSockSelect(struct IPerlSock* piPerl, int nfds, char* readfds, char* writefds, char* exceptfds, const struct timeval* timeout)
1260 {
1261         return nw_select(nfds, (fd_set*) readfds, (fd_set*) writefds, (fd_set*) exceptfds, timeout);
1262 }
1263
1264 int
1265 PerlSockSend(struct IPerlSock* piPerl, SOCKET s, const char* buffer, int len, int flags)
1266 {
1267         return (nw_send(s, buffer, len, flags));
1268 }
1269
1270 int
1271 PerlSockSendto(struct IPerlSock* piPerl, SOCKET s, const char* buffer, int len, int flags, const struct sockaddr* to, int tolen)
1272 {
1273         return(nw_sendto(s, buffer, len, flags, to, tolen));
1274 }
1275
1276 void
1277 PerlSockSethostent(struct IPerlSock* piPerl, int stayopen)
1278 {
1279         nw_sethostent(stayopen);
1280 }
1281
1282 void
1283 PerlSockSetnetent(struct IPerlSock* piPerl, int stayopen)
1284 {
1285         nw_setnetent(stayopen);
1286 }
1287
1288 void
1289 PerlSockSetprotoent(struct IPerlSock* piPerl, int stayopen)
1290 {
1291         nw_setprotoent(stayopen);
1292 }
1293
1294 void
1295 PerlSockSetservent(struct IPerlSock* piPerl, int stayopen)
1296 {
1297         nw_setservent(stayopen);
1298 }
1299
1300 int
1301 PerlSockSetsockopt(struct IPerlSock* piPerl, SOCKET s, int level, int optname, const char* optval, int optlen)
1302 {
1303         return nw_setsockopt(s, level, optname, optval, optlen);
1304 }
1305
1306 int
1307 PerlSockShutdown(struct IPerlSock* piPerl, SOCKET s, int how)
1308 {
1309         return nw_shutdown(s, how);
1310 }
1311
1312 SOCKET
1313 PerlSockSocket(struct IPerlSock* piPerl, int af, int type, int protocol)
1314 {
1315         return nw_socket(af, type, protocol);
1316 }
1317
1318 int
1319 PerlSockSocketpair(struct IPerlSock* piPerl, int domain, int type, int protocol, int* fds)
1320 {
1321     dTHX;
1322     Perl_croak(aTHX_ "socketpair not implemented!\n");
1323     return 0;
1324 }
1325
1326 int
1327 PerlSockIoctlsocket(struct IPerlSock* piPerl, SOCKET s, long cmd, u_long *argp)
1328 {
1329         dTHX;
1330     Perl_croak(aTHX_ "ioctlsocket not implemented!\n");
1331         return 0;
1332 }
1333
1334 struct IPerlSock  perlSock =
1335 {
1336         PerlSockHtonl,
1337     PerlSockHtons,
1338     PerlSockNtohl,
1339     PerlSockNtohs,
1340     PerlSockAccept,
1341     PerlSockBind,
1342     PerlSockConnect,
1343     PerlSockEndhostent,
1344     PerlSockEndnetent,
1345     PerlSockEndprotoent,
1346     PerlSockEndservent,
1347     PerlSockGethostname,
1348     PerlSockGetpeername,
1349     PerlSockGethostbyaddr,
1350     PerlSockGethostbyname,
1351     PerlSockGethostent,
1352     PerlSockGetnetbyaddr,
1353     PerlSockGetnetbyname,
1354     PerlSockGetnetent,
1355     PerlSockGetprotobyname,
1356     PerlSockGetprotobynumber,
1357     PerlSockGetprotoent,
1358     PerlSockGetservbyname,
1359     PerlSockGetservbyport,
1360     PerlSockGetservent,
1361     PerlSockGetsockname,
1362     PerlSockGetsockopt,
1363     PerlSockInetAddr,
1364         PerlSockInetNtoa,
1365         PerlSockListen,
1366     PerlSockRecv,
1367     PerlSockRecvfrom,
1368     PerlSockSelect,
1369     PerlSockSend,
1370     PerlSockSendto,
1371     PerlSockSethostent,
1372     PerlSockSetnetent,
1373     PerlSockSetprotoent,
1374     PerlSockSetservent,
1375     PerlSockSetsockopt,
1376     PerlSockShutdown,
1377         PerlSockSocket,
1378     PerlSockSocketpair,
1379 };
1380
1381 /* IPerlSock - Socket functions - End ==================================================*/
1382
1383 #endif /* ___NWPerlSys_H___ */