#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 "handler.h"

#include "util.h"

#include "globals.h"

#include "socket.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 <locale.h>

#include <pwd.h>

#include <fcntl.h>

#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>

#include <syslog.h>

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

{

abort();

}

real8 curtime;

static Boolean alarmpending;

#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);

switch(baudrate)

{

case 4000000: baud = B4000000; break;

case 3500000: baud = B3500000; break;

case 3000000: baud = B3000000; break;

case 2500000: baud = B2500000; break;

case 2000000: baud = B2000000; break;

case 1500000: baud = B1500000; break;

case 1152000: baud = B1152000; break;

case 1000000: baud = B1000000; break;

case 921600: baud = B921600; break;

case 576000: baud = B576000; break;

case 500000: baud = B500000; break;

case 460800: baud = B460800; break;

case 230400: baud = B230400; break;

case 115200: baud = B115200; break;

case 57600: baud = B57600; break;

case 38400: baud = B38400; break;

case 19200: baud = B19200; break;

case 9600: baud = B9600; break;

case 4800: baud = B4800; break;

case 2400: baud = B2400; break;

case 1800: baud = B1800; break;

case 1200: baud = B1200; break;

case 600: baud = B600; break;

case 300: baud = B300; break;

default:

baud = B9600;

break;

}

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)

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

//initialize to the default setting

struct termios theTermios;

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

{

MCLog("Error getting terminous attributes");

}

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");

}

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);

}

#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 (nothrow) 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\";\

#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

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;

}

class MCStdioFileHandle: public MCSystemFileHandle

{

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;

}

FILE *m_fptr;

bool m_is_eof;

};

class MCLinuxDesktop: public MCSystemInterface

{

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)

{

MCAutoStringRefAsSysString t_string;

if (t_string.Lock(p_string))

syslog(LOG_DEBUG, "%s", *t_string);

}

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 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 (nothrow) 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;

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

}

///* LEGACY */ char *GetCurrentFolder(void);

virtual Boolean SetCurrentFolder(MCStringRef p_path)

{

MCAutoStringRef t_new_path;

if (MCS_resolvepath(p_path, &t_new_path))

{

MCAutoStringRefAsSysString t_path_sys;

/* UNCHECKED */ t_path_sys.Lock(*t_new_path);

return chdir(*t_path_sys) == 0;

}

return false;

}

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

virtual Boolean GetStandardFolder(MCNameRef p_type, MCStringRef& r_folder)

{

MCAutoStringRef t_home, t_tilde;

if (!MCStringCreateWithCString("~", &t_tilde) ||

!MCS_resolvepath(*t_tilde, &t_home))

return false;

if (MCNameIsEqualToCaseless(p_type, MCN_desktop))

return MCStringFormat(r_folder, "%@/Desktop", *t_home);

else if (MCNameIsEqualToCaseless(p_type, MCN_home))

return MCStringCopy(*t_home, r_folder);

else if (MCNameIsEqualToCaseless(p_type, MCN_temporary))

return MCStringCreateWithCString("/tmp", r_folder);

// SN-2014-08-08: [[ Bug 13026 ]] Fix ported from 6.7