10 skills found
QuantumKitHub / TensorOperations.jlJulia package for tensor contractions and related operations
SciML / EllipsisNotation.jlJulia-based implementation of ellipsis array indexing notation `..`
sanusanth / C Basic ProgramsWhat is C#? C# is pronounced "C-Sharp". It is an object-oriented programming language created by Microsoft that runs on the .NET Framework. C# has roots from the C family, and the language is close to other popular languages like C++ and Java. The first version was released in year 2002. The latest version, C# 8, was released in September 2019. C# is a modern object-oriented programming language developed in 2000 by Anders Hejlsberg, the principal designer and lead architect at Microsoft. It is pronounced as "C-Sharp," inspired by the musical notation “♯” which stands for a note with a slightly higher pitch. As it’s considered an incremental compilation of the C++ language, the name C “sharp” seemed most appropriate. The sharp symbol, however, has been replaced by the keyboard friendly “#” as a suffix to “C” for purposes of programming. Although the code is very similar to C++, C# is newer and has grown fast with extensive support from Microsoft. The fact that it’s so similar to Java syntactically helps explain why it has emerged as one of the most popular programming languages today. C# is pronounced "C-Sharp". It is an object-oriented programming language created by Microsoft that runs on the .NET Framework. C# has roots from the C family, and the language is close to other popular languages like C++ and Java. The first version was released in year 2002. The latest version, C# 8, was released in September 2019. C# is used for: Mobile applications Desktop applications Web applications Web services Web sites Games VR Database applications And much, much more! An Introduction to C# Programming C# is a general-purpose, object-oriented programming language that is structured and easy to learn. It runs on Microsoft’s .Net Framework and can be compiled on a variety of computer platforms. As the syntax is simple and easy to learn, developers familiar with C, C++, or Java have found a comfort zone within C#. C# is a boon for developers who want to build a wide range of applications on the .NET Framework—Windows applications, Web applications, and Web services—in addition to building mobile apps, Windows Store apps, and enterprise software. It is thus considered a powerful programming language and features in every developer’s cache of tools. Although first released in 2002, when it was introduced with .NET Framework 1.0, the C# language has evolved a great deal since then. The most recent version is C# 8.0, available in preview as part of Visual Studio. To get access to all of the new language features, you would need to install the latest preview version of .NET Core 3.0. C# is used for: Mobile applications Desktop applications Web applications Web services Web sites Games VR Database applications And much, much more! Why Use C#? It is one of the most popular programming language in the world It is easy to learn and simple to use It has a huge community support C# is an object oriented language which gives a clear structure to programs and allows code to be reused, lowering development costs. As C# is close to C, C++ and Java, it makes it easy for programmers to switch to C# or vice versa. The C# Environment You need the .NET Framework and an IDE (integrated development environment) to work with the C# language. The .NET Framework The .NET Framework platform of the Windows OS is required to write web and desktop-based applications using not only C# but also Visual Basic and Jscript, as the platform provides language interoperability. Besides, the .Net Framework allows C# to communicate with any of the other common languages, such as C++, Jscript, COBOL, and so on. IDEs Microsoft provides various IDEs for C# programming: Visual Studio 2010 (VS) Visual Studio Express Visual Web Developer Visual Studio Code (VSC) The C# source code files can be written using a basic text editor, like Notepad, and compiled using the command-line compiler of the .NET Framework. Alternative open-source versions of the .Net Framework can work on other operating systems as well. For instance, the Mono has a C# compiler and runs on several operating systems, including Linux, Mac, Android, BSD, iOS, Windows, Solaris, and UNIX. This brings enhanced development tools to the developer. As C# is part of the .Net Framework platform, it has access to its enormous library of codes and components, such as Common Language Runtime (CLR), the .Net Framework Class Library, Common Language Specification, Common Type System, Metadata and Assemblies, Windows Forms, ASP.Net and ASP.Net AJAX, Windows Workflow Foundation (WF), Windows Communication Foundation (WCF), and LINQ. C# and Java C# and Java are high-level programming languages that share several similarities (as well as many differences). They are both object-oriented languages much influenced by C++. But while C# is suitable for application development in the Microsoft ecosystem from the front, Java is considered best for client-side web applications. Also, while C# has many tools for programming, Java has a larger arsenal of tools to choose from in IDEs and Text Editors. C# is used for virtual reality projects like games, mobile, and web applications. It is built specifically for Microsoft platforms and several non-Microsoft-based operating systems, like the Mono Project that works with Linux and OS X. Java is used for creating messaging applications and developing web-based and enterprise-based applications in open-source ecosystems. Both C# and Java support arrays. However, each language uses them differently. In C#, arrays are a specialization of the system; in Java, they are a direct specialization of the object. The C# programming language executes on the CLR. The source code is interpreted into bytecode, which is further compiled by the CLR. Java runs on any platform with the assistance of JRE (Java Runtime Environment). The written source code is first compiled into bytecode and then converted into machine code to be executed on a JRE. C# and C++ Although C# and C++ are both C-based languages with similar code, there are some differences. For one, C# is considered a component-oriented programming language, while C++ is a partial object-oriented language. Also, while both languages are compiled languages, C# compiles to CLR and is interpreted by.NET, but C++ compiles to machine code. The size of binaries in C# is much larger than in C++. Other differences between the two include the following: C# gives compiler errors and warnings, but C++ doesn’t support warnings, which may cause damage to the OS. C# runs in a virtual machine for automatic memory management. C++ requires you to manage memory manually. C# can create Windows, .NET, web, desktop, and mobile applications, but not stand-alone apps. C++ can create server-side, stand-alone, and console applications as it can work directly with the hardware. C++ can be used on any platform, while C# is targeted toward Windows OS. Generally, C++ being faster than C#, the former is preferred for applications where performance is essential. Features of C# The C# programming language has many features that make it more useful and unique when compared to other languages, including: Object-oriented language Being object-oriented, C# allows the creation of modular applications and reusable codes, an advantage over C++. As an object-oriented language, C# makes development and maintenance easier when project size grows. It supports all three object-oriented features: data encapsulation, inheritance, interfaces, and polymorphism. Simplicity C# is a simple language with a structured approach to problem-solving. Unsafe operations, like direct memory manipulation, are not allowed. Speed The compilation and execution time in C# is very powerful and fast. A Modern programming language C# programming is used for building scalable and interoperable applications with support for modern features like automatic garbage collection, error handling, debugging, and robust security. It has built-in support for a web service to be invoked from any app running on any platform. Type-safe Arrays and objects are zero base indexed and bound checked. There is an automatic checking of the overflow of types. The C# type safety instances support robust programming. Interoperability Language interoperability of C# maximizes code reuse for the efficiency of the development process. C# programs can work upon almost anything as a program can call out any native API. Consistency Its unified type system enables developers to extend the type system simply and easily for consistent behavior. Updateable C# is automatically updateable. Its versioning support enables complex frameworks to be developed and evolved. Component oriented C# supports component-oriented programming through the concepts of properties, methods, events, and attributes for self-contained and self-describing components of functionality for robust and scalable applications. Structured Programming Language The structured design and modularization in C# break a problem into parts, using functions for easy implementation to solve significant problems. Rich Library C# has a standard library with many inbuilt functions for easy and fast development. Prerequisites for Learning C# Basic knowledge of C or C++ or any programming language or programming fundamentals. Additionally, the OOP concept makes for a short learning curve of C#. Advantages of C# There are many advantages to the C# language that makes it a useful programming language compared to other languages like Java, C, or C++. These include: Being an object-oriented language, C# allows you to create modular, maintainable applications and reusable codes Familiar syntax Easy to develop as it has a rich class of libraries for smooth implementation of functions Enhanced integration as an application written in .NET will integrate and interpret better when compared to other NET technologies As C# runs on CLR, it makes it easy to integrate with components written in other languages It’s safe, with no data loss as there is no type-conversion so that you can write secure codes The automatic garbage collection keeps the system clean and doesn’t hang it during execution As your machine has to install the .NET Framework to run C#, it supports cross-platform Strong memory backup prevents memory leakage Programming support of the Microsoft ecosystem makes development easy and seamless Low maintenance cost, as C# can develop iOS, Android, and Windows Phone native apps The syntax is similar to C, C++, and Java, which makes it easier to learn and work with C# Useful as it can develop iOS, Android, and Windows Phone native apps with the Xamarin Framework C# is the most powerful programming language for the .NET Framework Fast development as C# is open source steered by Microsoft with access to open source projects and tools on Github, and many active communities contributing to the improvement What Can C Sharp Do for You? C# can be used to develop a wide range of: Windows client applications Windows libraries and components Windows services Web applications Native iOS and Android mobile apps Azure cloud applications and services Gaming consoles and gaming systems Video and virtual reality games Interoperability software like SharePoint Enterprise software Backend services and database programs AI and ML applications Distributed applications Hardware-level programming Virus and malware software GUI-based applications IoT devices Blockchain and distributed ledger technology C# Programming for Beginners: Introduction, Features and Applications By Simplilearn Last updated on Jan 20, 2020674 C# Programming for Beginners As a programmer, you’re motivated to master the most popular languages that will give you an edge in your career. There’s a vast number of programming languages that you can learn, but how do you know which is the most useful? If you know C and C++, do you need to learn C# as well? How similar is C# to Java? Does it become more comfortable for you to learn C# if you already know Java? Every developer and wannabe programmer asks these types of questions. So let us explore C# programming: how it evolved as an extension of C and why you need to learn it as a part of the Master’s Program in integrated DevOps for server-side execution. Are you a web developer or someone interested to build a website? Enroll for the Javascript Certification Training. Check out the course preview now! What is C#? C# is a modern object-oriented programming language developed in 2000 by Anders Hejlsberg, the principal designer and lead architect at Microsoft. It is pronounced as "C-Sharp," inspired by the musical notation “♯” which stands for a note with a slightly higher pitch. As it’s considered an incremental compilation of the C++ language, the name C “sharp” seemed most appropriate. The sharp symbol, however, has been replaced by the keyboard friendly “#” as a suffix to “C” for purposes of programming. Although the code is very similar to C++, C# is newer and has grown fast with extensive support from Microsoft. The fact that it’s so similar to Java syntactically helps explain why it has emerged as one of the most popular programming languages today. An Introduction to C# Programming C# is a general-purpose, object-oriented programming language that is structured and easy to learn. It runs on Microsoft’s .Net Framework and can be compiled on a variety of computer platforms. As the syntax is simple and easy to learn, developers familiar with C, C++, or Java have found a comfort zone within C#. C# is a boon for developers who want to build a wide range of applications on the .NET Framework—Windows applications, Web applications, and Web services—in addition to building mobile apps, Windows Store apps, and enterprise software. It is thus considered a powerful programming language and features in every developer’s cache of tools. Although first released in 2002, when it was introduced with .NET Framework 1.0, the C# language has evolved a great deal since then. The most recent version is C# 8.0, available in preview as part of Visual Studio. To get access to all of the new language features, you would need to install the latest preview version of .NET Core 3.0. The C# Environment You need the .NET Framework and an IDE (integrated development environment) to work with the C# language. The .NET Framework The .NET Framework platform of the Windows OS is required to write web and desktop-based applications using not only C# but also Visual Basic and Jscript, as the platform provides language interoperability. Besides, the .Net Framework allows C# to communicate with any of the other common languages, such as C++, Jscript, COBOL, and so on. IDEs Microsoft provides various IDEs for C# programming: Visual Studio 2010 (VS) Visual Studio Express Visual Web Developer Visual Studio Code (VSC) The C# source code files can be written using a basic text editor, like Notepad, and compiled using the command-line compiler of the .NET Framework. Alternative open-source versions of the .Net Framework can work on other operating systems as well. For instance, the Mono has a C# compiler and runs on several operating systems, including Linux, Mac, Android, BSD, iOS, Windows, Solaris, and UNIX. This brings enhanced development tools to the developer. As C# is part of the .Net Framework platform, it has access to its enormous library of codes and components, such as Common Language Runtime (CLR), the .Net Framework Class Library, Common Language Specification, Common Type System, Metadata and Assemblies, Windows Forms, ASP.Net and ASP.Net AJAX, Windows Workflow Foundation (WF), Windows Communication Foundation (WCF), and LINQ. C# and Java C# and Java are high-level programming languages that share several similarities (as well as many differences). They are both object-oriented languages much influenced by C++. But while C# is suitable for application development in the Microsoft ecosystem from the front, Java is considered best for client-side web applications. Also, while C# has many tools for programming, Java has a larger arsenal of tools to choose from in IDEs and Text Editors. C# is used for virtual reality projects like games, mobile, and web applications. It is built specifically for Microsoft platforms and several non-Microsoft-based operating systems, like the Mono Project that works with Linux and OS X. Java is used for creating messaging applications and developing web-based and enterprise-based applications in open-source ecosystems. Both C# and Java support arrays. However, each language uses them differently. In C#, arrays are a specialization of the system; in Java, they are a direct specialization of the object. The C# programming language executes on the CLR. The source code is interpreted into bytecode, which is further compiled by the CLR. Java runs on any platform with the assistance of JRE (Java Runtime Environment). The written source code is first compiled into bytecode and then converted into machine code to be executed on a JRE. C# and C++ Although C# and C++ are both C-based languages with similar code, there are some differences. For one, C# is considered a component-oriented programming language, while C++ is a partial object-oriented language. Also, while both languages are compiled languages, C# compiles to CLR and is interpreted by.NET, but C++ compiles to machine code. The size of binaries in C# is much larger than in C++. Other differences between the two include the following: C# gives compiler errors and warnings, but C++ doesn’t support warnings, which may cause damage to the OS. C# runs in a virtual machine for automatic memory management. C++ requires you to manage memory manually. C# can create Windows, .NET, web, desktop, and mobile applications, but not stand-alone apps. C++ can create server-side, stand-alone, and console applications as it can work directly with the hardware. C++ can be used on any platform, while C# is targeted toward Windows OS. Generally, C++ being faster than C#, the former is preferred for applications where performance is essential. Features of C# The C# programming language has many features that make it more useful and unique when compared to other languages, including: Object-oriented language Being object-oriented, C# allows the creation of modular applications and reusable codes, an advantage over C++. As an object-oriented language, C# makes development and maintenance easier when project size grows. It supports all three object-oriented features: data encapsulation, inheritance, interfaces, and polymorphism. Simplicity C# is a simple language with a structured approach to problem-solving. Unsafe operations, like direct memory manipulation, are not allowed. Speed The compilation and execution time in C# is very powerful and fast. A Modern programming language C# programming is used for building scalable and interoperable applications with support for modern features like automatic garbage collection, error handling, debugging, and robust security. It has built-in support for a web service to be invoked from any app running on any platform. Type-safe Arrays and objects are zero base indexed and bound checked. There is an automatic checking of the overflow of types. The C# type safety instances support robust programming. Interoperability Language interoperability of C# maximizes code reuse for the efficiency of the development process. C# programs can work upon almost anything as a program can call out any native API. Consistency Its unified type system enables developers to extend the type system simply and easily for consistent behavior. Updateable C# is automatically updateable. Its versioning support enables complex frameworks to be developed and evolved. Component oriented C# supports component-oriented programming through the concepts of properties, methods, events, and attributes for self-contained and self-describing components of functionality for robust and scalable applications. Structured Programming Language The structured design and modularization in C# break a problem into parts, using functions for easy implementation to solve significant problems. Rich Library C# has a standard library with many inbuilt functions for easy and fast development. Full Stack Java Developer Course The Gateway to Master Web DevelopmentEXPLORE COURSEFull Stack Java Developer Course Prerequisites for Learning C# Basic knowledge of C or C++ or any programming language or programming fundamentals. Additionally, the OOP concept makes for a short learning curve of C#. Advantages of C# There are many advantages to the C# language that makes it a useful programming language compared to other languages like Java, C, or C++. These include: Being an object-oriented language, C# allows you to create modular, maintainable applications and reusable codes Familiar syntax Easy to develop as it has a rich class of libraries for smooth implementation of functions Enhanced integration as an application written in .NET will integrate and interpret better when compared to other NET technologies As C# runs on CLR, it makes it easy to integrate with components written in other languages It’s safe, with no data loss as there is no type-conversion so that you can write secure codes The automatic garbage collection keeps the system clean and doesn’t hang it during execution As your machine has to install the .NET Framework to run C#, it supports cross-platform Strong memory backup prevents memory leakage Programming support of the Microsoft ecosystem makes development easy and seamless Low maintenance cost, as C# can develop iOS, Android, and Windows Phone native apps The syntax is similar to C, C++, and Java, which makes it easier to learn and work with C# Useful as it can develop iOS, Android, and Windows Phone native apps with the Xamarin Framework C# is the most powerful programming language for the .NET Framework Fast development as C# is open source steered by Microsoft with access to open source projects and tools on Github, and many active communities contributing to the improvement What Can C Sharp Do for You? C# can be used to develop a wide range of: Windows client applications Windows libraries and components Windows services Web applications Native iOS and Android mobile apps Azure cloud applications and services Gaming consoles and gaming systems Video and virtual reality games Interoperability software like SharePoint Enterprise software Backend services and database programs AI and ML applications Distributed applications Hardware-level programming Virus and malware software GUI-based applications IoT devices Blockchain and distributed ledger technology Who Should Learn the C# Programming Language and Why? C# is one of the most popular programming languages as it can be used for a variety of applications: mobile apps, game development, and enterprise software. What’s more, the C# 8.0 version is packed with several new features and enhancements to the C# language that can change the way developers write their C# code. The most important new features available are ‘null reference types,’ enhanced ‘pattern matching,’ and ‘async streams’ that help you to write more reliable and readable code. As you’re exposed to the fundamental programming concepts of C# in this course, you can work on projects that open the doors for you as a Full Stack Java Developer. So, upskill and master the C# language for a faster career trajectory and salary scope.
mercerheather476 / Turbo Garbanzo [](https://search.maven.org/search?q=g:net.openid%20appauth) [](http://javadoc.io/doc/net.openid/appauth) [](https://github.com/openid/AppAuth-Android/actions/workflows/build.yml) [](https://codecov.io/github/openid/AppAuth-Android?branch=master) AppAuth for Android is a client SDK for communicating with [OAuth 2.0](https://tools.ietf.org/html/rfc6749) and [OpenID Connect](http://openid.net/specs/openid-connect-core-1_0.html) providers. It strives to directly map the requests and responses of those specifications, while following the idiomatic style of the implementation language. In addition to mapping the raw protocol flows, convenience methods are available to assist with common tasks like performing an action with fresh tokens. The library follows the best practices set out in [RFC 8252 - OAuth 2.0 for Native Apps](https://tools.ietf.org/html/rfc8252), including using [Custom Tabs](https://developer.chrome.com/multidevice/android/customtabs) for authorization requests. For this reason, `WebView` is explicitly *not* supported due to usability and security reasons. The library also supports the [PKCE](https://tools.ietf.org/html/rfc7636) extension to OAuth which was created to secure authorization codes in public clients when custom URI scheme redirects are used. The library is friendly to other extensions (standard or otherwise) with the ability to handle additional parameters in all protocol requests and responses. A talk providing an overview of using the library for enterprise single sign-on (produced by Google) can be found here: [Enterprise SSO with Chrome Custom Tabs](https://www.youtube.com/watch?v=DdQTXrk6YTk). ## Download AppAuth for Android is available on [MavenCentral](https://search.maven.org/search?q=g:net.openid%20appauth) ```groovy implementation 'net.openid:appauth:<version>' ``` ## Requirements AppAuth supports Android API 16 (Jellybean) and above. Browsers which provide a custom tabs implementation are preferred by the library, but not required. Both Custom URI Schemes (all supported versions of Android) and App Links (Android M / API 23+) can be used with the library. In general, AppAuth can work with any Authorization Server (AS) that supports native apps as documented in [RFC 8252](https://tools.ietf.org/html/rfc8252), either through custom URI scheme redirects, or App Links. AS's that assume all clients are web-based or require clients to maintain confidentiality of the client secrets may not work well. ## Demo app A demo app is contained within this repository. For instructions on how to build and configure this app, see the [demo app readme](https://github.com/openid/AppAuth-Android/blob/master/app/README.md). ## Conceptual overview AppAuth encapsulates the authorization state of the user in the [net.openid.appauth.AuthState](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthState.java) class, and communicates with an authorization server through the use of the [net.openid.appauth.AuthorizationService](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java) class. AuthState is designed to be easily persistable as a JSON string, using the storage mechanism of your choice (e.g. [SharedPreferences](https://developer.android.com/training/basics/data-storage/shared-preferences.html), [sqlite](https://developer.android.com/training/basics/data-storage/databases.html), or even just [in a file](https://developer.android.com/training/basics/data-storage/files.html)). AppAuth provides data classes which are intended to model the OAuth2 specification as closely as possible; this provides the greatest flexibility in interacting with a wide variety of OAuth2 and OpenID Connect implementations. Authorizing the user occurs via the user's web browser, and the request is described using instances of [AuthorizationRequest](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationRequest.java). The request is dispatched using [performAuthorizationRequest()](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java#L159) on an AuthorizationService instance, and the response (an [AuthorizationResponse](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationResponse.java) instance) will be dispatched to the activity of your choice, expressed via an Intent. Token requests, such as obtaining a new access token using a refresh token, follow a similar pattern: [TokenRequest](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/TokenRequest.java) instances are dispatched using [performTokenRequest()](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java#L252) on an AuthorizationService instance, and a [TokenResponse](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/TokenResponse.java) instance is returned via a callback. Responses can be provided to the [update()](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthState.java#L367) methods on AuthState in order to track and persist changes to the authorization state. Once in an authorized state, the [performActionWithFreshTokens()](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthState.java#L449) method on AuthState can be used to automatically refresh access tokens as necessary before performing actions that require valid tokens. ## Implementing the authorization code flow It is recommended that native apps use the [authorization code](https://tools.ietf.org/html/rfc6749#section-1.3.1) flow with a public client to gain authorization to access user data. This has the primary advantage for native clients that the authorization flow, which must occur in a browser, only needs to be performed once. This flow is effectively composed of four stages: 1. Discovering or specifying the endpoints to interact with the provider. 2. Authorizing the user, via a browser, in order to obtain an authorization code. 3. Exchanging the authorization code with the authorization server, to obtain a refresh token and/or ID token. 4. Using access tokens derived from the refresh token to interact with a resource server for further access to user data. At each step of the process, an AuthState instance can (optionally) be updated with the result to help with tracking the state of the flow. ### Authorization service configuration First, AppAuth must be instructed how to interact with the authorization service. This can be done either by directly creating an [AuthorizationServiceConfiguration](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationServiceConfiguration.java#L102) instance, or by retrieving an OpenID Connect discovery document. Directly specifying an AuthorizationServiceConfiguration involves providing the URIs of the authorization endpoint and token endpoint, and optionally a dynamic client registration endpoint (see "Dynamic client registration" for more info): ```java AuthorizationServiceConfiguration serviceConfig = new AuthorizationServiceConfiguration( Uri.parse("https://idp.example.com/auth"), // authorization endpoint Uri.parse("https://idp.example.com/token")); // token endpoint ``` Where available, using an OpenID Connect discovery document is preferable: ```java AuthorizationServiceConfiguration.fetchFromIssuer( Uri.parse("https://idp.example.com"), new AuthorizationServiceConfiguration.RetrieveConfigurationCallback() { public void onFetchConfigurationCompleted( @Nullable AuthorizationServiceConfiguration serviceConfiguration, @Nullable AuthorizationException ex) { if (ex != null) { Log.e(TAG, "failed to fetch configuration"); return; } // use serviceConfiguration as needed } }); ``` This will attempt to download a discovery document from the standard location under this base URI, `https://idp.example.com/.well-known/openid-configuration`. If the discovery document for your IDP is in some other non-standard location, you can instead provide the full URI as follows: ```java AuthorizationServiceConfiguration.fetchFromUrl( Uri.parse("https://idp.example.com/exampletenant/openid-config"), new AuthorizationServiceConfiguration.RetrieveConfigurationCallback() { ... } }); ``` If desired, this configuration can be used to seed an AuthState instance, to persist the configuration easily: ```java AuthState authState = new AuthState(serviceConfig); ``` ### Obtaining an authorization code An authorization code can now be acquired by constructing an AuthorizationRequest, using its Builder. In AppAuth, the builders for each data class accept the mandatory parameters via the builder constructor: ```java AuthorizationRequest.Builder authRequestBuilder = new AuthorizationRequest.Builder( serviceConfig, // the authorization service configuration MY_CLIENT_ID, // the client ID, typically pre-registered and static ResponseTypeValues.CODE, // the response_type value: we want a code MY_REDIRECT_URI); // the redirect URI to which the auth response is sent ``` Other optional parameters, such as the OAuth2 [scope string](https://tools.ietf.org/html/rfc6749#section-3.3) or OpenID Connect [login hint](http://openid.net/specs/openid-connect-core-1_0.html#rfc.section.3.1.2.1) are specified through set methods on the builder: ```java AuthorizationRequest authRequest = authRequestBuilder .setScope("openid email profile https://idp.example.com/custom-scope") .setLoginHint("jdoe@user.example.com") .build(); ``` This request can then be dispatched using one of two approaches. a `startActivityForResult` call using an Intent returned from the `AuthorizationService`, or by calling `performAuthorizationRequest` and providing pending intent for completion and cancelation handling activities. The `startActivityForResult` approach is simpler to use but may require more processing of the result: ```java private void doAuthorization() { AuthorizationService authService = new AuthorizationService(this); Intent authIntent = authService.getAuthorizationRequestIntent(authRequest); startActivityForResult(authIntent, RC_AUTH); } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == RC_AUTH) { AuthorizationResponse resp = AuthorizationResponse.fromIntent(data); AuthorizationException ex = AuthorizationException.fromIntent(data); // ... process the response or exception ... } else { // ... } } ``` If instead you wish to directly transition to another activity on completion or cancelation, you can use `performAuthorizationRequest`: ```java AuthorizationService authService = new AuthorizationService(this); authService.performAuthorizationRequest( authRequest, PendingIntent.getActivity(this, 0, new Intent(this, MyAuthCompleteActivity.class), 0), PendingIntent.getActivity(this, 0, new Intent(this, MyAuthCanceledActivity.class), 0)); ``` The intents may be customized to carry any additional data or flags required for the correct handling of the authorization response. #### Capturing the authorization redirect Once the authorization flow is completed in the browser, the authorization service will redirect to a URI specified as part of the authorization request, providing the response via query parameters. In order for your app to capture this response, it must register with the Android OS as a handler for this redirect URI. We recommend using a custom scheme based redirect URI (i.e. those of form `my.scheme:/path`), as this is the most widely supported across all versions of Android. To avoid conflicts with other apps, it is recommended to configure a distinct scheme using "reverse domain name notation". This can either match your service web domain (in reverse) e.g. `com.example.service` or your package name `com.example.app` or be something completely new as long as it's distinct enough. Using the package name of your app is quite common but it's not always possible if it contains illegal characters for URI schemes (like underscores) or if you already have another handler for that scheme - so just use something else. When a custom scheme is used, AppAuth can be easily configured to capture all redirects using this custom scheme through a manifest placeholder: ```groovy android.defaultConfig.manifestPlaceholders = [ 'appAuthRedirectScheme': 'com.example.app' ] ``` Alternatively, the redirect URI can be directly configured by adding an intent-filter for AppAuth's RedirectUriReceiverActivity to your AndroidManifest.xml: ```xml <activity android:name="net.openid.appauth.RedirectUriReceiverActivity" tools:node="replace"> <intent-filter> <action android:name="android.intent.action.VIEW"/> <category android:name="android.intent.category.DEFAULT"/> <category android:name="android.intent.category.BROWSABLE"/> <data android:scheme="com.example.app"/> </intent-filter> </activity> ``` If an HTTPS redirect URI is required instead of a custom scheme, the same approach (modifying your AndroidManifest.xml) is used: ```xml <activity android:name="net.openid.appauth.RedirectUriReceiverActivity" tools:node="replace"> <intent-filter> <action android:name="android.intent.action.VIEW"/> <category android:name="android.intent.category.DEFAULT"/> <category android:name="android.intent.category.BROWSABLE"/> <data android:scheme="https" android:host="app.example.com" android:path="/oauth2redirect"/> </intent-filter> </activity> ``` HTTPS redirects can be secured by configuring the redirect URI as an [app link](https://developer.android.com/training/app-links/index.html) in Android M and above. We recommend that a fallback page be configured at the same address to forward authorization responses to your app via a custom scheme, for older Android devices. #### Handling the authorization response Upon completion of the authorization flow, the completion Intent provided to performAuthorizationRequest will be triggered. The authorization response is provided to this activity via Intent extra data, which can be extracted using the `fromIntent()` methods on AuthorizationResponse and AuthorizationException respectively: ```java public void onCreate(Bundle b) { AuthorizationResponse resp = AuthorizationResponse.fromIntent(getIntent()); AuthorizationException ex = AuthorizationException.fromIntent(getIntent()); if (resp != null) { // authorization completed } else { // authorization failed, check ex for more details } // ... } ``` The response can be provided to the AuthState instance for easy persistence and further processing: ``` authState.update(resp, ex); ``` If the full redirect URI is required in order to extract additional information that AppAuth does not provide, this is also provided to your activity: ```java public void onCreate(Bundle b) { // ... Uri redirectUri = getIntent().getData(); // ... } ``` ### Exchanging the authorization code Given a successful authorization response carrying an authorization code, a token request can be made to exchange the code for a refresh token: ```java authService.performTokenRequest( resp.createTokenExchangeRequest(), new AuthorizationService.TokenResponseCallback() { @Override public void onTokenRequestCompleted( TokenResponse resp, AuthorizationException ex) { if (resp != null) { // exchange succeeded } else { // authorization failed, check ex for more details } } }); ``` The token response can also be used to update an AuthState instance: ```java authState.update(resp, ex); ``` ### Using access tokens Finally, the retrieved access token can be used to interact with a resource server. This can be done directly, by extracting the access token from a token response. However, in most cases, it is simpler to use the `performActionWithFreshTokens` utility method provided by AuthState: ```java authState.performActionWithFreshTokens(service, new AuthStateAction() { @Override public void execute( String accessToken, String idToken, AuthorizationException ex) { if (ex != null) { // negotiation for fresh tokens failed, check ex for more details return; } // use the access token to do something ... } }); ``` This also updates the AuthState object with current access, id, and refresh tokens. If you are storing your AuthState in persistent storage, you should write the updated copy in the callback to this method. ### Ending current session Given you have a logged in session and you want to end it. In that case you need to get: - `AuthorizationServiceConfiguration` - valid Open Id Token that you should get after authentication - End of session URI that should be provided within you OpenId service config First you have to build EndSessionRequest ```java EndSessionRequest endSessionRequest = new EndSessionRequest.Builder(authorizationServiceConfiguration) .setIdTokenHint(idToken) .setPostLogoutRedirectUri(endSessionRedirectUri) .build(); ``` This request can then be dispatched using one of two approaches. a `startActivityForResult` call using an Intent returned from the `AuthorizationService`, or by calling `performEndSessionRequest` and providing pending intent for completion and cancelation handling activities. The startActivityForResult approach is simpler to use but may require more processing of the result: ```java private void endSession() { AuthorizationService authService = new AuthorizationService(this); Intent endSessionItent = authService.getEndSessionRequestIntent(endSessionRequest); startActivityForResult(endSessionItent, RC_END_SESSION); } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == RC_END_SESSION) { EndSessionResonse resp = EndSessionResonse.fromIntent(data); AuthorizationException ex = AuthorizationException.fromIntent(data); // ... process the response or exception ... } else { // ... } } ``` If instead you wish to directly transition to another activity on completion or cancelation, you can use `performEndSessionRequest`: ```java AuthorizationService authService = new AuthorizationService(this); authService.performEndSessionRequest( endSessionRequest, PendingIntent.getActivity(this, 0, new Intent(this, MyAuthCompleteActivity.class), 0), PendingIntent.getActivity(this, 0, new Intent(this, MyAuthCanceledActivity.class), 0)); ``` End session flow will also work involving browser mechanism that is described in authorization mechanism session. Handling response mechanism with transition to another activity should be as follows: ```java public void onCreate(Bundle b) { EndSessionResponse resp = EndSessionResponse.fromIntent(getIntent()); AuthorizationException ex = AuthorizationException.fromIntent(getIntent()); if (resp != null) { // authorization completed } else { // authorization failed, check ex for more details } // ... } ``` ### AuthState persistence Instances of `AuthState` keep track of the authorization and token requests and responses. This is the only object that you need to persist to retain the authorization state of the session. Typically, one would do this by storing the authorization state in SharedPreferences or some other persistent store private to the app: ```java @NonNull public AuthState readAuthState() { SharedPreferences authPrefs = getSharedPreferences("auth", MODE_PRIVATE); String stateJson = authPrefs.getString("stateJson", null); if (stateJson != null) { return AuthState.jsonDeserialize(stateJson); } else { return new AuthState(); } } public void writeAuthState(@NonNull AuthState state) { SharedPreferences authPrefs = getSharedPreferences("auth", MODE_PRIVATE); authPrefs.edit() .putString("stateJson", state.jsonSerializeString()) .apply(); } ``` The demo app has an [AuthStateManager](https://github.com/openid/AppAuth-Android/blob/master/app/java/net/openid/appauthdemo/AuthStateManager.java) type which demonstrates this in more detail. ## Advanced configuration AppAuth provides some advanced configuration options via [AppAuthConfiguration](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AppAuthConfiguration.java) instances, which can be provided to [AuthorizationService](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java) during construction. ### Controlling which browser is used for authorization Some applications require explicit control over which browsers can be used for authorization - for example, to require that Chrome be used for second factor authentication to work, or require that some custom browser is used for authentication in an enterprise environment. Control over which browsers can be used can be achieved by defining a [BrowserMatcher](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/BrowserMatcher.java), and supplying this to the builder of AppAuthConfiguration. A BrowserMatcher is suppled with a [BrowserDescriptor](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/BrowserDescriptor.java) instance, and must decide whether this browser is permitted for the authorization flow. By default, [AnyBrowserMatcher](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/AnyBrowserMatcher.java) is used. For your convenience, utility classes to help define a browser matcher are provided, such as: - [Browsers](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/Browsers.java): contains a set of constants for the official package names and signatures of Chrome, Firefox and Samsung SBrowser. - [VersionedBrowserMatcher](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/VersionedBrowserMatcher.java): will match a browser if it has a matching package name and signature, and a version number within a defined [VersionRange](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/VersionRange.java). This class also provides some static instances for matching Chrome, Firefox and Samsung SBrowser. - [BrowserAllowList](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/BrowserAllowList.java): takes a list of BrowserMatcher instances, and will match a browser if any of these child BrowserMatcher instances signals a match. - [BrowserDenyList](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/BrowserDenyList.java): the inverse of BrowserAllowList - takes a list of browser matcher instances, and will match a browser if it _does not_ match any of these child BrowserMatcher instances. For instance, in order to restrict the authorization flow to using Chrome or SBrowser as a custom tab: ```java AppAuthConfiguration appAuthConfig = new AppAuthConfiguration.Builder() .setBrowserMatcher(new BrowserAllowList( VersionedBrowserMatcher.CHROME_CUSTOM_TAB, VersionedBrowserMatcher.SAMSUNG_CUSTOM_TAB)) .build(); AuthorizationService authService = new AuthorizationService(context, appAuthConfig); ``` Or, to prevent the use of a buggy version of the custom tabs in Samsung SBrowser: ```java AppAuthConfiguration appAuthConfig = new AppAuthConfiguration.Builder() .setBrowserMatcher(new BrowserDenyList( new VersionedBrowserMatcher( Browsers.SBrowser.PACKAGE_NAME, Browsers.SBrowser.SIGNATURE_SET, true, // when this browser is used via a custom tab VersionRange.atMost("5.3") ))) .build(); AuthorizationService authService = new AuthorizationService(context, appAuthConfig); ``` ### Customizing the connection builder for HTTP requests It can be desirable to customize how HTTP connections are made when performing token requests, for instance to use [certificate pinning](https://www.owasp.org/index.php/Certificate_and_Public_Key_Pinning) or to add additional trusted certificate authorities for an enterprise environment. This can be achieved in AppAuth by providing a custom [ConnectionBuilder](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/connectivity/ConnectionBuilder.java) instance. For example, to custom the SSL socket factory used, one could do the following: ```java AppAuthConfiguration appAuthConfig = new AppAuthConfiguration.Builder() .setConnectionBuilder(new ConnectionBuilder() { public HttpURLConnection openConnect(Uri uri) throws IOException { URL url = new URL(uri.toString()); HttpURLConnection connection = (HttpURLConnection) url.openConnection(); if (connection instanceof HttpsUrlConnection) { HttpsURLConnection connection = (HttpsURLConnection) connection; connection.setSSLSocketFactory(MySocketFactory.getInstance()); } } }) .build(); ``` ### Issues with [ID Token](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/IdToken.java#L118) validation ID Token validation was introduced in `0.8.0` but not all authorization servers or configurations support it correctly. - For testing environments [setSkipIssuerHttpsCheck](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AppAuthConfiguration.java#L129) can be used to bypass the fact the issuer needs to be HTTPS. ```java AppAuthConfiguration appAuthConfig = new AppAuthConfiguration.Builder() .setSkipIssuerHttpsCheck(true) .build() ``` - For services that don't support nonce[s] resulting in **IdTokenException** `Nonce mismatch` just set nonce to `null` on the `AuthorizationRequest`. Please consider **raising an issue** with your Identity Provider and removing this once it is fixed. ```java AuthorizationRequest authRequest = authRequestBuilder .setNonce(null) .build(); ``` ## Dynamic client registration AppAuth supports the [OAuth2 dynamic client registration protocol](https://tools.ietf.org/html/rfc7591). In order to dynamically register a client, create a [RegistrationRequest](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/RegistrationRequest.java) and dispatch it using [performRegistrationRequest](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java#L278) on your AuthorizationService instance. The registration endpoint can either be defined directly as part of your [AuthorizationServiceConfiguration](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationServiceConfiguration.java), or discovered from an OpenID Connect discovery document. ```java RegistrationRequest registrationRequest = new RegistrationRequest.Builder( serviceConfig, Arrays.asList(redirectUri)) .build(); ``` Requests are dispatched with the help of `AuthorizationService`. As this request is asynchronous the response is passed to a callback: ```java service.performRegistrationRequest( registrationRequest, new AuthorizationService.RegistrationResponseCallback() { @Override public void onRegistrationRequestCompleted( @Nullable RegistrationResponse resp, @Nullable AuthorizationException ex) { if (resp != null) { // registration succeeded, store the registration response AuthState state = new AuthState(resp); //proceed to authorization... } else { // registration failed, check ex for more details } } }); ``` ## Utilizing client secrets (DANGEROUS) We _strongly recommend_ you avoid using static client secrets in your native applications whenever possible. Client secrets derived via a dynamic client registration are safe to use, but static client secrets can be easily extracted from your apps and allow others to impersonate your app and steal user data. If client secrets must be used by the OAuth2 provider you are integrating with, we strongly recommend performing the code exchange step on your backend, where the client secret can be kept hidden. Having said this, in some cases using client secrets is unavoidable. In these cases, a [ClientAuthentication](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/ClientAuthentication.java) instance can be provided to AppAuth when performing a token request. This allows additional parameters (both HTTP headers and request body parameters) to be added to token requests. Two standard implementations of ClientAuthentication are provided: - [ClientSecretBasic](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/ClientSecretBasic.java): includes a client ID and client secret as an HTTP Basic Authorization header. - [ClientSecretPost](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/ClientSecretPost.java): includes a client ID and client secret as additional request parameters. So, in order to send a token request using HTTP basic authorization, one would write: ```java ClientAuthentication clientAuth = new ClientSecretBasic(MY_CLIENT_SECRET); TokenRequest req = ...; authService.performTokenRequest(req, clientAuth, callback); ``` This can also be done when using `performActionWithFreshTokens` on AuthState: ```java ClientAuthentication clientAuth = new ClientSecretPost(MY_CLIENT_SECRET); authState.performActionWithFreshTokens( authService, clientAuth, action); ``` ## Modifying or contributing to AppAuth This project requires the Android SDK for API level 25 (Nougat) to build, though the produced binaries only require API level 16 (Jellybean) to be used. We recommend that you fork and/or clone this repository to make modifications; downloading the source has been known to cause some developers problems. For contributors, see the additional instructions in [CONTRIBUTING.md](https://github.com/openid/AppAuth-Android/blob/master/CONTRIBUTING.md). ### Building from the Command line AppAuth for Android uses Gradle as its build system. In order to build the library and app binaries, run `./gradlew assemble`. The library AAR files are output to `library/build/outputs/aar`, while the demo app is output to `app/build/outputs/apk`. In order to run the tests and code analysis, run `./gradlew check`. ### Building from Android Studio In AndroidStudio, File -> New -> Import project. Select the root folder (the one with the `build.gradle` file).
heru299 / Script Copy-? Print this help message and exit -alertnotify=<cmd> Execute command when a relevant alert is received or we see a really long fork (%s in cmd is replaced by message) -assumevalid=<hex> If this block is in the chain assume that it and its ancestors are valid and potentially skip their script verification (0 to verify all, default: 0000000000000000000b9d2ec5a352ecba0592946514a92f14319dc2b367fc72, testnet: 000000000000006433d1efec504c53ca332b64963c425395515b01977bd7b3b0, signet: 0000002a1de0f46379358c1fd09906f7ac59adf3712323ed90eb59e4c183c020) -blockfilterindex=<type> Maintain an index of compact filters by block (default: 0, values: basic). If <type> is not supplied or if <type> = 1, indexes for all known types are enabled. -blocknotify=<cmd> Execute command when the best block changes (%s in cmd is replaced by block hash) -blockreconstructionextratxn=<n> Extra transactions to keep in memory for compact block reconstructions (default: 100) -blocksdir=<dir> Specify directory to hold blocks subdirectory for *.dat files (default: <datadir>) -blocksonly Whether to reject transactions from network peers. Automatic broadcast and rebroadcast of any transactions from inbound peers is disabled, unless the peer has the 'forcerelay' permission. RPC transactions are not affected. (default: 0) -conf=<file> Specify path to read-only configuration file. Relative paths will be prefixed by datadir location. (default: bitcoin.conf) -daemon Run in the background as a daemon and accept commands -datadir=<dir> Specify data directory -dbcache=<n> Maximum database cache size <n> MiB (4 to 16384, default: 450). In addition, unused mempool memory is shared for this cache (see -maxmempool). -debuglogfile=<file> Specify location of debug log file. Relative paths will be prefixed by a net-specific datadir location. (-nodebuglogfile to disable; default: debug.log) -includeconf=<file> Specify additional configuration file, relative to the -datadir path (only useable from configuration file, not command line) -loadblock=<file> Imports blocks from external file on startup -maxmempool=<n> Keep the transaction memory pool below <n> megabytes (default: 300) -maxorphantx=<n> Keep at most <n> unconnectable transactions in memory (default: 100) -mempoolexpiry=<n> Do not keep transactions in the mempool longer than <n> hours (default: 336) -par=<n> Set the number of script verification threads (-8 to 15, 0 = auto, <0 = leave that many cores free, default: 0) -persistmempool Whether to save the mempool on shutdown and load on restart (default: 1) -pid=<file> Specify pid file. Relative paths will be prefixed by a net-specific datadir location. (default: bitcoind.pid) -prune=<n> Reduce storage requirements by enabling pruning (deleting) of old blocks. This allows the pruneblockchain RPC to be called to delete specific blocks, and enables automatic pruning of old blocks if a target size in MiB is provided. This mode is incompatible with -txindex and -rescan. Warning: Reverting this setting requires re-downloading the entire blockchain. (default: 0 = disable pruning blocks, 1 = allow manual pruning via RPC, >=550 = automatically prune block files to stay under the specified target size in MiB) -reindex Rebuild chain state and block index from the blk*.dat files on disk -reindex-chainstate Rebuild chain state from the currently indexed blocks. When in pruning mode or if blocks on disk might be corrupted, use full -reindex instead. -settings=<file> Specify path to dynamic settings data file. Can be disabled with -nosettings. File is written at runtime and not meant to be edited by users (use bitcoin.conf instead for custom settings). Relative paths will be prefixed by datadir location. (default: settings.json) -startupnotify=<cmd> Execute command on startup. -sysperms Create new files with system default permissions, instead of umask 077 (only effective with disabled wallet functionality) -txindex Maintain a full transaction index, used by the getrawtransaction rpc call (default: 0) -version Print version and exit Connection options: -addnode=<ip> Add a node to connect to and attempt to keep the connection open (see the `addnode` RPC command help for more info). This option can be specified multiple times to add multiple nodes. -asmap=<file> Specify asn mapping used for bucketing of the peers (default: ip_asn.map). Relative paths will be prefixed by the net-specific datadir location. -bantime=<n> Default duration (in seconds) of manually configured bans (default: 86400) -bind=<addr>[:<port>][=onion] Bind to given address and always listen on it (default: 0.0.0.0). Use [host]:port notation for IPv6. Append =onion to tag any incoming connections to that address and port as incoming Tor connections (default: 127.0.0.1:8334=onion, testnet: 127.0.0.1:18334=onion, signet: 127.0.0.1:38334=onion, regtest: 127.0.0.1:18445=onion) -connect=<ip> Connect only to the specified node; -noconnect disables automatic connections (the rules for this peer are the same as for -addnode). This option can be specified multiple times to connect to multiple nodes. -discover Discover own IP addresses (default: 1 when listening and no -externalip or -proxy) -dns Allow DNS lookups for -addnode, -seednode and -connect (default: 1) -dnsseed Query for peer addresses via DNS lookup, if low on addresses (default: 1 unless -connect used) -externalip=<ip> Specify your own public address -forcednsseed Always query for peer addresses via DNS lookup (default: 0) -listen Accept connections from outside (default: 1 if no -proxy or -connect) -listenonion Automatically create Tor onion service (default: 1) -maxconnections=<n> Maintain at most <n> connections to peers (default: 125) -maxreceivebuffer=<n> Maximum per-connection receive buffer, <n>*1000 bytes (default: 5000) -maxsendbuffer=<n> Maximum per-connection send buffer, <n>*1000 bytes (default: 1000) -maxtimeadjustment Maximum allowed median peer time offset adjustment. Local perspective of time may be influenced by peers forward or backward by this amount. (default: 4200 seconds) -maxuploadtarget=<n> Tries to keep outbound traffic under the given target (in MiB per 24h). Limit does not apply to peers with 'download' permission. 0 = no limit (default: 0) -networkactive Enable all P2P network activity (default: 1). Can be changed by the setnetworkactive RPC command -onion=<ip:port> Use separate SOCKS5 proxy to reach peers via Tor onion services, set -noonion to disable (default: -proxy) -onlynet=<net> Make outgoing connections only through network <net> (ipv4, ipv6 or onion). Incoming connections are not affected by this option. This option can be specified multiple times to allow multiple networks. -peerblockfilters Serve compact block filters to peers per BIP 157 (default: 0) -peerbloomfilters Support filtering of blocks and transaction with bloom filters (default: 0) -permitbaremultisig Relay non-P2SH multisig (default: 1) -port=<port> Listen for connections on <port>. Nodes not using the default ports (default: 8333, testnet: 18333, signet: 38333, regtest: 18444) are unlikely to get incoming connections. -proxy=<ip:port> Connect through SOCKS5 proxy, set -noproxy to disable (default: disabled) -proxyrandomize Randomize credentials for every proxy connection. This enables Tor stream isolation (default: 1) -seednode=<ip> Connect to a node to retrieve peer addresses, and disconnect. This option can be specified multiple times to connect to multiple nodes. -timeout=<n> Specify connection timeout in milliseconds (minimum: 1, default: 5000) -torcontrol=<ip>:<port> Tor control port to use if onion listening enabled (default: 127.0.0.1:9051) -torpassword=<pass> Tor control port password (default: empty) -upnp Use UPnP to map the listening port (default: 0) -whitebind=<[permissions@]addr> Bind to the given address and add permission flags to the peers connecting to it. Use [host]:port notation for IPv6. Allowed permissions: bloomfilter (allow requesting BIP37 filtered blocks and transactions), noban (do not ban for misbehavior; implies download), forcerelay (relay transactions that are already in the mempool; implies relay), relay (relay even in -blocksonly mode, and unlimited transaction announcements), mempool (allow requesting BIP35 mempool contents), download (allow getheaders during IBD, no disconnect after maxuploadtarget limit), addr (responses to GETADDR avoid hitting the cache and contain random records with the most up-to-date info). Specify multiple permissions separated by commas (default: download,noban,mempool,relay). Can be specified multiple times. -whitelist=<[permissions@]IP address or network> Add permission flags to the peers connecting from the given IP address (e.g. 1.2.3.4) or CIDR-notated network (e.g. 1.2.3.0/24). Uses the same permissions as -whitebind. Can be specified multiple times. Wallet options: -addresstype What type of addresses to use ("legacy", "p2sh-segwit", or "bech32", default: "bech32") -avoidpartialspends Group outputs by address, selecting all or none, instead of selecting on a per-output basis. Privacy is improved as an address is only used once (unless someone sends to it after spending from it), but may result in slightly higher fees as suboptimal coin selection may result due to the added limitation (default: 0 (always enabled for wallets with "avoid_reuse" enabled)) -changetype What type of change to use ("legacy", "p2sh-segwit", or "bech32"). Default is same as -addresstype, except when -addresstype=p2sh-segwit a native segwit output is used when sending to a native segwit address) -disablewallet Do not load the wallet and disable wallet RPC calls -discardfee=<amt> The fee rate (in BTC/kB) that indicates your tolerance for discarding change by adding it to the fee (default: 0.0001). Note: An output is discarded if it is dust at this rate, but we will always discard up to the dust relay fee and a discard fee above that is limited by the fee estimate for the longest target -fallbackfee=<amt> A fee rate (in BTC/kB) that will be used when fee estimation has insufficient data. 0 to entirely disable the fallbackfee feature. (default: 0.00) -keypool=<n> Set key pool size to <n> (default: 1000). Warning: Smaller sizes may increase the risk of losing funds when restoring from an old backup, if none of the addresses in the original keypool have been used. -maxapsfee=<n> Spend up to this amount in additional (absolute) fees (in BTC) if it allows the use of partial spend avoidance (default: 0.00) -mintxfee=<amt> Fees (in BTC/kB) smaller than this are considered zero fee for transaction creation (default: 0.00001) -paytxfee=<amt> Fee (in BTC/kB) to add to transactions you send (default: 0.00) -rescan Rescan the block chain for missing wallet transactions on startup -spendzeroconfchange Spend unconfirmed change when sending transactions (default: 1) -txconfirmtarget=<n> If paytxfee is not set, include enough fee so transactions begin confirmation on average within n blocks (default: 6) -wallet=<path> Specify wallet path to load at startup. Can be used multiple times to load multiple wallets. Path is to a directory containing wallet data and log files. If the path is not absolute, it is interpreted relative to <walletdir>. This only loads existing wallets and does not create new ones. For backwards compatibility this also accepts names of existing top-level data files in <walletdir>. -walletbroadcast Make the wallet broadcast transactions (default: 1) -walletdir=<dir> Specify directory to hold wallets (default: <datadir>/wallets if it exists, otherwise <datadir>) -walletnotify=<cmd> Execute command when a wallet transaction changes. %s in cmd is replaced by TxID and %w is replaced by wallet name. %w is not currently implemented on windows. On systems where %w is supported, it should NOT be quoted because this would break shell escaping used to invoke the command. -walletrbf Send transactions with full-RBF opt-in enabled (RPC only, default: 0) ZeroMQ notification options: -zmqpubhashblock=<address> Enable publish hash block in <address> -zmqpubhashblockhwm=<n> Set publish hash block outbound message high water mark (default: 1000) -zmqpubhashtx=<address> Enable publish hash transaction in <address> -zmqpubhashtxhwm=<n> Set publish hash transaction outbound message high water mark (default: 1000) -zmqpubrawblock=<address> Enable publish raw block in <address> -zmqpubrawblockhwm=<n> Set publish raw block outbound message high water mark (default: 1000) -zmqpubrawtx=<address> Enable publish raw transaction in <address> -zmqpubrawtxhwm=<n> Set publish raw transaction outbound message high water mark (default: 1000) -zmqpubsequence=<address> Enable publish hash block and tx sequence in <address> -zmqpubsequencehwm=<n> Set publish hash sequence message high water mark (default: 1000) Debugging/Testing options: -debug=<category> Output debugging information (default: -nodebug, supplying <category> is optional). If <category> is not supplied or if <category> = 1, output all debugging information. <category> can be: net, tor, mempool, http, bench, zmq, walletdb, rpc, estimatefee, addrman, selectcoins, reindex, cmpctblock, rand, prune, proxy, mempoolrej, libevent, coindb, qt, leveldb, validation. -debugexclude=<category> Exclude debugging information for a category. Can be used in conjunction with -debug=1 to output debug logs for all categories except one or more specified categories. -help-debug Print help message with debugging options and exit -logips Include IP addresses in debug output (default: 0) -logthreadnames Prepend debug output with name of the originating thread (only available on platforms supporting thread_local) (default: 0) -logtimestamps Prepend debug output with timestamp (default: 1) -maxtxfee=<amt> Maximum total fees (in BTC) to use in a single wallet transaction; setting this too low may abort large transactions (default: 0.10) -printtoconsole Send trace/debug info to console (default: 1 when no -daemon. To disable logging to file, set -nodebuglogfile) -shrinkdebugfile Shrink debug.log file on client startup (default: 1 when no -debug) -uacomment=<cmt> Append comment to the user agent string Chain selection options: -chain=<chain> Use the chain <chain> (default: main). Allowed values: main, test, signet, regtest -signet Use the signet chain. Equivalent to -chain=signet. Note that the network is defined by the -signetchallenge parameter -signetchallenge Blocks must satisfy the given script to be considered valid (only for signet networks; defaults to the global default signet test network challenge) -signetseednode Specify a seed node for the signet network, in the hostname[:port] format, e.g. sig.net:1234 (may be used multiple times to specify multiple seed nodes; defaults to the global default signet test network seed node(s)) -testnet Use the test chain. Equivalent to -chain=test. Node relay options: -bytespersigop Equivalent bytes per sigop in transactions for relay and mining (default: 20) -datacarrier Relay and mine data carrier transactions (default: 1) -datacarriersize Maximum size of data in data carrier transactions we relay and mine (default: 83) -minrelaytxfee=<amt> Fees (in BTC/kB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: 0.00001) -whitelistforcerelay Add 'forcerelay' permission to whitelisted inbound peers with default permissions. This will relay transactions even if the transactions were already in the mempool. (default: 0) -whitelistrelay Add 'relay' permission to whitelisted inbound peers with default permissions. This will accept relayed transactions even when not relaying transactions (default: 1) Block creation options: -blockmaxweight=<n> Set maximum BIP141 block weight (default: 3996000) -blockmintxfee=<amt> Set lowest fee rate (in BTC/kB) for transactions to be included in block creation. (default: 0.00001) RPC server options: -rest Accept public REST requests (default: 0) -rpcallowip=<ip> Allow JSON-RPC connections from specified source. Valid for <ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). This option can be specified multiple times -rpcauth=<userpw> Username and HMAC-SHA-256 hashed password for JSON-RPC connections. The field <userpw> comes in the format: <USERNAME>:<SALT>$<HASH>. A canonical python script is included in share/rpcauth. The client then connects normally using the rpcuser=<USERNAME>/rpcpassword=<PASSWORD> pair of arguments. This option can be specified multiple times -rpcbind=<addr>[:port] Bind to given address to listen for JSON-RPC connections. Do not expose the RPC server to untrusted networks such as the public internet! This option is ignored unless -rpcallowip is also passed. Port is optional and overrides -rpcport. Use [host]:port notation for IPv6. This option can be specified multiple times (default: 127.0.0.1 and ::1 i.e., localhost) -rpccookiefile=<loc> Location of the auth cookie. Relative paths will be prefixed by a net-specific datadir location. (default: data dir) -rpcpassword=<pw> Password for JSON-RPC connections -rpcport=<port> Listen for JSON-RPC connections on <port> (default: 8332, testnet: 18332, signet: 38332, regtest: 18443) -rpcserialversion Sets the serialization of raw transaction or block hex returned in non-verbose mode, non-segwit(0) or segwit(1) (default: 1) -rpcthreads=<n> Set the number of threads to service RPC calls (default: 4) -rpcuser=<user> Username for JSON-RPC connections -rpcwhitelist=<whitelist> Set a whitelist to filter incoming RPC calls for a specific user. The field <whitelist> comes in the format: <USERNAME>:<rpc 1>,<rpc 2>,...,<rpc n>. If multiple whitelists are set for a given user, they are set-intersected. See -rpcwhitelistdefault documentation for information on default whitelist behavior. -rpcwhitelistdefault Sets default behavior for rpc whitelisting. Unless rpcwhitelistdefault is set to 0, if any -rpcwhitelist is set, the rpc server acts as if all rpc users are subject to empty-unless-otherwise-specified whitelists. If rpcwhitelistdefault is set to 1 and no -rpcwhitelist is set, rpc server acts as if all rpc users are subject to empty whitelists. -server Accept command line and JSON-RPC commands ~ $
simurgailab / An Enhanced Tooth Segmentation In Bitewing RadiographsThis study was published in 2022 in a scientific journal with SCI-Expanded index. The tooth numbering module uses the FDI notation, which is widely used by dentists, to classify and number dental items found as a result of segmentation. The performance of the Mask R–CNN method used has been proven by comparing it with other state-of-the-art methods.
Smoren / Array View PhpCreate array views for easy data manipulation, select elements using Python-like slice notation, enable efficient selection of elements using index lists and boolean masks.
Smoren / Array View TsCreate array views for easy data manipulation, select elements using Python-like slice notation, enable efficient selection of elements using index lists and boolean masks.
pointofsale / MongodbMongo db console commands //showing the existing dbs.. show dbs //use test switching to db test, (only creating it when actually adding new data) //prompts the name of the working db now db //the fllw would prompt the count(), in the link2 collection, in the current db... >db.links2.count() //inserting a record in links2 db.links2.insert({title:"unn titulo", url:"", comment:"", tags:["un primer tag", "un segundo tag"], saved_on: new Date}) //working with an object the javascript way... data = {} | data.title = "un titulo" | data.tags = ["un tag", "otro"] | data.meta = {} | data.meta.OS = "win7" | db.links2.insert(data) //printing the result of the find, in the structured json format. db.links2.find().forEach(printjson) //--> in this case we pass to forEach the printjson function... //retriving only the first of the results of the find method. db.links2.find()[0] db.links2.find()[0]._id //getting the timestamp present in the _id variable (is made of (also) the time it was created) db.links2.find()[0]._id.getTimestamp() /*the following function creates, when called, a new collection inside the same working db, that tracks the last id number we are in. This allows having the same behavieur than in relational DBs.*/ //apparently, u have to declare this function... function counter(name) { var ret = db.counter.findAndModify({query:{_id:name}, update:{$inc:{next:1}}, "new":true, upsert:true}); return ret.next; } //so u can do something like db.products.insert({_id:counter("products"), nombre:"primer nombre"}) //the result is something like: { "_id": 1, "name": "un producto" } { "_id": 2, "name": "otro producto" } /*referencing in MongoDB*/ db.users.insert({name:"Richard"}) var a = db.users.findOne({name:"Richard"}) db.links2.insert({title:"primer titulo", author:a._id}) //reference to other collection throught the _id key... //quering db.users.findOne({ _id:link.author }) //a way to make manual inner joins... within the user db, we search for a coincidence of our _ids on the links2 db, author field. ---note--- embedding is much more efficient when we have significantly more read than writes. Otherwise, consider using the normalized way. These depends on every case. /**/ #importing data from a .js in json format. With mongod running or in a services: > ../../../mongodb/bin/mongo 127.0.0.1/bookmarks bookmarks.js //the first part is the location to the mongo exe in the mongo usual location //the second part is the server and db in which we will be importing in //the third part is the file with all the mongo commands... --this bookmarks file is in C:\Tuto\mongo\trying -- https://raw.github.com/tuts-premium/learning-mongodb/master/08%20-%20bookmarks.js /*bookmarks.js extract*/ var u1 = db.users.findOne({ 'name.first': 'John' }), u2 = db.users.findOne({ 'name.first': 'Jane' }), u3 = db.users.findOne({ 'name.first': 'Bob' }); db.links.insert({ title: 'Nettuts+', url: 'http://net.tutsplus.com', comment: 'Great site for web dev tutorials', tags: ['tutorials', 'dev', 'code'], favourites: 100, userId: u1._id }); /**/ //connecting directly to db bookmarks > ../../../mongodb/bin/mongo bookmarks //searching in the collection all docs that have inside the tags array the "code" element. //this can be done because we are dealing with an array --> array advantages... db.users.find({tags:"code"}).forEach(printjson) //with findOne u can do (not with find) findOne().name db.links.find({favourites:100}, title:true, url:1) //selecting only some fields... db.links.find({favourites:100}, tags:0) //selecting all but the tag field... //selecting inside an object... db.users.findOne({"name.first": "John"}) db.users.findOne({"name.first": "John"}, "name.last":1) var john = db.users.findOne({"name.first": "John"}) db.links.find({userId:john._id}, {title:1, _id: 0}) /*queries directives*/ //greater than 150 db.links.find({favourites:{$gt:150}}, {_id:0, favourites:1, title:1}).forEach(printjson) db.links.find({favourites:{$gt:150}}, {_id:0, favourites:1, title:1}).count() //less than db.links.find({favourites:{$lt:150}}, {_id:0, favourites:1, title:1}).forEach(printjson) //$lte, $gte -- and iqual //using in db.users.find({"name.first":{$in:["John", "Jane"]}}) //the opposite is $nin db.users.find({"name.first":{$nin:["John", "Jane"]}}) //$all -- only the records with all the specifications in "tags" field. db.links.find({tags: {$all:["code", "marketplace"]}}, {title:1, tags:1, _id:0}) //$ne -- not equal //the $or flag search for the fullfillment of at least one of the elements in the array passed... db.users.find({$or: [{"name.first": "John"}, {"name.last": "Wilson"}]}) //the opposite: $nor //inclusive: $and //$exists db.users.find({email: {$exists: true}}) //$mod db.links.find({favourites: {$mod: [5, 0]}}, {_id:0, title:1, favourites:1}) db.links.find({favourites: {$not: {$mod: [5, 0]}}}, {_id:0, title:1, favourites:1}) //elemMatch -- inside logins, search for an element match that has minutes = 20, and return the complete record db.users.find({logins: {$elemMatch: {minutes: 20}}}) //searching for an 'at' prior to 2012/03/30.. and returning the whole record... db.users.find({logins: {$elemMatch: {at: { $lt: new Date(2012, 3, 30)}}}}) //using where -- c) is equivalent to a) a) db.users.find({ $where: 'this.name.first === "John"'}) b) db.users.find({ $where: 'this.name.first === "John"', age:30}) c) db.users.find( 'this.name.first === "John"') //injecting functions in mongodb -- as this example returns trueéfalse, its going to return values randomly var frand = function() {return Math.random() > 0.5} db.users.find(frand) // var f = function() { return this.name.first === "John"} db.users.find(f) //or db.users.find( {$where: f} ) //other queries //distinct -- returns a list of diff results db.links.distinct('favourites') --> [100, 32, 21, 78, ...] db.links.distinct("url") db.links.group({ key:{userId : true}, initial:{favCount: 0}, reduce: function (doc, o) {o.favCount += doc.favourites}, finalize: function(o) {o.name = db.users.findOne({ _id: o.userId}).name } }); *** //the final part is not working... db.links.group({ key:{userId : true}, initial:{favCount: 0}, reduce: function (doc, o) {o.favCount += doc.favourites} }); db.links.group({ key:{userId : true}, initial:{favCount: 0}, reduce: function (doc, o) {o.favCount += doc.favourites}, finalize: function(o) {o.name = "richard"}} ); //regex db.links.find({ title: /tuts\+$/}) db.links.find({ title: {regex: /tuts\+$/}}, {title:1}) //counting db.users.count({'name.first': 'John'}) db.users.count(); //all users in the collection //sorting, limit db.links.find({}, {title:1}).sort({title:1}).limit(1) //1: asc -1: desc //sorting, skipping and limiting... normal behavieur in the pagination rutine... db.links.find({}, {title:1, _id:0}).sort({title:1}).skip(3).limit(3) /*updating*/ //by replacement or by modification... ---general form /* db.collection.update( <query>, <update>, { upsert: <Boolean>, //if not found insert multi: <Boolean>, //change in all the condition <query> is fullfilled } ) */ // more info in http://docs.mongodb.org/manual/reference/method/db.collection.update/ db.users.update({-the query object-}, {-the update object-}, -upsert boolean-); var n = {title:"Nettuts+"} db.links.find(n, {title:1}) db.links.update(n, {$inc: {favourites: 5}}) var q = {"name.last": "Doe"} db.users.find(q, {name:1}) //we can use set to update a field or add a completly new one... db.users.update(q, {$set: {"name.last": "Doetix"}}) //modifying an existing field.. db.users.update(q, {$set: {"email": "doetix81@gmail.com"}}) //inserting a new one... //to remove a field w use unset db.users.update(q, {$unset: {job: "Web developper"}}) db.users.update({"name.first":"John"}, {$set: {job:"Web developer"}}, false, true) //modifying and then inserting an object var bob = db.users.findOne({"name.first":"Bob"}) >bob { "_id" : ObjectId("525f06242df9763abe646b62"), "name" : { "first" : "Bob", "last" : "Smith" }, "age" : 31, "email" : "bob.smith@gmail.com", "passwordHash" : "last_password_hash" } > bob.job = "Thick Brush Painter" > db.users.save(bob) //find and modify -- findAndModify {{}} /* The findAndModify command atomically modifies and returns a single document. By default, the returned document does not include the modifications made on the update. To return the document with the modifications made on the update, use the new option. { findAndModify: <string>, query: <document>, sort: <document>, remove: <boolean>, //one of | update: <document>, //this two | new: <boolean>, //if the new object must be shown or the old one.. fields: <document>, //fields to show in the result upsert: <boolean> } */ > db.links.findAndModify({ query:{favourites: {$gt:150}}, sort:{title:1}, update:{favourites: 333}, new: true, fields: {_id:0} }); //pulling into arrays db.links.update(n, { $push: {tags: "jobs"}}) > db.links.findOne(n).tags //several... db.links.update(n, {$pushAll:{tags: ['blogs','press','contests']}}) //on pull into the array if the new element is not present.. db.links.update(n, {$addToSet:{tags: "dev"}}) //doing the same with an array... db.links.update(n, {$addToSet:{ tags:{$each: ["dev", "interviews"]} }}) //pulling out content from the array... db.links.update(n, {$pull: {tags:'interviews'}}) //pulling several... db.links.update(n, {$pullAll: {tags: ['blogs','dev', 'contests']}}) //poping out from the beginning or the end.. db.links.update(n, {$pop: {tags: 1}}) //--from the end (-1 -- from the beginning) //positional operator... only the subobject gets updated... db.users.update({'logins.minutes': 20} , {$inc:{ 'logins.$.minutes': 10}}, false, true) db.users.update({'logins.minutes': 20} , {$set:{ 'logins.$.location': 10}}, false, true) db.users.update({'logins.minutes': 30}, {$set: {random: true}}, false, true) //renaming the fields name... db.links.update({url: {$exists: true}}, {$rename:{"url": "camino"}}, false, true); //more info on the positional operator in: http://docs.mongodb.org/manual/reference/operator/update/positional/ //taken from there: /* The positional $ operator facilitates updates to arrays that contain embedded documents. Use the positional $ operator to access the fields in the embedded documents with the dot notation on the $ operator. db.collection.update( { <query selector> }, { <update operator>: { "array.$.field" : value } } ) */ /***EXAMPLE Consider the following document in the students collection whose grades field value is an array of embedded documents: { "_id" : 4, "grades" : [ { grade: 80, mean: 75, std: 8 }, { grade: 85, mean: 90, std: 5 }, { grade: 90, mean: 85, std: 3 } ] } Use the positional $ operator to update the value of the std field in the embedded document with the grade of 85: db.students.update( { _id: 4, "grades.grade": 85 }, { $set: { "grades.$.std" : 6 } } ) ***/ //removing db.users.remove({'name.first': "John"}) //all the collections in the selected db... show collections //dropping completly a collection... db.acoll.drop() //indexes... db.links.find().explain db.links.ensureIndex({ title: 1}) //in ascending order.. in mainly important in cpompund indexes.. //a reflect of this index can be found in that db indexes collection db.system.indexes.find(); //u cound put an index to a canging value, but every time u change that value the index must be updated. keep in mind. //usually is a good idea to set the indexes at the beginning when no data is present in the collections. However, u could use the following formula to treat duplicates and unique data //keeping only the first one, deleting the others.. db.links.ensureIndex({ title: 1}, { unique: true, dropDups: true}) //when considering the case of some of the documents without the idexed field, to save mongo from storing space for this index if the field itself has not been inserted: db.links.ensureIndex({ title: 1}, {sparse: true}) //its important to think of the compund index as a nested one, an index of an index. Its related to each problem-case. Like in the case of the recepies: indexing first the ingredient and the the recepie, makes more sense than indexing in reverse. Its all related on how u are going to search. db.links.ensureIndex({ title: 1, url: 1}) //this one means that u can search on title; or on title and url... db.links.ensureIndex({ a: 1, b: 1, c: 1}) //searches are possible on a; a, b; a, b, c //deleting indexes db.links.dropIndex("title_1"); //the same way that appears in system.index collection... /*concepts to follow*/ //Sharding and Replica Set... http://www.slideshare.net/Dataversity/common-mongodb-use-cases-13695677 http://docs.mongodb.org/ecosystem/use-cases/product-catalog/ db.collection.update({"grades.grade":80}, { $set: {"grades.$.std": 18}})
malikturkoglu / Cache SimilatorYou must run this project on a 64-bit x86-64 machine. You will need the trace files in traces.rar and the RAM image in RAM.dat. 3 Description In this project, you will write a cache simulator which takes an image of memory and a memory trace as input, simulates the hit/miss behavior of a cache memory on this trace, and outputs the total number of hits, misses, and evictions for each cache type along with the content of each cache at the end. Your simulator will take the following command-line arguments: Usage: ./your_simulator -L1s <L1s> -L1E <L1E> -L1b <L1b> -L2s <L2s> -L2E <L2E> -L2b <L2b> -t <tracefile> • -L1Ds <L1Ds>: Number of set index bits for L1 data/instruction cache (S = 2s is the number of sets) • -L1DE <L1DE>: Associativity for L1 data/instruction cache (number of lines per set) • -L1Db <L1Db>: Number of block bits for L1 data/instruction cache (B = 2b is the block size) • -L2s <L2s>: Number of set index bits for L2 cache (S = 2s is the number of sets) • -L2E <L2E>: Associativity for L2 cache (number of lines per set) • -L2b <L2b>: Number of block bits for L2 cache (B = 2b is the block size) • -t <tracefile>: Name of the trace file (see Reference Trace Files part below) The command-line arguments are based on the notation (s, E, and b) from page 652 of the CS:APP3e textbook. The s, E, and b values will be the same for both L1 data and instruction caches. For example, if you want to simulate a fully associative (s=0) L1 cache of 2 lines (E=2) and 8 blocks (b=3), and a 2-way set associative (E=2) L2 cache of 2 sets (s=1) and 8 blocks (b=3), and see the results for the trace file test1.trace, you will run your program with the arguments given in the following example. Also, the results should be in the given format. linux> ./your_simulator -L1s 0 -L1E 2 -L1b 3 -L2s 1 -L2E 2 -L2b 3 -t test1.trace L1I-hits:0 L1I-misses:1 L1I-evictions:0 L1D-hits:1 L1D-misses:1 L1D-evictions:0 L2-hits:1 L2-misses:2 L2-evictions:0 L 5, 3 L1D miss, L2 miss Place in L2 set 0, L1D I 10, 8 L1I miss, L2 miss Place in L2 set 0, L1I S 0, 1, ab L1D hit, L2 hit Store in L1D, L2, RAMProgramming Rules • You can use any either Java or C. • Name of your source code file should include your name like yournamesurname.c • Your code must compile without warnings in order to receive credit. • Your simulator must work correctly for different sets of s, E, and b values for each cache type. This means that you will need to allocate storage for your simulator’s data structures using the malloc function. Type “man malloc” for information about this function. • For this project, we are interested in L1 data cache, L1 instruction cache, and unified L2 cache performance. • Each of the caches will implement write-through and no write allocate mechanism for store and modify instructions. • For the evictions, FIFO (first in first out) policy will be used. • To receive credit, for each cache (L1D, L1I, L2), you must print the total number of hits, misses, and evictions, at the end of your program. • For this project, you should assume that memory accesses are aligned properly, such that a single memory access never crosses block boundaries (Read and write requests are less than or equal to block size). • We will hand you sample RAM image for testing. For each Miss in the caches you can fetch the data from the binary file “RAM.dat”. This file is a byte file that includes the contents of the memory in the beginning of the execution. • The contents of the caches at the end of the execution will be written to the corresponding byte file for each cache. Reference Trace Files The traces subdirectory of the handout directory contains a collection of reference trace files that we will use to evaluate the correctness of the cache simulator you write. The memory trace files have the following form: M 000ebe20, 3, 58a35a L 000eaa30, 6 S 0003b020, 7, abb2cdc69bb454 I 00002010, 6 Each line denotes one or two memory accesses. The format of each line for I and L: operation address, size The format of each line for M and S: operation address, size, data The operation field denotes the type of memory access: “I” denotes an instruction load, “L” a data load, “S” a data store, and “M” a data modify (i.e., a data load followed by a data store). The address field specifies a 32-bit hexadecimal memory address. The size field specifies the number of bytes accessed by the operation. The data field specifies the data bytes stored in the given address.EXAMPLE RUN: test1.trace: L 5, 3 I 10, 8 S 0, 1, ab
