netcomlib.pkg

Go to the documentation of this file.

// -- processed by [filterPKG] --
/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2009 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

/*
Network Communication Library
Used with Scol Java server

Bastien Bourineau - september 2009
*/

defcom cMessage = message I S S S S;;

struct NetComm{

  NC_channel (Chn);
  NC_serverName (S);
  NC_serverPort (I);
  NC_script (S);
  NC_env (Env);
  NC_rsaPrivate (S);
  NC_rsaPublic (S);
  NC_rsaServerPublic (S);
  NC_aesServerKey (S);
  NC_roomName (S);
  NC_lUsers ([[I NetUser] r1]);
  NC_userId (I);
  NC_status (I);
  NC_messageBuffer (S);
  NC_roomItems ([[S S] r1]);
  
  NC_cbConnected (fun [NetComm] I);
  NC_cbClosed (fun [NetComm] I);
  NC_cbSConnected (fun [NetComm] I);
  NC_cbSrvMessage (fun [NetComm S S S] I);
  NC_cbUserMessage (fun [NetComm NetUser S S S] I);
  NC_cbGetFile (fun [NetComm NetUser S S S] I);
  NC_cbUserGetItem (fun [NetComm NetUser S S] I);
  NC_cbRoomGetItem (fun [NetComm S S] I);
  NC_cbNewUser (fun [NetComm NetUser] I);
  NC_cbDelUser (fun [NetComm NetUser] I);
  NC_cbUserChangeLogin (fun [NetComm NetUser S] I);
  NC_cbNbUsers (fun [NetComm I] I);
  NC_cbRoomChanged (fun [NetComm S] I
  
  );
};
typedef struct mkNetComm NetComm;


struct NetUser{

  NU_id (I);
  NU_login (S);
  NU_items ([[S S] r1]);
  NU_status (I
  
  );
};
typedef struct mkNetUser NetUser;


typeof lNetCommInst=[[Chn NetComm] r1];

var iComFlagDefault=0;
var iComFlagRSA=1;
var iComFlagAES=2;
var iComFlagBroad=4;
var iComFlagMulti=8;
var iComFlagMultiEnd=16;
var iComFlagFile=32;
var iComFlagPrivate=64;
var iComFlagBroadOthers=128;

var iStatusDisconnected=0;
var iStatusConnected=1;
var iStatusSecurised=2;

var iMaxMessageSize=16384;


isIP(s,i){
if i>=strlen s then 1
 else let nth_char s i-> a in
 if a!='. && (a<'0 || a>'9) then 0
 else isIP s i+1;
}

/* ********************************************************************************************* /
  generate AppID    modify on of the app package or ressource will modify this AppID
/ ********************************************************************************************* */

typeof sAppId=S;

getAppId(scenepath){
let mkAppletGetAppMd5 scenepath -> lmd5 in
  let
    let _envchannel _channel -> env in
    let nil -> lenv in
    (
      while ((_envfirstname env) != nil) do
      (
        set lenv = (_envfirstname env)::lenv;
        set env = _removepkg env;
      );
      lenv;
    )
  -> lenv in
  
  let hexListToBignumList (lcat lmd5 lenv) -> lbig in
  
  let sizelist lmd5 -> size in
  let BigFromInt 0 -> nvalue in
  let 0 -> i in
  (
    while i < size do
    (
      let nth_list lmd5 i -> elem in
      let nth_list lbig i -> big in
        set nvalue = BigAdd nvalue big;
      
      set i = i + 1;
    );
    set sAppId = strmd5 BigToAsc nvalue;
  );
  0;
}


/* ********************************************************************************************* /
  User management
/ ********************************************************************************************* */

netUserGetItemValue(netstr, userstr, item){
if userstr == nil then nil else
    switchstr userstr.NU_items item
  ;
}


netUserSetItemValue(netstr, userstr, item, val){
if userstr == nil then nil else
  let switchstr userstr.NU_items item -> exist in
  if (exist == nil) then
  (
    set userstr.NU_items = [item val]::userstr.NU_items;
    0;
  )
  else  
  let sizelist userstr.NU_items -> size in
  let 0 -> i in
  let nil -> fitem in
  while (i < size) && (fitem == nil) do
  (
    let nth_list userstr.NU_items i -> titem in
    let titem -> [name value] in
    if (strcmpi item name) then nil else
    (
      mutate titem <- [_ val];
      set fitem = titem;
    );
    
    set i = i + 1;
  );
  exec netstr.NC_cbUserGetItem with [netstr userstr item val];
  0;
}


netRoomGetItemValue(netstr, item){
if netstr == nil then nil else
    switchstr netstr.NC_roomItems item
  ;
}


netRoomSetItemValue(netstr, item, val){
if netstr == nil then nil else
  let switchstr netstr.NC_roomItems item -> exist in
  if (exist == nil) then
  (
    set netstr.NC_roomItems = [item val]::netstr.NC_roomItems;
    0;
  )
  else  
  let sizelist netstr.NC_roomItems -> size in
  let 0 -> i in
  let nil -> fitem in
  while (i < size) && (fitem == nil) do
  (
    let nth_list netstr.NC_roomItems i -> titem in
    let titem -> [name value] in
    if (strcmpi item name) then nil else
    (
      mutate titem <- [_ val];
      set fitem = titem;
    );
    
    set i = i + 1;
  );
  exec netstr.NC_cbRoomGetItem with [netstr item val];
  0;
}


netAddUser(netstr, id, login){
let switch netstr.NC_lUsers id -> userstr in
  if userstr != nil then userstr else
  let mkNetUser [id login ["Login" login]::nil 1] -> nuserstr in
  (
    exec netstr.NC_cbNbUsers with [netstr (sizelist netstr.NC_lUsers)];
    set netstr.NC_lUsers = [id nuserstr]::netstr.NC_lUsers;
    exec netstr.NC_cbNewUser with [netstr nuserstr];
    nuserstr;
  );
}


netDelUser(netstr, userstr){
if userstr == nil then nil else
  (
    exec netstr.NC_cbNbUsers with [netstr (sizelist netstr.NC_lUsers)];
    exec netstr.NC_cbDelUser with [netstr userstr];
    set netstr.NC_lUsers = remove_idx_from_list netstr.NC_lUsers userstr.NU_id;
  );
  0;
}


netDelUserById(netstr, id){
let switch netstr.NC_lUsers id -> userstr in
  if userstr == nil then nil else
  (
    exec netstr.NC_cbNbUsers with [netstr (sizelist netstr.NC_lUsers)];
    exec netstr.NC_cbDelUser with [netstr userstr];
    set netstr.NC_lUsers = remove_idx_from_list netstr.NC_lUsers id;
  );
  0;
}


netUserSetLoginById(netstr, id, login){
let switch netstr.NC_lUsers id -> userstr in
  let if userstr == nil then (netAddUser netstr id login) else userstr -> userstr in
  (
    exec netstr.NC_cbUserChangeLogin with [netstr userstr login];
    set userstr.NU_login = login;
    netUserSetItemValue netstr userstr "Login" login;
    userstr;
  );
}


netUserSetLogin(netstr, userstr, login){
if userstr == nil then nil else
  (
    exec netstr.NC_cbUserChangeLogin with [netstr userstr login];
    set userstr.NU_login = login;
    netUserSetItemValue netstr userstr "Login" login;
    userstr;
  );
}


netUserGetLoginById(netstr, id){
let switch netstr.NC_lUsers id -> userstr in
  if userstr == nil then nil else
    userstr.NU_login
  ;
}


netUserGetLogin(userstr){
if userstr == nil then nil else
    userstr.NU_login
  ;
}
  

netUserGetId(userstr){
if userstr == nil then nil else
    userstr.NU_id
  ;
}


netGetUserByLogin(netstr, login){
let nil -> user in
  let sizelist netstr.NC_lUsers -> size in
  let 0 -> i in
  (
    while i < size do
    (
      let nth_list netstr.NC_lUsers i -> [_ iuser] in
        if (!strcmp login iuser.NU_login) then
          set user = iuser
        else nil;
      
      set i = i + 1;
    );
    user;
  );
}


netGetUserById(netstr, id){
switch netstr.NC_lUsers id;
}


netThisId(netstr){
netstr.NC_userId;
}
  

netThisUser(netstr){
switch netstr.NC_lUsers netstr.NC_userId;
}


netThisLogin(netstr){
netUserGetLogin netThisUser netstr;
}


netGetNbUsers(netstr){
sizelist netstr.NC_lUsers;
}


/* ********************************************************************************************* /
  Connection Channel management
/ ********************************************************************************************* */

_connected(){
let switch lNetCommInst _channel -> netstr in
  (
      exec netstr.NC_cbConnected with [netstr];
  );
  0;
}


_closed(){
let switch lNetCommInst _channel -> netstr in
  (
    exec netstr.NC_cbClosed with [netstr];
  );
  0;
}



/* ********************************************************************************************* /
  Callback management
/ ********************************************************************************************* */

netSetCbConnected(netstr, cbfun){
set netstr.NC_cbConnected = cbfun;
  0;
}


netSetCbClosed(netstr, cbfun){
set netstr.NC_cbClosed = cbfun;
  0;
}


netSetCbSConnected(netstr, cbfun){
set netstr.NC_cbSConnected = cbfun;
  0;
}


netSetCbSrvMessage(netstr, cbfun){
set netstr.NC_cbSrvMessage = cbfun;
  0;
}


netSetCbUserMessage(netstr, cbfun){
set netstr.NC_cbUserMessage = cbfun;
  0;
}


netSetCbGetFile(netstr, cbfun){
set netstr.NC_cbGetFile = cbfun;
  0;
}


netSetCbNewUser(netstr, cbfun){
set netstr.NC_cbNewUser = cbfun;
  0;
}


netSetCbDelUser(netstr, cbfun){
set netstr.NC_cbDelUser = cbfun;
  0;
}


netSetCbUserChangeLogin(netstr, cbfun){
set netstr.NC_cbUserChangeLogin = cbfun;
  0;
}


netSetCbUserGetItem(netstr, cbfun){
set netstr.NC_cbUserGetItem = cbfun;
  0;
}


netSetCbRoomGetItem(netstr, cbfun){
set netstr.NC_cbRoomGetItem = cbfun;
  0;
}


netSetCbNbUsers(netstr, cbfun){
set netstr.NC_cbNbUsers = cbfun;
  0;
}
  

netSetCbRoomChanged(netstr, cbfun){
set netstr.NC_cbRoomChanged = cbfun;
  0;
}
  
  
/* ********************************************************************************************* /
  Message management
/ ********************************************************************************************* */

netSendMultiPart(netstr, userstr, flag, cmd, message, arg, pos){
let if flag == nil then iComFlagDefault else flag -> flag in
  let strlen message -> len in
  let substr message pos iMaxMessageSize -> part in
  let if (pos + iMaxMessageSize) >= len then flag|iComFlagMultiEnd else flag|iComFlagMulti -> nflag in
  (
    _on netstr.NC_channel cMessage [nflag (itoa userstr.NU_id) cmd part arg];
    if (pos + iMaxMessageSize) >= len then nil else
      netSendMultiPart netstr userstr flag cmd message arg (pos + iMaxMessageSize);
  );
  0;
}


netSendFile(netstr, userstr, flag, cmd, filename){
let if flag == nil then iComFlagDefault else flag -> flag in
  let strtoweb (_getpack _checkpack filename) -> data in
  if (data == nil) then nil else
  let if userstr == nil then flag|iComFlagBroad else flag|iComFlagPrivate -> flag in
  let if (flag & iComFlagAES) then _AESencryptMessage data netstr.NC_aesServerKey else data -> data in
  let if (flag & iComFlagAES) then _AESencryptMessage filename netstr.NC_aesServerKey else filename -> filename in
  if ((strlen data) > iMaxMessageSize) then
    netSendMultiPart netstr userstr flag|iComFlagFile cmd data filename 0
  else
    _on netstr.NC_channel cMessage [flag|iComFlagFile (itoa userstr.NU_id) cmd data filename];
  0;
}


netGetFile(netstr, userstr, flag, cmd, filename){
let if flag == nil then iComFlagDefault else flag -> flag in
  let if userstr == nil then flag|iComFlagBroadOthers else flag|iComFlagPrivate -> flag in
  let if (flag & iComFlagAES) then _AESencryptMessage cmd netstr.NC_aesServerKey else cmd -> cmd in
  let if (flag & iComFlagAES) then _AESencryptMessage filename netstr.NC_aesServerKey else filename -> filename in
    _on netstr.NC_channel cMessage [flag (itoa userstr.NU_id) "requestFile" cmd filename];
  0;
}


netSendMessageExt(netstr, cmd, message, arg){
let if (netstr.NC_status & iStatusSecurised) then iComFlagAES else iComFlagDefault -> flag in
  let if (netstr.NC_status & iStatusSecurised) then _AESencryptMessage message netstr.NC_aesServerKey else message -> message in
  let if (netstr.NC_status & iStatusSecurised) then _AESencryptMessage arg netstr.NC_aesServerKey else arg -> arg in
  if ((strlen message) > iMaxMessageSize) then
    netSendMultiPart netstr nil flag cmd message arg 0
  else
    _on netstr.NC_channel cMessage [flag nil cmd message arg];
  0;
}


netSendMessage(netstr, cmd, message){
let if (netstr.NC_status & iStatusSecurised) then iComFlagAES else iComFlagDefault -> flag in
  let if (netstr.NC_status & iStatusSecurised) then _AESencryptMessage message netstr.NC_aesServerKey else message -> message in
  if ((strlen message) > iMaxMessageSize) then
    netSendMultiPart netstr nil flag cmd message nil 0
  else
    _on netstr.NC_channel cMessage [flag nil cmd message nil];
  0;
}


netSendBroadMessage(netstr, cmd, message){
let if (netstr.NC_status & iStatusSecurised) then iComFlagAES|iComFlagBroad else iComFlagDefault|iComFlagBroad -> flag in
  let if (netstr.NC_status & iStatusSecurised) then _AESencryptMessage message netstr.NC_aesServerKey else message -> message in
  if ((strlen message) > iMaxMessageSize) then
    netSendMultiPart netstr nil flag cmd message nil 0
  else
    _on netstr.NC_channel cMessage [flag nil cmd message nil];
  0;
}


netUpdateUserItem(netstr, item, val){
let if (netstr.NC_status & iStatusSecurised) then iComFlagAES else iComFlagDefault -> flag in
  let if (netstr.NC_status & iStatusSecurised) then _AESencryptMessage item netstr.NC_aesServerKey else item -> item in
  let if (netstr.NC_status & iStatusSecurised) then _AESencryptMessage val netstr.NC_aesServerKey else val -> val in
  if ((strlen item) > iMaxMessageSize) then
    netSendMultiPart netstr nil flag "setCliItem" item val 0
  else
    _on netstr.NC_channel cMessage [flag nil "setCliItem" item val];
  0;
}


netUpdateRoomItem(netstr, item, val){
let if (netstr.NC_status & iStatusSecurised) then iComFlagAES else iComFlagDefault -> flag in
  let if (netstr.NC_status & iStatusSecurised) then _AESencryptMessage item netstr.NC_aesServerKey else item -> item in
  let if (netstr.NC_status & iStatusSecurised) then _AESencryptMessage val netstr.NC_aesServerKey else val -> val in
  if ((strlen item) > iMaxMessageSize) then
    netSendMultiPart netstr nil flag "setRoomItem" item val 0
  else
    _on netstr.NC_channel cMessage [flag nil "setRoomItem" item val];
  0;
}


netSendRsaMessage(netstr, cmd, message){
let _RSAencryptMessage message netstr.NC_rsaServerPublic -> message in
  if ((strlen message) > iMaxMessageSize) then
    netSendMultiPart netstr nil iComFlagRSA cmd message nil 0
  else
    _on netstr.NC_channel cMessage [iComFlagRSA nil cmd message nil];
  0;
}


netSendPrivateMessage(netstr, userstr, cmd, message){
let if (netstr.NC_status & iStatusSecurised) then iComFlagAES|iComFlagPrivate else iComFlagPrivate -> flag in
  let if (netstr.NC_status & iStatusSecurised) then _AESencryptMessage message netstr.NC_aesServerKey else message -> message in
  if ((strlen message) > iMaxMessageSize) then
    netSendMultiPart netstr userstr flag cmd message nil 0
  else
    _on netstr.NC_channel cMessage [flag (itoa userstr.NU_id) cmd message nil];
  0;
}


netKickUser(netstr, userstr){
_on netstr.NC_channel cMessage [iComFlagPrivate (itoa userstr.NU_id) "kickUser" nil nil];
  0;
}


netCryptMessage(netstr, message, mode){
if (mode & iComFlagRSA) then
    _RSAencryptMessage message netstr.NC_rsaServerPublic
  else
    _AESencryptMessage message netstr.NC_aesServerKey
  ;
}


netUnCryptMessage(netstr, message, mode){
if (mode & iComFlagRSA) then
    _RSAdecryptMessage message netstr.NC_rsaPrivate
  else
    _AESdecryptMessage message netstr.NC_aesServerKey
  ;
}


netFormatMessage(netstr, userstr, message){
let sizelist userstr.NU_items -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list userstr.NU_items i -> [item value] in
      set message = strreplacei message (strcatn "%"::item::"%"::nil) value;
      
    set i = i + 1;
  );
  message;
}


netChannel(netstr){
netstr.NC_channel;
}


netIsConnected(netstr){
if netstr.NC_channel == nil then 0 else 1;
}


netDisconnect(netstr){
let netstr.NC_channel -> chan in
  (
    _killchannel chan;
    set netstr.NC_channel = nil;
    set netstr.NC_status = iStatusDisconnected;
    set lNetCommInst = remove_idx_from_list lNetCommInst chan;
    exec netstr.NC_cbClosed with [netstr];
  );
  0;
}


netCreateExt(server, port, script, env){
let if env == nil then (_envchannel _channel) else env -> env in
  let if (isIP server 0) then server else _gethostbyname server -> server in
    mkNetComm[nil server port script env nil nil nil nil nil nil nil 0 nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil]
  ;
}


netCreate(server, port){
let _envchannel _channel -> env in
  let if (isIP server 0) then server else _gethostbyname server -> server in
    mkNetComm[nil server port nil env nil nil nil nil nil nil nil 0 nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil]
  ;
}


netCreateMinimum(){
let _envchannel _channel -> env in
    mkNetComm[nil nil nil nil env nil nil nil nil nil nil nil 0 nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil]
  ;
}


netConnect(netstr){
if (netstr.NC_status & iStatusConnected) then 1 else
  let 0 -> ret in
  (
    // remove existing users
    set netstr.NC_lUsers = nil;
    
    set netstr.NC_channel = _openchannel strcatn netstr.NC_serverName::":"::(itoa netstr.NC_serverPort)::nil netstr.NC_script netstr.NC_env;
    
    if netstr.NC_channel == nil then nil else
    (
      set netstr.NC_status = iStatusConnected;
      set lNetCommInst = [netstr.NC_channel netstr]::lNetCommInst;
      set ret = 1;
    );
    ret;
  );
}


netReconnect(netstr){
if netstr.NC_channel == nil then nil else
    netDisconnect netstr;
  netConnect netstr;
}


netSetServer(netstr, server, port){
let if (isIP server 0) then server else _gethostbyname server -> server in
  set netstr.NC_serverName = server;
  set netstr.NC_serverPort = port;
  if (netstr.NC_status & iStatusConnected) then
    netReconnect netstr
  else nil;
  
  netstr;
}


netChangeLogin(netstr, login){
netSendMessage netstr "setLogin" login;
  0;
}


netChangeRoom(netstr, room){
set netstr.NC_roomItems = nil;
  netSendMessage netstr "setRoom" room;
  0;
}


/* ********************************************************************************************* /
  Server responses
/ ********************************************************************************************* */

__connectedToServer(cid, clogin, srvpubkey){
let switch lNetCommInst _channel -> netstr in
  let _RSAgetKeyPair 1024 -> [priv pub] in
  (
    set netstr.NC_rsaServerPublic = srvpubkey;
    set netstr.NC_rsaPrivate = priv;
    set netstr.NC_rsaPublic = pub;
    set netstr.NC_userId = atoi cid;
    
    netAddUser netstr atoi cid clogin;
    
    // send client public key to server
    netSendMessageExt netstr "setCliSecure" pub (netCryptMessage netstr sAppId iComFlagRSA);
  );
  0;
}


__srvMessage(mode, cmd, message, arg){
let switch lNetCommInst _channel -> netstr in
  if (mode & iComFlagMulti) then
  (
    set netstr.NC_messageBuffer = strcat netstr.NC_messageBuffer message;
    0;
  )
  else
  let if (mode & iComFlagMultiEnd) then (strcat netstr.NC_messageBuffer message) else message -> message in
  let if (mode & iComFlagRSA) then
        _RSAdecryptMessage message netstr.NC_rsaPrivate
      else if (mode & iComFlagAES) then
        _AESdecryptMessage message netstr.NC_aesServerKey
      else
        message
  -> message in
  let if (mode & iComFlagRSA) then
        _RSAdecryptMessage arg netstr.NC_rsaPrivate
      else if (mode & iComFlagAES) then
        _AESdecryptMessage arg netstr.NC_aesServerKey
      else
        arg
  -> arg in
  (
    set netstr.NC_messageBuffer = nil;
    if (!strcmp cmd "setCryptoAES") then
    (
      set netstr.NC_aesServerKey = message;
      set netstr.NC_status = netstr.NC_status|iStatusSecurised;
      exec netstr.NC_cbSConnected with [netstr];
      0;
    )
    else if (!strcmp cmd "delUser") then
    (
      netDelUserById netstr atoi message;
      0;
    )
    else if (!strcmp cmd "addUser") then
    (
      netAddUser netstr (atoi message) arg;
      0;
    )
    else if (!strcmp cmd "getRoomItem") then
    (
      netRoomSetItemValue netstr message arg;
      0;
    )
    else if (!strcmp cmd "getRoom") then
    (
      set netstr.NC_roomName = message;
      exec netstr.NC_cbRoomChanged with [netstr message];
      0;
    )
    else
    (
      exec netstr.NC_cbSrvMessage with [netstr cmd message arg];
      0;
    );
  );
  0;
}


__usrMessage(mode, from, cmd, message, arg){
let switch lNetCommInst _channel -> netstr in
  let switch netstr.NC_lUsers (atoi from) -> userstr in
  if netstr == nil || userstr == nil then nil else
  if (mode & iComFlagMulti) then
  (
    set netstr.NC_messageBuffer = strcat netstr.NC_messageBuffer message;
    0;
  )
  else
  let if (mode & iComFlagMultiEnd) then (strcat netstr.NC_messageBuffer message) else message -> message in
  let if (mode & iComFlagRSA) then
        _RSAdecryptMessage message netstr.NC_rsaPrivate
      else if (mode & iComFlagAES) then
        _AESdecryptMessage message netstr.NC_aesServerKey
      else
        message
  -> message in
  let if (mode & iComFlagRSA) then
        _RSAdecryptMessage arg netstr.NC_rsaPrivate
      else if (mode & iComFlagAES) then
        _AESdecryptMessage arg netstr.NC_aesServerKey
      else
        arg
  -> arg in
  (
    set netstr.NC_messageBuffer = nil;
    
    if (mode & iComFlagFile) then
    (
      if arg == nil then nil else
      //  _storepack webtostr message arg;
        exec netstr.NC_cbGetFile with [netstr userstr cmd (webtostr message) arg];
      0;
    )
    else if (!strcmp cmd "loginChanged") then
    (
      netUserSetLogin netstr userstr message;
      0;
    )
    else if (!strcmp cmd "getCliItem") then
    (
      netUserSetItemValue netstr userstr message arg;
    )
    else if (!strcmp cmd "requestFile") then
    (
      netSendFile netstr userstr mode message arg;
      0;
    )
    else
    (
      exec netstr.NC_cbUserMessage with [netstr userstr cmd message arg];
      0;
    );
  );
  0;
}
// -- [/filterPKG] --

---