Merge branch 'master' into pr/238

Author: 12ya

context/context.go

@@ -6,7 +6,7 @@
 // cancellation signals, and other request-scoped values across API boundaries
 // and between processes.
 // As of Go 1.7 this package is available in the standard library under the
-// name [context], and migrating to it can be done automatically with [go fix].
+// name [context].
 //
 // Incoming requests to a server should create a [Context], and outgoing
 // calls to servers should accept a Context. The chain of function
@@ -38,8 +38,6 @@
 //
 // See https://go.dev/blog/context for example code for a server that uses
 // Contexts.
-//
-// [go fix]: https://go.dev/cmd/go#hdr-Update_packages_to_use_new_APIs
 package context
 
 import (
@@ -51,36 +49,37 @@ import (
 // API boundaries.
 //
 // Context's methods may be called by multiple goroutines simultaneously.
+//
+//go:fix inline
 type Context = context.Context
 
 // Canceled is the error returned by [Context.Err] when the context is canceled
 // for some reason other than its deadline passing.
+//
+//go:fix inline
 var Canceled = context.Canceled
 
 // DeadlineExceeded is the error returned by [Context.Err] when the context is canceled
 // due to its deadline passing.
+//
+//go:fix inline
 var DeadlineExceeded = context.DeadlineExceeded
 
 // Background returns a non-nil, empty Context. It is never canceled, has no
 // values, and has no deadline. It is typically used by the main function,
 // initialization, and tests, and as the top-level Context for incoming
 // requests.
-func Background() Context {
-return background
-}
+//
+//go:fix inline
+func Background() Context { return context.Background() }
 
 // TODO returns a non-nil, empty Context. Code should use context.TODO when
 // it's unclear which Context to use or it is not yet available (because the
 // surrounding function has not yet been extended to accept a Context
 // parameter).
-func TODO() Context {
-return todo
-}
-
-var (
-background = context.Background()
-todo = context.TODO()
-)
+//
+//go:fix inline
+func TODO() Context { return context.TODO() }
 
 // A CancelFunc tells an operation to abandon its work.
 // A CancelFunc does not wait for the work to stop.
@@ -95,6 +94,8 @@ type CancelFunc = context.CancelFunc
 //
 // Canceling this context releases resources associated with it, so code should
 // call cancel as soon as the operations running in this [Context] complete.
+//
+//go:fix inline
 func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
 return context.WithCancel(parent)
 }
@@ -108,6 +109,8 @@ func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
 //
 // Canceling this context releases resources associated with it, so code should
 // call cancel as soon as the operations running in this [Context] complete.
+//
+//go:fix inline
 func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
 return context.WithDeadline(parent, d)
 }
@@ -122,6 +125,8 @@ func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
 //	defer cancel() // releases resources if slowOperation completes before timeout elapses
 //	return slowOperation(ctx)
 //	}
+//
+//go:fix inline
 func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
 return context.WithTimeout(parent, timeout)
 }
@@ -139,6 +144,8 @@ func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
 // interface{}, context keys often have concrete type
 // struct{}. Alternatively, exported context key variables' static
 // type should be a pointer or interface.
+//
+//go:fix inline
 func WithValue(parent Context, key, val interface{}) Context {
 return context.WithValue(parent, key, val)
 }

go.mod

@@ -1,10 +1,10 @@
 module golang.org/x/net
 
-go 1.23.0
+go 1.24.0
 
 require (
-golang.org/x/crypto v0.38.0
-golang.org/x/sys v0.33.0
-golang.org/x/term v0.32.0
-golang.org/x/text v0.25.0
+golang.org/x/crypto v0.43.0
+golang.org/x/sys v0.37.0
+golang.org/x/term v0.36.0
+golang.org/x/text v0.30.0
 )

go.sum

@@ -1,8 +1,8 @@
-golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
-golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
-golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
-golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=
+golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q=
+golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
+golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
+golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=

html/escape.go

@@ -299,7 +299,7 @@ func escape(w writer, s string) error {
 case '\r':
 esc = "
"
 default:
-panic("unrecognized escape character")
+panic("html: unrecognized escape character")
 }
 s = s[i+1:]
 if _, err := w.WriteString(esc); err != nil {

html/parse.go

@@ -136,7 +136,7 @@ func (p *parser) indexOfElementInScope(s scope, matchTags ...a.Atom) int {
 return -1
 }
 default:
-panic("unreachable")
+panic(fmt.Sprintf("html: internal error: indexOfElementInScope unknown scope: %d", s))
 }
 }
 switch s {
@@ -179,7 +179,7 @@ func (p *parser) clearStackToContext(s scope) {
 return
 }
 default:
-panic("unreachable")
+panic(fmt.Sprintf("html: internal error: clearStackToContext unknown scope: %d", s))
 }
 }
 }
@@ -231,7 +231,14 @@ func (p *parser) addChild(n *Node) {
 }
 
 if n.Type == ElementNode {
-p.oe = append(p.oe, n)
+p.insertOpenElement(n)
+}
+}
+
+func (p *parser) insertOpenElement(n *Node) {
+p.oe = append(p.oe, n)
+if len(p.oe) > 512 {
+panic("html: open stack of elements exceeds 512 nodes")
 }
 }
 
@@ -810,7 +817,7 @@ func afterHeadIM(p *parser) bool {
 p.im = inFramesetIM
 return true
 case a.Base, a.Basefont, a.Bgsound, a.Link, a.Meta, a.Noframes, a.Script, a.Style, a.Template, a.Title:
-p.oe = append(p.oe, p.head)
+p.insertOpenElement(p.head)
 defer p.oe.remove(p.head)
 return inHeadIM(p)
 case a.Head:
@@ -1678,7 +1685,7 @@ func inTableBodyIM(p *parser) bool {
 return inTableIM(p)
 }
 
-// Section 12.2.6.4.14.
+// Section 13.2.6.4.14.
 func inRowIM(p *parser) bool {
 switch p.tok.Type {
 case StartTagToken:
@@ -1690,7 +1697,9 @@ func inRowIM(p *parser) bool {
 p.im = inCellIM
 return true
 case a.Caption, a.Col, a.Colgroup, a.Tbody, a.Tfoot, a.Thead, a.Tr:
-if p.popUntil(tableScope, a.Tr) {
+if p.elementInScope(tableScope, a.Tr) {
+p.clearStackToContext(tableRowScope)
+p.oe.pop()
 p.im = inTableBodyIM
 return false
 }
@@ -1700,22 +1709,28 @@ func inRowIM(p *parser) bool {
 case EndTagToken:
 switch p.tok.DataAtom {
 case a.Tr:
-if p.popUntil(tableScope, a.Tr) {
+if p.elementInScope(tableScope, a.Tr) {
+p.clearStackToContext(tableRowScope)
+p.oe.pop()
 p.im = inTableBodyIM
 return true
 }
 // Ignore the token.
 return true
 case a.Table:
-if p.popUntil(tableScope, a.Tr) {
+if p.elementInScope(tableScope, a.Tr) {
+p.clearStackToContext(tableRowScope)
+p.oe.pop()
 p.im = inTableBodyIM
 return false
 }
 // Ignore the token.
 return true
 case a.Tbody, a.Tfoot, a.Thead:
-if p.elementInScope(tableScope, p.tok.DataAtom) {
-p.parseImpliedToken(EndTagToken, a.Tr, a.Tr.String())
+if p.elementInScope(tableScope, p.tok.DataAtom) && p.elementInScope(tableScope, a.Tr) {
+p.clearStackToContext(tableRowScope)
+p.oe.pop()
+p.im = inTableBodyIM
 return false
 }
 // Ignore the token.
@@ -2222,16 +2237,20 @@ func parseForeignContent(p *parser) bool {
 p.acknowledgeSelfClosingTag()
 }
 case EndTagToken:
+if strings.EqualFold(p.oe[len(p.oe)-1].Data, p.tok.Data) {
+p.oe = p.oe[:len(p.oe)-1]
+return true
+}
 for i := len(p.oe) - 1; i >= 0; i-- {
-if p.oe[i].Namespace == "" {
-return p.im(p)
-}
 if strings.EqualFold(p.oe[i].Data, p.tok.Data) {
 p.oe = p.oe[:i]
+return true
+}
+if i > 0 && p.oe[i-1].Namespace == "" {
 break
 }
 }
-return true
+return p.im(p)
 default:
 // Ignore the token.
 }
@@ -2312,9 +2331,13 @@ func (p *parser) parseCurrentToken() {
 }
 }
 
-func (p *parser) parse() error {
+func (p *parser) parse() (err error) {
+defer func() {
+if panicErr := recover(); panicErr != nil {
+err = fmt.Errorf("%s", panicErr)
+}
+}()
 // Iterate until EOF. Any other error will cause an early return.
-var err error
 for err != io.EOF {
 // CDATA sections are allowed only in foreign content.
 n := p.oe.top()
@@ -2343,6 +2366,8 @@ func (p *parser) parse() error {
 // <tag>s. Conversely, explicit <tag>s in r's data can be silently dropped,
 // with no corresponding node in the resulting tree.
 //
+// Parse will reject HTML that is nested deeper than 512 elements.
+//
 // The input is assumed to be UTF-8 encoded.
 func Parse(r io.Reader) (*Node, error) {
 return ParseWithOptions(r)

html/parse_test.go

@@ -251,31 +251,35 @@ func TestParser(t *testing.T) {
 t.Fatal(err)
 }
 for _, tf := range testFiles {
-f, err := os.Open(tf)
-if err != nil {
-t.Fatal(err)
-}
-defer f.Close()
-r := bufio.NewReader(f)
-
-for i := 0; ; i++ {
-ta, err := readParseTest(r)
-if err == io.EOF {
-break
-}
+t.Run(tf, func(t *testing.T) {
+f, err := os.Open(tf)
 if err != nil {
 t.Fatal(err)
 }
-if parseTestBlacklist[ta.text] {
-continue
+defer f.Close()
+r := bufio.NewReader(f)
+
+for i := 0; ; i++ {
+ta, err := readParseTest(r)
+if err == io.EOF {
+break
+}
+if err != nil {
+t.Fatal(err)
+}
+if parseTestBlacklist[ta.text] {
+continue
+}
+
+t.Run(fmt.Sprint(i), func(t *testing.T) {
+err = testParseCase(ta.text, ta.want, ta.context, ParseOptionEnableScripting(ta.scripting))
+
+if err != nil {
+t.Errorf("%s test #%d %q, %s", tf, i, ta.text, err)
+}
+})
 }
-
-err = testParseCase(ta.text, ta.want, ta.context, ParseOptionEnableScripting(ta.scripting))
-
-if err != nil {
-t.Errorf("%s test #%d %q, %s", tf, i, ta.text, err)
-}
-}
+})
 }
 }
 }
@@ -506,3 +510,35 @@ func BenchmarkParser(b *testing.B) {
 Parse(bytes.NewBuffer(buf))
 }
 }
+
+func TestIssue70179(t *testing.T) {
+_, err := Parse(strings.NewReader("<table><tbody><svg><td><desc><select></select></tbody>"))
+if err != nil {
+t.Fatalf("unexpected failure: %v", err)
+}
+}
+
+func TestDepthLimit(t *testing.T) {
+for _, tc := range []struct {
+name string
+input string
+succeed bool
+}{
+// Not we don't use 512 as the limit here, because the parser will
+// insert implied <html> and <body> tags, increasing the size of the
+// stack by two before we start parsing the <dl>.
+{"above depth limit", strings.Repeat("<dl>", 511), false},
+{"below depth limit", strings.Repeat("<dl>", 510), true},
+{"above depth limit, interspersed elements", strings.Repeat("<dl><img />", 511), false},
+{"closing tags", strings.Repeat("</dl>", 512), true},
+} {
+t.Run(tc.name, func(t *testing.T) {
+_, err := Parse(strings.NewReader(tc.input))
+if tc.succeed && err != nil {
+t.Errorf("unexpected error: %v", err)
+} else if !tc.succeed && err == nil {
+t.Errorf("unexpected success")
+}
+})
+}
+}

html/render.go

@@ -184,7 +184,7 @@ func render1(w writer, n *Node) error {
 return err
 }
 
-// Add initial newline where there is danger of a newline beging ignored.
+// Add initial newline where there is danger of a newline being ignored.
 if c := n.FirstChild; c != nil && c.Type == TextNode && strings.HasPrefix(c.Data, "\n") {
 switch n.Data {
 case "pre", "listing", "textarea":