package gpgme // #include <string.h> // #include <gpgme.h> // #include <errno.h> // #include "go_gpgme.h" import "C" import ( "io" "os" "runtime" "unsafe" ) const ( SeekSet = C.SEEK_SET SeekCur = C.SEEK_CUR SeekEnd = C.SEEK_END ) //export gogpgme_readfunc func gogpgme_readfunc(handle, buffer unsafe.Pointer, size C.size_t) C.ssize_t { d := callbackLookup(uintptr(handle)).(*Data) if len(d.buf) < int(size) { d.buf = make([]byte, size) } n, err := d.r.Read(d.buf[:size]) if err != nil && err != io.EOF { C.gpgme_err_set_errno(C.EIO) return -1 } C.memcpy(buffer, unsafe.Pointer(&d.buf[0]), C.size_t(n)) return C.ssize_t(n) } //export gogpgme_writefunc func gogpgme_writefunc(handle, buffer unsafe.Pointer, size C.size_t) C.ssize_t { d := callbackLookup(uintptr(handle)).(*Data) if len(d.buf) < int(size) { d.buf = make([]byte, size) } C.memcpy(unsafe.Pointer(&d.buf[0]), buffer, C.size_t(size)) n, err := d.w.Write(d.buf[:size]) if err != nil && err != io.EOF { C.gpgme_err_set_errno(C.EIO) return -1 } return C.ssize_t(n) } //export gogpgme_seekfunc func gogpgme_seekfunc(handle unsafe.Pointer, offset C.off_t, whence C.int) C.off_t { d := callbackLookup(uintptr(handle)).(*Data) n, err := d.s.Seek(int64(offset), int(whence)) if err != nil { C.gpgme_err_set_errno(C.EIO) return -1 } return C.off_t(n) } // The Data buffer used to communicate with GPGME type Data struct { dh C.gpgme_data_t buf []byte cbs C.struct_gpgme_data_cbs r io.Reader w io.Writer s io.Seeker cbc uintptr } func newData() *Data { d := &Data{} runtime.SetFinalizer(d, (*Data).Close) return d } // NewData returns a new memory based data buffer func NewData() (*Data, error) { d := newData() return d, handleError(C.gpgme_data_new(&d.dh)) } // NewDataFile returns a new file based data buffer func NewDataFile(f *os.File) (*Data, error) { d := newData() return d, handleError(C.gpgme_data_new_from_fd(&d.dh, C.int(f.Fd()))) } // NewDataBytes returns a new memory based data buffer that contains `b` bytes func NewDataBytes(b []byte) (*Data, error) { d := newData() var cb *C.char if len(b) != 0 { cb = (*C.char)(unsafe.Pointer(&b[0])) } return d, handleError(C.gpgme_data_new_from_mem(&d.dh, cb, C.size_t(len(b)), 1)) } // NewDataReader returns a new callback based data buffer func NewDataReader(r io.Reader) (*Data, error) { d := newData() d.r = r d.cbs.read = C.gpgme_data_read_cb_t(C.gogpgme_readfunc) cbc := callbackAdd(d) d.cbc = cbc return d, handleError(C.gogpgme_data_new_from_cbs(&d.dh, &d.cbs, C.uintptr_t(cbc))) } // NewDataWriter returns a new callback based data buffer func NewDataWriter(w io.Writer) (*Data, error) { d := newData() d.w = w d.cbs.write = C.gpgme_data_write_cb_t(C.gogpgme_writefunc) cbc := callbackAdd(d) d.cbc = cbc return d, handleError(C.gogpgme_data_new_from_cbs(&d.dh, &d.cbs, C.uintptr_t(cbc))) } // NewDataReadWriter returns a new callback based data buffer func NewDataReadWriter(rw io.ReadWriter) (*Data, error) { d := newData() d.r = rw d.w = rw d.cbs.read = C.gpgme_data_read_cb_t(C.gogpgme_readfunc) d.cbs.write = C.gpgme_data_write_cb_t(C.gogpgme_writefunc) cbc := callbackAdd(d) d.cbc = cbc return d, handleError(C.gogpgme_data_new_from_cbs(&d.dh, &d.cbs, C.uintptr_t(cbc))) } // NewDataReadWriteSeeker returns a new callback based data buffer func NewDataReadWriteSeeker(rw io.ReadWriteSeeker) (*Data, error) { d := newData() d.r = rw d.w = rw d.s = rw d.cbs.read = C.gpgme_data_read_cb_t(C.gogpgme_readfunc) d.cbs.write = C.gpgme_data_write_cb_t(C.gogpgme_writefunc) d.cbs.seek = C.gpgme_data_seek_cb_t(C.gogpgme_seekfunc) cbc := callbackAdd(d) d.cbc = cbc return d, handleError(C.gogpgme_data_new_from_cbs(&d.dh, &d.cbs, C.uintptr_t(cbc))) } // Close releases any resources associated with the data buffer func (d *Data) Close() error { if d.dh == nil { return nil } if d.cbc > 0 { callbackDelete(d.cbc) } _, err := C.gpgme_data_release(d.dh) d.dh = nil return err } func (d *Data) Write(p []byte) (int, error) { n, err := C.gpgme_data_write(d.dh, unsafe.Pointer(&p[0]), C.size_t(len(p))) if err != nil { return 0, err } if n == 0 { return 0, io.EOF } return int(n), nil } func (d *Data) Read(p []byte) (int, error) { n, err := C.gpgme_data_read(d.dh, unsafe.Pointer(&p[0]), C.size_t(len(p))) if err != nil { return 0, err } if n == 0 { return 0, io.EOF } return int(n), nil } func (d *Data) Seek(offset int64, whence int) (int64, error) { n, err := C.gpgme_data_seek(d.dh, C.off_t(offset), C.int(whence)) return int64(n), err } // Name returns the associated filename if any func (d *Data) Name() string { return C.GoString(C.gpgme_data_get_file_name(d.dh)) }