//export callback_friend_request func callback_friend_request( c_tox *C.Tox, c_public_key *C.uint8_t, c_message *C.uint8_t, c_length C.size_t, c_user_data unsafe.Pointer, ) { // Initialize variables. tox := (*Tox)(c_user_data) var publicKey ToxPublicKey message := make([]byte, c_length) // Copy the public key. C.memcpy( unsafe.Pointer(&publicKey[0]), unsafe.Pointer(c_public_key), ToxPublicKeySize, ) // Copy the friend request message. if c_length > 0 { C.memcpy( unsafe.Pointer(&message[0]), unsafe.Pointer(c_message), c_length, ) } // Register the callback. tox.onFriendRequest(tox, publicKey, message) }
// GetProperty() retreives the given attribute or freeform property // string on the underlying Image func (im *MagickImage) GetProperty(prop string) (value string) { c_prop := C.CString(prop) defer C.free(unsafe.Pointer(c_prop)) c_value := C.GetImageProperty(im.Image, c_prop) defer C.free(unsafe.Pointer(c_value)) return C.GoString(c_value) }
// Returns the list of available screen dimensions for the given format. // // NOTE: The result of this function uses a different encoding than the underlying C function. // It returns an empty array if no modes are available, // and nil if any dimension is okay for the given format. func ListModes(format *PixelFormat, flags uint32) []Rect { modes := C.SDL_ListModes((*C.SDL_PixelFormat)(cast(format)), C.Uint32(flags)) // No modes available if modes == nil { return make([]Rect, 0) } // (modes == -1) --> Any dimension is ok if uintptr(unsafe.Pointer(modes))+1 == uintptr(0) { return nil } count := 0 ptr := *modes //first element in the list for ptr != nil { count++ ptr = *(**C.SDL_Rect)(unsafe.Pointer(uintptr(unsafe.Pointer(modes)) + uintptr(count*unsafe.Sizeof(ptr)))) } ret := make([]Rect, count) for i := 0; i < count; i++ { ptr := (**C.SDL_Rect)(unsafe.Pointer(uintptr(unsafe.Pointer(modes)) + uintptr(i*unsafe.Sizeof(*modes)))) var r *C.SDL_Rect = *ptr ret[i].X = int16(r.x) ret[i].Y = int16(r.y) ret[i].W = uint16(r.w) ret[i].H = uint16(r.h) } return ret }
func mount(source string, target string, fstype string, flags uintptr, data *byte) (err error) { var _p0 *byte _p0, err = BytePtrFromString(source) if err != nil { return } var _p1 *byte _p1, err = BytePtrFromString(target) if err != nil { return } var _p2 *byte _p2, err = BytePtrFromString(fstype) if err != nil { return } _, _, e1 := Syscall6(SYS_MOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(data)), 0) use(unsafe.Pointer(_p0)) use(unsafe.Pointer(_p1)) use(unsafe.Pointer(_p2)) if e1 != 0 { err = errnoErr(e1) } return }
func getBuffer(s *reflect.SliceHeader, p *C.PaStreamParameters) (unsafe.Pointer, int, error) { if p.sampleFormat&C.paNonInterleaved == 0 { n := int(p.channelCount) if s.Len%n != 0 { return nil, 0, fmt.Errorf("length of interleaved buffer not divisible by number of channels") } return unsafe.Pointer(s.Data), s.Len / n, nil } else { if s.Len != int(p.channelCount) { return nil, 0, fmt.Errorf("buffer has wrong number of channels") } buf := make([]uintptr, s.Len) frames := -1 sp := s.Data for i := range buf { ch := (*reflect.SliceHeader)(unsafe.Pointer(sp)) if frames == -1 { frames = ch.Len } else if ch.Len != frames { return nil, 0, fmt.Errorf("channels have different lengths") } buf[i] = ch.Data sp += unsafe.Sizeof(reflect.SliceHeader{}) } return unsafe.Pointer(&buf[0]), frames, nil } }
func (ic *Iconv) convert(input []byte, out io.Writer, outBuf []byte) (bytesConverted int, err error) { inputLen := len(input) if inputLen == 0 { return } outputLen := len(outBuf) if outputLen == 0 { outputLen = inputLen outBuf = make([]byte, outputLen) } outputPtr := &outBuf[0] outputPtrPtr := (**C.char)(unsafe.Pointer(&outputPtr)) outputBytesLeft := C.size_t(outputLen) inputPtr := &input[0] inputPtrPtr := (**C.char)(unsafe.Pointer(&inputPtr)) inputBytesLeft := C.size_t(inputLen) _, err = C.iconv(ic.pIconv, inputPtrPtr, &inputBytesLeft, outputPtrPtr, &outputBytesLeft) bytesConverted = inputLen - int(inputBytesLeft) if int(outputBytesLeft) < outputLen { out.Write(outBuf[:outputLen-int(outputBytesLeft)]) } return }
func (c *driverConn) Prepare(query string) (driver.Stmt, error) { // Generate unique statement name. stmtname := strconv.Itoa(c.stmtNum) cstmtname := C.CString(stmtname) c.stmtNum++ defer C.free(unsafe.Pointer(cstmtname)) stmtstr := C.CString(query) defer C.free(unsafe.Pointer(stmtstr)) res := C.PQprepare(c.db, cstmtname, stmtstr, 0, nil) err := resultError(res) if err != nil { C.PQclear(res) return nil, err } stmtinfo := C.PQdescribePrepared(c.db, cstmtname) err = resultError(stmtinfo) if err != nil { C.PQclear(stmtinfo) return nil, err } defer C.PQclear(stmtinfo) nparams := int(C.PQnparams(stmtinfo)) statement := &driverStmt{stmtname, c.db, res, nparams} runtime.SetFinalizer(statement, (*driverStmt).Close) return statement, nil }
func (bnd *bndTimePtr) bind(value *time.Time, position int, stmt *Stmt) error { bnd.stmt = stmt bnd.value = value r := C.OCIDescriptorAlloc( unsafe.Pointer(bnd.stmt.ses.srv.env.ocienv), //CONST dvoid *parenth, (*unsafe.Pointer)(unsafe.Pointer(&bnd.ociDateTime)), //dvoid **descpp, C.OCI_DTYPE_TIMESTAMP_TZ, //ub4 type, 0, //size_t xtramem_sz, nil) //dvoid **usrmempp); if r == C.OCI_ERROR { return bnd.stmt.ses.srv.env.ociError() } else if r == C.OCI_INVALID_HANDLE { return errNew("unable to allocate oci timestamp handle during bind") } r = C.OCIBINDBYPOS( bnd.stmt.ocistmt, //OCIStmt *stmtp, (**C.OCIBind)(&bnd.ocibnd), //OCIBind **bindpp, bnd.stmt.ses.srv.env.ocierr, //OCIError *errhp, C.ub4(position), //ub4 position, unsafe.Pointer(&bnd.ociDateTime), //void *valuep, C.LENGTH_TYPE(unsafe.Sizeof(bnd.ociDateTime)), //sb8 value_sz, C.SQLT_TIMESTAMP_TZ, //ub2 dty, unsafe.Pointer(&bnd.isNull), //void *indp, nil, //ub2 *alenp, nil, //ub2 *rcodep, 0, //ub4 maxarr_len, nil, //ub4 *curelep, C.OCI_DEFAULT) //ub4 mode ); if r == C.OCI_ERROR { return bnd.stmt.ses.srv.env.ociError() } return nil }
// Sets the debugging hook function. // // Argument fn is the hook function. mask specifies on which events the hook // will be called: it is formed by a bitwise OR of the constants Maskcall, // Maskret, Maskline, and Maskcount. The count argument is only meaningful // when the mask includes Maskcount. The hook is called for each event type // present in mask. // // A hook is disabled by setting mask to 0. func (s *State) Sethook(fn Hook, mask, count int) error { s.Getglobal(namehooks) if mask&Maskcall == Maskcall { s.Pushstring(namecall) s.Pushlightuserdata(unsafe.Pointer(&fn)) s.Settable(-3) } if mask&Maskret == Maskret { s.Pushstring(nameret) s.Pushlightuserdata(unsafe.Pointer(&fn)) s.Settable(-3) } if mask&Maskline == Maskline { s.Pushstring(nameline) s.Pushlightuserdata(unsafe.Pointer(&fn)) s.Settable(-3) } if mask&Maskcount == Maskcount { s.Pushstring(namecount) s.Pushlightuserdata(unsafe.Pointer(&fn)) s.Settable(-3) } s.Pop(1) // pop hook table C.sethook(s.l, C.int(mask), C.int(count)) return nil }
func init() { // CUDA driver kernel call wants pointers to arguments, set them up once. zeromask_args.argptr[0] = unsafe.Pointer(&zeromask_args.arg_dst) zeromask_args.argptr[1] = unsafe.Pointer(&zeromask_args.arg_maskLUT) zeromask_args.argptr[2] = unsafe.Pointer(&zeromask_args.arg_regions) zeromask_args.argptr[3] = unsafe.Pointer(&zeromask_args.arg_N) }
// CmdGetMapped returns the interface settings in a map func (e *Ethtool) CmdGetMapped(intf string) (map[string]uint64, error) { ecmd := EthtoolCmd{ Cmd: ETHTOOL_GSET, } var name [IFNAMSIZ]byte copy(name[:], []byte(intf)) ifr := ifreq{ ifr_name: name, ifr_data: uintptr(unsafe.Pointer(&ecmd)), } _, _, ep := syscall.Syscall(syscall.SYS_IOCTL, uintptr(e.fd), SIOCETHTOOL, uintptr(unsafe.Pointer(&ifr))) if ep != 0 { return nil, syscall.Errno(ep) } var result = make(map[string]uint64) // ref https://gist.github.com/drewolson/4771479 // Golang Reflection Example ecmd.reflect(&result) var speedval uint32 = (uint32(ecmd.Speed_hi) << 16) | (uint32(ecmd.Speed) & 0xffff) result["speed"] = uint64(speedval) return result, nil }
func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) { fd, e := socketcall(_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0) if e != 0 { err = e } return }
//export callback_friend_message func callback_friend_message( c_tox *C.Tox, c_friend_number C.uint32_t, c_message_type C.TOX_MESSAGE_TYPE, c_message *C.uint8_t, c_length C.size_t, c_user_data unsafe.Pointer, ) { // Initialize variables. tox := (*Tox)(c_user_data) friendNumber := uint32(c_friend_number) var messageType ToxMessageType switch c_message_type { case C.TOX_MESSAGE_TYPE_NORMAL: messageType = ToxMessageTypeNormal case C.TOX_MESSAGE_TYPE_ACTION: messageType = ToxMessageTypeAction } message := make([]byte, c_length) // Copy the chat message. if c_length > 0 { C.memcpy( unsafe.Pointer(&message[0]), unsafe.Pointer(c_message), c_length, ) } // Register the callback. tox.onFriendMessage(tox, friendNumber, messageType, message) }
func connect(conninfo string) (*PgConn, error) { cs := C.CString(conninfo) defer C.free(unsafe.Pointer(cs)) conn := C.PQconnectdb(cs) if C.PQstatus(conn) != C.CONNECTION_OK { cerr := C.PQerrorMessage(conn) err := fmt.Errorf("connection failed: %s", C.GoString(cerr)) C.PQfinish(conn) return nil, err } // TODO: support other encodings? pname := C.CString("client_encoding") defer C.free(unsafe.Pointer(pname)) cenc := C.PQparameterStatus(conn, pname) if cenc == nil { err := errors.New("connection failed: no client encoding") C.PQfinish(conn) return nil, err } if enc := C.GoString(cenc); enc != "UTF8" { err := fmt.Errorf( "connection failed: client encoding not supported: %s", enc) C.PQfinish(conn) return nil, err } // one-line error message C.PQsetErrorVerbosity(conn, C.PQERRORS_TERSE) return &PgConn{conn: conn, conninfo: conninfo}, nil }
//raise a pubkey to the power of a seckey func ECDH(pub []byte, sec []byte) []byte { if len(sec) != 32 { log.Panic() } if len(pub) != 33 { log.Panic() } if VerifyPubkey(pub) != 1 { log.Printf("Invalid Pubkey") return nil } if VerifySeckey(sec) != 1 { log.Printf("Invalid Seckey") } var pub2 []byte = make([]byte, 33) copy(pub2[0:33], pub[0:33]) var pub_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&pub2[0])) var sec_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&sec[0])) ret := C.secp256k1_ecdsa_pubkey_tweak_mul( pub_ptr, C.int(len(pub2)), sec_ptr, ) if ret != 1 { return nil } return pub2 }
// Marshal returns the binary encoding of the IPv4 header h. func (h *Header) Marshal() ([]byte, error) { if h == nil { return nil, syscall.EINVAL } if h.Len < HeaderLen { return nil, errHeaderTooShort } hdrlen := HeaderLen + len(h.Options) b := make([]byte, hdrlen) b[0] = byte(Version<<4 | (hdrlen >> 2 & 0x0f)) b[posTOS] = byte(h.TOS) if supportsNewIPInput { b[posTotalLen], b[posTotalLen+1] = byte(h.TotalLen>>8), byte(h.TotalLen) b[posFragOff], b[posFragOff+1] = byte(h.FragOff>>8), byte(h.FragOff) } else { *(*uint16)(unsafe.Pointer(&b[posTotalLen : posTotalLen+1][0])) = uint16(h.TotalLen) *(*uint16)(unsafe.Pointer(&b[posFragOff : posFragOff+1][0])) = uint16(h.FragOff) } b[posID], b[posID+1] = byte(h.ID>>8), byte(h.ID) b[posTTL] = byte(h.TTL) b[posProtocol] = byte(h.Protocol) b[posChecksum], b[posChecksum+1] = byte(h.Checksum>>8), byte(h.Checksum) if ip := h.Src.To4(); ip != nil { copy(b[posSrc:posSrc+net.IPv4len], ip[0:net.IPv4len]) } if ip := h.Dst.To4(); ip != nil { copy(b[posDst:posDst+net.IPv4len], ip[0:net.IPv4len]) } else { return nil, errMissingAddress } if len(h.Options) > 0 { copy(b[HeaderLen:], h.Options) } return b, nil }
func GenerateKeyPair() ([]byte, []byte) { pubkey_len := C.int(33) const seckey_len = 32 var pubkey []byte = make([]byte, pubkey_len) var pubkey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&pubkey[0])) var ret C.int new_seckey: var seckey []byte = RandByte(seckey_len) var seckey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&seckey[0])) ret = C.secp256k1_ecdsa_seckey_verify(seckey_ptr) if ret != 1 { goto new_seckey } //for C.secp256k1_ecdsa_seckey_verify(seckey_ptr) != 1 { // seckey = RandByte(seckey_len) // seckey_ptr = (*C.uchar)(unsafe.Pointer(&seckey[0])) //} ret = C.secp256k1_ecdsa_pubkey_create( pubkey_ptr, &pubkey_len, seckey_ptr, 1) if ret != 1 { goto new_seckey } return pubkey, seckey }
// ParseHeader parses b as an IPv4 header. func ParseHeader(b []byte) (*Header, error) { if len(b) < HeaderLen { return nil, errHeaderTooShort } hdrlen := (int(b[0]) & 0x0f) << 2 if hdrlen > len(b) { return nil, errBufferTooShort } h := &Header{} h.Version = int(b[0] >> 4) h.Len = hdrlen h.TOS = int(b[posTOS]) if supportsNewIPInput { h.TotalLen = int(b[posTotalLen])<<8 | int(b[posTotalLen+1]) h.FragOff = int(b[posFragOff])<<8 | int(b[posFragOff+1]) } else { h.TotalLen = int(*(*uint16)(unsafe.Pointer(&b[posTotalLen : posTotalLen+1][0]))) h.TotalLen += hdrlen h.FragOff = int(*(*uint16)(unsafe.Pointer(&b[posFragOff : posFragOff+1][0]))) } h.ID = int(b[posID])<<8 | int(b[posID+1]) h.TTL = int(b[posTTL]) h.Protocol = int(b[posProtocol]) h.Checksum = int(b[posChecksum])<<8 | int(b[posChecksum+1]) h.Src = net.IPv4(b[posSrc], b[posSrc+1], b[posSrc+2], b[posSrc+3]) h.Dst = net.IPv4(b[posDst], b[posDst+1], b[posDst+2], b[posDst+3]) if hdrlen-HeaderLen > 0 { h.Options = make([]byte, hdrlen-HeaderLen) copy(h.Options, b[HeaderLen:]) } return h, nil }
func (def *defUint64) value() (value interface{}, err error) { if def.isNullable { oraUint64Value := Uint64{IsNull: def.null < C.sb2(0)} if !oraUint64Value.IsNull { r := C.OCINumberToInt( def.rset.stmt.ses.srv.env.ocierr, //OCIError *err, &def.ociNumber, //const OCINumber *number, C.uword(8), //uword rsl_length, C.OCI_NUMBER_UNSIGNED, //uword rsl_flag, unsafe.Pointer(&oraUint64Value.Value)) //void *rsl ); if r == C.OCI_ERROR { err = def.rset.stmt.ses.srv.env.ociError() } } value = oraUint64Value } else { if def.null > C.sb2(-1) { var uint64Value uint64 r := C.OCINumberToInt( def.rset.stmt.ses.srv.env.ocierr, //OCIError *err, &def.ociNumber, //const OCINumber *number, C.uword(8), //uword rsl_length, C.OCI_NUMBER_UNSIGNED, //uword rsl_flag, unsafe.Pointer(&uint64Value)) //void *rsl ); if r == C.OCI_ERROR { err = def.rset.stmt.ses.srv.env.ociError() } value = uint64Value } } return value, err }
func (self *Surface) ClipRectangleList() ([]Rectangle, Status) { list := C.cairo_copy_clip_rectangle_list(self.context) defer C.cairo_rectangle_list_destroy(list) rects := make([]Rectangle, int(list.num_rectangles)) C.memcpy(unsafe.Pointer(&rects[0]), unsafe.Pointer(list.rectangles), C.size_t(list.num_rectangles*8)) return rects, Status(list.status) }
func OpenWithFallback(fromCode string, toCode string, fallbackPolicy int) (ic *Iconv, err error) { var pIconv C.iconv_t toCodeCharPtr := C.CString(toCode) defer C.free(unsafe.Pointer(toCodeCharPtr)) fromCodeCharPtr := C.CString(fromCode) defer C.free(unsafe.Pointer(fromCodeCharPtr)) pIconv, err = C.iconv_open(toCodeCharPtr, fromCodeCharPtr) if err == nil { if pIconv == nil { err = NilIconvPointer return } if fallbackPolicy == DISCARD_UNRECOGNIZED { ic = &Iconv{pIconv: pIconv, fallbackPolicy: fallbackPolicy, fallback: fallbackDiscardUnrecognized} } else if fallbackPolicy == KEEP_UNRECOGNIZED { ic = &Iconv{pIconv: pIconv, fallbackPolicy: fallbackPolicy, fallback: fallbackKeepIntactUnrecognized} } else if fallbackPolicy == NEXT_ENC_UNRECOGNIZED { ic = &Iconv{pIconv: pIconv, fallbackPolicy: fallbackPolicy} } else { err = InvalidFallbackPolicy } } return }
func (self *Surface) Native() (surface, context uintptr) { surface = uintptr(unsafe.Pointer(self.surface)) context = uintptr(unsafe.Pointer(self.context)) return }
func (z *zeroconf) removePrinter(name string) error { z.spMutex.Lock() defer z.spMutex.Unlock() r, exists := z.printers[name] if !exists { return fmt.Errorf("printer %s cannot be updated for Avahi publishing; it was never added", name) } if z.state == C.AVAHI_CLIENT_S_RUNNING && r.group != nil { C.avahi_threaded_poll_lock(z.threadedPoll) defer C.avahi_threaded_poll_unlock(z.threadedPoll) var errstr *C.char C.removeAvahiGroup(z.threadedPoll, r.group, &errstr) if errstr != nil { err := errors.New(C.GoString(errstr)) C.free(unsafe.Pointer(errstr)) return err } } C.free(unsafe.Pointer(r.name)) delete(z.printers, name) return nil }
//generates deterministic keypair with weak SHA256 hash of seed //internal use only //be extremely careful with golang slice semantics func generateDeterministicKeyPair(seed []byte) ([]byte, []byte) { if seed == nil { log.Panic() } pubkey_len := C.int(33) const seckey_len = 32 var pubkey []byte = make([]byte, pubkey_len) var seckey []byte = make([]byte, seckey_len) var pubkey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&pubkey[0])) var seckey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&seckey[0])) new_seckey: seed = SumSHA256(seed[0:32]) copy(seckey[0:32], seed[0:32]) if C.secp256k1_ecdsa_seckey_verify(seckey_ptr) != 1 { goto new_seckey //rehash seckey until it succeeds, almost never happens } ret := C.secp256k1_ecdsa_pubkey_create( pubkey_ptr, &pubkey_len, seckey_ptr, 1) if ret != 1 { log.Panic("secp256k1-g0, generateDeterministicKeyPair, pubkey generation failing for valid seckey") } return pubkey, seckey }
// May run with m.p==nil, so write barriers are not allowed. //go:nowritebarrier func newosproc(mp *m, _ unsafe.Pointer) { var ( attr pthreadattr oset sigset tid pthread ret int32 size uint64 ) if pthread_attr_init(&attr) != 0 { throw("pthread_attr_init") } if pthread_attr_setstack(&attr, 0, 0x200000) != 0 { throw("pthread_attr_setstack") } if pthread_attr_getstack(&attr, unsafe.Pointer(&mp.g0.stack.hi), &size) != 0 { throw("pthread_attr_getstack") } mp.g0.stack.lo = mp.g0.stack.hi - uintptr(size) if pthread_attr_setdetachstate(&attr, _PTHREAD_CREATE_DETACHED) != 0 { throw("pthread_attr_setdetachstate") } // Disable signals during create, so that the new thread starts // with signals disabled. It will enable them in minit. sigprocmask(_SIG_SETMASK, &sigset_all, &oset) ret = pthread_create(&tid, &attr, funcPC(tstart_sysvicall), unsafe.Pointer(mp)) sigprocmask(_SIG_SETMASK, &oset, nil) if ret != 0 { print("runtime: failed to create new OS thread (have ", mcount(), " already; errno=", ret, ")\n") throw("newosproc") } }
//generate signature in repeatable way func SignDeterministic(msg []byte, seckey []byte, nonce_seed []byte) []byte { nonce := SumSHA256(nonce_seed) //deterministicly generate nonce var sig []byte = make([]byte, 65) var recid C.int var msg_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&msg[0])) var seckey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&seckey[0])) var nonce_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&nonce[0])) var sig_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&sig[0])) if C.secp256k1_ecdsa_seckey_verify(seckey_ptr) != C.int(1) { log.Panic("Invalid secret key") } ret := C.secp256k1_ecdsa_sign_compact( msg_ptr, C.int(len(msg)), sig_ptr, seckey_ptr, nonce_ptr, &recid) sig[64] = byte(int(recid)) if int(recid) > 4 { log.Panic() } if ret != 1 { return SignDeterministic(msg, seckey, nonce_seed) //nonce invalid,retry } return sig }
func Nanosleep(time *Timespec, leftover *Timespec) (err error) { _, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) if e1 != 0 { err = errnoErr(e1) } return }
//recovers the public key from the signature //recovery of pubkey means correct signature func RecoverPubkey(msg []byte, sig []byte) []byte { if len(sig) != 65 { log.Panic() } var pubkey []byte = make([]byte, 33) var msg_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&msg[0])) var sig_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&sig[0])) var pubkey_ptr *C.uchar = (*C.uchar)(unsafe.Pointer(&pubkey[0])) var pubkeylen C.int ret := C.secp256k1_ecdsa_recover_compact( msg_ptr, C.int(len(msg)), sig_ptr, pubkey_ptr, &pubkeylen, C.int(1), C.int(sig[64]), ) if ret == 0 || int(pubkeylen) != 33 { return nil } return pubkey }
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 }
// Delete the actual bridge device. func DeleteBridge(name string) error { s, err := getIfSocket() if err != nil { return err } defer syscall.Close(s) nameBytePtr, err := syscall.BytePtrFromString(name) if err != nil { return err } var ifr ifreqFlags copy(ifr.IfrnName[:len(ifr.IfrnName)-1], []byte(name)) if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(s), syscall.SIOCSIFFLAGS, uintptr(unsafe.Pointer(&ifr))); err != 0 { return err } if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(s), SIOC_BRDELBR, uintptr(unsafe.Pointer(nameBytePtr))); err != 0 { return err } return nil }