// LoadHTML loads the given content string with the specified baseURI. The MIME
// type of the document will be "text/html".
//
// See also: webkit_web_view_load_html at
// http://webkitgtk.org/reference/webkit2gtk/stable/WebKitWebView.html#webkit-web-view-load-html
func (v *WebView) LoadHTML(content, baseURI string) {
cContent := C.CString(content)
defer C.free(unsafe.Pointer(cContent))
cBaseURI := C.CString(baseURI)
defer C.free(unsafe.Pointer(cBaseURI))
C.webkit_web_view_load_html(v.webView, (*C.gchar)(cContent), (*C.gchar)(cBaseURI))
}
func (v *WebKitWebView) LoadHtmlString(content, base_uri string) {
pcontent := C.CString(content)
defer C.free_string(pcontent)
pbase_uri := C.CString(base_uri)
defer C.free_string(pbase_uri)
C.webkit_web_view_load_html_string(v.getWebView(), C.to_gcharptr(pcontent), C.to_gcharptr(pbase_uri))
}
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 (v *Reference) Rename(name string, force bool, sig *Signature, msg string) (*Reference, error) {
var ptr *C.git_reference
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
csig := sig.toC()
defer C.free(unsafe.Pointer(csig))
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_rename(&ptr, v.ptr, cname, cbool(force), csig, cmsg)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr), nil
}
func (provider *Provider) AddProbe(function string, name string, signature ...reflect.Kind) Probe {
cFunction := C.CString(function)
cName := C.CString(name)
defer C.free(unsafe.Pointer(cFunction))
defer C.free(unsafe.Pointer(cName))
cTypes := make([]*C.char, len(signature))
for i, kind := range signature {
switch kind {
case reflect.Int:
cTypes[i] = C.CString("int")
defer C.free(unsafe.Pointer(cTypes[i]))
case reflect.String:
cTypes[i] = C.CString("char *")
defer C.free(unsafe.Pointer(cTypes[i]))
default:
cTypes[i] = nil
}
}
probedef := C.usdt_create_probe(cFunction, cName, C.size_t(len(signature)), &cTypes[0])
C.usdt_provider_add_probe(provider.provider_t, probedef)
newProbe := Probe{
function,
name,
probedef,
}
provider.Probes = append(provider.Probes, newProbe)
return newProbe
}
func (e Enumerate) AddNoMatchSysAttr(sysattr string, value string) error {
err := C.udev_enumerate_add_match_sysattr(e.ptr, C.CString(sysattr), C.CString(value))
if err != 0 {
return Error(err)
}
return nil
}
// GetApproximateSizes returns the approximate number of bytes of file system
// space used by one or more key ranges.
//
// The keys counted will begin at Range.Start and end on the key before
// Range.Limit.
func (db *DB) GetApproximateSizes(ranges []Range) []uint64 {
starts := make([]*C.char, len(ranges))
limits := make([]*C.char, len(ranges))
startLens := make([]C.size_t, len(ranges))
limitLens := make([]C.size_t, len(ranges))
for i, r := range ranges {
starts[i] = C.CString(string(r.Start))
startLens[i] = C.size_t(len(r.Start))
limits[i] = C.CString(string(r.Limit))
limitLens[i] = C.size_t(len(r.Limit))
}
sizes := make([]uint64, len(ranges))
numranges := C.int(len(ranges))
startsPtr := &starts[0]
limitsPtr := &limits[0]
startLensPtr := &startLens[0]
limitLensPtr := &limitLens[0]
sizesPtr := (*C.uint64_t)(&sizes[0])
C.hyperleveldb_rocksdb_approximate_sizes(
db.Ldb, numranges, startsPtr, startLensPtr,
limitsPtr, limitLensPtr, sizesPtr)
for i := range ranges {
C.free(unsafe.Pointer(starts[i]))
C.free(unsafe.Pointer(limits[i]))
}
return sizes
}
// ConfigureTUN sets up the tun device, this is equivalent to the
// badvpn-tun2socks configuration, except for the --socks-server-addr.
func ConfigureTUN(tundev, ipaddr, netmask, udpgw string, d dialer) error {
if d == nil {
d = dummyDialer
}
Dialer = d
udpGwServerAddress = udpgw
ctundev := C.CString(tundev)
cipaddr := C.CString(ipaddr)
cnetmask := C.CString(netmask)
cudpgw_addr := C.CString(udpgw)
defer func() {
C.free(unsafe.Pointer(ctundev))
C.free(unsafe.Pointer(cipaddr))
C.free(unsafe.Pointer(cnetmask))
C.free(unsafe.Pointer(cudpgw_addr))
}()
log.Printf("Configuring with TUN device...")
if err_t := C.configure_tun(ctundev, cipaddr, cnetmask, cudpgw_addr); err_t != C.ERR_OK {
return errors.New("Failed to configure device.")
}
return nil
}
// Publish publishes an announcement at an interval
func (b *Beacon) Publish(announcement string, interval int) error {
cmd := C.CString("PUBLISH")
defer C.free(unsafe.Pointer(cmd))
cAnnouncement := C.CString(announcement)
defer C.free(unsafe.Pointer(cAnnouncement))
cInterval := C.CString(strconv.Itoa(interval))
defer C.free(unsafe.Pointer(cInterval))
rc := C.zstr_sendm(unsafe.Pointer(b.zactorT), cmd)
if rc == -1 {
return ErrActorCmd
}
rc = C.zstr_sendm(unsafe.Pointer(b.zactorT), cAnnouncement)
if rc == -1 {
return ErrActorCmd
}
rc = C.zstr_send(unsafe.Pointer(b.zactorT), cInterval)
if rc == -1 {
return ErrActorCmd
}
return nil
}
// CurrentUnitName attempts to retrieve the name of the systemd system unit
// from which the calling process has been invoked. It wraps the systemd
// `sd_pid_get_unit` call, with the same caveat: for processes not part of a
// systemd system unit, this function will return an error.
func CurrentUnitName() (unit string, err error) {
var h *libHandle
h, err = getHandle()
if err != nil {
return
}
defer func() {
if err1 := h.Close(); err1 != nil {
err = err1
}
}()
sym := C.CString("sd_pid_get_unit")
defer C.free(unsafe.Pointer(sym))
sd_pid_get_unit := C.dlsym(h.handle, sym)
if sd_pid_get_unit == nil {
err = fmt.Errorf("error resolving sd_pid_get_unit function")
return
}
var s string
u := C.CString(s)
defer C.free(unsafe.Pointer(u))
ret := C.my_sd_pid_get_unit(sd_pid_get_unit, 0, &u)
if ret < 0 {
err = fmt.Errorf("error calling sd_pid_get_unit: %v", syscall.Errno(-ret))
return
}
unit = C.GoString(u)
return
}
// ConfigureFD sets up the tun device using a file descriptor.
func ConfigureFD(tunFd int, tunMTU int, ipaddr, netmask, udpgw string, d dialer) error {
if d == nil {
d = dummyDialer
}
Dialer = d
udpGwServerAddress = udpgw
ctunFd := C.int(tunFd)
ctunMTU := C.int(tunMTU)
cipaddr := C.CString(ipaddr)
cnetmask := C.CString(netmask)
cudpgw_addr := C.CString(udpgw)
defer func() {
C.free(unsafe.Pointer(cipaddr))
C.free(unsafe.Pointer(cnetmask))
C.free(unsafe.Pointer(cudpgw_addr))
}()
log.Printf("Configuring with file descriptor...")
if err_t := C.configure_fd(ctunFd, ctunMTU, cipaddr, cnetmask, cudpgw_addr); err_t != C.ERR_OK {
return errors.New("Failed to configure device.")
}
return nil
}
// GetRunningSlice attempts to retrieve the name of the systemd slice in which
// the current process is running.
// This function is a wrapper around the libsystemd C library; if it cannot be
// opened, an error is returned.
func GetRunningSlice() (slice string, err error) {
var h *libHandle
h, err = getHandle()
if err != nil {
return
}
defer func() {
if err1 := h.Close(); err1 != nil {
err = err1
}
}()
sym := C.CString("sd_pid_get_slice")
defer C.free(unsafe.Pointer(sym))
sd_pid_get_slice := C.dlsym(h.handle, sym)
if sd_pid_get_slice == nil {
err = fmt.Errorf("error resolving sd_pid_get_slice function")
return
}
var s string
sl := C.CString(s)
defer C.free(unsafe.Pointer(sl))
ret := C.my_sd_pid_get_slice(sd_pid_get_slice, 0, &sl)
if ret < 0 {
err = fmt.Errorf("error calling sd_pid_get_slice: %v", syscall.Errno(-ret))
return
}
return C.GoString(sl), nil
}
func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool, signature *Signature, msg string) (*Branch, error) {
ref := new(Reference)
cBranchName := C.CString(branchName)
cForce := cbool(force)
cSignature, err := signature.toC()
if err != nil {
return nil, err
}
defer C.git_signature_free(cSignature)
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_create(&ref.ptr, repo.ptr, cBranchName, target.cast_ptr, cForce, cSignature, cmsg)
if ret < 0 {
return nil, MakeGitError(ret)
}
return ref.Branch(), nil
}
func (b *Branch) Move(newBranchName string, force bool, signature *Signature, msg string) (*Branch, error) {
var ptr *C.git_reference
cNewBranchName := C.CString(newBranchName)
cForce := cbool(force)
cSignature, err := signature.toC()
if err != nil {
return nil, err
}
defer C.git_signature_free(cSignature)
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_branch_move(&ptr, b.Reference.ptr, cNewBranchName, cForce, cSignature, cmsg)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr, b.repo).Branch(), nil
}
func sqlOpen(name string, flags int, vfs string) (conn *sqlConnection, rc int) {
conn = new(sqlConnection)
p := C.CString(name)
if len(vfs) > 0 {
q := C.CString(vfs)
rc = int(C.sqlite3_open_v2(p, &conn.handle, C.int(flags), q))
C.free(unsafe.Pointer(q))
} else {
rc = int(C.sqlite3_open_v2(p, &conn.handle, C.int(flags), nil))
}
C.free(unsafe.Pointer(p))
// We could get a handle even if there's an error, see
// http://www.sqlite.org/c3ref/open.html for details.
// Initially we didn't want to return a connection on
// error, but we actually have to since we want to fill
// in a SystemError struct. Sigh.
// if rc != StatusOk && conn.handle != nil {
// _ = conn.sqlClose();
// conn = nil;
// }
return
}
// void dsyevd_(char *jobz, char *uplo, int *n, double *A, int *ldA, double *W,
// double *work, int *lwork, int *iwork, int *liwork, int *info);
func dsyevd(jobz, uplo string, N int, A []float64, lda int, W []float64) int {
var info int = 0
var lwork int = -1
var liwork int = -1
var iwork int32
var work float64
cjobz := C.CString(jobz)
defer C.free(unsafe.Pointer(cjobz))
cuplo := C.CString(uplo)
defer C.free(unsafe.Pointer(cuplo))
// pre-calculate work buffer size
C.dsyevd_(cjobz, cuplo, (*C.int)(unsafe.Pointer(&N)), nil,
(*C.int)(unsafe.Pointer(&lda)), nil,
(*C.double)(unsafe.Pointer(&work)), (*C.int)(unsafe.Pointer(&lwork)),
(*C.int)(unsafe.Pointer(&iwork)), (*C.int)(unsafe.Pointer(&liwork)),
(*C.int)(unsafe.Pointer(&info)))
// allocate work area
lwork = int(work)
wbuf := make([]float64, lwork)
liwork = int(iwork)
wibuf := make([]int32, liwork)
C.dsyevd_(cjobz, cuplo, (*C.int)(unsafe.Pointer(&N)),
(*C.double)(unsafe.Pointer(&A[0])),
(*C.int)(unsafe.Pointer(&lda)), (*C.double)(unsafe.Pointer(&W[0])),
(*C.double)(unsafe.Pointer(&wbuf[0])), (*C.int)(unsafe.Pointer(&lwork)),
(*C.int)(unsafe.Pointer(&wibuf[0])), (*C.int)(unsafe.Pointer(&liwork)),
(*C.int)(unsafe.Pointer(&info)))
return info
}
func (conn *connection) performLogon(dsn string) error {
user, pwd, host := parseDsn(dsn)
puser := C.CString(user)
defer C.free(unsafe.Pointer(puser))
ppwd := C.CString(pwd)
defer C.free(unsafe.Pointer(ppwd))
phost := C.CString(host)
defer C.free(unsafe.Pointer(phost))
result := C.OCILogon2((*C.OCIEnv)(unsafe.Pointer(conn.env)),
(*C.OCIError)(conn.err),
(**C.OCIServer)(unsafe.Pointer(&conn.svr)),
(*C.OraText)(unsafe.Pointer(puser)),
C.ub4(C.strlen(puser)),
(*C.OraText)(unsafe.Pointer(ppwd)),
C.ub4(C.strlen(ppwd)),
(*C.OraText)(unsafe.Pointer(phost)),
C.ub4(C.strlen(phost)),
C.OCI_LOGON2_STMTCACHE)
if result != C.OCI_SUCCESS {
return ociGetError(conn.err)
}
return nil
}
func NewTrailDBConstructor(path string, ofields ...string) (*TrailDBConstructor, error) {
cons := C.tdb_cons_init()
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
var ofield_p *C.char
ptrSize := unsafe.Sizeof(ofield_p)
// Allocate the char** list.
ptr := C.malloc(C.size_t(len(ofields)) * C.size_t(ptrSize))
defer C.free(ptr)
// Assign each byte slice to its appropriate offset.
for i := 0; i < len(ofields); i++ {
element := (**C.char)(unsafe.Pointer(uintptr(ptr) + uintptr(i)*ptrSize))
cofield := C.CString(ofields[i])
defer C.free(unsafe.Pointer(cofield))
*element = cofield
}
if err := C.tdb_cons_open(cons, cpath, (**C.char)(ptr), C.uint64_t(len(ofields))); err != 0 {
return nil, errors.New(errToString(err))
}
return &TrailDBConstructor{
cons: cons,
path: path,
ofields: ofields,
valueLengths: make([]C.uint64_t, len(ofields)),
valuePtr: C.malloc(C.size_t(len(ofields)) * C.size_t(ptrSize)),
}, nil
}
func (e Enumerate) AddMatchProperty(property string, value string) error {
err := C.udev_enumerate_add_match_property(e.ptr, C.CString(property), C.CString(value))
if err != 0 {
return Error(err)
}
return nil
}
func (p *Comment) AddTag(tag string, contents string) {
cTag := C.CString(tag)
cContents := C.CString(contents)
C.vorbis_comment_add_tag((*C.vorbis_comment)(p), cTag, cContents)
C.free(unsafe.Pointer(cTag))
C.free(unsafe.Pointer(cContents))
}
func (v *Reference) SetSymbolicTarget(target string, sig *Signature, msg string) (*Reference, error) {
var ptr *C.git_reference
ctarget := C.CString(target)
defer C.free(unsafe.Pointer(ctarget))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
csig := sig.toC()
defer C.free(unsafe.Pointer(csig))
var cmsg *C.char
if msg == "" {
cmsg = nil
} else {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
ret := C.git_reference_symbolic_set_target(&ptr, v.ptr, ctarget, csig, cmsg)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr), nil
}
// Create a new layer on the data source
func (ds DataSource) CreateLayer(
name string,
sr SpatialReference,
geomType GeometryType,
options []string,
) Layer {
cName := C.CString(name)
defer C.free(unsafe.Pointer(cName))
length := len(options)
opts := make([]*C.char, length+1)
for i := 0; i < length; i++ {
opts[i] = C.CString(options[i])
defer C.free(unsafe.Pointer(opts[i]))
}
opts[length] = (*C.char)(unsafe.Pointer(nil))
layer := C.OGR_DS_CreateLayer(
ds.cval,
cName,
sr.cval,
C.OGRwkbGeometryType(geomType),
(**C.char)(unsafe.Pointer(&opts[0])),
)
return Layer{layer}
}
// VlmAddVOD adds a VOD with given input.
//
// name: The name of the new broadcast.
// input: The input MRL.
// options: Additional options.
// mux: The muxer of the vod media.
// enabled: Enable the new broadcast?
//
func (this *Instance) VlmAddVOD(name, input, output, mux string, options []string, enabled bool) error {
if this.ptr == nil {
return os.EINVAL
}
a := C.CString(name)
b := C.CString(input)
c := C.int(len(options))
d := make([]*C.char, len(options))
for i := range d {
d[i] = C.CString(options[i])
}
var e C.int
if enabled {
e = 1
}
f := C.CString(mux)
C.libvlc_vlm_add_vod(this.ptr, a, b, c, *(***C.char)(unsafe.Pointer(&d)), e, f)
C.free(unsafe.Pointer(a))
C.free(unsafe.Pointer(b))
for i := range d {
C.free(unsafe.Pointer(d[i]))
}
C.free(unsafe.Pointer(f))
return checkError()
}
func Clone(url string, path string, options *CloneOptions) (*Repository, error) {
repo := new(Repository)
curl := C.CString(url)
defer C.free(unsafe.Pointer(curl))
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
var copts C.git_clone_options
populateCloneOptions(&copts, options)
defer freeCheckoutOpts(&copts.checkout_opts)
if len(options.CheckoutBranch) != 0 {
copts.checkout_branch = C.CString(options.CheckoutBranch)
defer C.free(unsafe.Pointer(copts.checkout_branch))
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_clone(&repo.ptr, curl, cpath, &copts)
if ret < 0 {
return nil, MakeGitError(ret)
}
runtime.SetFinalizer(repo, (*Repository).Free)
return repo, nil
}
// Create a codec which convert a string encoded in fromcode into a string
// encoded in tocode
//
// If you add //TRANSLIT at the end of tocode, any character which doesn't
// exists in the destination charset will be replaced by its closest
// equivalent (for example, € will be represented by EUR in ASCII). Else,
// such a character will trigger an error.
func Open(tocode string, fromcode string) (*Iconv, error) {
ret, err := C.iconv_open(C.CString(tocode), C.CString(fromcode))
if err != nil {
return nil, err
}
return &Iconv{ret}, nil
}
// MONGO_EXPORT int mongo_update( mongo *conn, const char *ns, const bson *cond,
// const bson *op, int flags, mongo_write_concern *custom_write_concern );
func (m *Mongo) Update(ns string, cond, op *Bson, flags int, writeConcern *MongoWriteConcern) int {
if writeConcern == nil {
return int(C.mongo_update(m.conn, C.CString(ns), cond._bson, op._bson, C.int(flags), nil))
}
return int(C.mongo_update(m.conn, C.CString(ns), cond._bson,
op._bson, C.int(flags), writeConcern.writeConcern))
}
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
}
// Remove the specified `keys` from the omap `oid`
func (ioctx *IOContext) RmOmapKeys(oid string, keys []string) error {
c_oid := C.CString(oid)
defer C.free(unsafe.Pointer(c_oid))
var c *C.char
ptrSize := unsafe.Sizeof(c)
c_keys := C.malloc(C.size_t(len(keys)) * C.size_t(ptrSize))
defer C.free(unsafe.Pointer(c_keys))
i := 0
for _, key := range keys {
c_key_ptr := (**C.char)(unsafe.Pointer(uintptr(c_keys) + uintptr(i)*ptrSize))
*c_key_ptr = C.CString(key)
defer C.free(unsafe.Pointer(*c_key_ptr))
i++
}
op := C.rados_create_write_op()
C.rados_write_op_omap_rm_keys(
op,
(**C.char)(c_keys),
C.size_t(len(keys)))
ret := C.rados_write_op_operate(op, ioctx.ioctx, c_oid, nil, 0)
C.rados_release_write_op(op)
return GetRadosError(ret)
}
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
}
// Sets the authority for a node
func (sr SpatialReference) SetAuthority(target, authority string, code int) error {
cTarget := C.CString(target)
defer C.free(unsafe.Pointer(cTarget))
cAuthority := C.CString(authority)
defer C.free(unsafe.Pointer(cAuthority))
return C.OSRSetAuthority(sr.cval, cTarget, cAuthority, C.int(code)).Err()
}