Would this practically work? A theory in work with some sample code I drafted.

[Vlad]

I was thinking, it would be possible to make an addon template of sorts where the addon code itself is tucked into a capsule like a string "[=[ <code> ]=]" and the code surrounding it would handle receiving or serving update requests.

The whole idea is using the addon channel to broadcast the user current version and potentially receive a update from a fellow gamer that has a newer version.

Once the new code is downloaded it's stored in the .toc SavedVariables and the user must reload the UI or relog to load the new code. This way you can update the addon(s) without having to download the new version from a site but rather trust your friends that have updated it manually (or if you know the author he will work as a seed and spread it around the guild and raid/BGs that form).

The flow of information (partial):

1. A>* "uniqueIdent" "1000" -- basic interval broadcast indicating the current version of user A
2. B>A "uniqueIdent" "1001 newhash" -- replies with that B has later version of A's code
3. A>B "uniqueIdent" "newhash" -- confirm and let B know he can send the new code over
4. B>A "uniqueIdent" "chunkOfTheCode248Chars" -- B sends piece by piece over to A
5. <...>

At some point the hash of the string would fit the "newhash" send by B earlier, A knows by then that the code is complete (if the integer grows too large then it means there is something wrong or inconsistent with the code read, hence aborts).

Just a draft I made, by far not usable but just a more visual version of the idea: (also my hash function is down the toilet :P)

-- CONSTANT BLOCK
local function hash(str, hex)
  local m, c = "", 0
  for i = 1, s:len() do
    c = c + (s:sub(i,i):byte() * i)
    if c >= 0xFFFFFF00 then
      m = m..string.format("%X", c)
      c = 0
    end
  end
  if c > 0 then
    m = m..string.format("%X", c)
  end
  c = 0
  local f = m:len()
  f = f/(f > 32 and 16 or 1)
  f = math.ceil(f)
  for i = 1, m:len(), f do
    c = c + (tonumber("0x"..m:sub(i,i+3)) * i)
  end
  return hex and string.format("%X", c) or c
end
 
-- ADDON BLOCK
local addonInfo = {
  WWW = "http://www.google.com",
  NAM = "My Test Addon",
  VER = 1000,
}
 
local aID = addonInfo.NAM:gsub("[^%a%d]", "-")
local preName = "LAName_"..aID
local preCode = "LACode_"..aID -- should be the SavedVariables in the .toc
local preChnk = "LAChnk_"..aID
 
_G[preName] = "My Addon"
_G[preCode] = [=[
 
print("Hello World!")
 
]=]
 
chunck, errno = loadstring(_G["LACode_"..aID], preChnk) -- should load the addon after savedvariables are loaded, otherwise we don't load the new addon at all
print(preCode, chunck, errno, _G[preChnk])
 
-- CONSTANT BLOCK
local upd = CreateFrame("Frame")
upd:RegisterEvent("CHAT_MSG_ADDON")
upd:SetScript("OnEvent", function(upd, event, pre, msg, cha, src)
  if event == "CHAT_MSG_ADDON" then
    if pre == preName then
      local version, newhash = msg:split(" ", 2)
      version = tonumber(version)
      if version and version > addonInfo.VER then
        upd.newcode = ""
        upd.newhash = newhash
        SendAddonMessage(preCode, newhash, cha, src)
      end
    elseif pre == preCode then
      -- NYI (should be sending parts of code to the src/cha)
    elseif pre == preChnk then
      upd.newcode = upd.newcode..msg
      if hash(upd.newcode, 1) == upd.newhash then
        -- done, we got all the data we needed
      end
    end
  end
end)

The huge problem here is actually being able to identify what is safe code and not, for example if you get replies by other addons that say "hey I got version 1001 here" and the hashes they offer are not the same, hence it would indicate someone is a rogue or trying to taint the distribution.

If I update the code on my own I could bump the version build up and fake being the proper update, hence the hashing has to be in some way or have an additional .lua code the author uses to generate some sort of hash or something that can be read and used to compare the incoming versions but not the other way around, I wouldn't be able to edit the code and build without generating some code and putting it in the file, something like the .sig files used by Blizzard to avoid people editing the files.

If by some point we manage to do this would could essentially reduce the need to use sites to update some addons (small once for instance) or addons that someone makes for their guild, the guild members wouldn't have to fetch updates from a site and could use the addon channel to get the new code.

What is your point of view on the idea?

[Foxlit]

Originally Posted by Vladinator What is your point of view on the idea?

It makes for a rather impractical addon distribution method. You're basically limiting yourself to only supporting pure Lua scripts, without any (reasonable) way to handle other types of resources addons may include; and the amount of computation required to ensure safety is unreasonably large.

It'd make more sense to identify just why your addon requires such frequent updates that the traditional "I'll go get an update once in a blue moon" method fails. In some cases, it may make sense for addons to distribute data to older versions -- think bossmods data expressed as some sort of data structure rather than code -- which would lessen the safety requirements as you aren't sharing code.

Finally, you've invented your own hashing function. Never implement your own cryptography unless you know what you're doing. In this case, you're actually looking for the concept of digital signatures, as without some sort of asymmetric secret component, you'll not be able to verify whether an update stems from the author or from a malicious third party.

[Vlad]

You seem like you know something, I tried looking up some hashing and compression classes for LUA that will work with the game, perhaps any ideas on some that are small in length and efficient enough?

I was thinking to apply a system like this mostly for fun, try work on my coding and get some practice with addon communicating with each other.

I had a feeling this would really require a lot of work to accomplish if it were to be a main stream kind of deal, really impractical but perhaps usable in very small communities.

Now this got me thinking of a small addon I could code for me and my friends, simple "plugin" that could be sent and received trough the chat. Practical example where this could come in handy:
Friend: hey Vlad, could you make me an addon that alerts me when I don't got my self buff on?
Vlad: sure, hang on a sec. <coding> <send plugin>
Friend: <receive popup> <accepts> thanks!
Then they could use a simple GUI to delete/enable/disable plugins.
Again this could use of some compression to make the code smaller and require less messages to send.

[Ketho]

Originally Posted by Vladinator Now this got me thinking of a small addon I could code for me and my friends, simple "plugin" that could be sent and received trough the chat.

There is a slightly similar addon, called Bi
maybe you could check it's code out a bit, although it's very outdated (addon comm messages)

[Saiket]

If you only need to manually send scripts to friends, you could try _DevPad. It doesn't do any auto-updating, though.

[sigg]

RDX means Raid Data eXchange

http://www.wowinterface.com/forums/s...ad.php?t=31717

[Vlad]

I've managed to make a small plugin exchange system, in short one can write some mini "addon" (plugin may seem more appropriate term) and they can be easily enabled and disabled while playing.

It uses reusable frames and for now can run code when it is enabled, disabled (to cleanup or prepare) and triggers the code on specific events.
So far it works just fine, no problems sending code to myself.

Only wish I had a compression method for the strings, maybe I should use a library that is made for sending addon messages (usually once that are too big, thus get automatically split into parts). At the moment I split them up myself but no compression so you quickly end up sending 5 addon messages if I have to share: the code around 500 chars + introduction message + end of transmition message + onenable/ondisable/events to monitor message.

In any case you could use this but not for whole addons, would be messy. :P

[Torhal]

There's always LibCompress.

[Vlad]

Torhal, good suggestion!

So far I've managed to make this: http://pastebin.com/embed_iframe.php?i=5BnvYJVW (for the interested)

The second time I make a options UI and must say you learn a lot while practicing. Anyway I know transfers could be improved by filling each message to 248 before sending it, but one step at a time.