Class: Ronin::Support::Binary::Memory Private

Inherits:
Object
  • Object
show all
Defined in:
lib/ronin/support/binary/memory.rb

Overview

This class is part of a private API. You should avoid using this class if possible, as it may be removed or be changed in the future.

Base class for all memory objects.

Since:

  • 1.0.0

Direct Known Subclasses

Array, Buffer, CString, Struct

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(size_or_string) ⇒ Memory

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Initializes the memory.

Raises:

  • (ArgumentError) —

    The argument was not an Integer, String, or ByteSlice.

Since:

  • 1.0.0



49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/ronin/support/binary/memory.rb', line 49

def initialize(size_or_string)
  case size_or_string
  when String, ByteSlice
    @string = size_or_string
  when Integer
    size    = size_or_string
    @string = String.new("\0" * size, encoding: Encoding::ASCII_8BIT)
  else
    raise(ArgumentError,"first argument must be either a size (Integer) or a buffer (String): #{size_or_string.inspect}")
  end
end

Instance Attribute Details

#string ⇒ String, ByteSlice (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The underlying String buffer.

Since:

  • 1.0.0



37
38
39
 
# File 'lib/ronin/support/binary/memory.rb', line 37

def string
  @string
end

Instance Method Details

#+(offset) ⇒ ByteSlice

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns a byte slice of the memory at the given offset and for the remainder of the memory.

Examples:

memory+10

Create a buffer starting at offset 10:

buffer = Buffer.new(memory+10)

Create an Array starting at offset 10:

array = Binary::Array.new(:int32_le, memory+10)

Since:

  • 1.0.0



178
179
180
 
# File 'lib/ronin/support/binary/memory.rb', line 178

def +(offset)
  ByteSlice.new(@string, offset: offset, length: size - offset)
end

#[](index_or_range, length = nil) ⇒ String?

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Reads a character or a substring from the underlying buffer at the given index.

Examples:

Reading a single char at the given index:

memory[0]
# => "\x00"

Reading multiple chars at the range of indexes:

memory[0..2]
# => "\x00\x00"

Reading multiple chars at the given index and length:

memory[0,2]
# => "\x00\x00"

Since:

  • 1.0.0



95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/ronin/support/binary/memory.rb', line 95

def [](index_or_range,length=nil)
  case index_or_range
  when Range
    range = index_or_range

    @string[range]
  when Integer
    index  = index_or_range

    case length
    when Integer         then @string[index,length]
    when nil             then @string[index]
    when Float::INFINITY then @string[index,@string.length - index]
    else
      raise(ArgumentError,"invalid length (#{length.inspect}) must be an Integer, nil, or Float::INFINITY")
    end
  else
    raise(ArgumentError,"invalid index (#{index_or_range.inspect}) must be an Integer or a Range")
  end
end

#[]=(index_or_range, length = nil, value) ⇒ String

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Writes a value to the underlying buffer at the given index.

Examples:

Writing a single char:

buffer[0] = 'A'

Writing multiple characters to the given range of indexes:

buffer[0..3] = "AAA"

Since:

  • 1.0.0



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/ronin/support/binary/memory.rb', line 137

def []=(index_or_range,length=nil,value)
  case index_or_range
  when Range
    range = index_or_range

    @string[range] = value
  when Integer
    index  = index_or_range

    case length
    when Integer then @string[index,length] = value
    when nil     then @string[index]        = value
    when Float::INFINITY
      @string[index,@string.length - index] = value
    else
      raise(ArgumentError,"invalid length (#{length.inspect}) must be an Integer, nil, or Float::INFINITY")
    end
  else
    raise(ArgumentError,"invalid index (#{index_or_range.inspect}) must be an Integer or a Range")
  end
end

#byteslice(offset, length = 1) ⇒ ByteSlice

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Creates a new byte slice within the memory.

Since:

  • 1.0.0



194
195
196
 
# File 'lib/ronin/support/binary/memory.rb', line 194

def byteslice(offset,length=1)
  ByteSlice.new(@string, offset: offset, length: length)
end

#clear ⇒ self

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Clears the memory by setting each byte to 0.

Since:

  • 1.0.0



203
204
205
206
207
208
209
 
# File 'lib/ronin/support/binary/memory.rb', line 203

def clear
  (0...@string.bytesize).each do |index|
    @string.setbyte(index,0)
  end

  return self
end

#copy_from(src, count = size) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Copies data from the other memory object into this memory object.

Since:

  • 1.0.0



233
234
235
 
# File 'lib/ronin/support/binary/memory.rb', line 233

def copy_from(src,count=size)
  @string[0,count] = src[0,count]
end

#copy_to(dest, count = size) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Copies data from this memory object into another memory object.

Since:

  • 1.0.0



220
221
222
 
# File 'lib/ronin/support/binary/memory.rb', line 220

def copy_to(dest,count=size)
  dest[0,count] = @string
end

#pack ⇒ String Also known as: to_s, to_str

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Converts the buffer to a String.

Since:

  • 1.0.0



258
259
260
 
# File 'lib/ronin/support/binary/memory.rb', line 258

def pack
  @string.to_s
end

#read_from(io) ⇒ self

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Reads #size bytes from the given IO stream.

Since:

  • 1.0.0



245
246
247
248
249
250
 
# File 'lib/ronin/support/binary/memory.rb', line 245

def read_from(io)
  data = io.read(size)

  @string[0,data.bytesize] = data
  return self
end

#size ⇒ Integer

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The size of the underlying buffer.

Since:

  • 1.0.0



66
67
68
 
# File 'lib/ronin/support/binary/memory.rb', line 66

def size
  @string.bytesize
end