{

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;

}

}

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

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

{

MCshellfd = fd;

size = 0;

while (True)

{

int readsize = 0;

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

readsize += READ_PIPE_SIZE;

if (size + readsize > buffersize)

{

MCU_realloc((char **)&buffer, buffersize,

buffersize + readsize + 1, sizeof(char));

buffersize += readsize;

}

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;

{

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

>= 0;

{

#ifdef /* MCS_is_link_dsk_lnx */ LEGACY_SYSTEM_ORPHAN

struct stat64 buf;

return (lstat64(MCStringGetCString(p_path), &buf) == 0 && S_ISLNK(buf.st_mode));

#endif /* MCS_is_link_dsk_lnx */

MCAutoStringRefAsSysString t_path;

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

struct stat64 buf;

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

{

#ifdef /* MCS_readlink_dsk_lnx */ LEGACY_SYSTEM_ORPHAN

struct stat64 t_stat;

ssize_t t_size;

MCAutoNativeCharArray t_buffer;

if (lstat64(MCStringGetCString(p_path), &t_stat) == -1 ||

!t_buffer.New(t_stat.st_size))

return false;

t_size = readlink(MCStringGetCString(p_path), (char*)t_buffer.Chars(), t_stat.st_size);

return (t_size == t_stat.st_size) && t_buffer.CreateStringAndRelease(r_link);

#endif /* MCS_readlink_dsk_lnx */

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

{

ConverterRecord *next;

const char *encoding;

iconv_t converter;

{

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)

{

iconv_t t_converter;

t_converter = iconv_open("UTF-16", 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;

{

unsigned long rv = inet_addr(cp);

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

if (rv == -1)

return False;

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

return True;

{

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)

MCPlayer *tptr = MCplayers;

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

waitedpid = -1;

if ( tptr != NULL)

{

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(tptr != NULL)

{

if ( waitedpid == tptr -> getpid())

{

if (tptr->isdisposable())

tptr->playstop();

else

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

tptr->shutdown();

break;

}

tptr = tptr -> 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;

{

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;

{

MCStdioFileHandle(FILE* p_fptr)

{

m_fptr = p_fptr;

m_is_eof = false;

}

virtual void Close(void)

{

#ifdef /* MCS_close_dsk_lnx */ LEGACY_SYSTEM

if (stream->fptr == NULL)

{

if (stream->fd == 0)

{

if (!(stream->flags & IO_FAKE))

delete stream->buffer;

}

#ifndef NOMMAP

else

{

munmap((char *)stream->buffer, stream->len);

close(stream->fd);

}

#endif

}

else

fclose(stream->fptr);

delete stream;

stream = NULL;

return IO_NORMAL;

#endif /* MCS_close_dsk_lnx */

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)

{

#ifdef /* MCS_read_dsk_lnx */ LEGACY_SYSTEM

if (MCabortscript || ptr == NULL)

return IO_ERROR;

if ((stream -> flags & IO_FAKEWRITE) == IO_FAKEWRITE)

return IO_ERROR;

// MW-2009-06-25: If this is a custom stream, call the appropriate callback.

// MW-2009-06-30: Refactored to common (platform-independent) implementation

// in mcio.cpp

if ((stream -> flags & IO_FAKECUSTOM) == IO_FAKECUSTOM)

return MCS_fake_read(ptr, size, n, stream);

IO_stat stat = IO_NORMAL;

if (stream->fptr == NULL)

{

uint4 nread = size * n;

if (nread > stream->len - (stream->ioptr - stream->buffer))

{

n = (stream->len - (stream->ioptr - stream->buffer)) / size;

nread = (stream->len - (stream->ioptr - stream->buffer)) / size;

stat = IO_EOF;

}

if (nread == 1)

{

char *tptr = (char *)ptr;

*tptr = *stream->ioptr++;

}

else

{

memcpy(ptr, stream->ioptr, nread);

stream->ioptr += nread;

}

}

else

{

char *sptr = (char *)ptr;

uint4 nread;

uint4 toread = n * size;

uint4 offset = 0;

errno = 0;

while ((nread = fread(&sptr[offset], 1, toread, stream->fptr)) != toread)

{

offset += nread;

n = offset / size;

if (ferror(stream->fptr))

{

clearerr(stream->fptr);

if (errno == EAGAIN)

return IO_NORMAL;

if (errno == EINTR)

{

toread -= nread;

continue;

}

else

return IO_ERROR;

}

if (MCS_eof(stream))

{

return IO_EOF;

}

return IO_NONE;

}

}

return stat;

#endif /* MCS_read_dsk_lnx */

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)

{

#ifdef /* MCS_write_dsk_lnx */ LEGACY_SYSTEM

if ((stream -> flags & IO_FAKEWRITE) == IO_FAKEWRITE)

return MCU_dofakewrite(stream -> buffer, stream -> len, ptr, size, n);

if (fwrite(ptr, size, n, stream->fptr) != n)

return IO_ERROR;

return IO_NORMAL;

#endif /* MCS_write_dsk_lnx */

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)

{

#ifdef /* MCS_seek_cur_dsk_lnx */ LEGACY_SYSTEM

// MW-2009-06-25: If this is a custom stream, call the appropriate callback.

// MW-2009-06-30: Refactored to common implementation in mcio.cpp.

if ((stream -> flags & IO_FAKECUSTOM) == IO_FAKECUSTOM)

return MCS_fake_seek_cur(stream, offset);

if (stream->fptr == NULL)

IO_set_stream(stream, stream->ioptr + offset);

else

if (fseeko64(stream->fptr, offset, SEEK_CUR) != 0)

return IO_ERROR;

return IO_NORMAL;

#endif /* MCS_seek_cur_dsk_lnx */

#ifdef /* MCS_seek_set_dsk_lnx */ LEGACY_SYSTEM

// MW-2009-06-30: If this is a custom stream, call the appropriate callback.

if ((stream -> flags & IO_FAKECUSTOM) == IO_FAKECUSTOM)

return MCS_fake_seek_set(stream, offset);

if (stream->fptr == NULL)

IO_set_stream(stream, stream->buffer + offset);

else

if (fseeko64(stream->fptr, offset, SEEK_SET) != 0)

return IO_ERROR;

return IO_NORMAL;

#endif /* MCS_seek_set_dsk_lnx */

#ifdef /* MCS_seek_end_dsk_lnx */ LEGACY_SYSTEM

if (stream->fptr == NULL)

IO_set_stream(stream, stream->buffer + stream->len + offset);

else

if (fseeko64(stream->fptr, offset, SEEK_END) != 0)

return IO_ERROR;

return IO_NORMAL;

#endif /* MCS_seek_end_dsk_lnx */

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

}

virtual bool Truncate(void)

{

#ifdef /* MCS_trunc_dsk_lnx */ LEGACY_SYSTEM

if (ftruncate(fileno(stream->fptr), ftell(stream->fptr)))

return IO_ERROR;

return IO_NORMAL;

#endif /* MCS_trunc_dsk_lnx */

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

}

virtual bool Sync(void)

{

#ifdef /* MCS_sync_dsk_lnx */ LEGACY_SYSTEM

if (stream->fptr != NULL)

{

int64_t pos = ftello64(stream->fptr);

if (fseeko64(stream->fptr, pos, SEEK_SET) != 0)

return IO_ERROR;

}

return IO_NORMAL;

#endif /* MCS_sync_dsk_lnx */

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)

{

#ifdef /* MCS_flush_dsk_lnx */ LEGACY_SYSTEM

if (stream->fptr != NULL)

if (fflush(stream->fptr))

return IO_ERROR;

return IO_NORMAL;

#endif /* MCS_flush_dsk_lnx */

if (fflush(m_fptr))

return false;

return true;

}

virtual bool PutBack(char p_char)

{

#ifdef /* MCS_putback_dsk_lnx */ LEGACY_SYSTEM

if (stream -> fptr == NULL)

return MCS_seek_cur(stream, -1);

if (ungetc(c, stream -> fptr) != c)

return IO_ERROR;

return IO_NORMAL;

#endif /* MCS_putback_dsk_lnx */

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

return false;

return true;

}

virtual int64_t Tell(void)

{

#ifdef /* MCS_tell_dsk_lnx */ LEGACY_SYSTEM

// MW-2009-06-30: If this is a custom stream, call the appropriate callback.

if ((stream -> flags & IO_FAKECUSTOM) == IO_FAKECUSTOM)

return MCS_fake_tell(stream);

if (stream->fptr != NULL)

return ftello64(stream->fptr);

else

return stream->ioptr - stream->buffer;

#endif /* MCS_tell_dsk_lnx */

return ftello64(m_fptr);

}

virtual void *GetFilePointer(void)

{

return (void*)m_fptr;

}

virtual int64_t GetFileSize(void)

{

#ifdef /* MCS_fsize_dsk_lnx */ LEGACY_SYSTEM

if ((stream -> flags & IO_FAKECUSTOM) == IO_FAKECUSTOM)

return MCS_fake_fsize(stream);

struct stat64 buf;

if (stream->fptr == NULL)

return stream->len;

int fd = fileno(stream->fptr);

if (fstat64(fd, &buf))

return 0;

return buf.st_size;

#endif /* MCS_fsize_dsk_lnx */

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;

{

virtual MCServiceInterface *QueryService(MCServiceType type)

{

// No Linux-specific services

return nil;

}

virtual bool Initialize(void)

{

#ifdef /* MCS_init_dsk_lnx */ LEGACY_SYSTEM

IO_stdin = new IO_header(stdin, NULL, 0, 0, 0);

IO_stdout = new IO_header(stdout, NULL, 0, 0, 0);

IO_stderr = new IO_header(stderr, NULL, 0, 0, 0);

setlocale(LC_CTYPE, MCnullstring);

setlocale(LC_COLLATE, MCnullstring);

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

if (!MCS_isatty(0))

MCS_nodelay(0);

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

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

MCshellcmd = strclone("/bin/sh");

#endif /* MCS_init_dsk_lnx */

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