move gotd fork into repo. (#111)

- update to latest telegram layer
- remove some references to fields in tg.Entities that don't exist in
the schema
- originally added here:
https://github.com/beeper/td/commit/820929062a2ba0104397bc01235ab58a9cff780e
  - referenced here
-
https://github.com/mautrix/telegramgo/commit/124f0967ed195b5a380c9bd02e170ada9710dde3
-
https://github.com/mautrix/telegramgo/commit/4205047aab2e0639217148b5d125bfaab668bd8e

pkg/gotd/syncio/doc.go

@@ -0,0 +1,2 @@
+// Package syncio contains synchronized wrappers for interfaces from io package.
+package syncio

pkg/gotd/syncio/reader.go

@@ -0,0 +1,26 @@
+package syncio
+
+import (
+	"io"
+	"sync"
+)
+
+// Reader is synchronized io.Reader.
+type Reader struct {
+	r   io.Reader
+	mux sync.Mutex
+}
+
+// NewReader creates new Reader.
+func NewReader(r io.Reader) *Reader {
+	return &Reader{r: r}
+}
+
+// Read implements io.Reader.
+func (s *Reader) Read(p []byte) (n int, err error) {
+	s.mux.Lock()
+	n, err = s.r.Read(p)
+	s.mux.Unlock()
+
+	return
+}

pkg/gotd/syncio/writer_at.go

@@ -0,0 +1,97 @@
+package syncio
+
+import (
+	"io"
+	"sync"
+
+	"github.com/go-faster/errors"
+)
+
+// WriterAt is synchronized io.WriterAt.
+type WriterAt struct {
+	w   io.WriterAt
+	mux sync.Mutex
+}
+
+// NewWriterAt creates new WriterAt.
+func NewWriterAt(w io.WriterAt) *WriterAt {
+	return &WriterAt{w: w}
+}
+
+// WriteAt implements io.WriterAt.
+func (s *WriterAt) WriteAt(p []byte, off int64) (n int, err error) {
+	s.mux.Lock()
+	n, err = s.w.WriteAt(p, off)
+	s.mux.Unlock()
+
+	return
+}
+
+// BufWriterAt is synchronized buffer which implements io.WriterAt.
+type BufWriterAt struct {
+	buf []byte
+	mux sync.RWMutex
+}
+
+// Bytes returns copy of data from buffer.
+func (b *BufWriterAt) Bytes() (r []byte) {
+	b.mux.RLock()
+	defer b.mux.RUnlock()
+
+	return append(make([]byte, 0, len(b.buf)), b.buf...)
+}
+
+// Len returns buffer available data size.
+func (b *BufWriterAt) Len() int {
+	b.mux.RLock()
+	defer b.mux.RUnlock()
+
+	return len(b.buf)
+}
+
+// ReadAt implements io.ReaderAt.
+func (b *BufWriterAt) ReadAt(p []byte, off int64) (n int, err error) {
+	if off < 0 {
+		return 0, errors.Errorf("invalid offset %d", off)
+	}
+
+	b.mux.RLock()
+	defer b.mux.RUnlock()
+
+	l := int64(len(b.buf))
+	switch {
+	case off >= l:
+		return 0, nil
+	case off+int64(len(p)) >= l:
+		r := b.buf[off:]
+		copy(p, r)
+		return len(r), nil
+	}
+
+	from := off
+	to := off + int64(len(p))
+	copy(p, b.buf[from:to])
+	return len(p), nil
+}
+
+// WriteAt implements io.WriterAt.
+func (b *BufWriterAt) WriteAt(p []byte, off int64) (n int, err error) {
+	if off < 0 {
+		return 0, errors.Errorf("invalid offset %d", off)
+	}
+
+	b.mux.Lock()
+	defer b.mux.Unlock()
+
+	ends := len(p) + int(off)
+	if len(b.buf) < ends {
+		newBuf := make([]byte, ends)
+		copy(newBuf, b.buf)
+		b.buf = newBuf
+	}
+
+	from := off
+	to := off + int64(len(p))
+	copy(b.buf[from:to], p)
+	return len(p), nil
+}

pkg/gotd/syncio/writer_at_test.go

@@ -0,0 +1,68 @@
+package syncio
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestBufWriterAt(t *testing.T) {
+	a := require.New(t)
+	f := BufWriterAt{}
+	var err error
+
+	testData := []byte{1, 2, 3, 4, 5}
+	buf := make([]byte, len(testData))
+	offset := len(testData)
+	zeros := bytes.Repeat([]byte{0}, offset)
+
+	_, err = f.WriteAt([]byte{1}, -1)
+	a.Error(err)
+
+	_, err = f.ReadAt([]byte{}, -1)
+	a.Error(err)
+
+	_, err = f.ReadAt([]byte{1}, 0)
+	a.NoError(err)
+
+	// 5 zeros + testdata
+	_, err = f.WriteAt(testData, int64(offset))
+	a.NoError(err)
+	a.Equal(testData, f.buf[offset:])
+	a.Equal(zeros, f.buf[:offset])
+	_, err = f.ReadAt(buf, int64(offset))
+	a.NoError(err)
+	a.Equal(testData, buf)
+
+	// 2 * testdata
+	_, err = f.WriteAt(testData, 0)
+	a.NoError(err)
+	a.Equal(bytes.Repeat(testData, 2), f.buf)
+	_, err = f.ReadAt(buf, 0)
+	a.NoError(err)
+	a.Equal(testData, buf)
+
+	// 3 * testdata
+	_, err = f.WriteAt(testData, int64(offset*2))
+	a.NoError(err)
+	a.Equal(bytes.Repeat(testData, 3), f.buf)
+	_, err = f.ReadAt(buf, int64(offset*2))
+	a.NoError(err)
+	a.Equal(testData, buf)
+
+	// 3 * testdata + 5 zeros + testdata
+	_, err = f.WriteAt(testData, int64(offset*4))
+	a.NoError(err)
+	a.Equal(bytes.Repeat(testData, 3), f.buf[:3*offset])
+	a.Equal(zeros, f.buf[3*offset:4*offset])
+	a.Equal(testData, f.buf[4*offset:])
+	_, err = f.ReadAt(buf, int64(offset*4))
+	a.NoError(err)
+	a.Equal(testData, buf)
+
+	// 5 * testdata
+	_, err = f.WriteAt(testData, int64(offset*3))
+	a.NoError(err)
+	a.Equal(bytes.Repeat(testData, 5), f.buf)
+}