// Package calendar implements file-backed calendars. SQLite is a disposable index. package calendar import ( "bytes" "crypto/sha256" "encoding/hex" "errors" "fmt" "io" "strconv" "strings" "time" "unicode/utf8" ical "github.com/emersion/go-ical" ) const MaxResource = 256 << 10 var ErrInvalid = errors.New("invalid or unsupported iCalendar data") type Event struct { UID string `json:"uid"` Summary string `json:"summary"` Description string `json:"description"` Location string `json:"location"` Start time.Time `json:"start"` End time.Time `json:"end"` AllDay bool `json:"all_day"` ETag string `json:"etag"` Data string `json:"-"` } func digest(data []byte) string { h := sha256.Sum256(data); return hex.EncodeToString(h[:]) } func envelope(events ...*ical.Component) *ical.Calendar { c := ical.NewCalendar() c.Props.SetText("VERSION", "2.0") c.Props.SetText("PRODID", "-//PagesWiki//Calendar 1//EN") c.Children = events return c } func encode(c *ical.Calendar) (string, error) { var b bytes.Buffer err := ical.NewEncoder(&b).Encode(c) if err != nil { return "", err } // RFC 5545 3.1: fold at 75 octets without splitting a UTF-8 sequence. var out strings.Builder for _, line := range strings.Split(strings.TrimSuffix(b.String(), "\r\n"), "\r\n") { limit := 75 for len(line) > limit { n := limit for n > 0 && !utf8.RuneStart(line[n]) { n-- } out.WriteString(line[:n]) out.WriteString("\r\n ") line = line[n:] limit = 74 } out.WriteString(line) out.WriteString("\r\n") } return out.String(), nil } // Parse deliberately accepts a declared, lossless subset. Unsupported temporal // semantics are rejected, never accepted and silently omitted from REPORT. func Parse(data string) (Event, error) { bad := func(reason string) (Event, error) { return Event{}, fmt.Errorf("%w: %s", ErrInvalid, reason) } if len(data) > MaxResource || !utf8.ValidString(data) || strings.ContainsRune(data, 0) { return bad("size or encoding") } for _, ch := range data { if ch < 32 && ch != '\r' && ch != '\n' && ch != '\t' || ch == 127 { return bad("control character") } } dec := ical.NewDecoder(strings.NewReader(data)) c, err := dec.Decode() if err != nil { return bad(err.Error()) } if _, err = dec.Decode(); err != io.EOF { return bad("one VCALENDAR required") } if len(c.Children) != 1 || c.Children[0].Name != "VEVENT" { return bad("exactly one VEVENT required; recurrence and VTIMEZONE are not yet supported") } if c.Props.Get("METHOD") != nil { return bad("scheduling METHOD is not supported") } v, _ := c.Props.Text("VERSION") if v != "2.0" { return bad("VERSION must be 2.0") } if product, err := c.Props.Text("PRODID"); err != nil || product == "" { return bad("PRODID is required") } // Collection-level properties cannot be merged losslessly into monthly files. for name := range c.Props { if name != "VERSION" && name != "PRODID" && name != "CALSCALE" { return bad("unsupported VCALENDAR property: " + name) } } if scale, _ := c.Props.Text("CALSCALE"); scale != "" && scale != "GREGORIAN" { return bad("unsupported calendar scale") } e := ical.Event{Component: c.Children[0]} for _, key := range []string{"RRULE", "RDATE", "EXDATE", "RECURRENCE-ID", "DURATION"} { if e.Props.Get(key) != nil { return bad(key + " is not yet supported") } } if len(e.Children) > 0 { return bad("VALARM delivery is not yet supported") } for _, key := range []string{"UID", "DTSTAMP", "DTSTART"} { if len(e.Props[key]) != 1 { return bad(key + " must occur exactly once") } } uid, err := e.Props.Text("UID") if err != nil || uid == "" || len(uid) > 512 || strings.ContainsAny(uid, "\r\n\x00") { return bad("invalid UID") } startProp := e.Props.Get("DTSTART") allDay := startProp.ValueType() == ical.ValueDate for _, key := range []string{"DTSTART", "DTEND", "DTSTAMP", "CREATED", "LAST-MODIFIED"} { p := e.Props.Get(key) if p == nil { continue } date := p.ValueType() == ical.ValueDate if p.Params.Get("TZID") != "" || (!date && !strings.HasSuffix(p.Value, "Z")) { return bad("only UTC DATE-TIME or DATE supported") } if (key == "DTEND" && date != allDay) || (key != "DTSTART" && key != "DTEND" && date) { return bad("inconsistent date types") } t, err := p.DateTime(time.UTC) if err != nil || t.Year() < 1 || t.Year() > 9998 { return bad("invalid " + key) } } start, err := e.DateTimeStart(time.UTC) if err != nil { return bad("invalid DTSTART") } end, err := e.DateTimeEnd(time.UTC) if err != nil || end.Before(start) || (e.Props.Get("DTEND") != nil && !end.After(start)) { return bad("DTEND must follow DTSTART") } if _, err = e.Status(); err != nil { return bad(err.Error()) } // Encoder validates required properties, cardinality and child components. canonical, err := encode(c) if err != nil { return bad(err.Error()) } // Normalize the envelope, preserving every accepted event property/parameter. canonical, err = encode(envelope(e.Component)) if err != nil { return bad(err.Error()) } result := Event{UID: uid, Start: start, End: end, AllDay: allDay, Data: canonical, ETag: "\"" + digest([]byte(canonical)) + "\""} for key, dst := range map[string]*string{"SUMMARY": &result.Summary, "DESCRIPTION": &result.Description, "LOCATION": &result.Location} { s, err := e.Props.Text(key) if err != nil { return bad(key) } *dst = s } return result, nil } func component(data string) (*ical.Component, error) { c, e := ical.NewDecoder(strings.NewReader(data)).Decode() if e != nil { return nil, e } return c.Children[0], nil } // Build changes only UI-owned fields. Unknown properties survive browser edits. func Build(old string, item Event) (Event, error) { e := ical.NewEvent() if old != "" { c, err := component(old) if err != nil { return Event{}, err } e.Component = c } e.Props.SetText("UID", item.UID) e.Props.SetText("SUMMARY", item.Summary) e.Props.SetText("DESCRIPTION", item.Description) e.Props.SetText("LOCATION", item.Location) e.Props.SetDateTime("DTSTAMP", time.Now().UTC().Truncate(time.Second)) e.Props.SetDateTime("LAST-MODIFIED", time.Now().UTC().Truncate(time.Second)) for name, t := range map[string]time.Time{"DTSTART": item.Start, "DTEND": item.End} { p := ical.NewProp(name) if item.AllDay { p.SetDate(t.UTC()) } else { p.SetDateTime(t.UTC()) } e.Props.Set(p) } if old != "" { n := 0 if p := e.Props.Get("SEQUENCE"); p != nil { n, _ = strconv.Atoi(p.Value) } p := ical.NewProp("SEQUENCE") p.Value = strconv.Itoa(n + 1) e.Props.Set(p) } data, err := encode(envelope(e.Component)) if err != nil { return Event{}, err } return Parse(data) }