Allow string operators to be disabled

[bopjesvla]

In Erlang's current state, it's impossible to impose memory limits on a process that allows string manipulation. max_heap_size does not help here, since large binaries are stored off-heap.

Most ways to manipulate or dynamically generate strings (string.*, tostring, and perhaps pcall) can already be disabled (#77). This PR introduces a way to disable string concatenation and other future string operators. For reference:

# limiting memory on heap

iex(4)> Process.flag(:max_heap_size, 30000)                                                                                                                                                                         
%{error_logger: true, kill: true, size: 0}                                                                                                                                                               
iex(5)> :luerl.eval("a={}; for i=1,1000000 do a[i] = 5 end")                                                                                                                 
** (EXIT from #PID<0.351.0>) killed                                                                                                                                                                          
                                                                                                                                                                                                             
Interactive Elixir (1.4.1) - press Ctrl+C to exit (type h() ENTER for help)                                                                                                                                  
iex(1)> [error]      Process:          #PID<0.351.0>                                                                                                                                                         
     Context:          maximum heap size reached                                                                                                                                                             
     Max Heap Size:    30000                                                                                                                                                                                 
     Total Heap Size:  96966                                                                                                                                                                                 
     Kill:             true                                                                                                                                                                                  
     Error Logger:     true                                                                                                                                                                                  
     GC Info:          [old_heap_block_size: 75113, heap_block_size: 21916, mbuf_size: 0,                                                                                                                    
 recent_size: 2643, stack_size: 60, old_heap_size: 55675, heap_size: 10895,                                                                                                                                  
 bin_vheap_size: 112, bin_vheap_block_size: 46422, bin_old_vheap_size: 596,                                                                                                                                  
 bin_old_vheap_block_size: 46422]             

# does not work on binaries 
                                                                                                                                                                                                             
iex(1)> Process.flag(:max_heap_size, 30000)                                                                                                                                                                  
%{error_logger: true, kill: true, size: 0}                                                                                                                                                                   
iex(2)> Application.put_env(:luerl, :no_string_ops, false)                                                                                                                                                         
:ok                                                                                                                                                                                                                                 
iex(3)> :luerl.eval("x = 'a'; while true do x = x .. x end")                                                                                                                                              
binary_alloc: Cannot reallocate 1073741855 bytes of memory (of type "binary").                                                                                                                               
                                                                                                                                                                                                             
Crash dump is being written to: erl_crash.dump...done                                                                           

# the solution                                                                                   
                                                                                                                                                                                                             
iex(1)> Process.flag(:max_heap_size, 30000)                                                                                                                                                                          
%{error_logger: true, kill: true, size: 0}                                                                                                                                                                   
iex(2)> Application.put_env(:luerl, :no_string_ops, true)                                                                                                                                                                    
:ok                                                                                                                                                                                                                                     
iex(3)> :luerl.eval("x = 'a' .. 'a'")                                                                                                                                                
{:error,                                                                                              
  {:lua_error, {:forbidden, :concat_op},
  ...
}

[bopjesvla]

Fixed the example.

[bopjesvla]

@rvirding, can you take a look at this? I'd like to give #78 a shot next week, but it would be nice to have some assurance that this project still takes pull requests.

[rvirding]

The idea is interesting but going out and checking the application environment for every concatenation call is a bit too slow. It also depends on the luerl application being loaded which is actually not needed now.

[bopjesvla]

As I recall it, the reason I didn't use erlc macros was that I could not figure out how to configure them in Mix. If this is too slow, I could read the environment variable at compile time.

It also depends on the luerl application being loaded which is actually not needed now.

If the application is not loaded, get_env will return nil, so people will only have to configure the application if they want to use this specific feature.

I will likely get back to this PR in a month, when I might add the option to allow concatenations when the combined byte size does not exceed 64.

[bopjesvla]

I modified the rebar script to also take configuration from the app env. I'd say this is good to go now.

[bopjesvla]

Renamed NO_STRING_OPS to SANDBOX_STRINGS. When this flag is on, string literals and concatenated strings cannot have a byte size larger than 64.

[bopjesvla]

Changed identifier storage from atoms to strings because they are only used as strings and dynamic atom creation is scary. ... still works. When SANDBOX_STRINGS is set, the length of identifiers is limited to 64.

[davydog187]

@bopjesvla do you still have an interest in solving this problem?

Since the PR is stale now, I will plan to close in a week or two unless I hear otherwise