3 * - By John Hodge (thePowersGang)
18 #define OUTPUT_RINGBUFFER_LEN 1024 // Number of bytes in output queue before client blocks
19 #define INPUT_RINGBUFFER_LEN 256 // Number of bytes in input queue before being dropped
20 #define INPUT_LINE_LEN 256
31 tPTY_OutputFcn OutputFcn;
32 tPTY_ReqResize ReqResize;
41 char InputData[INPUT_RINGBUFFER_LEN];
44 char LineData[INPUT_LINE_LEN];
49 char OutputData[OUTPUT_RINGBUFFER_LEN];
55 // TODO: Maintain list of client PIDs
59 int PTY_Install(char **Arguments);
60 int PTY_ReadDir(tVFS_Node *Node, int Pos, char Name[FILENAME_MAX]);
61 tVFS_Node *PTY_FindDir(tVFS_Node *Node, const char *Name, Uint Flags);
62 tVFS_Node *PTY_MkNod(tVFS_Node *Node, const char *Name, Uint Mode);
64 size_t _rb_write(void *buf, size_t buflen, int *rd, int *wr, const void *data, size_t len);
65 size_t _rb_read(void *buf, size_t buflen, int *rd, int *wr, void *data, size_t len);
66 size_t PTY_int_WriteInput(tPTY *PTY, const char *Input, size_t Length);
67 size_t PTY_int_SendInput(tPTY *PTY, const char *Input, size_t Length);
69 size_t PTY_ReadClient(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer, Uint Flags);
70 size_t PTY_WriteClient(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer, Uint Flags);
71 int PTY_IOCtlClient(tVFS_Node *Node, int ID, void *Arg);
72 void PTY_ReferenceClient(tVFS_Node *Node);
73 void PTY_CloseClient(tVFS_Node *Node);
74 size_t PTY_ReadServer(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer, Uint Flags);
75 size_t PTY_WriteServer(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer, Uint Flags);
76 int PTY_IOCtlServer(tVFS_Node *Node, int ID, void *Arg);
77 void PTY_CloseServer(tVFS_Node *Node);
80 MODULE_DEFINE(0, 0x100, PTY, PTY_Install, NULL, NULL);
81 tVFS_NodeType gPTY_NodeType_Root = {
82 .TypeName = "PTY-Root",
83 .ReadDir = PTY_ReadDir,
84 .FindDir = PTY_FindDir,
87 tVFS_NodeType gPTY_NodeType_Client = {
88 .TypeName = "PTY-Client",
89 .Read = PTY_ReadClient,
90 .Write = PTY_WriteClient,
91 .IOCtl = PTY_IOCtlClient,
92 .Reference = PTY_ReferenceClient,
93 .Close = PTY_CloseClient
95 tVFS_NodeType gPTY_NodeType_Server = {
96 .TypeName = "PTY-Server",
97 .Read = PTY_ReadServer,
98 .Write = PTY_WriteServer,
99 .IOCtl = PTY_IOCtlServer,
100 .Close = PTY_CloseServer
102 tDevFS_Driver gPTY_Driver = {
105 .Flags = VFS_FFLAG_DIRECTORY,
106 .Type = &gPTY_NodeType_Root
110 tRWLock glPTY_NumPTYs;
111 tPTY *gpPTY_FirstNumPTY;
112 int giPTY_NamedCount;
113 tRWLock glPTY_NamedPTYs;
114 tPTY *gpPTY_FirstNamedPTY;
117 int PTY_Install(char **Arguments)
119 DevFS_AddDevice(&gPTY_Driver);
120 return MODULE_ERR_OK;
123 // --- Management ---
124 tPTY *PTY_Create(const char *Name, void *Handle, tPTY_OutputFcn Output, tPTY_ReqResize ReqResize)
126 tPTY **prev_np = NULL;
129 if( Name && Name[0] )
131 prev_np = &gpPTY_FirstNamedPTY;
133 // Check the name isn't decimal
135 if( strtol(Name, &end, 10) != 0 && *end == '\0' ) {
140 RWLock_AcquireWrite(&glPTY_NamedPTYs);
142 for( tPTY *pty = gpPTY_FirstNamedPTY; pty; prev_np = &pty->Next, pty = pty->Next )
144 int cmp = strcmp(pty->Name, Name);
148 RWLock_Release(&glPTY_NamedPTYs);
154 namelen = strlen(Name);
159 RWLock_AcquireWrite(&glPTY_NumPTYs);
160 // Get a pty ID if Name==NULL
161 prev_np = &gpPTY_FirstNumPTY;
162 for( tPTY *pty = gpPTY_FirstNumPTY; pty; prev_np = &pty->Next, pty = pty->Next )
164 if( pty->NumericName > idx )
171 tPTY *ret = calloc(sizeof(tPTY) + namelen + 1, 1);
177 // - List maintainance
178 ret->Next = *prev_np;
180 // - PTY Name (Used by VT)
181 ret->Name = (char*)(ret + 1);
183 strcpy(ret->Name, Name);
186 ret->NumericName = idx;
187 // - Output function and handle (same again)
188 ret->OutputHandle = Handle;
189 ret->OutputFcn = Output;
190 ret->ReqResize = ReqResize;
192 ret->ServerNode.ImplPtr = ret;
193 ret->ServerNode.Type = &gPTY_NodeType_Server;
194 ret->ServerNode.UID = Threads_GetUID();
195 ret->ServerNode.GID = Threads_GetGID();
196 ret->ServerNode.NumACLs = 1;
197 ret->ServerNode.ACLs = &ret->OwnerRW;
198 ret->ServerNode.ReferenceCount = (Output ? 1 : 0); // Prevent a userland close killing a kernel pty
200 ret->ClientNode.ImplPtr = ret;
201 ret->ClientNode.Type = &gPTY_NodeType_Client;
202 ret->ClientNode.UID = Threads_GetUID();
203 ret->ClientNode.GID = Threads_GetGID();
204 ret->ClientNode.NumACLs = 1;
205 ret->ClientNode.ACLs = &ret->OwnerRW;
206 // - Owner Read-Write ACL
207 ret->OwnerRW.Ent.ID = Threads_GetUID();
208 ret->OwnerRW.Perm.Perms = -1;
210 if( Name && Name[0] ) {
212 RWLock_Release(&glPTY_NamedPTYs);
216 RWLock_Release(&glPTY_NumPTYs);
222 int PTY_SetAttrib(tPTY *PTY, const struct ptydims *Dims, const struct ptymode *Mode, int WasClient)
226 // (for now) userland terminals can't be put into framebuffer mode
227 if( !PTY->OutputFcn && (Mode->OutputMode & PTYOMODE_BUFFMT) == PTYBUFFMT_FB ) {
232 if( !WasClient && !PTY->OutputFcn )
234 Log_Warning("PTY", "TODO: Need to stop client output until modeset has been ACKed");
235 // Block write until acked
236 // ACK by server doing GETMODE
243 if( PTY->ReqResize && PTY->ReqResize(PTY->OutputHandle, Dims) )
248 else if( !PTY->OutputFcn )
250 // Inform server process... somehow
254 // SIGWINSZ to client
261 void PTY_Close(tPTY *PTY)
266 size_t _rb_write(void *buf, size_t buflen, int *rd, int *wr, const void *data, size_t len)
268 size_t space = (*rd - *wr + buflen - 1) % buflen;
269 ENTER("pbuf ibuflen prd pwr pdata ilen", buf, buflen, rd, wr, data, len);
270 len = MIN(space, len);
271 LOG("space = %i, *rd = %i, *wr = %i", space, *rd, *wr);
272 if(*wr + len >= buflen) {
273 size_t prelen = buflen - *wr;
274 memcpy((char*)buf + *wr, data, prelen);
275 memcpy(buf, (char*)data + prelen, len - prelen);
279 memcpy((char*)buf + *wr, data, len);
285 size_t _rb_read(void *buf, size_t buflen, int *rd, int *wr, void *data, size_t len)
287 size_t space = (*wr - *rd + buflen) % buflen;
288 len = MIN(space, len);
289 if(*rd + len >= buflen) {
290 size_t prelen = buflen - *rd;
291 memcpy(data, (char*)buf + *rd, prelen);
292 memcpy((char*)data + prelen, buf, len - prelen);
296 memcpy(data, (char*)buf + *rd, len);
302 size_t PTY_int_WriteInput(tPTY *PTY, const char *Input, size_t Length)
306 Mutex_Acquire(&PTY->InputMutex);
308 ret = _rb_write(PTY->InputData, INPUT_RINGBUFFER_LEN, &PTY->InputReadPos, &PTY->InputWritePos,
311 Mutex_Release(&PTY->InputMutex);
313 VFS_MarkAvaliable(&PTY->ClientNode, 1);
315 VFS_MarkFull(&PTY->ServerNode, 1);
320 size_t PTY_int_SendInput(tPTY *PTY, const char *Input, size_t Length)
322 size_t ret = 1, print = 1;
324 // Input mode stuff only counts for text output mode
325 // - Any other is Uint32 keypresses
326 if( (PTY->Mode.OutputMode & PTYOMODE_BUFFMT) != PTYBUFFMT_TEXT )
327 return PTY_int_WriteInput(PTY, Input, Length);
328 // If in raw mode, flush directlr
329 if( (PTY->Mode.InputMode & PTYIMODE_RAW) )
330 return PTY_int_WriteInput(PTY, Input, Length);
332 if( PTY->Mode.InputMode & PTYIMODE_CANON )
334 const char char_bs = '\b';
339 // Threads_PostSignalExt(PTY->ClientThreads, SIGINT);
343 PTY_int_WriteInput(PTY, PTY->LineData, PTY->LineLength);
344 PTY->HasHitEOF = (PTY->LineLength == 0);
349 if(PTY->LineLength != 0)
352 case 'w'-'a': // Word erase
353 while(PTY->LineLength != 0 && isalnum(PTY->LineData[--PTY->LineLength]))
354 PTY_WriteClient(&PTY->ClientNode, 0, 1, &char_bs, 0);
357 case 'u'-'a': // Kill
358 while(PTY->LineLength > 0)
359 PTY_WriteClient(&PTY->ClientNode, 0, 1, &char_bs, 0);
369 if(PTY->LineLength == INPUT_LINE_LEN) {
370 PTY_int_WriteInput(PTY, PTY->LineData, PTY->LineLength);
373 PTY->LineData[PTY->LineLength++] = '\n';
374 PTY_int_WriteInput(PTY, PTY->LineData, PTY->LineLength);
377 // TODO: Handle ^[[D and ^[[C for in-line editing, also ^[[1~/^[[4~ (home/end)
382 if(PTY->LineLength == INPUT_LINE_LEN) {
383 PTY_int_WriteInput(PTY, PTY->LineData, PTY->LineLength);
386 PTY->LineData[PTY->LineLength++] = Input[0];
392 ret = PTY_int_WriteInput(PTY, Input, Length);
396 if( PTY->Mode.InputMode & PTYIMODE_ECHO )
398 PTY_WriteClient(&PTY->ClientNode, 0, print, Input, 0);
404 size_t PTY_SendInput(tPTY *PTY, const char *Input, size_t Length)
407 while( ret < Length && !PTY->ClientNode.BufferFull )
409 // TODO: Detect blocking?
410 ret += PTY_int_SendInput(PTY, Input + ret, Length - ret);
416 int PTY_ReadDir(tVFS_Node *Node, int Pos, char Name[FILENAME_MAX])
419 if( Pos < giPTY_NumCount * 2 )
421 RWLock_AcquireRead(&glPTY_NumPTYs);
422 for( pty = gpPTY_FirstNumPTY; pty; pty = pty->Next )
428 RWLock_Release(&glPTY_NumPTYs);
430 else if( Pos < (giPTY_NumCount + giPTY_NamedCount) * 2 )
432 RWLock_AcquireRead(&glPTY_NamedPTYs);
433 for( pty = gpPTY_FirstNamedPTY; pty; pty = pty->Next )
439 RWLock_Release(&glPTY_NamedPTYs);
447 snprintf(Name, FILENAME_MAX, "%s%c", pty->Name, (Pos == 0 ? 'c' : 's'));
449 snprintf(Name, FILENAME_MAX, "%i%c", pty->NumericName, (Pos == 0 ? 'c' : 's'));
453 tVFS_Node *PTY_FindDir(tVFS_Node *Node, const char *Name, Uint Flags)
456 int num = strtol(Name, &end, 10);
458 if( Name[0] == '\0' || Name[1] == '\0' )
461 size_t len = strlen(Name);
462 if( Name[len-1] != 'c' && Name[len-1] != 's' )
464 int isServer = (Name[len-1] != 'c');
467 if( num && (end[0] == 'c' || end[0] == 's') && end[1] == '\0' )
470 RWLock_AcquireRead(&glPTY_NumPTYs);
471 for( tPTY *pty = gpPTY_FirstNumPTY; pty; pty = pty->Next )
473 if( pty->NumericName > num )
475 if( pty->NumericName == num ) {
480 RWLock_Release(&glPTY_NumPTYs);
485 RWLock_AcquireRead(&glPTY_NamedPTYs);
486 for( tPTY *pty = gpPTY_FirstNamedPTY; pty; pty = pty->Next )
488 int cmp = strncmp(pty->Name, Name, len-1);
491 if(cmp == 0 && pty->Name[len-1] == '\0' ) {
496 RWLock_Release(&glPTY_NamedPTYs);
499 return (isServer ? &ret->ServerNode : &ret->ClientNode);
504 tVFS_Node *PTY_MkNod(tVFS_Node *Node, const char *Name, Uint Mode)
506 // zero-length name means a numbered pty has been requested
507 if( Name[0] == '\0' )
509 tPTY *ret = PTY_Create(NULL, NULL, NULL, NULL);
512 return &ret->ServerNode;
515 // Otherwise return a named PTY
516 // TODO: Should the request be for '<name>s' or just '<name>'
518 tPTY *ret = PTY_Create(Name, NULL, NULL, NULL);
521 return &ret->ServerNode;
524 //\! Read from the client's input
525 size_t PTY_ReadClient(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer, Uint Flags)
527 tPTY *pty = Node->ImplPtr;
529 // Read from flushed queue
530 tTime timeout_z = 0, *timeout = (Flags & VFS_IOFLAG_NOBLOCK) ? &timeout_z : NULL;
533 // If server has disconnected, return EIO
534 if( pty->ServerNode.ReferenceCount == 0 ) {
535 //Threads_PostSignal(SIGPIPE);
539 // Wait for data to be ready
540 rv = VFS_SelectNode(Node, VFS_SELECT_READ, timeout, "PTY_ReadClient");
542 errno = (timeout ? EWOULDBLOCK : EINTR);
546 Mutex_Acquire(&pty->InputMutex);
547 Length = _rb_read(pty->InputData, INPUT_RINGBUFFER_LEN, &pty->InputReadPos, &pty->InputWritePos,
549 Mutex_Release(&pty->InputMutex);
551 if(pty->InputReadPos == pty->InputWritePos)
552 VFS_MarkAvaliable(Node, 0);
554 if(Length == 0 && !pty->HasHitEOF) {
562 //\! Write to the client's output
563 size_t PTY_WriteClient(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer, Uint Flags)
565 tPTY *pty = Node->ImplPtr;
567 // If the server has terminated, send SIGPIPE
568 if( pty->ServerNode.ReferenceCount == 0 )
570 //Threads_PostSignal(SIGPIPE);
575 // Write to either FIFO or directly to output function
578 pty->OutputFcn(pty->OutputHandle, Buffer, Length, pty->Mode.OutputMode);
582 // Write to output ringbuffer
583 Length = _rb_write(pty->OutputData, OUTPUT_RINGBUFFER_LEN,
584 &pty->OutputReadPos, &pty->OutputWritePos,
586 VFS_MarkAvaliable(&pty->ServerNode, 1);
592 int PTY_IOCtlClient(tVFS_Node *Node, int ID, void *Data)
594 tPTY *pty = Node->ImplPtr;
595 struct ptymode *mode = Data;
596 struct ptydims *dims = Data;
599 case DRV_IOCTL_TYPE: return DRV_TYPE_TERMINAL;
600 case DRV_IOCTL_IDENT: memcpy(Data, "PTY\0", 4); return 0;
601 case DRV_IOCTL_VER: return 0x100;
602 case DRV_IOCTL_LOOKUP: return 0;
604 case PTY_IOCTL_GETMODE:
605 if( !CheckMem(Data, sizeof(*mode)) ) { errno = EINVAL; return -1; }
608 case PTY_IOCTL_SETMODE:
609 if( !CheckMem(Data, sizeof(*mode)) ) { errno = EINVAL; return -1; }
610 return PTY_SetAttrib(pty, NULL, mode, 1);
611 case PTY_IOCTL_GETDIMS:
612 if( !CheckMem(Data, sizeof(*dims)) ) { errno = EINVAL; return -1; }
615 case PTY_IOCTL_SETDIMS:
616 if( !CheckMem(Data, sizeof(*dims)) ) { errno = EINVAL; return -1; }
617 return PTY_SetAttrib(pty, dims, NULL, 1);
623 void PTY_ReferenceClient(tVFS_Node *Node)
625 Node->ReferenceCount ++;
626 // TODO: Add PID to list of client PIDs
627 Log_Notice("PTY", "TODO: List of client PIDs");
630 void PTY_CloseClient(tVFS_Node *Node)
632 tPTY *pty = Node->ImplPtr;
633 Node->ReferenceCount --;
635 // Remove PID from list
637 // Free structure if this was the last open handle
638 if( Node->ReferenceCount == 0 && pty->ServerNode.ReferenceCount == 0 )
640 // Free the structure! (Should be off the PTY list now)
645 //\! Read from the client's output
646 size_t PTY_ReadServer(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer, Uint Flags)
648 tPTY *pty = Node->ImplPtr;
650 // TODO: Prevent two servers fighting over client's output
653 // Kernel-land PTYs can't be read from userland
657 // Read back from fifo
658 tTime timeout_z = 0, *timeout = (Flags & VFS_IOFLAG_NOBLOCK) ? &timeout_z : NULL;
659 int rv = VFS_SelectNode(Node, VFS_SELECT_READ, timeout, "PTY_ReadServer");
661 errno = (timeout ? EWOULDBLOCK : EINTR);
665 Length = _rb_read(pty->OutputData, OUTPUT_RINGBUFFER_LEN,
666 &pty->OutputReadPos, &pty->OutputWritePos,
668 if( pty->OutputReadPos == pty->OutputWritePos )
669 VFS_MarkAvaliable(Node, 0);
670 VFS_MarkFull(&pty->ClientNode, 0);
675 //\! Write to the client's input
676 size_t PTY_WriteServer(tVFS_Node *Node, off_t Offset, size_t Length, const void *Buffer, Uint Flags)
678 return PTY_SendInput(Node->ImplPtr, Buffer, Length);
681 int PTY_IOCtlServer(tVFS_Node *Node, int ID, void *Data)
683 tPTY *pty = Node->ImplPtr;
684 struct ptymode *mode = Data;
685 struct ptydims *dims = Data;
688 case DRV_IOCTL_TYPE: return DRV_TYPE_TERMINAL;
689 case DRV_IOCTL_IDENT: memcpy(Data, "PTY\0", 4); return 0;
690 case DRV_IOCTL_VER: return 0x100;
691 case DRV_IOCTL_LOOKUP: return 0;
693 case PTY_IOCTL_GETMODE:
694 if( !CheckMem(Data, sizeof(*mode)) ) { errno = EINVAL; return -1; }
696 // ACK client's SETMODE
698 case PTY_IOCTL_SETMODE:
699 if( !CheckMem(Data, sizeof(*mode)) ) { errno = EINVAL; return -1; }
700 PTY_SetAttrib(pty, NULL, mode, 0);
702 case PTY_IOCTL_GETDIMS:
703 if( !CheckMem(Data, sizeof(*dims)) ) { errno = EINVAL; return -1; }
706 case PTY_IOCTL_SETDIMS:
707 if( !CheckMem(Data, sizeof(*dims)) ) { errno = EINVAL; return -1; }
708 PTY_SetAttrib(pty, dims, NULL, 0);
710 case PTY_IOCTL_GETID:
711 return pty->NumericName;
717 void PTY_CloseServer(tVFS_Node *Node)
719 tPTY *pty = Node->ImplPtr;
721 Node->ReferenceCount --;
722 // If reference count == 0, remove from main list
723 if( Node->ReferenceCount > 0 )
726 // Locate on list and remove
729 RWLock_AcquireWrite(&glPTY_NamedPTYs);
730 prev_np = &gpPTY_FirstNamedPTY;
733 RWLock_AcquireWrite(&glPTY_NumPTYs);
734 prev_np = &gpPTY_FirstNumPTY;
737 // Search list until *prev_np is equal to pty
738 for( tPTY *tmp = *prev_np; *prev_np != pty && tmp; prev_np = &tmp->Next, tmp = tmp->Next )
742 if( *prev_np != pty ) {
743 Log_Error("PTY", "PTY %p(%i/%s) not on list at deletion time", pty, pty->NumericName, pty->Name);
746 *prev_np = pty->Next;
751 RWLock_Release(&glPTY_NamedPTYs);
755 RWLock_Release(&glPTY_NumPTYs);
759 // If there are no open children, we can safely free this PTY
760 if( pty->ClientNode.ReferenceCount == 0 )