pc/util_nt.c

   1 /* Various utilities - NT versions
   2    Copyright (C) 1994, 1995, 1996 the Free Software Foundation.
   3
   4    Written 1994, 1995, 1996 by:
   5    Juan Grigera, Miguel de Icaza, Janne Kukonlehto, Dugan Porter,
   6    Jakub Jelinek, Mauricio Plaza.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include <config.h>
  23 #include <sys/types.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <windows.h>
  27 #include <io.h>
  28 #include <fcntl.h>
  29 #include <signal.h>             /* my_system */
  30 #include <limits.h>             /* INT_MAX */
  31 #include <errno.h>
  32 #include <sys/time.h>           /* select: timeout */
  33 #include <sys/param.h>
  34 #include <sys/stat.h>
  35 #include <stdarg.h>
  36 #include <process.h>
  37 #include "../src/fs.h"
  38 #include "../src/util.h"
  39 #include "util_win32.h"
  40
  41 #ifdef __BORLANDC__
  42 #define ENOTEMPTY ERROR_DIR_NOT_EMPTY
  43 #endif
  44
  45 char *get_owner (int uid)
  46 {
  47     return "none";
  48 }
  49
  50 char *get_group (int gid)
  51 {
  52     return "none";
  53 }
  54
  55 /* Pipes are guaranteed to be able to hold at least 4096 bytes */
  56 /* More than that would be unportable */
  57 #define MAX_PIPE_SIZE 4096
  58
  59 static int error_pipe[2];       /* File descriptors of error pipe */
  60 static int old_error;           /* File descriptor of old standard error */
  61
  62 /* Creates a pipe to hold standard error for a later analysis. */
  63 /* The pipe can hold 4096 bytes. Make sure no more is written */
  64 /* or a deadlock might occur. */
  65 void open_error_pipe (void)
  66 {
  67     if (pipe (error_pipe) < 0){
  68         message (0, " Warning ", " Pipe failed ");
  69     }
  70     old_error = dup (2);
  71     if(old_error < 0 || close(2) || dup (error_pipe[1]) != 2){
  72         message (0, " Warning ", " Dup failed ");
  73         close (error_pipe[0]);
  74         close (error_pipe[1]);
  75     }
  76     close (error_pipe[1]);
  77 }
  78
  79 void close_error_pipe (int error, char *text)
  80 {
  81     char *title;
  82     char msg[MAX_PIPE_SIZE];
  83     int len = 0;
  84
  85     if (error)
  86         title = " Error ";
  87     else
  88         title = " Warning ";
  89     if (old_error >= 0){
  90         close (2);
  91         dup (old_error);
  92         close (old_error);
  93         len = read (error_pipe[0], msg, MAX_PIPE_SIZE);
  94
  95         if (len >= 0)
  96             msg[len] = 0;
  97         close (error_pipe[0]);
  98     }
  99     if (error < 0)
 100         return;         /* Just ignore error message */
 101     if (text == NULL){
 102         if (len == 0) return;   /* Nothing to show */
 103
 104         /* Show message from pipe */
 105         message (error, title, msg);
 106     } else {
 107         /* Show given text and possible message from pipe */
 108         message (error, title, " %s \n %s ", text, msg);
 109     }
 110 }
 111
 112 void check_error_pipe (void)
 113 {
 114     char error[MAX_PIPE_SIZE];
 115     int len = 0;
 116     if (old_error >= 0){
 117         while (len < MAX_PIPE_SIZE)
 118         {
 119             int rvalue;
 120
 121             rvalue = -1; // read (error_pipe[0], error + len, 1);
 122             if (rvalue <= 0)
 123                 break;
 124             len ++;
 125         }
 126         error[len] = 0;
 127         close (error_pipe[0]);
 128     }
 129     if (len > 0)
 130         message (0, " Warning ", error);
 131 }
 132
 133 int my_system (int as_shell_command, const char *shell, const char *command)
 134 {
 135     int status = 0;
 136
 137 #if 0
 138 /* .ado: temp. turn out */
 139     if (as_shell_command) {
 140                 /* It is only the shell, /c will not work */
 141                 if (command)
 142                         spawnlp (P_WAIT, shell, shell, "/c", command, (char *) 0);
 143                 else
 144                         spawnlp (P_WAIT, shell, (char *) 0);
 145         } else
 146        spawnl (P_WAIT, shell, shell, command, (char *) 0);
 147
 148     if (win32_GetPlatform() == OS_Win95) {
 149             SetConsoleTitle ("GNU Midnight Commander");         /* title is gone after spawn... */
 150     }
 151 #endif
 152     if (as_shell_command) {
 153         if (!access(command, 0)) {
 154             switch(win32_GetEXEType (shell)) {
 155                 case EXE_win16:                 /* Windows 3.x archive or OS/2 */
 156                 case EXE_win32GUI:              /* NT or Chicago GUI API */
 157                     spawnlp (P_NOWAIT, shell, shell, "/c", command, (char *) 0);   /* don't wait for GUI programs to end */
 158                     break;
 159                 case EXE_otherCUI:              /* DOS COM, MZ, ZM, Phar Lap */
 160                 case EXE_win32CUI:              /* NT or Chicago Console API, also OS/2 */
 161                 case EXE_Unknown:
 162                 default:
 163                     spawnlp (P_WAIT, shell, shell, "/c", command, (char *) 0);
 164                     break;
 165             }
 166         }
 167         else
 168             spawnlp (P_WAIT, shell, shell, "/c", command, (char *) 0);
 169     }
 170     else
 171        spawnl (P_WAIT, shell, shell, command, (char *) 0);
 172
 173     if (win32_GetPlatform() == OS_Win95) {
 174             SetConsoleTitle ("GNU Midnight Commander");         /* title is gone after spawn... */
 175     }
 176
 177     return status;
 178 }
 179
 180 /* get_default_shell
 181    Get the default shell for the current hardware platform
 182 */
 183 char* get_default_shell()
 184 {
 185     if (win32_GetPlatform() == OS_WinNT)
 186         return "cmd.exe";
 187     else
 188         return "command.com";
 189 }
 190
 191 char *tilde_expand (char *directory)
 192 {
 193     return strdup (directory);
 194 }
 195
 196 /* sleep: Call Windows API.
 197           Cannot do simple define. That would need <windows.h> in every source
 198 */
 199 #ifndef __EMX__
 200 void sleep(unsigned long dwMiliSecs)
 201 {
 202     Sleep(dwMiliSecs);
 203 }
 204 #endif
 205
 206 /* Canonicalize path, and return a new path. Do everything in situ.
 207    The new path differs from path in:
 208         Multiple `/'s are collapsed to a single `/'.
 209         Leading `./'s and trailing `/.'s are removed.
 210         Trailing `/'s are removed.
 211         Non-leading `../'s and trailing `..'s are handled by removing
 212         portions of the path. */
 213 char *canonicalize_pathname (char *path)
 214 {
 215     int i, start;
 216     char stub_char;
 217
 218     stub_char = (*path == PATH_SEP) ? PATH_SEP : '.';
 219
 220     /* Walk along path looking for things to compact. */
 221     i = 0;
 222     for (;;) {
 223         if (!path[i])
 224             break;
 225
 226         while (path[i] && path[i] != PATH_SEP)
 227             i++;
 228
 229         start = i++;
 230
 231         /* If we didn't find any slashes, then there is nothing left to do. */
 232         if (!path[start])
 233             break;
 234
 235         /* Handle multiple `/'s in a row. */
 236         while (path[i] == PATH_SEP)
 237             i++;
 238
 239         if ((start + 1) != i) {
 240             strcpy (path + start + 1, path + i);
 241             i = start + 1;
 242         }
 243
 244         /* Check for trailing `/'. */
 245         if (start && !path[i]) {
 246         zero_last:
 247             path[--i] = '\0';
 248             break;
 249         }
 250
 251         /* Check for `../', `./' or trailing `.' by itself. */
 252         if (path[i] == '.') {
 253             /* Handle trailing `.' by itself. */
 254             if (!path[i + 1])
 255                 goto zero_last;
 256
 257             /* Handle `./'. */
 258             if (path[i + 1] == PATH_SEP) {
 259                 strcpy (path + i, path + i + 1);
 260                 i = start;
 261                 continue;
 262             }
 263
 264             /* Handle `../' or trailing `..' by itself.
 265                Remove the previous ?/ part with the exception of
 266                ../, which we should leave intact. */
 267             if (path[i + 1] == '.' && (path[i + 2] == PATH_SEP || !path[i + 2])) {
 268                 while (--start > -1 && path[start] != PATH_SEP);
 269                 if (!strncmp (path + start + 1, "../", 3))
 270                     continue;
 271                 strcpy (path + start + 1, path + i + 2);
 272                 i = start;
 273                 continue;
 274             }
 275         }
 276     }
 277
 278     if (!*path) {
 279         *path = stub_char;
 280         path[1] = '\0';
 281     }
 282     return path;
 283 }
 284
 285 #ifndef USE_VFS
 286 /*
 287    int mc_rmdir (char *path);
 288    Fix for Win95 UGLY BUG in rmdir: it will return ENOACCESS instead
 289    of ENOTEMPTY.
 290  */
 291 int mc_rmdir (char *path)
 292 {
 293     if (win32_GetPlatform() == OS_Win95) {
 294                 if (rmdir(path)) {
 295                         SetLastError (ERROR_DIR_NOT_EMPTY);
 296 #ifndef __EMX__
 297                         /* FIXME: We are always saying the same thing! */
 298                         _doserrno = ERROR_DIR_NOT_EMPTY;
 299 #endif
 300                         errno = ENOTEMPTY;
 301                         return -1;
 302                 } else
 303                         return 0;
 304     }
 305     else
 306                 return rmdir(path);             /* No trouble in Windows NT */
 307 }
 308
 309 static int conv_nt_unx_rc(int rc)
 310 {
 311    int errCode;
 312    switch (rc) {
 313       case ERROR_FILE_NOT_FOUND:
 314       case ERROR_PATH_NOT_FOUND:
 315       case ERROR_TOO_MANY_OPEN_FILES:
 316          errCode = ENOENT;
 317          break;
 318       case ERROR_INVALID_HANDLE:
 319       case ERROR_ARENA_TRASHED:
 320       case ERROR_ACCESS_DENIED:
 321           case ERROR_INVALID_ACCESS:
 322           case ERROR_WRITE_PROTECT:
 323           case ERROR_WRITE_FAULT:
 324       case ERROR_READ_FAULT:
 325           case ERROR_SHARING_VIOLATION:
 326              errCode = EACCES;
 327          break;
 328       case ERROR_NOT_ENOUGH_MEMORY:
 329                   errCode = ENOMEM;
 330                   break;
 331       case ERROR_INVALID_BLOCK:
 332           case ERROR_INVALID_FUNCTION:
 333           case ERROR_INVALID_DRIVE:
 334                   errCode = ENODEV;
 335                   break;
 336           case ERROR_CURRENT_DIRECTORY:
 337                   errCode = ENOTDIR;
 338                   break;
 339           case ERROR_NOT_READY:
 340          errCode = EINVAL;
 341          break;
 342       default:
 343          errCode = EINVAL;
 344         break;
 345    } /* endswitch */
 346    return errCode;
 347 }
 348
 349 /*
 350    int mc_unlink (char *pathName)
 351    For Windows 95 and NT, files should be able to be deleted even
 352    if they don't have write-protection. We should build a question box
 353    like: Delete anyway? Yes <No> All
 354 */
 355 int mc_unlink (char *pathName)
 356 {
 357         char            *fileName;
 358         char            *trunced_name;
 359         static int  erase_all = 0;
 360         BOOL        rc;
 361         DWORD       returnError;
 362
 363         rc = DeleteFile(pathName);
 364         returnError = GetLastError();
 365         if ((rc == FALSE) && (returnError == ERROR_ACCESS_DENIED)) {
 366                 int result;
 367                 if (!erase_all) {
 368                         errno = conv_nt_unx_rc(returnError);
 369                         trunced_name = name_trunc(pathName, 30);
 370                         fileName = (char *) malloc(strlen(trunced_name) + 16);
 371                         strcpy(fileName, "File ");
 372                         strcat(fileName, trunced_name);
 373                         strcat(fileName, " protected");
 374                     result = query_dialog(fileName, "Delete anyway?", 3, 3, " No ", " Yes ", " All in the future!");
 375                         free(fileName);
 376
 377                     switch (result) {
 378                     case 0:
 379                            do_refresh ();
 380                            return -1;
 381                     case 1:
 382                        do_refresh ();
 383                            break;
 384                     case 2:
 385                            do_refresh ();
 386                            erase_all = 1;
 387                            break;
 388                     default:
 389                            do_refresh ();
 390                            return -1;
 391                            break;
 392                    }
 393                 }
 394
 395                 chmod(pathName, S_IWRITE); /* make it writable */
 396                 rc = DeleteFile(pathName);
 397                 returnError = GetLastError();
 398                 if (rc == FALSE) {
 399                         errno = conv_nt_unx_rc(returnError);
 400                         return -1;
 401                 }
 402         }
 403         if (rc == TRUE) return 0;
 404         else
 405                 return -1;
 406 }
 407 #endif /*USE_VFS*/
 408
 409 void my_statfs (struct my_statfs *myfs_stats, char *path)
 410 {
 411     int len = 0;
 412     DWORD lpSectorsPerCluster, lpBytesPerSector, lpFreeClusters, lpClusters;
 413        DWORD           lpMaximumComponentLength, lpFileSystemFlags;
 414        static char     lpVolumeNameBuffer[256], lpFileSystemNameBuffer[30];
 415
 416        GetDiskFreeSpace(NULL, &lpSectorsPerCluster, &lpBytesPerSector,
 417                         &lpFreeClusters, &lpClusters);
 418
 419        /* KBytes available */
 420        myfs_stats->avail = lpSectorsPerCluster * lpBytesPerSector * lpFreeClusters / 1024;
 421
 422        /* KBytes total */
 423        myfs_stats->total = lpSectorsPerCluster * lpBytesPerSector * lpClusters / 1024;
 424        myfs_stats->nfree = lpFreeClusters;
 425        myfs_stats->nodes = lpClusters;
 426
 427        GetVolumeInformation(NULL, lpVolumeNameBuffer, 255, NULL,
 428                             &lpMaximumComponentLength, &lpFileSystemFlags,
 429                             lpFileSystemNameBuffer, 30);
 430
 431        myfs_stats->mpoint = lpFileSystemNameBuffer;
 432        myfs_stats->device = lpVolumeNameBuffer;
 433
 434
 435        myfs_stats->type = GetDriveType(NULL);
 436        switch (myfs_stats->type) {
 437            /*
 438             * mmm. DeviceIoControl may fail if you are not root case
 439             * F5_1Pt2_512,            5.25", 1.2MB,  512 bytes/sector
 440             * myfs_stats->typename = "5.25\" 1.2MB"; break; case
 441             * F3_1Pt44_512,           3.5",  1.44MB, 512 bytes/sector
 442             * myfs_stats->typename = "3.5\" 1.44MB"; break; case
 443             * F3_2Pt88_512,           3.5",  2.88MB, 512 bytes/sector
 444             * myfs_stats->typename = "3.5\" 2.88MB"; break; case
 445             * F3_20Pt8_512,           3.5",  20.8MB, 512 bytes/sector
 446             * myfs_stats->typename = "3.5\" 20.8MB"; break; case
 447             * F3_720_512,             3.5",  720KB,  512 bytes/sector
 448             * myfs_stats->typename = "3.5\" 720MB"; break; case
 449             * F5_360_512,             5.25", 360KB,  512 bytes/sector
 450             * myfs_stats->typename = "5.25\" 360KB"; break; case
 451             * F5_320_512,             5.25", 320KB,  512 bytes/sector
 452             * case F5_320_1024,       5.25", 320KB,  1024
 453             * bytes/sector myfs_stats->typename = "5.25\" 320KB"; break;
 454             * case F5_180_512,        5.25", 180KB,  512
 455             * bytes/sector myfs_stats->typename = "5.25\" 180KB"; break;
 456             * case F5_160_512,        5.25", 160KB,  512
 457             * bytes/sector myfs_stats->typename = "5.25\" 160KB"; break;
 458             * case RemovableMedia,    Removable media other than
 459             * floppy myfs_stats->typename = "Removable"; break; case
 460             * FixedMedia              Fixed hard disk media
 461             * myfs_stats->typename = "Hard Disk"; break; case Unknown:
 462             * Format is unknown
 463             */
 464        case DRIVE_REMOVABLE:
 465                myfs_stats->typename = "Removable";
 466                break;
 467        case DRIVE_FIXED:
 468                myfs_stats->typename = "Hard Disk";
 469                break;
 470        case DRIVE_REMOTE:
 471                myfs_stats->typename = "Networked";
 472                break;
 473        case DRIVE_CDROM:
 474                myfs_stats->typename = "CD-ROM";
 475                break;
 476        case DRIVE_RAMDISK:
 477                myfs_stats->typename = "RAM disk";
 478                break;
 479        default:
 480                myfs_stats->typename = "unknown";
 481                break;
 482        };
 483 }
 484
 485 int gettimeofday (struct timeval* tvp, void *p)
 486 {
 487     if (p != NULL)
 488         return 0;
 489
 490  /* Since MC only calls this func from get_random_hint we return
 491     some value, not exactly the "correct" one */
 492     tvp->tv_sec = GetTickCount()/1000;  /* Number of milliseconds since Windows started*/
 493     tvp->tv_usec = GetTickCount();
 494 }
 495
 496 /* FAKE functions */
 497
 498 int
 499 look_for_exe(const char* pathname)
 500 {
 501    int j;
 502    char *p;
 503    int lgh = strlen(pathname);
 504
 505    if (lgh < 4) {
 506       return 0;
 507    } else {
 508       p = (char *) pathname;
 509       for (j=0; j<lgh-4; j++) {
 510          p++;
 511       } /* endfor */
 512       if (!stricmp(p, ".exe") ||
 513           !stricmp(p, ".bat") ||
 514           !stricmp(p, ".com") ||
 515           !stricmp(p, ".cmd")) {
 516          return 1;
 517       }
 518    }
 519    return 0;
 520 }
 521
 522 int
 523 lstat (const char* pathname, struct stat *buffer)
 524 {
 525    int rc = stat (pathname, buffer);
 526 #ifdef __BORLANDC__
 527    if (rc == 0) {
 528      if (!(buffer->st_mode & S_IFDIR)) {
 529         if (!look_for_exe(pathname)) {
 530            buffer->st_mode &= !S_IXUSR & !S_IXGRP & !S_IXOTH;
 531         }
 532      }
 533    }
 534 #endif
 535    return rc;
 536 }
 537
 538 int getuid ()
 539 {
 540 /*    SID sid;
 541     LookupAccountName (NULL, &sid...
 542     return 0;
 543 */
 544     return 0;
 545 }
 546
 547 int getgid ()
 548 {
 549     return 0;
 550 }
 551
 552 int readlink (char* path, char* buf, int size)
 553 {
 554     return -1;
 555 }
 556 int symlink (char *n1, char *n2)
 557 {
 558     return -1;
 559 }
 560 int link (char *p1, char *p2)
 561 {
 562     return -1;
 563 }
 564 int chown (char *path, int owner, int group)
 565 {
 566     return -1;
 567 }
 568 int mknod (char *path, int mode, int dev)
 569 {
 570     return -1;
 571 }
 572
 573 void init_uid_gid_cache (void)
 574 {
 575     return;
 576 }
 577
 578 /* INHANDLE is a result of some mc_open call to any vfs, this function
 579    returns a normal handle (to be used with read) of a pipe for reading
 580    of the output of COMMAND with arguments ... (must include argv[0] as
 581    well) which gets as its input at most INLEN bytes from the INHANDLE
 582    using mc_read. You have to call mc_doublepclose to close the returned
 583    handle afterwards. If INLEN is -1, we read as much as we can :) */
 584 int mc_doublepopen (int inhandle, int inlen, pid_t *the_pid, char *command, ...)
 585 {
 586     int pipe0 [2], pipe1 [2], std_sav [2];
 587 #define MAXARGS 16
 588         int argno;
 589         char *args[MAXARGS];
 590         char buffer [8192];
 591         int i;
 592         va_list ap;
 593
 594     pid_t pid;
 595
 596         // Create the pipes
 597         if(_pipe(pipe0, 8192, O_BINARY | O_NOINHERIT) == -1)
 598             exit (1);
 599         if(_pipe(pipe1, 8192, O_BINARY | O_NOINHERIT) == -1)
 600             exit (1);
 601         // Duplicate stdin/stdout handles (next line will close original)
 602         std_sav[0] = _dup(_fileno(stdin));
 603         std_sav[1] = _dup(_fileno(stdout));
 604         // Duplicate read end of pipe0 to stdin handle
 605         if(_dup2(pipe0[0], _fileno(stdin)) != 0)
 606             exit (1);
 607         // Duplicate write end of pipe1 to stdout handle
 608         if(_dup2(pipe1[1], _fileno(stdout)) != 0)
 609             exit (1);
 610         // Close original read end of pipe0
 611         close(pipe0[0]);
 612         // Close original write end of pipe1
 613         close(pipe1[1]);
 614
 615         va_start (ap, command);
 616         argno = 0;
 617         while ((args[argno++] = va_arg(ap, char *)) != NULL)
 618                 if (argno == (MAXARGS - 1)) {
 619                 args[argno] = NULL;
 620                 break;
 621         }
 622         va_end (ap);
 623         // Spawn process
 624         pid = spawnvp(P_NOWAIT,command, args);// argv[1], (const char* const*)&argv[1]);
 625         if(!pid)
 626             exit (1);
 627         // Duplicate copy of original stdin back into stdin
 628         if(_dup2(std_sav[0], _fileno(stdin)) != 0)
 629             exit (1);
 630         // Duplicate copy of original stdout back into stdout
 631         if(_dup2(std_sav[1], _fileno(stdout)) != 0)
 632             exit (1);
 633         // Close duplicate copy of original stdout  and stdin
 634         close(std_sav[0]);
 635         close(std_sav[1]);
 636
 637
 638         while ((i = _read (inhandle, buffer,
 639                                                          (inlen == -1 || inlen > 8192)
 640                                                          ? 8192 : inlen)) > 0) {
 641                 write (pipe0 [1], buffer, i);
 642                 if (inlen != -1) {
 643                         inlen -= i;
 644                         if (!inlen)
 645                                 break;
 646                 }
 647         }
 648         close (pipe0 [1]);
 649         *the_pid = pid;
 650     return pipe1 [0];
 651
 652 }
 653
 654 int mc_doublepclose (int pipe, pid_t pid)
 655 {
 656     int status = 0;
 657
 658     close (pipe);
 659     _cwait ( &status, pid, 0);
 660     return status;
 661 }
 662
 663 /*hacks to get it compile, remove these after vfs works */
 664
 665 /*hacks to get it compile, remove these after vfs works */
 666 #ifndef USE_VFS
 667 char *vfs_get_current_dir (void)
 668 {
 669         return NULL;
 670 }
 671
 672 int vfs_current_is_extfs (void)
 673 {
 674         return 0;
 675 }
 676
 677 int vfs_file_is_ftp (char *filename)
 678 {
 679         return 0;
 680 }
 681
 682 int mc_utime (char *path, void *times)
 683 {
 684         return 0;
 685 }
 686
 687
 688 void extfs_run (char *file)
 689 {
 690         return;
 691 }
 692 #endif
 693
 694 char *
 695 get_default_editor (void)
 696 {
 697    return "notepad.exe";
 698 }
 699
 700 int
 701 errno_dir_not_empty (int err)
 702 {
 703     if (err == ENOTEMPTY || err == EEXIST || err == EACCES)
 704       return 1;
 705     return 0;
 706 }
 707
 708 /* The MC library directory is by default the directory where mc.exe
 709    is situated. It is possible to specify this directory via MCHOME
 710    environment variable */
 711 char *
 712 get_mc_lib_dir ()
 713 {
 714     char *cur;
 715     char *mchome = getenv("MCHOME");
 716
 717     if (mchome && *mchome)
 718         return mchome;
 719     mchome = malloc(MC_MAXPATHLEN);
 720     GetModuleFileName(NULL, mchome, MC_MAXPATHLEN);
 721     for (cur = mchome + strlen(mchome); \
 722         (cur > mchome) && (*cur != PATH_SEP); cur--);
 723     *cur = 0;
 724     cur = strdup(mchome);
 725     free(mchome);
 726     if (!cur || !*cur) {
 727         free(cur);
 728         return "C:\\MC";
 729     }
 730     return cur;
 731 }
 732 int get_user_rights (struct stat *buf)
 733 {
 734     return 2;
 735 }
 736 void init_groups (void)
 737 {
 738 }
 739 void delete_groups (void)
 740 {
 741 }