+==========================================================+ | | | Named Pipe extension for Win32 Perl | | | | ----------------------------- | | | | by Dave Roth | | | | | | Copyright (c) 1996-1999 Dave Roth. | | All rights reserved. | | Courtesy of Roth Consulting | | http://www.roth.net/consult/ | | | +==========================================================+ Following in tradition... ******************************************** * * * Use under GNU General Public License * * * * Details can be found at: * * http://www.gnu.org/copyleft/gpl.html * * * ******************************************** ---------------------------------------------------------------- NOTICE: I do not guarantee ANYTHING with this package. If you use it you are doing so AT YOUR OWN RISK! I may or may not support this depending on my time schedule. ---------------------------------------------------------------- BENEFITS What is the deal with this? - This will allow you to create, connect to, read from, write to and manage named pipes on the Win32 platform. - You can peek ahead in the pipe before reading data. - The default buffer size is 512 bytes, this can be altered by the ResizeBuffer(xxx) method. - You may create as many named pipes as you want (uh, well, as many as your resources will allow). - Security can be specified when you create a pipe (by using either Win32::Perms or specifying an absolute Security Descriptor. KNOWN PROBLEMS: What known problems does this thing have? - All pipes are blocking. There are no async callbacks or threads to handle overlapping io. - Currently there is a limit of 256 instances of a named pipe (once a pipe is created you can have 256 client/server connections to that name). - If someone is waiting on a Read() and the other end terminates then you will wait for one REALLY long time! (if anyone has an idea on how I can detect the termination of the other end let me know!) HOW TO INSTALL: - IF you are using Perl 5.005 (either ActivePerl or core with PERL_OBJECT enabled): a) Install via the Perl Package Manager (ppm.pl that comes with Perl 5.005): perl ppm.pl install http://www.roth.net/perl/packages/win32-pipe.ppd - IF you are using the ActiveState version of Win32 Perl: a) Copy the PIPE.PM file into the directory perl\lib\win32\ b) Rename the file PIPE_XXX.PLL to PIPE.PLL c) Make a directory: perl\lib\auto\win32\pipe\ d) Copy the PIPE.PLL file into the directory in step c - IF you are using the core distribution of Win32 Perl: a) Copy the PIPE.PM file into the directory perl\lib\site\win32\ b) Rename the file PIPE_CORE.DLL to PIPE.DLL c) Make a directory: perl\lib\site\auto\win32\PIPE\ d) Copy the PIPE.DLL file into the directory in step c That is it! PARSE EXCEPTIONS: If you are lucky enough to get a parse exception when you use this extension then that means that the particular build of this extension is not compatible with your build of Win32 Perl. What you need to do is download a compatible build of the extension from our FTP site. The way you do this is first discovering your Win32 Perl build by using the following command: perl -v There will be a build number listed. Next download the updated version of this extension for that build number. You will need the one which either matches your build number or is the closest smaller build number. For example there are builds for 307 and 311. If you are using Win32 Perl build 313 you would download the extension built for 311 (since 311 and 313 are compatible). However if you have Win32 Perl build 310 you would download the 307 build (builds 307 - 310 are all compatible). Crazy, eh? I am hoping that the builds will cease to change the way extensions are managed so we don't have this build breaking anymore. :) HOW TO TEST: This package comes equiped with three test files: 1) TEST.BAT 2) TESTSR.PL 3) TESTCL.PL Change to the directory where these three files are and run TEST.BAT. This will run the server and client perl scripts, so two perl windows will appear. You can now enter stuff into the Client window and watch the output on the Server window. This *should* work accross a network (client on machine A and server on machine B). GENERAL USE: This extension gives Win32 Perl the ability to use Named Pipes. Why? Well considering that Win32 Perl does not (yet) have the ability to fork() I could not see what good the pipe(X,Y) was. Besides, where I am an admin I must have several perl daemons running on several NT Servers. It dawned on me one day that if I could pipe all these daemons' output to my workstation (accross the net) then it would much easier to monitor. This was the impetus for an extension using Named Pipes. I think that it is kinda cool. :) To use this extension you can follow these basic steps: First you need to 'use' the pipe extension: use Win32::Pipe; Then you need to create a server side of a named pipe: $Pipe = new Win32::Pipe("My Pipe Name"); or if you are going to connect to pipe that has already been created: $Pipe = new Win32::Pipe("\\\\server\\pipe\\My Pipe Name"); NOTE: The "\\\\server\\pipe\\" is necessary when connecting to an existing pipe! If you are accessing the same machine you could use "\\\\.\\pipe\\" but either way works fine. NOTE 2: You can open the pipe using traditional filehandles such as: open(PIPE, "+> \\\\server\\pipe\\My Pipe Name"); The only problem with this is that you can not use the other Win32::Pipe function to manage this filehandle. You should check to see if $Pipe is indeed defined otherwise there has been an error. Whichever end is the server, it must now wait for a connection... $Result = $Pipe->Connect(); NOTE: The client end does not do this! When the client creates the pipe it has already connected! Now you can read and write data from either end of the pipe: $Data = $Pipe->Read(); $Result = $Pipe->Write("Howdy! This is cool!"); When the server is finished it must disconnect: $Pipe->Disconnect(); Now the server could Connect() again (and wait for another client) or it could destroy the named pipe... $Data->Close(); The client should Close() in order to properly end the session. NULL PIPES: Let's say that you have a client process that needs to connect to a named pipe on a remote machine. This is easy enough to do unless the client is run by the LocalSystem account. This commonly occurs when a service connects to a named pipe. The reason this fails is because the LocalSystem account does not have any credentials to pass accross the net to the remote named pipe. Since no credentials are passed there is no way to authenticate the LocalSystem (since there are not credentials). This can be rectified by adding the named pipe to the list of NULL Sessions. A NULL Session is a named pipe that does not attempt to authenticate connections. Therefore anyone can connect (including remote machine's LocalSystem account) and interact with the pipe. This is done by adding the named pipe to the list found in the Registry key: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\lanmanserver\parameters This key contains a value called "NullSessionPipes" of type REG_MULTI_SZ. The data of this value is a list of UNICODE, null terminated strings. The end of the list is terminated by another UNICODE null (so at the end of the data there will be 4 bytes of 0--terminating null for last string and a null terminating character for the entire array. F U N C T I O N S ================= BufferSize() Returns the size of the instance of the named pipe's buffer. returns: $BufferSize Connect() Tells the named pipe to create an instance of the named pipe and wait until a client connects. returns: TRUE if success FALSE if failure Close() Closes the named pipe. Disconnect() Disconnects (and destroys) the instance of the named pipe from the client. returns: TRUE if success FALSE if failure Error() Returns the last error messages pertaining to the named pipe. If used in context to the package. returns: ($ErrorNumber, $ErrorText) ImpersonateStart() Only the server side of a pipe can call this. The process will impersonatate the client. This means that the scripts security permissions will look like the user who opened the client end of the named pipe. For example: the BILLY runs a script which opens a named pipe. Then a the user JOEL connects to the pipe. If BILLY's script then calls ImpersonateStart() then the script will be allowed to open JOEL's files (as if the script was run by JOEL). ImpersonateStop() Stops impersonating the pipes client. Refer to ImpersonateStart(). new($Name [, $Timeout [, $Type [, $Permissions ] ] ) Creates a named pipe if used in server context or a connection to the specified named pipe if used in client context. $Timeout is optional and is the amount of time to wait for the connection. The time is in milliseconds. $Type can be either: PIPE_TYPE_MESSAGE...Data will move across the pipe as a message of a specific size. PIPE_TYPE_BYTE......Data will move across the pipe as a stream of bytes. Use this type when transfering data that is not always predictable. This is the default state of a newly created pipe. $Permissions is either a Win32::Perms object or a binary Security Descriptor. This will set the permissions on the named pipe. If this parameter is not specified then the pipe will be created with a NULL DACL hence providing FULL CONTROL to Everyone. If the $Name starts with a "\\\\" or a "//" then the pipe will be created as a client and try to connect to the specified server. Otherwise the pipe will be created as a server. returns: TRUE if success FALSE if failure Peek() This will look ahead into the pipe without remove data from the pipe. If nothing is in the pipe then it returns with no data -- there is nothing waiting. If this is successful then the data is returned but not removed hence a call to Read() will return the same data. The number of bytes returned is no greater than the pipes buffer. returns: The data from the pipe without removing that data from the pipe if success undef if failure PeekPipe( $PipeHandle, $Size ) Just like Peek() this will return the data in the pipe without removing the data from the pipe except that this is called as a function, not a method. The first parameter is a Win32 Pipe Handle from any pipe (named or anonymous). The second parameter is the limit of how many bytes are returned. returns: an array: element0......Data from the pipe element1......Number of bytes returned element2......Number of bytes in the pipe that are not returned (due to buffer size) PipeGetInfo() Returns an array of data regarding the pipe. The following is returned: 1) State of Pipe 2) Number of instances the pipe has. 3) Name of user connected as the client. 4) Max number of bytes collected before the pipe sends the data. 5) Max amount of time before data is sent. returns: array if success nothing if failure Read() Reads from the named pipe. returns: data read from the pipe if success undef if failure ResizeBuffer($Size) Sets the instance of the named pipe's buffer to $Size. returns: $BufferSize if success FALSE if failure Transact( $Data ) This is the same as TransactNamedPipe() but for a particular pipe object. TransactNamedPipe( $Pipe, $Data ) Write($Data) Writes $Data to the named pipe. returns: TRUE if success FALSE if failure