// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package unix

//go:cgo_import_dynamic libc_fstatat fstatat "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_openat openat "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_unlinkat unlinkat "libc.a/shr_64.o"

const (
	AT_REMOVEDIR        = 0x1
	AT_SYMLINK_NOFOLLOW = 0x1
	UTIME_OMIT          = -0x3

// license that can be found in the LICENSE file.

//go:build unix

package unix

const (
	R_OK = 0x4
	W_OK = 0x2
	X_OK = 0x1

	// NoFollowErrno is the error returned from open/openat called with
	// O_NOFOLLOW flag, when the trailing component (basename) of the path
	// is a symbolic link.
	NoFollowErrno = noFollowErrno

apiVersion: apps.openshift.io/v1
kind: DeploymentConfig
metadata:
  name: hello
spec:
  replicas: 7
  template:
    metadata:
      labels:
        app: hello
        tier: backend
        track: stable
    spec:
      containers:
        - name: hello
          image: "fake.docker.io/google-samples/hello-go-gke:1.0"
          ports:
            - name: http
              containerPort: 80
  triggers:

	}
	return exe
}

func main() {
	if len(os.Args) != 3 {
		usage()
	}

	exePath := os.Args[1]
	dieSuffix := os.Args[2]

	var exe dwarfer

	for _, openfn := range []func(string) dwarfer{openMacho, openPE, openElf} {
		exe = openfn(exePath)
		if exe != nil {
			break
		}
	}

	if exe == nil {
		fmt.Fprintf(os.Stderr, "could not open %s\n", exePath)
		os.Exit(1)
	}

	data, err := exe.DWARF()

apiVersion: apps.openshift.io/v1
kind: DeploymentConfig
metadata:
  creationTimestamp: null
  name: hello
spec:
  replicas: 7
  revisionHistoryLimit: 2
  strategy:
    resources: {}
    type: Rolling
  template:
    metadata:
      annotations:
        istio.io/rev: default
        kubectl.kubernetes.io/default-container: hello
        kubectl.kubernetes.io/default-logs-container: hello
        prometheus.io/path: /stats/prometheus

func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)

//go:cgo_import_dynamic libc_fstatat fstatat "libc.so"
//go:cgo_import_dynamic libc_openat openat "libc.so"
//go:cgo_import_dynamic libc_unlinkat unlinkat "libc.so"
//go:cgo_import_dynamic libc_uname uname "libc.so"

const (
	AT_REMOVEDIR        = 0x1
	AT_SYMLINK_NOFOLLOW = 0x1000

	UTIME_OMIT = -0x2

                logger.debug("OPENSHIFT IP environment variable {} detected. Using IP address {}.", key, ipAddress);
                try {
                    return InetAddress.getByName(ipAddress);
                } catch (UnknownHostException e) {

	err := rootCmd.Execute()
	if err != nil {
		t.Fatalf("failed to execute istioctl profile command: %v", err)
	}
	output := out.String()
	expectedProfiles := []string{"default", "demo", "empty", "minimal", "openshift", "preview", "remote"}
	for _, prof := range expectedProfiles {
		g.Expect(output).To(ContainSubstring(prof))
	}

  metadata:
    name: frontend
  spec:
    ports:
    - port: 80
      protocol: TCP
      targetPort: 80
    selector:
      app: hello
      tier: frontend
    type: LoadBalancer
- apiVersion: apps.openshift.io/v1
  kind: DeploymentConfig
  metadata:
    creationTimestamp: null
    name: hello
  spec:
    replicas: 7
    revisionHistoryLimit: 2
    strategy:
      resources: {}
      type: Rolling

	if err != nil {
		return err
	}

	_, _, errno := syscall.Syscall(unlinkatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(flags))
	if errno != 0 {
		return errno
	}

	return nil
}

func Openat(dirfd int, path string, flags int, perm uint32) (int, error) {
	p, err := syscall.BytePtrFromString(path)
	if err != nil {
		return 0, err
	}