ircd.chat/ircd
11
1
Fork 0
Code Issues Pull Requests 1 Releases Wiki Activity

Merge pull request #1200 from slingamn/issue1190_remove_offerlist.1

Browse Source 
fix #1190
This commit is contained in:
Shivaram Lingamneni 2020-07-26 03:11:12 -07:00 committed by GitHub
commit 4bb4d02729
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 1 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
conventional.yaml
View File

@ -451,10 +451,6 @@ accounts:
# before they can request a new one.
cooldown: 168h
# vhosts that users can take without approval, using `/HS TAKE`
offer-list:
#- "oragono.test"
# modes that are set by default when a user connects
# if unset, no user modes will be set by default
# +i is invisible (a user's channels are hidden from whois replies)

4
default.yaml
View File

@ -477,10 +477,6 @@ accounts:
# before they can request a new one.
cooldown: 168h
# vhosts that users can take without approval, using `/HS TAKE`
offer-list:
#- "oragono.test"
# modes that are set by default when a user connects
# if unset, no user modes will be set by default
# +i is invisible (a user's channels are hidden from whois replies)

43
irc/accounts.go
View File

@ -1590,7 +1590,6 @@ func (am *AccountManager) ModifyAccountSettings(account string, munger settingsM
type VHostInfo struct {
ApprovedVHost string
Enabled bool
Forbidden bool
RequestedVHost string
RejectedVHost string
RejectionReason string
@ -1644,10 +1643,6 @@ func (am *AccountManager) VHostSet(account string, vhost string) (result VHostIn
func (am *AccountManager) VHostRequest(account string, vhost string, cooldown time.Duration) (result VHostInfo, err error) {
munger := func(input VHostInfo) (output VHostInfo, err error) {
output = input
if input.Forbidden {
err = errVhostsForbidden
return
}
// you can update your existing request, but if you were approved or rejected,
// you can't spam a new request
if output.RequestedVHost == "" {
@ -1666,32 +1661,6 @@ func (am *AccountManager) VHostRequest(account string, vhost string, cooldown ti
return am.performVHostChange(account, munger)
}
func (am *AccountManager) VHostTake(account string, vhost string, cooldown time.Duration) (result VHostInfo, err error) {
munger := func(input VHostInfo) (output VHostInfo, err error) {
output = input
if input.Forbidden {
err = errVhostsForbidden
return
}
// if you have a request pending, you can cancel it using take;
// otherwise, you're subject to the same throttling as if you were making a request
if output.RequestedVHost == "" {
err = output.checkThrottle(cooldown)
}
if err != nil {
return
}
output.ApprovedVHost = vhost
output.RequestedVHost = ""
output.RejectedVHost = ""
output.RejectionReason = ""
output.LastRequestTime = time.Now().UTC()
return
}
return am.performVHostChange(account, munger)
}
func (am *AccountManager) VHostApprove(account string) (result VHostInfo, err error) {
munger := func(input VHostInfo) (output VHostInfo, err error) {
output = input
@ -1731,16 +1700,6 @@ func (am *AccountManager) VHostSetEnabled(client *Client, enabled bool) (result
return am.performVHostChange(client.Account(), munger)
}
func (am *AccountManager) VHostForbid(account string, forbid bool) (result VHostInfo, err error) {
munger := func(input VHostInfo) (output VHostInfo, err error) {
output = input
output.Forbidden = forbid
return
}
return am.performVHostChange(account, munger)
}
func (am *AccountManager) performVHostChange(account string, munger vhostMunger) (result VHostInfo, err error) {
account, err = CasefoldName(account)
if err != nil || account == "" {
@ -1861,7 +1820,7 @@ func (am *AccountManager) applyVHostInfo(client *Client, info VHostInfo) {
}
vhost := ""
if info.Enabled && !info.Forbidden {
if info.Enabled {
vhost = info.ApprovedVHost
}
oldNickmask := client.NickMaskString()

7
irc/config.go
View File

@ -315,7 +315,6 @@ type VHostConfig struct {
Channel string
Cooldown custime.Duration
} `yaml:"user-requests"`
OfferList []string `yaml:"offer-list"`
}
type NickEnforcementMethod int
@ -1086,12 +1085,6 @@ func LoadConfig(filename string) (config *Config, err error) {
config.Accounts.VHosts.ValidRegexp = defaultValidVhostRegex
}
for _, vhost := range config.Accounts.VHosts.OfferList {
if !config.Accounts.VHosts.ValidRegexp.MatchString(vhost) {
return nil, fmt.Errorf("invalid offered vhost: %s", vhost)
}
}
config.Server.capValues[caps.SASL] = "PLAIN,EXTERNAL"
if !config.Accounts.AuthenticationEnabled {
config.Server.supportedCaps.Disable(caps.SASL)

1
irc/errors.go
View File

@ -58,7 +58,6 @@ var (
errBanned = errors.New("IP or nickmask banned")
errInvalidParams = utils.ErrInvalidParams
errNoVhost = errors.New(`You do not have an approved vhost`)
errVhostsForbidden = errors.New(`An administrator has denied you the ability to use vhosts`)
errLimitExceeded = errors.New("Limit exceeded")
errNoop = errors.New("Action was a no-op")
errCASFailed = errors.New("Compare-and-swap update of database value failed")

116
irc/hostserv.go
View File

@ -129,51 +129,6 @@ for the rejection.`,
maxParams: 2,
unsplitFinalParam: true,
},
"forbid": {
handler: hsForbidHandler,
help: `Syntax: $bFORBID <user>$b
FORBID prevents a user from using any vhost, including ones on the offer list.`,
helpShort: `$bFORBID$b prevents a user from using vhosts.`,
capabs: []string{"vhosts"},
enabled: hostservEnabled,
minParams: 1,
maxParams: 1,
},
"permit": {
handler: hsForbidHandler,
help: `Syntax: $bPERMIT <user>$b
PERMIT undoes FORBID, allowing the user to TAKE vhosts again.`,
helpShort: `$bPERMIT$b allows a user to use vhosts again.`,
capabs: []string{"vhosts"},
enabled: hostservEnabled,
minParams: 1,
maxParams: 1,
},
"offerlist": {
handler: hsOfferListHandler,
help: `Syntax: $bOFFERLIST$b
OFFERLIST lists vhosts that can be chosen without requiring operator approval;
to use one of the listed vhosts, take it with /HOSTSERV TAKE.`,
helpShort: `$bOFFERLIST$b lists vhosts that can be taken without operator approval.`,
enabled: hostservEnabled,
minParams: 0,
maxParams: 0,
},
"take": {
handler: hsTakeHandler,
help: `Syntax: $bTAKE$b <vhost>
TAKE sets your vhost to one of the vhosts in the server's offer list; to see
the offered vhosts, use /HOSTSERV OFFERLIST.`,
helpShort: `$bTAKE$b sets your vhost to one of the options from the offer list.`,
enabled: hostservEnabled,
authRequired: true,
minParams: 1,
maxParams: 1,
},
"setcloaksecret": {
handler: hsSetCloakSecretHandler,
help: `Syntax: $bSETCLOAKSECRET$b <secret> [code]
@ -238,8 +193,6 @@ func hsRequestHandler(server *Server, client *Client, command string, params []s
if err != nil {
if throttled, ok := err.(*vhostThrottleExceeded); ok {
hsNotice(rb, fmt.Sprintf(client.t("You must wait an additional %v before making another request"), throttled.timeRemaining))
} else if err == errVhostsForbidden {
hsNotice(rb, client.t("An administrator has denied you the ability to use vhosts"))
} else {
hsNotice(rb, client.t("An error occurred"))
}
@ -276,11 +229,6 @@ func hsStatusHandler(server *Server, client *Client, command string, params []st
return
}
if account.VHost.Forbidden {
hsNotice(rb, client.t("An administrator has denied you the ability to use vhosts"))
return
}
if account.VHost.ApprovedVHost != "" {
hsNotice(rb, fmt.Sprintf(client.t("Account %[1]s has vhost: %[2]s"), accountName, account.VHost.ApprovedVHost))
if !account.VHost.Enabled {
@ -382,70 +330,6 @@ func hsRejectHandler(server *Server, client *Client, command string, params []st
}
}
func hsForbidHandler(server *Server, client *Client, command string, params []string, rb *ResponseBuffer) {
user := params[0]
forbidden := command == "forbid"
_, err := server.accounts.VHostForbid(user, forbidden)
if err == errAccountDoesNotExist {
hsNotice(rb, client.t("No such account"))
} else if err != nil {
hsNotice(rb, client.t("An error occurred"))
} else {
if forbidden {
hsNotice(rb, fmt.Sprintf(client.t("User %s is no longer allowed to use vhosts"), user))
} else {
hsNotice(rb, fmt.Sprintf(client.t("User %s is now allowed to use vhosts"), user))
}
}
}
func hsOfferListHandler(server *Server, client *Client, command string, params []string, rb *ResponseBuffer) {
vhostConfig := server.Config().Accounts.VHosts
if len(vhostConfig.OfferList) == 0 {
if vhostConfig.UserRequests.Enabled {
hsNotice(rb, client.t("The server does not offer any vhosts, but you can request one with /HOSTSERV REQUEST"))
} else {
hsNotice(rb, client.t("The server does not offer any vhosts"))
}
} else {
hsNotice(rb, client.t("The following vhosts are available and can be chosen with /HOSTSERV TAKE:"))
for _, vhost := range vhostConfig.OfferList {
hsNotice(rb, vhost)
}
}
}
func hsTakeHandler(server *Server, client *Client, command string, params []string, rb *ResponseBuffer) {
config := server.Config()
vhost := params[0]
found := false
for _, offered := range config.Accounts.VHosts.OfferList {
if offered == vhost {
found = true
}
}
if !found {
hsNotice(rb, client.t("That vhost isn't being offered by the server"))
return
}
account := client.Account()
_, err := server.accounts.VHostTake(account, vhost, time.Duration(config.Accounts.VHosts.UserRequests.Cooldown))
if err != nil {
if throttled, ok := err.(*vhostThrottleExceeded); ok {
hsNotice(rb, fmt.Sprintf(client.t("You must wait an additional %v before taking a vhost"), throttled.timeRemaining))
} else if err == errVhostsForbidden {
hsNotice(rb, client.t("An administrator has denied you the ability to use vhosts"))
} else {
hsNotice(rb, client.t("An error occurred"))
}
} else {
hsNotice(rb, client.t("Successfully set vhost"))
server.snomasks.Send(sno.LocalVhosts, fmt.Sprintf("Client %s (account %s) took vhost %s", client.Nick(), account, vhost))
}
}
func hsSetCloakSecretHandler(server *Server, client *Client, command string, params []string, rb *ResponseBuffer) {
secret := params[0]
expectedCode := utils.ConfirmationCode(secret, server.ctime)