int diag_tty_break(struct diag_l0_device *dl0d, const int ms)
{
HANDLE hd;
long h;
/*
* I'm going through this convoluted two-step conversion
* to avoid compiler warnings:
*/
h = get_osfhandle(dl0d->fd);
hd = (HANDLE)h;
if (tcdrain(dl0d->fd)) {
fprintf(stderr, FLFMT "tcdrain returned %s.\n",
FL, strerror(errno));
return diag_iseterr(DIAG_ERR_GENERAL);
}
SetCommBreak(hd);
diag_os_millisleep(ms);
ClearCommBreak(hd);
return 0;
}
serial_source open_serial_source(const char *device, int baud_rate, int non_blocking, void (*message)(serial_source_msg problem))
/* Effects: opens serial port device at specified baud_rate. If non_blocking
is true, read_serial_packet calls will be non-blocking (writes are
always blocking, for now at least)
Returns: descriptor for serial forwarder at host:port, or
NULL for failure (bad device or bad baud rate)
*/
{
struct termios newtio;
int fd;
tcflag_t baudflag = parse_baudrate(baud_rate);
if (!baudflag)
return NULL;
fd = open(device, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (fd < 0)
return NULL;
#ifdef __CYGWIN__
/* For some very mysterious reason, this incantation is necessary to make
the serial port work under some windows machines */
HANDLE handle = (HANDLE)get_osfhandle(fd);
DCB dcb;
if (!(GetCommState(handle, &dcb) && SetCommState(handle, &dcb)))
{
close(fd);
return NULL;
}
#endif
/* Serial port setting */
memset(&newtio, 0, sizeof(newtio));
newtio.c_cflag = CS8 | CLOCAL | CREAD;
newtio.c_iflag = IGNPAR | IGNBRK;
cfsetispeed(&newtio, baudflag);
cfsetospeed(&newtio, baudflag);
/* Raw output_file */
newtio.c_oflag = 0;
if (tcflush(fd, TCIFLUSH) >= 0 && tcsetattr(fd, TCSANOW, &newtio) >= 0) {
serial_source src = malloc(sizeof *src);
if (src) {
memset(src, 0, sizeof src);
src->fd = fd;
src->non_blocking = non_blocking;
src->message = message;
src->send.seqno = 37;
return src;
}
}
close(fd);
return NULL;
}
/* Start a new overlapped I/O read from the command stream */
void start_read_command(
struct command_buffer_t *buffer)
{
HANDLE command_stream =
(HANDLE)get_osfhandle(buffer->command_stream);
int space_remaining =
COMMAND_BUFFER_SIZE - buffer->incoming_read_position - 1;
int err;
/* If a read is already active, or the pipe is closed, do nothing */
if (!buffer->platform.pipe_open || buffer->platform.read_active) {
return;
}
memset(&buffer->platform.overlapped, 0, sizeof(OVERLAPPED));
buffer->platform.overlapped.hEvent = (HANDLE)buffer;
if (!ReadFileEx(
command_stream, buffer->platform.overlapped_buffer, space_remaining,
&buffer->platform.overlapped, finish_read_command)) {
err = GetLastError();
if (err == ERROR_BROKEN_PIPE) {
/* If the command stream has been closed, we need to wake from
the next altertable wait to exit the main loop */
buffer->platform.pipe_open = false;
queue_empty_apc();
return;
} else if (err != WAIT_IO_COMPLETION) {
fprintf(
stderr, "Unexpected ReadFileEx failure %d\n", GetLastError());
exit(EXIT_FAILURE);
}
}
/* Remember that we have started an overlapped read already */
buffer->platform.read_active = true;
}
/* We are using Windows-specific API's to map files */
static void *mmapPerform(int fd, unsigned long offset,
unsigned long len, unsigned long end)
{
HANDLE osHandle;
HANDLE mapHandle;
void *mapAddress;
/* Get the underlying OS handle for the fd */
#ifdef IL_WIN32_CYGWIN
osHandle = (HANDLE)get_osfhandle(fd);
#else
osHandle = (HANDLE)_get_osfhandle(fd);
#endif
if(osHandle == (HANDLE)INVALID_HANDLE_VALUE)
{
return 0;
}
/* Under Windows, we cannot map bytes beyond the end of the file,
so we need to clamp the length to stay within the file's extent */
if((offset + len) > end)
{
len = end - offset;
}
/* Attempt to map the file */
mapHandle = CreateFileMapping(osHandle, NULL, PAGE_READONLY,
0, 0, NULL);
if(mapHandle == (HANDLE)NULL)
{
return 0;
}
mapAddress = MapViewOfFile(mapHandle, FILE_MAP_READ, 0, offset, len);
/* Close the mapping object, which we no longer require */
CloseHandle(mapHandle);
/* Return the memory pointer to the caller */
return mapAddress;
}
/**
* Opens up a stream to the serial port.
*
* @return Handle to the serial port as an integer.
* @author Martin Turon
* @version 2004/3/10 mturon Intial revision
* @n 2004/3/11 mturon Fixed cygwin reset problem
* @n 2004/3/12 mturon Added improved cygwin fix by dgay
*/
int xserial_port_open()
{
/* open serline for read/write */
int serline;
const char *name = g_device;
unsigned long baudrate = g_baudrate;
serline = open(name, O_RDWR | O_NOCTTY);
if (serline == -1) {
fprintf(stderr, "Failed to open %s\n", name);
perror("");
fprintf(stderr, "Verify that user has permission to open device.\n");
exit(2);
}
if (xmain_get_verbose()) printf("%s input stream opened\n", name);
#ifdef __CYGWIN__
/* Cygwin requires some specific initialization. */
HANDLE handle = (HANDLE)get_osfhandle(serline);
DCB dcb;
if (!(GetCommState(handle, &dcb) &&
SetCommState(handle, &dcb))) {
fprintf(stderr, "serial port initialisation problem\n");
exit(2);
}
#endif
/* Serial port setting */
struct termios newtio;
bzero(&newtio, sizeof(newtio));
newtio.c_cc[VMIN] = 1;
newtio.c_cflag = CS8 | CLOCAL | CREAD;
newtio.c_iflag = IGNBRK | IGNPAR;
cfsetispeed(&newtio, baudrate);
cfsetospeed(&newtio, baudrate);
tcflush(serline, TCIFLUSH);
tcsetattr(serline, TCSANOW, &newtio);
return serline;
}
int ILSysIOLock(ILSysIOHandle handle, ILInt64 position, ILInt64 length)
{
#if defined(IL_WIN32_PLATFORM)
/* Bypass the system library and call LockFile directly under Win32 */
#ifdef IL_WIN32_CYGWIN
HANDLE osHandle = (HANDLE)get_osfhandle((int)(ILNativeInt)handle);
#else
HANDLE osHandle = (HANDLE)_get_osfhandle((int)(ILNativeInt)handle);
#endif
if(osHandle == (HANDLE)INVALID_HANDLE_VALUE)
{
ILSysIOSetErrno(IL_ERRNO_EBADF);
return 0;
}
if(LockFile(osHandle,
(DWORD)(position & IL_MAX_UINT32),
(DWORD)((position >> 32) & IL_MAX_UINT32),
(DWORD)(length & IL_MAX_UINT32),
(DWORD)((length >> 32) & IL_MAX_UINT32)))
{
return 1;
}
else
{
int
w32fcntl(int fd, int flag, void *argp)
{
HANDLE h = LongToHandle(get_osfhandle(fd));
int r = 0, err = 0;
struct flock *fl;
switch (flag)
{
case F_SETLK:
case F_SETLKW:
#if 0
default:
return fcntl(fd, flag, argp);
#else
fl = (struct flock *) argp;
switch (fl->l_type)
{
case F_RDLCK:
case F_WRLCK:
r = LockFile(h, fl->l_start, 0, fl->l_len, 0);
break;
case F_UNLCK:
r = UnlockFile(h, fl->l_start, 0, fl->l_len, 0);
break;
}
if (!r)
err = GetLastError();
return !r;
#endif
case F_GETLK:
#if 0
fl = (struct flock *) argp;
fl->l_type = F_WRLCK;
if (!fcntl(fd, F_SETLK, fl))
{
fl->l_type = F_UNLCK;
fcntl(fd, F_SETLK, fl);
fl->l_type = F_SETLK;
}
else
fl->l_type = F_UNLCK;
return 0;
#else
fl = (struct flock *) argp;
if (LockFile(h, fl->l_start, 0, fl->l_len, 0))
{
fl->l_type = F_UNLCK;
UnlockFile(h, fl->l_start, 0, fl->l_len, 0);
}
else
{
fl->l_type = F_WRLCK;
}
#endif
return 0;
}
return -1;
}
serial_source open_serial_source(const char *device, int baud_rate,
int non_blocking,
void (*message)(serial_source_msg problem))
/* Effects: opens serial port device at specified baud_rate. If non_blocking
is true, read_serial_packet calls will be non-blocking (writes are
always blocking, for now at least)
Returns: descriptor for serial forwarder at host:port, or
NULL for failure (bad device or bad baud rate)
*/
{
#ifndef LOSE32
struct termios newtio;
int fd;
tcflag_t baudflag = parse_baudrate(baud_rate);
if (!baudflag)
return NULL;
fd = open(device, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (fd < 0)
return NULL;
#ifdef __CYGWIN__
/* For some very mysterious reason, this incantation is necessary to make
the serial port work under some windows machines */
HANDLE handle = (HANDLE)get_osfhandle(fd);
DCB dcb;
if (!(GetCommState(handle, &dcb) && SetCommState(handle, &dcb)))
{
close(fd);
return NULL;
}
#endif
/* Serial port setting */
memset(&newtio, 0, sizeof(newtio));
newtio.c_cflag = CS8 | CLOCAL | CREAD;
newtio.c_iflag = IGNPAR | IGNBRK;
cfsetispeed(&newtio, baudflag);
cfsetospeed(&newtio, baudflag);
/* Raw output_file */
newtio.c_oflag = 0;
if (tcflush(fd, TCIFLUSH) >= 0 &&
tcsetattr(fd, TCSANOW, &newtio) >= 0)
{
serial_source src = malloc(sizeof *src);
if (src)
{
memset(src, 0, sizeof *src);
src->fd = fd;
src->non_blocking = non_blocking;
src->message = message;
src->send.seqno = 37;
return src;
}
}
close(fd);
return NULL;
#else // LOSE32
LPCTSTR ComName = (LPCTSTR)device;
HANDLE hComm;
DCB dcb;
serial_source src;
int buflen = MultiByteToWideChar(CP_ACP,0,(PCSTR)device,-1,(LPWSTR)ComName,0);
MultiByteToWideChar(CP_ACP,0,(PCSTR)device,-1,(LPWSTR)ComName,buflen);
//syncronize
hComm = CreateFile(ComName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if (hComm == INVALID_HANDLE_VALUE) {
return NULL;
}
PurgeComm(hComm, PURGE_RXCLEAR);
GetCommState(hComm, &dcb);
dcb.BaudRate = baud_rate;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
dcb.fParity = FALSE;
dcb.StopBits = ONESTOPBIT;
if (SetCommState(hComm, &dcb) == 0) {
return NULL;
}
src = malloc(sizeof *src);
if (src) {
memset(src, 0, sizeof *src);
src->hComm = hComm;
src->non_blocking = non_blocking;
src->message = message;
src->send.seqno = 37;
}
return src;
#endif // LOSE32
}
int fb_hFileUnlock( FILE *f, fb_off_t inipos, fb_off_t size )
{
return fb_ErrorSetNum( UnlockFile( (HANDLE)get_osfhandle( fileno( f ) ), inipos, 0, size, 0 ) == TRUE ?
FB_RTERROR_OK : FB_RTERROR_FILEIO );
}
static int start_process(Channel * c, char ** envp, char * dir, char * exe, char ** args, int attach,
int * pid, int * selfattach, ChildProcess ** prs) {
typedef struct _SYSTEM_HANDLE_INFORMATION {
ULONG Count;
struct HANDLE_INFORMATION {
USHORT ProcessId;
USHORT CreatorBackTraceIndex;
UCHAR ObjectTypeNumber;
UCHAR Flags;
USHORT Handle;
PVOID Object;
ACCESS_MASK GrantedAccess;
} Handles[1];
} SYSTEM_HANDLE_INFORMATION;
FARPROC QuerySystemInformationProc = GetProcAddress(GetModuleHandle("NTDLL.DLL"), "NtQuerySystemInformation");
DWORD size;
NTSTATUS status;
SYSTEM_HANDLE_INFORMATION * hi = NULL;
int fpipes[3][2];
HANDLE hpipes[3][2];
char * cmd = NULL;
int err = 0;
int i;
if (args != NULL) {
int i = 0;
int cmd_size = 0;
int cmd_pos = 0;
# define cmd_append(ch) { \
if (!cmd) { \
cmd_size = 0x1000; \
cmd = (char *)loc_alloc(cmd_size); \
} \
else if (cmd_pos >= cmd_size) { \
char * tmp = (char *)loc_alloc(cmd_size * 2); \
memcpy(tmp, cmd, cmd_pos); \
loc_free(cmd); \
cmd = tmp; \
cmd_size *= 2; \
}; \
cmd[cmd_pos++] = (ch); \
}
while (args[i] != NULL) {
char * p = args[i++];
if (cmd_pos > 0) cmd_append(' ');
cmd_append('"');
while (*p) {
if (*p == '"') cmd_append('\\');
cmd_append(*p);
p++;
}
cmd_append('"');
}
cmd_append(0);
# undef cmd_append
}
size = sizeof(SYSTEM_HANDLE_INFORMATION) * 16;
hi = loc_alloc(size);
for (;;) {
status = QuerySystemInformationProc(SystemHandleInformation, hi, size, &size);
if (status != STATUS_INFO_LENGTH_MISMATCH) break;
hi = loc_realloc(hi, size);
}
if (status == 0) {
ULONG i;
DWORD id = GetCurrentProcessId();
for (i = 0; i < hi->Count; i++) {
if (hi->Handles[i].ProcessId != id) continue;
SetHandleInformation((HANDLE)(int)hi->Handles[i].Handle, HANDLE_FLAG_INHERIT, FALSE);
}
}
else {
err = set_win32_errno(status);
trace(LOG_ALWAYS, "Can't start process '%s': %s", exe, errno_to_str(err));
}
loc_free(hi);
memset(hpipes, 0, sizeof(hpipes));
for (i = 0; i < 3; i++) fpipes[i][0] = fpipes[i][1] = -1;
if (!err) {
#if defined(__CYGWIN__)
for (i = 0; i < 3; i++) {
if (pipe(fpipes[i]) < 0) {
err = errno;
break;
}
hpipes[i][0] = (HANDLE)get_osfhandle(fpipes[i][0]);
hpipes[i][1] = (HANDLE)get_osfhandle(fpipes[i][1]);
}
#else
for (i = 0; i < 3; i++) {
if (!CreatePipe(&hpipes[i][0], &hpipes[i][1], NULL, PIPE_SIZE)) {
err = set_win32_errno(GetLastError());
break;
}
fpipes[i][0] = _open_osfhandle((intptr_t)hpipes[i][0], O_TEXT);
fpipes[i][1] = _open_osfhandle((intptr_t)hpipes[i][1], O_TEXT);
}
#endif
}
if (!err) {
STARTUPINFO si;
PROCESS_INFORMATION prs_info;
SetHandleInformation(hpipes[0][0], HANDLE_FLAG_INHERIT, TRUE);
SetHandleInformation(hpipes[1][1], HANDLE_FLAG_INHERIT, TRUE);
SetHandleInformation(hpipes[2][1], HANDLE_FLAG_INHERIT, TRUE);
memset(&si, 0, sizeof(si));
memset(&prs_info, 0, sizeof(prs_info));
si.cb = sizeof(si);
si.dwFlags |= STARTF_USESTDHANDLES;
si.hStdInput = hpipes[0][0];
si.hStdOutput = hpipes[1][1];
si.hStdError = hpipes[2][1];
if (CreateProcess(exe, cmd, NULL, NULL, TRUE, (attach ? CREATE_SUSPENDED : 0),
(envp ? envp[0] : NULL), (dir[0] ? dir : NULL), &si, &prs_info) == 0)
{
err = set_win32_errno(GetLastError());
}
else {
*pid = prs_info.dwProcessId;
CloseHandle(prs_info.hThread);
CloseHandle(prs_info.hProcess);
}
}
close(fpipes[0][0]);
close(fpipes[1][1]);
close(fpipes[2][1]);
if (!err) {
*prs = loc_alloc_zero(sizeof(ChildProcess));
(*prs)->inp = fpipes[0][1];
(*prs)->out = fpipes[1][0];
(*prs)->err = fpipes[2][0];
(*prs)->pid = *pid;
(*prs)->bcg = c->bcg;
list_add_first(&(*prs)->link, &prs_list);
}
else {
close(fpipes[0][1]);
close(fpipes[1][0]);
close(fpipes[2][0]);
}
loc_free(cmd);
if (!err) return 0;
trace(LOG_ALWAYS, "Can't start process '%s': %s", exe, errno_to_str(err));
errno = err;
return -1;
}
