Rednet messages being ignored

local connection, err = network.connection.establish( tonumber( response ), "http" )
  if connection then
   for i = 1, 3 do -- for debugging purposes, not any actual application.
	os.log( connection:send( message ) ) -- the log file shows that this does send. (and other computer gets the modem_message event)
	sleep( .5 )
   end
   app.display.alert "Message sent" ( )
  else
   app.display.alert( err ) ( )
  end

if event == "http_connection" then
  local connection = network.connection.get( cid ) -- gets the connection object, cid is event[2] basically
  table.insert( buffer, "connection established with " .. connection:getPeer( ) )
  app.newThread( function( ) -- runs in a seperate coroutine getting all events
   while true do
	local data, err = connection:receive( 1 )
	if data then
	 table.insert( buffer, data ) -- gets 1 message, but not the next 2
	else
	 table.insert( buffer, "error: " .. tostring( err ) )
	 break
	end
   end
  end )
end

  if not self.open then return false, "connection closed" end
  local timer
  if timeout then
   timer = os.startTimer( timeout )
  end
  while true do
   local ev = { coroutine.yield() }
   if ev[1] == "timer" and ev[2] == timer then
	return false, "connection timed out"
   -- elseif ev[1] == "rednet_message" and type( ev[3] ) == "table" and ev[4] == "NovaNetwork" then
   elseif ev[1] == "modem_message" and ev[3] == 2514 and type( ev[5] ) == "table" then
   -- local data = self:decode( ev[3] )
	local data = self:decode( ev[5] ) -- this function logs an "incoming message", which is only seen the first time
	if data then
	 if data == "close" then
	  self.open = false
	  return false, "connection closed"
	 end
	 return data
	end
   end
  end

-- I believe this is the only important line:
rednet.send( target, packet, "NovaNetwork" )

--[[type="class"]]
local threads = { }
Thread.public "environment"
function Thread.public.environment:read( )
return self.env
end
function Thread.public.environment:write( value )
if type( value ) ~= "table" then
  error( "expected table", 3 )
end
self.env = value
end
Thread.public "onException" "function"
Thread.public "onFinish" "function"
Thread.public "doesUpdate" "boolean"
function Thread:Thread( thread )
self.state = "running"
self.thread = thread
self.env = setmetatable( { wait = coroutine.yield, thread = self.public }, { __index = getfenv( ) } )
setfenv( self.thread, setmetatable( { }, { __index = function( _, k ) return self.env[k] end, __newindex = function( _, k, v ) self.env[k] = v end } ) )
self.co = coroutine.create( thread )
table.insert( threads, self.public )
return self.public
end
function Thread.public:pause( )
if self.state == "running" then
  self.state = "paused"
  return true
end
return false
end
function Thread.public:resume( )
if self.state == "paused" then
  self.state = "running"
  return true
end
return false
end
function Thread.public:restart( )
self.co = coroutine.create( self.thread )
self.state = "running"
end
function Thread.public:kill( )
self.state = "stopped"
end
function Thread.public:isRunning( )
return self.state == "running"
end
function Thread.public:isPaused( )
return self.state == "paused"
end
function Thread.public:update( args )
if self.state == "stopped" then
  return false, "finished"
end
if self.state ~= "running" then
  return false, "not running"
end
local ok, data = coroutine.resume( self.co, unpack( args ) )
if not ok then
  self.state = "stopped"
  if type( self.onException ) == "function" then
   pcall( self.onException, self.public, data )
  end
  if self.state == "stopped" then
   return false, "finished"
  end
  return false, "errored"
end
if coroutine.status( self.co ) == "dead" then -- give it a chance to restart
  if type( self.onFinish ) == "function" then
   pcall( self.onFinish, self.public )
  end
end
if coroutine.status( self.co ) == "dead" then
  self.state = "stopped"
  return false, "finished"
end
return true, data
end
function Thread.static.update( args, all )
for i = #threads, 1, -1 do
  local ok, data = threads[i]:update( args )
  if not ok and data == "finished" then
   table.remove( threads, i )
  end
end
end