Golang C.u_int32_t函数代码示例

// NewRing creates a new PFRing.  Note that when the ring is initially created,
// it is disabled.  The caller must call Enable to start receiving packets.
// The caller should call Close on the given ring when finished with it.
func NewRing(device string, snaplen uint32, flags Flag) (ring *Ring, _ error) {
	dev := C.CString(device)
	defer C.free(unsafe.Pointer(dev))

	cptr, err := C.pfring_open(dev, C.u_int32_t(snaplen), C.u_int32_t(flags))
	if cptr == nil || err != nil {
		return nil, fmt.Errorf("pfring NewRing error: %v", err)
	}
	ring = &Ring{cptr: cptr, snaplen: int(snaplen)}
	ring.SetApplicationName(os.Args[0])
	return
}

func OpenBDB(env Environment, txn Transaction, file string, database *string, dbtype DbType, flags DbFlag, mode int) (*BerkeleyDB, error) {
	cFile := C.CString(file)
	defer C.free(unsafe.Pointer(cFile))

	var cDatabase *C.char
	if database != nil {
		cDatabase = C.CString(*database)
		defer C.free(unsafe.Pointer(cDatabase))
	}

	var db *BerkeleyDB = new(BerkeleyDB)

	//The flags parameter is currently unused, and must be set to 0.
	// https://docs.oracle.com/cd/E17276_01/html/api_reference/C/dbcreate.html
	err := Err(C.db_create(&db.ptr, env.ptr, 0))
	if err != nil {
		return nil, err
	}

	err = Err(C.db_open(db.ptr, txn.ptr, cFile, cDatabase, C.DBTYPE(dbtype), C.u_int32_t(flags), C.int(mode)))
	if err != nil {
		db.Close(0)
		return nil, err
	}
	return db, ok
}

func (db BerkeleyDB) Put(txn Transaction, key, val []byte, flags DbFlag) error {
	cKey := AllocDBT(key)
	defer cKey.Free()
	cVal := AllocDBT(val)
	defer cVal.Free()

	return Err(C.db_put(db.ptr, txn.ptr, cKey, cVal, C.u_int32_t(flags)))
}

func (db BerkeleyDB) NewCursor(txn Transaction, flags DbFlag) (*Cursor, error) {
	ret := new(Cursor)
	err := Err(C.db_cursor(db.ptr, txn.ptr, &ret.ptr, C.u_int32_t(flags)))
	if err != nil {
		return nil, err
	}
	return ret, ok
}

func AllocDBT(val []byte) *C.DBT {
	return &C.DBT{
		// someday we will be able to use C.CBytes() for this purpose
		// https://github.com/golang/go/issues/14838
		data:  unsafe.Pointer(C.CString(string(val))),
		size:  C.u_int32_t(len(val)),
		flags: C.DB_DBT_USERMEM,
	}
}

// NewRing creates a new PFRing.  Note that when the ring is initially created,
// it is disabled.  The caller must call Enable to start receiving packets.
// The caller should call Close on the given ring when finished with it.
func NewRing(device string, snaplen uint32, flags Flag) (ring *Ring, _ error) {
	dev := C.CString(device)
	defer C.free(unsafe.Pointer(dev))

	cptr, err := C.pfring_open(dev, C.u_int32_t(snaplen), C.u_int32_t(flags))
	if cptr == nil || err != nil {
		return nil, fmt.Errorf("pfring NewRing error: %v", err)
	}
	ring = &Ring{cptr: cptr, snaplen: int(snaplen)}

	if flags&FlagLongHeader == FlagLongHeader {
		ring.useExtendedPacketHeader = true
	} else {
		ifc, err := net.InterfaceByName(device)
		if err == nil {
			ring.interfaceIndex = ifc.Index
		}
	}
	ring.SetApplicationName(os.Args[0])
	return
}

func (cursor Cursor) CursorGetRaw(flags DbFlag) ([]byte, []byte, error) {
	key := C.DBT{flags: C.DB_DBT_REALLOC}
	defer C.free(key.data)
	val := C.DBT{flags: C.DB_DBT_REALLOC}
	defer C.free(val.data)

	err := Err(C.db_cursor_get(cursor.ptr, &key, &val, C.u_int32_t(flags)))
	if err != nil {
		return nil, nil, err
	}
	return cloneToBytes(&key), cloneToBytes(&val), ok
}

func (env Environment) Close(flags DbFlag) error {
	if env.ptr == nil {
		return ok
	}

	err := Err(C.db_env_close(env.ptr, C.u_int32_t(flags)))
	if err != nil {
		return err
	}

	env.ptr = nil
	return ok
}

func (db BerkeleyDB) Get(txn Transaction, key []byte, flags DbFlag) ([]byte, error) {
	data := &C.DBT{flags: C.DB_DBT_REALLOC}
	defer data.Free()

	cKey := AllocDBT(key)
	defer cKey.Free()

	err := Err(C.db_get(db.ptr, txn.ptr, cKey, data, C.u_int32_t(flags)))
	if err != nil {
		return nil, err
	}

	return cloneToBytes(data), ok
}

// Queues returns all queues in pf.
func (p *OpenPf) Queues() ([]Queue, error) {
	pq := &C.struct_pfioc_queue{}
	pqs := &C.struct_pfioc_qstats{}
	hfscstats := &C.struct_hfsc_class_stats{}

	err := ioctl(p.fd.Fd(), DIOCGETQUEUES, uintptr(unsafe.Pointer(pq)))
	if err != nil {
		return nil, err
	}

	queues := make([]Queue, 0)

	n := int(pq.nr)

	for i := 0; i < n; i++ {
		pqs.nr = C.u_int32_t(i)
		pqs.ticket = pq.ticket
		pqs.buf = unsafe.Pointer(hfscstats)
		pqs.nbytes = C.int(unsafe.Sizeof(C.struct_hfsc_class_stats{}))

		err := ioctl(p.fd.Fd(), DIOCGETQSTATS, uintptr(unsafe.Pointer(pqs)))
		if err != nil {
			return nil, err
		}

		qname := C.GoString(&pqs.queue.qname[0])
		if qname[0] == '_' {
			continue
		}

		qparent := C.GoString(&pqs.queue.parent[0])
		qifname := C.GoString(&pqs.queue.ifname[0])

		queue := Queue{
			Name:   qname,
			Parent: qparent,
			IfName: qifname,
			Stats: QueueStats{
				TransmitPackets: uint64(hfscstats.xmit_cnt.packets),
				TransmitBytes:   uint64(hfscstats.xmit_cnt.bytes),
				DroppedPackets:  uint64(hfscstats.drop_cnt.packets),
				DroppedBytes:    uint64(hfscstats.drop_cnt.bytes),
			},
		}

		queues = append(queues, queue)
	}

	return queues, nil
}

// Perform an operation within a transaction. The transaction is
// automatically committed if the action doesn't return an error. If
// an error occurs, the transaction is automatically aborted. Any
// error is passed through to the caller.
func (env Environment) WithTransaction(config *TransactionConfig, action func(Transaction) error) (err error) {
	var parent *C.DB_TXN
	var flags C.u_int32_t = C.DB_READ_COMMITTED

	if config != nil {
		if config.Parent != NoTransaction {
			parent = config.Parent.ptr
		}
		if config.Isolation != 0 {
			flags = C.u_int32_t(config.Isolation)
		}
		if config.Bulk {
			flags |= C.DB_TXN_BULK
		}
		if config.NoWait {
			flags |= C.DB_TXN_NOWAIT
		}
		if config.NoSync {
			flags |= C.DB_TXN_NOSYNC
		}
		if config.WriteNoSync {
			flags |= C.DB_TXN_WRITE_NOSYNC
		}
	}

	var txn Transaction
	err = check(C.db_env_txn_begin(env.ptr, parent, &txn.ptr, flags))
	if err == nil {
		defer func() {
			if err != nil && txn.ptr != nil {
				C.db_txn_abort(txn.ptr)
				txn.ptr = nil
			}
		}()
	} else {
		return
	}

	err = action(txn)
	if err == nil {
		err = check(C.db_txn_commit(txn.ptr, 0))
		txn.ptr = nil
	} else {
		return
	}

	return
}

// Marshal a protobuf struct into a database thang.
func marshalDBT(dbt *C.DBT, val proto.Message) (err error) {
	buf, err := proto.Marshal(val)
	if err != nil {
		return
	}

	if len(buf) > 0 {
		dbt.data = unsafe.Pointer(&buf[0])
		dbt.size = C.u_int32_t(len(buf))
	} else {
		dbt.data = nil
		dbt.size = 0
	}

	return
}

//Create and bind to queue specified by queueId
func NewNFQueue(queueId uint16, maxPacketsInQueue uint32, packetSize uint32) (*NFQueue, error) {
	var nfq = NFQueue{}
	var err error
	var ret C.int

	if nfq.h, err = C.nfq_open(); err != nil {
		return nil, fmt.Errorf("Error opening NFQueue handle: %v\n", err)
	}

	if ret, err = C.nfq_unbind_pf(nfq.h, AF_INET); err != nil || ret < 0 {
		return nil, fmt.Errorf("Error unbinding existing NFQ handler from AF_INET protocol family: %v\n", err)
	}

	if ret, err := C.nfq_bind_pf(nfq.h, AF_INET); err != nil || ret < 0 {
		return nil, fmt.Errorf("Error binding to AF_INET protocol family: %v\n", err)
	}

	nfq.packets = make(chan NFPacket)
	if nfq.qh, err = C.CreateQueue(nfq.h, C.u_int16_t(queueId), unsafe.Pointer(&nfq.packets)); err != nil || nfq.qh == nil {
		C.nfq_close(nfq.h)
		return nil, fmt.Errorf("Error binding to queue: %v\n", err)
	}

	if ret, err = C.nfq_set_queue_maxlen(nfq.qh, C.u_int32_t(maxPacketsInQueue)); err != nil || ret < 0 {
		C.nfq_destroy_queue(nfq.qh)
		C.nfq_close(nfq.h)
		return nil, fmt.Errorf("Unable to set max packets in queue: %v\n", err)
	}

	if C.nfq_set_mode(nfq.qh, C.u_int8_t(2), C.uint(packetSize)) < 0 {
		C.nfq_destroy_queue(nfq.qh)
		C.nfq_close(nfq.h)
		return nil, fmt.Errorf("Unable to set packets copy mode: %v\n", err)
	}

	if nfq.fd, err = C.nfq_fd(nfq.h); err != nil {
		C.nfq_destroy_queue(nfq.qh)
		C.nfq_close(nfq.h)
		return nil, fmt.Errorf("Unable to get queue file-descriptor. %v", err)
	}

	go nfq.run()

	return &nfq, nil
}

func NewEnvironment(home string, flags DbFlag, mode int) (*Environment, error) {
	ret := new(Environment)

	err := Err(C.db_env_create(&ret.ptr, 0))
	if err != nil {
		return nil, err
	}

	cHome := C.CString(home)
	defer C.free(unsafe.Pointer(cHome))

	err = Err(C.db_env_open(ret.ptr, cHome, C.u_int32_t(flags), C.int(mode)))
	if err != nil {
		ret.Close(0)
		return nil, err
	}

	return ret, ok
}

func (p *OpenPf) Anchors() ([]string, error) {
	pr := &C.struct_pfioc_ruleset{}

	err := ioctl(p.fd.Fd(), DIOCGETRULESETS, uintptr(unsafe.Pointer(pr)))
	if err != nil {
		return nil, err
	}

	anchors := make([]string, 0)

	n := int(pr.nr)

	for i := 0; i < n; i++ {
		pr.nr = C.u_int32_t(i)

		err := ioctl(p.fd.Fd(), DIOCGETRULESET, uintptr(unsafe.Pointer(pr)))
		if err != nil {
			return nil, err
		}

		anchor := ""

		if pr.path[0] != '\x00' {
			anchor += C.GoString(&pr.path[0]) + "/"
		}

		name := C.GoString(&pr.name[0])

		if name == PF_RESERVED_ANCHOR {
			continue
		}

		anchor += name

		anchors = append(anchors, anchor)
	}

	return anchors, nil
}