/* Copyright (C) 2003-2015 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include "lnxprefix.h"

#include "osspec.h"

#include "globdefs.h"

#include "filedefs.h"

#include "objdefs.h"

#include "parsedef.h"

#include "mcio.h"

#include "system.h"

#include "foundation.h"

#include "object.h"

#include "stack.h"

#include "card.h"

#include "mcerror.h"

//#include "param.h"

#include "handler.h"

#include "util.h"

#include "globals.h"

//#include "ports.cpp"

#include "socket.h"

//#include "mcssl.h"

//#include "securemode.h"

#include "mode.h"

#include "player.h"

#include "text.h"

#include "variable.h"

#include <sys/utsname.h>

#include <sys/ioctl.h>

#include <sys/mman.h>

#include <sys/dir.h>

#include <sys/wait.h>

#include <sys/time.h>

#include <sys/statvfs.h>

#include <dlfcn.h>

#include <termios.h>

//#include <langinfo.h>

#include <locale.h>

#include <pwd.h>

#include <fcntl.h>

// SN-2014-12-17: [[ Bug 14220 ]] Server should not wait put rather poll

#include <poll.h>

#include <libgnome/gnome-url.h>

#include <libgnome/gnome-program.h>

#include <libgnome/gnome-init.h>

#include <libgnomevfs/gnome-vfs.h>

#include <libgnomevfs/gnome-vfs-utils.h>

#include <libgnomevfs/gnome-vfs-mime.h>

#include <libgnomevfs/gnome-vfs-mime-handlers.h>

#include <gtk/gtk.h>

////////////////////////////////////////////////////////////////////////////////

// This is in here so we do not need GLIBC2.4

extern "C" void __attribute__ ((noreturn)) __stack_chk_fail (void)

{

abort();

}

////////////////////////////////////////////////////////////////////////////////

// MW-2005-02-22: Make global for now so opensslsocket.cpp can access it

real8 curtime;

static Boolean alarmpending;

// MW-2013-10-08: [[ Bug 11259 ]] We use our own tables on linux since

// we use a fixed locale which isn't available on all systems.

#if !defined(_LINUX_SERVER) && !defined(_LINUX_DESKTOP)

uint1 *MClowercasingtable = NULL;

uint1 *MCuppercasingtable = NULL;

#endif

//

////////////////////////////////////////////////////////////////////////////////

static void parseSerialControlStr(char *setting, struct termios *theTermios)

{

int baud = 0;

char *type = setting;

char *value = NULL;

if ((value = strchr(type, '=')) != NULL)

{

*value++ = '\0';

if (MCU_strncasecmp(type, "baud", strlen(type)) == 0)

{

long baudrate = strtol(value, NULL, 10);

if (baudrate == 57600)

baud = B57600;

else if (baudrate == 38400)

baud = B38400;

else if (baudrate == 19200)

baud = B19200;

else if (baudrate == 9600)

baud = B9600;

else if (baudrate == 4800)

baud = B4800;

else if (baudrate == 3600)

baud = B4800;

else if (baudrate == 2400)

baud = B2400;

else if (baudrate == 1800)

baud = B1800;

else if (baudrate == 1200)

baud = B1200;

else if (baudrate == 600)

baud = B600;

else if (baudrate == 300)

baud = B300;

cfsetispeed(theTermios, baud);

cfsetospeed(theTermios, baud);

}

else if (MCU_strncasecmp(type, "parity", strlen(type)) == 0)

{

if (value[0] == 'N' || value[0] == 'n')

theTermios->c_cflag &= ~(PARENB | PARODD);

else if (value[0] == 'O' || value[0] == 'o')

theTermios->c_cflag |= PARENB | PARODD;

else if (value[0] == 'E' || value[0] == 'e')

theTermios->c_cflag |= PARENB;

}

else if (MCU_strncasecmp(type, "data", strlen(type)) == 0)

{

short data = atoi(value);

switch (data)

{

case 5:

theTermios->c_cflag |= CS5;

break;

case 6:

theTermios->c_cflag |= CS6;

break;

case 7:

theTermios->c_cflag |= CS7;

break;

case 8:

theTermios->c_cflag |= CS8;

break;

}

}

else if (MCU_strncasecmp(type, "stop", strlen(type)) == 0)

{

double stopbit = strtol(value, NULL, 10);

if (stopbit == 1.0)

theTermios->c_cflag &= ~CSTOPB;

else if (stopbit == 1.5)

theTermios->c_cflag &= ~CSTOPB;

else if (stopbit == 2.0)

theTermios->c_cflag |= CSTOPB;

}

}

}

static void configureSerialPort(int sRefNum)

{/****************************************************************************

*parse MCserialcontrolstring and set the serial output port to the settings*

*defined by MCserialcontrolstring accordingly *

****************************************************************************/

//initialize to the default setting

struct termios theTermios;

if (tcgetattr(sRefNum, &theTermios) < 0)

{

MCLog("Error getting terminous attributes", nil);

}

cfsetispeed(&theTermios, B9600);

theTermios.c_cflag = CS8;

MCAutoStringRefAsSysString t_serial_settings;

/* UNCHECKED */ t_serial_settings.Lock(MCserialcontrolsettings);

char *controlptr = strclone(*t_serial_settings);

char *str = controlptr;

char *each = NULL;

while ((each = strchr(str, ' ')) != NULL)

{

*each = '\0';

each++;

parseSerialControlStr(str, &theTermios);

str = each;

}

//configure the serial output device

parseSerialControlStr(str,&theTermios);

if (tcsetattr(sRefNum, TCSANOW, &theTermios) < 0)

{

MCLog("Error setting terminous attributes", nil);

}

delete[] controlptr;

return;

}

////////////////////////////////////////////////////////////////////////////////

static IO_stat MCS_lnx_shellread(int fd, char *&buffer, uint4 &buffersize, uint4 &size)

{

MCshellfd = fd;

size = 0;

while (True)

{

int readsize = 0;

ioctl(fd, FIONREAD, (char *)&readsize);

readsize += READ_PIPE_SIZE;

if (size + readsize > buffersize)

{

if (!MCMemoryResizeArray(buffersize + readsize + 1,

buffer, buffersize))

return IO_ERROR;

}

errno = 0;

int4 amount = read(fd, &buffer[size], readsize);

if (amount <= 0)

{

if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)

break;

MCU_play();

// SN-2014-12-17: [[ Bug 14220 ]] The server wasn't waiting pre-7.0

#ifdef _SERVER

pollfd t_poll_fd;

t_poll_fd . fd = fd;

t_poll_fd . events = POLLIN;

t_poll_fd . revents = 0;

// SN-2015-02-12: [[ Bug 14441 ]] poll might as well get signal interrupted

// and we don't want to miss the reading for that only reason.

int t_result;

do

{

t_result = poll(&t_poll_fd, 1, -1);

}

while (t_result != 1 ||

(errno != EAGAIN && errno != EINTR && errno != EWOULDBLOCK));

// SN-2015-02-26: [[ CID 37859 ]] Dead code removed (t_result is

// always different from -1 here

#else

if (MCscreen->wait(READ_INTERVAL, False, True))

{

MCshellfd = -1;

return IO_ERROR;

}

#endif

}

else

size += amount;

}

MCshellfd = -1;

return IO_NORMAL;

}

////////////////////////////////////////////////////////////////////////////////

static Boolean MCS_lnx_nodelay(int4 fd)

{

return fcntl(fd, F_SETFL, (fcntl(fd, F_GETFL, 0) & O_APPEND) | O_NONBLOCK)

>= 0;

}

////////////////////////////////////////////////////////////////////////////////

bool MCS_lnx_is_link(MCStringRef p_path)

{

MCAutoStringRefAsSysString t_path;

/* UNCHECKED */ t_path.Lock(p_path);

struct stat64 buf;

return (lstat64(*t_path, &buf) == 0 && S_ISLNK(buf.st_mode));

}

bool MCS_lnx_readlink(MCStringRef p_path, MCStringRef& r_link)

{

struct stat64 t_stat;

ssize_t t_size;

MCAutoArray<char> t_buffer;

MCAutoStringRefAsSysString t_path;

/* UNCHECKED */ t_path.Lock(p_path);

if (lstat64(*t_path, &t_stat) == -1 ||

// SN-2014-09-02: [[ Bug 13323 ]] The size needs be 1 bigger to allow

// a final NIL-byte.

!t_buffer.New(t_stat.st_size + 1))

return false;

t_size = readlink(*t_path, (char*)t_buffer.Ptr(), t_stat.st_size);

if (t_size != t_stat.st_size)

return false;

return MCStringCreateWithSysString(t_buffer.Ptr(), r_link);

}

////////////////////////////////////////////////////////////////////////////////

// REFACTORED FROM lnxmisc.cpp

#include <iconv.h>

struct ConverterRecord

{

ConverterRecord *next;

const char *encoding;

iconv_t converter;

};

static iconv_t fetch_converter(const char *p_encoding)

{

static ConverterRecord *s_records = NULL;

ConverterRecord *t_previous, *t_current;

for(t_previous = NULL, t_current = s_records; t_current != NULL; t_previous = t_current, t_current = t_current -> next)

if (t_current -> encoding == p_encoding)

break;

if (t_current == NULL)

{

// SN-2015-11-19: [[ Bug 16450 ]] Ask for UTF-16LE to avoid iconv to put

// a BOM char at the start of the stream

iconv_t t_converter;

t_converter = iconv_open("UTF-16LE", p_encoding);

ConverterRecord *t_record;

t_record = new ConverterRecord;

t_record -> next = s_records;

t_record -> encoding = p_encoding;

t_record -> converter = t_converter;

s_records = t_record;

return t_record -> converter;

}

if (t_previous != NULL)

{

t_previous -> next = t_current -> next;

t_current -> next = s_records;

s_records = t_current;

}

return s_records -> converter;

}

////////////////////////////////////////////////////////////////////////////////

#define DNS_SCRIPT "repeat for each line l in url \"binfile:/etc/resolv.conf\";\

if word 1 of l is \"nameserver\" then put word 2 of l & cr after it; end repeat;\

delete last char of it; return it"

#define LAUNCH_URL_SCRIPT "put \"%@\" into tFilename; " \

"put empty into tCmd; " \

"if tCmd is empty and shell(\"which xdg-open\") is not empty then; " \

" put \"xdg-open\" into tCmd; "\

"end if; " \

"if tCmd is empty and $GNOME_DESKTOP_SESSION_ID is not empty and shell(\"which gnome-open\") is not empty then; " \

" put \"gnome-open\" into tCmd; " \

"end if; " \

"if tCmd is empty and $KDE_FULL_SESSION is not empty then; " \

" if shell(\"which kde-open\") is not empty then; " \

" put \"kde-open\" into tCmd; " \

" else if shell(\"which kfmclient\") is not empty then; " \

" put \"kfmclient exec\" into tCmd; " \

" end if; " \

"end if; " \

"if tCmd is not empty then; " \

" launch tFilename with tCmd; " \

"else; " \

" return \"not supported\"; " \

"end if;"

////////////////////////////////////////////////////////////////////////////////

#ifdef NOATON

int inet_aton(const char *cp, struct in_addr *inp)

{

unsigned long rv = inet_addr(cp);

//fprintf(stderr, "%d\n", rv);

if (rv == -1)

return False;

memcpy(inp, &rv, sizeof(unsigned long));

return True;

}

#endif

// TS-2008-03-03 : Make this global so that MCS_checkprocesses () can look at it

// and figure out if one of its children have already been waited on in the

// SIGCHLD handler.

pid_t waitedpid;

static void handle_signal(int sig)

{

MCHandler handler(HT_MESSAGE);

switch (sig)

{

case SIGUSR1:

MCsiguser1++;

break;

case SIGUSR2:

MCsiguser2++;

break;

case SIGTERM:

switch (MCdefaultstackptr->getcard()->message(MCM_shut_down_request))

{

case ES_NORMAL:

return;

case ES_NOT_HANDLED:

if (handler.getpass())

{

MCdefaultstackptr->getcard()->message(MCM_shut_down);

MCquit = True; //set MC quit flag, to invoke quitting

return;

}

default:

break;

}

case SIGILL:

case SIGBUS:

case SIGSEGV:

{

MCAutoStringRefAsSysString t_cmd;

/* UNCHECKED */ t_cmd.Lock(MCcmd);

fprintf(stderr, "%s exiting on signal %d\n", *t_cmd, sig);

MCS_killall();

exit(-1);

}

case SIGHUP:

case SIGINT:

case SIGQUIT:

case SIGIOT:

fprintf(stderr,"\n\nGot SIGIOT\n");

if (MCnoui)

exit(1);

MCabortscript = True;

break;

case SIGFPE:

errno = EDOM;

break;

case SIGCHLD:

{

#if defined(_LINUX_DESKTOP)

MCPlayerHandle t_player = MCplayers;

// If we have some players waiting then deal with these first

waitedpid = -1;

if (t_player.IsValid())

{

waitedpid = wait(NULL);

// Moving these two lines half fixes bug 5966 - however it still isn't quite right

// as there will still be some interaction between a player and shell command

while(t_player.IsValid())

{

if (t_player.IsValid() && waitedpid == t_player->getpid())

{

if (t_player->isdisposable())

t_player->playstop();

else

MCscreen->delaymessage(t_player, MCM_play_stopped, NULL, NULL);

t_player->shutdown();

break;

}

t_player = t_player -> getnextplayer() ;

}

}

else

{

// Check to see if we have created a video window. If we have got to here it means

// that we could not start mplayer -- so the child thread has exited, but the player

// object has not had a chance to be created yet. TODO - investigate if there is a

// cleaner way of dealing with this situation.

if ( MClastvideowindow != DNULL )

{

gdk_window_hide(MClastvideowindow);

gdk_window_destroy(MClastvideowindow);

MClastvideowindow = DNULL ;

}

else

{

MCS_checkprocesses();

}

}

#endif /* LINUX_DESKTOP */

}

break;

case SIGALRM:

MCalarm = True;

#ifdef NOITIMERS

alarm(1);

#endif

break;

case SIGPIPE:

default:

break;

}

return;

}

////////////////////////////////////////////////////////////////////////////////

bool MCS_generate_uuid(char p_buffer[128])

{

typedef void (*uuid_generate_ptr)(unsigned char uuid[16]);

typedef void (*uuid_unparse_ptr)(unsigned char uuid[16], char *out);

static void *s_uuid_generate = NULL, *s_uuid_unparse = NULL;

if (s_uuid_generate == NULL && s_uuid_unparse == NULL)

{

void *t_libuuid;

t_libuuid = dlopen("libuuid.so", RTLD_LAZY);

if (t_libuuid == NULL)

t_libuuid = dlopen("libuuid.so.1", RTLD_LAZY);

if (t_libuuid != NULL)

{

s_uuid_generate = dlsym(t_libuuid, "uuid_generate");

s_uuid_unparse = dlsym(t_libuuid, "uuid_unparse");

}

}

if (s_uuid_generate != NULL && s_uuid_unparse != NULL)

{

unsigned char t_uuid[16];

((uuid_generate_ptr)s_uuid_generate)(t_uuid);

((uuid_unparse_ptr)s_uuid_unparse)(t_uuid, p_buffer);

return true;

}

return false;

}

////////////////////////////////////////////////////////////////////////////////

class MCStdioFileHandle: public MCSystemFileHandle

{

public:

MCStdioFileHandle(FILE* p_fptr)

{

m_fptr = p_fptr;

m_is_eof = false;

}

virtual void Close(void)

{

if (m_fptr != NULL)

fclose(m_fptr);

delete this;

}

// Returns true if an attempt has been made to read past the end of the

// stream.

virtual bool IsExhausted(void)

{

return feof(m_fptr);

}

virtual bool Read(void *p_buffer, uint32_t p_length, uint32_t& r_read)

{

if (MCabortscript || p_buffer == NULL)

return false;

char *sptr = (char *)p_buffer;

uint4 nread;

uint4 toread = p_length;

uint4 offset = 0;

errno = 0;

while ((nread = fread(&sptr[offset], 1, toread, m_fptr)) != toread)

{

offset += nread;

r_read = offset;

if (ferror(m_fptr))

{

clearerr(m_fptr);

if (errno == EAGAIN)

return true;

if (errno == EINTR)

{

toread -= nread;

continue;

}

}

return false;

}

r_read = offset + nread;

return true;

}

virtual bool Write(const void *p_buffer, uint32_t p_length)

{

if (fwrite(p_buffer, 1, p_length, m_fptr) != p_length)

return false;

return true;

}

virtual bool Seek(int64_t p_offset, int p_dir)

{

return fseeko64(m_fptr, p_offset, p_dir > 0 ? SEEK_SET : (p_dir < 0 ? SEEK_END : SEEK_CUR)) == 0;

}

virtual bool Truncate(void)

{

return ftruncate(fileno(m_fptr), ftell(m_fptr)) == 0;

}

virtual bool Sync(void)

{

if (m_fptr != NULL)

{

int64_t pos = ftello64(m_fptr);

if (fseeko64(m_fptr, pos, SEEK_SET) != 0)

return false;

}

return true;

}

virtual bool Flush(void)

{

if (fflush(m_fptr))

return false;

return true;

}

virtual bool PutBack(char p_char)

{

if (ungetc(p_char, m_fptr) != p_char)

return false;

return true;

}

virtual int64_t Tell(void)

{

return ftello64(m_fptr);

}

virtual void *GetFilePointer(void)

{

return (void*)m_fptr;

}

virtual uint64_t GetFileSize(void)

{

struct stat64 buf;

int fd = fileno(m_fptr);

if (fstat64(fd, &buf))

return 0;

return buf.st_size;

}

virtual bool TakeBuffer(void*& r_buffer, size_t& r_length)

{

return false;

}

virtual FILE* GetStream(void)

{

return m_fptr;

}

private:

FILE *m_fptr;

bool m_is_eof;

};

////////////////////////////////////////////////////////////////////////////////

class MCLinuxDesktop: public MCSystemInterface

{

public:

virtual MCServiceInterface *QueryService(MCServiceType type)

{

// No Linux-specific services

return nil;

}

virtual bool Initialize(void)

{

IO_stdin = MCsystem -> OpenFd(0, kMCOpenFileModeRead);

IO_stdout = MCsystem -> OpenFd(1, kMCOpenFileModeWrite);

IO_stderr = MCsystem -> OpenFd(2, kMCOpenFileModeWrite);

// Internally, LiveCode assumes sorting orders etc are those of en_US.

// Additionally, the "native" string encoding for Linux is ISO-8859-1

// (even if the Linux system is using something different).

const char *t_internal_locale = "en_US.ISO-8859-1";

setlocale(LC_CTYPE, t_internal_locale);

setlocale(LC_COLLATE, t_internal_locale);

MCinfinity = HUGE_VAL;

struct sigaction action;

memset((char *)&action, 0, sizeof(action));

action.sa_handler = handle_signal;

action.sa_flags = SA_RESTART;

action.sa_flags |= SA_NOCLDSTOP;

sigaction(SIGCHLD, &action, NULL);

sigaction(SIGALRM, &action, NULL);

#ifndef _DEBUG

sigaction(SIGHUP, &action, NULL);

sigaction(SIGINT, &action, NULL);

sigaction(SIGQUIT, &action, NULL);

sigaction(SIGILL, &action, NULL);

sigaction(SIGIOT, &action, NULL);

sigaction(SIGFPE, &action, NULL);

sigaction(SIGBUS, &action, NULL);

sigaction(SIGSEGV, &action, NULL);

sigaction(SIGPIPE, &action, NULL);

sigaction(SIGTERM, &action, NULL);

sigaction(SIGUSR1, &action, NULL);

sigaction(SIGUSR2, &action, NULL);

#ifndef _LINUX

sigaction(SIGSYS, &action, NULL);

#endif

#endif

#ifndef _SERVER

// ST-2015-04-20: [[ Bug 15257 ]] Stdin shouldn't be set to

// non-blocking in server.

if (!IsInteractiveConsole(0))

MCS_lnx_nodelay(0);

#endif

// MW-2013-10-01: [[ Bug 11160 ]] At the moment NBSP is not considered a space.

MCctypetable[160] &= ~(1 << 4);

MCValueAssign(MCshellcmd, MCSTR("/bin/sh"));

return true;

}

virtual void Finalize(void)

{

}

virtual void Debug(MCStringRef p_string)

{

// TODO implement?

}

virtual real64_t GetCurrentTime(void)

{

struct timezone tz;

struct timeval tv;

gettimeofday(&tv, &tz);

curtime = tv.tv_sec + (real8)tv.tv_usec / 1000000.0;

return curtime;

}

virtual bool GetVersion(MCStringRef& r_string)

{

struct utsname u;

uname(&u);

MCAutoStringRef t_sysname, t_release;

/* UNCHECKED */ MCStringCreateWithSysString(u.sysname, &t_sysname);

/* UNCHECKED */ MCStringCreateWithSysString(u.release, &t_release);

return MCStringFormat(r_string, "%@ %@", *t_sysname, *t_release);

}

virtual bool GetMachine(MCStringRef& r_string)

{

struct utsname u;

uname(&u);

return MCStringCreateWithNativeChars((const char_t *)u.machine, MCCStringLength(u.machine), r_string);

}

virtual MCNameRef GetProcessor(void)

{

#if defined(__X86_64__)

return MCN_x86_64;

#elif defined(__ARM__)

return MCN_arm;

#elif defined(__I386__)

return MCN_x86;

#else

# error "One of __X86_64__, __ARM__ or __I386__ must be defined"

#endif

}

virtual bool GetAddress(MCStringRef& r_address)

{

struct utsname u;

uname(&u);

MCAutoStringRef t_nodename;

/* UNCHECKED */ MCStringCreateWithSysString(u.nodename, &t_nodename);

return MCStringFormat(r_address, "%@:%@", *t_nodename, MCcmd);

}

virtual uint32_t GetProcessId(void)

{

return getpid();

}

virtual void Alarm(real64_t p_when)

{

if (!MCnoui)

{

#ifdef NOITIMERS

if (p_when != 0.)

alarm(p_when + 1.0);

else

alarm(0);

#else

static real8 oldsecs;

if (p_when != oldsecs)

{

itimerval val;

val.it_interval.tv_sec = (long)p_when;

val.it_interval.tv_usec

= (long)((p_when - (double)(long)p_when) * 1000000.0);

val.it_value = val.it_interval;

setitimer(ITIMER_REAL, &val, NULL);

oldsecs = p_when;

}

#endif

if (p_when == 0.0)

alarmpending = False;

else

alarmpending = True;

}

}

virtual void Sleep(real64_t p_when)

{

Boolean wasalarm = alarmpending;

if (alarmpending)

MCS_alarm(0.0);

struct timeval timeoutval;

timeoutval.tv_sec = (long)p_when;

timeoutval.tv_usec = (long)((p_when - floor(p_when)) * 1000000.0);

select(0, NULL, NULL, NULL, &timeoutval);

if (wasalarm)

MCS_alarm(CHECK_INTERVAL);

}

virtual void SetEnv(MCStringRef p_name, MCStringRef p_value)

{

#ifdef NOSETENV

char *dptr = new char[strlen(p_name) + strlen(p_value) + 2];

sprintf(dptr, "%s=%s", p_name, p_value);

putenv(dptr);

#else

MCAutoStringRefAsSysString t_name, t_value;

/* UNCHECKED */ t_name.Lock(p_name);

if (p_value == nil)

unsetenv(*t_name);

else

{

/* UNCHECKED */ t_value.Lock(p_value);

setenv(*t_name, *t_value, True);

}

#endif

}

virtual bool GetEnv(MCStringRef p_name, MCStringRef& r_value)

{

MCAutoStringRefAsSysString t_name;

/* UNCHECKED */ t_name.Lock(p_name);

char *t_env_value = getenv(*t_name);

// We need to know whethere we actually got an environment variable

// or if it defaulted to an empty stringref because the env variable

// was unset

return t_env_value != nil && MCStringCreateWithSysString(t_env_value, r_value);

}

virtual Boolean CreateFolder(MCStringRef p_path)

{

MCAutoStringRefAsSysString t_path;

MCAutoStringRef t_resolved_path_string;

if (MCS_resolvepath(p_path, &t_resolved_path_string))

{

/* UNCHECKED */ t_path.Lock(*t_resolved_path_string);

return mkdir(*t_path, 0777) == 0;

}

return false;

}

virtual Boolean DeleteFolder(MCStringRef p_path)

{

MCAutoStringRefAsSysString t_path;

MCAutoStringRef t_resolved_path_string;

if (MCS_resolvepath(p_path, &t_resolved_path_string))

{

/* UNCHECKED */ t_path.Lock(*t_resolved_path_string);

return rmdir(*t_path) == 0;

}

return false;

}

virtual Boolean DeleteFile(MCStringRef p_path)

{

MCAutoStringRefAsSysString t_path;

MCAutoStringRef t_resolved_path;

MCS_resolvepath(p_path, &t_resolved_path);

/* UNCHECKED */ t_path.Lock(*t_resolved_path);

Boolean done = unlink(*t_path) == 0;

return done;

}

virtual Boolean RenameFileOrFolder(MCStringRef p_old_name, MCStringRef p_new_name)

{

MCAutoStringRef t_old_resolved_path, t_new_resolved_path;

MCS_resolvepath(p_old_name, &t_old_resolved_path);

MCS_resolvepath(p_new_name, &t_new_resolved_path);

Boolean done;

#ifndef NORENAME

MCAutoStringRefAsSysString t_from, t_to;

/* UNCHECKED */ t_from.Lock(*t_old_resolved_path);

/* UNCHECKED */ t_to.Lock(*t_new_resolved_path);

done = rename(*t_from, *t_to) == 0;

#else

// doesn't work on directories

MCAutoStringRefAsSysString t_from, t_to;

/* UNCHECKED */ t_from.Lock(*t_old_resovled_path);

/* UNCHECKED */ t_to.Lock(*t_new_resolved_path);

done = True;

if (link(*t_from, *t_to) != 0)

done = False;

else

if (unlink(*t_from) != 0)

{

unlink(*t_to);

done = False;

}

#endif

return done;

}

virtual Boolean BackupFile(MCStringRef p_old_name, MCStringRef p_new_name)

{

return MCS_rename(p_old_name, p_new_name);

}

virtual Boolean UnbackupFile(MCStringRef p_old_name, MCStringRef p_new_name)

{

return MCS_rename(p_old_name, p_new_name);

}

virtual Boolean CreateAlias(MCStringRef p_target, MCStringRef p_alias)

{

MCAutoStringRef t_target;

MCAutoStringRef t_alias;

/* UNCHECKED */ MCS_resolvepath(p_target, &t_target);

/* UNCHECKED */ MCS_resolvepath(p_alias, &t_alias);

MCAutoStringRefAsSysString t_target_sys, t_alias_sys;

/* UNCHECKED */ t_target_sys.Lock(*t_target);

/* UNCHECKED */ t_alias_sys.Lock(*t_alias);

return symlink(*t_target_sys, *t_alias_sys) == 0;

}

// NOTE: 'ResolveAlias' returns a standard (not native) path.

virtual Boolean ResolveAlias(MCStringRef p_target, MCStringRef& r_dest)

{

return MCS_resolvepath(p_target, r_dest);

}

virtual bool GetCurrentFolder(MCStringRef& r_path)

{

MCAutoArray<char> t_buffer;

if (!t_buffer.New(PATH_MAX + 1))

return false;

if (NULL == getcwd((char*)t_buffer.Ptr(), PATH_MAX + 1))

return false;