# Vulnerability Management Policy

This document formally describes the process of addressing and managing a
reported vulnerability that has been found in the MinIO server code base,
any directly connected ecosystem component or a direct / indirect dependency
of the code base.

## Scope

The vulnerability management policy described in this document covers the
process of investigating, assessing and resolving a vulnerability report

                    copy.call(delegate);
                }
            }
        } catch (groovy.lang.MissingMethodException e) {
            if (Objects.equal(e.getType(), closure.getClass()) && Objects.equal(e.getMethod(), "doCall")) {
                throw new InvalidActionClosureException(closure, delegate);
            }
            // https://github.com/apache/groovy/commit/75c068207ba24648ea2d698c520601c6fcf0a45b

See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

) : Closure<T>(
    trackingProjectAccess(crossProjectModelAccess, referrerProject, delegate.owner),
    trackingProjectAccess(crossProjectModelAccess, referrerProject, delegate.thisObject)
) {
    @Suppress("unused")
    fun doCall(vararg args: Any) {
        val numClosureArgs = delegate.maximumNumberOfParameters

                closure.setResolveStrategy(Closure.DELEGATE_FIRST);
                BeanDynamicObject dynamicObject = new BeanDynamicObject(closure);
                result = dynamicObject.tryInvokeMethod("doCall", arguments);
                if (!result.isFound() && !(closure instanceof GeneratedClosure)) {
                    return DynamicInvokeResult.found(closure.call(arguments));
                }
                return result;

module M

go 1.21
-- it/it.go --
package it

type Ctr interface {
	Count() int
}

type Conc struct {
	X int
}

func (c *Conc) Count() int {
	return c.X
}

func DoCall(c *Conc) {
	c2 := Callee(c)
	println(c2.Count())
}

func Callee(ii Ctr) Ctr {
	q := ii.Count()
	return &Conc{X: q}
}
-- main/main.go --
package main

import (
	"M/a"
	"M/b"

	MOVL	$0, 0x34(FS)

	MOVL	libcall_n(BX), CX

	// Fast version, do not store args on the stack.
	CMPL	CX, $0
	JE	docall

	// Copy args to the stack.
	MOVL	CX, AX
	SALL	$2, AX
	SUBL	AX, SP			// room for args
	MOVL	SP, DI
	MOVL	libcall_args(BX), SI
	CLD
	REP; MOVSL

docall:
	// Call stdcall or cdecl function.
	// DI SI BP BX are preserved, SP is not
	CALL	libcall_fn(BX)
	MOVL	BP, SP

        registryProbe.resetToken()
    }

    @Override
    int getPort() {
        Pattern pattern = Pattern.compile("^.*" + DaemonMessages.ADVERTISING_DAEMON + ".*port:(\\d+).*",
            Pattern.MULTILINE + Pattern.DOTALL);

        Matcher matcher = pattern.matcher(daemonLog.text);
        assert matcher.matches(): "Unable to find daemon address in the daemon log. Daemon: $context"

        try {

	}
	if pos := f.undef[name]; pos != "" {
		panic(fmt.Sprintf("flag %s set at %s before being defined", name, pos))
	}
	if f.formal == nil {
		f.formal = make(map[string]*Flag)
	}
	f.formal[name] = flag
}

// Var defines a flag with the specified name and usage string. The type and
// value of the flag are represented by the first argument, of type [Value], which

                    copy.call(delegate);
                }
            }
        } catch (groovy.lang.MissingMethodException e) {
            if (Objects.equal(e.getType(), closure.getClass()) && Objects.equal(e.getMethod(), "doCall")) {
                throw new InvalidActionClosureException(closure, delegate);
            }
            throw e;
        }
    }

    public Closure getClosure() {
        return closure;
    }