[ruby-talk:8417] Re: RAA-ANN: rbwrap 0.1.0

On Sat, 30 Dec 2000, Kevin Smith wrote:

> Robert Feldt wrote:
> >rbwrap - Creating stand-alone executables from Ruby programs
> >
> >It's inspired by previous discussion on ruby-talk and by the
> >wrapping/freezing utilities of python and tcl.
> 
> Excellent. Having written a prototype to 
> accomplish a similar goal, I'm quite interested 
> in your approach.
> 
Would be great if we can combine our efforts to make a good and genereal
Ruby wrapper.

> >2. copy rbwrap.rb and memunwrapper.c to were you want to wrap exe's
> (snip)
> >Requirements?
> >-------------
> >Windows NT or 2000, Cygwin 1.1.x with gcc compiler, and Ruby 1.6.x.
> 
> Ok. I gather you pack everything into a 
> proprietary format, and unpack it at run-time. I 
> had considered this approach, but had security 
> concerns. It means that the app is writing out 
> files that will then be executed (exe's and/or 
> dll's in Win-speak). I wasn't sure if *nix folks 
> would be offended by that, or if it's perfectly 
> acceptable. (I'd appreciate *nix folks speaking 
> up--I'm a long-time Windows guy who just recently 
> switched).
> 
Yes, I had to do it this way since I:
1, Couldn't find a way to statically link to the dll's
2, Couldn't load the dll's from memory.

We could probably work around 1 by tweaking with mkmf that people use to
compile their extensions. Ideas anyone?

There might be a way to fix 2. There is a program called PEbundle from
Collake Software doing it so it should be possible... Anyone knows how?

> It seems like you could pre-compile your 
> unpacker. The packer could then append all the 
> other pieces to the end of a copy of the unpacker 
> (that's what I had done). It would avoid the 
> requirement that the person doing the packaging 
> has access to a C compiler. Thoughts?
> 
I did this in my first version (not released though). However when you
append to exe files they are not in Win32 PE format so they cannot be
compressed with UPX. In the file DESIGN in the rbwrap package I
discuss some different approaches:

---------EXTRACT FROM FILE DESIGN----------------------------
There are many different ways to create the executable. They can be
classified according to:

* Unwrapper (uw) or embedded interpreter (er) used
* Compile needed (compile) or files appended (append) to unwrapper,
* Which files unwrapped to disc during execution.
	wtdall = All files Written-To-Disc
	wtdext = Extensions Written-To-Disc

rbwrap currently supports:
* uw-append-wtdall - All files are appended to an unwrapping exe. During
  execution they are all written to disc.
    Pros: + No need for compiler => non-power users can wrap
          + Simple
    Cons: - UPX does not work since final exe does not conform to win32
	    PE format
	  - Scripts and extensions written to disc
          - files unwrapped from disc => slower

* uw-compile-wtdall - Wrapped files are inserted into unwrapper source
  code and compiled.
    Pros: + UPX works since output from compiler conforms to win32 PE
            format
          + Faster since files are unwrapped from mem
          + Simple
    Cons: - Compiler needed
          - Scripts and extensions written to disc

but it would be nice in the future to also support:

* er-compile-wtdext - Compiled exe with embedded interpreter. Script
  files need not be wtd and then loaded if require calls are
  intercepted and the corresponding scripts loaded directly from mem.
    Pros: + No need to WTD and then load script files => Faster??
          + No need to find and wrap ruby exe (or dll)
    Cons: - Extensions written to disc

* er-compile-wtdnone - Compiled exe with embedded interpreter and
  in-memory dll redirection. I'm not sure how this is done but
  PEBundle by Collake Software claims to do it so it should be
  possible.
    Pros: + No files written to disc => faster and simpler
    Cons: - Not known how this is implemented

Other ideas are to statically link to the extensions but I'm unsure if
this is supported on any/all platforms?
---------------END OF EXTRACT-------------------------

The "problems" with uw-append-wtdall can be partially overcomed by
upx-compressing prior to appending.

> >rbwrap will likely fail to find dependencies if you dynamically decide
> >what
> >modules to require/load into your program. However, you can explicitly 
> >specify files that rbwrap didn't find. Just list them after your program
> >on the command line.
> 
> My prototype had the same problem. You have a 
> nice solution.
> 
> I'll take a look, but that particular project has 
> fallen a few notches on my to-do list. I would 
> apreciate if you could confirm my beliefs about 
> your approach.
> 
Hope this mail helps.

Happy new year!

Regards,

Robert