#include <modules.h>
#include <rwlock.h>
#include <mutex.h>
+#include <posix_signals.h>
// === CONSTANTS ===
#define OUTPUT_RINGBUFFER_LEN 1024 // Number of bytes in output queue before client blocks
tVFS_Node *ServerNode;
tVFS_Node ClientNode;
tVFS_ACL OwnerRW;
-
- // TODO: Maintain list of client PIDs
+
+ tPGID ControllingProcGroup;
};
// === PROTOTYPES ===
tPTY **prev_np = NULL;
size_t namelen;
int idx = 1;
- if( Name && Name[0] )
+ if( !Name || Name[0] == '\0' )
+ {
+ RWLock_AcquireWrite(&glPTY_NumPTYs);
+ // Get a pty ID if Name==NULL
+ prev_np = &gpPTY_FirstNumPTY;
+ for( tPTY *pty = gpPTY_FirstNumPTY; pty; prev_np = &pty->Next, pty = pty->Next )
+ {
+ if( pty->NumericName > idx )
+ break;
+ idx ++;
+ }
+ namelen = snprintf(NULL,0, "%u", idx);
+ }
+ else if( Name[strlen(Name)-1] == '#' )
+ {
+ // Sequenced PTYs
+ // - "gui#" would translate to "gui0", "gui1", "gui2", ...
+ // whichever is free
+ prev_np = &gpPTY_FirstNamedPTY;
+
+ idx = 0;
+ namelen = strlen(Name)-1;
+ for( tPTY *pty = gpPTY_FirstNamedPTY; pty; prev_np = &pty->Next, pty = pty->Next )
+ {
+ int cmp = strncmp(pty->Name, Name, namelen);
+ if( cmp < 0 )
+ continue ;
+ if( cmp > 0 )
+ break;
+
+ // Skip non-numbered
+ if( pty->Name[namelen] == '\0' )
+ continue ;
+
+ // Find an unused index
+ char *name_end;
+ int this_idx = strtol(pty->Name+namelen, &name_end, 10);
+ if( *name_end != '\0' )
+ continue;
+ if( this_idx > idx )
+ break;
+ idx ++;
+ }
+
+ namelen += snprintf(NULL, 0, "%u", idx);
+ }
+ else
{
prev_np = &gpPTY_FirstNamedPTY;
errno = EINVAL;
return NULL;
}
-
+
RWLock_AcquireWrite(&glPTY_NamedPTYs);
// Detect duplicates
for( tPTY *pty = gpPTY_FirstNamedPTY; pty; prev_np = &pty->Next, pty = pty->Next )
namelen = strlen(Name);
idx = -1;
}
- else
- {
- RWLock_AcquireWrite(&glPTY_NumPTYs);
- // Get a pty ID if Name==NULL
- prev_np = &gpPTY_FirstNumPTY;
- for( tPTY *pty = gpPTY_FirstNumPTY; pty; prev_np = &pty->Next, pty = pty->Next )
- {
- if( pty->NumericName > idx )
- break;
- idx ++;
- }
- namelen = snprintf(NULL,0, "%u", idx);
- }
tPTY *ret = calloc(sizeof(tPTY) + namelen + 1, 1);
if(!ret) {
*prev_np = ret;
// - PTY Name (Used by VT)
ret->Name = (char*)(ret + 1);
- if(Name)
+ if( idx == -1 )
strcpy(ret->Name, Name);
- else
- sprintf(ret->Name, "%u", idx);
+ else {
+ if(!Name) Name = "";
+ sprintf(ret->Name, "%.*s%u", strlen(Name)-1, Name, idx);
+ }
ret->NumericName = idx;
// - Output function and handle (same again)
ret->OutputHandle = Handle;
if( Mode )
{
// (for now) userland terminals can't be put into framebuffer mode
+ // - Userland PTYs are streams, framebuffer is a block
if( !PTY->OutputFcn && (Mode->OutputMode & PTYOMODE_BUFFMT) == PTYBUFFMT_FB ) {
errno = EINVAL;
return -1;
}
else if( !PTY->OutputFcn )
{
- Log_Warning("PTY", "TODO: Need to stop client output until modeset has been ACKed");
- // Block write until acked
- // ACK by server doing GETMODE
+ Log_Warning("PTY", "TODO: Inform server of client SETMODE, halt output");
+ // Block slave write until master ACKs
+ // 0-length read on master indicates need to GETMODE
}
}
else
{
// Should the client be informed that the server just twiddled the modes?
+ Log_Warning("PTY", "Server changed mode, TODO: inform client?");
}
LOG("PTY %p mode set to {0%o, 0%o}", PTY, Mode->InputMode, Mode->OutputMode);
PTY->Mode = *Mode;
else if( !PTY->OutputFcn )
{
// Inform server process... somehow
+ Log_Warning("PTY", "TODO: Inform server of client resize request");
}
}
else
{
// SIGWINSZ to client
+ Threads_SignalGroup(PTY->ControllingProcGroup, SIGWINCH);
}
LOG("PTY %p dims set to %ix%i", PTY, Dims->W, Dims->H);
PTY->Dims = *Dims;
size_t _rb_write(void *buf, size_t buflen, int *rd, int *wr, const void *data, size_t len)
{
size_t space = (*rd - *wr + buflen - 1) % buflen;
- ENTER("pbuf ibuflen prd pwr pdata ilen", buf, buflen, rd, wr, data, len);
len = MIN(space, len);
- LOG("space = %i, *rd = %i, *wr = %i", space, *rd, *wr);
if(*wr + len >= buflen) {
size_t prelen = buflen - *wr;
memcpy((char*)buf + *wr, data, prelen);
memcpy((char*)buf + *wr, data, len);
*wr += len;
}
- LEAVE('i', len);
return len;
}
size_t _rb_read(void *buf, size_t buflen, int *rd, int *wr, void *data, size_t len)
Mutex_Release(&PTY->InputMutex);
VFS_MarkAvaliable(&PTY->ClientNode, 1);
- if(ret < Length)
+ if(ret < Length && PTY->ServerNode)
VFS_MarkFull(PTY->ServerNode, 1);
return ret;
switch(Input[0])
{
case 3: // INTR - ^C
- // TODO: Send SIGINT
- // Threads_PostSignalExt(PTY->ClientThreads, SIGINT);
+ // Send SIGINT
+ Threads_SignalGroup(PTY->ControllingProcGroup, SIGINT);
print = 0;
break;
case 4: // EOF - ^D
}
if( !pty ) {
- LOG("%i out of range", Pos);
return -1;
}
- strncpy(Name, pty->Name, FILENAME_MAX)
- LOG("Return '%s'", Name);
+ strncpy(Name, pty->Name, FILENAME_MAX);
return 0;
}
}
RWLock_Release(&glPTY_NamedPTYs);
}
+// Debug("PTY_FindDir('%s') returned %p", Name, &ret->ClientNode);
if( ret ) {
tVFS_Node *retnode = &ret->ClientNode;
retnode->ReferenceCount ++;
Mutex_Acquire(&pty->InputMutex);
Length = _rb_read(pty->InputData, INPUT_RINGBUFFER_LEN, &pty->InputReadPos, &pty->InputWritePos,
Buffer, Length);
+ if( Length && pty->ServerNode )
+ VFS_MarkFull(pty->ServerNode, 0);
Mutex_Release(&pty->InputMutex);
if(pty->InputReadPos == pty->InputWritePos)
// If the server has terminated, send SIGPIPE
if( pty->ServerNode && pty->ServerNode->ReferenceCount == 0 )
{
- //Threads_PostSignal(SIGPIPE);
+ Threads_PostSignal(SIGPIPE);
errno = EIO;
return -1;
}
// Write to either FIFO or directly to output function
- if( pty->OutputFcn )
- {
+ if( pty->OutputFcn ) {
pty->OutputFcn(pty->OutputHandle, Length, Buffer);
+ return Length;
}
- else
+
+ // FIFO
+ size_t remaining = Length;
+ do
{
+ tTime timeout_z, *timeout = (Flags & VFS_IOFLAG_NOBLOCK) ? &timeout_z : NULL;
+ int rv;
+
+ rv = VFS_SelectNode(Node, VFS_SELECT_WRITE, timeout, "PTY_WriteClient");
+ if(!rv) {
+ errno = (timeout ? EWOULDBLOCK : EINTR);
+ return -1;
+ }
+
// Write to output ringbuffer
- Length = _rb_write(pty->OutputData, OUTPUT_RINGBUFFER_LEN,
+ size_t written = _rb_write(pty->OutputData, OUTPUT_RINGBUFFER_LEN,
&pty->OutputReadPos, &pty->OutputWritePos,
- Buffer, Length);
+ Buffer, remaining);
+ LOG("Wrote %i of %i : '%.*s'", written, remaining, written, Buffer);
VFS_MarkAvaliable(pty->ServerNode, 1);
- }
+ if( (pty->OutputWritePos + 1) % OUTPUT_RINGBUFFER_LEN == pty->OutputReadPos )
+ VFS_MarkFull(Node, 1);
+
+ remaining -= written;
+ Buffer = (const char*)Buffer + written;
+ } while( remaining > 0 || (Flags & VFS_IOFLAG_NOBLOCK) );
- return Length;
+ return Length - remaining;
}
void PTY_ReferenceClient(tVFS_Node *Node)
{
Node->ReferenceCount ++;
- // TODO: Add PID to list of client PIDs
-// Log_Notice("PTY", "ReferenceClient: TODO - List of client PIDs");
}
void PTY_CloseClient(tVFS_Node *Node)
size_t PTY_ReadServer(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer, Uint Flags)
{
tPTY *pty = Node->ImplPtr;
+ if( !pty ) {
+ errno = EIO;
+ return -1;
+ }
// TODO: Prevent two servers fighting over client's output
if( pty->OutputFcn )
Length = _rb_read(pty->OutputData, OUTPUT_RINGBUFFER_LEN,
&pty->OutputReadPos, &pty->OutputWritePos,
Buffer, Length);
+ LOG("Read %i '%.*s'", Length, Length, Buffer);
if( pty->OutputReadPos == pty->OutputWritePos )
VFS_MarkAvaliable(Node, 0);
VFS_MarkFull(&pty->ClientNode, 0);
//\! Write to the client's input
size_t PTY_WriteServer(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer, Uint Flags)
{
- return PTY_SendInput(Node->ImplPtr, Buffer, Length);
+ tPTY *pty = Node->ImplPtr;
+ if( !pty ) {
+ errno = EIO;
+ return -1;
+ }
+
+ tTime timeout_z = 0, *timeout = (Flags & VFS_IOFLAG_NOBLOCK) ? &timeout_z : NULL;
+ int rv = VFS_SelectNode(Node, VFS_SELECT_WRITE, timeout, "PTY_WriteServer");
+ if(!rv) {
+ errno = (timeout ? EWOULDBLOCK : EINTR);
+ return -1;
+ }
+ size_t used = 0;
+ do {
+ used += PTY_SendInput(Node->ImplPtr, Buffer, Length);
+ } while( used < Length && !(Flags & VFS_IOFLAG_NOBLOCK) );
+
+ if( (pty->InputWritePos+1)%INPUT_RINGBUFFER_LEN == pty->InputReadPos )
+ VFS_MarkFull(Node, 1);
+ return used;
}
void PTY_CloseServer(tVFS_Node *Node)
// Locate on list and remove
tPTY **prev_np;
- if( pty->NumericName == 0 ) {
+ if( pty->NumericName == -1 ) {
RWLock_AcquireWrite(&glPTY_NamedPTYs);
prev_np = &gpPTY_FirstNamedPTY;
}
}
// Clean up lock
- if( pty->NumericName == 0 ) {
+ if( pty->NumericName == -1 ) {
RWLock_Release(&glPTY_NamedPTYs);
giPTY_NamedCount --;
}
giPTY_NumCount --;
}
+ // Send SIGHUP to controling PGID
+ if( pty->ControllingProcGroup > 0 ) {
+ Threads_SignalGroup(pty->ControllingProcGroup, SIGHUP);
+ }
+
// If there are no open children, we can safely free this PTY
if( pty->ClientNode.ReferenceCount == 0 ) {
free(Node);
Node->ImplPtr = pty;
pty->ServerNode = Node;
return 0;
+ case PTY_IOCTL_SETPGRP:
+ // TODO: Should this only be done by client?
+ if( Data )
+ {
+ if( !CheckMem(Data, sizeof(tPGID)) ) { errno = EINVAL; return -1; }
+ pty->ControllingProcGroup = *(tPGID*)Data;
+ Log_Debug("PTY", "Set controlling PGID to %i", pty->ControllingProcGroup);
+ }
+ return pty->ControllingProcGroup;
}
errno = ENOSYS;
return -1;
git.ucc.asn.au / tpg / acess2.git / blobdiff
UCC git Repository :: git.ucc.asn.au