func (self *KcDb) Iter(fun func(string, Getter) bool) { cur := C.kcdbcursor(self.cdb) C.kccurjump(cur) var kSize, vSize C.size_t var vBuff, kBuff *C.char var ret bool for { kBuff = C.kccurget(cur, &kSize, &vBuff, &vSize, kcTrue) if kBuff == nil { C.kcfree(unsafe.Pointer(kBuff)) break } key := string(C.GoBytes(unsafe.Pointer(kBuff), C.int(kSize))) value := C.GoBytes(unsafe.Pointer(vBuff), C.int(vSize)) r := bytes.NewReader(value) ret = fun(key, func(e interface{}) error { return decode(r, e) }) C.kcfree(unsafe.Pointer(kBuff)) if ret == false { break } } C.kccurdel(cur) }
//export GetProof func GetProof(dispatcher_c unsafe.Pointer, server_ip_c unsafe.Pointer, server_ip_sz C.size_t, hostname_c unsafe.Pointer, hostname_sz_c C.size_t, server_config_c unsafe.Pointer, server_config_sz_c C.size_t, ecdsa_ok_c C.int, out_certs_c ***C.char, out_certs_sz_c *C.int, out_certs_item_sz_c **C.size_t, out_signature_c **C.char, out_signature_sz_c *C.size_t) C.int { dispatcher := (*QuicDispatcher)(dispatcher_c) if !dispatcher.isSecure { return C.int(0) } serverIp := net.IP(C.GoBytes(server_ip_c, C.int(server_ip_sz))) hostname := C.GoBytes(hostname_c, C.int(hostname_sz_c)) serverConfig := C.GoBytes(server_config_c, C.int(server_config_sz_c)) ecdsaOk := int(ecdsa_ok_c) > 0 certs, sig := dispatcher.proofSource.GetProof(serverIp, hostname, serverConfig, ecdsaOk) certsCStrList := make([](*C.char), 0, 10) certsCStrSzList := make([](C.size_t), 0, 10) for _, outCert := range certs { outCert_c := C.CString(string(outCert)) // Must free this C string in C code certsCStrList = append(certsCStrList, outCert_c) certsCStrSzList = append(certsCStrSzList, C.size_t(len(outCert))) } *out_certs_c = (**C.char)(unsafe.Pointer(&certsCStrList[0])) *out_certs_sz_c = C.int(len(certsCStrList)) *out_certs_item_sz_c = (*C.size_t)(unsafe.Pointer(&certsCStrSzList[0])) *out_signature_c = C.CString(string(sig)) // Must free C string *out_signature_sz_c = C.size_t(len(sig)) return C.int(1) }
//export registeredCB func registeredCB( ptr unsafe.Pointer, frameworkMessage *C.ProtobufObj, masterMessage *C.ProtobufObj) { if ptr != nil { var driver *SchedulerDriver = (*SchedulerDriver)(ptr) if driver.Scheduler.Registered == nil { return } frameworkData := C.GoBytes( frameworkMessage.data, C.int(frameworkMessage.size)) var frameworkId FrameworkID err := proto.Unmarshal(frameworkData, &frameworkId) if err != nil { return } masterData := C.GoBytes(masterMessage.data, C.int(masterMessage.size)) var masterInfo MasterInfo err = proto.Unmarshal(masterData, &masterInfo) if err != nil { return } driver.Scheduler.Registered(driver, frameworkId, masterInfo) } }
// Render returns the map as an encoded image. func (m *Map) Render(opts RenderOpts) ([]byte, error) { scaleFactor := opts.ScaleFactor if scaleFactor == 0.0 { scaleFactor = 1.0 } i := C.mapnik_map_render_to_image(m.m, C.double(opts.Scale), C.double(scaleFactor)) if i == nil { return nil, m.lastError() } defer C.mapnik_image_free(i) if opts.Format == "raw" { size := 0 raw := C.mapnik_image_to_raw(i, (*C.size_t)(unsafe.Pointer(&size))) return C.GoBytes(unsafe.Pointer(raw), C.int(size)), nil } var format *C.char if opts.Format != "" { format = C.CString(opts.Format) } else { format = C.CString("png256") } b := C.mapnik_image_to_blob(i, format) if b == nil { return nil, errors.New("mapnik: " + C.GoString(C.mapnik_image_last_error(i))) } C.free(unsafe.Pointer(format)) defer C.mapnik_image_blob_free(b) return C.GoBytes(unsafe.Pointer(b.ptr), C.int(b.len)), nil }
// GetEventLog returns an array of structures representing the contents of the // TSS event log func (tpm *TPM) GetEventLog() ([]Log, error) { var count C.UINT32 var events *C.TSS_PCR_EVENT var event C.TSS_PCR_EVENT err := tspiError(C.Tspi_TPM_GetEventLog(tpm.handle, &count, &events)) if err != nil { return nil, err } if count == 0 { return nil, nil } log := make([]Log, count) length := count * C.UINT32(unsafe.Sizeof(event)) slice := (*[1 << 30]C.TSS_PCR_EVENT)(unsafe.Pointer(events))[:length:length] for i := 0; i < int(count); i++ { log[i].Pcr = int(slice[i].ulPcrIndex) log[i].Eventtype = int(slice[i].eventType) log[i].PcrValue = C.GoBytes(unsafe.Pointer(slice[i].rgbPcrValue), C.int(slice[i].ulPcrValueLength)) log[i].Event = C.GoBytes(unsafe.Pointer(slice[i].rgbEvent), C.int(slice[i].ulEventLength)) } C.Tspi_Context_FreeMemory(tpm.context, (*C.BYTE)(unsafe.Pointer(events))) return log, nil }
func (self *LsmDb) Iter(fun func(string, Getter) bool) { var cur *C.lsm_cursor rc := C.lsm_csr_open(self.cdb, &cur) if rc != C.LSM_OK { return } defer C.lsm_csr_close(cur) var keyP, valP unsafe.Pointer var keyL, valL C.int for rc := C.lsm_csr_first(cur); rc == C.LSM_OK && C.lsm_csr_valid(cur) == lsmTrue; rc = C.lsm_csr_next(cur) { rc = C.lsm_csr_key(cur, &keyP, &keyL) if rc != C.LSM_OK { break } rc = C.lsm_csr_value(cur, &valP, &valL) if rc != C.LSM_OK { break } key := string(C.GoBytes(keyP, keyL)) value := C.GoBytes(valP, valL) r := bytes.NewReader(value) ret := fun(key, func(obj interface{}) error { return decode(r, obj) }) if ret == false { break } } }
//export consume func consume(ctx *C.knot_layer_t, pkt *C.knot_pkt_t) C.int { req := (*C.struct_kr_request)(ctx.data) qry := req.current_query state := (C.int)(ctx.state) if qry.flags&C.QUERY_CACHED != 0 { return state } // Parse answer source address sa := (*C.struct_sockaddr)(unsafe.Pointer(&qry.ns.addr[0])) var ip net.IP if sa.sa_family == C.AF_INET { sa_v4 := (*C.struct_sockaddr_in)(unsafe.Pointer(sa)) ip = net.IP(C.GoBytes(unsafe.Pointer(&sa_v4.sin_addr), 4)) } else if sa.sa_family == C.AF_INET6 { sa_v6 := (*C.struct_sockaddr_in6)(unsafe.Pointer(sa)) ip = net.IP(C.GoBytes(unsafe.Pointer(&sa_v6.sin6_addr), 16)) } // Parse metadata qname := C.knot_dname_to_str_alloc(C.knot_pkt_qname(pkt)) defer C.free(unsafe.Pointer(qname)) qtype := C.knot_pkt_qtype(pkt) secure := (bool)(C.knot_pkt_has_dnssec(pkt)) // Sample metric process_sample(C.GoString(qname), int(qtype), ip, secure) return state }
func (cursor *Cursor) Get(set_key []byte, op uint) (key, val []byte, err error) { var ckey C.MDB_val var cval C.MDB_val if set_key != nil && op == SET { var cset_key *C.MDB_val cset_key = &C.MDB_val{mv_size: C.size_t(len(set_key)), mv_data: unsafe.Pointer(&set_key[0])} ret := C.mdb_cursor_get(cursor._cursor, cset_key, &cval, C.MDB_cursor_op(op)) if ret != SUCCESS { err = Errno(ret) key = nil val = nil return } key = set_key val = C.GoBytes(cval.mv_data, C.int(cval.mv_size)) } ret := C.mdb_cursor_get(cursor._cursor, &ckey, &cval, C.MDB_cursor_op(op)) if ret != SUCCESS { err = Errno(ret) key = nil val = nil return } err = nil key = C.GoBytes(ckey.mv_data, C.int(ckey.mv_size)) val = C.GoBytes(cval.mv_data, C.int(cval.mv_size)) return }
func loadSystemRoots() (*CertPool, error) { roots := NewCertPool() var data C.CFDataRef = nil var untrustedData C.CFDataRef = nil err := C.FetchPEMRoots(&data, &untrustedData) if err == -1 { // TODO: better error message return nil, errors.New("crypto/x509: failed to load darwin system roots with cgo") } defer C.CFRelease(C.CFTypeRef(data)) buf := C.GoBytes(unsafe.Pointer(C.CFDataGetBytePtr(data)), C.int(C.CFDataGetLength(data))) roots.AppendCertsFromPEM(buf) if untrustedData == nil { return roots, nil } defer C.CFRelease(C.CFTypeRef(untrustedData)) buf = C.GoBytes(unsafe.Pointer(C.CFDataGetBytePtr(untrustedData)), C.int(C.CFDataGetLength(untrustedData))) untrustedRoots := NewCertPool() untrustedRoots.AppendCertsFromPEM(buf) trustedRoots := NewCertPool() for _, c := range roots.certs { if !untrustedRoots.contains(c) { trustedRoots.AddCert(c) } } return trustedRoots, nil }
// GetTokenInfo obtains information about a particular token // in the system. func (c *Ctx) GetTokenInfo(slotID uint) (TokenInfo, error) { var cti C.CK_TOKEN_INFO e := C.GetTokenInfo(c.ctx, C.CK_ULONG(slotID), &cti) s := TokenInfo{ Label: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.label[0]), 32)), " "), ManufacturerID: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.manufacturerID[0]), 32)), " "), Model: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.model[0]), 16)), " "), SerialNumber: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.serialNumber[0]), 16)), " "), Flags: uint(cti.flags), MaxSessionCount: uint(cti.ulMaxSessionCount), SessionCount: uint(cti.ulSessionCount), MaxRwSessionCount: uint(cti.ulMaxRwSessionCount), RwSessionCount: uint(cti.ulRwSessionCount), MaxPinLen: uint(cti.ulMaxPinLen), MinPinLen: uint(cti.ulMinPinLen), TotalPublicMemory: uint(cti.ulTotalPublicMemory), FreePublicMemory: uint(cti.ulFreePublicMemory), TotalPrivateMemory: uint(cti.ulTotalPrivateMemory), FreePrivateMemory: uint(cti.ulFreePrivateMemory), HardwareVersion: toVersion(cti.hardwareVersion), FirmwareVersion: toVersion(cti.firmwareVersion), UTCTime: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.utcTime[0]), 16)), " "), } return s, toError(e) }
//export GetProof func GetProof(proof_source_c unsafe.Pointer, server_ip_c unsafe.Pointer, server_ip_sz C.size_t, hostname_c unsafe.Pointer, hostname_sz_c C.size_t, server_config_c unsafe.Pointer, server_config_sz_c C.size_t, ecdsa_ok_c C.int, out_certs_c ***C.char, out_certs_sz_c *C.int, out_certs_item_sz_c **C.size_t, out_signature_c **C.char, out_signature_sz_c *C.size_t) C.int { proofSource := (*ProofSource)(proof_source_c) if !proofSource.impl.IsSecure() { return C.int(0) } serverIp := net.IP(C.GoBytes(server_ip_c, C.int(server_ip_sz))) hostname := C.GoBytes(hostname_c, C.int(hostname_sz_c)) serverConfig := C.GoBytes(server_config_c, C.int(server_config_sz_c)) ecdsaOk := int(ecdsa_ok_c) > 0 certs, sig := proofSource.impl.GetProof(serverIp, hostname, serverConfig, ecdsaOk) certsCStrList := make([](*C.char), 0, 10) certsCStrSzList := make([](C.size_t), 0, 10) // XXX(hodduc): certsCStrList and certsCStrSzList may be garbage collected before reading in C side, isn't it? for _, outCert := range certs { outCert_c := C.CString(string(outCert)) // Must free this C string in C code certsCStrList = append(certsCStrList, outCert_c) certsCStrSzList = append(certsCStrSzList, C.size_t(len(outCert))) } *out_certs_c = (**C.char)(unsafe.Pointer(&certsCStrList[0])) *out_certs_sz_c = C.int(len(certsCStrList)) *out_certs_item_sz_c = (*C.size_t)(unsafe.Pointer(&certsCStrSzList[0])) *out_signature_c = C.CString(string(sig)) // Must free C string *out_signature_sz_c = C.size_t(len(sig)) return C.int(1) }
//export executorLostCB func executorLostCB( ptr unsafe.Pointer, executorIdMessage *C.ProtobufObj, slaveIdMessage *C.ProtobufObj, status C.int) { if ptr != nil { var driver *SchedulerDriver = (*SchedulerDriver)(ptr) if driver.Scheduler.ExecutorLost == nil { return } executorData := C.GoBytes(executorIdMessage.data, C.int(executorIdMessage.size)) var executorId ExecutorID err := proto.Unmarshal(executorData, &executorId) if err != nil { return } slaveData := C.GoBytes(slaveIdMessage.data, C.int(slaveIdMessage.size)) var slaveId SlaveID err = proto.Unmarshal(slaveData, &slaveId) if err != nil { return } driver.Scheduler.ExecutorLost(driver, executorId, slaveId, int(status)) } }
//export frameworkMessageCB func frameworkMessageCB( ptr unsafe.Pointer, executorIdMessage *C.ProtobufObj, slaveIdMessage *C.ProtobufObj, dataMessage *C.ProtobufObj) { if ptr != nil { var driver *SchedulerDriver = (*SchedulerDriver)(ptr) if driver.Scheduler.FrameworkMessage == nil { return } executorData := C.GoBytes(executorIdMessage.data, C.int(executorIdMessage.size)) var executorId ExecutorID err := proto.Unmarshal(executorData, &executorId) if err != nil { return } slaveData := C.GoBytes(slaveIdMessage.data, C.int(slaveIdMessage.size)) var slaveId SlaveID err = proto.Unmarshal(slaveData, &slaveId) if err != nil { return } message := C.GoBytes(dataMessage.data, C.int(dataMessage.size)) var messageString string = string(message) driver.Scheduler.FrameworkMessage(driver, executorId, slaveId, messageString) } }
// Next moves the cursor to the next element and returns the key and value. // Returns a nil key if there are no more key/value pairs. func (c *Cursor) Next() (key, value []byte) { var k, v C.bolt_val var flags C.uint32_t C.bolt_cursor_next(c.C, &k, &v, &flags) if k.data == nil { return nil, nil } return C.GoBytes(k.data, C.int(k.size)), C.GoBytes(v.data, C.int(v.size)) }
// Resolve wraps Unbound's ub_resolve. func (u *Unbound) Resolve(name string, rrtype, rrclass uint16) (*Result, error) { res := C.new_ub_result() r := new(Result) defer C.ub_resolve_free(res) i := C.ub_resolve(u.ctx, C.CString(name), C.int(rrtype), C.int(rrclass), &res) err := newError(int(i)) if err != nil { return nil, err } r.Qname = C.GoString(res.qname) r.Qtype = uint16(res.qtype) r.Qclass = uint16(res.qclass) r.CanonName = C.GoString(res.canonname) r.Rcode = int(res.rcode) r.AnswerPacket = new(dns.Msg) r.AnswerPacket.Unpack(C.GoBytes(res.answer_packet, res.answer_len)) // Should always work r.HaveData = res.havedata == 1 r.NxDomain = res.nxdomain == 1 r.Secure = res.secure == 1 r.Bogus = res.bogus == 1 r.WhyBogus = C.GoString(res.why_bogus) // Re-create the RRs var h dns.RR_Header h.Name = r.Qname h.Rrtype = r.Qtype h.Class = r.Qclass h.Ttl = 0 r.Data = make([][]byte, 0) r.Rr = make([]dns.RR, 0) j := 0 if r.HaveData { b := C.GoBytes(unsafe.Pointer(C.array_elem_char(res.data, C.int(j))), C.array_elem_int(res.len, C.int(j))) for len(b) != 0 { // Create the RR h.Rdlength = uint16(len(b)) msg := make([]byte, 20+len(h.Name)) // Long enough off, _ := dns.PackStruct(&h, msg, 0) msg = msg[:off] rrbuf := append(msg, b...) rr, _, err := dns.UnpackRR(rrbuf, 0) if err == nil { r.Rr = append(r.Rr, rr) } r.Data = append(r.Data, b) j++ b = C.GoBytes(unsafe.Pointer(C.array_elem_char(res.data, C.int(j))), C.array_elem_int(res.len, C.int(j))) } } return r, err }
//export merge // merge is a wrapper around goMerge, returning the result // as a non-garbage collected C string. // It is used by C code in this package. func merge(a, b *C.char, aLen, bLen C.size_t) (*C.char, C.size_t) { result, err := goMerge(C.GoBytes(unsafe.Pointer(a), C.int(aLen)), C.GoBytes(unsafe.Pointer(b), C.int(bLen))) if err != nil { return nil, 0 } // As above, the first return value will have to be manually freed // by the receiver. return C.CString(string(result)), C.size_t(len(result)) }
func webpSetMetadata(data, metadata []byte, format string) (newData []byte, err error) { if len(data) == 0 || len(metadata) == 0 { err = errors.New("webpSetMetadata: bad arguments") return } isCBuf := false cData := cgoSafePtr(data, isCBuf) defer cgoFreePtr(cData, isCBuf) cMetadata := cgoSafePtr(metadata, isCBuf) defer cgoFreePtr(cMetadata, isCBuf) switch format { case "EXIF": rv := C.cgoWebpSetEXIF( (*C.uint8_t)(cData), C.size_t(len(data)), (*C.char)(cMetadata), C.size_t(len(metadata)), ) if rv.ok != 1 { err = errors.New("webpSetMetadata: failed") return } newData = C.GoBytes(unsafe.Pointer(rv.ptr), C.int(rv.size)) C.webpFree(unsafe.Pointer(rv.ptr)) return case "ICCP": rv := C.cgoWebpSetICCP( (*C.uint8_t)(cData), C.size_t(len(data)), (*C.char)(cMetadata), C.size_t(len(metadata)), ) if rv.ok != 1 { err = errors.New("webpSetMetadata: failed") return } newData = C.GoBytes(unsafe.Pointer(rv.ptr), C.int(rv.size)) C.webpFree(unsafe.Pointer(rv.ptr)) return case "XMP": rv := C.cgoWebpSetXMP( (*C.uint8_t)(cData), C.size_t(len(data)), (*C.char)(cMetadata), C.size_t(len(metadata)), ) if rv.ok != 1 { err = errors.New("webpSetMetadata: failed") return } newData = C.GoBytes(unsafe.Pointer(rv.ptr), C.int(rv.size)) C.webpFree(unsafe.Pointer(rv.ptr)) return default: err = errors.New("webpSetMetadata: unknown format") return } }
/* GetSlotInfo obtains information about a particular slot in the system. */ func (c *Ctx) GetSlotInfo(slotID uint) (SlotInfo, error) { var csi C.CK_SLOT_INFO e := C.GetSlotInfo(c.ctx, C.CK_ULONG(slotID), &csi) s := SlotInfo{ SlotDescription: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&csi.slotDescription[0]), 64)), " "), ManufacturerID: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&csi.manufacturerID[0]), 32)), " "), Flags: uint(csi.flags), HardwareVersion: toVersion(csi.hardwareVersion), FirmwareVersion: toVersion(csi.firmwareVersion), } return s, toError(e) }
/* GetInfo returns general information about Cryptoki. */ func (c *Ctx) GetInfo() (Info, error) { var p C.CK_INFO e := C.GetInfo(c.ctx, C.CK_INFO_PTR(&p)) i := Info{ CryptokiVersion: toVersion(p.cryptokiVersion), ManufacturerID: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&p.manufacturerID[0]), 32)), " "), Flags: uint(p.flags), LibraryDescription: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&p.libraryDescription[0]), 32)), " "), LibraryVersion: toVersion(p.libraryVersion), } return i, toError(e) }
// Scan returns up to max key/value objects starting from // start (inclusive) and ending at end (non-inclusive). // If max is zero then the number of key/values returned is unbounded. func (r *RocksDB) Scan(start, end Key, max int64) ([]RawKeyValue, error) { var keyVals []RawKeyValue if bytes.Compare(start, end) >= 0 { return keyVals, nil } // In order to prevent content displacement, caching is disabled // when performing scans. Any options set within the shared read // options field that should be carried over needs to be set here // as well. opts := C.rocksdb_readoptions_create() C.rocksdb_readoptions_set_fill_cache(opts, 0) defer C.rocksdb_readoptions_destroy(opts) it := C.rocksdb_create_iterator(r.rdb, opts) defer C.rocksdb_iter_destroy(it) byteCount := len(start) if byteCount == 0 { // start=Key("") needs special treatment since we need // to access start[0] in an explicit seek. C.rocksdb_iter_seek_to_first(it) } else { C.rocksdb_iter_seek(it, bytesPointer(start), C.size_t(byteCount)) } for i := int64(1); C.rocksdb_iter_valid(it) == 1; C.rocksdb_iter_next(it) { if max > 0 && i > max { break } var l C.size_t // The data returned by rocksdb_iter_{key,value} is not meant to be // freed by the client. It is a direct reference to the data managed // by the iterator, so it is copied instead of freed. data := C.rocksdb_iter_key(it, &l) k := C.GoBytes(unsafe.Pointer(data), C.int(l)) if bytes.Compare(k, end) >= 0 { break } data = C.rocksdb_iter_value(it, &l) v := C.GoBytes(unsafe.Pointer(data), C.int(l)) keyVals = append(keyVals, RawKeyValue{ Key: k, Value: v, }) i++ } // Check for any errors during iteration. var cErr *C.char C.rocksdb_iter_get_error(it, &cErr) if cErr != nil { return nil, charToErr(cErr) } return keyVals, nil }
// With an unsafe.Pointer to the block of C memory NewIp6Hdr returns a filled in Ip6Hdr struct. func NewIp6Hdr(p unsafe.Pointer) (*Ip6Hdr, unsafe.Pointer) { ip6Hdr := &Ip6Hdr{ cptr: (*C.struct_ip6_hdr)(p), // The fixed header of an IPv6 packet consists of its first 40 octets. payload: unsafe.Pointer(uintptr(p) + uintptr(40)), } ip6Hdr.SrcAddr = net.IP(C.GoBytes(unsafe.Pointer(&ip6Hdr.cptr.ip6_src), 16)) ip6Hdr.DstAddr = net.IP(C.GoBytes(unsafe.Pointer(&ip6Hdr.cptr.ip6_dst), 16)) u := (*C.struct_ip6_hdrctl)(unsafe.Pointer(&ip6Hdr.cptr.ip6_ctlun)) ip6Hdr.NextHeader = uint8(u.ip6_un1_nxt) ip6Hdr.PayloadLen = uint16(C.ntohs(u.ip6_un1_plen)) return ip6Hdr, ip6Hdr.payload }
// Seek moves the cursor to a given key and returns it. // If the key does not exist then the next key is used. If no keys // follow, an empty value is returned. func (c *Cursor) Seek(seek []byte) (key, value []byte, flags int) { var _flags C.uint32_t var _seek, k, v C.bolt_val if len(seek) > 0 { _seek.size = C.uint32_t(len(seek)) _seek.data = unsafe.Pointer(&seek[0]) } C.bolt_cursor_seek(c.C, _seek, &k, &v, &_flags) if k.data == nil { return nil, nil, 0 } return C.GoBytes(k.data, C.int(k.size)), C.GoBytes(v.data, C.int(v.size)), int(_flags) }
func writeToUDP(writer_c unsafe.Pointer, peer_ip unsafe.Pointer, peer_ip_sz C.size_t, peer_port uint16, buffer_c unsafe.Pointer, length_c C.size_t, isServer bool) { buf := C.GoBytes(buffer_c, C.int(length_c)) if isServer { peer_addr := &net.UDPAddr{ IP: net.IP(C.GoBytes(peer_ip, C.int(peer_ip_sz))), Port: int(peer_port), } ((*ServerWriter)(writer_c)).Ch <- UdpData{Buf: buf, Addr: peer_addr} } else { ((*ClientWriter)(writer_c)).Ch <- UdpData{Buf: buf} } }
func callbackArgBytes(v *C.sqlite3_value) (reflect.Value, error) { switch C.sqlite3_value_type(v) { case C.SQLITE_BLOB: l := C.sqlite3_value_bytes(v) p := C.sqlite3_value_blob(v) return reflect.ValueOf(C.GoBytes(p, l)), nil case C.SQLITE_TEXT: l := C.sqlite3_value_bytes(v) c := unsafe.Pointer(C.sqlite3_value_text(v)) return reflect.ValueOf(C.GoBytes(c, l)), nil default: return reflect.Value{}, fmt.Errorf("argument must be BLOB or TEXT") } }
func generateSubkey(key []byte) (k1 []byte, k2 []byte) { if len(key) != 16 { panic("Invalid length.") } cK1 := (*C.uchar)(C.malloc(16)) defer C.free(unsafe.Pointer(cK1)) cK2 := (*C.uchar)(C.malloc(16)) defer C.free(unsafe.Pointer(cK2)) C.generate_subkey((*C.uchar)(&key[0]), cK1, cK2) return C.GoBytes(unsafe.Pointer(cK1), 16), C.GoBytes(unsafe.Pointer(cK2), 16) }
func NewDnetIOAttr(io *C.struct_dnet_io_attr) DnetIOAttr { return DnetIOAttr{ Parent: C.GoBytes(unsafe.Pointer(&io.parent[0]), C.int(C.DNET_ID_SIZE)), ID: C.GoBytes(unsafe.Pointer(&io.id[0]), C.int(C.DNET_ID_SIZE)), Start: uint64(C.dnet_io_attr_get_start(io)), Num: uint64(C.dnet_io_attr_get_num(io)), Timestamp: time.Unix(int64(C.dnet_io_attr_get_tsec(io)), int64(C.dnet_io_attr_get_tnsec(io))), UserFlags: uint64(C.dnet_io_attr_get_user_flags(io)), TotalSize: uint64(C.dnet_io_attr_get_total_size(io)), Flags: uint32(C.dnet_io_attr_get_flags(io)), Offset: uint64(C.dnet_io_attr_get_offset(io)), Size: uint64(C.dnet_io_attr_get_size(io)), RecordFlags: uint64(C.dnet_io_attr_get_record_flags(io)), } }
func (db *DB) get(ro *ReadOptions, key []byte) ([]byte, error) { var errStr *C.char var vallen C.size_t var k *C.char if len(key) != 0 { k = (*C.char)(unsafe.Pointer(&key[0])) } var value *C.char c := C.leveldb_get_ext( db.db, ro.Opt, k, C.size_t(len(key)), &value, &vallen, &errStr) if errStr != nil { return nil, saveError(errStr) } if value == nil { return nil, nil } defer C.leveldb_get_free_ext(unsafe.Pointer(c)) return C.GoBytes(unsafe.Pointer(value), C.int(vallen)), nil }
// function that lists all the xattrs for an object, since xattrs are // a k-v pair, this function returns a map of k-v pairs on // success, error code on failure func (ioctx *IOContext) ListXattrs(oid string) (map[string][]byte, error) { c_oid := C.CString(oid) defer C.free(unsafe.Pointer(c_oid)) var it C.rados_xattrs_iter_t ret := C.rados_getxattrs(ioctx.ioctx, c_oid, &it) if ret < 0 { return nil, GetRadosError(ret) } defer func() { C.rados_getxattrs_end(it) }() m := make(map[string][]byte) for { var c_name, c_val *C.char var c_len C.size_t defer C.free(unsafe.Pointer(c_name)) defer C.free(unsafe.Pointer(c_val)) ret := C.rados_getxattrs_next(it, &c_name, &c_val, &c_len) if ret < 0 { return nil, GetRadosError(ret) } // rados api returns a null name,val & 0-length upon // end of iteration if c_name == nil { return m, nil // stop iteration } m[C.GoString(c_name)] = C.GoBytes(unsafe.Pointer(c_val), (C.int)(c_len)) } }
func returnArray() []byte { var l C.int var buf *C.char C.return_array(&buf, &l) defer C.free(unsafe.Pointer(buf)) return C.GoBytes(unsafe.Pointer(buf), 12) }
// Encode image.Image with Mapniks image encoder. func Encode(img image.Image, format string) ([]byte, error) { var i *C.mapnik_image_t switch img := img.(type) { // XXX does mapnik expect NRGBA or RGBA? this might stop working //as expected if we start encoding images with full alpha channel case *image.NRGBA: i = C.mapnik_image_from_raw( (*C.uint8_t)(unsafe.Pointer(&img.Pix[0])), C.int(img.Bounds().Dx()), C.int(img.Bounds().Dy()), ) case *image.RGBA: i = C.mapnik_image_from_raw( (*C.uint8_t)(unsafe.Pointer(&img.Pix[0])), C.int(img.Bounds().Dx()), C.int(img.Bounds().Dy()), ) } if i == nil { return nil, errors.New("unable to create image from raw") } defer C.mapnik_image_free(i) cformat := C.CString(format) b := C.mapnik_image_to_blob(i, cformat) if b == nil { return nil, errors.New("mapnik: " + C.GoString(C.mapnik_image_last_error(i))) } C.free(unsafe.Pointer(cformat)) defer C.mapnik_image_blob_free(b) return C.GoBytes(unsafe.Pointer(b.ptr), C.int(b.len)), nil }