├── .codebuild ├── buildspec.yml └── source-archive.yml ├── .github ├── CODEOWNERS ├── ISSUE_TEMPLATE │ ├── config.yml │ └── third_party_license_usage_request.yml ├── PULL_REQUEST_TEMPLATE.md ├── dependabot.yml ├── dependency-review-config.yml ├── new-pull-request-labels.yml └── workflows │ ├── build.yaml │ ├── check-links.yml │ ├── codeql.yml │ ├── new-pull-requests.yml │ └── review-dependencies.yml ├── .gitignore ├── CHANGELOG.md ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── Dockerfile ├── LICENSE ├── Makefile ├── NOTICE ├── README.md ├── THIRD-PARTY-LICENSES ├── VERSION ├── docs ├── docker-credential-ecr-login.1 ├── ecr.png └── packaging.md ├── ecr-login ├── api │ ├── client.go │ ├── client_test.go │ ├── factory.go │ └── mocks │ │ └── api_mocks.go ├── cache │ ├── build.go │ ├── build_test.go │ ├── credentials.go │ ├── credentials_test.go │ ├── file.go │ ├── file_test.go │ ├── mocks │ │ └── cache_mocks.go │ ├── null.go │ └── null_test.go ├── cli │ └── docker-credential-ecr-login │ │ └── main.go ├── config │ ├── cache_dir.go │ └── log.go ├── ecr.go ├── ecr_test.go ├── go.mod ├── go.sum ├── mocks │ └── ecr_mocks.go ├── vendor │ ├── github.com │ │ ├── aws │ │ │ ├── aws-sdk-go-v2 │ │ │ │ ├── LICENSE.txt │ │ │ │ ├── NOTICE.txt │ │ │ │ ├── aws │ │ │ │ │ ├── accountid_endpoint_mode.go │ │ │ │ │ ├── checksum.go │ │ │ │ │ ├── config.go │ │ │ │ │ ├── context.go │ │ │ │ │ ├── credential_cache.go │ │ │ │ │ ├── credentials.go │ │ │ │ │ ├── defaults │ │ │ │ │ │ ├── auto.go │ │ │ │ │ │ ├── configuration.go │ │ │ │ │ │ ├── defaults.go │ │ │ │ │ │ └── doc.go │ │ │ │ │ ├── defaultsmode.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── endpoints.go │ │ │ │ │ ├── errors.go │ │ │ │ │ ├── from_ptr.go │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ ├── logging.go │ │ │ │ │ ├── logging_generate.go │ │ │ │ │ ├── middleware │ │ │ │ │ │ ├── metadata.go │ │ │ │ │ │ ├── middleware.go │ │ │ │ │ │ ├── osname.go │ │ │ │ │ │ ├── osname_go115.go │ │ │ │ │ │ ├── recursion_detection.go │ │ │ │ │ │ ├── request_id.go │ │ │ │ │ │ ├── request_id_retriever.go │ │ │ │ │ │ └── user_agent.go │ │ │ │ │ ├── protocol │ │ │ │ │ │ ├── query │ │ │ │ │ │ │ ├── array.go │ │ │ │ │ │ │ ├── encoder.go │ │ │ │ │ │ │ ├── map.go │ │ │ │ │ │ │ ├── middleware.go │ │ │ │ │ │ │ ├── object.go │ │ │ │ │ │ │ └── value.go │ │ │ │ │ │ ├── restjson │ │ │ │ │ │ │ └── decoder_util.go │ │ │ │ │ │ └── xml │ │ │ │ │ │ │ └── error_utils.go │ │ │ │ │ ├── ratelimit │ │ │ │ │ │ ├── none.go │ │ │ │ │ │ ├── token_bucket.go │ │ │ │ │ │ └── token_rate_limit.go │ │ │ │ │ ├── request.go │ │ │ │ │ ├── retry │ │ │ │ │ │ ├── adaptive.go │ │ │ │ │ │ ├── adaptive_ratelimit.go │ │ │ │ │ │ ├── adaptive_token_bucket.go │ │ │ │ │ │ ├── attempt_metrics.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ ├── jitter_backoff.go │ │ │ │ │ │ ├── metadata.go │ │ │ │ │ │ ├── middleware.go │ │ │ │ │ │ ├── retry.go │ │ │ │ │ │ ├── retryable_error.go │ │ │ │ │ │ ├── standard.go │ │ │ │ │ │ ├── throttle_error.go │ │ │ │ │ │ └── timeout_error.go │ │ │ │ │ ├── retryer.go │ │ │ │ │ ├── runtime.go │ │ │ │ │ ├── signer │ │ │ │ │ │ ├── internal │ │ │ │ │ │ │ └── v4 │ │ │ │ │ │ │ │ ├── cache.go │ │ │ │ │ │ │ │ ├── const.go │ │ │ │ │ │ │ │ ├── header_rules.go │ │ │ │ │ │ │ │ ├── headers.go │ │ │ │ │ │ │ │ ├── hmac.go │ │ │ │ │ │ │ │ ├── host.go │ │ │ │ │ │ │ │ ├── scope.go │ │ │ │ │ │ │ │ ├── time.go │ │ │ │ │ │ │ │ └── util.go │ │ │ │ │ │ └── v4 │ │ │ │ │ │ │ ├── middleware.go │ │ │ │ │ │ │ ├── presign_middleware.go │ │ │ │ │ │ │ ├── stream.go │ │ │ │ │ │ │ └── v4.go │ │ │ │ │ ├── to_ptr.go │ │ │ │ │ ├── transport │ │ │ │ │ │ └── http │ │ │ │ │ │ │ ├── client.go │ │ │ │ │ │ │ ├── content_type.go │ │ │ │ │ │ │ ├── response_error.go │ │ │ │ │ │ │ ├── response_error_middleware.go │ │ │ │ │ │ │ └── timeout_read_closer.go │ │ │ │ │ ├── types.go │ │ │ │ │ └── version.go │ │ │ │ ├── config │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ ├── config.go │ │ │ │ │ ├── defaultsmode.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── env_config.go │ │ │ │ │ ├── generate.go │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ ├── load_options.go │ │ │ │ │ ├── local.go │ │ │ │ │ ├── provider.go │ │ │ │ │ ├── resolve.go │ │ │ │ │ ├── resolve_bearer_token.go │ │ │ │ │ ├── resolve_credentials.go │ │ │ │ │ └── shared_config.go │ │ │ │ ├── credentials │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── ec2rolecreds │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── provider.go │ │ │ │ │ ├── endpointcreds │ │ │ │ │ │ ├── internal │ │ │ │ │ │ │ └── client │ │ │ │ │ │ │ │ ├── auth.go │ │ │ │ │ │ │ │ ├── client.go │ │ │ │ │ │ │ │ ├── endpoints.go │ │ │ │ │ │ │ │ └── middleware.go │ │ │ │ │ │ └── provider.go │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ ├── processcreds │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── provider.go │ │ │ │ │ ├── ssocreds │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── sso_cached_token.go │ │ │ │ │ │ ├── sso_credentials_provider.go │ │ │ │ │ │ └── sso_token_provider.go │ │ │ │ │ ├── static_provider.go │ │ │ │ │ └── stscreds │ │ │ │ │ │ ├── assume_role_provider.go │ │ │ │ │ │ └── web_identity_provider.go │ │ │ │ ├── feature │ │ │ │ │ └── ec2 │ │ │ │ │ │ └── imds │ │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ │ ├── api_client.go │ │ │ │ │ │ ├── api_op_GetDynamicData.go │ │ │ │ │ │ ├── api_op_GetIAMInfo.go │ │ │ │ │ │ ├── api_op_GetInstanceIdentityDocument.go │ │ │ │ │ │ ├── api_op_GetMetadata.go │ │ │ │ │ │ ├── api_op_GetRegion.go │ │ │ │ │ │ ├── api_op_GetToken.go │ │ │ │ │ │ ├── api_op_GetUserData.go │ │ │ │ │ │ ├── auth.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── endpoints.go │ │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ │ ├── internal │ │ │ │ │ │ └── config │ │ │ │ │ │ │ └── resolvers.go │ │ │ │ │ │ ├── request_middleware.go │ │ │ │ │ │ └── token_provider.go │ │ │ │ ├── internal │ │ │ │ │ ├── auth │ │ │ │ │ │ ├── auth.go │ │ │ │ │ │ ├── scheme.go │ │ │ │ │ │ └── smithy │ │ │ │ │ │ │ ├── bearer_token_adapter.go │ │ │ │ │ │ │ ├── bearer_token_signer_adapter.go │ │ │ │ │ │ │ ├── credentials_adapter.go │ │ │ │ │ │ │ ├── smithy.go │ │ │ │ │ │ │ └── v4signer_adapter.go │ │ │ │ │ ├── configsources │ │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ │ ├── config.go │ │ │ │ │ │ ├── endpoints.go │ │ │ │ │ │ └── go_module_metadata.go │ │ │ │ │ ├── context │ │ │ │ │ │ └── context.go │ │ │ │ │ ├── endpoints │ │ │ │ │ │ ├── awsrulesfn │ │ │ │ │ │ │ ├── arn.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── generate.go │ │ │ │ │ │ │ ├── host.go │ │ │ │ │ │ │ ├── partition.go │ │ │ │ │ │ │ ├── partitions.go │ │ │ │ │ │ │ └── partitions.json │ │ │ │ │ │ ├── endpoints.go │ │ │ │ │ │ └── v2 │ │ │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ │ │ ├── endpoints.go │ │ │ │ │ │ │ └── go_module_metadata.go │ │ │ │ │ ├── ini │ │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ │ ├── ini.go │ │ │ │ │ │ ├── parse.go │ │ │ │ │ │ ├── sections.go │ │ │ │ │ │ ├── strings.go │ │ │ │ │ │ ├── token.go │ │ │ │ │ │ ├── tokenize.go │ │ │ │ │ │ └── value.go │ │ │ │ │ ├── middleware │ │ │ │ │ │ └── middleware.go │ │ │ │ │ ├── rand │ │ │ │ │ │ └── rand.go │ │ │ │ │ ├── sdk │ │ │ │ │ │ ├── interfaces.go │ │ │ │ │ │ └── time.go │ │ │ │ │ ├── sdkio │ │ │ │ │ │ └── byte.go │ │ │ │ │ ├── shareddefaults │ │ │ │ │ │ └── shared_config.go │ │ │ │ │ ├── strings │ │ │ │ │ │ └── strings.go │ │ │ │ │ ├── sync │ │ │ │ │ │ └── singleflight │ │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ │ ├── docs.go │ │ │ │ │ │ │ └── singleflight.go │ │ │ │ │ └── timeconv │ │ │ │ │ │ └── duration.go │ │ │ │ └── service │ │ │ │ │ ├── ecr │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ ├── api_client.go │ │ │ │ │ ├── api_op_BatchCheckLayerAvailability.go │ │ │ │ │ ├── api_op_BatchDeleteImage.go │ │ │ │ │ ├── api_op_BatchGetImage.go │ │ │ │ │ ├── api_op_BatchGetRepositoryScanningConfiguration.go │ │ │ │ │ ├── api_op_CompleteLayerUpload.go │ │ │ │ │ ├── api_op_CreatePullThroughCacheRule.go │ │ │ │ │ ├── api_op_CreateRepository.go │ │ │ │ │ ├── api_op_CreateRepositoryCreationTemplate.go │ │ │ │ │ ├── api_op_DeleteLifecyclePolicy.go │ │ │ │ │ ├── api_op_DeletePullThroughCacheRule.go │ │ │ │ │ ├── api_op_DeleteRegistryPolicy.go │ │ │ │ │ ├── api_op_DeleteRepository.go │ │ │ │ │ ├── api_op_DeleteRepositoryCreationTemplate.go │ │ │ │ │ ├── api_op_DeleteRepositoryPolicy.go │ │ │ │ │ ├── api_op_DescribeImageReplicationStatus.go │ │ │ │ │ ├── api_op_DescribeImageScanFindings.go │ │ │ │ │ ├── api_op_DescribeImages.go │ │ │ │ │ ├── api_op_DescribePullThroughCacheRules.go │ │ │ │ │ ├── api_op_DescribeRegistry.go │ │ │ │ │ ├── api_op_DescribeRepositories.go │ │ │ │ │ ├── api_op_DescribeRepositoryCreationTemplates.go │ │ │ │ │ ├── api_op_GetAccountSetting.go │ │ │ │ │ ├── api_op_GetAuthorizationToken.go │ │ │ │ │ ├── api_op_GetDownloadUrlForLayer.go │ │ │ │ │ ├── api_op_GetLifecyclePolicy.go │ │ │ │ │ ├── api_op_GetLifecyclePolicyPreview.go │ │ │ │ │ ├── api_op_GetRegistryPolicy.go │ │ │ │ │ ├── api_op_GetRegistryScanningConfiguration.go │ │ │ │ │ ├── api_op_GetRepositoryPolicy.go │ │ │ │ │ ├── api_op_InitiateLayerUpload.go │ │ │ │ │ ├── api_op_ListImages.go │ │ │ │ │ ├── api_op_ListTagsForResource.go │ │ │ │ │ ├── api_op_PutAccountSetting.go │ │ │ │ │ ├── api_op_PutImage.go │ │ │ │ │ ├── api_op_PutImageScanningConfiguration.go │ │ │ │ │ ├── api_op_PutImageTagMutability.go │ │ │ │ │ ├── api_op_PutLifecyclePolicy.go │ │ │ │ │ ├── api_op_PutRegistryPolicy.go │ │ │ │ │ ├── api_op_PutRegistryScanningConfiguration.go │ │ │ │ │ ├── api_op_PutReplicationConfiguration.go │ │ │ │ │ ├── api_op_SetRepositoryPolicy.go │ │ │ │ │ ├── api_op_StartImageScan.go │ │ │ │ │ ├── api_op_StartLifecyclePolicyPreview.go │ │ │ │ │ ├── api_op_TagResource.go │ │ │ │ │ ├── api_op_UntagResource.go │ │ │ │ │ ├── api_op_UpdatePullThroughCacheRule.go │ │ │ │ │ ├── api_op_UpdateRepositoryCreationTemplate.go │ │ │ │ │ ├── api_op_UploadLayerPart.go │ │ │ │ │ ├── api_op_ValidatePullThroughCacheRule.go │ │ │ │ │ ├── auth.go │ │ │ │ │ ├── deserializers.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── endpoints.go │ │ │ │ │ ├── generated.json │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ ├── internal │ │ │ │ │ │ └── endpoints │ │ │ │ │ │ │ └── endpoints.go │ │ │ │ │ ├── options.go │ │ │ │ │ ├── serializers.go │ │ │ │ │ ├── types │ │ │ │ │ │ ├── enums.go │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ └── types.go │ │ │ │ │ └── validators.go │ │ │ │ │ ├── ecrpublic │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ ├── api_client.go │ │ │ │ │ ├── api_op_BatchCheckLayerAvailability.go │ │ │ │ │ ├── api_op_BatchDeleteImage.go │ │ │ │ │ ├── api_op_CompleteLayerUpload.go │ │ │ │ │ ├── api_op_CreateRepository.go │ │ │ │ │ ├── api_op_DeleteRepository.go │ │ │ │ │ ├── api_op_DeleteRepositoryPolicy.go │ │ │ │ │ ├── api_op_DescribeImageTags.go │ │ │ │ │ ├── api_op_DescribeImages.go │ │ │ │ │ ├── api_op_DescribeRegistries.go │ │ │ │ │ ├── api_op_DescribeRepositories.go │ │ │ │ │ ├── api_op_GetAuthorizationToken.go │ │ │ │ │ ├── api_op_GetRegistryCatalogData.go │ │ │ │ │ ├── api_op_GetRepositoryCatalogData.go │ │ │ │ │ ├── api_op_GetRepositoryPolicy.go │ │ │ │ │ ├── api_op_InitiateLayerUpload.go │ │ │ │ │ ├── api_op_ListTagsForResource.go │ │ │ │ │ ├── api_op_PutImage.go │ │ │ │ │ ├── api_op_PutRegistryCatalogData.go │ │ │ │ │ ├── api_op_PutRepositoryCatalogData.go │ │ │ │ │ ├── api_op_SetRepositoryPolicy.go │ │ │ │ │ ├── api_op_TagResource.go │ │ │ │ │ ├── api_op_UntagResource.go │ │ │ │ │ ├── api_op_UploadLayerPart.go │ │ │ │ │ ├── auth.go │ │ │ │ │ ├── deserializers.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── endpoints.go │ │ │ │ │ ├── generated.json │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ ├── internal │ │ │ │ │ │ └── endpoints │ │ │ │ │ │ │ └── endpoints.go │ │ │ │ │ ├── options.go │ │ │ │ │ ├── serializers.go │ │ │ │ │ ├── types │ │ │ │ │ │ ├── enums.go │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ └── types.go │ │ │ │ │ └── validators.go │ │ │ │ │ ├── internal │ │ │ │ │ ├── accept-encoding │ │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ │ ├── accept_encoding_gzip.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── go_module_metadata.go │ │ │ │ │ └── presigned-url │ │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ │ ├── context.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ │ └── middleware.go │ │ │ │ │ ├── sso │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ ├── api_client.go │ │ │ │ │ ├── api_op_GetRoleCredentials.go │ │ │ │ │ ├── api_op_ListAccountRoles.go │ │ │ │ │ ├── api_op_ListAccounts.go │ │ │ │ │ ├── api_op_Logout.go │ │ │ │ │ ├── auth.go │ │ │ │ │ ├── deserializers.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── endpoints.go │ │ │ │ │ ├── generated.json │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ ├── internal │ │ │ │ │ │ └── endpoints │ │ │ │ │ │ │ └── endpoints.go │ │ │ │ │ ├── options.go │ │ │ │ │ ├── serializers.go │ │ │ │ │ ├── types │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ └── types.go │ │ │ │ │ └── validators.go │ │ │ │ │ ├── ssooidc │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ ├── api_client.go │ │ │ │ │ ├── api_op_CreateToken.go │ │ │ │ │ ├── api_op_CreateTokenWithIAM.go │ │ │ │ │ ├── api_op_RegisterClient.go │ │ │ │ │ ├── api_op_StartDeviceAuthorization.go │ │ │ │ │ ├── auth.go │ │ │ │ │ ├── deserializers.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── endpoints.go │ │ │ │ │ ├── generated.json │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ ├── internal │ │ │ │ │ │ └── endpoints │ │ │ │ │ │ │ └── endpoints.go │ │ │ │ │ ├── options.go │ │ │ │ │ ├── serializers.go │ │ │ │ │ ├── types │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ └── types.go │ │ │ │ │ └── validators.go │ │ │ │ │ └── sts │ │ │ │ │ ├── CHANGELOG.md │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ ├── api_client.go │ │ │ │ │ ├── api_op_AssumeRole.go │ │ │ │ │ ├── api_op_AssumeRoleWithSAML.go │ │ │ │ │ ├── api_op_AssumeRoleWithWebIdentity.go │ │ │ │ │ ├── api_op_AssumeRoot.go │ │ │ │ │ ├── api_op_DecodeAuthorizationMessage.go │ │ │ │ │ ├── api_op_GetAccessKeyInfo.go │ │ │ │ │ ├── api_op_GetCallerIdentity.go │ │ │ │ │ ├── api_op_GetFederationToken.go │ │ │ │ │ ├── api_op_GetSessionToken.go │ │ │ │ │ ├── auth.go │ │ │ │ │ ├── deserializers.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── endpoints.go │ │ │ │ │ ├── generated.json │ │ │ │ │ ├── go_module_metadata.go │ │ │ │ │ ├── internal │ │ │ │ │ └── endpoints │ │ │ │ │ │ └── endpoints.go │ │ │ │ │ ├── options.go │ │ │ │ │ ├── serializers.go │ │ │ │ │ ├── types │ │ │ │ │ ├── errors.go │ │ │ │ │ └── types.go │ │ │ │ │ └── validators.go │ │ │ └── smithy-go │ │ │ │ ├── .gitignore │ │ │ │ ├── .travis.yml │ │ │ │ ├── CHANGELOG.md │ │ │ │ ├── CODE_OF_CONDUCT.md │ │ │ │ ├── CONTRIBUTING.md │ │ │ │ ├── LICENSE │ │ │ │ ├── Makefile │ │ │ │ ├── NOTICE │ │ │ │ ├── README.md │ │ │ │ ├── auth │ │ │ │ ├── auth.go │ │ │ │ ├── bearer │ │ │ │ │ ├── docs.go │ │ │ │ │ ├── middleware.go │ │ │ │ │ ├── token.go │ │ │ │ │ └── token_cache.go │ │ │ │ ├── identity.go │ │ │ │ ├── option.go │ │ │ │ └── scheme_id.go │ │ │ │ ├── changelog-template.json │ │ │ │ ├── context │ │ │ │ └── suppress_expired.go │ │ │ │ ├── doc.go │ │ │ │ ├── document.go │ │ │ │ ├── document │ │ │ │ ├── doc.go │ │ │ │ ├── document.go │ │ │ │ └── errors.go │ │ │ │ ├── encoding │ │ │ │ ├── doc.go │ │ │ │ ├── encoding.go │ │ │ │ ├── httpbinding │ │ │ │ │ ├── encode.go │ │ │ │ │ ├── header.go │ │ │ │ │ ├── path_replace.go │ │ │ │ │ ├── query.go │ │ │ │ │ └── uri.go │ │ │ │ ├── json │ │ │ │ │ ├── array.go │ │ │ │ │ ├── constants.go │ │ │ │ │ ├── decoder_util.go │ │ │ │ │ ├── encoder.go │ │ │ │ │ ├── escape.go │ │ │ │ │ ├── object.go │ │ │ │ │ └── value.go │ │ │ │ └── xml │ │ │ │ │ ├── array.go │ │ │ │ │ ├── constants.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── element.go │ │ │ │ │ ├── encoder.go │ │ │ │ │ ├── error_utils.go │ │ │ │ │ ├── escape.go │ │ │ │ │ ├── map.go │ │ │ │ │ ├── value.go │ │ │ │ │ └── xml_decoder.go │ │ │ │ ├── endpoints │ │ │ │ └── endpoint.go │ │ │ │ ├── errors.go │ │ │ │ ├── go_module_metadata.go │ │ │ │ ├── internal │ │ │ │ └── sync │ │ │ │ │ └── singleflight │ │ │ │ │ ├── LICENSE │ │ │ │ │ ├── docs.go │ │ │ │ │ └── singleflight.go │ │ │ │ ├── io │ │ │ │ ├── byte.go │ │ │ │ ├── doc.go │ │ │ │ ├── reader.go │ │ │ │ └── ringbuffer.go │ │ │ │ ├── local-mod-replace.sh │ │ │ │ ├── logging │ │ │ │ └── logger.go │ │ │ │ ├── metrics │ │ │ │ ├── metrics.go │ │ │ │ └── nop.go │ │ │ │ ├── middleware │ │ │ │ ├── context.go │ │ │ │ ├── doc.go │ │ │ │ ├── logging.go │ │ │ │ ├── metadata.go │ │ │ │ ├── middleware.go │ │ │ │ ├── ordered_group.go │ │ │ │ ├── stack.go │ │ │ │ ├── stack_values.go │ │ │ │ ├── step_build.go │ │ │ │ ├── step_deserialize.go │ │ │ │ ├── step_finalize.go │ │ │ │ ├── step_initialize.go │ │ │ │ └── step_serialize.go │ │ │ │ ├── modman.toml │ │ │ │ ├── private │ │ │ │ └── requestcompression │ │ │ │ │ ├── gzip.go │ │ │ │ │ ├── middleware_capture_request_compression.go │ │ │ │ │ └── request_compression.go │ │ │ │ ├── properties.go │ │ │ │ ├── ptr │ │ │ │ ├── doc.go │ │ │ │ ├── from_ptr.go │ │ │ │ ├── gen_scalars.go │ │ │ │ └── to_ptr.go │ │ │ │ ├── rand │ │ │ │ ├── doc.go │ │ │ │ ├── rand.go │ │ │ │ └── uuid.go │ │ │ │ ├── time │ │ │ │ └── time.go │ │ │ │ ├── tracing │ │ │ │ ├── context.go │ │ │ │ ├── nop.go │ │ │ │ └── tracing.go │ │ │ │ ├── transport │ │ │ │ └── http │ │ │ │ │ ├── auth.go │ │ │ │ │ ├── auth_schemes.go │ │ │ │ │ ├── checksum_middleware.go │ │ │ │ │ ├── client.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── headerlist.go │ │ │ │ │ ├── host.go │ │ │ │ │ ├── internal │ │ │ │ │ └── io │ │ │ │ │ │ └── safe.go │ │ │ │ │ ├── md5_checksum.go │ │ │ │ │ ├── metrics.go │ │ │ │ │ ├── middleware_close_response_body.go │ │ │ │ │ ├── middleware_content_length.go │ │ │ │ │ ├── middleware_header_comment.go │ │ │ │ │ ├── middleware_headers.go │ │ │ │ │ ├── middleware_http_logging.go │ │ │ │ │ ├── middleware_metadata.go │ │ │ │ │ ├── middleware_min_proto.go │ │ │ │ │ ├── properties.go │ │ │ │ │ ├── request.go │ │ │ │ │ ├── response.go │ │ │ │ │ ├── time.go │ │ │ │ │ ├── url.go │ │ │ │ │ └── user_agent.go │ │ │ │ ├── validation.go │ │ │ │ └── waiter │ │ │ │ ├── logger.go │ │ │ │ └── waiter.go │ │ ├── davecgh │ │ │ └── go-spew │ │ │ │ ├── LICENSE │ │ │ │ └── spew │ │ │ │ ├── bypass.go │ │ │ │ ├── bypasssafe.go │ │ │ │ ├── common.go │ │ │ │ ├── config.go │ │ │ │ ├── doc.go │ │ │ │ ├── dump.go │ │ │ │ ├── format.go │ │ │ │ └── spew.go │ │ ├── docker │ │ │ └── docker-credential-helpers │ │ │ │ ├── LICENSE │ │ │ │ └── credentials │ │ │ │ ├── credentials.go │ │ │ │ ├── error.go │ │ │ │ ├── helper.go │ │ │ │ └── version.go │ │ ├── mitchellh │ │ │ └── go-homedir │ │ │ │ ├── LICENSE │ │ │ │ ├── README.md │ │ │ │ └── homedir.go │ │ ├── pmezard │ │ │ └── go-difflib │ │ │ │ ├── LICENSE │ │ │ │ └── difflib │ │ │ │ └── difflib.go │ │ ├── sirupsen │ │ │ └── logrus │ │ │ │ ├── .gitignore │ │ │ │ ├── .golangci.yml │ │ │ │ ├── .travis.yml │ │ │ │ ├── CHANGELOG.md │ │ │ │ ├── LICENSE │ │ │ │ ├── README.md │ │ │ │ ├── alt_exit.go │ │ │ │ ├── appveyor.yml │ │ │ │ ├── buffer_pool.go │ │ │ │ ├── doc.go │ │ │ │ ├── entry.go │ │ │ │ ├── exported.go │ │ │ │ ├── formatter.go │ │ │ │ ├── hooks.go │ │ │ │ ├── json_formatter.go │ │ │ │ ├── logger.go │ │ │ │ ├── logrus.go │ │ │ │ ├── terminal_check_appengine.go │ │ │ │ ├── terminal_check_bsd.go │ │ │ │ ├── terminal_check_js.go │ │ │ │ ├── terminal_check_no_terminal.go │ │ │ │ ├── terminal_check_notappengine.go │ │ │ │ ├── terminal_check_solaris.go │ │ │ │ ├── terminal_check_unix.go │ │ │ │ ├── terminal_check_windows.go │ │ │ │ ├── text_formatter.go │ │ │ │ └── writer.go │ │ └── stretchr │ │ │ └── testify │ │ │ ├── LICENSE │ │ │ └── assert │ │ │ ├── assertion_compare.go │ │ │ ├── assertion_format.go │ │ │ ├── assertion_format.go.tmpl │ │ │ ├── assertion_forward.go │ │ │ ├── assertion_forward.go.tmpl │ │ │ ├── assertion_order.go │ │ │ ├── assertions.go │ │ │ ├── doc.go │ │ │ ├── errors.go │ │ │ ├── forward_assertions.go │ │ │ ├── http_assertions.go │ │ │ └── yaml │ │ │ ├── yaml_custom.go │ │ │ ├── yaml_default.go │ │ │ └── yaml_fail.go │ ├── golang.org │ │ └── x │ │ │ └── sys │ │ │ ├── LICENSE │ │ │ ├── PATENTS │ │ │ ├── unix │ │ │ ├── .gitignore │ │ │ ├── README.md │ │ │ ├── affinity_linux.go │ │ │ ├── aliases.go │ │ │ ├── asm_aix_ppc64.s │ │ │ ├── asm_bsd_386.s │ │ │ ├── asm_bsd_amd64.s │ │ │ ├── asm_bsd_arm.s │ │ │ ├── asm_bsd_arm64.s │ │ │ ├── asm_bsd_ppc64.s │ │ │ ├── asm_bsd_riscv64.s │ │ │ ├── asm_linux_386.s │ │ │ ├── asm_linux_amd64.s │ │ │ ├── asm_linux_arm.s │ │ │ ├── asm_linux_arm64.s │ │ │ ├── asm_linux_loong64.s │ │ │ ├── asm_linux_mips64x.s │ │ │ ├── asm_linux_mipsx.s │ │ │ ├── asm_linux_ppc64x.s │ │ │ ├── asm_linux_riscv64.s │ │ │ ├── asm_linux_s390x.s │ │ │ ├── asm_openbsd_mips64.s │ │ │ ├── asm_solaris_amd64.s │ │ │ ├── asm_zos_s390x.s │ │ │ ├── bluetooth_linux.go │ │ │ ├── bpxsvc_zos.go │ │ │ ├── bpxsvc_zos.s │ │ │ ├── cap_freebsd.go │ │ │ ├── constants.go │ │ │ ├── dev_aix_ppc.go │ │ │ ├── dev_aix_ppc64.go │ │ │ ├── dev_darwin.go │ │ │ ├── dev_dragonfly.go │ │ │ ├── dev_freebsd.go │ │ │ ├── dev_linux.go │ │ │ ├── dev_netbsd.go │ │ │ ├── dev_openbsd.go │ │ │ ├── dev_zos.go │ │ │ ├── dirent.go │ │ │ ├── endian_big.go │ │ │ ├── endian_little.go │ │ │ ├── env_unix.go │ │ │ ├── fcntl.go │ │ │ ├── fcntl_darwin.go │ │ │ ├── fcntl_linux_32bit.go │ │ │ ├── fdset.go │ │ │ ├── gccgo.go │ │ │ ├── gccgo_c.c │ │ │ ├── gccgo_linux_amd64.go │ │ │ ├── ifreq_linux.go │ │ │ ├── ioctl_linux.go │ │ │ ├── ioctl_signed.go │ │ │ ├── ioctl_unsigned.go │ │ │ ├── ioctl_zos.go │ │ │ ├── mkall.sh │ │ │ ├── mkerrors.sh │ │ │ ├── mmap_nomremap.go │ │ │ ├── mremap.go │ │ │ ├── pagesize_unix.go │ │ │ ├── pledge_openbsd.go │ │ │ ├── ptrace_darwin.go │ │ │ ├── ptrace_ios.go │ │ │ ├── race.go │ │ │ ├── race0.go │ │ │ ├── readdirent_getdents.go │ │ │ ├── readdirent_getdirentries.go │ │ │ ├── sockcmsg_dragonfly.go │ │ │ ├── sockcmsg_linux.go │ │ │ ├── sockcmsg_unix.go │ │ │ ├── sockcmsg_unix_other.go │ │ │ ├── sockcmsg_zos.go │ │ │ ├── symaddr_zos_s390x.s │ │ │ ├── syscall.go │ │ │ ├── syscall_aix.go │ │ │ ├── syscall_aix_ppc.go │ │ │ ├── syscall_aix_ppc64.go │ │ │ ├── syscall_bsd.go │ │ │ ├── syscall_darwin.go │ │ │ ├── syscall_darwin_amd64.go │ │ │ ├── syscall_darwin_arm64.go │ │ │ ├── syscall_darwin_libSystem.go │ │ │ ├── syscall_dragonfly.go │ │ │ ├── syscall_dragonfly_amd64.go │ │ │ ├── syscall_freebsd.go │ │ │ ├── syscall_freebsd_386.go │ │ │ ├── syscall_freebsd_amd64.go │ │ │ ├── syscall_freebsd_arm.go │ │ │ ├── syscall_freebsd_arm64.go │ │ │ ├── syscall_freebsd_riscv64.go │ │ │ ├── syscall_hurd.go │ │ │ ├── syscall_hurd_386.go │ │ │ ├── syscall_illumos.go │ │ │ ├── syscall_linux.go │ │ │ ├── syscall_linux_386.go │ │ │ ├── syscall_linux_alarm.go │ │ │ ├── syscall_linux_amd64.go │ │ │ ├── syscall_linux_amd64_gc.go │ │ │ ├── syscall_linux_arm.go │ │ │ ├── syscall_linux_arm64.go │ │ │ ├── syscall_linux_gc.go │ │ │ ├── syscall_linux_gc_386.go │ │ │ ├── syscall_linux_gc_arm.go │ │ │ ├── syscall_linux_gccgo_386.go │ │ │ ├── syscall_linux_gccgo_arm.go │ │ │ ├── syscall_linux_loong64.go │ │ │ ├── syscall_linux_mips64x.go │ │ │ ├── syscall_linux_mipsx.go │ │ │ ├── syscall_linux_ppc.go │ │ │ ├── syscall_linux_ppc64x.go │ │ │ ├── syscall_linux_riscv64.go │ │ │ ├── syscall_linux_s390x.go │ │ │ ├── syscall_linux_sparc64.go │ │ │ ├── syscall_netbsd.go │ │ │ ├── syscall_netbsd_386.go │ │ │ ├── syscall_netbsd_amd64.go │ │ │ ├── syscall_netbsd_arm.go │ │ │ ├── syscall_netbsd_arm64.go │ │ │ ├── syscall_openbsd.go │ │ │ ├── syscall_openbsd_386.go │ │ │ ├── syscall_openbsd_amd64.go │ │ │ ├── syscall_openbsd_arm.go │ │ │ ├── syscall_openbsd_arm64.go │ │ │ ├── syscall_openbsd_libc.go │ │ │ ├── syscall_openbsd_mips64.go │ │ │ ├── syscall_openbsd_ppc64.go │ │ │ ├── syscall_openbsd_riscv64.go │ │ │ ├── syscall_solaris.go │ │ │ ├── syscall_solaris_amd64.go │ │ │ ├── syscall_unix.go │ │ │ ├── syscall_unix_gc.go │ │ │ ├── syscall_unix_gc_ppc64x.go │ │ │ ├── syscall_zos_s390x.go │ │ │ ├── sysvshm_linux.go │ │ │ ├── sysvshm_unix.go │ │ │ ├── sysvshm_unix_other.go │ │ │ ├── timestruct.go │ │ │ ├── unveil_openbsd.go │ │ │ ├── xattr_bsd.go │ │ │ ├── zerrors_aix_ppc.go │ │ │ ├── zerrors_aix_ppc64.go │ │ │ ├── zerrors_darwin_amd64.go │ │ │ ├── zerrors_darwin_arm64.go │ │ │ ├── zerrors_dragonfly_amd64.go │ │ │ ├── zerrors_freebsd_386.go │ │ │ ├── zerrors_freebsd_amd64.go │ │ │ ├── zerrors_freebsd_arm.go │ │ │ ├── zerrors_freebsd_arm64.go │ │ │ ├── zerrors_freebsd_riscv64.go │ │ │ ├── zerrors_linux.go │ │ │ ├── zerrors_linux_386.go │ │ │ ├── zerrors_linux_amd64.go │ │ │ ├── zerrors_linux_arm.go │ │ │ ├── zerrors_linux_arm64.go │ │ │ ├── zerrors_linux_loong64.go │ │ │ ├── zerrors_linux_mips.go │ │ │ ├── zerrors_linux_mips64.go │ │ │ ├── zerrors_linux_mips64le.go │ │ │ ├── zerrors_linux_mipsle.go │ │ │ ├── zerrors_linux_ppc.go │ │ │ ├── zerrors_linux_ppc64.go │ │ │ ├── zerrors_linux_ppc64le.go │ │ │ ├── zerrors_linux_riscv64.go │ │ │ ├── zerrors_linux_s390x.go │ │ │ ├── zerrors_linux_sparc64.go │ │ │ ├── zerrors_netbsd_386.go │ │ │ ├── zerrors_netbsd_amd64.go │ │ │ ├── zerrors_netbsd_arm.go │ │ │ ├── zerrors_netbsd_arm64.go │ │ │ ├── zerrors_openbsd_386.go │ │ │ ├── zerrors_openbsd_amd64.go │ │ │ ├── zerrors_openbsd_arm.go │ │ │ ├── zerrors_openbsd_arm64.go │ │ │ ├── zerrors_openbsd_mips64.go │ │ │ ├── zerrors_openbsd_ppc64.go │ │ │ ├── zerrors_openbsd_riscv64.go │ │ │ ├── zerrors_solaris_amd64.go │ │ │ ├── zerrors_zos_s390x.go │ │ │ ├── zptrace_armnn_linux.go │ │ │ ├── zptrace_linux_arm64.go │ │ │ ├── zptrace_mipsnn_linux.go │ │ │ ├── zptrace_mipsnnle_linux.go │ │ │ ├── zptrace_x86_linux.go │ │ │ ├── zsymaddr_zos_s390x.s │ │ │ ├── zsyscall_aix_ppc.go │ │ │ ├── zsyscall_aix_ppc64.go │ │ │ ├── zsyscall_aix_ppc64_gc.go │ │ │ ├── zsyscall_aix_ppc64_gccgo.go │ │ │ ├── zsyscall_darwin_amd64.go │ │ │ ├── zsyscall_darwin_amd64.s │ │ │ ├── zsyscall_darwin_arm64.go │ │ │ ├── zsyscall_darwin_arm64.s │ │ │ ├── zsyscall_dragonfly_amd64.go │ │ │ ├── zsyscall_freebsd_386.go │ │ │ ├── zsyscall_freebsd_amd64.go │ │ │ ├── zsyscall_freebsd_arm.go │ │ │ ├── zsyscall_freebsd_arm64.go │ │ │ ├── zsyscall_freebsd_riscv64.go │ │ │ ├── zsyscall_illumos_amd64.go │ │ │ ├── zsyscall_linux.go │ │ │ ├── zsyscall_linux_386.go │ │ │ ├── zsyscall_linux_amd64.go │ │ │ ├── zsyscall_linux_arm.go │ │ │ ├── zsyscall_linux_arm64.go │ │ │ ├── zsyscall_linux_loong64.go │ │ │ ├── zsyscall_linux_mips.go │ │ │ ├── zsyscall_linux_mips64.go │ │ │ ├── zsyscall_linux_mips64le.go │ │ │ ├── zsyscall_linux_mipsle.go │ │ │ ├── zsyscall_linux_ppc.go │ │ │ ├── zsyscall_linux_ppc64.go │ │ │ ├── zsyscall_linux_ppc64le.go │ │ │ ├── zsyscall_linux_riscv64.go │ │ │ ├── zsyscall_linux_s390x.go │ │ │ ├── zsyscall_linux_sparc64.go │ │ │ ├── zsyscall_netbsd_386.go │ │ │ ├── zsyscall_netbsd_amd64.go │ │ │ ├── zsyscall_netbsd_arm.go │ │ │ ├── zsyscall_netbsd_arm64.go │ │ │ ├── zsyscall_openbsd_386.go │ │ │ ├── zsyscall_openbsd_386.s │ │ │ ├── zsyscall_openbsd_amd64.go │ │ │ ├── zsyscall_openbsd_amd64.s │ │ │ ├── zsyscall_openbsd_arm.go │ │ │ ├── zsyscall_openbsd_arm.s │ │ │ ├── zsyscall_openbsd_arm64.go │ │ │ ├── zsyscall_openbsd_arm64.s │ │ │ ├── zsyscall_openbsd_mips64.go │ │ │ ├── zsyscall_openbsd_mips64.s │ │ │ ├── zsyscall_openbsd_ppc64.go │ │ │ ├── zsyscall_openbsd_ppc64.s │ │ │ ├── zsyscall_openbsd_riscv64.go │ │ │ ├── zsyscall_openbsd_riscv64.s │ │ │ ├── zsyscall_solaris_amd64.go │ │ │ ├── zsyscall_zos_s390x.go │ │ │ ├── zsysctl_openbsd_386.go │ │ │ ├── zsysctl_openbsd_amd64.go │ │ │ ├── zsysctl_openbsd_arm.go │ │ │ ├── zsysctl_openbsd_arm64.go │ │ │ ├── zsysctl_openbsd_mips64.go │ │ │ ├── zsysctl_openbsd_ppc64.go │ │ │ ├── zsysctl_openbsd_riscv64.go │ │ │ ├── zsysnum_darwin_amd64.go │ │ │ ├── zsysnum_darwin_arm64.go │ │ │ ├── zsysnum_dragonfly_amd64.go │ │ │ ├── zsysnum_freebsd_386.go │ │ │ ├── zsysnum_freebsd_amd64.go │ │ │ ├── zsysnum_freebsd_arm.go │ │ │ ├── zsysnum_freebsd_arm64.go │ │ │ ├── zsysnum_freebsd_riscv64.go │ │ │ ├── zsysnum_linux_386.go │ │ │ ├── zsysnum_linux_amd64.go │ │ │ ├── zsysnum_linux_arm.go │ │ │ ├── zsysnum_linux_arm64.go │ │ │ ├── zsysnum_linux_loong64.go │ │ │ ├── zsysnum_linux_mips.go │ │ │ ├── zsysnum_linux_mips64.go │ │ │ ├── zsysnum_linux_mips64le.go │ │ │ ├── zsysnum_linux_mipsle.go │ │ │ ├── zsysnum_linux_ppc.go │ │ │ ├── zsysnum_linux_ppc64.go │ │ │ ├── zsysnum_linux_ppc64le.go │ │ │ ├── zsysnum_linux_riscv64.go │ │ │ ├── zsysnum_linux_s390x.go │ │ │ ├── zsysnum_linux_sparc64.go │ │ │ ├── zsysnum_netbsd_386.go │ │ │ ├── zsysnum_netbsd_amd64.go │ │ │ ├── zsysnum_netbsd_arm.go │ │ │ ├── zsysnum_netbsd_arm64.go │ │ │ ├── zsysnum_openbsd_386.go │ │ │ ├── zsysnum_openbsd_amd64.go │ │ │ ├── zsysnum_openbsd_arm.go │ │ │ ├── zsysnum_openbsd_arm64.go │ │ │ ├── zsysnum_openbsd_mips64.go │ │ │ ├── zsysnum_openbsd_ppc64.go │ │ │ ├── zsysnum_openbsd_riscv64.go │ │ │ ├── zsysnum_zos_s390x.go │ │ │ ├── ztypes_aix_ppc.go │ │ │ ├── ztypes_aix_ppc64.go │ │ │ ├── ztypes_darwin_amd64.go │ │ │ ├── ztypes_darwin_arm64.go │ │ │ ├── ztypes_dragonfly_amd64.go │ │ │ ├── ztypes_freebsd_386.go │ │ │ ├── ztypes_freebsd_amd64.go │ │ │ ├── ztypes_freebsd_arm.go │ │ │ ├── ztypes_freebsd_arm64.go │ │ │ ├── ztypes_freebsd_riscv64.go │ │ │ ├── ztypes_linux.go │ │ │ ├── ztypes_linux_386.go │ │ │ ├── ztypes_linux_amd64.go │ │ │ ├── ztypes_linux_arm.go │ │ │ ├── ztypes_linux_arm64.go │ │ │ ├── ztypes_linux_loong64.go │ │ │ ├── ztypes_linux_mips.go │ │ │ ├── ztypes_linux_mips64.go │ │ │ ├── ztypes_linux_mips64le.go │ │ │ ├── ztypes_linux_mipsle.go │ │ │ ├── ztypes_linux_ppc.go │ │ │ ├── ztypes_linux_ppc64.go │ │ │ ├── ztypes_linux_ppc64le.go │ │ │ ├── ztypes_linux_riscv64.go │ │ │ ├── ztypes_linux_s390x.go │ │ │ ├── ztypes_linux_sparc64.go │ │ │ ├── ztypes_netbsd_386.go │ │ │ ├── ztypes_netbsd_amd64.go │ │ │ ├── ztypes_netbsd_arm.go │ │ │ ├── ztypes_netbsd_arm64.go │ │ │ ├── ztypes_openbsd_386.go │ │ │ ├── ztypes_openbsd_amd64.go │ │ │ ├── ztypes_openbsd_arm.go │ │ │ ├── ztypes_openbsd_arm64.go │ │ │ ├── ztypes_openbsd_mips64.go │ │ │ ├── ztypes_openbsd_ppc64.go │ │ │ ├── ztypes_openbsd_riscv64.go │ │ │ ├── ztypes_solaris_amd64.go │ │ │ └── ztypes_zos_s390x.go │ │ │ └── windows │ │ │ ├── aliases.go │ │ │ ├── dll_windows.go │ │ │ ├── env_windows.go │ │ │ ├── eventlog.go │ │ │ ├── exec_windows.go │ │ │ ├── memory_windows.go │ │ │ ├── mkerrors.bash │ │ │ ├── mkknownfolderids.bash │ │ │ ├── mksyscall.go │ │ │ ├── race.go │ │ │ ├── race0.go │ │ │ ├── security_windows.go │ │ │ ├── service.go │ │ │ ├── setupapi_windows.go │ │ │ ├── str.go │ │ │ ├── syscall.go │ │ │ ├── syscall_windows.go │ │ │ ├── types_windows.go │ │ │ ├── types_windows_386.go │ │ │ ├── types_windows_amd64.go │ │ │ ├── types_windows_arm.go │ │ │ ├── types_windows_arm64.go │ │ │ ├── zerrors_windows.go │ │ │ ├── zknownfolderids_windows.go │ │ │ └── zsyscall_windows.go │ ├── gopkg.in │ │ └── yaml.v3 │ │ │ ├── LICENSE │ │ │ ├── NOTICE │ │ │ ├── README.md │ │ │ ├── apic.go │ │ │ ├── decode.go │ │ │ ├── emitterc.go │ │ │ ├── encode.go │ │ │ ├── parserc.go │ │ │ ├── readerc.go │ │ │ ├── resolve.go │ │ │ ├── scannerc.go │ │ │ ├── sorter.go │ │ │ ├── writerc.go │ │ │ ├── yaml.go │ │ │ ├── yamlh.go │ │ │ └── yamlprivateh.go │ └── modules.txt └── version │ └── version.go └── scripts ├── build_binary.sh ├── build_third_party_licenses.sh ├── build_variant.sh ├── container_init.sh ├── gogenerate ├── hack ├── codepipeline-git-commit.sh ├── codepipeline-source-archive.sh ├── symlink-gopath-codebuild.sh └── version-changelog.sh └── third_party_licenses ├── APACHE_LICENSE ├── apache.tpl └── other.tpl /.codebuild/buildspec.yml: -------------------------------------------------------------------------------- 1 | version: 0.2 2 | 3 | phases: 4 | install: 5 | commands: 6 | - chmod +x -R scripts 7 | - ./scripts/container_init.sh 8 | - ./scripts/hack/codepipeline-git-commit.sh 9 | - ./scripts/hack/symlink-gopath-codebuild.sh 10 | - cd /go/src/github.com/awslabs/amazon-ecr-credential-helper 11 | pre_build: 12 | commands: 13 | - echo "Starting tests..." 14 | - make test 15 | build: 16 | commands: 17 | - echo "Starting build..." 18 | - make all-variants 19 | post_build: 20 | commands: 21 | - echo "Build completed on $(date)" 22 | artifacts: 23 | files: 24 | - '**/*' 25 | base-directory: 'bin' 26 | -------------------------------------------------------------------------------- /.codebuild/source-archive.yml: -------------------------------------------------------------------------------- 1 | version: 0.2 2 | 3 | phases: 4 | build: 5 | commands: 6 | - ./scripts/hack/codepipeline-source-archive.sh 7 | - ./scripts/hack/version-changelog.sh | tee archive/VERSION_CHANGELOG.md 8 | post_build: 9 | commands: 10 | - echo "Archive completed on $(date)" 11 | artifacts: 12 | files: 13 | - 'release.tar.gz' 14 | - 'release-novendor.tar.gz' 15 | - 'VERSION' 16 | - 'GITCOMMIT_SHA' 17 | - 'VERSION_CHANGELOG.md' 18 | base-directory: 'archive' 19 | -------------------------------------------------------------------------------- /.github/CODEOWNERS: -------------------------------------------------------------------------------- 1 | * @awslabs/runtime @awslabs/ecr 2 | 3 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/config.yml: -------------------------------------------------------------------------------- 1 | blank_issues_enabled: true 2 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/third_party_license_usage_request.yml: -------------------------------------------------------------------------------- 1 | name: 3rd Party License Request 2 | description: File a request for usage of a 3rd party license in the Amazon ECR credential helpers project. 3 | title: "[3rd Party License Request]: " 4 | labels: "license-request" 5 | body: 6 | - type: markdown 7 | attributes: 8 | value: | 9 | Thanks for taking the time to fill out this request! 10 | 11 | - type: textarea 12 | id: license-request 13 | attributes: 14 | label: License request 15 | value: | 16 | License: 17 | 18 | - type: textarea 19 | id: use-case 20 | attributes: 21 | label: Use case 22 | description: | 23 | Briefly describe the use case the dependency would resolve. 24 | validations: 25 | required: true 26 | 27 | - type: textarea 28 | id: other-solutions 29 | attributes: 30 | label: Other solutions considered 31 | -------------------------------------------------------------------------------- /.github/PULL_REQUEST_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | *Issue #, if available:* 2 | 3 | *Description of changes:* 4 | 5 | 6 | By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license. 7 | -------------------------------------------------------------------------------- /.github/dependabot.yml: -------------------------------------------------------------------------------- 1 | version: 2 2 | updates: 3 | # Dependencies listed in ecr-login/go.mod 4 | - package-ecosystem: "gomod" 5 | directory: "/ecr-login" 6 | schedule: 7 | interval: "daily" 8 | groups: 9 | # Group updates from github.com/aws/aws-sdk-go-v2 dependencies 10 | aws-sdk-go-v2: 11 | patterns: 12 | - "github.com/aws/aws-sdk-go-v2/*" 13 | 14 | # Dependencies listed in .github/workflows/*.yml 15 | - package-ecosystem: "github-actions" 16 | directory: "/" 17 | schedule: 18 | interval: "daily" 19 | 20 | # Base image in Dockerfile 21 | - package-ecosystem: "docker" 22 | directory: "/" 23 | schedule: 24 | interval: "daily" 25 | -------------------------------------------------------------------------------- /.github/dependency-review-config.yml: -------------------------------------------------------------------------------- 1 | # Fail third party dependency usage if not covered by the curated set of pre-approved licenses. 2 | # 3 | # List was generated from guidance set forth by Amazon open source usage policies. 4 | allow-licenses: 5 | - 'Apache-2.0' 6 | - 'BSD-3-Clause' 7 | - 'ISC' 8 | - 'MIT' 9 | -------------------------------------------------------------------------------- /.github/new-pull-request-labels.yml: -------------------------------------------------------------------------------- 1 | aws_partition_change: 2 | - changed-files: 3 | - any-glob-to-any-file: ['ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/awsrulesfn/partitions.*'] 4 | 5 | dependencies: 6 | - changed-files: 7 | - any-glob-to-any-file: ['**/go.mod', '**/go.sum'] 8 | 9 | documentation: 10 | - changed-files: 11 | - all-globs-to-all-files: ['**/*.md'] 12 | 13 | github_actions: 14 | - changed-files: 15 | - any-glob-to-any-file: ['.github/**', 'scripts/**'] 16 | 17 | go: 18 | - changed-files: 19 | - any-glob-to-any-file: ['**/*.go'] 20 | 21 | testing: 22 | - changed-files: 23 | - any-glob-to-any-file: ['integration/**', '**/*_test.go'] 24 | -------------------------------------------------------------------------------- /.github/workflows/check-links.yml: -------------------------------------------------------------------------------- 1 | name: Check Links 2 | 3 | on: 4 | workflow_dispatch: 5 | schedule: 6 | - cron: "0 0 * * 3" # Every Wednesday at 00:00 UTC 7 | pull_request: 8 | paths: 9 | - ".github/workflows/check-links.yml" 10 | 11 | jobs: 12 | check: 13 | runs-on: ubuntu-22.04 14 | if: github.repository == 'awslabs/amazon-ecr-credential-helper' 15 | name: lychee 16 | timeout-minutes: 15 17 | steps: 18 | - uses: actions/checkout@v4 19 | - uses: lycheeverse/lychee-action@v2.4.0 20 | with: 21 | fail: true 22 | args: --exclude-path ecr-login/vendor --timeout 30 --no-progress './**/*.md' 23 | format: markdown 24 | jobSummary: true 25 | -------------------------------------------------------------------------------- /.github/workflows/codeql.yml: -------------------------------------------------------------------------------- 1 | name: "CodeQL Scan" 2 | 3 | on: 4 | push: 5 | branches: [ "main" ] 6 | pull_request: 7 | branches: [ "main" ] 8 | schedule: 9 | - cron: '25 21 * * 5' 10 | 11 | jobs: 12 | analyze: 13 | name: Analyze 14 | runs-on: ubuntu-22.04 15 | permissions: 16 | actions: read 17 | contents: read 18 | security-events: write 19 | 20 | strategy: 21 | fail-fast: false 22 | matrix: 23 | language: [ 'go' ] 24 | 25 | steps: 26 | - name: Checkout repository 27 | uses: actions/checkout@v4 28 | 29 | # Initializes the CodeQL tools for scanning. 30 | - name: Initialize CodeQL 31 | uses: github/codeql-action/init@v3 32 | with: 33 | languages: ${{ matrix.language }} 34 | 35 | - name: Build 36 | run: make build 37 | 38 | - name: Perform CodeQL Analysis 39 | uses: github/codeql-action/analyze@v3 40 | with: 41 | category: "/language:${{matrix.language}}" 42 | 43 | -------------------------------------------------------------------------------- /.github/workflows/new-pull-requests.yml: -------------------------------------------------------------------------------- 1 | name: "New Pull Requests" 2 | 3 | on: 4 | # It is safe to use pull_request_target here because we are not checking out 5 | # code from the pull request branch. 6 | # 7 | # See https://securitylab.github.com/research/github-actions-preventing-pwn-requests/ 8 | pull_request_target: 9 | 10 | permissions: 11 | contents: read 12 | 13 | jobs: 14 | label: 15 | if: github.event.pull_request.draft == false 16 | runs-on: ubuntu-22.04 17 | 18 | permissions: 19 | pull-requests: write 20 | 21 | steps: 22 | # Use label configuration from main instead of from the pull request branch 23 | # to mitigate running untrusted workflows with write permissions. 24 | - uses: actions/labeler@v5 25 | with: 26 | configuration-path: '.github/new-pull-request-labels.yml' 27 | sync-labels: true 28 | -------------------------------------------------------------------------------- /.github/workflows/review-dependencies.yml: -------------------------------------------------------------------------------- 1 | name: Review dependencies 2 | 3 | on: 4 | pull_request: 5 | branches: ['main', 'release/**'] 6 | paths: 7 | - 'ecr-login/go.*' 8 | 9 | jobs: 10 | review: 11 | runs-on: ubuntu-latest 12 | 13 | permissions: 14 | # Write permissions needed to comment review results on PR. 15 | # Pwn request risk mitigated by using pull_request workflow trigger 16 | # and external contributor workflow runs require maintainer approval. 17 | pull-requests: write 18 | 19 | steps: 20 | - uses: actions/checkout@v4 21 | - uses: actions/dependency-review-action@v4 22 | with: 23 | config-file: './.github/dependency-review-config.yml' 24 | comment-summary-in-pr: always 25 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /bin/ 2 | GITCOMMIT_SHA 3 | *.tar.gz 4 | *.tar 5 | -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | ## Code of Conduct 2 | This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct). 3 | For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact 4 | opensource-codeofconduct@amazon.com with any additional questions or comments. 5 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"). You 4 | # may not use this file except in compliance with the License. A copy of 5 | # the License is located at 6 | # 7 | # http://aws.amazon.com/apache2.0/ 8 | # 9 | # or in the "license" file accompanying this file. This file is 10 | # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF 11 | # ANY KIND, either express or implied. See the License for the specific 12 | # language governing permissions and limitations under the License. 13 | 14 | FROM public.ecr.aws/docker/library/golang:1.23-alpine 15 | 16 | WORKDIR /go/src/github.com/awslabs/amazon-ecr-credential-helper 17 | 18 | COPY ./scripts/container_init.sh /setup/container_init.sh 19 | 20 | RUN /setup/container_init.sh 21 | 22 | -------------------------------------------------------------------------------- /NOTICE: -------------------------------------------------------------------------------- 1 | Amazon ECR Credential Helper 2 | Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | -------------------------------------------------------------------------------- /VERSION: -------------------------------------------------------------------------------- 1 | 0.10.0 2 | -------------------------------------------------------------------------------- /docs/ecr.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/awslabs/amazon-ecr-credential-helper/79ad5557681c631ff7f9391a561609a8452f81c1/docs/ecr.png -------------------------------------------------------------------------------- /docs/packaging.md: -------------------------------------------------------------------------------- 1 | # Packaging Amazon ECR Credential Helper 2 | 3 | Amazon maintains packages for the Amazon ECR Credential Helper on the following 4 | operating systems: 5 | 6 | * Amazon Linux 2 7 | ([source](https://github.com/awslabs/amazon-ecr-credential-helper/tree/amazonlinux), 8 | [packaging documentation](https://github.com/awslabs/amazon-ecr-credential-helper/blob/amazonlinux/docs/packaging-amazon-linux.md)) 9 | * Debian 10 | ([source](https://github.com/awslabs/amazon-ecr-credential-helper/tree/debian)) 11 | (note: the packages in derivatives of Debian like Devuan, Ubuntu 19.04 Disco 12 | Dingo, and PureOS are derived from the Debian package with no additional 13 | modifications) 14 | 15 | There are community-maintained packages for the Amazon ECR Credential Helper on 16 | the following operating systems: 17 | 18 | * Mac OS X (with the Homebrew package manager) 19 | ([source](https://github.com/Homebrew/homebrew-core/blob/master/Formula/d/docker-credential-helper-ecr.rb)) 20 | * NixOS (and the Nix package manager) 21 | ([source](https://github.com/NixOS/nixpkgs/blob/master/pkgs/by-name/am/amazon-ecr-credential-helper/package.nix)) 22 | * Arch Linux (in the Arch User Repository) 23 | ([source](https://aur.archlinux.org/packages/amazon-ecr-credential-helper)) 24 | 25 | If you are interested in packaging the Amazon ECR Credential Helper, please get 26 | in touch! We can list your community-maintained packaging here and include 27 | installation instructions in our [README.md](../README.md). 28 | -------------------------------------------------------------------------------- /ecr-login/cache/null.go: -------------------------------------------------------------------------------- 1 | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"). You may 4 | // not use this file except in compliance with the License. A copy of the 5 | // License is located at 6 | // 7 | // http://aws.amazon.com/apache2.0/ 8 | // 9 | // or in the "license" file accompanying this file. This file is distributed 10 | // on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 11 | // express or implied. See the License for the specific language governing 12 | // permissions and limitations under the License. 13 | 14 | package cache 15 | 16 | type nullCredentialsCache struct{} 17 | 18 | func NewNullCredentialsCache() CredentialsCache { 19 | return &nullCredentialsCache{} 20 | } 21 | 22 | func (n *nullCredentialsCache) Get(_ string) *AuthEntry { 23 | return nil 24 | } 25 | 26 | func (n *nullCredentialsCache) GetPublic() *AuthEntry { 27 | return nil 28 | } 29 | 30 | func (n *nullCredentialsCache) Set(_ string, _ *AuthEntry) { 31 | } 32 | 33 | func (n *nullCredentialsCache) List() []*AuthEntry { 34 | return []*AuthEntry{} 35 | } 36 | 37 | func (n *nullCredentialsCache) Clear() { 38 | } 39 | -------------------------------------------------------------------------------- /ecr-login/cache/null_test.go: -------------------------------------------------------------------------------- 1 | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"). You may 4 | // not use this file except in compliance with the License. A copy of the 5 | // License is located at 6 | // 7 | // http://aws.amazon.com/apache2.0/ 8 | // 9 | // or in the "license" file accompanying this file. This file is distributed 10 | // on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 11 | // express or implied. See the License for the specific language governing 12 | // permissions and limitations under the License. 13 | 14 | package cache 15 | 16 | import ( 17 | "testing" 18 | 19 | "github.com/stretchr/testify/assert" 20 | ) 21 | 22 | func TestNullCache(t *testing.T) { 23 | credentialCache := NewNullCredentialsCache() 24 | 25 | entry := credentialCache.Get(testRegistryName) 26 | assert.Nil(t, entry) 27 | 28 | credentialCache.Set(testRegistryName, &testAuthEntry) 29 | 30 | entry = credentialCache.Get(testRegistryName) 31 | assert.Nil(t, entry) 32 | 33 | credentialCache.Clear() 34 | 35 | entries := credentialCache.List() 36 | assert.Empty(t, entries) 37 | } 38 | -------------------------------------------------------------------------------- /ecr-login/config/cache_dir.go: -------------------------------------------------------------------------------- 1 | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"). You may 4 | // not use this file except in compliance with the License. A copy of the 5 | // License is located at 6 | // 7 | // http://aws.amazon.com/apache2.0/ 8 | // 9 | // or in the "license" file accompanying this file. This file is distributed 10 | // on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 11 | // express or implied. See the License for the specific language governing 12 | // permissions and limitations under the License. 13 | 14 | package config 15 | 16 | import "os" 17 | 18 | func GetCacheDir() string { 19 | if cacheDir := os.Getenv("AWS_ECR_CACHE_DIR"); cacheDir != "" { 20 | return cacheDir 21 | } 22 | return "~/.ecr" 23 | } 24 | -------------------------------------------------------------------------------- /ecr-login/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/awslabs/amazon-ecr-credential-helper/ecr-login 2 | 3 | go 1.22 4 | 5 | require ( 6 | github.com/aws/aws-sdk-go-v2 v1.36.3 7 | github.com/aws/aws-sdk-go-v2/config v1.29.14 8 | github.com/aws/aws-sdk-go-v2/credentials v1.17.67 9 | github.com/aws/aws-sdk-go-v2/service/ecr v1.44.0 10 | github.com/aws/aws-sdk-go-v2/service/ecrpublic v1.33.0 11 | github.com/aws/smithy-go v1.22.3 12 | github.com/docker/docker-credential-helpers v0.9.3 13 | github.com/mitchellh/go-homedir v1.1.0 14 | github.com/sirupsen/logrus v1.9.3 15 | github.com/stretchr/testify v1.10.0 16 | ) 17 | 18 | require ( 19 | github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30 // indirect 20 | github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 // indirect 21 | github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 // indirect 22 | github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 // indirect 23 | github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.3 // indirect 24 | github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.15 // indirect 25 | github.com/aws/aws-sdk-go-v2/service/sso v1.25.3 // indirect 26 | github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.1 // indirect 27 | github.com/aws/aws-sdk-go-v2/service/sts v1.33.19 // indirect 28 | github.com/davecgh/go-spew v1.1.1 // indirect 29 | github.com/pmezard/go-difflib v1.0.0 // indirect 30 | golang.org/x/sys v0.20.0 // indirect 31 | gopkg.in/yaml.v3 v3.0.1 // indirect 32 | ) 33 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/NOTICE.txt: -------------------------------------------------------------------------------- 1 | AWS SDK for Go 2 | Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | Copyright 2014-2015 Stripe, Inc. 4 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/accountid_endpoint_mode.go: -------------------------------------------------------------------------------- 1 | package aws 2 | 3 | // AccountIDEndpointMode controls how a resolved AWS account ID is handled for endpoint routing. 4 | type AccountIDEndpointMode string 5 | 6 | const ( 7 | // AccountIDEndpointModeUnset indicates the AWS account ID will not be used for endpoint routing 8 | AccountIDEndpointModeUnset AccountIDEndpointMode = "" 9 | 10 | // AccountIDEndpointModePreferred indicates the AWS account ID will be used for endpoint routing if present 11 | AccountIDEndpointModePreferred = "preferred" 12 | 13 | // AccountIDEndpointModeRequired indicates an error will be returned if the AWS account ID is not resolved from identity 14 | AccountIDEndpointModeRequired = "required" 15 | 16 | // AccountIDEndpointModeDisabled indicates the AWS account ID will be ignored during endpoint routing 17 | AccountIDEndpointModeDisabled = "disabled" 18 | ) 19 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/checksum.go: -------------------------------------------------------------------------------- 1 | package aws 2 | 3 | // RequestChecksumCalculation controls request checksum calculation workflow 4 | type RequestChecksumCalculation int 5 | 6 | const ( 7 | // RequestChecksumCalculationUnset is the unset value for RequestChecksumCalculation 8 | RequestChecksumCalculationUnset RequestChecksumCalculation = iota 9 | 10 | // RequestChecksumCalculationWhenSupported indicates request checksum will be calculated 11 | // if the operation supports input checksums 12 | RequestChecksumCalculationWhenSupported 13 | 14 | // RequestChecksumCalculationWhenRequired indicates request checksum will be calculated 15 | // if required by the operation or if user elects to set a checksum algorithm in request 16 | RequestChecksumCalculationWhenRequired 17 | ) 18 | 19 | // ResponseChecksumValidation controls response checksum validation workflow 20 | type ResponseChecksumValidation int 21 | 22 | const ( 23 | // ResponseChecksumValidationUnset is the unset value for ResponseChecksumValidation 24 | ResponseChecksumValidationUnset ResponseChecksumValidation = iota 25 | 26 | // ResponseChecksumValidationWhenSupported indicates response checksum will be validated 27 | // if the operation supports output checksums 28 | ResponseChecksumValidationWhenSupported 29 | 30 | // ResponseChecksumValidationWhenRequired indicates response checksum will only 31 | // be validated if the operation requires output checksum validation 32 | ResponseChecksumValidationWhenRequired 33 | ) 34 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/context.go: -------------------------------------------------------------------------------- 1 | package aws 2 | 3 | import ( 4 | "context" 5 | "time" 6 | ) 7 | 8 | type suppressedContext struct { 9 | context.Context 10 | } 11 | 12 | func (s *suppressedContext) Deadline() (deadline time.Time, ok bool) { 13 | return time.Time{}, false 14 | } 15 | 16 | func (s *suppressedContext) Done() <-chan struct{} { 17 | return nil 18 | } 19 | 20 | func (s *suppressedContext) Err() error { 21 | return nil 22 | } 23 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/defaults/auto.go: -------------------------------------------------------------------------------- 1 | package defaults 2 | 3 | import ( 4 | "github.com/aws/aws-sdk-go-v2/aws" 5 | "runtime" 6 | "strings" 7 | ) 8 | 9 | var getGOOS = func() string { 10 | return runtime.GOOS 11 | } 12 | 13 | // ResolveDefaultsModeAuto is used to determine the effective aws.DefaultsMode when the mode 14 | // is set to aws.DefaultsModeAuto. 15 | func ResolveDefaultsModeAuto(region string, environment aws.RuntimeEnvironment) aws.DefaultsMode { 16 | goos := getGOOS() 17 | if goos == "android" || goos == "ios" { 18 | return aws.DefaultsModeMobile 19 | } 20 | 21 | var currentRegion string 22 | if len(environment.EnvironmentIdentifier) > 0 { 23 | currentRegion = environment.Region 24 | } 25 | 26 | if len(currentRegion) == 0 && len(environment.EC2InstanceMetadataRegion) > 0 { 27 | currentRegion = environment.EC2InstanceMetadataRegion 28 | } 29 | 30 | if len(region) > 0 && len(currentRegion) > 0 { 31 | if strings.EqualFold(region, currentRegion) { 32 | return aws.DefaultsModeInRegion 33 | } 34 | return aws.DefaultsModeCrossRegion 35 | } 36 | 37 | return aws.DefaultsModeStandard 38 | } 39 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/defaults/configuration.go: -------------------------------------------------------------------------------- 1 | package defaults 2 | 3 | import ( 4 | "time" 5 | 6 | "github.com/aws/aws-sdk-go-v2/aws" 7 | ) 8 | 9 | // Configuration is the set of SDK configuration options that are determined based 10 | // on the configured DefaultsMode. 11 | type Configuration struct { 12 | // RetryMode is the configuration's default retry mode API clients should 13 | // use for constructing a Retryer. 14 | RetryMode aws.RetryMode 15 | 16 | // ConnectTimeout is the maximum amount of time a dial will wait for 17 | // a connect to complete. 18 | // 19 | // See https://pkg.go.dev/net#Dialer.Timeout 20 | ConnectTimeout *time.Duration 21 | 22 | // TLSNegotiationTimeout specifies the maximum amount of time waiting to 23 | // wait for a TLS handshake. 24 | // 25 | // See https://pkg.go.dev/net/http#Transport.TLSHandshakeTimeout 26 | TLSNegotiationTimeout *time.Duration 27 | } 28 | 29 | // GetConnectTimeout returns the ConnectTimeout value, returns false if the value is not set. 30 | func (c *Configuration) GetConnectTimeout() (time.Duration, bool) { 31 | if c.ConnectTimeout == nil { 32 | return 0, false 33 | } 34 | return *c.ConnectTimeout, true 35 | } 36 | 37 | // GetTLSNegotiationTimeout returns the TLSNegotiationTimeout value, returns false if the value is not set. 38 | func (c *Configuration) GetTLSNegotiationTimeout() (time.Duration, bool) { 39 | if c.TLSNegotiationTimeout == nil { 40 | return 0, false 41 | } 42 | return *c.TLSNegotiationTimeout, true 43 | } 44 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/defaults/doc.go: -------------------------------------------------------------------------------- 1 | // Package defaults provides recommended configuration values for AWS SDKs and CLIs. 2 | package defaults 3 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/errors.go: -------------------------------------------------------------------------------- 1 | package aws 2 | 3 | // MissingRegionError is an error that is returned if region configuration 4 | // value was not found. 5 | type MissingRegionError struct{} 6 | 7 | func (*MissingRegionError) Error() string { 8 | return "an AWS region is required, but was not found" 9 | } 10 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package aws 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.36.3" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/middleware/osname.go: -------------------------------------------------------------------------------- 1 | //go:build go1.16 2 | // +build go1.16 3 | 4 | package middleware 5 | 6 | import "runtime" 7 | 8 | func getNormalizedOSName() (os string) { 9 | switch runtime.GOOS { 10 | case "android": 11 | os = "android" 12 | case "linux": 13 | os = "linux" 14 | case "windows": 15 | os = "windows" 16 | case "darwin": 17 | os = "macos" 18 | case "ios": 19 | os = "ios" 20 | default: 21 | os = "other" 22 | } 23 | return os 24 | } 25 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/middleware/osname_go115.go: -------------------------------------------------------------------------------- 1 | //go:build !go1.16 2 | // +build !go1.16 3 | 4 | package middleware 5 | 6 | import "runtime" 7 | 8 | func getNormalizedOSName() (os string) { 9 | switch runtime.GOOS { 10 | case "android": 11 | os = "android" 12 | case "linux": 13 | os = "linux" 14 | case "windows": 15 | os = "windows" 16 | case "darwin": 17 | // Due to Apple M1 we can't distinguish between macOS and iOS when GOOS/GOARCH is darwin/amd64 18 | // For now declare this as "other" until we have a better detection mechanism. 19 | fallthrough 20 | default: 21 | os = "other" 22 | } 23 | return os 24 | } 25 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/middleware/request_id.go: -------------------------------------------------------------------------------- 1 | package middleware 2 | 3 | import ( 4 | "github.com/aws/smithy-go/middleware" 5 | ) 6 | 7 | // requestIDKey is used to retrieve request id from response metadata 8 | type requestIDKey struct{} 9 | 10 | // SetRequestIDMetadata sets the provided request id over middleware metadata 11 | func SetRequestIDMetadata(metadata *middleware.Metadata, id string) { 12 | metadata.Set(requestIDKey{}, id) 13 | } 14 | 15 | // GetRequestIDMetadata retrieves the request id from middleware metadata 16 | // returns string and bool indicating value of request id, whether request id was set. 17 | func GetRequestIDMetadata(metadata middleware.Metadata) (string, bool) { 18 | if !metadata.Has(requestIDKey{}) { 19 | return "", false 20 | } 21 | 22 | v, ok := metadata.Get(requestIDKey{}).(string) 23 | if !ok { 24 | return "", true 25 | } 26 | return v, true 27 | } 28 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/ratelimit/none.go: -------------------------------------------------------------------------------- 1 | package ratelimit 2 | 3 | import "context" 4 | 5 | // None implements a no-op rate limiter which effectively disables client-side 6 | // rate limiting (also known as "retry quotas"). 7 | // 8 | // GetToken does nothing and always returns a nil error. The returned 9 | // token-release function does nothing, and always returns a nil error. 10 | // 11 | // AddTokens does nothing and always returns a nil error. 12 | var None = &none{} 13 | 14 | type none struct{} 15 | 16 | func (*none) GetToken(ctx context.Context, cost uint) (func() error, error) { 17 | return func() error { return nil }, nil 18 | } 19 | 20 | func (*none) AddTokens(v uint) error { return nil } 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/request.go: -------------------------------------------------------------------------------- 1 | package aws 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // TODO remove replace with smithy.CanceledError 8 | 9 | // RequestCanceledError is the error that will be returned by an API request 10 | // that was canceled. Requests given a Context may return this error when 11 | // canceled. 12 | type RequestCanceledError struct { 13 | Err error 14 | } 15 | 16 | // CanceledError returns true to satisfy interfaces checking for canceled errors. 17 | func (*RequestCanceledError) CanceledError() bool { return true } 18 | 19 | // Unwrap returns the underlying error, if there was one. 20 | func (e *RequestCanceledError) Unwrap() error { 21 | return e.Err 22 | } 23 | func (e *RequestCanceledError) Error() string { 24 | return fmt.Sprintf("request canceled, %v", e.Err) 25 | } 26 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/retry/errors.go: -------------------------------------------------------------------------------- 1 | package retry 2 | 3 | import "fmt" 4 | 5 | // MaxAttemptsError provides the error when the maximum number of attempts have 6 | // been exceeded. 7 | type MaxAttemptsError struct { 8 | Attempt int 9 | Err error 10 | } 11 | 12 | func (e *MaxAttemptsError) Error() string { 13 | return fmt.Sprintf("exceeded maximum number of attempts, %d, %v", e.Attempt, e.Err) 14 | } 15 | 16 | // Unwrap returns the nested error causing the max attempts error. Provides the 17 | // implementation for errors.Is and errors.As to unwrap nested errors. 18 | func (e *MaxAttemptsError) Unwrap() error { 19 | return e.Err 20 | } 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/runtime.go: -------------------------------------------------------------------------------- 1 | package aws 2 | 3 | // ExecutionEnvironmentID is the AWS execution environment runtime identifier. 4 | type ExecutionEnvironmentID string 5 | 6 | // RuntimeEnvironment is a collection of values that are determined at runtime 7 | // based on the environment that the SDK is executing in. Some of these values 8 | // may or may not be present based on the executing environment and certain SDK 9 | // configuration properties that drive whether these values are populated.. 10 | type RuntimeEnvironment struct { 11 | EnvironmentIdentifier ExecutionEnvironmentID 12 | Region string 13 | EC2InstanceMetadataRegion string 14 | } 15 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/signer/internal/v4/hmac.go: -------------------------------------------------------------------------------- 1 | package v4 2 | 3 | import ( 4 | "crypto/hmac" 5 | "crypto/sha256" 6 | ) 7 | 8 | // HMACSHA256 computes a HMAC-SHA256 of data given the provided key. 9 | func HMACSHA256(key []byte, data []byte) []byte { 10 | hash := hmac.New(sha256.New, key) 11 | hash.Write(data) 12 | return hash.Sum(nil) 13 | } 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/signer/internal/v4/scope.go: -------------------------------------------------------------------------------- 1 | package v4 2 | 3 | import "strings" 4 | 5 | // BuildCredentialScope builds the Signature Version 4 (SigV4) signing scope 6 | func BuildCredentialScope(signingTime SigningTime, region, service string) string { 7 | return strings.Join([]string{ 8 | signingTime.ShortTimeFormat(), 9 | region, 10 | service, 11 | "aws4_request", 12 | }, "/") 13 | } 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/signer/internal/v4/time.go: -------------------------------------------------------------------------------- 1 | package v4 2 | 3 | import "time" 4 | 5 | // SigningTime provides a wrapper around a time.Time which provides cached values for SigV4 signing. 6 | type SigningTime struct { 7 | time.Time 8 | timeFormat string 9 | shortTimeFormat string 10 | } 11 | 12 | // NewSigningTime creates a new SigningTime given a time.Time 13 | func NewSigningTime(t time.Time) SigningTime { 14 | return SigningTime{ 15 | Time: t, 16 | } 17 | } 18 | 19 | // TimeFormat provides a time formatted in the X-Amz-Date format. 20 | func (m *SigningTime) TimeFormat() string { 21 | return m.format(&m.timeFormat, TimeFormat) 22 | } 23 | 24 | // ShortTimeFormat provides a time formatted of 20060102. 25 | func (m *SigningTime) ShortTimeFormat() string { 26 | return m.format(&m.shortTimeFormat, ShortTimeFormat) 27 | } 28 | 29 | func (m *SigningTime) format(target *string, format string) string { 30 | if len(*target) > 0 { 31 | return *target 32 | } 33 | v := m.Time.Format(format) 34 | *target = v 35 | return v 36 | } 37 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/transport/http/content_type.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | "github.com/aws/smithy-go/middleware" 7 | smithyhttp "github.com/aws/smithy-go/transport/http" 8 | ) 9 | 10 | // removeContentTypeHeader is a build middleware that removes 11 | // content type header if content-length header is unset or 12 | // is set to zero, 13 | type removeContentTypeHeader struct { 14 | } 15 | 16 | // ID the name of the middleware. 17 | func (m *removeContentTypeHeader) ID() string { 18 | return "RemoveContentTypeHeader" 19 | } 20 | 21 | // HandleBuild adds or appends the constructed user agent to the request. 22 | func (m *removeContentTypeHeader) HandleBuild(ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler) ( 23 | out middleware.BuildOutput, metadata middleware.Metadata, err error, 24 | ) { 25 | req, ok := in.Request.(*smithyhttp.Request) 26 | if !ok { 27 | return out, metadata, fmt.Errorf("unknown transport type %T", in) 28 | } 29 | 30 | // remove contentTypeHeader when content-length is zero 31 | if req.ContentLength == 0 { 32 | req.Header.Del("content-type") 33 | } 34 | 35 | return next.HandleBuild(ctx, in) 36 | } 37 | 38 | // RemoveContentTypeHeader removes content-type header if 39 | // content length is unset or equal to zero. 40 | func RemoveContentTypeHeader(stack *middleware.Stack) error { 41 | return stack.Build.Add(&removeContentTypeHeader{}, middleware.After) 42 | } 43 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/transport/http/response_error.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import ( 4 | "errors" 5 | "fmt" 6 | 7 | smithyhttp "github.com/aws/smithy-go/transport/http" 8 | ) 9 | 10 | // ResponseError provides the HTTP centric error type wrapping the underlying error 11 | // with the HTTP response value and the deserialized RequestID. 12 | type ResponseError struct { 13 | *smithyhttp.ResponseError 14 | 15 | // RequestID associated with response error 16 | RequestID string 17 | } 18 | 19 | // ServiceRequestID returns the request id associated with Response Error 20 | func (e *ResponseError) ServiceRequestID() string { return e.RequestID } 21 | 22 | // Error returns the formatted error 23 | func (e *ResponseError) Error() string { 24 | return fmt.Sprintf( 25 | "https response error StatusCode: %d, RequestID: %s, %v", 26 | e.Response.StatusCode, e.RequestID, e.Err) 27 | } 28 | 29 | // As populates target and returns true if the type of target is a error type that 30 | // the ResponseError embeds, (e.g.AWS HTTP ResponseError) 31 | func (e *ResponseError) As(target interface{}) bool { 32 | return errors.As(e.ResponseError, target) 33 | } 34 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/types.go: -------------------------------------------------------------------------------- 1 | package aws 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // Ternary is an enum allowing an unknown or none state in addition to a bool's 8 | // true and false. 9 | type Ternary int 10 | 11 | func (t Ternary) String() string { 12 | switch t { 13 | case UnknownTernary: 14 | return "unknown" 15 | case FalseTernary: 16 | return "false" 17 | case TrueTernary: 18 | return "true" 19 | default: 20 | return fmt.Sprintf("unknown value, %d", int(t)) 21 | } 22 | } 23 | 24 | // Bool returns true if the value is TrueTernary, false otherwise. 25 | func (t Ternary) Bool() bool { 26 | return t == TrueTernary 27 | } 28 | 29 | // Enumerations for the values of the Ternary type. 30 | const ( 31 | UnknownTernary Ternary = iota 32 | FalseTernary 33 | TrueTernary 34 | ) 35 | 36 | // BoolTernary returns a true or false Ternary value for the bool provided. 37 | func BoolTernary(v bool) Ternary { 38 | if v { 39 | return TrueTernary 40 | } 41 | return FalseTernary 42 | } 43 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/aws/version.go: -------------------------------------------------------------------------------- 1 | // Package aws provides core functionality for making requests to AWS services. 2 | package aws 3 | 4 | // SDKName is the name of this AWS SDK 5 | const SDKName = "aws-sdk-go-v2" 6 | 7 | // SDKVersion is the version of this SDK 8 | const SDKVersion = goModuleVersion 9 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/config/doc.go: -------------------------------------------------------------------------------- 1 | // Package config provides utilities for loading configuration from multiple 2 | // sources that can be used to configure the SDK's API clients, and utilities. 3 | // 4 | // The config package will load configuration from environment variables, AWS 5 | // shared configuration file (~/.aws/config), and AWS shared credentials file 6 | // (~/.aws/credentials). 7 | // 8 | // Use the LoadDefaultConfig to load configuration from all the SDK's supported 9 | // sources, and resolve credentials using the SDK's default credential chain. 10 | // 11 | // LoadDefaultConfig allows for a variadic list of additional Config sources that can 12 | // provide one or more configuration values which can be used to programmatically control the resolution 13 | // of a specific value, or allow for broader range of additional configuration sources not supported by the SDK. 14 | // A Config source implements one or more provider interfaces defined in this package. Config sources passed in will 15 | // take precedence over the default environment and shared config sources used by the SDK. If one or more Config sources 16 | // implement the same provider interface, priority will be handled by the order in which the sources were passed in. 17 | // 18 | // A number of helpers (prefixed by “With“) are provided in this package that implement their respective provider 19 | // interface. These helpers should be used for overriding configuration programmatically at runtime. 20 | package config 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/config/generate.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | //go:generate go run -tags codegen ./codegen -output=provider_assert_test.go 4 | //go:generate gofmt -s -w ./ 5 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/config/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package config 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.29.14" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/config/local.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "fmt" 5 | "net" 6 | "net/url" 7 | ) 8 | 9 | var lookupHostFn = net.LookupHost 10 | 11 | func isLoopbackHost(host string) (bool, error) { 12 | ip := net.ParseIP(host) 13 | if ip != nil { 14 | return ip.IsLoopback(), nil 15 | } 16 | 17 | // Host is not an ip, perform lookup 18 | addrs, err := lookupHostFn(host) 19 | if err != nil { 20 | return false, err 21 | } 22 | if len(addrs) == 0 { 23 | return false, fmt.Errorf("no addrs found for host, %s", host) 24 | } 25 | 26 | for _, addr := range addrs { 27 | if !net.ParseIP(addr).IsLoopback() { 28 | return false, nil 29 | } 30 | } 31 | 32 | return true, nil 33 | } 34 | 35 | func validateLocalURL(v string) error { 36 | u, err := url.Parse(v) 37 | if err != nil { 38 | return err 39 | } 40 | 41 | host := u.Hostname() 42 | if len(host) == 0 { 43 | return fmt.Errorf("unable to parse host from local HTTP cred provider URL") 44 | } else if isLoopback, err := isLoopbackHost(host); err != nil { 45 | return fmt.Errorf("failed to resolve host %q, %v", host, err) 46 | } else if !isLoopback { 47 | return fmt.Errorf("invalid endpoint host, %q, only host resolving to loopback addresses are allowed", host) 48 | } 49 | 50 | return nil 51 | } 52 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/credentials/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package credentials provides types for retrieving credentials from credentials sources. 3 | */ 4 | package credentials 5 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/credentials/endpointcreds/internal/client/auth.go: -------------------------------------------------------------------------------- 1 | package client 2 | 3 | import ( 4 | "context" 5 | "github.com/aws/smithy-go/middleware" 6 | ) 7 | 8 | type getIdentityMiddleware struct { 9 | options Options 10 | } 11 | 12 | func (*getIdentityMiddleware) ID() string { 13 | return "GetIdentity" 14 | } 15 | 16 | func (m *getIdentityMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( 17 | out middleware.FinalizeOutput, metadata middleware.Metadata, err error, 18 | ) { 19 | return next.HandleFinalize(ctx, in) 20 | } 21 | 22 | type signRequestMiddleware struct { 23 | } 24 | 25 | func (*signRequestMiddleware) ID() string { 26 | return "Signing" 27 | } 28 | 29 | func (m *signRequestMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( 30 | out middleware.FinalizeOutput, metadata middleware.Metadata, err error, 31 | ) { 32 | return next.HandleFinalize(ctx, in) 33 | } 34 | 35 | type resolveAuthSchemeMiddleware struct { 36 | operation string 37 | options Options 38 | } 39 | 40 | func (*resolveAuthSchemeMiddleware) ID() string { 41 | return "ResolveAuthScheme" 42 | } 43 | 44 | func (m *resolveAuthSchemeMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( 45 | out middleware.FinalizeOutput, metadata middleware.Metadata, err error, 46 | ) { 47 | return next.HandleFinalize(ctx, in) 48 | } 49 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/credentials/endpointcreds/internal/client/endpoints.go: -------------------------------------------------------------------------------- 1 | package client 2 | 3 | import ( 4 | "context" 5 | "github.com/aws/smithy-go/middleware" 6 | ) 7 | 8 | type resolveEndpointV2Middleware struct { 9 | options Options 10 | } 11 | 12 | func (*resolveEndpointV2Middleware) ID() string { 13 | return "ResolveEndpointV2" 14 | } 15 | 16 | func (m *resolveEndpointV2Middleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( 17 | out middleware.FinalizeOutput, metadata middleware.Metadata, err error, 18 | ) { 19 | return next.HandleFinalize(ctx, in) 20 | } 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/credentials/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package credentials 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.17.67" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/feature/ec2/imds/auth.go: -------------------------------------------------------------------------------- 1 | package imds 2 | 3 | import ( 4 | "context" 5 | "github.com/aws/smithy-go/middleware" 6 | ) 7 | 8 | type getIdentityMiddleware struct { 9 | options Options 10 | } 11 | 12 | func (*getIdentityMiddleware) ID() string { 13 | return "GetIdentity" 14 | } 15 | 16 | func (m *getIdentityMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( 17 | out middleware.FinalizeOutput, metadata middleware.Metadata, err error, 18 | ) { 19 | return next.HandleFinalize(ctx, in) 20 | } 21 | 22 | type signRequestMiddleware struct { 23 | } 24 | 25 | func (*signRequestMiddleware) ID() string { 26 | return "Signing" 27 | } 28 | 29 | func (m *signRequestMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( 30 | out middleware.FinalizeOutput, metadata middleware.Metadata, err error, 31 | ) { 32 | return next.HandleFinalize(ctx, in) 33 | } 34 | 35 | type resolveAuthSchemeMiddleware struct { 36 | operation string 37 | options Options 38 | } 39 | 40 | func (*resolveAuthSchemeMiddleware) ID() string { 41 | return "ResolveAuthScheme" 42 | } 43 | 44 | func (m *resolveAuthSchemeMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( 45 | out middleware.FinalizeOutput, metadata middleware.Metadata, err error, 46 | ) { 47 | return next.HandleFinalize(ctx, in) 48 | } 49 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/feature/ec2/imds/doc.go: -------------------------------------------------------------------------------- 1 | // Package imds provides the API client for interacting with the Amazon EC2 2 | // Instance Metadata Service. 3 | // 4 | // All Client operation calls have a default timeout. If the operation is not 5 | // completed before this timeout expires, the operation will be canceled. This 6 | // timeout can be overridden through the following: 7 | // - Set the options flag DisableDefaultTimeout 8 | // - Provide a Context with a timeout or deadline with calling the client's operations. 9 | // 10 | // See the EC2 IMDS user guide for more information on using the API. 11 | // https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html 12 | package imds 13 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/feature/ec2/imds/endpoints.go: -------------------------------------------------------------------------------- 1 | package imds 2 | 3 | import ( 4 | "context" 5 | "github.com/aws/smithy-go/middleware" 6 | ) 7 | 8 | type resolveEndpointV2Middleware struct { 9 | options Options 10 | } 11 | 12 | func (*resolveEndpointV2Middleware) ID() string { 13 | return "ResolveEndpointV2" 14 | } 15 | 16 | func (m *resolveEndpointV2Middleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( 17 | out middleware.FinalizeOutput, metadata middleware.Metadata, err error, 18 | ) { 19 | return next.HandleFinalize(ctx, in) 20 | } 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/feature/ec2/imds/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package imds 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.16.30" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/auth/smithy/bearer_token_adapter.go: -------------------------------------------------------------------------------- 1 | package smithy 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | "time" 7 | 8 | "github.com/aws/smithy-go" 9 | "github.com/aws/smithy-go/auth" 10 | "github.com/aws/smithy-go/auth/bearer" 11 | ) 12 | 13 | // BearerTokenAdapter adapts smithy bearer.Token to smithy auth.Identity. 14 | type BearerTokenAdapter struct { 15 | Token bearer.Token 16 | } 17 | 18 | var _ auth.Identity = (*BearerTokenAdapter)(nil) 19 | 20 | // Expiration returns the time of expiration for the token. 21 | func (v *BearerTokenAdapter) Expiration() time.Time { 22 | return v.Token.Expires 23 | } 24 | 25 | // BearerTokenProviderAdapter adapts smithy bearer.TokenProvider to smithy 26 | // auth.IdentityResolver. 27 | type BearerTokenProviderAdapter struct { 28 | Provider bearer.TokenProvider 29 | } 30 | 31 | var _ (auth.IdentityResolver) = (*BearerTokenProviderAdapter)(nil) 32 | 33 | // GetIdentity retrieves a bearer token using the underlying provider. 34 | func (v *BearerTokenProviderAdapter) GetIdentity(ctx context.Context, _ smithy.Properties) ( 35 | auth.Identity, error, 36 | ) { 37 | token, err := v.Provider.RetrieveBearerToken(ctx) 38 | if err != nil { 39 | return nil, fmt.Errorf("get token: %w", err) 40 | } 41 | 42 | return &BearerTokenAdapter{Token: token}, nil 43 | } 44 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/auth/smithy/bearer_token_signer_adapter.go: -------------------------------------------------------------------------------- 1 | package smithy 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | 7 | "github.com/aws/smithy-go" 8 | "github.com/aws/smithy-go/auth" 9 | "github.com/aws/smithy-go/auth/bearer" 10 | smithyhttp "github.com/aws/smithy-go/transport/http" 11 | ) 12 | 13 | // BearerTokenSignerAdapter adapts smithy bearer.Signer to smithy http 14 | // auth.Signer. 15 | type BearerTokenSignerAdapter struct { 16 | Signer bearer.Signer 17 | } 18 | 19 | var _ (smithyhttp.Signer) = (*BearerTokenSignerAdapter)(nil) 20 | 21 | // SignRequest signs the request with the provided bearer token. 22 | func (v *BearerTokenSignerAdapter) SignRequest(ctx context.Context, r *smithyhttp.Request, identity auth.Identity, _ smithy.Properties) error { 23 | ca, ok := identity.(*BearerTokenAdapter) 24 | if !ok { 25 | return fmt.Errorf("unexpected identity type: %T", identity) 26 | } 27 | 28 | signed, err := v.Signer.SignWithBearerToken(ctx, ca.Token, r) 29 | if err != nil { 30 | return fmt.Errorf("sign request: %w", err) 31 | } 32 | 33 | *r = *signed.(*smithyhttp.Request) 34 | return nil 35 | } 36 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/auth/smithy/credentials_adapter.go: -------------------------------------------------------------------------------- 1 | package smithy 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | "time" 7 | 8 | "github.com/aws/aws-sdk-go-v2/aws" 9 | "github.com/aws/smithy-go" 10 | "github.com/aws/smithy-go/auth" 11 | ) 12 | 13 | // CredentialsAdapter adapts aws.Credentials to auth.Identity. 14 | type CredentialsAdapter struct { 15 | Credentials aws.Credentials 16 | } 17 | 18 | var _ auth.Identity = (*CredentialsAdapter)(nil) 19 | 20 | // Expiration returns the time of expiration for the credentials. 21 | func (v *CredentialsAdapter) Expiration() time.Time { 22 | return v.Credentials.Expires 23 | } 24 | 25 | // CredentialsProviderAdapter adapts aws.CredentialsProvider to auth.IdentityResolver. 26 | type CredentialsProviderAdapter struct { 27 | Provider aws.CredentialsProvider 28 | } 29 | 30 | var _ (auth.IdentityResolver) = (*CredentialsProviderAdapter)(nil) 31 | 32 | // GetIdentity retrieves AWS credentials using the underlying provider. 33 | func (v *CredentialsProviderAdapter) GetIdentity(ctx context.Context, _ smithy.Properties) ( 34 | auth.Identity, error, 35 | ) { 36 | if v.Provider == nil { 37 | return &CredentialsAdapter{Credentials: aws.Credentials{}}, nil 38 | } 39 | 40 | creds, err := v.Provider.Retrieve(ctx) 41 | if err != nil { 42 | return nil, fmt.Errorf("get credentials: %w", err) 43 | } 44 | 45 | return &CredentialsAdapter{Credentials: creds}, nil 46 | } 47 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/auth/smithy/smithy.go: -------------------------------------------------------------------------------- 1 | // Package smithy adapts concrete AWS auth and signing types to the generic smithy versions. 2 | package smithy 3 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package configsources 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.3.34" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/awsrulesfn/doc.go: -------------------------------------------------------------------------------- 1 | // Package awsrulesfn provides AWS focused endpoint rule functions for 2 | // evaluating endpoint resolution rules. 3 | package awsrulesfn 4 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/awsrulesfn/generate.go: -------------------------------------------------------------------------------- 1 | //go:build codegen 2 | // +build codegen 3 | 4 | package awsrulesfn 5 | 6 | //go:generate go run -tags codegen ./internal/partition/codegen.go -model partitions.json -output partitions.go 7 | //go:generate gofmt -w -s . 8 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package endpoints 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "2.6.34" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/ini/errors.go: -------------------------------------------------------------------------------- 1 | package ini 2 | 3 | import "fmt" 4 | 5 | // UnableToReadFile is an error indicating that a ini file could not be read 6 | type UnableToReadFile struct { 7 | Err error 8 | } 9 | 10 | // Error returns an error message and the underlying error message if present 11 | func (e *UnableToReadFile) Error() string { 12 | base := "unable to read file" 13 | if e.Err == nil { 14 | return base 15 | } 16 | return fmt.Sprintf("%s: %v", base, e.Err) 17 | } 18 | 19 | // Unwrap returns the underlying error 20 | func (e *UnableToReadFile) Unwrap() error { 21 | return e.Err 22 | } 23 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/ini/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package ini 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.8.3" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/ini/ini.go: -------------------------------------------------------------------------------- 1 | // Package ini implements parsing of the AWS shared config file. 2 | // 3 | // Example: 4 | // sections, err := ini.OpenFile("/path/to/file") 5 | // if err != nil { 6 | // panic(err) 7 | // } 8 | // 9 | // profile := "foo" 10 | // section, ok := sections.GetSection(profile) 11 | // if !ok { 12 | // fmt.Printf("section %q could not be found", profile) 13 | // } 14 | package ini 15 | 16 | import ( 17 | "fmt" 18 | "io" 19 | "os" 20 | "strings" 21 | ) 22 | 23 | // OpenFile parses shared config from the given file path. 24 | func OpenFile(path string) (sections Sections, err error) { 25 | f, oerr := os.Open(path) 26 | if oerr != nil { 27 | return Sections{}, &UnableToReadFile{Err: oerr} 28 | } 29 | 30 | defer func() { 31 | closeErr := f.Close() 32 | if err == nil { 33 | err = closeErr 34 | } else if closeErr != nil { 35 | err = fmt.Errorf("close error: %v, original error: %w", closeErr, err) 36 | } 37 | }() 38 | 39 | return Parse(f, path) 40 | } 41 | 42 | // Parse parses shared config from the given reader. 43 | func Parse(r io.Reader, path string) (Sections, error) { 44 | contents, err := io.ReadAll(r) 45 | if err != nil { 46 | return Sections{}, fmt.Errorf("read all: %v", err) 47 | } 48 | 49 | lines := strings.Split(string(contents), "\n") 50 | tokens, err := tokenize(lines) 51 | if err != nil { 52 | return Sections{}, fmt.Errorf("tokenize: %v", err) 53 | } 54 | 55 | return parse(tokens, path), nil 56 | } 57 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/ini/token.go: -------------------------------------------------------------------------------- 1 | package ini 2 | 3 | type lineToken interface { 4 | isLineToken() 5 | } 6 | 7 | type lineTokenProfile struct { 8 | Type string 9 | Name string 10 | } 11 | 12 | func (*lineTokenProfile) isLineToken() {} 13 | 14 | type lineTokenProperty struct { 15 | Key string 16 | Value string 17 | } 18 | 19 | func (*lineTokenProperty) isLineToken() {} 20 | 21 | type lineTokenContinuation struct { 22 | Value string 23 | } 24 | 25 | func (*lineTokenContinuation) isLineToken() {} 26 | 27 | type lineTokenSubProperty struct { 28 | Key string 29 | Value string 30 | } 31 | 32 | func (*lineTokenSubProperty) isLineToken() {} 33 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/rand/rand.go: -------------------------------------------------------------------------------- 1 | package rand 2 | 3 | import ( 4 | "crypto/rand" 5 | "fmt" 6 | "io" 7 | "math/big" 8 | ) 9 | 10 | func init() { 11 | Reader = rand.Reader 12 | } 13 | 14 | // Reader provides a random reader that can reset during testing. 15 | var Reader io.Reader 16 | 17 | var floatMaxBigInt = big.NewInt(1 << 53) 18 | 19 | // Float64 returns a float64 read from an io.Reader source. The returned float will be between [0.0, 1.0). 20 | func Float64(reader io.Reader) (float64, error) { 21 | bi, err := rand.Int(reader, floatMaxBigInt) 22 | if err != nil { 23 | return 0, fmt.Errorf("failed to read random value, %v", err) 24 | } 25 | 26 | return float64(bi.Int64()) / (1 << 53), nil 27 | } 28 | 29 | // CryptoRandFloat64 returns a random float64 obtained from the crypto rand 30 | // source. 31 | func CryptoRandFloat64() (float64, error) { 32 | return Float64(Reader) 33 | } 34 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/sdk/interfaces.go: -------------------------------------------------------------------------------- 1 | package sdk 2 | 3 | // Invalidator provides access to a type's invalidate method to make it 4 | // invalidate it cache. 5 | // 6 | // e.g aws.SafeCredentialsProvider's Invalidate method. 7 | type Invalidator interface { 8 | Invalidate() 9 | } 10 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/sdkio/byte.go: -------------------------------------------------------------------------------- 1 | package sdkio 2 | 3 | const ( 4 | // Byte is 8 bits 5 | Byte int64 = 1 6 | // KibiByte (KiB) is 1024 Bytes 7 | KibiByte = Byte * 1024 8 | // MebiByte (MiB) is 1024 KiB 9 | MebiByte = KibiByte * 1024 10 | // GibiByte (GiB) is 1024 MiB 11 | GibiByte = MebiByte * 1024 12 | ) 13 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/shareddefaults/shared_config.go: -------------------------------------------------------------------------------- 1 | package shareddefaults 2 | 3 | import ( 4 | "os" 5 | "os/user" 6 | "path/filepath" 7 | ) 8 | 9 | // SharedCredentialsFilename returns the SDK's default file path 10 | // for the shared credentials file. 11 | // 12 | // Builds the shared config file path based on the OS's platform. 13 | // 14 | // - Linux/Unix: $HOME/.aws/credentials 15 | // - Windows: %USERPROFILE%\.aws\credentials 16 | func SharedCredentialsFilename() string { 17 | return filepath.Join(UserHomeDir(), ".aws", "credentials") 18 | } 19 | 20 | // SharedConfigFilename returns the SDK's default file path for 21 | // the shared config file. 22 | // 23 | // Builds the shared config file path based on the OS's platform. 24 | // 25 | // - Linux/Unix: $HOME/.aws/config 26 | // - Windows: %USERPROFILE%\.aws\config 27 | func SharedConfigFilename() string { 28 | return filepath.Join(UserHomeDir(), ".aws", "config") 29 | } 30 | 31 | // UserHomeDir returns the home directory for the user the process is 32 | // running under. 33 | func UserHomeDir() string { 34 | // Ignore errors since we only care about Windows and *nix. 35 | home, _ := os.UserHomeDir() 36 | 37 | if len(home) > 0 { 38 | return home 39 | } 40 | 41 | currUser, _ := user.Current() 42 | if currUser != nil { 43 | home = currUser.HomeDir 44 | } 45 | 46 | return home 47 | } 48 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/strings/strings.go: -------------------------------------------------------------------------------- 1 | package strings 2 | 3 | import ( 4 | "strings" 5 | ) 6 | 7 | // HasPrefixFold tests whether the string s begins with prefix, interpreted as UTF-8 strings, 8 | // under Unicode case-folding. 9 | func HasPrefixFold(s, prefix string) bool { 10 | return len(s) >= len(prefix) && strings.EqualFold(s[0:len(prefix)], prefix) 11 | } 12 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/sync/singleflight/docs.go: -------------------------------------------------------------------------------- 1 | // Package singleflight provides a duplicate function call suppression 2 | // mechanism. This package is a fork of the Go golang.org/x/sync/singleflight 3 | // package. The package is forked, because the package a part of the unstable 4 | // and unversioned golang.org/x/sync module. 5 | // 6 | // https://github.com/golang/sync/tree/67f06af15bc961c363a7260195bcd53487529a21/singleflight 7 | package singleflight 8 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/internal/timeconv/duration.go: -------------------------------------------------------------------------------- 1 | package timeconv 2 | 3 | import "time" 4 | 5 | // FloatSecondsDur converts a fractional seconds to duration. 6 | func FloatSecondsDur(v float64) time.Duration { 7 | return time.Duration(v * float64(time.Second)) 8 | } 9 | 10 | // DurSecondsFloat converts a duration into fractional seconds. 11 | func DurSecondsFloat(d time.Duration) float64 { 12 | return float64(d) / float64(time.Second) 13 | } 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/ecr/doc.go: -------------------------------------------------------------------------------- 1 | // Code generated by smithy-go-codegen DO NOT EDIT. 2 | 3 | // Package ecr provides the API client, operations, and parameter types for Amazon 4 | // Elastic Container Registry. 5 | // 6 | // # Amazon Elastic Container Registry 7 | // 8 | // Amazon Elastic Container Registry (Amazon ECR) is a managed container image 9 | // registry service. Customers can use the familiar Docker CLI, or their preferred 10 | // client, to push, pull, and manage images. Amazon ECR provides a secure, 11 | // scalable, and reliable registry for your Docker or Open Container Initiative 12 | // (OCI) images. Amazon ECR supports private repositories with resource-based 13 | // permissions using IAM so that specific users or Amazon EC2 instances can access 14 | // repositories and images. 15 | // 16 | // Amazon ECR has service endpoints in each supported Region. For more 17 | // information, see [Amazon ECR endpoints]in the Amazon Web Services General Reference. 18 | // 19 | // [Amazon ECR endpoints]: https://docs.aws.amazon.com/general/latest/gr/ecr.html 20 | package ecr 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/ecr/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package ecr 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.44.0" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/doc.go: -------------------------------------------------------------------------------- 1 | // Code generated by smithy-go-codegen DO NOT EDIT. 2 | 3 | // Package ecrpublic provides the API client, operations, and parameter types for 4 | // Amazon Elastic Container Registry Public. 5 | // 6 | // # Amazon Elastic Container Registry Public 7 | // 8 | // Amazon Elastic Container Registry Public (Amazon ECR Public) is a managed 9 | // container image registry service. Amazon ECR provides both public and private 10 | // registries to host your container images. You can use the Docker CLI or your 11 | // preferred client to push, pull, and manage images. Amazon ECR provides a secure, 12 | // scalable, and reliable registry for your Docker or Open Container Initiative 13 | // (OCI) images. Amazon ECR supports public repositories with this API. For 14 | // information about the Amazon ECR API for private repositories, see [Amazon Elastic Container Registry API Reference]. 15 | // 16 | // [Amazon Elastic Container Registry API Reference]: https://docs.aws.amazon.com/AmazonECR/latest/APIReference/Welcome.html 17 | package ecrpublic 18 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package ecrpublic 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.33.0" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package acceptencoding provides customizations associated with Accept Encoding Header. 3 | 4 | # Accept encoding gzip 5 | 6 | The Go HTTP client automatically supports accept-encoding and content-encoding 7 | gzip by default. This default behavior is not desired by the SDK, and prevents 8 | validating the response body's checksum. To prevent this the SDK must manually 9 | control usage of content-encoding gzip. 10 | 11 | To control content-encoding, the SDK must always set the `Accept-Encoding` 12 | header to a value. This prevents the HTTP client from using gzip automatically. 13 | When gzip is enabled on the API client, the SDK's customization will control 14 | decompressing the gzip data in order to not break the checksum validation. When 15 | gzip is disabled, the API client will disable gzip, preventing the HTTP 16 | client's default behavior. 17 | 18 | An `EnableAcceptEncodingGzip` option may or may not be present depending on the client using 19 | the below middleware. The option if present can be used to enable auto decompressing 20 | gzip by the SDK. 21 | */ 22 | package acceptencoding 23 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package acceptencoding 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.12.3" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/doc.go: -------------------------------------------------------------------------------- 1 | // Package presignedurl provides the customizations for API clients to fill in 2 | // presigned URLs into input parameters. 3 | package presignedurl 4 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package presignedurl 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.12.15" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/sso/generated.json: -------------------------------------------------------------------------------- 1 | { 2 | "dependencies": { 3 | "github.com/aws/aws-sdk-go-v2": "v1.4.0", 4 | "github.com/aws/aws-sdk-go-v2/internal/configsources": "v0.0.0-00010101000000-000000000000", 5 | "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2": "v2.0.0-00010101000000-000000000000", 6 | "github.com/aws/smithy-go": "v1.4.0" 7 | }, 8 | "files": [ 9 | "api_client.go", 10 | "api_client_test.go", 11 | "api_op_GetRoleCredentials.go", 12 | "api_op_ListAccountRoles.go", 13 | "api_op_ListAccounts.go", 14 | "api_op_Logout.go", 15 | "auth.go", 16 | "deserializers.go", 17 | "doc.go", 18 | "endpoints.go", 19 | "endpoints_config_test.go", 20 | "endpoints_test.go", 21 | "generated.json", 22 | "internal/endpoints/endpoints.go", 23 | "internal/endpoints/endpoints_test.go", 24 | "options.go", 25 | "protocol_test.go", 26 | "serializers.go", 27 | "snapshot_test.go", 28 | "sra_operation_order_test.go", 29 | "types/errors.go", 30 | "types/types.go", 31 | "validators.go" 32 | ], 33 | "go": "1.22", 34 | "module": "github.com/aws/aws-sdk-go-v2/service/sso", 35 | "unstable": false 36 | } 37 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/sso/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package sso 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.25.3" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/generated.json: -------------------------------------------------------------------------------- 1 | { 2 | "dependencies": { 3 | "github.com/aws/aws-sdk-go-v2": "v1.4.0", 4 | "github.com/aws/aws-sdk-go-v2/internal/configsources": "v0.0.0-00010101000000-000000000000", 5 | "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2": "v2.0.0-00010101000000-000000000000", 6 | "github.com/aws/smithy-go": "v1.4.0" 7 | }, 8 | "files": [ 9 | "api_client.go", 10 | "api_client_test.go", 11 | "api_op_CreateToken.go", 12 | "api_op_CreateTokenWithIAM.go", 13 | "api_op_RegisterClient.go", 14 | "api_op_StartDeviceAuthorization.go", 15 | "auth.go", 16 | "deserializers.go", 17 | "doc.go", 18 | "endpoints.go", 19 | "endpoints_config_test.go", 20 | "endpoints_test.go", 21 | "generated.json", 22 | "internal/endpoints/endpoints.go", 23 | "internal/endpoints/endpoints_test.go", 24 | "options.go", 25 | "protocol_test.go", 26 | "serializers.go", 27 | "snapshot_test.go", 28 | "sra_operation_order_test.go", 29 | "types/errors.go", 30 | "types/types.go", 31 | "validators.go" 32 | ], 33 | "go": "1.22", 34 | "module": "github.com/aws/aws-sdk-go-v2/service/ssooidc", 35 | "unstable": false 36 | } 37 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package ssooidc 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.30.1" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/ssooidc/types/types.go: -------------------------------------------------------------------------------- 1 | // Code generated by smithy-go-codegen DO NOT EDIT. 2 | 3 | package types 4 | 5 | import ( 6 | smithydocument "github.com/aws/smithy-go/document" 7 | ) 8 | 9 | // This structure contains Amazon Web Services-specific parameter extensions for 10 | // the token endpoint responses and includes the identity context. 11 | type AwsAdditionalDetails struct { 12 | 13 | // STS context assertion that carries a user identifier to the Amazon Web Services 14 | // service that it calls and can be used to obtain an identity-enhanced IAM role 15 | // session. This value corresponds to the sts:identity_context claim in the ID 16 | // token. 17 | IdentityContext *string 18 | 19 | noSmithyDocumentSerde 20 | } 21 | 22 | type noSmithyDocumentSerde = smithydocument.NoSerde 23 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/sts/doc.go: -------------------------------------------------------------------------------- 1 | // Code generated by smithy-go-codegen DO NOT EDIT. 2 | 3 | // Package sts provides the API client, operations, and parameter types for AWS 4 | // Security Token Service. 5 | // 6 | // # Security Token Service 7 | // 8 | // Security Token Service (STS) enables you to request temporary, 9 | // limited-privilege credentials for users. This guide provides descriptions of the 10 | // STS API. For more information about using this service, see [Temporary Security Credentials]. 11 | // 12 | // [Temporary Security Credentials]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html 13 | package sts 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/aws-sdk-go-v2/service/sts/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package sts 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.33.19" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/.gitignore: -------------------------------------------------------------------------------- 1 | # Eclipse 2 | .classpath 3 | .project 4 | .settings/ 5 | 6 | # Intellij 7 | .idea/ 8 | *.iml 9 | *.iws 10 | 11 | # Mac 12 | .DS_Store 13 | 14 | # Maven 15 | target/ 16 | **/dependency-reduced-pom.xml 17 | 18 | # Gradle 19 | /.gradle 20 | build/ 21 | */out/ 22 | */*/out/ 23 | 24 | # VS Code 25 | bin/ 26 | .vscode/ 27 | 28 | # make 29 | c.out 30 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | sudo: true 3 | dist: bionic 4 | 5 | branches: 6 | only: 7 | - main 8 | 9 | os: 10 | - linux 11 | - osx 12 | # Travis doesn't work with windows and Go tip 13 | #- windows 14 | 15 | go: 16 | - tip 17 | 18 | matrix: 19 | allow_failures: 20 | - go: tip 21 | 22 | before_install: 23 | - if [ "$TRAVIS_OS_NAME" = "windows" ]; then choco install make; fi 24 | - (cd /tmp/; go get golang.org/x/lint/golint) 25 | 26 | script: 27 | - make go test -v ./...; 28 | 29 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | ## Code of Conduct 2 | This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct). 3 | For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact 4 | opensource-codeofconduct@amazon.com with any additional questions or comments. 5 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/NOTICE: -------------------------------------------------------------------------------- 1 | Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 2 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/auth/auth.go: -------------------------------------------------------------------------------- 1 | // Package auth defines protocol-agnostic authentication types for smithy 2 | // clients. 3 | package auth 4 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/auth/bearer/docs.go: -------------------------------------------------------------------------------- 1 | // Package bearer provides middleware and utilities for authenticating API 2 | // operation calls with a Bearer Token. 3 | package bearer 4 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/auth/identity.go: -------------------------------------------------------------------------------- 1 | package auth 2 | 3 | import ( 4 | "context" 5 | "time" 6 | 7 | "github.com/aws/smithy-go" 8 | ) 9 | 10 | // Identity contains information that identifies who the user making the 11 | // request is. 12 | type Identity interface { 13 | Expiration() time.Time 14 | } 15 | 16 | // IdentityResolver defines the interface through which an Identity is 17 | // retrieved. 18 | type IdentityResolver interface { 19 | GetIdentity(context.Context, smithy.Properties) (Identity, error) 20 | } 21 | 22 | // IdentityResolverOptions defines the interface through which an entity can be 23 | // queried to retrieve an IdentityResolver for a given auth scheme. 24 | type IdentityResolverOptions interface { 25 | GetIdentityResolver(schemeID string) IdentityResolver 26 | } 27 | 28 | // AnonymousIdentity is a sentinel to indicate no identity. 29 | type AnonymousIdentity struct{} 30 | 31 | var _ Identity = (*AnonymousIdentity)(nil) 32 | 33 | // Expiration returns the zero value for time, as anonymous identity never 34 | // expires. 35 | func (*AnonymousIdentity) Expiration() time.Time { 36 | return time.Time{} 37 | } 38 | 39 | // AnonymousIdentityResolver returns AnonymousIdentity. 40 | type AnonymousIdentityResolver struct{} 41 | 42 | var _ IdentityResolver = (*AnonymousIdentityResolver)(nil) 43 | 44 | // GetIdentity returns AnonymousIdentity. 45 | func (*AnonymousIdentityResolver) GetIdentity(_ context.Context, _ smithy.Properties) (Identity, error) { 46 | return &AnonymousIdentity{}, nil 47 | } 48 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/auth/option.go: -------------------------------------------------------------------------------- 1 | package auth 2 | 3 | import "github.com/aws/smithy-go" 4 | 5 | type ( 6 | authOptionsKey struct{} 7 | ) 8 | 9 | // Option represents a possible authentication method for an operation. 10 | type Option struct { 11 | SchemeID string 12 | IdentityProperties smithy.Properties 13 | SignerProperties smithy.Properties 14 | } 15 | 16 | // GetAuthOptions gets auth Options from Properties. 17 | func GetAuthOptions(p *smithy.Properties) ([]*Option, bool) { 18 | v, ok := p.Get(authOptionsKey{}).([]*Option) 19 | return v, ok 20 | } 21 | 22 | // SetAuthOptions sets auth Options on Properties. 23 | func SetAuthOptions(p *smithy.Properties, options []*Option) { 24 | p.Set(authOptionsKey{}, options) 25 | } 26 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/auth/scheme_id.go: -------------------------------------------------------------------------------- 1 | package auth 2 | 3 | // Anonymous 4 | const ( 5 | SchemeIDAnonymous = "smithy.api#noAuth" 6 | ) 7 | 8 | // HTTP auth schemes 9 | const ( 10 | SchemeIDHTTPBasic = "smithy.api#httpBasicAuth" 11 | SchemeIDHTTPDigest = "smithy.api#httpDigestAuth" 12 | SchemeIDHTTPBearer = "smithy.api#httpBearerAuth" 13 | SchemeIDHTTPAPIKey = "smithy.api#httpApiKeyAuth" 14 | ) 15 | 16 | // AWS auth schemes 17 | const ( 18 | SchemeIDSigV4 = "aws.auth#sigv4" 19 | SchemeIDSigV4A = "aws.auth#sigv4a" 20 | ) 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/changelog-template.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "00000000-0000-0000-0000-000000000000", 3 | "type": "feature|bugfix|dependency", 4 | "description": "Description of your changes", 5 | "collapse": false, 6 | "modules": [ 7 | "." 8 | ] 9 | } 10 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/doc.go: -------------------------------------------------------------------------------- 1 | // Package smithy provides the core components for a Smithy SDK. 2 | package smithy 3 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/document.go: -------------------------------------------------------------------------------- 1 | package smithy 2 | 3 | // Document provides access to loosely structured data in a document-like 4 | // format. 5 | // 6 | // Deprecated: See the github.com/aws/smithy-go/document package. 7 | type Document interface { 8 | UnmarshalDocument(interface{}) error 9 | GetValue() (interface{}, error) 10 | } 11 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/document/doc.go: -------------------------------------------------------------------------------- 1 | // Package document provides interface definitions and error types for document types. 2 | // 3 | // A document is a protocol-agnostic type which supports a JSON-like data-model. You can use this type to send 4 | // UTF-8 strings, arbitrary precision numbers, booleans, nulls, a list of these values, and a map of UTF-8 5 | // strings to these values. 6 | // 7 | // API Clients expose document constructors in their respective client document packages which must be used to 8 | // Marshal and Unmarshal Go types to and from their respective protocol representations. 9 | // 10 | // See the Marshaler and Unmarshaler type documentation for more details on how to Go types can be converted to and from 11 | // document types. 12 | package document 13 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/encoding/doc.go: -------------------------------------------------------------------------------- 1 | // Package encoding provides utilities for encoding values for specific 2 | // document encodings. 3 | 4 | package encoding 5 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/encoding/encoding.go: -------------------------------------------------------------------------------- 1 | package encoding 2 | 3 | import ( 4 | "fmt" 5 | "math" 6 | "strconv" 7 | ) 8 | 9 | // EncodeFloat encodes a float value as per the stdlib encoder for json and xml protocol 10 | // This encodes a float value into dst while attempting to conform to ES6 ToString for Numbers 11 | // 12 | // Based on encoding/json floatEncoder from the Go Standard Library 13 | // https://golang.org/src/encoding/json/encode.go 14 | func EncodeFloat(dst []byte, v float64, bits int) []byte { 15 | if math.IsInf(v, 0) || math.IsNaN(v) { 16 | panic(fmt.Sprintf("invalid float value: %s", strconv.FormatFloat(v, 'g', -1, bits))) 17 | } 18 | 19 | abs := math.Abs(v) 20 | fmt := byte('f') 21 | 22 | if abs != 0 { 23 | if bits == 64 && (abs < 1e-6 || abs >= 1e21) || bits == 32 && (float32(abs) < 1e-6 || float32(abs) >= 1e21) { 24 | fmt = 'e' 25 | } 26 | } 27 | 28 | dst = strconv.AppendFloat(dst, v, fmt, -1, bits) 29 | 30 | if fmt == 'e' { 31 | // clean up e-09 to e-9 32 | n := len(dst) 33 | if n >= 4 && dst[n-4] == 'e' && dst[n-3] == '-' && dst[n-2] == '0' { 34 | dst[n-2] = dst[n-1] 35 | dst = dst[:n-1] 36 | } 37 | } 38 | 39 | return dst 40 | } 41 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/encoding/json/array.go: -------------------------------------------------------------------------------- 1 | package json 2 | 3 | import ( 4 | "bytes" 5 | ) 6 | 7 | // Array represents the encoding of a JSON Array 8 | type Array struct { 9 | w *bytes.Buffer 10 | writeComma bool 11 | scratch *[]byte 12 | } 13 | 14 | func newArray(w *bytes.Buffer, scratch *[]byte) *Array { 15 | w.WriteRune(leftBracket) 16 | return &Array{w: w, scratch: scratch} 17 | } 18 | 19 | // Value adds a new element to the JSON Array. 20 | // Returns a Value type that is used to encode 21 | // the array element. 22 | func (a *Array) Value() Value { 23 | if a.writeComma { 24 | a.w.WriteRune(comma) 25 | } else { 26 | a.writeComma = true 27 | } 28 | 29 | return newValue(a.w, a.scratch) 30 | } 31 | 32 | // Close encodes the end of the JSON Array 33 | func (a *Array) Close() { 34 | a.w.WriteRune(rightBracket) 35 | } 36 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/encoding/json/constants.go: -------------------------------------------------------------------------------- 1 | package json 2 | 3 | const ( 4 | leftBrace = '{' 5 | rightBrace = '}' 6 | 7 | leftBracket = '[' 8 | rightBracket = ']' 9 | 10 | comma = ',' 11 | quote = '"' 12 | colon = ':' 13 | 14 | null = "null" 15 | ) 16 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/encoding/json/encoder.go: -------------------------------------------------------------------------------- 1 | package json 2 | 3 | import ( 4 | "bytes" 5 | ) 6 | 7 | // Encoder is JSON encoder that supports construction of JSON values 8 | // using methods. 9 | type Encoder struct { 10 | w *bytes.Buffer 11 | Value 12 | } 13 | 14 | // NewEncoder returns a new JSON encoder 15 | func NewEncoder() *Encoder { 16 | writer := bytes.NewBuffer(nil) 17 | scratch := make([]byte, 64) 18 | 19 | return &Encoder{w: writer, Value: newValue(writer, &scratch)} 20 | } 21 | 22 | // String returns the String output of the JSON encoder 23 | func (e Encoder) String() string { 24 | return e.w.String() 25 | } 26 | 27 | // Bytes returns the []byte slice of the JSON encoder 28 | func (e Encoder) Bytes() []byte { 29 | return e.w.Bytes() 30 | } 31 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/encoding/json/object.go: -------------------------------------------------------------------------------- 1 | package json 2 | 3 | import ( 4 | "bytes" 5 | ) 6 | 7 | // Object represents the encoding of a JSON Object type 8 | type Object struct { 9 | w *bytes.Buffer 10 | writeComma bool 11 | scratch *[]byte 12 | } 13 | 14 | func newObject(w *bytes.Buffer, scratch *[]byte) *Object { 15 | w.WriteRune(leftBrace) 16 | return &Object{w: w, scratch: scratch} 17 | } 18 | 19 | func (o *Object) writeKey(key string) { 20 | escapeStringBytes(o.w, []byte(key)) 21 | o.w.WriteRune(colon) 22 | } 23 | 24 | // Key adds the given named key to the JSON object. 25 | // Returns a Value encoder that should be used to encode 26 | // a JSON value type. 27 | func (o *Object) Key(name string) Value { 28 | if o.writeComma { 29 | o.w.WriteRune(comma) 30 | } else { 31 | o.writeComma = true 32 | } 33 | o.writeKey(name) 34 | return newValue(o.w, o.scratch) 35 | } 36 | 37 | // Close encodes the end of the JSON Object 38 | func (o *Object) Close() { 39 | o.w.WriteRune(rightBrace) 40 | } 41 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/encoding/xml/constants.go: -------------------------------------------------------------------------------- 1 | package xml 2 | 3 | const ( 4 | leftAngleBracket = '<' 5 | rightAngleBracket = '>' 6 | forwardSlash = '/' 7 | colon = ':' 8 | equals = '=' 9 | quote = '"' 10 | ) 11 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/endpoints/endpoint.go: -------------------------------------------------------------------------------- 1 | package transport 2 | 3 | import ( 4 | "net/http" 5 | "net/url" 6 | 7 | "github.com/aws/smithy-go" 8 | ) 9 | 10 | // Endpoint is the endpoint object returned by Endpoint resolution V2 11 | type Endpoint struct { 12 | // The complete URL minimally specfiying the scheme and host. 13 | // May optionally specify the port and base path component. 14 | URI url.URL 15 | 16 | // An optional set of headers to be sent using transport layer headers. 17 | Headers http.Header 18 | 19 | // A grab-bag property map of endpoint attributes. The 20 | // values present here are subject to change, or being add/removed at any 21 | // time. 22 | Properties smithy.Properties 23 | } 24 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/go_module_metadata.go: -------------------------------------------------------------------------------- 1 | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. 2 | 3 | package smithy 4 | 5 | // goModuleVersion is the tagged release for this module 6 | const goModuleVersion = "1.22.3" 7 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/internal/sync/singleflight/docs.go: -------------------------------------------------------------------------------- 1 | // Package singleflight provides a duplicate function call suppression 2 | // mechanism. This package is a fork of the Go golang.org/x/sync/singleflight 3 | // package. The package is forked, because the package a part of the unstable 4 | // and unversioned golang.org/x/sync module. 5 | // 6 | // https://github.com/golang/sync/tree/67f06af15bc961c363a7260195bcd53487529a21/singleflight 7 | 8 | package singleflight 9 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/io/byte.go: -------------------------------------------------------------------------------- 1 | package io 2 | 3 | const ( 4 | // Byte is 8 bits 5 | Byte int64 = 1 6 | // KibiByte (KiB) is 1024 Bytes 7 | KibiByte = Byte * 1024 8 | // MebiByte (MiB) is 1024 KiB 9 | MebiByte = KibiByte * 1024 10 | // GibiByte (GiB) is 1024 MiB 11 | GibiByte = MebiByte * 1024 12 | ) 13 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/io/doc.go: -------------------------------------------------------------------------------- 1 | // Package io provides utilities for Smithy generated API clients. 2 | package io 3 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/io/reader.go: -------------------------------------------------------------------------------- 1 | package io 2 | 3 | import ( 4 | "io" 5 | ) 6 | 7 | // ReadSeekNopCloser wraps an io.ReadSeeker with an additional Close method 8 | // that does nothing. 9 | type ReadSeekNopCloser struct { 10 | io.ReadSeeker 11 | } 12 | 13 | // Close does nothing. 14 | func (ReadSeekNopCloser) Close() error { 15 | return nil 16 | } 17 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/local-mod-replace.sh: -------------------------------------------------------------------------------- 1 | #1/usr/bin/env bash 2 | 3 | PROJECT_DIR="" 4 | SMITHY_SOURCE_DIR=$(cd `dirname $0` && pwd) 5 | 6 | usage() { 7 | echo "Usage: $0 [-s SMITHY_SOURCE_DIR] [-d PROJECT_DIR]" 1>&2 8 | exit 1 9 | } 10 | 11 | while getopts "hs:d:" options; do 12 | case "${options}" in 13 | s) 14 | SMITHY_SOURCE_DIR=${OPTARG} 15 | if [ "$SMITHY_SOURCE_DIR" == "" ]; then 16 | echo "path to smithy-go source directory is required" || exit 17 | usage 18 | fi 19 | ;; 20 | d) 21 | PROJECT_DIR=${OPTARG} 22 | ;; 23 | h) 24 | usage 25 | ;; 26 | *) 27 | usage 28 | ;; 29 | esac 30 | done 31 | 32 | if [ "$PROJECT_DIR" != "" ]; then 33 | cd $PROJECT_DIR || exit 34 | fi 35 | 36 | go mod graph | awk '{print $1}' | cut -d '@' -f 1 | sort | uniq | grep "github.com/aws/smithy-go" | while read x; do 37 | repPath=${x/github.com\/aws\/smithy-go/${SMITHY_SOURCE_DIR}} 38 | echo -replace $x=$repPath 39 | done | xargs go mod edit 40 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/modman.toml: -------------------------------------------------------------------------------- 1 | [dependencies] 2 | "github.com/jmespath/go-jmespath" = "v0.4.0" 3 | 4 | [modules] 5 | 6 | [modules.codegen] 7 | no_tag = true 8 | 9 | [modules."codegen/smithy-go-codegen/build/test-generated/go/internal/testmodule"] 10 | no_tag = true 11 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/private/requestcompression/gzip.go: -------------------------------------------------------------------------------- 1 | package requestcompression 2 | 3 | import ( 4 | "bytes" 5 | "compress/gzip" 6 | "fmt" 7 | "io" 8 | ) 9 | 10 | func gzipCompress(input io.Reader) ([]byte, error) { 11 | var b bytes.Buffer 12 | w, err := gzip.NewWriterLevel(&b, gzip.DefaultCompression) 13 | if err != nil { 14 | return nil, fmt.Errorf("failed to create gzip writer, %v", err) 15 | } 16 | 17 | inBytes, err := io.ReadAll(input) 18 | if err != nil { 19 | return nil, fmt.Errorf("failed read payload to compress, %v", err) 20 | } 21 | 22 | if _, err = w.Write(inBytes); err != nil { 23 | return nil, fmt.Errorf("failed to write payload to be compressed, %v", err) 24 | } 25 | if err = w.Close(); err != nil { 26 | return nil, fmt.Errorf("failed to flush payload being compressed, %v", err) 27 | } 28 | 29 | return b.Bytes(), nil 30 | } 31 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/ptr/doc.go: -------------------------------------------------------------------------------- 1 | // Package ptr provides utilities for converting scalar literal type values to and from pointers inline. 2 | package ptr 3 | 4 | //go:generate go run -tags codegen generate.go 5 | //go:generate gofmt -w -s . 6 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/rand/doc.go: -------------------------------------------------------------------------------- 1 | // Package rand provides utilities for creating and working with random value 2 | // generators. 3 | package rand 4 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/rand/rand.go: -------------------------------------------------------------------------------- 1 | package rand 2 | 3 | import ( 4 | "crypto/rand" 5 | "fmt" 6 | "io" 7 | "math/big" 8 | ) 9 | 10 | func init() { 11 | Reader = rand.Reader 12 | } 13 | 14 | // Reader provides a random reader that can reset during testing. 15 | var Reader io.Reader 16 | 17 | // Int63n returns a int64 between zero and value of max, read from an io.Reader source. 18 | func Int63n(reader io.Reader, max int64) (int64, error) { 19 | bi, err := rand.Int(reader, big.NewInt(max)) 20 | if err != nil { 21 | return 0, fmt.Errorf("failed to read random value, %w", err) 22 | } 23 | 24 | return bi.Int64(), nil 25 | } 26 | 27 | // CryptoRandInt63n returns a random int64 between zero and value of max 28 | // obtained from the crypto rand source. 29 | func CryptoRandInt63n(max int64) (int64, error) { 30 | return Int63n(Reader, max) 31 | } 32 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/tracing/nop.go: -------------------------------------------------------------------------------- 1 | package tracing 2 | 3 | import "context" 4 | 5 | // NopTracerProvider is a no-op tracing implementation. 6 | type NopTracerProvider struct{} 7 | 8 | var _ TracerProvider = (*NopTracerProvider)(nil) 9 | 10 | // Tracer returns a tracer which creates no-op spans. 11 | func (NopTracerProvider) Tracer(string, ...TracerOption) Tracer { 12 | return nopTracer{} 13 | } 14 | 15 | type nopTracer struct{} 16 | 17 | var _ Tracer = (*nopTracer)(nil) 18 | 19 | func (nopTracer) StartSpan(ctx context.Context, name string, opts ...SpanOption) (context.Context, Span) { 20 | return ctx, nopSpan{} 21 | } 22 | 23 | type nopSpan struct{} 24 | 25 | var _ Span = (*nopSpan)(nil) 26 | 27 | func (nopSpan) Name() string { return "" } 28 | func (nopSpan) Context() SpanContext { return SpanContext{} } 29 | func (nopSpan) AddEvent(string, ...EventOption) {} 30 | func (nopSpan) SetProperty(any, any) {} 31 | func (nopSpan) SetStatus(SpanStatus) {} 32 | func (nopSpan) End() {} 33 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/transport/http/auth.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import ( 4 | "context" 5 | 6 | smithy "github.com/aws/smithy-go" 7 | "github.com/aws/smithy-go/auth" 8 | ) 9 | 10 | // AuthScheme defines an HTTP authentication scheme. 11 | type AuthScheme interface { 12 | SchemeID() string 13 | IdentityResolver(auth.IdentityResolverOptions) auth.IdentityResolver 14 | Signer() Signer 15 | } 16 | 17 | // Signer defines the interface through which HTTP requests are supplemented 18 | // with an Identity. 19 | type Signer interface { 20 | SignRequest(context.Context, *Request, auth.Identity, smithy.Properties) error 21 | } 22 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/transport/http/auth_schemes.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import ( 4 | "context" 5 | 6 | smithy "github.com/aws/smithy-go" 7 | "github.com/aws/smithy-go/auth" 8 | ) 9 | 10 | // NewAnonymousScheme returns the anonymous HTTP auth scheme. 11 | func NewAnonymousScheme() AuthScheme { 12 | return &authScheme{ 13 | schemeID: auth.SchemeIDAnonymous, 14 | signer: &nopSigner{}, 15 | } 16 | } 17 | 18 | // authScheme is parameterized to generically implement the exported AuthScheme 19 | // interface 20 | type authScheme struct { 21 | schemeID string 22 | signer Signer 23 | } 24 | 25 | var _ AuthScheme = (*authScheme)(nil) 26 | 27 | func (s *authScheme) SchemeID() string { 28 | return s.schemeID 29 | } 30 | 31 | func (s *authScheme) IdentityResolver(o auth.IdentityResolverOptions) auth.IdentityResolver { 32 | return o.GetIdentityResolver(s.schemeID) 33 | } 34 | 35 | func (s *authScheme) Signer() Signer { 36 | return s.signer 37 | } 38 | 39 | type nopSigner struct{} 40 | 41 | var _ Signer = (*nopSigner)(nil) 42 | 43 | func (*nopSigner) SignRequest(context.Context, *Request, auth.Identity, smithy.Properties) error { 44 | return nil 45 | } 46 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/transport/http/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package http provides the HTTP transport client and request/response types 3 | needed to round trip API operation calls with an service. 4 | */ 5 | package http 6 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/transport/http/md5_checksum.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import ( 4 | "crypto/md5" 5 | "encoding/base64" 6 | "fmt" 7 | "io" 8 | ) 9 | 10 | // computeMD5Checksum computes base64 md5 checksum of an io.Reader's contents. 11 | // Returns the byte slice of md5 checksum and an error. 12 | func computeMD5Checksum(r io.Reader) ([]byte, error) { 13 | h := md5.New() 14 | // copy errors may be assumed to be from the body. 15 | _, err := io.Copy(h, r) 16 | if err != nil { 17 | return nil, fmt.Errorf("failed to read body: %w", err) 18 | } 19 | 20 | // encode the md5 checksum in base64. 21 | sum := h.Sum(nil) 22 | sum64 := make([]byte, base64.StdEncoding.EncodedLen(len(sum))) 23 | base64.StdEncoding.Encode(sum64, sum) 24 | return sum64, nil 25 | } 26 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/transport/http/response.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import ( 4 | "fmt" 5 | "net/http" 6 | ) 7 | 8 | // Response provides the HTTP specific response structure for HTTP specific 9 | // middleware steps to use to deserialize the response from an operation call. 10 | type Response struct { 11 | *http.Response 12 | } 13 | 14 | // ResponseError provides the HTTP centric error type wrapping the underlying 15 | // error with the HTTP response value. 16 | type ResponseError struct { 17 | Response *Response 18 | Err error 19 | } 20 | 21 | // HTTPStatusCode returns the HTTP response status code received from the service. 22 | func (e *ResponseError) HTTPStatusCode() int { return e.Response.StatusCode } 23 | 24 | // HTTPResponse returns the HTTP response received from the service. 25 | func (e *ResponseError) HTTPResponse() *Response { return e.Response } 26 | 27 | // Unwrap returns the nested error if any, or nil. 28 | func (e *ResponseError) Unwrap() error { return e.Err } 29 | 30 | func (e *ResponseError) Error() string { 31 | return fmt.Sprintf( 32 | "http response error StatusCode: %d, %v", 33 | e.Response.StatusCode, e.Err) 34 | } 35 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/transport/http/time.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import ( 4 | "time" 5 | 6 | smithytime "github.com/aws/smithy-go/time" 7 | ) 8 | 9 | // ParseTime parses a time string like the HTTP Date header. This uses a more 10 | // relaxed rule set for date parsing compared to the standard library. 11 | func ParseTime(text string) (t time.Time, err error) { 12 | return smithytime.ParseHTTPDate(text) 13 | } 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/transport/http/url.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import "strings" 4 | 5 | // JoinPath returns an absolute URL path composed of the two paths provided. 6 | // Enforces that the returned path begins with '/'. If added path is empty the 7 | // returned path suffix will match the first parameter suffix. 8 | func JoinPath(a, b string) string { 9 | if len(a) == 0 { 10 | a = "/" 11 | } else if a[0] != '/' { 12 | a = "/" + a 13 | } 14 | 15 | if len(b) != 0 && b[0] == '/' { 16 | b = b[1:] 17 | } 18 | 19 | if len(b) != 0 && len(a) > 1 && a[len(a)-1] != '/' { 20 | a = a + "/" 21 | } 22 | 23 | return a + b 24 | } 25 | 26 | // JoinRawQuery returns an absolute raw query expression. Any duplicate '&' 27 | // will be collapsed to single separator between values. 28 | func JoinRawQuery(a, b string) string { 29 | a = strings.TrimFunc(a, isAmpersand) 30 | b = strings.TrimFunc(b, isAmpersand) 31 | 32 | if len(a) == 0 { 33 | return b 34 | } 35 | if len(b) == 0 { 36 | return a 37 | } 38 | 39 | return a + "&" + b 40 | } 41 | 42 | func isAmpersand(v rune) bool { 43 | return v == '&' 44 | } 45 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/transport/http/user_agent.go: -------------------------------------------------------------------------------- 1 | package http 2 | 3 | import ( 4 | "strings" 5 | ) 6 | 7 | // UserAgentBuilder is a builder for a HTTP User-Agent string. 8 | type UserAgentBuilder struct { 9 | sb strings.Builder 10 | } 11 | 12 | // NewUserAgentBuilder returns a new UserAgentBuilder. 13 | func NewUserAgentBuilder() *UserAgentBuilder { 14 | return &UserAgentBuilder{sb: strings.Builder{}} 15 | } 16 | 17 | // AddKey adds the named component/product to the agent string 18 | func (u *UserAgentBuilder) AddKey(key string) { 19 | u.appendTo(key) 20 | } 21 | 22 | // AddKeyValue adds the named key to the agent string with the given value. 23 | func (u *UserAgentBuilder) AddKeyValue(key, value string) { 24 | u.appendTo(key + "/" + value) 25 | } 26 | 27 | // Build returns the constructed User-Agent string. May be called multiple times. 28 | func (u *UserAgentBuilder) Build() string { 29 | return u.sb.String() 30 | } 31 | 32 | func (u *UserAgentBuilder) appendTo(value string) { 33 | if u.sb.Len() > 0 { 34 | u.sb.WriteRune(' ') 35 | } 36 | u.sb.WriteString(value) 37 | } 38 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/aws/smithy-go/waiter/logger.go: -------------------------------------------------------------------------------- 1 | package waiter 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | 7 | "github.com/aws/smithy-go/logging" 8 | "github.com/aws/smithy-go/middleware" 9 | ) 10 | 11 | // Logger is the Logger middleware used by the waiter to log an attempt 12 | type Logger struct { 13 | // Attempt is the current attempt to be logged 14 | Attempt int64 15 | } 16 | 17 | // ID representing the Logger middleware 18 | func (*Logger) ID() string { 19 | return "WaiterLogger" 20 | } 21 | 22 | // HandleInitialize performs handling of request in initialize stack step 23 | func (m *Logger) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 24 | out middleware.InitializeOutput, metadata middleware.Metadata, err error, 25 | ) { 26 | logger := middleware.GetLogger(ctx) 27 | 28 | logger.Logf(logging.Debug, fmt.Sprintf("attempting waiter request, attempt count: %d", m.Attempt)) 29 | 30 | return next.HandleInitialize(ctx, in) 31 | } 32 | 33 | // AddLogger is a helper util to add waiter logger after `SetLogger` middleware in 34 | func (m Logger) AddLogger(stack *middleware.Stack) error { 35 | return stack.Initialize.Insert(&m, "SetLogger", middleware.After) 36 | } 37 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/davecgh/go-spew/LICENSE: -------------------------------------------------------------------------------- 1 | ISC License 2 | 3 | Copyright (c) 2012-2016 Dave Collins 4 | 5 | Permission to use, copy, modify, and/or distribute this software for any 6 | purpose with or without fee is hereby granted, provided that the above 7 | copyright notice and this permission notice appear in all copies. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/docker/docker-credential-helpers/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2016 David Calavera 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be 12 | included in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 17 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 18 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 19 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 20 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/docker/docker-credential-helpers/credentials/helper.go: -------------------------------------------------------------------------------- 1 | package credentials 2 | 3 | // Helper is the interface a credentials store helper must implement. 4 | type Helper interface { 5 | // Add appends credentials to the store. 6 | Add(*Credentials) error 7 | // Delete removes credentials from the store. 8 | Delete(serverURL string) error 9 | // Get retrieves credentials from the store. 10 | // It returns username and secret as strings. 11 | Get(serverURL string) (string, string, error) 12 | // List returns the stored serverURLs and their associated usernames. 13 | List() (map[string]string, error) 14 | } 15 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/docker/docker-credential-helpers/credentials/version.go: -------------------------------------------------------------------------------- 1 | package credentials 2 | 3 | var ( 4 | // Name is filled at linking time 5 | Name = "" 6 | 7 | // Package is filled at linking time 8 | Package = "github.com/docker/docker-credential-helpers" 9 | 10 | // Version holds the complete version number. Filled in at linking time. 11 | Version = "v0.0.0+unknown" 12 | 13 | // Revision is filled with the VCS (e.g. git) revision being used to build 14 | // the program at linking time. 15 | Revision = "" 16 | ) 17 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/mitchellh/go-homedir/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2013 Mitchell Hashimoto 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/mitchellh/go-homedir/README.md: -------------------------------------------------------------------------------- 1 | # go-homedir 2 | 3 | This is a Go library for detecting the user's home directory without 4 | the use of cgo, so the library can be used in cross-compilation environments. 5 | 6 | Usage is incredibly simple, just call `homedir.Dir()` to get the home directory 7 | for a user, and `homedir.Expand()` to expand the `~` in a path to the home 8 | directory. 9 | 10 | **Why not just use `os/user`?** The built-in `os/user` package requires 11 | cgo on Darwin systems. This means that any Go code that uses that package 12 | cannot cross compile. But 99% of the time the use for `os/user` is just to 13 | retrieve the home directory, which we can do for the current user without 14 | cgo. This library does that, enabling cross-compilation. 15 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/.gitignore: -------------------------------------------------------------------------------- 1 | logrus 2 | vendor 3 | 4 | .idea/ 5 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/.golangci.yml: -------------------------------------------------------------------------------- 1 | run: 2 | # do not run on test files yet 3 | tests: false 4 | 5 | # all available settings of specific linters 6 | linters-settings: 7 | errcheck: 8 | # report about not checking of errors in type assetions: `a := b.(MyStruct)`; 9 | # default is false: such cases aren't reported by default. 10 | check-type-assertions: false 11 | 12 | # report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`; 13 | # default is false: such cases aren't reported by default. 14 | check-blank: false 15 | 16 | lll: 17 | line-length: 100 18 | tab-width: 4 19 | 20 | prealloc: 21 | simple: false 22 | range-loops: false 23 | for-loops: false 24 | 25 | whitespace: 26 | multi-if: false # Enforces newlines (or comments) after every multi-line if statement 27 | multi-func: false # Enforces newlines (or comments) after every multi-line function signature 28 | 29 | linters: 30 | enable: 31 | - megacheck 32 | - govet 33 | disable: 34 | - maligned 35 | - prealloc 36 | disable-all: false 37 | presets: 38 | - bugs 39 | - unused 40 | fast: false 41 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go_import_path: github.com/sirupsen/logrus 3 | git: 4 | depth: 1 5 | env: 6 | - GO111MODULE=on 7 | go: 1.15.x 8 | os: linux 9 | install: 10 | - ./travis/install.sh 11 | script: 12 | - cd ci 13 | - go run mage.go -v -w ../ crossBuild 14 | - go run mage.go -v -w ../ lint 15 | - go run mage.go -v -w ../ test 16 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014 Simon Eskildsen 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: "{build}" 2 | platform: x64 3 | clone_folder: c:\gopath\src\github.com\sirupsen\logrus 4 | environment: 5 | GOPATH: c:\gopath 6 | branches: 7 | only: 8 | - master 9 | install: 10 | - set PATH=%GOPATH%\bin;c:\go\bin;%PATH% 11 | - go version 12 | build_script: 13 | - go get -t 14 | - go test 15 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/buffer_pool.go: -------------------------------------------------------------------------------- 1 | package logrus 2 | 3 | import ( 4 | "bytes" 5 | "sync" 6 | ) 7 | 8 | var ( 9 | bufferPool BufferPool 10 | ) 11 | 12 | type BufferPool interface { 13 | Put(*bytes.Buffer) 14 | Get() *bytes.Buffer 15 | } 16 | 17 | type defaultPool struct { 18 | pool *sync.Pool 19 | } 20 | 21 | func (p *defaultPool) Put(buf *bytes.Buffer) { 22 | p.pool.Put(buf) 23 | } 24 | 25 | func (p *defaultPool) Get() *bytes.Buffer { 26 | return p.pool.Get().(*bytes.Buffer) 27 | } 28 | 29 | // SetBufferPool allows to replace the default logrus buffer pool 30 | // to better meets the specific needs of an application. 31 | func SetBufferPool(bp BufferPool) { 32 | bufferPool = bp 33 | } 34 | 35 | func init() { 36 | SetBufferPool(&defaultPool{ 37 | pool: &sync.Pool{ 38 | New: func() interface{} { 39 | return new(bytes.Buffer) 40 | }, 41 | }, 42 | }) 43 | } 44 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package logrus is a structured logger for Go, completely API compatible with the standard library logger. 3 | 4 | 5 | The simplest way to use Logrus is simply the package-level exported logger: 6 | 7 | package main 8 | 9 | import ( 10 | log "github.com/sirupsen/logrus" 11 | ) 12 | 13 | func main() { 14 | log.WithFields(log.Fields{ 15 | "animal": "walrus", 16 | "number": 1, 17 | "size": 10, 18 | }).Info("A walrus appears") 19 | } 20 | 21 | Output: 22 | time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10 23 | 24 | For a full guide visit https://github.com/sirupsen/logrus 25 | */ 26 | package logrus 27 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/hooks.go: -------------------------------------------------------------------------------- 1 | package logrus 2 | 3 | // A hook to be fired when logging on the logging levels returned from 4 | // `Levels()` on your implementation of the interface. Note that this is not 5 | // fired in a goroutine or a channel with workers, you should handle such 6 | // functionality yourself if your call is non-blocking and you don't wish for 7 | // the logging calls for levels returned from `Levels()` to block. 8 | type Hook interface { 9 | Levels() []Level 10 | Fire(*Entry) error 11 | } 12 | 13 | // Internal type for storing the hooks on a logger instance. 14 | type LevelHooks map[Level][]Hook 15 | 16 | // Add a hook to an instance of logger. This is called with 17 | // `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface. 18 | func (hooks LevelHooks) Add(hook Hook) { 19 | for _, level := range hook.Levels() { 20 | hooks[level] = append(hooks[level], hook) 21 | } 22 | } 23 | 24 | // Fire all the hooks for the passed level. Used by `entry.log` to fire 25 | // appropriate hooks for a log entry. 26 | func (hooks LevelHooks) Fire(level Level, entry *Entry) error { 27 | for _, hook := range hooks[level] { 28 | if err := hook.Fire(entry); err != nil { 29 | return err 30 | } 31 | } 32 | 33 | return nil 34 | } 35 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/terminal_check_appengine.go: -------------------------------------------------------------------------------- 1 | // +build appengine 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | ) 8 | 9 | func checkIfTerminal(w io.Writer) bool { 10 | return true 11 | } 12 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go: -------------------------------------------------------------------------------- 1 | // +build darwin dragonfly freebsd netbsd openbsd 2 | // +build !js 3 | 4 | package logrus 5 | 6 | import "golang.org/x/sys/unix" 7 | 8 | const ioctlReadTermios = unix.TIOCGETA 9 | 10 | func isTerminal(fd int) bool { 11 | _, err := unix.IoctlGetTermios(fd, ioctlReadTermios) 12 | return err == nil 13 | } 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/terminal_check_js.go: -------------------------------------------------------------------------------- 1 | // +build js 2 | 3 | package logrus 4 | 5 | func isTerminal(fd int) bool { 6 | return false 7 | } 8 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go: -------------------------------------------------------------------------------- 1 | // +build js nacl plan9 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | ) 8 | 9 | func checkIfTerminal(w io.Writer) bool { 10 | return false 11 | } 12 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go: -------------------------------------------------------------------------------- 1 | // +build !appengine,!js,!windows,!nacl,!plan9 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | "os" 8 | ) 9 | 10 | func checkIfTerminal(w io.Writer) bool { 11 | switch v := w.(type) { 12 | case *os.File: 13 | return isTerminal(int(v.Fd())) 14 | default: 15 | return false 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go: -------------------------------------------------------------------------------- 1 | package logrus 2 | 3 | import ( 4 | "golang.org/x/sys/unix" 5 | ) 6 | 7 | // IsTerminal returns true if the given file descriptor is a terminal. 8 | func isTerminal(fd int) bool { 9 | _, err := unix.IoctlGetTermio(fd, unix.TCGETA) 10 | return err == nil 11 | } 12 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/terminal_check_unix.go: -------------------------------------------------------------------------------- 1 | // +build linux aix zos 2 | // +build !js 3 | 4 | package logrus 5 | 6 | import "golang.org/x/sys/unix" 7 | 8 | const ioctlReadTermios = unix.TCGETS 9 | 10 | func isTerminal(fd int) bool { 11 | _, err := unix.IoctlGetTermios(fd, ioctlReadTermios) 12 | return err == nil 13 | } 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/sirupsen/logrus/terminal_check_windows.go: -------------------------------------------------------------------------------- 1 | // +build !appengine,!js,windows 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | "os" 8 | 9 | "golang.org/x/sys/windows" 10 | ) 11 | 12 | func checkIfTerminal(w io.Writer) bool { 13 | switch v := w.(type) { 14 | case *os.File: 15 | handle := windows.Handle(v.Fd()) 16 | var mode uint32 17 | if err := windows.GetConsoleMode(handle, &mode); err != nil { 18 | return false 19 | } 20 | mode |= windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING 21 | if err := windows.SetConsoleMode(handle, mode); err != nil { 22 | return false 23 | } 24 | return true 25 | } 26 | return false 27 | } 28 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/stretchr/testify/LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2012-2020 Mat Ryer, Tyler Bunnell and contributors. 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentFormat}} 2 | func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool { 3 | if h, ok := t.(tHelper); ok { h.Helper() } 4 | return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}}) 5 | } 6 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentWithoutT "a"}} 2 | func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool { 3 | if h, ok := a.t.(tHelper); ok { h.Helper() } 4 | return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) 5 | } 6 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/stretchr/testify/assert/errors.go: -------------------------------------------------------------------------------- 1 | package assert 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | // AnError is an error instance useful for testing. If the code does not care 8 | // about error specifics, and only needs to return the error for example, this 9 | // error should be used to make the test code more readable. 10 | var AnError = errors.New("assert.AnError general error for testing") 11 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/stretchr/testify/assert/forward_assertions.go: -------------------------------------------------------------------------------- 1 | package assert 2 | 3 | // Assertions provides assertion methods around the 4 | // TestingT interface. 5 | type Assertions struct { 6 | t TestingT 7 | } 8 | 9 | // New makes a new Assertions object for the specified TestingT. 10 | func New(t TestingT) *Assertions { 11 | return &Assertions{ 12 | t: t, 13 | } 14 | } 15 | 16 | //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs" 17 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/stretchr/testify/assert/yaml/yaml_custom.go: -------------------------------------------------------------------------------- 1 | //go:build testify_yaml_custom && !testify_yaml_fail && !testify_yaml_default 2 | // +build testify_yaml_custom,!testify_yaml_fail,!testify_yaml_default 3 | 4 | // Package yaml is an implementation of YAML functions that calls a pluggable implementation. 5 | // 6 | // This implementation is selected with the testify_yaml_custom build tag. 7 | // 8 | // go test -tags testify_yaml_custom 9 | // 10 | // This implementation can be used at build time to replace the default implementation 11 | // to avoid linking with [gopkg.in/yaml.v3]. 12 | // 13 | // In your test package: 14 | // 15 | // import assertYaml "github.com/stretchr/testify/assert/yaml" 16 | // 17 | // func init() { 18 | // assertYaml.Unmarshal = func (in []byte, out interface{}) error { 19 | // // ... 20 | // return nil 21 | // } 22 | // } 23 | package yaml 24 | 25 | var Unmarshal func(in []byte, out interface{}) error 26 | -------------------------------------------------------------------------------- /ecr-login/vendor/github.com/stretchr/testify/assert/yaml/yaml_fail.go: -------------------------------------------------------------------------------- 1 | //go:build testify_yaml_fail && !testify_yaml_custom && !testify_yaml_default 2 | // +build testify_yaml_fail,!testify_yaml_custom,!testify_yaml_default 3 | 4 | // Package yaml is an implementation of YAML functions that always fail. 5 | // 6 | // This implementation can be used at build time to replace the default implementation 7 | // to avoid linking with [gopkg.in/yaml.v3]: 8 | // 9 | // go test -tags testify_yaml_fail 10 | package yaml 11 | 12 | import "errors" 13 | 14 | var errNotImplemented = errors.New("YAML functions are not available (see https://pkg.go.dev/github.com/stretchr/testify/assert/yaml)") 15 | 16 | func Unmarshal([]byte, interface{}) error { 17 | return errNotImplemented 18 | } 19 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/PATENTS: -------------------------------------------------------------------------------- 1 | Additional IP Rights Grant (Patents) 2 | 3 | "This implementation" means the copyrightable works distributed by 4 | Google as part of the Go project. 5 | 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive, 7 | no-charge, royalty-free, irrevocable (except as stated in this section) 8 | patent license to make, have made, use, offer to sell, sell, import, 9 | transfer and otherwise run, modify and propagate the contents of this 10 | implementation of Go, where such license applies only to those patent 11 | claims, both currently owned or controlled by Google and acquired in 12 | the future, licensable by Google that are necessarily infringed by this 13 | implementation of Go. This grant does not include claims that would be 14 | infringed only as a consequence of further modification of this 15 | implementation. If you or your agent or exclusive licensee institute or 16 | order or agree to the institution of patent litigation against any 17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging 18 | that this implementation of Go or any code incorporated within this 19 | implementation of Go constitutes direct or contributory patent 20 | infringement, or inducement of patent infringement, then any patent 21 | rights granted to you under this License for this implementation of Go 22 | shall terminate as of the date such litigation is filed. 23 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/.gitignore: -------------------------------------------------------------------------------- 1 | _obj/ 2 | unix.test 3 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/aliases.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | type Signal = syscall.Signal 12 | type Errno = syscall.Errno 13 | type SysProcAttr = syscall.SysProcAttr 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_aix_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 11 | // 12 | 13 | TEXT ·syscall6(SB),NOSPLIT,$0-88 14 | JMP syscall·syscall6(SB) 15 | 16 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSyscall6(SB) 18 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_bsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for 386 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-28 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_bsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for AMD64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_bsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for ARM BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-28 15 | B syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 18 | B syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 21 | B syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 24 | B syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 27 | B syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_bsd_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for ARM64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_bsd_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ppc64, BSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_bsd_riscv64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for RISCV64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_linux_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for AMD64, Linux 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 23 | CALL runtime·entersyscall(SB) 24 | MOVQ a1+8(FP), DI 25 | MOVQ a2+16(FP), SI 26 | MOVQ a3+24(FP), DX 27 | MOVQ $0, R10 28 | MOVQ $0, R8 29 | MOVQ $0, R9 30 | MOVQ trap+0(FP), AX // syscall entry 31 | SYSCALL 32 | MOVQ AX, r1+32(FP) 33 | MOVQ DX, r2+40(FP) 34 | CALL runtime·exitsyscall(SB) 35 | RET 36 | 37 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 38 | JMP syscall·RawSyscall(SB) 39 | 40 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 41 | JMP syscall·RawSyscall6(SB) 42 | 43 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 44 | MOVQ a1+8(FP), DI 45 | MOVQ a2+16(FP), SI 46 | MOVQ a3+24(FP), DX 47 | MOVQ $0, R10 48 | MOVQ $0, R8 49 | MOVQ $0, R9 50 | MOVQ trap+0(FP), AX // syscall entry 51 | SYSCALL 52 | MOVQ AX, r1+32(FP) 53 | MOVQ DX, r2+40(FP) 54 | RET 55 | 56 | TEXT ·gettimeofday(SB),NOSPLIT,$0-16 57 | JMP syscall·gettimeofday(SB) 58 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_linux_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for arm, Linux 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-24 23 | BL runtime·entersyscall(SB) 24 | MOVW trap+0(FP), R7 25 | MOVW a1+4(FP), R0 26 | MOVW a2+8(FP), R1 27 | MOVW a3+12(FP), R2 28 | MOVW $0, R3 29 | MOVW $0, R4 30 | MOVW $0, R5 31 | SWI $0 32 | MOVW R0, r1+16(FP) 33 | MOVW $0, R0 34 | MOVW R0, r2+20(FP) 35 | BL runtime·exitsyscall(SB) 36 | RET 37 | 38 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 39 | B syscall·RawSyscall(SB) 40 | 41 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 42 | B syscall·RawSyscall6(SB) 43 | 44 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24 45 | MOVW trap+0(FP), R7 // syscall entry 46 | MOVW a1+4(FP), R0 47 | MOVW a2+8(FP), R1 48 | MOVW a3+12(FP), R2 49 | SWI $0 50 | MOVW R0, r1+16(FP) 51 | MOVW $0, R0 52 | MOVW R0, r2+20(FP) 53 | RET 54 | 55 | TEXT ·seek(SB),NOSPLIT,$0-28 56 | B syscall·seek(SB) 57 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_linux_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && arm64 && gc 6 | 7 | #include "textflag.h" 8 | 9 | // Just jump to package syscall's implementation for all these functions. 10 | // The runtime may know about them. 11 | 12 | TEXT ·Syscall(SB),NOSPLIT,$0-56 13 | B syscall·Syscall(SB) 14 | 15 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 16 | B syscall·Syscall6(SB) 17 | 18 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 19 | BL runtime·entersyscall(SB) 20 | MOVD a1+8(FP), R0 21 | MOVD a2+16(FP), R1 22 | MOVD a3+24(FP), R2 23 | MOVD $0, R3 24 | MOVD $0, R4 25 | MOVD $0, R5 26 | MOVD trap+0(FP), R8 // syscall entry 27 | SVC 28 | MOVD R0, r1+32(FP) // r1 29 | MOVD R1, r2+40(FP) // r2 30 | BL runtime·exitsyscall(SB) 31 | RET 32 | 33 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 34 | B syscall·RawSyscall(SB) 35 | 36 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 37 | B syscall·RawSyscall6(SB) 38 | 39 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 40 | MOVD a1+8(FP), R0 41 | MOVD a2+16(FP), R1 42 | MOVD a3+24(FP), R2 43 | MOVD $0, R3 44 | MOVD $0, R4 45 | MOVD $0, R5 46 | MOVD trap+0(FP), R8 // syscall entry 47 | SVC 48 | MOVD R0, r1+32(FP) 49 | MOVD R1, r2+40(FP) 50 | RET 51 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_linux_loong64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && loong64 && gc 6 | 7 | #include "textflag.h" 8 | 9 | 10 | // Just jump to package syscall's implementation for all these functions. 11 | // The runtime may know about them. 12 | 13 | TEXT ·Syscall(SB),NOSPLIT,$0-56 14 | JMP syscall·Syscall(SB) 15 | 16 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 17 | JMP syscall·Syscall6(SB) 18 | 19 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 20 | JAL runtime·entersyscall(SB) 21 | MOVV a1+8(FP), R4 22 | MOVV a2+16(FP), R5 23 | MOVV a3+24(FP), R6 24 | MOVV R0, R7 25 | MOVV R0, R8 26 | MOVV R0, R9 27 | MOVV trap+0(FP), R11 // syscall entry 28 | SYSCALL 29 | MOVV R4, r1+32(FP) 30 | MOVV R0, r2+40(FP) // r2 is not used. Always set to 0 31 | JAL runtime·exitsyscall(SB) 32 | RET 33 | 34 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 35 | JMP syscall·RawSyscall(SB) 36 | 37 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 38 | JMP syscall·RawSyscall6(SB) 39 | 40 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 41 | MOVV a1+8(FP), R4 42 | MOVV a2+16(FP), R5 43 | MOVV a3+24(FP), R6 44 | MOVV R0, R7 45 | MOVV R0, R8 46 | MOVV R0, R9 47 | MOVV trap+0(FP), R11 // syscall entry 48 | SYSCALL 49 | MOVV R4, r1+32(FP) 50 | MOVV R0, r2+40(FP) // r2 is not used. Always set to 0 51 | RET 52 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_linux_mips64x.s: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (mips64 || mips64le) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for mips64, Linux 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 23 | JAL runtime·entersyscall(SB) 24 | MOVV a1+8(FP), R4 25 | MOVV a2+16(FP), R5 26 | MOVV a3+24(FP), R6 27 | MOVV R0, R7 28 | MOVV R0, R8 29 | MOVV R0, R9 30 | MOVV trap+0(FP), R2 // syscall entry 31 | SYSCALL 32 | MOVV R2, r1+32(FP) 33 | MOVV R3, r2+40(FP) 34 | JAL runtime·exitsyscall(SB) 35 | RET 36 | 37 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 38 | JMP syscall·RawSyscall(SB) 39 | 40 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 41 | JMP syscall·RawSyscall6(SB) 42 | 43 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 44 | MOVV a1+8(FP), R4 45 | MOVV a2+16(FP), R5 46 | MOVV a3+24(FP), R6 47 | MOVV R0, R7 48 | MOVV R0, R8 49 | MOVV R0, R9 50 | MOVV trap+0(FP), R2 // syscall entry 51 | SYSCALL 52 | MOVV R2, r1+32(FP) 53 | MOVV R3, r2+40(FP) 54 | RET 55 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_linux_mipsx.s: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (mips || mipsle) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for mips, Linux 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-24 26 | JAL runtime·entersyscall(SB) 27 | MOVW a1+4(FP), R4 28 | MOVW a2+8(FP), R5 29 | MOVW a3+12(FP), R6 30 | MOVW R0, R7 31 | MOVW trap+0(FP), R2 // syscall entry 32 | SYSCALL 33 | MOVW R2, r1+16(FP) // r1 34 | MOVW R3, r2+20(FP) // r2 35 | JAL runtime·exitsyscall(SB) 36 | RET 37 | 38 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 39 | JMP syscall·RawSyscall(SB) 40 | 41 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 42 | JMP syscall·RawSyscall6(SB) 43 | 44 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24 45 | MOVW a1+4(FP), R4 46 | MOVW a2+8(FP), R5 47 | MOVW a3+12(FP), R6 48 | MOVW trap+0(FP), R2 // syscall entry 49 | SYSCALL 50 | MOVW R2, r1+16(FP) 51 | MOVW R3, r2+20(FP) 52 | RET 53 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (ppc64 || ppc64le) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for ppc64, Linux 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 17 | BL runtime·entersyscall(SB) 18 | MOVD a1+8(FP), R3 19 | MOVD a2+16(FP), R4 20 | MOVD a3+24(FP), R5 21 | MOVD R0, R6 22 | MOVD R0, R7 23 | MOVD R0, R8 24 | MOVD trap+0(FP), R9 // syscall entry 25 | SYSCALL R9 26 | MOVD R3, r1+32(FP) 27 | MOVD R4, r2+40(FP) 28 | BL runtime·exitsyscall(SB) 29 | RET 30 | 31 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 32 | MOVD a1+8(FP), R3 33 | MOVD a2+16(FP), R4 34 | MOVD a3+24(FP), R5 35 | MOVD R0, R6 36 | MOVD R0, R7 37 | MOVD R0, R8 38 | MOVD trap+0(FP), R9 // syscall entry 39 | SYSCALL R9 40 | MOVD R3, r1+32(FP) 41 | MOVD R4, r2+40(FP) 42 | RET 43 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_linux_riscv64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build riscv64 && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for linux/riscv64. 11 | // 12 | // Where available, just jump to package syscall's implementation of 13 | // these functions. 14 | 15 | TEXT ·Syscall(SB),NOSPLIT,$0-56 16 | JMP syscall·Syscall(SB) 17 | 18 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 19 | JMP syscall·Syscall6(SB) 20 | 21 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 22 | CALL runtime·entersyscall(SB) 23 | MOV a1+8(FP), A0 24 | MOV a2+16(FP), A1 25 | MOV a3+24(FP), A2 26 | MOV trap+0(FP), A7 // syscall entry 27 | ECALL 28 | MOV A0, r1+32(FP) // r1 29 | MOV A1, r2+40(FP) // r2 30 | CALL runtime·exitsyscall(SB) 31 | RET 32 | 33 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 34 | JMP syscall·RawSyscall(SB) 35 | 36 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 37 | JMP syscall·RawSyscall6(SB) 38 | 39 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 40 | MOV a1+8(FP), A0 41 | MOV a2+16(FP), A1 42 | MOV a3+24(FP), A2 43 | MOV trap+0(FP), A7 // syscall entry 44 | ECALL 45 | MOV A0, r1+32(FP) 46 | MOV A1, r2+40(FP) 47 | RET 48 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_linux_s390x.s: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && s390x && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for s390x, Linux 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | BR syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | BR syscall·Syscall6(SB) 21 | 22 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 23 | BL runtime·entersyscall(SB) 24 | MOVD a1+8(FP), R2 25 | MOVD a2+16(FP), R3 26 | MOVD a3+24(FP), R4 27 | MOVD $0, R5 28 | MOVD $0, R6 29 | MOVD $0, R7 30 | MOVD trap+0(FP), R1 // syscall entry 31 | SYSCALL 32 | MOVD R2, r1+32(FP) 33 | MOVD R3, r2+40(FP) 34 | BL runtime·exitsyscall(SB) 35 | RET 36 | 37 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 38 | BR syscall·RawSyscall(SB) 39 | 40 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 41 | BR syscall·RawSyscall6(SB) 42 | 43 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48 44 | MOVD a1+8(FP), R2 45 | MOVD a2+16(FP), R3 46 | MOVD a3+24(FP), R4 47 | MOVD $0, R5 48 | MOVD $0, R6 49 | MOVD $0, R7 50 | MOVD trap+0(FP), R1 // syscall entry 51 | SYSCALL 52 | MOVD R2, r1+32(FP) 53 | MOVD R3, r2+40(FP) 54 | RET 55 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for mips64, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/asm_solaris_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go 11 | // 12 | 13 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88 14 | JMP syscall·sysvicall6(SB) 15 | 16 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSysvicall6(SB) 18 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/bluetooth_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Bluetooth sockets and messages 6 | 7 | package unix 8 | 9 | // Bluetooth Protocols 10 | const ( 11 | BTPROTO_L2CAP = 0 12 | BTPROTO_HCI = 1 13 | BTPROTO_SCO = 2 14 | BTPROTO_RFCOMM = 3 15 | BTPROTO_BNEP = 4 16 | BTPROTO_CMTP = 5 17 | BTPROTO_HIDP = 6 18 | BTPROTO_AVDTP = 7 19 | ) 20 | 21 | const ( 22 | HCI_CHANNEL_RAW = 0 23 | HCI_CHANNEL_USER = 1 24 | HCI_CHANNEL_MONITOR = 2 25 | HCI_CHANNEL_CONTROL = 3 26 | HCI_CHANNEL_LOGGING = 4 27 | ) 28 | 29 | // Socketoption Level 30 | const ( 31 | SOL_BLUETOOTH = 0x112 32 | SOL_HCI = 0x0 33 | SOL_L2CAP = 0x6 34 | SOL_RFCOMM = 0x12 35 | SOL_SCO = 0x11 36 | ) 37 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/constants.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | const ( 10 | R_OK = 0x4 11 | W_OK = 0x2 12 | X_OK = 0x1 13 | ) 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/dev_aix_ppc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix && ppc 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used by AIX. 9 | 10 | package unix 11 | 12 | // Major returns the major component of a Linux device number. 13 | func Major(dev uint64) uint32 { 14 | return uint32((dev >> 16) & 0xffff) 15 | } 16 | 17 | // Minor returns the minor component of a Linux device number. 18 | func Minor(dev uint64) uint32 { 19 | return uint32(dev & 0xffff) 20 | } 21 | 22 | // Mkdev returns a Linux device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | return uint64(((major) << 16) | (minor)) 26 | } 27 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/dev_aix_ppc64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix && ppc64 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used AIX. 9 | 10 | package unix 11 | 12 | // Major returns the major component of a Linux device number. 13 | func Major(dev uint64) uint32 { 14 | return uint32((dev & 0x3fffffff00000000) >> 32) 15 | } 16 | 17 | // Minor returns the minor component of a Linux device number. 18 | func Minor(dev uint64) uint32 { 19 | return uint32((dev & 0x00000000ffffffff) >> 0) 20 | } 21 | 22 | // Mkdev returns a Linux device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | var DEVNO64 uint64 26 | DEVNO64 = 0x8000000000000000 27 | return ((uint64(major) << 32) | (uint64(minor) & 0x00000000FFFFFFFF) | DEVNO64) 28 | } 29 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/dev_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in Darwin's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of a Darwin device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev >> 24) & 0xff) 13 | } 14 | 15 | // Minor returns the minor component of a Darwin device number. 16 | func Minor(dev uint64) uint32 { 17 | return uint32(dev & 0xffffff) 18 | } 19 | 20 | // Mkdev returns a Darwin device number generated from the given major and minor 21 | // components. 22 | func Mkdev(major, minor uint32) uint64 { 23 | return (uint64(major) << 24) | uint64(minor) 24 | } 25 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/dev_dragonfly.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in Dragonfly's sys/types.h header. 7 | // 8 | // The information below is extracted and adapted from sys/types.h: 9 | // 10 | // Minor gives a cookie instead of an index since in order to avoid changing the 11 | // meanings of bits 0-15 or wasting time and space shifting bits 16-31 for 12 | // devices that don't use them. 13 | 14 | package unix 15 | 16 | // Major returns the major component of a DragonFlyBSD device number. 17 | func Major(dev uint64) uint32 { 18 | return uint32((dev >> 8) & 0xff) 19 | } 20 | 21 | // Minor returns the minor component of a DragonFlyBSD device number. 22 | func Minor(dev uint64) uint32 { 23 | return uint32(dev & 0xffff00ff) 24 | } 25 | 26 | // Mkdev returns a DragonFlyBSD device number generated from the given major and 27 | // minor components. 28 | func Mkdev(major, minor uint32) uint64 { 29 | return (uint64(major) << 8) | uint64(minor) 30 | } 31 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/dev_freebsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in FreeBSD's sys/types.h header. 7 | // 8 | // The information below is extracted and adapted from sys/types.h: 9 | // 10 | // Minor gives a cookie instead of an index since in order to avoid changing the 11 | // meanings of bits 0-15 or wasting time and space shifting bits 16-31 for 12 | // devices that don't use them. 13 | 14 | package unix 15 | 16 | // Major returns the major component of a FreeBSD device number. 17 | func Major(dev uint64) uint32 { 18 | return uint32((dev >> 8) & 0xff) 19 | } 20 | 21 | // Minor returns the minor component of a FreeBSD device number. 22 | func Minor(dev uint64) uint32 { 23 | return uint32(dev & 0xffff00ff) 24 | } 25 | 26 | // Mkdev returns a FreeBSD device number generated from the given major and 27 | // minor components. 28 | func Mkdev(major, minor uint32) uint64 { 29 | return (uint64(major) << 8) | uint64(minor) 30 | } 31 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/dev_netbsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in NetBSD's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of a NetBSD device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev & 0x000fff00) >> 8) 13 | } 14 | 15 | // Minor returns the minor component of a NetBSD device number. 16 | func Minor(dev uint64) uint32 { 17 | minor := uint32((dev & 0x000000ff) >> 0) 18 | minor |= uint32((dev & 0xfff00000) >> 12) 19 | return minor 20 | } 21 | 22 | // Mkdev returns a NetBSD device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | dev := (uint64(major) << 8) & 0x000fff00 26 | dev |= (uint64(minor) << 12) & 0xfff00000 27 | dev |= (uint64(minor) << 0) & 0x000000ff 28 | return dev 29 | } 30 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/dev_openbsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in OpenBSD's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of an OpenBSD device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev & 0x0000ff00) >> 8) 13 | } 14 | 15 | // Minor returns the minor component of an OpenBSD device number. 16 | func Minor(dev uint64) uint32 { 17 | minor := uint32((dev & 0x000000ff) >> 0) 18 | minor |= uint32((dev & 0xffff0000) >> 8) 19 | return minor 20 | } 21 | 22 | // Mkdev returns an OpenBSD device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | dev := (uint64(major) << 8) & 0x0000ff00 26 | dev |= (uint64(minor) << 8) & 0xffff0000 27 | dev |= (uint64(minor) << 0) & 0x000000ff 28 | return dev 29 | } 30 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/dev_zos.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build zos && s390x 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used by z/OS. 9 | // 10 | // The information below is extracted and adapted from macros. 11 | 12 | package unix 13 | 14 | // Major returns the major component of a z/OS device number. 15 | func Major(dev uint64) uint32 { 16 | return uint32((dev >> 16) & 0x0000FFFF) 17 | } 18 | 19 | // Minor returns the minor component of a z/OS device number. 20 | func Minor(dev uint64) uint32 { 21 | return uint32(dev & 0x0000FFFF) 22 | } 23 | 24 | // Mkdev returns a z/OS device number generated from the given major and minor 25 | // components. 26 | func Mkdev(major, minor uint32) uint64 { 27 | return (uint64(major) << 16) | uint64(minor) 28 | } 29 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/endian_big.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | //go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64 6 | 7 | package unix 8 | 9 | const isBigEndian = true 10 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/endian_little.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | //go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh 6 | 7 | package unix 8 | 9 | const isBigEndian = false 10 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/env_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2010 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | // Unix environment variables. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getenv(key string) (value string, found bool) { 14 | return syscall.Getenv(key) 15 | } 16 | 17 | func Setenv(key, value string) error { 18 | return syscall.Setenv(key, value) 19 | } 20 | 21 | func Clearenv() { 22 | syscall.Clearenv() 23 | } 24 | 25 | func Environ() []string { 26 | return syscall.Environ() 27 | } 28 | 29 | func Unsetenv(key string) error { 30 | return syscall.Unsetenv(key) 31 | } 32 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/fcntl.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build dragonfly || freebsd || linux || netbsd 6 | 7 | package unix 8 | 9 | import "unsafe" 10 | 11 | // fcntl64Syscall is usually SYS_FCNTL, but is overridden on 32-bit Linux 12 | // systems by fcntl_linux_32bit.go to be SYS_FCNTL64. 13 | var fcntl64Syscall uintptr = SYS_FCNTL 14 | 15 | func fcntl(fd int, cmd, arg int) (int, error) { 16 | valptr, _, errno := Syscall(fcntl64Syscall, uintptr(fd), uintptr(cmd), uintptr(arg)) 17 | var err error 18 | if errno != 0 { 19 | err = errno 20 | } 21 | return int(valptr), err 22 | } 23 | 24 | // FcntlInt performs a fcntl syscall on fd with the provided command and argument. 25 | func FcntlInt(fd uintptr, cmd, arg int) (int, error) { 26 | return fcntl(int(fd), cmd, arg) 27 | } 28 | 29 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. 30 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { 31 | _, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk))) 32 | if errno == 0 { 33 | return nil 34 | } 35 | return errno 36 | } 37 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/fcntl_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | import "unsafe" 8 | 9 | // FcntlInt performs a fcntl syscall on fd with the provided command and argument. 10 | func FcntlInt(fd uintptr, cmd, arg int) (int, error) { 11 | return fcntl(int(fd), cmd, arg) 12 | } 13 | 14 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. 15 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { 16 | _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk)))) 17 | return err 18 | } 19 | 20 | // FcntlFstore performs a fcntl syscall for the F_PREALLOCATE command. 21 | func FcntlFstore(fd uintptr, cmd int, fstore *Fstore_t) error { 22 | _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(fstore)))) 23 | return err 24 | } 25 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle) || (linux && ppc) 6 | 7 | package unix 8 | 9 | func init() { 10 | // On 32-bit Linux systems, the fcntl syscall that matches Go's 11 | // Flock_t type is SYS_FCNTL64, not SYS_FCNTL. 12 | fcntl64Syscall = SYS_FCNTL64 13 | } 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/fdset.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | // Set adds fd to the set fds. 10 | func (fds *FdSet) Set(fd int) { 11 | fds.Bits[fd/NFDBITS] |= (1 << (uintptr(fd) % NFDBITS)) 12 | } 13 | 14 | // Clear removes fd from the set fds. 15 | func (fds *FdSet) Clear(fd int) { 16 | fds.Bits[fd/NFDBITS] &^= (1 << (uintptr(fd) % NFDBITS)) 17 | } 18 | 19 | // IsSet returns whether fd is in the set fds. 20 | func (fds *FdSet) IsSet(fd int) bool { 21 | return fds.Bits[fd/NFDBITS]&(1<<(uintptr(fd)%NFDBITS)) != 0 22 | } 23 | 24 | // Zero clears the set fds. 25 | func (fds *FdSet) Zero() { 26 | for i := range fds.Bits { 27 | fds.Bits[i] = 0 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gccgo && linux && amd64 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //extern gettimeofday 12 | func realGettimeofday(*Timeval, *byte) int32 13 | 14 | func gettimeofday(tv *Timeval) (err syscall.Errno) { 15 | r := realGettimeofday(tv, nil) 16 | if r < 0 { 17 | return syscall.GetErrno() 18 | } 19 | return 0 20 | } 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/mmap_nomremap.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | var mapper = &mmapper{ 10 | active: make(map[*byte][]byte), 11 | mmap: mmap, 12 | munmap: munmap, 13 | } 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/pagesize_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | // For Unix, get the pagesize from the runtime. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getpagesize() int { 14 | return syscall.Getpagesize() 15 | } 16 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/ptrace_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin && !ios 6 | 7 | package unix 8 | 9 | func ptrace(request int, pid int, addr uintptr, data uintptr) error { 10 | return ptrace1(request, pid, addr, data) 11 | } 12 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/ptrace_ios.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build ios 6 | 7 | package unix 8 | 9 | func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) { 10 | return ENOTSUP 11 | } 12 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin && race) || (linux && race) || (freebsd && race) 6 | 7 | package unix 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || (darwin && !race) || (linux && !race) || (freebsd && !race) || netbsd || openbsd || solaris || dragonfly || zos 6 | 7 | package unix 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/readdirent_getdents.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || dragonfly || freebsd || linux || netbsd || openbsd 6 | 7 | package unix 8 | 9 | // ReadDirent reads directory entries from fd and writes them into buf. 10 | func ReadDirent(fd int, buf []byte) (n int, err error) { 11 | return Getdents(fd, buf) 12 | } 13 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin || zos 6 | 7 | package unix 8 | 9 | import "unsafe" 10 | 11 | // ReadDirent reads directory entries from fd and writes them into buf. 12 | func ReadDirent(fd int, buf []byte) (n int, err error) { 13 | // Final argument is (basep *uintptr) and the syscall doesn't take nil. 14 | // 64 bits should be enough. (32 bits isn't even on 386). Since the 15 | // actual system call is getdirentries64, 64 is a good guess. 16 | // TODO(rsc): Can we use a single global basep for all calls? 17 | var base = (*uintptr)(unsafe.Pointer(new(uint64))) 18 | return Getdirentries(fd, buf, base) 19 | } 20 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/sockcmsg_dragonfly.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | // Round the length of a raw sockaddr up to align it properly. 8 | func cmsgAlignOf(salen int) int { 9 | salign := SizeofPtr 10 | if SizeofPtr == 8 && !supportsABI(_dragonflyABIChangeVersion) { 11 | // 64-bit Dragonfly before the September 2019 ABI changes still requires 12 | // 32-bit aligned access to network subsystem. 13 | salign = 4 14 | } 15 | return (salen + salign - 1) & ^(salign - 1) 16 | } 17 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/sockcmsg_unix_other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix || darwin || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | import ( 10 | "runtime" 11 | ) 12 | 13 | // Round the length of a raw sockaddr up to align it properly. 14 | func cmsgAlignOf(salen int) int { 15 | salign := SizeofPtr 16 | 17 | // dragonfly needs to check ABI version at runtime, see cmsgAlignOf in 18 | // sockcmsg_dragonfly.go 19 | switch runtime.GOOS { 20 | case "aix": 21 | // There is no alignment on AIX. 22 | salign = 1 23 | case "darwin", "ios", "illumos", "solaris": 24 | // NOTE: It seems like 64-bit Darwin, Illumos and Solaris 25 | // kernels still require 32-bit aligned access to network 26 | // subsystem. 27 | if SizeofPtr == 8 { 28 | salign = 4 29 | } 30 | case "netbsd", "openbsd": 31 | // NetBSD and OpenBSD armv7 require 64-bit alignment. 32 | if runtime.GOARCH == "arm" { 33 | salign = 8 34 | } 35 | // NetBSD aarch64 requires 128-bit alignment. 36 | if runtime.GOOS == "netbsd" && runtime.GOARCH == "arm64" { 37 | salign = 16 38 | } 39 | case "zos": 40 | // z/OS socket macros use [32-bit] sizeof(int) alignment, 41 | // not pointer width. 42 | salign = SizeofInt 43 | } 44 | 45 | return (salen + salign - 1) & ^(salign - 1) 46 | } 47 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin 6 | 7 | package unix 8 | 9 | import _ "unsafe" 10 | 11 | // Implemented in the runtime package (runtime/sys_darwin.go) 12 | func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) 13 | func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 14 | func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 15 | func syscall_syscall9(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) // 32-bit only 16 | func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) 17 | func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 18 | func syscall_syscallPtr(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) 19 | 20 | //go:linkname syscall_syscall syscall.syscall 21 | //go:linkname syscall_syscall6 syscall.syscall6 22 | //go:linkname syscall_syscall6X syscall.syscall6X 23 | //go:linkname syscall_syscall9 syscall.syscall9 24 | //go:linkname syscall_rawSyscall syscall.rawSyscall 25 | //go:linkname syscall_rawSyscall6 syscall.rawSyscall6 26 | //go:linkname syscall_syscallPtr syscall.syscallPtr 27 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_hurd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build hurd 6 | 7 | package unix 8 | 9 | /* 10 | #include 11 | int ioctl(int, unsigned long int, uintptr_t); 12 | */ 13 | import "C" 14 | 15 | func ioctl(fd int, req uint, arg uintptr) (err error) { 16 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) 17 | if r0 == -1 && er != nil { 18 | err = er 19 | } 20 | return 21 | } 22 | 23 | func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) { 24 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(uintptr(arg))) 25 | if r0 == -1 && er != nil { 26 | err = er 27 | } 28 | return 29 | } 30 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_hurd_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build 386 && hurd 6 | 7 | package unix 8 | 9 | const ( 10 | TIOCGETA = 0x62251713 11 | ) 12 | 13 | type Winsize struct { 14 | Row uint16 15 | Col uint16 16 | Xpixel uint16 17 | Ypixel uint16 18 | } 19 | 20 | type Termios struct { 21 | Iflag uint32 22 | Oflag uint32 23 | Cflag uint32 24 | Lflag uint32 25 | Cc [20]uint8 26 | Ispeed int32 27 | Ospeed int32 28 | } 29 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_linux_alarm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (386 || amd64 || mips || mipsle || mips64 || mipsle || ppc64 || ppc64le || ppc || s390x || sparc64) 6 | 7 | package unix 8 | 9 | // SYS_ALARM is not defined on arm or riscv, but is available for other GOARCH 10 | // values. 11 | 12 | //sys Alarm(seconds uint) (remaining uint, err error) 13 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && linux && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //go:noescape 12 | func gettimeofday(tv *Timeval) (err syscall.Errno) 13 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_linux_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gc 6 | 7 | package unix 8 | 9 | // SyscallNoError may be used instead of Syscall for syscalls that don't fail. 10 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 11 | 12 | // RawSyscallNoError may be used instead of RawSyscall for syscalls that don't 13 | // fail. 14 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 15 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gc && 386 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // Underlying system call writes to newoffset via pointer. 12 | // Implemented in assembly to avoid allocation. 13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 14 | 15 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 16 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 17 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_linux_gc_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm && gc && linux 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // Underlying system call writes to newoffset via pointer. 12 | // Implemented in assembly to avoid allocation. 13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gccgo && 386 6 | 7 | package unix 8 | 9 | import ( 10 | "syscall" 11 | "unsafe" 12 | ) 13 | 14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 15 | var newoffset int64 16 | offsetLow := uint32(offset & 0xffffffff) 17 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 18 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 19 | return newoffset, err 20 | } 21 | 22 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) { 23 | fd, _, err := Syscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0) 24 | return int(fd), err 25 | } 26 | 27 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) { 28 | fd, _, err := RawSyscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0) 29 | return int(fd), err 30 | } 31 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && gccgo && arm 6 | 7 | package unix 8 | 9 | import ( 10 | "syscall" 11 | "unsafe" 12 | ) 13 | 14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 15 | var newoffset int64 16 | offsetLow := uint32(offset & 0xffffffff) 17 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 18 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 19 | return newoffset, err 20 | } 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_netbsd_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build 386 && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: int32(nsec)} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint32(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint32(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint64(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint64(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: int32(nsec)} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint32(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint32(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_netbsd_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm64 && netbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint64(fd) 19 | k.Filter = uint32(mode) 20 | k.Flags = uint32(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint64(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = int32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_openbsd_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build 386 && openbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: int32(nsec)} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint32(fd) 19 | k.Filter = int16(mode) 20 | k.Flags = uint16(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint32(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = uint32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | 39 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 40 | // of openbsd/386 the syscall is called sysctl instead of __sysctl. 41 | const SYS___SYSCTL = SYS_SYSCTL 42 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_openbsd_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && openbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: usec} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint64(fd) 19 | k.Filter = int16(mode) 20 | k.Flags = uint16(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint64(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = uint32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | 39 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 40 | // of openbsd/amd64 the syscall is called sysctl instead of __sysctl. 41 | const SYS___SYSCTL = SYS_SYSCTL 42 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_openbsd_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm && openbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: int32(nsec)} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: int32(usec)} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint32(fd) 19 | k.Filter = int16(mode) 20 | k.Flags = uint16(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint32(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = uint32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | 39 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 40 | // of openbsd/arm the syscall is called sysctl instead of __sysctl. 41 | const SYS___SYSCTL = SYS_SYSCTL 42 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_openbsd_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm64 && openbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: usec} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint64(fd) 19 | k.Filter = int16(mode) 20 | k.Flags = uint16(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint64(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = uint32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | 39 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 40 | // of openbsd/amd64 the syscall is called sysctl instead of __sysctl. 41 | const SYS___SYSCTL = SYS_SYSCTL 42 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_openbsd_libc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build openbsd 6 | 7 | package unix 8 | 9 | import _ "unsafe" 10 | 11 | // Implemented in the runtime package (runtime/sys_openbsd3.go) 12 | func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) 13 | func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 14 | func syscall_syscall10(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2 uintptr, err Errno) 15 | func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) 16 | func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 17 | 18 | //go:linkname syscall_syscall syscall.syscall 19 | //go:linkname syscall_syscall6 syscall.syscall6 20 | //go:linkname syscall_syscall10 syscall.syscall10 21 | //go:linkname syscall_rawSyscall syscall.rawSyscall 22 | //go:linkname syscall_rawSyscall6 syscall.rawSyscall6 23 | 24 | func syscall_syscall9(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) { 25 | return syscall_syscall10(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, 0) 26 | } 27 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_openbsd_mips64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | func setTimespec(sec, nsec int64) Timespec { 8 | return Timespec{Sec: sec, Nsec: nsec} 9 | } 10 | 11 | func setTimeval(sec, usec int64) Timeval { 12 | return Timeval{Sec: sec, Usec: usec} 13 | } 14 | 15 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 16 | k.Ident = uint64(fd) 17 | k.Filter = int16(mode) 18 | k.Flags = uint16(flags) 19 | } 20 | 21 | func (iov *Iovec) SetLen(length int) { 22 | iov.Len = uint64(length) 23 | } 24 | 25 | func (msghdr *Msghdr) SetControllen(length int) { 26 | msghdr.Controllen = uint32(length) 27 | } 28 | 29 | func (msghdr *Msghdr) SetIovlen(length int) { 30 | msghdr.Iovlen = uint32(length) 31 | } 32 | 33 | func (cmsg *Cmsghdr) SetLen(length int) { 34 | cmsg.Len = uint32(length) 35 | } 36 | 37 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 38 | // of OpenBSD the syscall is called sysctl instead of __sysctl. 39 | const SYS___SYSCTL = SYS_SYSCTL 40 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_openbsd_ppc64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build ppc64 && openbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: usec} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint64(fd) 19 | k.Filter = int16(mode) 20 | k.Flags = uint16(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint64(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = uint32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | 39 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 40 | // of openbsd/ppc64 the syscall is called sysctl instead of __sysctl. 41 | const SYS___SYSCTL = SYS_SYSCTL 42 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_openbsd_riscv64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build riscv64 && openbsd 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: usec} 15 | } 16 | 17 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 18 | k.Ident = uint64(fd) 19 | k.Filter = int16(mode) 20 | k.Flags = uint16(flags) 21 | } 22 | 23 | func (iov *Iovec) SetLen(length int) { 24 | iov.Len = uint64(length) 25 | } 26 | 27 | func (msghdr *Msghdr) SetControllen(length int) { 28 | msghdr.Controllen = uint32(length) 29 | } 30 | 31 | func (msghdr *Msghdr) SetIovlen(length int) { 32 | msghdr.Iovlen = uint32(length) 33 | } 34 | 35 | func (cmsg *Cmsghdr) SetLen(length int) { 36 | cmsg.Len = uint32(length) 37 | } 38 | 39 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions 40 | // of openbsd/riscv64 the syscall is called sysctl instead of __sysctl. 41 | const SYS___SYSCTL = SYS_SYSCTL 42 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && solaris 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: usec} 15 | } 16 | 17 | func (iov *Iovec) SetLen(length int) { 18 | iov.Len = uint64(length) 19 | } 20 | 21 | func (msghdr *Msghdr) SetIovlen(length int) { 22 | msghdr.Iovlen = int32(length) 23 | } 24 | 25 | func (cmsg *Cmsghdr) SetLen(length int) { 26 | cmsg.Len = uint32(length) 27 | } 28 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_unix_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin || dragonfly || freebsd || (linux && !ppc64 && !ppc64le) || netbsd || openbsd || solaris) && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 12 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 13 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 15 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (ppc64le || ppc64) && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 12 | return syscall.Syscall(trap, a1, a2, a3) 13 | } 14 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 15 | return syscall.Syscall6(trap, a1, a2, a3, a4, a5, a6) 16 | } 17 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 18 | return syscall.RawSyscall(trap, a1, a2, a3) 19 | } 20 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 21 | return syscall.RawSyscall6(trap, a1, a2, a3, a4, a5, a6) 22 | } 23 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/sysvshm_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux 6 | 7 | package unix 8 | 9 | import "runtime" 10 | 11 | // SysvShmCtl performs control operations on the shared memory segment 12 | // specified by id. 13 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 14 | if runtime.GOARCH == "arm" || 15 | runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le" { 16 | cmd |= ipc_64 17 | } 18 | 19 | return shmctl(id, cmd, desc) 20 | } 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (darwin && !ios) || zos 6 | 7 | package unix 8 | 9 | // SysvShmCtl performs control operations on the shared memory segment 10 | // specified by id. 11 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 12 | return shmctl(id, cmd, desc) 13 | } 14 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/unveil_openbsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package unix 6 | 7 | import "fmt" 8 | 9 | // Unveil implements the unveil syscall. 10 | // For more information see unveil(2). 11 | // Note that the special case of blocking further 12 | // unveil calls is handled by UnveilBlock. 13 | func Unveil(path string, flags string) error { 14 | if err := supportsUnveil(); err != nil { 15 | return err 16 | } 17 | pathPtr, err := BytePtrFromString(path) 18 | if err != nil { 19 | return err 20 | } 21 | flagsPtr, err := BytePtrFromString(flags) 22 | if err != nil { 23 | return err 24 | } 25 | return unveil(pathPtr, flagsPtr) 26 | } 27 | 28 | // UnveilBlock blocks future unveil calls. 29 | // For more information see unveil(2). 30 | func UnveilBlock() error { 31 | if err := supportsUnveil(); err != nil { 32 | return err 33 | } 34 | return unveil(nil, nil) 35 | } 36 | 37 | // supportsUnveil checks for availability of the unveil(2) system call based 38 | // on the running OpenBSD version. 39 | func supportsUnveil() error { 40 | maj, min, err := majmin() 41 | if err != nil { 42 | return err 43 | } 44 | 45 | // unveil is not available before 6.4 46 | if maj < 6 || (maj == 6 && min <= 3) { 47 | return fmt.Errorf("cannot call Unveil on OpenBSD %d.%d", maj, min) 48 | } 49 | 50 | return nil 51 | } 52 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/zptrace_armnn_linux.go: -------------------------------------------------------------------------------- 1 | // Code generated by linux/mkall.go generatePtracePair("arm", "arm64"). DO NOT EDIT. 2 | 3 | //go:build linux && (arm || arm64) 4 | 5 | package unix 6 | 7 | import "unsafe" 8 | 9 | // PtraceRegsArm is the registers used by arm binaries. 10 | type PtraceRegsArm struct { 11 | Uregs [18]uint32 12 | } 13 | 14 | // PtraceGetRegsArm fetches the registers used by arm binaries. 15 | func PtraceGetRegsArm(pid int, regsout *PtraceRegsArm) error { 16 | return ptracePtr(PTRACE_GETREGS, pid, 0, unsafe.Pointer(regsout)) 17 | } 18 | 19 | // PtraceSetRegsArm sets the registers used by arm binaries. 20 | func PtraceSetRegsArm(pid int, regs *PtraceRegsArm) error { 21 | return ptracePtr(PTRACE_SETREGS, pid, 0, unsafe.Pointer(regs)) 22 | } 23 | 24 | // PtraceRegsArm64 is the registers used by arm64 binaries. 25 | type PtraceRegsArm64 struct { 26 | Regs [31]uint64 27 | Sp uint64 28 | Pc uint64 29 | Pstate uint64 30 | } 31 | 32 | // PtraceGetRegsArm64 fetches the registers used by arm64 binaries. 33 | func PtraceGetRegsArm64(pid int, regsout *PtraceRegsArm64) error { 34 | return ptracePtr(PTRACE_GETREGS, pid, 0, unsafe.Pointer(regsout)) 35 | } 36 | 37 | // PtraceSetRegsArm64 sets the registers used by arm64 binaries. 38 | func PtraceSetRegsArm64(pid int, regs *PtraceRegsArm64) error { 39 | return ptracePtr(PTRACE_SETREGS, pid, 0, unsafe.Pointer(regs)) 40 | } 41 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/unix/zptrace_linux_arm64.go: -------------------------------------------------------------------------------- 1 | // Code generated by linux/mkall.go generatePtraceRegSet("arm64"). DO NOT EDIT. 2 | 3 | package unix 4 | 5 | import "unsafe" 6 | 7 | // PtraceGetRegSetArm64 fetches the registers used by arm64 binaries. 8 | func PtraceGetRegSetArm64(pid, addr int, regsout *PtraceRegsArm64) error { 9 | iovec := Iovec{(*byte)(unsafe.Pointer(regsout)), uint64(unsafe.Sizeof(*regsout))} 10 | return ptracePtr(PTRACE_GETREGSET, pid, uintptr(addr), unsafe.Pointer(&iovec)) 11 | } 12 | 13 | // PtraceSetRegSetArm64 sets the registers used by arm64 binaries. 14 | func PtraceSetRegSetArm64(pid, addr int, regs *PtraceRegsArm64) error { 15 | iovec := Iovec{(*byte)(unsafe.Pointer(regs)), uint64(unsafe.Sizeof(*regs))} 16 | return ptracePtr(PTRACE_SETREGSET, pid, uintptr(addr), unsafe.Pointer(&iovec)) 17 | } 18 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/aliases.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | import "syscall" 10 | 11 | type Errno = syscall.Errno 12 | type SysProcAttr = syscall.SysProcAttr 13 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/eventlog.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | const ( 10 | EVENTLOG_SUCCESS = 0 11 | EVENTLOG_ERROR_TYPE = 1 12 | EVENTLOG_WARNING_TYPE = 2 13 | EVENTLOG_INFORMATION_TYPE = 4 14 | EVENTLOG_AUDIT_SUCCESS = 8 15 | EVENTLOG_AUDIT_FAILURE = 16 16 | ) 17 | 18 | //sys RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW 19 | //sys DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource 20 | //sys ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) = advapi32.ReportEventW 21 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/mkknownfolderids.bash: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Copyright 2019 The Go Authors. All rights reserved. 4 | # Use of this source code is governed by a BSD-style 5 | # license that can be found in the LICENSE file. 6 | 7 | set -e 8 | shopt -s nullglob 9 | 10 | knownfolders="$(printf '%s\n' "/mnt/c/Program Files (x86)/Windows Kits/"/*/Include/*/um/KnownFolders.h | sort -Vr | head -n 1)" 11 | [[ -n $knownfolders ]] || { echo "Unable to find KnownFolders.h" >&2; exit 1; } 12 | 13 | { 14 | echo "// Code generated by 'mkknownfolderids.bash'; DO NOT EDIT." 15 | echo 16 | echo "package windows" 17 | echo "type KNOWNFOLDERID GUID" 18 | echo "var (" 19 | while read -r line; do 20 | [[ $line =~ DEFINE_KNOWN_FOLDER\((FOLDERID_[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+)\) ]] || continue 21 | printf "%s = &KNOWNFOLDERID{0x%08x, 0x%04x, 0x%04x, [8]byte{0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x}}\n" \ 22 | "${BASH_REMATCH[1]}" $(( "${BASH_REMATCH[2]}" )) $(( "${BASH_REMATCH[3]}" )) $(( "${BASH_REMATCH[4]}" )) \ 23 | $(( "${BASH_REMATCH[5]}" )) $(( "${BASH_REMATCH[6]}" )) $(( "${BASH_REMATCH[7]}" )) $(( "${BASH_REMATCH[8]}" )) \ 24 | $(( "${BASH_REMATCH[9]}" )) $(( "${BASH_REMATCH[10]}" )) $(( "${BASH_REMATCH[11]}" )) $(( "${BASH_REMATCH[12]}" )) 25 | done < "$knownfolders" 26 | echo ")" 27 | } | gofmt > "zknownfolderids_windows.go" 28 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/mksyscall.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build generate 6 | 7 | package windows 8 | 9 | //go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go setupapi_windows.go 10 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows && race 6 | 7 | package windows 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows && !race 6 | 7 | package windows 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/str.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | 7 | package windows 8 | 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 10 | if val < 0 { 11 | return "-" + itoa(-val) 12 | } 13 | var buf [32]byte // big enough for int64 14 | i := len(buf) - 1 15 | for val >= 10 { 16 | buf[i] = byte(val%10 + '0') 17 | i-- 18 | val /= 10 19 | } 20 | buf[i] = byte(val + '0') 21 | return string(buf[i:]) 22 | } 23 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/types_windows_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | _ uint32 // pad to 8 byte boundary 35 | } 36 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/types_windows_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | } 35 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/types_windows_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | _ uint32 // pad to 8 byte boundary 35 | } 36 | -------------------------------------------------------------------------------- /ecr-login/vendor/golang.org/x/sys/windows/types_windows_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | } 35 | -------------------------------------------------------------------------------- /ecr-login/vendor/gopkg.in/yaml.v3/NOTICE: -------------------------------------------------------------------------------- 1 | Copyright 2011-2016 Canonical Ltd. 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. 14 | -------------------------------------------------------------------------------- /ecr-login/version/version.go: -------------------------------------------------------------------------------- 1 | package version 2 | 3 | // Version indicates which version of the binary is running. 4 | var Version = "development" 5 | 6 | // GitCommitSHA indicates which git shorthash the binary was built off of 7 | var GitCommitSHA string 8 | -------------------------------------------------------------------------------- /scripts/build_variant.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | # 4 | # Licensed under the Apache License, Version 2.0 (the "License"). You 5 | # may not use this file except in compliance with the License. A copy of 6 | # the License is located at 7 | # 8 | # http://aws.amazon.com/apache2.0/ 9 | # 10 | # or in the "license" file accompanying this file. This file is 11 | # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF 12 | # ANY KIND, either express or implied. See the License for the specific 13 | # language governing permissions and limitations under the License. 14 | 15 | set -euo pipefail 16 | 17 | # This script is used for compilation of a specific variant. 18 | # Specify GOOS as $1, GOARCH as $2 19 | # Binaries are placed into ./bin/$GOOS-$GOARCH/docker-credential-ecr-login 20 | 21 | # Normalize to working directory being build root (up one level from ./scripts) 22 | ROOT=$( cd "$( dirname "${BASH_SOURCE[0]}" )/.." && pwd ) 23 | cd "${ROOT}" 24 | 25 | # Export variables 26 | export TARGET_GOOS="$1" 27 | export TARGET_GOARCH="$2" 28 | ECR_LOGIN_VERSION="$3" 29 | ECR_LOGIN_GITCOMMIT_SHA="$4" 30 | 31 | ./scripts/build_binary.sh "${ROOT}/bin/${TARGET_GOOS}-${TARGET_GOARCH}" $ECR_LOGIN_VERSION $ECR_LOGIN_GITCOMMIT_SHA 32 | 33 | echo "Built ecr-login for ${TARGET_GOOS}-${TARGET_GOARCH}-${ECR_LOGIN_VERSION}" 34 | -------------------------------------------------------------------------------- /scripts/container_init.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 4 | # 5 | # Licensed under the Apache License, Version 2.0 (the "License"). You 6 | # may not use this file except in compliance with the License. A copy of 7 | # the License is located at 8 | # 9 | # http://aws.amazon.com/apache2.0/ 10 | # 11 | # or in the "license" file accompanying this file. This file is 12 | # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF 13 | # ANY KIND, either express or implied. See the License for the specific 14 | # language governing permissions and limitations under the License. 15 | 16 | # A POSIX shell script which installs the required dependencies 17 | # to build the Amazon ECR credential helper variants in a Golang 18 | # Alpine container. 19 | 20 | set -ex 21 | 22 | apk add --no-cache \ 23 | bash \ 24 | git \ 25 | make 26 | 27 | # Resolves permission issues for Go cache when 28 | # building credential helper as non-root user. 29 | mkdir /.cache && chmod 777 /.cache 30 | # Resolves dubious ownership of git directory when 31 | # building credential helper as root user. 32 | git config --global --add safe.directory /go/src/github.com/awslabs/amazon-ecr-credential-helper 33 | 34 | -------------------------------------------------------------------------------- /scripts/gogenerate: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | # 4 | # Licensed under the Apache License, Version 2.0 (the "License"). You may 5 | # not use this file except in compliance with the License. A copy of the 6 | # License is located at 7 | # 8 | # http://aws.amazon.com/apache2.0/ 9 | # 10 | # or in the "license" file accompanying this file. This file is distributed 11 | # on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 12 | # express or implied. See the License for the specific language governing 13 | # permissions and limitations under the License. 14 | 15 | set -e 16 | 17 | # Normalize to working directory being build root (up one level from ./scripts) 18 | ROOT=$( cd "$( dirname "${BASH_SOURCE[0]}" )/.." && pwd ) 19 | cd "${ROOT}" 20 | 21 | go generate -x $(go list ./ecr-login/... | grep -v '/vendor/') 22 | -------------------------------------------------------------------------------- /scripts/hack/codepipeline-git-commit.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | # 4 | # Licensed under the Apache License, Version 2.0 (the "License"). You may 5 | # not use this file except in compliance with the License. A copy of the 6 | # License is located at 7 | # 8 | # http://aws.amazon.com/apache2.0/ 9 | # 10 | # or in the "license" file accompanying this file. This file is distributed 11 | # on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 12 | # express or implied. See the License for the specific language governing 13 | # permissions and limitations under the License. 14 | 15 | # This script populates the GITCOMMIT_SHA file when built inside AWS CodeBuild 16 | # and invoked from AWS CodePipeline. 17 | 18 | set -ex 19 | 20 | [[ -z "${CODEBUILD_RESOLVED_SOURCE_VERSION}" ]] && exit 1 21 | echo "${CODEBUILD_RESOLVED_SOURCE_VERSION}" > GITCOMMIT_SHA 22 | cat GITCOMMIT_SHA 23 | -------------------------------------------------------------------------------- /scripts/hack/symlink-gopath-codebuild.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | # 4 | # Licensed under the Apache License, Version 2.0 (the "License"). You may 5 | # not use this file except in compliance with the License. A copy of the 6 | # License is located at 7 | # 8 | # http://aws.amazon.com/apache2.0/ 9 | # 10 | # or in the "license" file accompanying this file. This file is distributed 11 | # on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 12 | # express or implied. See the License for the specific language governing 13 | # permissions and limitations under the License. 14 | 15 | # This script is meant to make the package available in the 'canonical' location 16 | # for execution in AWS CodeBuild in the golang container image. 17 | 18 | 19 | if [[ ! -d "/go/src/github.com/awslabs/amazon-ecr-credential-helper" ]]; then 20 | mkdir -p "/go/src/github.com/awslabs" 21 | ln -s "$(pwd)" "/go/src/github.com/awslabs/amazon-ecr-credential-helper" 22 | fi -------------------------------------------------------------------------------- /scripts/third_party_licenses/apache.tpl: -------------------------------------------------------------------------------- 1 | {{range . -}} 2 | {{if eq .LicenseName "Apache-2.0" -}} 3 | ** {{.Name}}; version {{.Version}} - {{.LicenseURL}} 4 | {{end -}} 5 | {{end -}} 6 | -------------------------------------------------------------------------------- /scripts/third_party_licenses/other.tpl: -------------------------------------------------------------------------------- 1 | {{ range . -}} 2 | {{ if ne .LicenseName "Apache-2.0" -}} 3 | -------------------------------------------------------------------------------- 4 | ** {{.Name}}; version {{.Version}} - {{.LicenseURL}} 5 | 6 | {{ .LicenseText }} 7 | 8 | {{end -}} 9 | {{end -}} 10 | --------------------------------------------------------------------------------