3 * - By John Hodge (thePowersGang)
17 #define OUTPUT_RINGBUFFER_LEN 1024 // Number of bytes in output queue before client blocks
18 #define INPUT_RINGBUFFER_LEN 256 // Number of bytes in input queue before being dropped
19 #define INPUT_LINE_LEN 256
30 tPTY_OutputFcn OutputFcn;
31 tPTY_ReqResize ReqResize;
40 char InputData[INPUT_RINGBUFFER_LEN];
43 char LineData[INPUT_LINE_LEN];
48 char OutputData[OUTPUT_RINGBUFFER_LEN];
54 // TODO: Maintain list of client PIDs
58 int PTY_Install(char **Arguments);
59 int PTY_ReadDir(tVFS_Node *Node, int Pos, char Name[FILENAME_MAX]);
60 tVFS_Node *PTY_FindDir(tVFS_Node *Node, const char *Name, Uint Flags);
61 tVFS_Node *PTY_MkNod(tVFS_Node *Node, const char *Name, Uint Mode);
63 size_t _rb_write(void *buf, size_t buflen, int *rd, int *wr, const void *data, size_t len);
64 size_t _rb_read(void *buf, size_t buflen, int *rd, int *wr, void *data, size_t len);
65 size_t PTY_int_WriteInput(tPTY *PTY, const char *Input, size_t Length);
66 size_t PTY_int_SendInput(tPTY *PTY, const char *Input, size_t Length);
68 size_t PTY_ReadClient(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer, Uint Flags);
69 size_t PTY_WriteClient(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer, Uint Flags);
70 int PTY_IOCtlClient(tVFS_Node *Node, int ID, void *Arg);
71 void PTY_ReferenceClient(tVFS_Node *Node);
72 void PTY_CloseClient(tVFS_Node *Node);
73 size_t PTY_ReadServer(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer, Uint Flags);
74 size_t PTY_WriteServer(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer, Uint Flags);
75 int PTY_IOCtlServer(tVFS_Node *Node, int ID, void *Arg);
76 void PTY_CloseServer(tVFS_Node *Node);
79 MODULE_DEFINE(0, 0x100, PTY, PTY_Install, NULL, NULL);
80 tVFS_NodeType gPTY_NodeType_Root = {
81 .TypeName = "PTY-Root",
82 .ReadDir = PTY_ReadDir,
83 .FindDir = PTY_FindDir,
86 tVFS_NodeType gPTY_NodeType_Client = {
87 .TypeName = "PTY-Client",
88 .Read = PTY_ReadClient,
89 .Write = PTY_WriteClient,
90 .IOCtl = PTY_IOCtlClient,
91 .Reference = PTY_ReferenceClient,
92 .Close = PTY_CloseClient
94 tVFS_NodeType gPTY_NodeType_Server = {
95 .TypeName = "PTY-Server",
96 .Read = PTY_ReadServer,
97 .Write = PTY_WriteServer,
98 .IOCtl = PTY_IOCtlServer,
99 .Close = PTY_CloseServer
101 tDevFS_Driver gPTY_Driver = {
104 .Flags = VFS_FFLAG_DIRECTORY,
105 .Type = &gPTY_NodeType_Root
109 tRWLock glPTY_NumPTYs;
110 tPTY *gpPTY_FirstNumPTY;
111 int giPTY_NamedCount;
112 tRWLock glPTY_NamedPTYs;
113 tPTY *gpPTY_FirstNamedPTY;
116 int PTY_Install(char **Arguments)
118 return MODULE_ERR_OK;
121 // --- Management ---
122 tPTY *PTY_Create(const char *Name, void *Handle, tPTY_OutputFcn Output, tPTY_ReqResize ReqResize)
124 tPTY **prev_np = NULL;
127 if( Name && Name[0] )
129 prev_np = &gpPTY_FirstNamedPTY;
131 // Check the name isn't decimal
133 if( strtol(Name, &end, 10) != 0 && *end == '\0' ) {
138 RWLock_AcquireWrite(&glPTY_NamedPTYs);
140 for( tPTY *pty = gpPTY_FirstNamedPTY; pty; prev_np = &pty->Next, pty = pty->Next )
142 int cmp = strcmp(pty->Name, Name);
146 RWLock_Release(&glPTY_NamedPTYs);
152 namelen = strlen(Name);
157 RWLock_AcquireWrite(&glPTY_NumPTYs);
158 // Get a pty ID if Name==NULL
159 prev_np = &gpPTY_FirstNumPTY;
160 for( tPTY *pty = gpPTY_FirstNumPTY; pty; prev_np = &pty->Next, pty = pty->Next )
162 if( pty->NumericName > idx )
169 tPTY *ret = calloc(sizeof(tPTY) + namelen + 1, 1);
175 // - List maintainance
176 ret->Next = *prev_np;
178 // - PTY Name (Used by VT)
179 ret->Name = (char*)(ret + 1);
181 strcpy(ret->Name, Name);
184 ret->NumericName = idx;
185 // - Output function and handle (same again)
186 ret->OutputHandle = Handle;
187 ret->OutputFcn = Output;
188 ret->ReqResize = ReqResize;
190 ret->ServerNode.ImplPtr = ret;
191 ret->ServerNode.Type = &gPTY_NodeType_Server;
192 ret->ServerNode.UID = Threads_GetUID();
193 ret->ServerNode.GID = Threads_GetGID();
194 ret->ServerNode.NumACLs = 1;
195 ret->ServerNode.ACLs = &ret->OwnerRW;
196 ret->ServerNode.ReferenceCount = (Output ? 1 : 0); // Prevent a userland close killing a kernel pty
198 ret->ClientNode.ImplPtr = ret;
199 ret->ClientNode.Type = &gPTY_NodeType_Client;
200 ret->ClientNode.UID = Threads_GetUID();
201 ret->ClientNode.GID = Threads_GetGID();
202 ret->ClientNode.NumACLs = 1;
203 ret->ClientNode.ACLs = &ret->OwnerRW;
204 // - Owner Read-Write ACL
205 ret->OwnerRW.Ent.ID = Threads_GetUID();
206 ret->OwnerRW.Perm.Perms = -1;
208 if( Name && Name[0] ) {
210 RWLock_Release(&glPTY_NamedPTYs);
214 RWLock_Release(&glPTY_NumPTYs);
220 int PTY_SetAttrib(tPTY *PTY, const struct ptydims *Dims, const struct ptymode *Mode, int WasClient)
224 // (for now) userland terminals can't be put into framebuffer mode
225 if( !PTY->OutputFcn && (Mode->OutputMode & PTYOMODE_BUFFMT) == PTYBUFFMT_FB ) {
230 if( !WasClient && !PTY->OutputFcn )
232 Log_Warning("PTY", "TODO: Need to stop client output until modeset has been ACKed");
233 // Block write until acked
234 // ACK by server doing GETMODE
241 if( PTY->ReqResize && PTY->ReqResize(PTY->OutputHandle, Dims) )
246 else if( !PTY->OutputFcn )
248 // Inform server process... somehow
252 // SIGWINSZ to client
259 void PTY_Close(tPTY *PTY)
264 size_t _rb_write(void *buf, size_t buflen, int *rd, int *wr, const void *data, size_t len)
266 size_t space = (*rd - *wr + buflen) % buflen - 1;
267 len = MIN(space, len);
268 if(*wr + len >= buflen) {
269 size_t prelen = buflen - *wr;
270 memcpy((char*)buf + *wr, data, prelen);
271 memcpy(buf, (char*)data + prelen, len - prelen);
275 memcpy((char*)buf + *wr, data, len);
280 size_t _rb_read(void *buf, size_t buflen, int *rd, int *wr, void *data, size_t len)
282 size_t space = (*wr - *rd + buflen) % buflen;
283 len = MIN(space, len);
284 if(*rd + len >= buflen) {
285 size_t prelen = buflen - *rd;
286 memcpy(data, (char*)buf + *rd, prelen);
287 memcpy((char*)data + prelen, buf, len - prelen);
291 memcpy(data, (char*)buf + *rd, len);
297 size_t PTY_int_WriteInput(tPTY *PTY, const char *Input, size_t Length)
301 Mutex_Acquire(&PTY->InputMutex);
303 ret = _rb_write(PTY->InputData, INPUT_RINGBUFFER_LEN, &PTY->InputReadPos, &PTY->InputWritePos,
306 Mutex_Release(&PTY->InputMutex);
308 VFS_MarkAvaliable(&PTY->ClientNode, 1);
310 VFS_MarkFull(&PTY->ServerNode, 1);
315 size_t PTY_int_SendInput(tPTY *PTY, const char *Input, size_t Length)
317 size_t ret = 1, print = 1;
319 // Only counts for text input modes
320 if( (PTY->Mode.OutputMode & PTYOMODE_BUFFMT) == PTYBUFFMT_TEXT )
321 return PTY_int_WriteInput(PTY, Input, Length);
322 // If in raw mode, flush directlr
323 if( (PTY->Mode.InputMode & PTYIMODE_RAW) )
324 return PTY_int_WriteInput(PTY, Input, Length);
326 if( PTY->Mode.InputMode & PTYIMODE_CANON )
328 const char char_bs = '\b';
333 // Threads_PostSignalExt(PTY->ClientThreads, SIGINT);
337 PTY_int_WriteInput(PTY, PTY->LineData, PTY->LineLength);
338 PTY->HasHitEOF = (PTY->LineLength == 0);
343 if(PTY->LineLength != 0)
346 case 'w'-'a': // Word erase
347 while(PTY->LineLength != 0 && isalnum(PTY->LineData[--PTY->LineLength]))
348 PTY_WriteClient(&PTY->ClientNode, 0, 1, &char_bs, 0);
351 case 'u'-'a': // Kill
352 while(PTY->LineLength > 0)
353 PTY_WriteClient(&PTY->ClientNode, 0, 1, &char_bs, 0);
363 if(PTY->LineLength == INPUT_LINE_LEN) {
364 PTY_int_WriteInput(PTY, PTY->LineData, PTY->LineLength);
367 PTY->LineData[PTY->LineLength++] = '\n';
368 PTY_int_WriteInput(PTY, PTY->LineData, PTY->LineLength);
371 // TODO: Handle ^[[D and ^[[C for in-line editing, also ^[[1~/^[[4~ (home/end)
376 if(PTY->LineLength == INPUT_LINE_LEN) {
377 PTY_int_WriteInput(PTY, PTY->LineData, PTY->LineLength);
380 PTY->LineData[PTY->LineLength++] = Input[0];
386 ret = PTY_int_WriteInput(PTY, Input, Length);
390 if( PTY->Mode.InputMode & PTYIMODE_ECHO )
392 PTY_WriteClient(&PTY->ClientNode, 0, print, Input, 0);
398 size_t PTY_SendInput(tPTY *PTY, const char *Input, size_t Length)
401 while( ret < Length && !PTY->ClientNode.BufferFull )
403 // TODO: Detect blocking?
404 ret += PTY_int_SendInput(PTY, Input + ret, Length - ret);
410 int PTY_ReadDir(tVFS_Node *Node, int Pos, char Name[FILENAME_MAX])
413 if( Pos < giPTY_NumCount * 2 )
415 RWLock_AcquireRead(&glPTY_NumPTYs);
416 for( pty = gpPTY_FirstNumPTY; pty; pty = pty->Next )
422 RWLock_Release(&glPTY_NumPTYs);
424 else if( Pos < (giPTY_NumCount + giPTY_NamedCount) * 2 )
426 RWLock_AcquireRead(&glPTY_NamedPTYs);
427 for( pty = gpPTY_FirstNamedPTY; pty; pty = pty->Next )
433 RWLock_Release(&glPTY_NamedPTYs);
441 snprintf(Name, 255, "%s%c", pty->Name, (Pos == 0 ? 'c' : 's'));
443 snprintf(Name, 255, "%i%c", pty->NumericName, (Pos == 0 ? 'c' : 's'));
447 tVFS_Node *PTY_FindDir(tVFS_Node *Node, const char *Name, Uint Flags)
450 int num = strtol(Name, &end, 10);
452 if( Name[0] == '\0' || Name[1] == '\0' )
455 size_t len = strlen(Name);
456 if( Name[len-1] != 'c' && Name[len-1] != 's' )
458 int isServer = (Name[len-1] != 'c');
461 if( num && (end[0] == 'c' || end[0] == 's') && end[1] == '\0' )
464 RWLock_AcquireRead(&glPTY_NumPTYs);
465 for( tPTY *pty = gpPTY_FirstNumPTY; pty; pty = pty->Next )
467 if( pty->NumericName > num )
469 if( pty->NumericName == num ) {
474 RWLock_Release(&glPTY_NumPTYs);
479 RWLock_AcquireRead(&glPTY_NamedPTYs);
480 for( tPTY *pty = gpPTY_FirstNamedPTY; pty; pty = pty->Next )
482 int cmp = strncmp(pty->Name, Name, len-1);
485 if(cmp == 0 && pty->Name[len-1] == '\0' ) {
490 RWLock_Release(&glPTY_NamedPTYs);
493 return (isServer ? &ret->ServerNode : &ret->ClientNode);
498 tVFS_Node *PTY_MkNod(tVFS_Node *Node, const char *Name, Uint Mode)
500 // zero-length name means a numbered pty has been requested
501 if( Name[0] == '\0' )
503 tPTY *ret = PTY_Create(NULL, NULL, NULL, NULL);
506 return &ret->ServerNode;
509 // Otherwise return a named PTY
510 // TODO: Should the request be for '<name>s' or just '<name>'
512 tPTY *ret = PTY_Create(Name, NULL, NULL, NULL);
515 return &ret->ServerNode;
518 //\! Read from the client's input
519 size_t PTY_ReadClient(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer, Uint Flags)
521 tPTY *pty = Node->ImplPtr;
523 // Read from flushed queue
524 tTime timeout_z = 0, *timeout = (Flags & VFS_IOFLAG_NOBLOCK) ? &timeout_z : NULL;
527 // If server has disconnected, return EIO
528 if( pty->ServerNode.ReferenceCount == 0 ) {
529 //Threads_PostSignal(SIGPIPE);
533 // Wait for data to be ready
534 rv = VFS_SelectNode(Node, VFS_SELECT_READ, timeout, "PTY_ReadClient");
536 errno = (timeout ? EWOULDBLOCK : EINTR);
540 Mutex_Acquire(&pty->InputMutex);
541 Length = _rb_read(pty->InputData, INPUT_RINGBUFFER_LEN, &pty->InputReadPos, &pty->InputWritePos,
543 Mutex_Release(&pty->InputMutex);
545 if(pty->InputReadPos == pty->InputWritePos)
546 VFS_MarkAvaliable(Node, 0);
548 if(Length == 0 && !pty->HasHitEOF) {
556 //\! Write to the client's output
557 size_t PTY_WriteClient(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer, Uint Flags)
559 tPTY *pty = Node->ImplPtr;
561 // If the server has terminated, send SIGPIPE
562 if( pty->ServerNode.ReferenceCount == 0 )
564 //Threads_PostSignal(SIGPIPE);
569 // Write to either FIFO or directly to output function
572 pty->OutputFcn(pty->OutputHandle, Buffer, Length, pty->Mode.OutputMode);
576 // Write to output ringbuffer
577 Length = _rb_write(pty->OutputData, OUTPUT_RINGBUFFER_LEN,
578 &pty->OutputReadPos, &pty->OutputWritePos,
580 VFS_MarkAvaliable(&pty->ServerNode, 1);
586 int PTY_IOCtlClient(tVFS_Node *Node, int ID, void *Data)
588 tPTY *pty = Node->ImplPtr;
589 struct ptymode *mode = Data;
590 struct ptydims *dims = Data;
593 case DRV_IOCTL_TYPE: return DRV_TYPE_TERMINAL;
594 case DRV_IOCTL_IDENT: memcpy(Data, "PTY\0", 4); return 0;
595 case DRV_IOCTL_VER: return 0x100;
596 case DRV_IOCTL_LOOKUP: return 0;
598 case PTY_IOCTL_GETMODE:
599 if( !CheckMem(Data, sizeof(*mode)) ) { errno = EINVAL; return -1; }
602 case PTY_IOCTL_SETMODE:
603 if( !CheckMem(Data, sizeof(*mode)) ) { errno = EINVAL; return -1; }
604 return PTY_SetAttrib(pty, NULL, mode, 1);
605 case PTY_IOCTL_GETDIMS:
606 if( !CheckMem(Data, sizeof(*dims)) ) { errno = EINVAL; return -1; }
609 case PTY_IOCTL_SETDIMS:
610 if( !CheckMem(Data, sizeof(*dims)) ) { errno = EINVAL; return -1; }
611 return PTY_SetAttrib(pty, dims, NULL, 1);
617 void PTY_ReferenceClient(tVFS_Node *Node)
619 Node->ReferenceCount ++;
620 // TODO: Add PID to list of client PIDs
621 Log_Notice("PTY", "TODO: List of client PIDs");
624 void PTY_CloseClient(tVFS_Node *Node)
626 tPTY *pty = Node->ImplPtr;
627 Node->ReferenceCount --;
629 // Remove PID from list
631 // Free structure if this was the last open handle
632 if( Node->ReferenceCount == 0 && pty->ServerNode.ReferenceCount == 0 )
634 // Free the structure! (Should be off the PTY list now)
639 //\! Read from the client's output
640 size_t PTY_ReadServer(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer, Uint Flags)
642 tPTY *pty = Node->ImplPtr;
644 // TODO: Prevent two servers fighting over client's output
647 // Kernel-land PTYs can't be read from userland
651 // Read back from fifo
652 tTime timeout_z = 0, *timeout = (Flags & VFS_IOFLAG_NOBLOCK) ? &timeout_z : NULL;
653 int rv = VFS_SelectNode(Node, VFS_SELECT_READ, timeout, "PTY_ReadServer");
655 errno = (timeout ? EWOULDBLOCK : EINTR);
659 Length = _rb_read(pty->OutputData, OUTPUT_RINGBUFFER_LEN,
660 &pty->OutputReadPos, &pty->OutputWritePos,
662 if( pty->OutputReadPos == pty->OutputWritePos )
663 VFS_MarkAvaliable(Node, 0);
664 VFS_MarkFull(&pty->ClientNode, 0);
669 //\! Write to the client's input
670 size_t PTY_WriteServer(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer, Uint Flags)
672 // Write to current line buffer, flushing on unknown character or newline
674 // Echo back if instructed
675 PTY_SendInput(Node->ImplPtr, Buffer, Length);
679 int PTY_IOCtlServer(tVFS_Node *Node, int ID, void *Data)
681 tPTY *pty = Node->ImplPtr;
682 struct ptymode *mode = Data;
683 struct ptydims *dims = Data;
686 case DRV_IOCTL_TYPE: return DRV_TYPE_TERMINAL;
687 case DRV_IOCTL_IDENT: memcpy(Data, "PTY\0", 4); return 0;
688 case DRV_IOCTL_VER: return 0x100;
689 case DRV_IOCTL_LOOKUP: return 0;
691 case PTY_IOCTL_GETMODE:
692 if( !CheckMem(Data, sizeof(*mode)) ) { errno = EINVAL; return -1; }
694 // ACK client's SETMODE
696 case PTY_IOCTL_SETMODE:
697 if( !CheckMem(Data, sizeof(*mode)) ) { errno = EINVAL; return -1; }
698 PTY_SetAttrib(pty, NULL, mode, 0);
700 case PTY_IOCTL_GETDIMS:
701 if( !CheckMem(Data, sizeof(*dims)) ) { errno = EINVAL; return -1; }
704 case PTY_IOCTL_SETDIMS:
705 if( !CheckMem(Data, sizeof(*dims)) ) { errno = EINVAL; return -1; }
706 PTY_SetAttrib(pty, dims, NULL, 0);
713 void PTY_CloseServer(tVFS_Node *Node)
715 tPTY *pty = Node->ImplPtr;
717 Node->ReferenceCount --;
718 // If reference count == 0, remove from main list
719 if( Node->ReferenceCount > 0 )
722 // Locate on list and remove
725 RWLock_AcquireWrite(&glPTY_NamedPTYs);
726 prev_np = &gpPTY_FirstNamedPTY;
729 RWLock_AcquireWrite(&glPTY_NumPTYs);
730 prev_np = &gpPTY_FirstNumPTY;
733 // Search list until *prev_np is equal to pty
734 for( tPTY *tmp = *prev_np; *prev_np != pty && tmp; prev_np = &tmp->Next, tmp = tmp->Next )
738 if( *prev_np != pty ) {
739 Log_Error("PTY", "PTY %p(%i/%s) not on list at deletion time", pty, pty->NumericName, pty->Name);
742 *prev_np = pty->Next;
747 RWLock_Release(&glPTY_NamedPTYs);
751 RWLock_Release(&glPTY_NumPTYs);
755 // If there are no open children, we can safely free this PTY
756 if( pty->ClientNode.ReferenceCount == 0 )