Class: GamespyQuery::Socket

198
199
200
201
202
203
204
205
206

# File 'lib/gamespy_query/socket.rb', line 198

def handle_challenge packet
  # Tools.debug{"Received challenge response (#{packet.length}): #{packet.inspect}"}
  need_challenge = !(packet.sub(STR_X0, STR_EMPTY) =~ RX_NO_CHALLENGE)
  if need_challenge
    str = packet.sub(RX_CHALLENGE, STR_EMPTY).gsub(RX_CHALLENGE2, STR_EMPTY).to_i
    challenge_packet = sprintf(STR_BLA, handle_chr(str >> 24), handle_chr(str >> 16), handle_chr(str >> 8), handle_chr(str >> 0))
    self.needs_challenge = challenge_packet
  end
end

169
170
171
172
173
174
175

# File 'lib/gamespy_query/socket.rb', line 169

def handle_exc
  Tools.debug {"Exception: #{self.inspect}"}
  close unless closed?
  self.failed = true

  false
end

119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

# File 'lib/gamespy_query/socket.rb', line 119

def handle_read
  # Tools.debug {"Read: #{self.inspect}, #{self.state}"}

  r = true
  begin
    case self.state
      when STATE_SENT_CHALLENGE
        data = self.recvfrom_nonblock(RECEIVE_SIZE)
        Tools.debug {"Read (1): #{self.inspect}: #{data}"}

        handle_challenge data[0]

        self.state = STATE_RECEIVED_CHALLENGE
      when STATE_SENT_CHALLENGE_RESPONSE, STATE_RECEIVE_DATA
        data = self.recvfrom_nonblock(RECEIVE_SIZE)
        Tools.debug {"Read (3,4): #{self.inspect}: #{data}"}
        self.state = STATE_RECEIVE_DATA

        game_data = data[0]
        Tools.debug {"Received (#{self.data.size + 1}):\n\n#{game_data.inspect}\n\n#{game_data}\n\n"}

        index = handle_splitnum game_data

        self.data[index] = game_data

        if self.data.size >= self.max_packets # OR we received the end-packet and all packets required
          Tools.debug {"Received packet limit: #{self.inspect}"}
          self.state = STATE_READY
          r = false
          close unless closed?
        end
      else
        raise NotInReadState, "NotInReadState, #{self}"
    end
  rescue NotInReadState => e
    r = false
    self.failed = true
    close unless closed?
  rescue => e
    # TODO: Simply raise the exception?
    Tools.log_exception(e)
    self.failed = true
    r = nil
    close unless closed?
  end
  r
end

179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

# File 'lib/gamespy_query/socket.rb', line 179

def handle_splitnum packet
  index = 0
  if packet.sub(STR_GARBAGE, STR_EMPTY)[RX_SPLITNUM]
    splitnum = $1
    flag = splitnum.unpack("C")[0]
    index = (flag & 127).to_i
    last = flag & 0x80 > 0
    # Data could be received out of order, use the "index" id when "last" flag is true, to determine total packet_count
    self.max_packets = index + 1 if last # update the max
    Tools.debug {"Splitnum: #{splitnum.inspect} (#{splitnum}) (#{flag}, #{index}, #{last}) Max: #{self.max_packets}"}
  else
    self.max_packets = 1
  end

  index
end

209

# File 'lib/gamespy_query/socket.rb', line 209

def handle_state; [STATE_INIT, STATE_RECEIVED_CHALLENGE].include? state; end

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

# File 'lib/gamespy_query/socket.rb', line 77

def handle_write
  #Tools.debug {"Write: #{self.inspect}, #{self.state}"}

  r = true
  begin
    case self.state
      when STATE_INIT
        Tools.debug {"Write (0): #{self.inspect}"}
        # Send Challenge request
        self.puts @packet
        self.state = STATE_SENT_CHALLENGE
      when STATE_RECEIVED_CHALLENGE
        Tools.debug {"Write (2): #{self.inspect}"}
        # Send Challenge response
        self.puts self.needs_challenge ? BASE_PACKET + @id_packet + self.needs_challenge + FULL_INFO_PACKET_MP : BASE_PACKET + @id_packet + FULL_INFO_PACKET_MP
        self.state = STATE_SENT_CHALLENGE_RESPONSE
      else
        raise NotInWriteState, "NotInWriteState, #{self}"
    end
  rescue NotInWriteState => e
    r = false
    self.failed = true
    close unless closed?
  rescue => e
    Tools.log_exception e
    self.failed = true
    r = nil
    close unless closed?
  end

=begin
if Time.now - self.stamp > @timeout
  Tools.debug {"TimedOut: #{self.inspect}"}
  self.failed = true
  r = false
  close unless closed?
end
=end
  r
end

214
215
216
217
218
219
220
221
222
223
224
225
226
227

# File 'lib/gamespy_query/socket.rb', line 214

def sync reply = self.fetch
  game_data, key = {}, nil
  return game_data if reply.nil? || reply.empty?

  parser = Parser.new(reply)
  data = parser.parse

  game_data.merge!(data[:game])
  game_data[:players] = Parser.pretty_player_data2(data[:players]).sort {|a, b| a[:name].downcase <=> b[:name].downcase }

  game_data[:ping] = @ping unless @ping.nil?

  game_data
end

74

# File 'lib/gamespy_query/socket.rb', line 74

def valid?; @state == STATE_READY; end