; --- module fileserver


; --- load dependencies

on *:load:{
  hmakeandhfill file
  setgroups
  ad.updatead fserve
  t.temp 60 noupdatecaching
}
on *:signal:rebuild:{
  startcache
}


; --- unload clean

on *:unload:{
  stopfservesessions
  .timerfserve off
  .timercache off
  .timerschedulestart off
  .timerschedulestop off
  .timerfillallsends off
  hstore file
  hfree -w file
}


; --- groups

on *:signal:setgroups:{
  setgroups
}
alias -l setgroups {
  tokenize 32 $inf(fserve,on)
  setgroup fileserver_fileserver $1
  setgroup fileserver_dccwatch $and($1,$inf(dccwatch,on))
  setgroup fileserver_afind $and($1,$inf(find,on))
  setgroup fileserver_forcesend $and($1,$inf(fserve,forcesend))
  setgroup fileserver_nosendonly $nod($inf(fserve,sendonly))
  setgroup fileserver_onaway $inf(fservecache,onaway)
  setgroup fileserver_responsive $inf(fservecache,responsive)
  setgroup fileserver_grouppools $inf(fservead,grouppools)
}


; --- register toggles

on *:signal:set.dccwatch.on:{ setgroup fileserver_dccwatch $and($inf(fserve,on),$1) }
on *:signal:set.find.on:{ setgroup fileserver_afind $and($inf(fserve,on),$1) }
on *:signal:set.fserve.forcesend:{ setgroup fileserver_forcesend $and($inf(fserve,on),$1) }
on *:signal:set.fserve.sendonly:{ setgroup fileserver_nosendonly $nod($1)
  ad.updatead fserve
}
on *:signal:set.fservecache.onaway:{ setgroup fileserver_onaway $1 }
on *:signal:set.fservecache.responsive:{ setgroup fileserver_responsive $1 }
on *:signal:set.fservead.grouppools:{ setgroup fileserver_grouppools $1 }
on *:signal:set.fserve.on:{
  setgroups
  if (!$1) { stopfservesessions }
}
alias -l stopfservesessions {
  ; !$1-
  var %o = $dat(fservelogin).num | while (%o) {
    fservelogin_close $dat(fservelogin,$dat(fservelogin,%o).itemat).wid
    dec %o
  }
}


; --- feedback signals

on *:signal:hashtables:{ $$1- file }
on *:signal:updateads:{ $$1- fserve }
on *:signal:makechn:{
  $$1- find -1 find on @find/@locator searches
  $$1- fservead -1 fservead on fserve ad
  $$1- trigger $dat(trigger).num fserve on on 0 fserve-trigger-
}


; --- updatepools listener

on *:signal:updatepools:{
  gq.sendonlycheck
}


; --- table close

on *:signal:close.fileserver:{
  checkpools
  ad.updatead fserve
  startcache
}


; --- on start

on *:start:{
  cachecheck
  startcache
}
alias -l cachecheck {
  if ((!$r.temp(noupdatecaching)) && ($inf(fservecache,onstart))) { updatehash }
  d.temp noupdatecaching
}
alias startcache {
  if ($inf(fservecache,expires)) { .timercache -io 0 $calc(3600* $inf(fservecache,expires.hours)) checkcache }
  elseif ($timer(cache)) { .timercache off }
  if ($inf(fserve,schedulestart)) { .timerschedulestart -io $inf(fservedata,schedulestart) 1 1 scheduledfserve start }
  elseif ($timer(schedulestart)) { .timerschedulestart off }
  if ($inf(fserve,schedulestop)) { .timerschedulestop -io $inf(fservedata,schedulestop) 1 1 scheduledfserve stop }
  elseif ($timer(schedulestop)) { .timerschedulestop off }
}


; --- fileserver event groups

#fileserver_forcesend on

on *:connect:{
  .timerfillallsends 1 30 .signal updatepools
}

#fileserver_forcesend end


alias scheduledfserve {
  ; $1 = start|stop
  .timer $+ $ctimer -io 1 180 startcache
  ad.advertise fserve $1
}
alias checkcache {
  if ((!$inf(fservecache,awayonly)) || ($away)) { updatehash }
}


#fileserver_onaway off

; --- update cache on away

on *:signal:away.leaving:{
  if (!$r.temp(updateonaway)) {
    updatehash
  }
  t.temp 180 updateonaway
}

#fileserver_onaway end


; --- fservelogin aliases

alias -l qs { return $dat(fservelogin,$fservelogin_fromip($address)).pool }
alias -l addfservequeue {
  ; $1 = fservelogin, $2- = file + size
  if ($dat(fservelogin,$1).cid !== $cid) { scid $v1 }
  .signal queue fserve $dat(fservelogin,$1).trigger $gettok($1,-1,46) $address $2-
}


; --- fileserver chat administration

on *:signal:chat.waiting.removed:{
  ; $?1 = nick, $?2 = ip, $3 = wid
  if ($timer($+(chat.,$3))) {
    offtimer chat. $+ $3
    if ($fservelogin_fromwid($3)) {
      fservelogin_remove $3
    }
  }
}
on *:signal:chat.waiting.added:{
  ; $?1 = nick, $?2 = ip, $3 = wid
  if ($fservelogin_fromwid($3)) {
    .timerchat. $+ $3 -io 1 180 fservelogin_remove $3
  }
}
on *:signal:chat.active.removed:{
  ; $?1 = nick, $?2 = ip, $3 = wid
  fservelogin_close $3
}
on *:signal:chat.active.added:{
  ; $!1 = nick, $2 = ip, $3 = wid
  offtimer chat. $+ $3
  var %netnick = $fservelogin_fromwid($3)
  if ((%netnick !== $null) && ($dat(fservelogin,%netnick).exists)) {
    if (($fservelogin_fromip($2)) && ($v1 !== %netnick)) {
      var %orig = $v1
      $dat(fservelogin,%orig,$addtok($dat(fservelogin,%orig).otherwids,$3,44)).otherwidsset
      $dat(fservelogin,%netnick).del
    }
    else {
      $dat(fservelogin,%netnick,$2).ipset
    }
  }
  if ($inf(firewall,on)) {
    offtimer $+(con.,$cid,.,$2)
    d.tmp con. $+ $2
    if ($timer($+(firechat.,$cid,.,$2))) {
      .timer $+ $+(firechat.,$cid,.,$2) -e
    }
  }
}
on *:signal:chat.inactive.added:{
  ; $!1 = nick, $2 = ip, $3 = wid
  offtimer chat. $+ $3
  var %netnick = $fservelogin_fromwid($3)
  if ((%netnick !== $null) && ($fservelogin_isuninitialized(%netnick))) {
    var %nick = $gettok(%netnick,-1,46)
    if ($inf(firewall,on)) {
      if ($timer($+(firechat.,$cid,.,$2))) {
        $dat(fservelogin,%netnick).del
        windowclose $2 $3
        return
      }
      if ($r.tmp(con. $+ $2) == again) {
        offtimer $+(con.,$cid,.,$2) | d.tmp con. $+ $2
        statuserror failed to connect to $cborder(%nick) $cbrack($2)
      }
      else {
        if (($timer($+(con.,$cid,.,$2))) && (!$r.tmp(con. $+ $2))) { t.tmp 30 con. $+ $2 | .timercon. $+ $+($cid,.,$2) -e }
        .timerfirechat. $+ $+($cid,.,$2) -io 1 10 retryfservechat $uneval(%nick) $2 $uneval(%netnick) $cid
        secho retrying to chat with $cborder(%nick) $cbrack($2)
        windowclose $2 $3
        return
      }
    }
    fservelogin_remove $3
  }
}
alias retryfservechat {
  ; $1 = nick, $2 = ip, $3 = netnick, $4 = cid
  if ($fservelogin_fromip($2)) {
    if ($v1 !== $3) { $dat(fservelogin,$3).del }
    return
  }
  if ($scid($4) !== $null) { scid $v1 }
  if (($cid == $4) && ($server)) {
    t.tmp 30 con. $+ $2 again
    dccc chat $1-2
  }
  elseif ($dat(fservelogin,$3).exists) {
    $dat(fservelogin,$3).del
  }
}


; --- fserve session initialization

on *:open:=:{
  var %netnick = $fservelogin_fromip($address)
  if (%netnick == $null) { return }
  if (($inf(fserve,on)) && ($fservelogin_isuninitialized(%netnick))) {
    if ($dat(fservelogin,%netnick).cid !== $cid) { scid $v1 }
    if ($inf(fserve,hidechats)) { window -h = $+ $nick }
    fservelogin.add %netnick
    if (($isban(*!*@ $+ $address)) || ($isban($address($gettok(%netnick,-1,46),5)))) {
      .notice $gettok(%netnick,-1,46) $eval($inf(fservemsg,banned),2) $logo
      secho $cborder($nick) is banned on your fserve
      close -mc $nick
      halt
    }
    var %trigger = $dat(fservelogin,%netnick).trigger
    setcloseuptimer %netnick
    $inf(stats,access).++
    setroot
    dofservewelcome
    if (($inf(fserve,showqueue)) && ($inf(top,queued,1))) { mc2 - | mostqueued mc1 }
    if ($ismodule(userstats)) {
      if (($inf(fserve,showsend)) && ($inf(top,sent,1))) { mc2 - | mostsend mc1 }
      if (($inf(fserve,showleech)) && ($inf(top,leeched,1))) { mc2 - | mostleeched mc1 }
      if (($inf(fserve,showuser)) && ($dat(user,%netnick).exists)) { mc2 - | userstats %netnick mc1 }
    }
    if ($inf(fserve,showstats)) { mc2 - | fservestats omc $nick }
    if ($dat(trigger,%trigger).welcome) { welcome $fstream(fservewelcome,$dat(trigger,%trigger).welcome_file).new }
    if (!$r.temp(welcome. $+ $address)) { mc2 - | mc1 $cborder(/) | failq }
  }
}
alias -l fservelogin.add {
  ; $1 = fservelogin
  tokenize 32 $1 $dat(fservelogin,$1).trigger
  $datset(fservelogin,$1,chatnick $nick,starttime $ctime,root $dat(trigger,$2).root,ip $address,pool $dat(trigger,$2).pool)
  fservemsg $1 opened
}
alias -l setcloseuptimer {
  ; $1 = fservelogin
  .timer $+ $dat(fservelogin,$1).ip -o 1 $inf(fservedata,idletime) fservelogin_timeout $dat(fservelogin,$1).wid
}
alias openserv {
  if (($1 isnum 1- $+ $dat(trigger).num) && ($2)) {
    if (!$inf(fserve,on)) { ad.advertise fserve start }
    startserv $1-
  }
  else { error syntax: /openserv [triggernr] <nick> [fulladdress] }
}
alias startserv {
  ; $1 = trigger, $2 = nick, $3 = fulladdress
  if (!$isban($3)) {
    if ($o.now < $o.max) {
      var %netnick = $+($getnet,.,$2)
      if ($fservelogin_isuninitialized(%netnick)) { fservelogin_remove $dat(fservelogin,%netnick).wid }
      if (!$dat(fservelogin,%netnick).exists) {
        $new(%netnick,trigger $1).fservelogin
        dccc chat $2 n/a
      }
      else { gq.nc $2 $eval($inf(fservemsg,doublelogin),2) }
    }
    else { gq.nc $2 $eval($inf(fservemsg,full),2) }
  }
  else { gq.nc $2 $eval($inf(fservemsg,banned),2) }
}


; --- fservelogin handling

alias -l fservelogin_remove {
  ; $1 = wid
  var %wid = $1
  tokenize 32 $fservelogin_fromwid($1)
  if ($1 == $null) { dbout fservelogin_remove invalid wid %wid | return }
  var %ip = $dat(fservelogin,$1).ip
  if (!$fservelogin_isuninitialized($1)) {
    $fstream($r.temp(welcome. $+ %ip)).del
    d.temp welcome. $+ %ip
    d.temp dir_ $+ %ip
    d.temp text_ $+ %ip
    d.temp tips_ $+ %ip
    d.temp tipsshown_ $+ %ip
    offtimer %ip
  }
  elseif ($inf(firewall,on)) {
    offtimer $+(con.,$cid,.,%ip)
    offtimer $+(firechat.,$cid,.,%ip)
    d.tmp $+(con.,%ip)
  }
  var %nick = $gettok($1,-1,46),%otherwids = $dat(fservelogin,$1).otherwids,%o = $numtok(%otherwids,44) | while (%o) {
    windowclose %nick $gettok(%otherwids,%o,44)
    dec %o
  }
  windowclose %nick $dat(fservelogin,$1).wid
  $dat(fservelogin,$1).del
}
alias fservelogin_timeout {
  ; $1 = wid
  var %netnick = $fservelogin_fromwid($1)
  if ((%netnick !== $null) && ($dat(fservelogin,%netnick).exists)) {
    var %chatnick = $dat(fservelogin,%netnick).chatnick
    var %wid = $1
    if ($dat(fservelogin,%netnick).cid !== $cid) { scid $v1 }
    if ($chat(%chatnick,$chatnr(%chatnick,%wid)).status == active) { omc1 %chatnick $bracket(this session timed out) }
    if ($server) { gq.nc $gettok(%netnick,-1,46) $eval($inf(fservemsg,timeout),2) }
    fservemsg %netnick timed out
    fservelogin_remove %wid
  }
}
alias fservelogin_close {
  ; $1 = wid
  var %netnick = $fservelogin_fromwid($1)
  if ((%netnick !== $null) && ($dat(fservelogin,%netnick).exists)) {
    fservemsg %netnick closed
    fservelogin_remove $1
  }
}
alias -l fservelogin_fromwid {
  ; $1 = wid
  return $dat(fservelogin,1,$makepropstok(7,wid $1),[this]).select
}
alias -l fservelogin_fromip {
  ; $1 = ip
  return $dat(fservelogin,1,$makepropstok(7,ip $1),[this]).select
}
alias -l fservelogin_isuninitialized {
  ; $1 = fservelogin
  if (($dat(fservelogin,$1).exists) && (!$dat(fservelogin,$1).starttime)) {
    return 1
  }
}


; --- fserve session status messages

alias -l fservemsg {
  ; $1 = fservelogin, $2- = msg
  if ($dat(fservelogin,$1).cid !== $cid) { scid $v1 }
  secho fileserver session to $cborder($dat(fservelogin,$1).chatnick) $cbrack($atail($gettok($1,-1,46),$dat(fservelogin,$1).ip)) $2-
}
alias -l netnicktoatail {
  ; $1 = netnick
  return $atail($gettok($1,-1,46),$deltok($1,-1,46))
}


; --- fserve welcome

alias -l welcome {
  ; $1 = stream
  var %l = $r.temp(welcome. $+ $address)
  w.temp welcome. $+ $address $1
  if (!$fopen($1)) {
    var %trigger = $dat(fservelogin,$fservelogin_fromip($address)).trigger
    error the fserve session welcome textfile $cborder($dat(trigger,%trigger).welcome_file) from trigger $cborder(%trigger) does not exist
    d.temp welcome. $+ $address
    return
  }
  if (!%l) { mc2 - }
  if ($inf(fserve,stopwelcome)) { var %k = $inf(fservedata,stopwelcome) }
  else { var %k = $calc(1 + $lines($fopen($1).fname)) }
  while ((%k) && (!$or($fopen($1).err,$fopen($1).eof))) {
    if ($fread($1) !== $null) { mc $fillonly($v1) }
    else { mc $chr(160) }
    dec %k
  }
  if ($or($fopen($1).err,$fopen($1).eof)) {
    if (%l) { mc2 - | mc1 $cborder(/) | failq }
    $fstream($1).del
    d.temp welcome. $+ $address
  }
  else {
    mc1 $cborder('C' for more $+ $chr(44) 'S' to stop)
  }
}

alias -l dofservewelcome {
  mc $fservewelcome_firstline
  if ($inf(fservewelcome,secondline).is) { mc $fservewelcome_secondline }
  if ($fservewelcome_thirdline !== $null) { mc1 $v1 }
  if ($fservewelcome_fourthline !== $null) { mc1 $v1 }
  if ($inf(fservewelcome,commands)) { fservewelcome_commands }
}
alias -l fservewelcome_firstline {
  var %author = $const(release,author),%version = $const(release,version)
  return $eval($inf(fservewelcome,firstline),2)
}
alias -l fservewelcome_secondline {
  var %number = $inf(stats,access),%address = $address
  return $eval($inf(fservewelcome,secondline),2)
}
alias -l fservewelcome_thirdline { return $fservewelcome_dccwatch $fservewelcome_instasend $fservewelcome_idletime $fservewelcome_timeout $fservewelcome_mincps $fservewelcome_maxcps }

alias -l fservewelcome_dccwatch { if ($inf(fservewelcome,dccwatch)) { return $boldalize(Dccwatch:) $+ $cbrack($con($inf(dccwatch,on))) } }
alias -l fservewelcome_instasend {
  if ($inf(fservewelcome,instasend)) {
    if (($inf(instasend,on)) && ($dat(queuepool,$qs).instasend)) { return $boldalize(Instasend) max.size: $+ $cbrack($size($dat(queuepool,$qs).instasend_maxbytes)) }
    return $boldalize(Instasend:) $+ $cbrack(off)
  }
}
alias -l fservewelcome_idletime { if ($inf(fservewelcome,idletime)) { return $boldalize(Idletime:) $+ $cbrack($inf(fservedata,idletime) secs) } }
alias -l fservewelcome_timeout { if ($inf(fservewelcome,timeout)) { return $boldalize(Timeout:) $+ $cbrack($inf(fservedata,timeout) secs) } }
alias -l fservewelcome_mincps {
  if ($inf(fservewelcome,mincps)) {
    if (($inf(mincps,on)) && ($dat(queuepool,$qs).mincps_on)) { return $+($inf(fservead,mincps),$chr(58),$cbrack($fserve.mincpslayout($qs))) }
    return $+($inf(fservead,mincps),$chr(58),$cbrack(off))
  }
}
alias -l fservewelcome_maxcps {
  if ($inf(fservewelcome,maxcps)) {
    if ($inf(maxcps,on)) { return $+($inf(fservead,maxcps),$chr(58),$cbrack($ads.maxcps)) }
    return $+($inf(fservead,maxcps),$chr(58),$cbrack(off))
  }
}

alias -l fservewelcome_fourthline { return $fservewelcome_online $fservewelcome_sends $fservewelcome_queues $fservewelcome_usersends $fservewelcome_userqueues $fservewelcome_userpriority }
alias -l fservewelcome_online { if ($inf(fservewelcome,online)) { return O: $+ $cborder($fserve.olayout) } }
alias -l fservewelcome_sends { if ($inf(fservewelcome,sends)) { return S: $+ $cborder($fserve.slayout($qs)) } }
alias -l fservewelcome_queues { if ($inf(fservewelcome,queues)) { return Q: $+ $cborder($fserve.qlayout($qs)) } }
alias -l fservewelcome_usersends { if ($inf(fservewelcome,usersends)) { return $csv(Your Sends,$fserve.yslayout($qs,$nick,$address,$cid)) } }
alias -l fservewelcome_userqueues { if ($inf(fservewelcome,userqueues)) { return $csv(Your Queues,$fserve.yqlayout($qs,$nick,$address,$cid,fserve)) } }
alias -l fservewelcome_userpriority { if ($inf(fservewelcome,userpriority)) { return $csv(Your Priority,$fserve.playout($nick)) } }

alias -l fservewelcome_commands {
  mc1 $boldalize(Commands:) $c(2) $+ cd, clr_fqueues, clr_queue, clr_queues, dir, failq $+ $fservewelcome_optionalcommands(find)
  mc2 get, help, my_queues, pwd, queues, quit $+ $fservewelcome_optionalcommands(sends,stats,time,who)
}
alias -l fservewelcome_optionalcommands {
  ; $!1- = command, ...
  var %ret,%com,%i = 1,%o = $0 | while (%i <= %o) {
    %com = $ [ $+ [ %i ] ]
    if ($inf(fservecommand,%com)) {
      %ret = $+(%ret,$chr(44) %com)
    }
    inc %i
  }
  return %ret
}


; --- dccwatch

#fileserver_dccwatch on

on !*:part:#:{
  if (($aretriggersfor($chan)) && (!$aretriggersleft($chan,$nick))) {
    .signal dccwatch $nick $site $wildsite $event $chan 
  }
}
on *:kick:#:{
  if (($knick !== $me) && ($aretriggersfor($chan)) && (!$aretriggersleft($chan,$knick))) {
    var %wildsite
    if (!$address($knick,5)) { %wildsite = $+(*!*@,$getnet,.,$knick) }
    else { %wildsite = $address($knick,2) }
    .signal dccwatch $knick $deltok(%wildsite,1,64) %wildsite $event $chan
  }
}
on *:quit:{
  .signal dccwatch $nick $site $wildsite $event
}
alias -l aretriggersfor {
  ; $1 = chan
  var %o = $dat(trigger).num | while (%o) {
    if (($dat(trigger,%o).on) && ($ch($dat(trigger,%o).ch,$1).is)) {
      return 1
    }
    dec %o
  }
}
alias -l aretriggersleft {
  ; $1 = chan, $2 = nick
  var %chan,%b,%a = $dat(trigger).num,%o = $comchan($2,0) | while (%o) {
    %chan = $comchan($2,%o)
    if (%chan !== $1) { 
      %b = %a | while (%b) {
        if (($dat(trigger,%b).on) && ($ch($dat(trigger,%b).ch,%chan).is) && ($lev($2,%chan) >= $dat(trigger,%b).lev)) { 
          return 1
        }
        dec %b
      }
    }
    dec %o
  }
}
on *:signal:dccwatch:{
  ; $1 = nick, $2 = site, $3 = wildsite, $4 = event, $?5 = chan
  if (($4 == quit) || (!$timer(dccwatch. $+ $cid $+ . $+ $2))) {
    var %ip = *
    if ($isip($2)) { %ip = $v1 }
    elseif ($gq.nicktoip($1)) { %ip = $v1 }
    var %q = $gq.queueformat($gq.setall($gq.queue.new(*),nick,$1,ip,%ip,network,$getnet))
    if ($od.queue(0,w,%q)) {
      offtimer dccwatch. $+ $cid $+ . $+ $getnet $+ . $+ $1
      .timerdccwatch. $+ $cid $+ . $+ $2 1 $inf(dccwatch,delay.secs) remqueues $1 $3 $4 %q
      if (($5) && ($inf(dccwatch,notice))) {
        .notice $1 $dccwatch_warning($5)
      }
    }
  }
}
alias -l dccwatch_warning {
  ; $1 = channel
  var %chan = $1,%duration = $hourtime($inf(dccwatch,delay.secs))
  return $eval($inf(dccwatch,warning),2)
}
alias -l remqueues {
  ; $1 = nick, $2 = wildsite, $3 = event, $4- = matchpattern
  var %nick
  if ((!$comchan($1,0)) && ($ial($2,0))) { %nick = $gettok($ial($2,1),1,33) }
  else { %nick = $1 }
  if (!$aretriggersleft(n/a,%nick)) {
    aecho removing queues from $cborder($1) because they $iif(($3 == quit),quit irc,are not on any serving channels)
    var %q,%o = $od.queue(0,w,$4-) | while (%o) {
      %q = $od.queue(%o,w,$4-)
      gq.deletepoolqueuenumber $gettok(%q,1,46) $deltok(%q,1,46)
      dec %o
    }
    remsends $1
    .signal updatepools
  }
}

#fileserver_dccwatch end


; --- @find

#fileserver_afind on

on *:text:@find *:#:{ if ((!$inf(fserve,sendonly)) && ($chn(find).getsafe) && ($levchans($lev($nick,$chan),$triggerchan($chan)))) { afind $v1 $2- } }
on *:text:@locator *:#:{ if ((!$inf(fserve,sendonly)) && ($chn(find).getsafe) && ($levchans($lev($nick,$chan),$triggerchan($chan)))) { afind $v1 $2- } }
alias -l triggernumtoroot {
  ; $1 = fservetrigger,...
  var %k,%i = 1,%o = $numtok($1,44) | while (%i <= %o) {
    %k = $instok(%k,$replace($gettok($dat(trigger,$gettok($1,%i,44)).root,1-,92),$chr(32),$chr(63)),0,1)
    inc %i
  }
  return %k
}
alias -l afind {
  ; $1 = triggers, $2- = searchstring
  if (($adqueue($nick).exists) || ($r.tmp(ignore.find) > 1)) { return }
  if ($r.tmp(find.search)) {
    if ($inf(ignore,find.hammering)) { inkt3 $cid $+ .ignore.find $inf(ignore,find.secs) }
    gq.nc $nick $errortag sorry, there's another search in progress
    return
  }
  if ($inf(ignore,find)) { t.tmp $inf(ignore,find.secs) find.search }
  if ($afind_search($triggernumtoroot($1),$2-,gq.nc $nick,$1) !== $null) {
    $adqueue($v1,$nick,$iif(($inf(find,replyasmsg)),msg,notice) $nick).new
  }
}

#fileserver_afind end


alias -l issubsetof {
  ; $1 = path, $2 = roots:C1
  var %mount,%o = $numtok($2,1) | while (%o) {
    %mount = $gettok($2,%o,1)
    if (%mount == $left($1,$len(%mount))) { return %o }
    dec %o
  }
}
alias -l maskpath {
  ; $1 = spacetoqroot, $2 = directory
  return $gettok($replace($2 $+ \,$1 $+ \,/),1-,92)
}
alias -l afindformat {
  ; $1 = dir::bool, $2 = match info, $3 = litmatch
  if ($1) { return $cborder($+($makebold($2,$3),$chr(92))) }
  return $cbrack($makebold($2,$3))
}
alias -l afindlocation {
  ; $1 = dir
  $null($regex(afl,$1-,^\/*([^\:\/]*)(\/|\:)))
  return $+(/,$regml(afl,1))
}
alias -l afind_search {
  ; $1 = roots, $2 = searchstring, $3 = alias, $?4 = triggers
  var %alias = $3,%triggers = $4
  tokenize 32 $1 $remove($2,$chr(47))
  var %litmatch = $remwild($2-)
  if ($len(%litmatch) !isnum 2-) { %alias $errortag search string must be at least 2 characters | return }
  var %dirs = $inf(find,returndirs),%trigger,%subsetof,%n,%max = $iif(((!%triggers) || ($inf(find,allresults))),0,$inf(find,maxresults)),%i = 1,%x = 0,%w = 0
  var %lastloc,%mtok,%nline,%mline,%dir,%q = $queue(1024).new,%wstring = $mkwild($2-),%timeout = 0
  $queue(%q,$bracket($iif((%triggers),@) $+ find) $csv(Searching For,%wstring)).push
  var %ticks
  if ($inf(find,timelimit)) { %ticks = $calc($ticks + $inf(find,maxsearchms)) }
  else { var %ticks = 0 }
  while ((!%timeout) && ((!%max) || (%w < %max)) && ($md.file(%i,%wstring))) {
    %n = $v1
    if ((%ticks) && ($ticks > %ticks)) { $queue(%q,$errortag searching stopped: search time exceeded $cborder($inf(find,maxsearchms) ms)).push | %timeout = 1 | continue }
    %subsetof = $issubsetof(%n,$1)
    if ($gettok(%n,-1,58) isnum) { %dir = 1 }
    else { %dir = 0 }
    if ((!%subsetof) || ((%dir) && (!%dirs))) {
      %n =
      inc %i
      continue
    }
    %trigger = $gettok($1,%subsetof,44)
    %nline = $r.file(%n)
    if (%dir) { %mline = %nline }
    else { %mline = $nosize(%nline) }
    var %o = 1,%m = $wildtok(%mline,%wstring,0,47)
    if ((%m) && ($afindlocation(%n) !== %lastloc)) {
      %lastloc = $v1
      %x = 0
      $queue(%q,$tag matches found in $cborder($lower($qtospace($maskpath(%trigger,%lastloc)))) $iif((%triggers),$csvu($inf(fservead,trigger),$fservead.triggerformat($gettok(%triggers,%subsetof,44))))).push
    }
    while (((!%max) || (%w < %max)) && (%o <= %m)) {
      if ((%ticks) && ($ticks > %ticks)) { $queue(%q,$errortag searching stopped: search time exceeded $cborder($inf(find,maxsearchms) ms)).push | %timeout = 1 | break }
      inc %x | inc %w
      %mtok = $gettok(%nline,$findtok(%mline,$wildtok(%mline,%wstring,%o,47),1,47),47)
      $queue(%q,$c(2) $+ %x $+ : $c(1) $+ $afindformat(%dir,%mtok,%litmatch)).push
      inc %o
    }
    inc %i
  }
  var %msgfound
  if (%w) { %msgfound = $bracket(found $iif((%max == %w),at least) %w match $+ $iif(%w !== 1,es)) }
  elseif ((!%triggers) || (!$inf(find,dontreplyalways))) { %msgfound = $bracket(found no matches) }
  else { $queue(%q).del | return }
  if (%triggers) {
    %msgfound = %msgfound $c(2) $+ on my fserve
    $afind_addfservead(%q,%msgfound)
  }
  else {
    $queue(%q,%msgfound).push
  }
  return %q
}
alias -l afind_addfservead {
  ; $1 = queue, $2 = message in front
  if ($inf(find,noad)) {
    $queue($1,$2 $logo).push
  }
  else {
    var %triggerchan = $triggerchan($chan)
    if ($inf(fservead,split)) {
      $queue($1,$2 $+ : $fserve.ad.split1($nick,%triggerchan)).push
      $queue($1,$fserve.ad.split2($chan,%triggerchan)).push
    }
    else {
      $queue($1,$2 $+ : $fserve.ad.temp($chan,$nick,%triggerchan)).push
    }
  }
}


; --- local fserve cache searches

alias find {
  var %f = $ticks
  if ($len($remwild($1-)) isnum 2-) {
    var %mkwild = $mkwild($1-)
    aecho searching fileserver cache for $cborder(%mkwild)
    var %x,%n,%i = 1
    while ($md.file(%i,%mkwild *)) {
      if ($gettok(%n,1,47) !== $gettok($md.file(%i,%mkwild *),1,47)) { var %x }
      %n = $md.file(%i,%mkwild *)
      if ($gettok(%n,-1,58) isnum) {
        %n =
        inc %i
        continue
      }
      var %o = 1,%m = $wildtok($r.file(%n),%mkwild *,0,47)
      while (%o <= %m) {
        if (%mkwild iswm $lastoff($wildtok($r.file(%n),%mkwild *,%o,47))) {
          if (!%x) { aecho files found in $cborder(/ $+ $iif($left(%n,2) !== //,$gettok($lower($qtospace(%n)),1,47))) }
          inc %x
          aecho $c(2) $+ %x $+ : $c(1) $+ $cbrack($wildtok($r.file(%n),%mkwild *,%o,47))
        }
        inc %o
      }
      inc %i
    }
    aecho $bracket(end of search) $csv(Duration,$calc($ticks - %f) ms)
  }
  else { aecho search string must be atleast 2 characters }
}
alias -l lastoff { tokenize 32 $1- | return $deltok($1-,-1,32) }
alias start {
  var %mkwild = $mkwild($1-),%i = 1,%o = $md.file(0,%mkwild *)
  while (%i <= %o) {
    var %n = $md.file(%i,%mkwild *)
    if (%n) { var %a = $deltok($abspath($chr(47) $+ $qtospace($gettok(%n,1,47)) $+ $chr(92) $+ $wildtok($r.file(%n),%mkwild *,1,47)),-1,32)
      if ($isfile(%a)) { aecho now starting $cborder(%a) | run %a | return }
    }
    inc %i
  }
  error no matching files found
}


; --- triggers

#fileserver_fileserver on

on *:signal:list:{
  ; $1 = chan, $2 = nick, $!3 = wildsite
  if ((!$inf(fserve,sendonly)) && ($listchans($lev($2,$1),$triggerchan($1)))) { fservead.user $v1 $1 .notice $2 }
}
on *:nick:{
  if ($dat(fservelogin,$+($getnet,.,$nick)).exists) {
    $dat(fservelogin,$+($getnet,.,$nick),$+($getnet,.,$newnick)).copy
    $dat(fservelogin,$+($getnet,.,$nick)).del
  }
}
on *:signal:fserve:{
  ; $1 = event, $2 trigger, $3 = nick, $4 = fulladdress, $?5 = chan
  var %chans = $chhh($dat(trigger,$2).ch)
  if (($1 == ctcp) || ($istok(%chans,$5,44))) {
    if ((($1 == ctcp) && ($ctcplevcheck($3,$dat(trigger,$2).lev,%chans))) || (($1 == text) && ($lev($3,$5) >= $dat(trigger,$2).lev))) { startserv $2 $3 $4 }
    else { gq.lowlevelreply $3 $dat(trigger,$2).lev }
  }
}

#fileserver_fileserver end
#fileserver_nosendonly on

on *:signal:fserve:{
  ; $1 = event, $2 trigger, $3 = nick, $!4 = fulladdress, $?5 = chan
  if (($1 == ctcp) || ($istok($chhh($dat(trigger,$2).ch),$5,44))) {
    gq.nc $3 $bracket($inf(fservead,fserveoffline)) $csvn($inf(fservead,offreason),$eval($inf(fservemsg,offline.reason),2))
  }
}
on *:text:*:#:{
  if ($istrigger($1-)) { .signal fserve $event $v1 $nick $fulladdress $chan }
}
ctcp *:*:?:{
  if ($istrigger($1-)) { .signal fserve $event $v1 $nick $fulladdress }
}
alias -l istrigger {
  return $dat(trigger,1,$makepropstok(7,mode $event,trigger $1-,on 1),[this]).select
}

#fileserver_nosendonly end


; --- fserve browsing interface

alias r.file { return $hget(file,$1) }
alias m.file { return $hfind(file,$2-,$1,w) }
alias -l md.file { return $hfind(file,$2-,$1,w).data }
alias -l navigateto {
  ; $1 = path
  tokenize 32 $makevalidpath($1)
  if ($1- == $null) { return }
  if ($left($1-,1) == /) { var %o = $spacetoq($gettok($1-,1-,92)) }
  else {
    var %k = $spacetoq($gettok($1-,1-,92)),%o = $ls
    while ((%o !== /) && ($gettok(%k,1,92) == ..)) { %o = $updir(%o) | %k = $deltok(%k,1,92) }
    if (%k !== $null) { %o = %o $+ $iif(%o !== /,\) $+ %k }
  }
  if ($incach(%o)) { 
    return %o
  }
}
alias -l makevalidpath {
  ; $1 = path
  var %i,%r = /\s*(\\)[\s\\]*/g
  $null($regsub(rdss,$replace($remove($strip($1),$chr(63),$chr(58)),$chr(47),$chr(92)),%r,\1,%i))
  if ($left(%i,1) == $chr(92)) { return $chr(47) $+ $right(%i,-1) }
  return %i
}
alias -l incach {
  tokenize 32 $sl($1-)
  if (($1- == /) || ($issubdirof($qtospace($remove($gettok($1-,-1,92),$chr(47))),$updir($1-)))) { 
    return $true 
  } 
}
alias -l issubdirof {
  ; $1 = subdirectory, $2 = full directory path
  var %subnum = 1 | while ($hget(file,$+($2,:,%subnum)) !== $null) {
    if ($istok($v1,$1,47)) { return 1 }
    inc %subnum
  }
}
alias -l dirup { return $deltok($1-,-1,92) }
alias -l updir { return $iff($dirup($1-),/) }
alias -l getroot { return $spacetoq($dat(fservelogin,$fservelogin_fromip($address)).root) }
alias -l setroot { w.temp dir_ $+ $address $gettok($getroot,1-,92) }
alias -l ls { return $gettok($replace($realdir $+ \,$getroot,/),1-,92) }
alias -l sl { return $gettok($iif(($getroot !== /\),$v1,/) $+ $right($1-,-1),1-,92) }
alias -l realdir { return $r.temp(dir_ $+ $address) }
alias -l dolist { dirlist $realdir | filelist $realdir | mceol }
alias -l setdir { w.temp dir_ $+ $address $lower($sl($1-)) }
alias -l lssc { return $qtospace($r.temp(dir_ $+ $1)) }
alias -l msgdir { mc1 $cborder($qtospace($ls)) }
alias -l msgdne { mc1 $errortag directory does not exist }
alias -l msgfdne { mc1 $errortag file does not exist }
alias -l dirlist {
  if ($ls !== /) { .mc2 0D: .. }
  var %o = 1,%n = 0
  while ($hget(file,$1- $+ : $+ %o)) {
    var %k = $v1,%i = 1,%b = $numtok(%k,47)
    while (%i <= %b) { inc %n | .mc2 %n $+ D: $gettok(%k,%i,47) | inc %i }
    inc %o
  }
}
alias -l filelist {
  var %o = 1,%n = 0
  while ($hget(file,$1- $+ / $+ %o)) {
    var %a,%k = $v1,%i = 1,%b = $numtok(%k,47)
    while (%i <= %b) { inc %n | %a = $gettok(%k,%i,47) | .mc1 %n $+ F: $+ $c(2) $deltok(%a,-1,32) $+(,$gettok(%a,-1,32)) | inc %i }
    inc %o
  }
}

on *:chat:*:{
  var %netnick = $fservelogin_fromip($address)
  if (%netnick == $null) { return }
  if (($timer($address)) && ($dat(fservelogin,%netnick).exists) && ($calc($ctime - $dat(fservelogin,%netnick).starttime) > $inf(fservedata,timeout))) { .timer $+ $address -e | halt }
  if ((!$dat(fservelogin,%netnick).exists) || (!$inf(fserve,on))) { return }
  if ($dat(fservelogin,%netnick).cid !== $cid) { scid $v1 }
  if (($isban(*!*@ $+ $address)) || ($isban($address($gettok(%netnick,-1,46),5)))) {
    .notice $gettok(%netnick,-1,46) $eval($inf(fservemsg,banned),2) $logo
    dbout isban $nick is banned on your fserve
    close -mc $nick
    halt
  }
  if ($r.temp(welcome. $+ $address)) {
    if ($1- == c) { welcome $r.temp(welcome. $+ $address) }
    else { $fstream($r.temp(welcome. $+ $address)).del | d.temp welcome. $+ $address | mc2 - | mc1 $cborder(/) | failq }
    setcloseuptimer %netnick
    return
  }

  if (($inf(fserve,showtips)) && (!$r.temp(tipsshown_ $+ $address))) {
    if (($1- == cd..) || ($1- == cd ..)) {
      w.temp tips_ $+ $address ..
    }
    elseif (($1 == cd) && ($2- !== $null) && ($count($2-,$chr(47),$chr(92)) == 0) && ($navigateto($2-) !== $null)) {
      var %thisdir = $gettok($right($v1,-1),-1,92)
      if ($r.temp(tips_ $+ $address) == $null) { 
        w.temp tips_ $+ $address %thisdir
      }
      else {
        mc1 $bracket(Tip) instead of using two seperate commands $cbrack(cd $qtospace($r.temp(tips_ $+ $address))) and $cbrack(cd $qtospace(%thisdir)) $+ , this fserve also supports cd with multiple directories, as in $cbrack(cd $qtospace($r.temp(tips_ $+ $address) $+ \ $+ %thisdir)) $+ , or using the full path $cbrack(cd $qtospace($navigateto($2-)))
        w.temp tipsshown_ $+ $address 1
      }
    }
    else { d.temp tips_ $+ $address }
  }

  var %text = $ls $1-
  if (%text == $deltok($r.temp(text_ $+ $address),1,32)) { w.temp text_ $+ $address $calc(1 + $gettok($r.temp(text_ $+ $address),1,32)) %text }
  else { w.temp text_ $+ $address 1 %text }
  if ($gettok($r.temp(text_ $+ $address),1,32) >= $inf(fservedata,maxrepeat)) { .notice $gettok(%netnick,-1,46) $eval($inf(fservemsg,repeat),2) $logo | fservelogin_close $dat(fservelogin,%netnick).wid | halt }
  setcloseuptimer %netnick
  if ($1) {
    if (!$ls) { dbout fservelogin %netnick has a null ls | setroot }
    if (($1- == dir) || ($1- == ls)) {
      dolist
    }
    elseif (($1- == cd..) || ($1- == cd ..) || ($1- == 0d)) {
      setdir $updir($ls)
      msgdir
      if ($1- == 0d) { dolist }
    }
    elseif (($1- == cd /) || ($1- == cd)) {
      setroot
      msgdir
    }
    elseif (($1 == cd) && ($2- !== $null)) {
      if (($3- == $null) && ($right($2,1) == d) && ($left($2,-1) isnum 0-)) { mc1 $bracket($null,you don't need to put cd in front of that. just type: $2) | return }
      if ($navigateto($2-) !== $null) { setdir $v1 | msgdir }
      else { msgdne | msgdir }
    }
    elseif (($right($1,1) == d) && ($left($1-,-1) isnum 1-)) {
      var %found,%o = 0,%i = 1,%c = $innt($v1),%d = $m.file(0,$realdir $+ :*)
      while (%i <= %d) {
        if (%c <= $calc(%o + $numtok($r.file($realdir $+ : $+ %i),47))) {
          setdir $ls $+ $iif($ls !== /,\) $+ $lower($spacetoq($gettok($r.file($realdir $+ : $+ %i),$calc(%c - %o),47)))
          msgdir | dolist | %found = $true | break
        }
        inc %o $numtok($r.file($realdir $+ : $+ %i),47)
        inc %i
      }
      if (!%found) { msgdne | msgdir }
    }
    elseif (($right($1,1) == f) && ($left($1-,-1) isnum 1-)) {
      var %found,%o = 0,%i = 1,%c = $innt($v1),%d = $m.file(0,$realdir $+ /*)
      while (%i <= %d) {
        if (%c <= $calc(%o + $numtok($r.file($realdir $+ / $+ %i),47))) {
          addfservequeue %netnick $abspath($qtospace($realdir) $+ $iif($realdir !== /,$chr(92)) $+ $gettok($r.file($realdir $+ / $+ %i),$calc(%c - %o),47))
          %found = $true | break
        }
        inc %o $numtok($r.file($realdir $+ / $+ %i),47)
        inc %i
      }
      if (!%found) { msgfdne | msgdir }
    }
    elseif (($1 == get) && ($2)) {
      if ($3- == $null) && ($right($2,1) == f) && ($left($2,-1) isnum 1-) { mc1 $bracket($null,you don't need to put get in front of that. just type: $2) | return }
      var %found,%i = 1,%d = $m.file(0,$realdir $+ /*)
      while (%i <= %d) {
        if ($wildtok($r.file($realdir $+ / $+ %i),$2- $+ *,0,47)) {
          addfservequeue %netnick $abspath($qtospace($realdir) $+ $iif($realdir !== /,$chr(92)) $+ $wildtok($r.file($realdir $+ / $+ %i),$2- $+ *,1,47))
          %found = $true | break
        }
        inc %i
      }
      if (!%found) { msgfdne | msgdir }
    }
    elseif (($1 == find) || ($1 == search)) {
      if ($inf(fservecommand,find)) {
        if ($afind_search($replace($gettok($dat(fservelogin,%netnick).root,1-,92),$chr(32),$chr(63)),$2-,mc1) !== $null) {
          var %q = $v1 | while (!$queue(%q).isempty) {
            msg = $+ $nick $queue(%q).pop
          }
          :error
          if ($error !== $null) { dbout chat_find $error }
          reseterror
          $queue(%q).del
        }
      }
    }
    elseif ($1- == pwd) {
      msgdir
    }
    elseif (($1 == fq) || ($1 == failq) || ($1 == failqueue)) {
      if ($2 isnum) {
        if ($dat(failqueue,$+($getnet,.,$nick,.,$2)).exists) {
          addfservequeue %netnick $dat(failqueue,$+($getnet,.,$nick,.,$2)).file $size($dat(failqueue,$+($getnet,.,$nick,.,$2)).size)
        }
        else { mc1 $errortag this failqueue number does not exist: $cbrack($2) }
      }
      else { failq 1 }
    }
    elseif (($1- == sends) || ($1- == s)) {
      if ($inf(fservecommand,sends)) {
        $gq.usersends(omc $nick,$qs,$nick,$address,$cid)
      }
    }
    elseif (($1- == queues) || ($1- == q)) {
      $gq.userqueues(omc $nick,$qs,$nick,$address,$getnet)
    }
    elseif (($1- == my_q) || ($1- == my_queues) || ($1- == myq)) {
      var %q = $gq.queuesinuseinpoolforuser($qs,$nick,$address,$cid),%inuse = $gq.queuesinuseforpool($qs)
      mc1 $bracket(Your Queues) $boldalize(You) have $cborder($fserve.yqlayout($qs,$nick,$address,$cid,fserve)) $fserve.qmilayout($qs)
      var %i = 1,%o = 0 | while (%i <= %inuse) {
        if ($gq.queueinpoolisfromuser($qs,$nick,$address,$getnet,%i)) {
          inc %o
          mc2 %o $+ : $c(1) $+ $csv(Queue,%i) $cbrack($gq.fileformat($qs,%i)) $csv(Priority,$dat(q,$qs,%i).priority) $csv(Network,$dat(q,$qs,%i).network) $csv(Age,$duration($calc($ctime - $dat(q,$qs,%i).ctime),2)) $csv(Type,$dat(q,$qs,%i).base)
          if (%o == %q) { break }
        }
        inc %i
      }
      if (%q) { mceol }
    }
    elseif (($1- == clr_fqs) || ($1- == clr_fqueues) || ($1- == clrfqs)) {
      fq.clruser $nick
      mc2 $bracket(removed all your failqueues)
    }
    elseif ($1- == clr_queues) {
      $gq.userclr_queues(omc $nick,$qs,$nick,$address,$getnet,$cid)
    }
    elseif ((($1 == clr_queue) || ($1 == del_q) || ($1 == clr_q)) && ($2 isnum 1-)) {
      if (($2 <= $gq.queuesinuseforpool($qs)) && ($gq.queueinpoolisfromuser($qs,$nick,$address,$getnet,$2))) {
        mc1 removed $cbrack($gq.fileformat($qs,$2)) from your queues
        gq.deletepoolqueuenumber $qs $2
        .signal updatepools
      }
      else { mc1 $errortag this queue does not exist or is not yours, look up your queuenumbers by typing $c(2) $+ myq }
    }
    elseif ($1- == help) {
      mc1 $bracket(UPP file server help menu)
      mc1 cd $cborder(change your current directory $c(1) $+ $cbrack($c(2) $+ cd [directory|/|..]))
      mc1 clr_fqueues $cborder(deletes your failqueueslots, this won't delete your queues $c(1) $+ $cbrack($c(2) $+ same as: clr_fqs|clrfqs))
      mc1 clr_queue $cborder(deletes one of your queues $c(1) $+ $cbrack($c(2) $+ clr_queue|del_q|clr_q <number>))
      mc1 clr_queues $cborder(deletes all your queues)
      mc1 dir $cborder(lists all files and directories in your current directory $c(1) $+ $cbrack($c(2) $+ same as: ls))
      mc1 failq $cborder(lists your failqueues $c(1) $+ $cbrack($c(2) $+ failq|fq|failqueue <failqnumber>))
      if ($inf(fservecommand,find)) { mc1 find $cborder(searches fileserver. wildcards are supported $c(1) $+ $cbrack($c(2) $+ find <filename>) $+ $cbrack(same as: search)) }
      mc1 get $cborder(gets file from the file server $c(1) $+ $cbrack($c(2) $+ get <filename>))
      mc1 help $cborder(displays this help menu)
      mc1 my_queues $cborder(lists your queueslots $c(1) $+ $cbrack($c(2) $+ same as: my_q|myq))
      mc1 pwd $cborder(shows your current directory)
      mc1 queues $cborder(shows the list of waiting queues $c(1) $+ $cbrack($c(2) $+ same as: q))
      mc1 quit $cborder(closes this fserve session $c(1) $+ $cbrack($c(2) $+ same as: exit|bye))
      if ($inf(fservecommand,sends)) { mc1 sends $cborder(shows the list of current sends $c(1) $+ $cbrack($c(2) $+ same as: s)) }
      if ($inf(fservecommand,stats)) { mc1 stats $cborder(shows file server statistics) }
      if ($inf(fservecommand,time)) { mc1 time $cborder(shows when this session times out) }
      if ($inf(fservecommand,who)) { mc1 who $cborder(shows who else is on the file server) }
    }
    elseif (($1- == bye) || ($1- == exit) || ($1- == quit)) {
      mc1 $bracket(bye bye)
      fservelogin_close $dat(fservelogin,%netnick).wid
    }
    elseif ($1- == stats) {
      if ($inf(fservecommand,stats)) {
        if ($inf(top,queued,1)) { mostqueued mc1 | mc2 - }
        if ($ismodule(userstats)) {
          if ($inf(top,sent,1)) { mostsend mc1 | mc2 - }
          if ($inf(top,leeched,1)) { mostleeched mc1 | mc2 - }
          if ($dat(user,%netnick).exists) { userstats %netnick mc1 | mc2 - }
        }
        fservestats mc
      }
    }
    elseif ($1- == time) {
      if ($inf(fservecommand,time)) {
        mc1 this session times out in $cborder($duration($calc($dat(fservelogin,%netnick).starttime + $inf(fservedata,timeout) - $ctime))) or after $cborder($duration($inf(fservedata,idletime))) idling
      }
    }
    elseif ($1- == who) {
      if ($inf(fservecommand,who)) {
        var %nnick,%i = 1,%o = $dat(fservelogin).num
        mc1 there $iif((%o == 2),is $ecborder(1) other user,are $ecborder($calc(%o -1)) other users) online $cbrack(max number of users is $o.max)
        while (%i <= %o) {
          %nnick = $dat(fservelogin,%i).itemat
          if (%nnick !== %netnick) {
            if ($fservelogin_isuninitialized(%nnick)) {
              mc1 user: $+ $cborder($netnicktoatail(%nnick)) $csv(status,connecting...)
            }
            else {
              mc1 user: $+ $cborder($netnicktoatail(%nnick)) ip: $+ $cbrack($dat(fservelogin,%nnick).ip) time remaining: $+ $cborder($duration($calc($dat(fservelogin,%nnick).starttime + $inf(fservedata,timeout) - $ctime))) $csv(directory,$lssc($dat(fservelogin,%nnick).ip))
            }
          }
          inc %i
        }
        if (%o > 1) { mceol }
      }
    }
  }
  halt
}


; --- fserve ad

alias fservead.sayall { fserve.ad }
alias fservead.sayalls { fserve.ad.multi }
alias fserve.ad.multi { scid -at1 fserve.ad }

alias -l fserve.ad {
  if (($server) && ($inf(fserve,on)) && ((!$inf(fservead,iffree)) || (!$allfull)) && ($fserveadchans)) {
    var %chan,%i = 1,%o = 0,%w = $v1,%b = $comchan($me,0)
    while (%i <= %b) {
      %chan = $comchan($me,%i)
      if (($istok(%w,%chan,44)) && ($fserve.removenoadtrigs($triggerchan(%chan)))) {
        var %k = $v1
        inc %o 4
        %chan = $uneval(%chan)
        if ($inf(fservead,split)) {
          .timer 1 %o fservead.msg %chan $+($,fserve.ad.split1,$chr(40),%chan,$chr(44),%k,$chr(41))
          .timer 1 %o fservead.msg %chan $+($,c,$chr(40),1,$chr(41),$chr(32),$,+,$chr(32),$,fserve.ad.split2,$chr(40),%chan,$chr(44),%k,$chr(41))
        }
        else {
          .timer 1 %o fservead.msg %chan $+($,fserve.ad.temp,$chr(40),%chan,$chr(44),%chan,$chr(44),%k,$chr(41))
        }
      }
      inc %i
    }
  }
}
alias fservead.msg {
  ; $1 = channel, $2- = alias
  if ($me ison $1) {
    if ($inf(fservead,strip)) { var %msg = $strip($2-,c) }
    else { var %msg = $stripforchannel($1,$2-) }
    msg $1 %msg
  }
}
alias fservead {
  if ($me ison $1) {
    var %k = $triggerchan($1)
    if (%k) {
      %k = $fserve.removenoadtrigs(%k)
      if (%k) {
        if ($inf(fservead,split)) {
          var %msg1 = $fserve.ad.split1($1,%k)
          var %msg2 = $c(1) $+ $fserve.ad.split2($1,%k)
          if ($inf(fservead,strip)) { %msg1 = $strip(%msg1,c) | %msg2 = $strip(%msg2,c) }
          else { %msg1 = $stripforchannel($1,%msg1) | %msg2 = $stripforchannel($1,%msg2) }
          msg $1 %msg1 | msg $1 %msg2
        }
        else {
          msg $1 $stripforchannel($1,$fserve.ad.temp($1,$1,%k))
        }
      }
      elseif ($innput(notriggers)) { dopen fileserver | did -fu fileserver 66 }
    }
    else { dbout fservead no triggers for channel :: $1- }
  }
  else { error fservead you're not on channel $ecborder($1) }
}
alias -l fservead.user {
  ; $1 = triggers, $2 = channel, $3- = alias
  if ($inf(fservead,split)) {
    $3- $iif($inf(fservead,strip),$strip($fserve.ad.split1($4,$1),c),$fserve.ad.split1($4,$1))
    $3- $iif($inf(fservead,strip),$strip($fserve.ad.split2($2,$1),c),$c(1) $+ $fserve.ad.split2($2,$1))
  }
  else { $3- $fserve.ad.temp($2,$4,$1) }
}
alias fserve.ad.temp {
  ; $1 = channel, $2 = target, $3- = triggers
  tokenize 32 $1-2 $replace($3-,$chr(32),$chr(44))
  if ($inf(fservead,strip)) {
    return $strip($fserve.ad.split1($2,$3) $fserve.ad.split2($1,$3),c)
  }
  return $fserve.ad.split1($2,$3) $fserve.ad.split2($1,$3)
}
alias fserve.ad.split1 {
  ; $1 = nick/target, $2- = triggers
  tokenize 32 $1 $replace($2-,$chr(32),$chr(44))
  return $bracket($inf(fservead,fserveonline)) $fserve.ad.running $fserve.ad.triggers($2) $fserve.ad.maxcps $&
    $fserve.ad.mincps($2) $fserve.ad.nextsend($2) $fserve.ad.upstream $fserve.ad.downstream $fserve.ad.bandwidth $&
    $fserve.ad.firewall($1) $fserve.ad.splitend
}
alias fserve.ad.split2 {
  ; $1 = channel, $2- = triggers
  tokenize 32 $1 $replace($2-,$chr(32),$chr(44))
  return $fserve.ad.access $fserve.ad.snagged $fserve.ad.record.cps $&
    $iif($inf(fservead,short),$fserve.ad.short($2),$fserve.ad.on $fserve.ad.sends($2) $fserve.ad.queues($2)) $&
    $fserve.ad.onserver($1) $fserve.ad.new($1) $fserve.ad.note($1) $&
    $logo
}
alias -l fserve.ad.splitend { if ($inf(fservead,split)) { return $eval($inf(fservead,continue),2) } }
alias -l fserve.ad.triggers { return $csvu($inf(fservead,trigger) $+ $iif(($numtok($1,44) !== 1),s),$gettriggers($1)) }
alias -l fserve.ad.running { if ($inf(fservead,running).is) { return $csv($inf(fservead,running),$upptime) } }
alias -l fserve.ad.mincps { if (($inf(fservead,mincps).is) && ($inf(mincps,on))) { return $csv($inf(fservead,mincps),$fserve.mincps($1)) } }
alias -l fserve.ad.maxcps { if (($inf(fservead,maxcps).is) && ($inf(maxcps,on))) { return $csv($inf(fservead,maxcps),$ads.maxcps) } }
alias -l fserve.ad.record.cps { if ($inf(fservead,recordcps).is) { return $csv($inf(fservead,recordcps),$size($inf(stats,record.cps)) $+ /s by $inf(stats,record.cps.nick)) } }
alias -l fserve.ad.on { if ($inf(fservead,online).is) { return $csv($inf(fservead,online),$fserve.olayout) } }
alias -l fserve.ad.sends { if ($inf(fservead,sends).is) { return $csv($inf(fservead,sends),$fserve.sends($1)) } }
alias -l fserve.ad.queues { if ($inf(fservead,queues).is) { return $csv($inf(fservead,queues),$fserve.queues($1)) } }
alias -l fserve.ad.access { if ($inf(fservead,accessed).is) { tokenize 32 $inf(stats,access) | return $csv($inf(fservead,accessed),$1 $iif(($1 !== 1),$inf(fservead,accessed.ord2),$inf(fservead,accessed.ord1))) } }
alias -l fserve.ad.snagged { if ($inf(fservead,snagged).is) { return $csv($inf(fservead,snagged),$size($inf(stats,send.bytes)) in $inf(stats,send.total) files) } }
alias -l fserve.ad.upstream { if ($inf(fservead,upstream).is) { return $csv($inf(fservead,upstream),$ads.upstream) } }
alias -l fserve.ad.downstream { if ($inf(fservead,downstream).is) { return $csv($inf(fservead,downstream),$ads.downstream) } }
alias -l fserve.ad.bandwidth { if ($inf(fservead,bandwidth).is) { return $csv($inf(fservead,bandwidth),$ads.bandwidth) } }
alias -l fserve.ad.note { if ($inf(fservead,note).is) { return $csv($inf(fservead,note),$fserve.ad.networkmsg(note,$1)) } }
alias -l fserve.ad.onserver { if ($inf(fservead,onserver).is) { return $csv($inf(fservead,onserver),$fserve.ad.networkmsg(onserver,$1)) } }
alias -l fserve.ad.new { if ($inf(fservead,new).is) { return $csv($inf(fservead,new),$fserve.ad.networkmsg(new,$1)) } }
alias -l fserve.ad.firewall { if (($inf(firewall,note.ad).is) && ($inf(firewall,on))) { return $firewalladnote($1) } }
alias -l fserve.ad.nextsend { if ($inf(fservead,nextsend).is) { return $csv($inf(fservead,nextsend),$ads.nextsend($fservetriggers2pools($1))) } }
alias -l fservetriggers2pools {
  ; $1 = trigger,...
  var %k,%o = $numtok($1,44) | while (%o) {
    %k = $addtok(%k,$dat(trigger,$gettok($1,%o,44)).pool,44)
    dec %o
  }
  return %k
}
alias -l fserve.ad.short {
  var %r
  if ($inf(fservead,online).is) { %r = $boldalize(O:) $+ $cborder($fserve.olayout) }
  if ($inf(fservead,sends).is) { %r = %r $boldalize(S:) $+ $cborder($fserve.sends($1)) }
  if ($inf(fservead,queues).is) { %r = %r $boldalize(Q:) $+ $cborder($fserve.queues($1)) }
  return %r
}
alias -l fserve.ad.networkmsg {
  ; $1 = note|new|onserver, $2 = target
  if ($inf(fservead,networkmsgs)) {
    var %net = $fserve.ad.networkmsg.getnetchan($getnet,$2)
    if (($dat(fservenetwork,%net).exists) && ($dat(fservenetwork,%net).use_ [ $+ [ $1 ] ] )) {
      return $dat(fservenetwork,%net). [ $+ [ $1 ] ]
    }
  }
  return $inf(fservedata,$1)
}
alias -l fserve.ad.networkmsg.getnetchan {
  ; $1 = network, $2 = channel
  if ($dat(fservenetwork,$+($1,.,$2)).exists) {
    return $+($1,.,$2)
  }
  return $1
}


; --- fileserver group pool information

#fileserver_grouppools off

alias fserve.sends {
  var %pools,%pool,%i = 1,%o = $numtok($1,44) | while (%i <= %o) { 
    %pool = $dat(trigger,$gettok($1,%i,44)).pool
    %pools = $addtok(%pools,%pool,44)
    set -l %pool_ [ $+ [ %pool ] ] $addtok( %pool_ [ $+ [ %pool ] ] ,$gettok($1,%i,44),44)
    inc %i 
  }
  %i = 1
  %o = $numtok(%pools,44)
  if (%o == 1) { 
    return $fserve.slayout(%pools)
  }
  var %k
  while (%i <= %o) {
    %pool = $gettok(%pools,%i,44)
    %k = %k $iif((%k),&) %pool_ [ $+ [ %pool ] ] $+ $chr(58) $+ $fserve.slayout(%pool)
    inc %i
  }
  return %k
}
alias fserve.queues {
  var %pools,%pool,%i = 1,%o = $numtok($1,44) | while (%i <= %o) { 
    %pool = $dat(trigger,$gettok($1,%i,44)).pool
    %pools = $addtok(%pools,%pool,44)
    set -l %pool_ [ $+ [ %pool ] ] $addtok( %pool_ [ $+ [ %pool ] ] ,$gettok($1,%i,44),44)
    inc %i 
  }
  %i = 1
  %o = $numtok(%pools,44)
  if (%o == 1) { 
    return $fserve.qlayout(%pools)
  }
  var %k
  while (%i <= %o) {
    %pool = $gettok(%pools,%i,44)
    %k = %k $iif((%k),&) %pool_ [ $+ [ %pool ] ] $+ $chr(58) $+ $fserve.qlayout(%pool)
    inc %i
  }
  return %k
}
alias -l fserve.mincps {
  var %pools,%pool,%i = 1,%o = $numtok($1,44) | while (%i <= %o) { 
    %pool = $dat(trigger,$gettok($1,%i,44)).pool
    %pools = $addtok(%pools,%pool,44)
    set -l %pool_ [ $+ [ %pool ] ] $addtok( %pool_ [ $+ [ %pool ] ] ,$gettok($1,%i,44),44)
    inc %i 
  }
  %i = 1
  %o = $numtok(%pools,44)
  if (%o == 1) { 
    return $fserve.mincpslayout(%pools)
  }
  var %k
  while (%i <= %o) {
    %pool = $gettok(%pools,%i,44)
    %k = %k $iif((%k),&) %pool_ [ $+ [ %pool ] ] $+ $chr(58) $+ $fserve.mincpslayout(%pool)
    inc %i
  }
  return %k
}

#fileserver_grouppools end

alias fserve.sends {
  var %i = $poollist($1)
  if ($numtok(%i,44) == 1) { return $fserve.slayout(%i) }
  else { var %i = 1,%k,%o = $numtok($1,44) | while (%i <= %o) { %k = %k $iif(%k,&) $fserve.slayout($dat(trigger,$gettok($1,%i,44)).pool) | inc %i } | return %k }
}
alias fserve.queues {
  var %i = $poollist($1)
  if ($numtok(%i,44) == 1) { return $fserve.qlayout(%i) }
  else { var %i = 1,%k,%o = $numtok($1,44) | while (%i <= %o) { %k = %k $iif(%k,&) $fserve.qlayout($dat(trigger,$gettok($1,%i,44)).pool) | inc %i } | return %k }
}
alias -l fserve.mincps {
  var %i = $poollist($1)
  if ($numtok(%i,44) == 1) { if ($dat(queuepool,%i).mincps_on) { return $fserve.mincpslayout(%i) } }
  else { var %i = 1,%k,%o = $numtok($1,44) | while (%i <= %o) { %k = %k $iif(%k,&) $fserve.mincpslayout($dat(trigger,$gettok($1,%i,44)).pool) | inc %i } | return %k }
}

alias -l o.max { return $inf(fservedata,maxonline) }
alias -l o.now { return $dat(fservelogin).num }


; --- finding trigger channels

alias -l gettriggers {
  var %a,%i = 1,%k,%o = $numtok($1,44) | while (%i <= %o) {
    %a = $gettok($1,%i,44)
    %k = $iif(%k,$v1 $eval($inf(fservead,separator),2)) $fservead.triggerformat(%a)
    inc %i
  }
  return %k
}
alias -l fservead.triggerformat {
  ; $1 = triggernum
  var %msg
  if (($inf(firewall,on)) && ($inf(fservead,firetriggers))) {
    %msg = //dccserver $rc(fservead,dccserverflags) on $inf(firewall,port) $chr(124)
    if ($dat(trigger,$1).mode == ctcp) { %msg = %msg ctcp $me }
    else { %msg = %msg say }
  }
  elseif ($dat(trigger,$1).mode == ctcp) { %msg = /ctcp $me }
  return %msg $dat(trigger,$1).trigger
}
alias -l fserve.removenoadtrigs { var %k,%i = 1,%o = $numtok($1,44) | while (%i <= %o) { if ($dat(trigger,$gettok($1,%i,44)).ad) { %k = $addtok(%k,$gettok($1,%i,44),44) } | inc %i } | return %k }
alias -l fserveadchans {
  var %i = 1,%k,%o = $dat(trigger).num | while (%i <= %o) {
    if (($dat(trigger,%i).on) && ($dat(trigger,%i).ad)) { %k = $tokadd(%k,$chhh($dat(trigger,%i).ch),44) }
    inc %i
  }
  %k = $tokand(%k,$chhh($inf(fservead,ch)),44)
  return %k
}
alias -l listchans { var %a,%i = 1,%k,%o = $numtok($2,44) | while (%i <= %o) { %a = $gettok($2,%i,44) | if ($1 >= $dat(trigger,%a).list) { %k = $addtok(%k,%a,44) } | inc %i } | return %k }
alias -l levchans { var %a,%i = 1,%k,%o = $numtok($2,44) | while (%i <= %o) { %a = $gettok($2,%i,44) | if ($1 >= $dat(trigger,%a).lev) { %k = $addtok(%k,%a,44) } | inc %i } | return %k }
alias triggerchan { var %i = 1,%k,%o = $dat(trigger).num | while (%i <= %o) { if (($dat(trigger,%i).on) && ($ch($dat(trigger,%i).ch,$1).is)) { %k = $addtok(%k,%i,44) } | inc %i } | return %k }
alias trigs { var %i = 1,%k,%o = $dat(trigger).num | while (%i <= %o) { if ($dat(trigger,%i).on) { %k = $addtok(%k,%i,44) } | inc %i } | return %k }

alias -l fserve.olayout { return $+($o.now,/,$o.max) }
alias -l fserve.yqlayout {
  ; $1 = pool, $2 = nick, $3 = ip, $4 = cid, $5 = base
  if ($dat(queuepool,$1).maxbytes_on) { return $+($size($gq.bytesqueuedinpoolforuser($1,$2,$3,$4)),/,$size($gq.maxbytesinpoolforuser($1))) }
  return $+($gq.queuesinuseinpoolforuser($1,$2,$3,$4),/,$fserve.toinf($gq.maxqueuesinpoolforuser($1,$2,$3,$4,$5)))
}
alias -l fserve.yslayout {
  ; $1 = pool, $2 = nick, $3 = ip, $4 = cid
  return $+($gq.sendsinuseinpoolforuser($1,$2,$3,$4),/,$fserve.toinf($gq.maxsendsinpoolforuser($1,$2,$3,$4)))
}
alias -l fserve.playout {
  var %trigger = $dat(fservelogin,$fservelogin_fromip($address)).trigger
  var %pri = $fmax($prinick($1,$gq.getchannelservice(fserve,%trigger)),$dat(trigger,%trigger).priority)
  return %pri
}

alias -l poollist { var %i = 1,%k,%o = $numtok($1,44) | while (%i <= %o) { %k = $addtok(%k,$dat(trigger,$gettok($1,%i,44)).pool,44) | inc %i } | return %k }


; --- fserve cache

#fileserver_responsive on

on *:close:@progress:{
  d.temp hash.progress
}
alias files {
  if (($hget(temp,hash.exclude)) && ($hget(temp,hash.excludefolders)) && ($isfmatch($2-,$v1))) {
    if ($hget(temp,hash.progress)) { nextbstep $findfile($2-,*.*,0,0) }
    return
  }
  var %o = $findfile($2-,*.*,0,0) 
  if (%o) {
    .bufferproc .radixsort $spacetoq($relpath($2-,$1)) $+ /
  }
  while (%o) {
    .bufferproc files_add %o $1-
    dec %o
  }
}
alias files_add {
  var %i = $1
  tokenize 32 $2-
  var %file,%size,%a = $findfile($2-,*.*,%i,0)
  if ($hget(temp,hash.progress)) { nextstep }
  if (%a) {
    var %r = $spacetoq($relpath($2-,$1)),%l = $maxhashlen(file,$+(%r,/)),%n = $m.file(0,%r $+ /*)
    if (!%n) { %n = 1 }
    var %o = $r.file(%r $+ / $+ %n)
    var %w = $calc($len(%o) + $len(%n))
    if ((!$hget(temp,hash.exclude)) || (!$hget(temp,hash.excludefiles)) || (!$ismatch($nopath(%a),$hget(temp,hash.excludefiles)))) {
      if ($gettok(%a,1-,32) == %a) {
        %size = $iif(($file(%a).size !== $null),$v1,0)
        hinc temp hash.totalsize $innt($calc(%size / 1024))
        %file = $nopath(%a) $size(%size)
        inc %w $calc(1 + $len(%file))
        if (%w >= %l) { inc %n | %o = %file }
        else { %o = $addtok(%o,%file,47) }
        hadd file %r $+ / $+ %n %o
      }
      else { error the file $cborder(%a) cannot be cached because the filename contains multiple adjacent spaces }
    }
  }
}
alias dirsss {
  if (($hget(temp,hash.exclude)) && ($hget(temp,hash.excludefolders)) && ($isfmatch($2-,$v1))) {
    if ($hget(temp,hash.progress)) { nextstep }
    return
  }
  var %o = $finddir($2-,*,0,0) 
  if (%o) { 
    .bufferproc radixsort $spacetoq($relpath($2-,$1)) $+ :
  }
  while (%o) {
    .bufferproc dirs_add %o $1-
    dec %o
  }
}
alias dirs_add {
  var %i = $1
  tokenize 32 $2-
  var %subdir,%a = $finddir($2-,*,%i,0)
  if ($hget(temp,hash.progress)) { nextstep }
  if (%a) { 
    var %format = $hget(temp,hash.format),%r = $spacetoq($relpath($2-,$1)),%l = $maxhashlen(file,$+(%r,:)),%n = $m.file(0,%r $+ :*)
    if (!%n) { %n = 1 }
    var %o = $r.file(%r $+ : $+ %n)
    var %w = $calc($len(%o) + 1 + $len(%n))
    if ((!$hget(temp,hash.exclude)) || (!$hget(temp,hash.excludefolders)) || (!$isfmatch(%a,$hget(temp,hash.excludefolders)))) {
      if ($gettok(%a,1-,32) == %a) {
        %subdir = $ [ $+ [ %format ] $+ ] ($gettok(%a,-1,92))
        inc %w $calc(1 + $len(%subdir))
        if (%w >= %l) { %o = %subdir | inc %n }
        else { %o = $addtok(%o,%subdir,47) }
        hadd file %r $+ : $+ %n %o
      }
      else { error the directory $cborder(%a) cannot be cached because the path contains multiple adjacent spaces }
    }
  }
}
alias -l dirret { return $1- }
alias storedir {
  if ($isdir($2-)) {
    .bufferproc files $1-
    .bufferproc dirsss $1-
  }
}
alias -l cachedir {
  $null($buffinddir($2-,*,0,storedir $uneval($1) $!1-))
  .bufferproc storedir $1 $2-
  .bufferproc secho caching $cborder($2-)
}
alias updatehash {
  w.temp hash.ticks $ticks
  w.temp hash.exclude $inf(fservecache,exclude)
  w.temp hash.excludefolders $inf(fservecache,exclude.folders)
  w.temp hash.excludefiles $inf(fservecache,exclude.files)
  w.temp hash.progress $inf(progress,on)
  w.temp hash.format $iif(($inf(fservecache,uppercase)),upper,dirret)
  w.temp hash.totalsize 0
  secho $rc(caching,start) $csv(Priority,background)
  if ($r.temp(hash.progress)) { progress $mountnumbers updating fileserver cache... }
  .hwipe file
  rootdir
  secho $rc(caching,roots)
  .bufferproc endcache
  var %a,%o = $dat(mount).num
  while (%o) {
    %a = $left($dat(mount,%o).abspath,-1)
    if ($isdir(%a)) { cachedir %o %a }
    else { error no such directory $cborder(%a) }
    dec %o
  }
}
alias endcache {
  hstore file
  progressend
  secho $bracket(all done in $calc($ticks - $hget(temp,hash.ticks)) $+ ms) $csv(Cached,$size($calc(1024 * $r.temp(hash.totalsize))))
  hdel -w temp hash.*
}

#fileserver_responsive end

on *:signal:cache:{
  if (($hget(temp,hash.progress) == 0) || ($window(@progress))) { $1- }
  elseif ($hget(temp,hash.ticks)) { endcache error caching halted after }
}
on *:signal:mount:{
  if ($1 !isnum 1-) { tokenize 32 1 }
  if ($hget(temp,cache. $+ $1 $+ .1)) {
    secho caching $cborder($v1)
    var %dir,%i = 1,%o = $hget(temp,cache. $+ $1 $+ .0) | while (%i <= %o) {
      %dir = $hget(temp,cache. $+ $1 $+ . $+ %i)
      if ($isdir(%dir)) {
        .signal cache dirsss $1 %dir
        .signal cache files $1 %dir
      }
      inc %i
    }
  }
  if ($1 < $dat(mount).num) { .timer -io 1 0 .signal cache .signal mount $calc(1 + $1) }
  else { .signal cache endcache secho all done in }
}
alias -l endcache {
  hdel -w temp cache.*
  hstore file
  progressend
  $1 $bracket($2- $calc($ticks - $hget(temp,hash.ticks)) $+ ms) $csv(Cached,$size($calc(1024 * $r.temp(hash.totalsize))))
  hdel -w temp hash.*
}
alias -l files {
  if (($hget(temp,hash.exclude)) && ($hget(temp,hash.excludefolders)) && ($isfmatch($2-,$v1))) {
    nextbstep $findfile($2-,*.*,0,0)
    return
  }
  var %file,%size,%i = 1,%a = $findfile($2-,*.*,%i,0),%o,%r = $spacetoq($relpath($2-,$1)),%l = $maxhashlen(file,$+(%r,/)),%n = $calc($m.file(0,%r $+ /*) + 1)
  var %w = $len(%n)
  while (%a) {
    if ($hget(temp,hash.progress)) { nextstep }
    if ((!$hget(temp,hash.exclude)) || (!$hget(temp,hash.excludefiles)) || (!$ismatch($nopath(%a),$hget(temp,hash.excludefiles)))) {
      if ($gettok(%a,1-,32) == %a) {
        %size = $iif(($file(%a).size !== $null),$v1,0)
        hinc temp hash.totalsize $innt($calc(%size / 1024))
        %file = $nopath(%a) $size(%size)
        inc %w $calc(1 + $len(%file))
        if (%w >= %l) { hadd file %r $+ / $+ %n %o | inc %n | var %o,%w = $calc($len(%n) + (1 + $len(%file))) }
        %o = $addtok(%o,%file,47)
      }
      else { error the file $cborder(%a) cannot be cached because the filename contains multiple adjacent spaces }
    }
    inc %i
    %a = $findfile($2-,*.*,%i,0)
  }
  if (%o !== $null) { hadd file %r $+ / $+ %n %o }
  .radixsort %r $+ /
}
alias -l dirsss {
  if (($hget(temp,hash.exclude)) && ($hget(temp,hash.excludefolders)) && ($isfmatch($2-,$v1))) {
    nextstep
    return
  }
  var %subdir,%format = $hget(temp,hash.format),%i = 1,%a = $finddir($2-,*,%i,0),%o,%r = $spacetoq($relpath($2-,$1)),%l = $maxhashlen(file,$+(%r,:)),%n = $calc($m.file(0,%r $+ :*) + 1)
  var %w = $len(%n)
  while (%a) {
    if ($hget(temp,hash.progress)) { nextstep }
    if ((!$hget(temp,hash.exclude)) || (!$hget(temp,hash.excludefolders)) || (!$isfmatch(%a,$hget(temp,hash.excludefolders)))) {
      if ($gettok(%a,1-,32) == %a) {
        %subdir = $ [ $+ [ %format ] $+ ] ($gettok(%a,-1,92))
        inc %w $calc(1 + $len(%subdir))
        if (%w >= %l) { hadd file %r $+ : $+ %n %o | inc %n | var %o,%w = $calc($len(%n) + (1 + $len(%subdir))) }
        %o = $addtok(%o,%subdir,47)
      }
      else { error the directory $cborder(%a) cannot be cached because the path contains multiple adjacent spaces }
    }
    inc %i
    %a = $finddir($2-,*,%i,0)
  }
  if (%o !== $null) { hadd file %r $+ : $+ %n %o }
  radixsort %r $+ :
}
alias -l dirret { return $1- }
alias -l storedir {
  hinc temp cache. $+ $1 $+ .0
  hadd temp cache. $+ $1 $+ . $+ $hget(temp,cache. $+ $1 $+ .0) $2-
}
alias -l cachedir {
  storedir $1 $2-
  return $finddir($2-,*,0,storedir [ [ $1 ] ] $1-)
}
alias updatehash {
  w.temp hash.ticks $ticks
  w.temp hash.exclude $inf(fservecache,exclude)
  w.temp hash.excludefolders $inf(fservecache,exclude.folders)
  w.temp hash.excludefiles $inf(fservecache,exclude.files)
  w.temp hash.progress $inf(progress,on)
  w.temp hash.format $iif(($inf(fservecache,uppercase)),upper,dirret)
  w.temp hash.totalsize 0
  secho $rc(caching,start) $csv(Priority,foreground)
  if ($r.temp(hash.progress)) { progress $mountnumbers updating fileserver cache... }
  .hwipe file
  hdel -w temp cache.*
  rootdir
  secho $rc(caching,roots)
  var %i = 1,%o = $dat(mount).num,%a
  while (%i <= %o) {
    %a = $left($dat(mount,%i).abspath,-1)
    if ($isdir(%a)) { cachedir %i %a }
    else { error no such directory $cborder(%a) }
    inc %i
  }
  .signal mount
}


alias mountnumbers {
  var %i = 1,%k = 0,%o = $dat(mount).num
  while (%i <= %o) {
    inc %k $findfile($dat(mount,%i).abspath,*,0)
    inc %k $finddir($dat(mount,%i).abspath,*,0)
    inc %i
  }
  return %k
}
alias -l relpath { return $gettok($replace($1 $+ \,$dat(mount,$2).abspath,$dat(mount,$2).relpath),1-,92) }
alias abspath {
  var %i = 1,%rel,%abs,%d = $deltok($1-,-1,32),%o = $dat(mount).num
  while (%i <= %o) {
    %rel = $dat(mount,%i).relpath
    %abs = $dat(mount,%i).abspath
    if ((%rel isin %d) && ($isfile($replace(%d,%rel,%abs)))) { return $replace(%d,%rel,%abs) $gettok($1-,-1,32) }
    inc %i
  }
  return $1-
}
alias -l rootdir {
  var %a,%d,%dirn,%i = 1,%o = $dat(mount).num,%upper = $inf(fservecache,uppercase)
  while (%i <= %o) {
    %a = $left($gettok($dat(mount,%i).relpath,1-,47),-1)
    if (%a) {
      %d = $numtok(%a,92)
      if (%upper) { %dirn = $upper($gettok(%a,1,92)) }
      else { %dirn = $gettok(%a,1,92) }
      hadd file /:1 $sorttok($addtok($hget(file,/:1),%dirn,47),47)
      var %h = 1,%n
      while (%h < %d) {
        %n = $hget(file,/ $+ $spacetoq($gettok(%a,1- [ $+ [ %h ] ] ,92)) $+ :1)
        if (%upper) { %dirn = $upper($gettok(%a,$calc(%h +1),92)) }
        else { %dirn = $gettok(%a,$calc(%h +1),92) }
        hadd file / $+ $spacetoq($gettok(%a,1- [ $+ [ %h ] ] ,92)) $+ :1 $sorttok($addtok(%n,%dirn,47),47)
        inc %h
      }
    }
    inc %i
  }
}
alias -l ismatch { var %i = 1,%o = $numtok($2-,1) | while (%i <= %o) { if ($gettok($2-,%i,1) iswm $1) { return $true } | inc %i } }
alias -l isfmatch { var %i = 1,%o = $numtok($2-,1) | while (%i <= %o) { if ($wildtok($1,$gettok($2-,%i,1),0,92)) { return $true } | inc %i } }


; --- fserve cache sorting algorithm

alias radixsort {
  var %last,%section,%i = 1,%d,%c,%l = $maxhashlen(file,$1),%n = 1,%o = $m.file(0,$1 $+ *)
  while (%i <= %o) { var % [ $+ [ %i ] ] $sorttok($hget(file,$1 $+ %i),47) | inc %i }
  hdel -w file $1 $+ *
  var %w = $len(%n)
  while (%o) {
    var %i = 1,%q = $chr(255)
    while (%i <= %o) {
      if ($show) { %section = $gettok(% [ $+ [ %i ] ] ,1,47) }
      else { %section = $nosize($gettok(% [ $+ [ %i ] ] ,1,47)) }
      if (%section == %last) {
        if ($gettok(% [ $+ [ %i ] ] ,2-,47)) { % [ $+ [ %i ] ] = $v1 }
        else { % [ $+ [ %i ] ] = % [ $+ [ %o ] ] | dec %o }
        continue
      }
      if (%section < %q) { %q = $v1 | %c = %i }
      inc %i
    }
    if (%q == $chr(255)) { break }
    %last = %q
    %q = $gettok(% [ $+ [ %c ] ] ,1,47)
    inc %w $calc($len(%q) + 1)
    if (%w >= %l) { hadd file $1 $+ %n %d | inc %n | var %d,%w = $calc($len(%n) + (1 + $len(%q))) }
    %d = $addtok(%d,%q,47)
  }
  if (%d !== $null) { hadd file $1 $+ %n %d }
}
alias -l nosize {
  ; $1- = files with sizes
  var %k
  $null($regsub(def,$1-,/\s[^\s]+(\/|$)/g,\1,%k))
  return %k
}


; --- used in dlgs

alias bind {
  ; $1 = path, $?2- = path
  return $gettok($1,1-,92) $+ $iif($1 !== /,\) $+ $gettok($2-,1-,92)
}


; --- show items

on *:signal:show.stats:{ fservestats $1- }
alias fservestats {
  ; $1- = output
  $1- $bracket($rc(fservestats,title))
  $1- $+($c(1),$csv($rc(fservestats,logins),$ifna($inf(stats,access))))
  $1- $+($c(1),$csv($rc(fservestats,filessent),$ifna($inf(stats,send.total))))
  $1- $+($c(1),$csv($rc(fservestats,bytessent),$size($inf(stats,send.bytes))))
  $1- $+($c(1),$csv($rc(fservestats,sendfails),$ifna($inf(stats,send.fails))))
  $1- $+($c(1),$csv($rc(fservestats,recordcps),$size($inf(stats,record.cps)) $+ /s by $inf(stats,record.cps.nick)))
  $1- $+($c(1),$msgdrive)