DEV Community: chinmay chhajed

Android vs iOS

chinmay chhajed — Fri, 30 Aug 2024 19:30:16 +0000

After using Android phones for almost all the years and iPhone for about 3 months, here is an analysis comparing the features of both. I have used stock Android on Pixel and iOS on iPhone 15 Pro, so best of both worlds.

A big factor in this comparison is that it just discusses the features of Android and iOS, not the complete infrastructure. I am pretty sure that if you add a Macbook, Airpods, and an iPad, the table might look way different.

The following comparison lists Android 14 vs iOS 17.6 (just a few days before the release of iOS 18).

Category	Android	iOS
Notifications	1 (+)	0
Widgets	2 (+)	0
Shortcuts/Automation 2 (N/A)	1(+)
Auto-complete	3 (+)	1
Keyboard navigation	3	2 (+)
Volume Control	4 (+)	2
Finger print/Face ID	4	3 (+)
Shazam/Music Recognition	5 (+)	3
Google Photos*	6 (+)	3
CarPlay/Android Auto*	6	4 (+)
Display	6	5 (+)
Action button	6	6 (+)
Navigation (Home, back, clear all)	7 (+)	6
App Management (Force Quit, Disable,clear memory, etc.)	8 (+)	6
Air Drop/Quick Share	9 (+)	7 (+)
Messaging/Web support*	10 (+)	7
Launcher/Home screen customization flexibility	11 (+)	7
Browser Support*	12 (+)	7
Bluetooth Audio*	13 (+)	7

*Google Photos: Cannot select which albums to back up on iOS. iPhone backs up just everything.
*CarPlay: Personal preference. Just has better connectivity and UI.
*Messaging: RCS Messaging can be opened on any browser, and any machine, however, iMessage can only be opened on Macbooks.
*Browser Support: Everything on iOS runs the Safari engine in the back, so, browser cannot add its own new features.
*Bluetooth Audio: Same Bluetooth piece, same streaming app, but still those beats were more vibrant in Android.

Simple ransomware in Python

chinmay chhajed — Tue, 14 Jun 2022 03:31:02 +0000

A ransomware is a piece of code that encrypts files and denies user access. The files can only be decrypted with the key used while encryption.

In this project, Python's Fernet module is used to generate keys, encrypt, and decrypt files.

encrypt.py first generates a key (key.key file). This is being done by Fernet.generate_key(). The key.key file stores the key which will be used to encrypt and further decrypt files. encrypt.py recursively iterates and encrypts all the files present in the root_dir. During encryption, we need to make sure that we are not encrypting the keys or the script used for encryption, or else that might have not end up well.

decrypt.py iterates through files similar to encrypt.py. Just the difference is that instead of encrypting, it decrypts all the files using same key which was generated during encryption. Without that key, decryption wouldn't work.

For recursively iterating files during encryption and decryption, FileLister is being used, which is just simple recursive way of listing all the files in a given directory.

Usage

For encryption, either give no arguments to run throughout test_dir or give specific path:

For specific set of files:

Decryption:

For specific set of files:

Project link: https://github.com/chhajedji/ransomware

Example showing usage of LD_PRELOAD environment variable in UNIX

chinmay chhajed — Fri, 29 Apr 2022 15:16:00 +0000

LD_PRELOAD

We can use LD_PRELOAD environment variable to set a location to fetch shared libraries. By setting this variable, we can overwrite the existing functions and make the standard command work differently, the way we want it to.

The linker links the libraries in the path provided by LD_PRELOAD for compiling the main file. Once a function is linked, when other instance of same function shows up, older location is ignored and the newer location is used.

For example, let us try to overwrite the puts function present in stdio.h file.

Consider a file main.c, with following content:



  #include <stdio.h>

  int theFunction(const char *s)
  {
      return puts(s);
  }

  int main (int argc, char** argv) {
      theFunction("Hello, this is traditional work flow.");
      printf("%s: puts location: %p\n", __FILE__, puts);
  }

Compiling and running the main.c file gives following output with location of puts as 0x7f877af52ef0.

Create another file, unmain.c as follows:



  #include <stdio.h>

  int puts(const char *__s)
  {
      return printf("New puts, hackerman alert!\n");
  }

Now, create a shared library of this unmain.c file with command:



  gcc -fPIC unmain.c -shared -o unmain.so

Update the LD_PRELOAD with the location of the shared library, unmain.so:



  export LD_PRELOAD="$PWD/unmain.so"

And then again run the first compiled main.c file's executable main.o to see that the location of the puts has been updated. For my case, new location has been set to 0x7f6003f5d119.



  ./main.o

To remove the shared library, use unset to unset value of
LD_PRELOAD.



  unset LD_PRELOAD

Same example to contribute on Github: https://github.com/chhajedji/ld-preload

Make fzf your best friend inside terminal

chinmay chhajed — Sat, 05 Jun 2021 11:56:28 +0000

Fuzzy finder is one of the best tool which you can use for speeding up your daily terminal work flow. In my daily workflow, I have integrated fzf in most of the tasks where I have many choices and have to choose one among them, whether be it changing a git branch, searching and opening a file, changing directory or changing a project.

Let's get started to exploit some features of fzf 😈

Install

Probably your package manager already has it. If it doesn't, don't worry, just clone the git repo and run the install script as directed here.

You can check if the installation has been successful by running the command whereis fzf. You should see the location of binary.

Make sure to read the README.md from the project's Github. It explains fzf and some of it's usage quite well. Specially the key-binding part, where you can map Ctrl-t to paste the selected files and directories onto the command-line, Alt-c for changing directories and Ctrl-r for fuzzy reverse searching. Also if you happen to use vim, you may check the vim extension for same.

Some other usage

Changing git projects

Add the following alias in your bashrc:

# Find and save location of all git repositories present in $HOME.
# Try using `fd', if not installed then use default `find'.
alias repoup="fd -HI ^\.git$ $HOME 2>/dev/null > $HOME/.tmp/gitfiles || find $HOME/ -regex .*/\.git$ 2>/dev/null > $HOME/.tmp/gitfiles"

If you happen to use fd (which definitely you should), this command will be completed in a wink.

Executing this alias will use search path of all git repositories stored inside HOME and list them in file at ~/.tmp/gitfiles. This file will be further used with fzf.

Make sure to execute this alias whenever you add a new git repository in your system. This will update the paths of all git repositories, specially the newly added one.

Next, add this function in your bashrc file:

gotoprj() {
    REPOS="$(cat $HOME/.tmp/gitfiles | xargs dirname  | sed s:/home/$USER:~: | fzf)"

# Cut the '~/' part from the `REPOS'.
        REPOS="$(echo $REPOS | cut -d '/' -f2-)"

# If user selected any repo then open `$TERMINAL' in that repo.
        [ "$REPOS" = "" ] || cd $HOME/$REPOS
}

This will list all the git repositories present in our database created in last step (~/.tmp/gitfiles) , and change current directory to that repository.

Switch to any directory

As simple as said in title, from any current directory, switch to any directory in you system by just typing the keywords you remember specific to target directory. Have this function in your bashrc:

sd() {
    TARGET="$({ fd . $HOME --type directory -HI 2>/dev/null || find $HOME -type d 2>/dev/null; } | fzf)"
        [ -n "$TARGET" ] && cd "$TARGET" && ls
}

Now whenever you want to go to any directory, instead of giving it's full path, just hit sd and give the directory name and few unique words in it's path, and Tada 🎉! No need to enter that ugly full path.

Change git branch

Many times it happens that I forget the branch name I want to switch to. Again, doing it with fzf saves the pain for searching the branch name. What can be done is add following section in your gitconfig file which should be present at $HOME/.gitconfig.

[alias]
    ; switch git local branches using fzf
    sb="!switch_branch_fzf() { git branch | fzf | xargs git checkout; }; switch_branch_fzf"

Note that since we are using git branch, it will only list the branches you have previously checked out. New branches will not appear in the finder.

Usage

git sb

This will list all the git branches in fzf and now we can search for the target branch with ease.

Once you get the idea of using the fuzzy finder, you can modify it to find anything which you need to search on regular basis. For example, if you have a location where you store all the scripts which you edit frequently, you can have a function to list all of them into fzf and then open the selected one in your editor. These were just some of the exploits I use. If you have anything more to suggest, add it in the comments.

Why to `find` files when you can `fd` them ;)

chinmay chhajed — Thu, 11 Mar 2021 09:35:44 +0000

If you happen to be a frequent terminal user, you must be using the GNU find command to know the location of files. But as the number of files increase, you can see a significant increase in runtime of find. This is where the younger sibling fd comes in picture ;)

According to the README of the project, some highlights of fd are:

Very fast due to parallelized directory traversal.
Uses colors to highlight different file types (same as ls).
The command name is 50% shorter than find :-)

For installation, most package managers like brew, apt, dnf, pacman, emerge, zypper and others have fd package so you can just run the standard installation command. For more details, see the installation guide for your system.

Note that for Debian based distros like Ubuntu and others, you will have to install fdfind because fd is already used by a different package. You can see the guide how to use fd on Ubuntu instead of fdfind. Spoiler alert: It's not about creating alias. xD

Personally, I am very impressed with the speed of fd. When I had to wait for few seconds for find to finish, fd does the work within a second. Also, if you know regex , fd is a big blessing as it uses regex for searching.

Coming to some numbers from comparison:

Number of all .png files in my home directory searched with find:

# Do a regex search with `find` with ignoring case
# and piping output to `wc -l` which will count number
# of lines in result 
find ~/ -iregex '.*\.png$' 2>/dev/null | wc -l
# 13530 results found

Number of all .png files in my home directory searched with fd:

# Same regex, but now with `fd`
# -H flag to search in hidden directories
# -I to not ignore any files. `fd` ignores files like
# .gitignore, .ignore, .fdignore

fd -HI '.*\.png$' ~/ 2>/dev/null | wc -l
# 13530 results found

So the number of results are same in both cases.

Now let's see the time taken for each command.

find:

time (find ~/ -iregex '.*\.png$' >/dev/null 2>&1)

# real    0m3.892s
# user    0m2.944s
# sys     0m0.937s

fd:

time (fd -HI '.*\.png$' >/dev/null 2>&1)

# real    0m0.607s
# user    0m2.110s
# sys     0m1.779s

As you can see, fd is more than 6 times faster than the GNU find. When you find files frequently, the time saved is quite significant! Experiencing the power of fd can be easily done with other programs like fzf and dmenu which I'll keep for another post ;).

Screenshots of above commands and their outputs for my system:

Transfer files between your phone and computer without any cable and internet!

chinmay chhajed — Mon, 22 Feb 2021 08:53:35 +0000

Isn't it tedious to always reach out for a USB cable and then connect phone with computer, wait while computer detects, then browse for files and then finally transfer! What a pain to do so many steps.

Worry not, here is a wireless solution to copy data from one device to other. All you need is Python and a supporting mobile app!

To do this, we will be using a simple concept: HTTP Server and Client. A server will be source of files and a client will be the one copying files from server.

Since we will be transferring files wireless, we need to connect mobile and computer to a common WiFi router. If you don't have a router, turn hotspot on from your mobile and connect your computer to it.

Transfer files from computer to phone

Make sure you have python installed. If not then first install python.
Next step is to check version of python. Open a terminal (or command prompt on Windows) and run python --version
If you have a python version starting from 3.x, then run the command python -m http.server in terminal.
If your python version is 2.x then run python -m SimpleHTTPServer

Output should look something like this in both the cases:

Next get the private IP address of your machine.
- For Windows, open command prompt and run ipconfig. Your local IP address will be listed under ‘IPv4 Address’.
- For Linux and Mac, open terminal and run command ifconfig. In the resulting information spewed out, we are looking for the section starting with wl. It could be wlp3s0 or something else. Basically it denotes wireless lan. Under this section, we need address after inet. In my case, it's 192.168.10.11.
Once we have the IP address, go to the browser in your phone and enter that address with a :8000 at the end in address bar. This 8000 comes from the output of python -m http.server command. As you can see in above image, default port is 8000. For my case, I would enter 192.168.10.11:8000 in my mobile browser and go to the link. Once the page loads, congrats, you may navigate to the file and download it.
If page doesn't load in mobile browser, make sure that you do not have a https:// at start of URL. If present then remove it.

Mobile browser for my case:

Bonus: If you need a specific file, then in terminal navigate to the directory where file is present and run the python server command in that directory. Python server will start from which ever directory command is executed.

Transfer files from phone to computer

For this you will need a mobile app to run HTTP Server like this or any other app. Just open the app and run the server. For this app, click on "off" to turn the server on.
- Open the link given on computer browser. From above screenshot, 192.168.10.2:12345/. And done! Browser files present in your phone from your computer.

Bash: Edit command in your editor and execute directly

chinmay chhajed — Sat, 20 Feb 2021 14:04:11 +0000

Sometimes we need to enter same command multiple times by changing 1 or 2 arguments. This is very tedious job to do. Update and execute command every single time!

But worry not as what you are going to see in next few minutes will act as a big time savior in such cases.

If you use shell in default mode (emacs if you don't know :P), you can press ctrl-x ctrl-e and enter text editor to edit all the commands together by using features of your editor like copy, paste visually select etc. Save and exit editor to execute all the commands.

If you are using vi mode, you can move to normal mode by pressing Esc and then pressing v would achieve similar functionality.

You can switch between vi and emacs mode by commands set -o vi and set -o emacs respectively. Your keybindings will work according to your mode.

For my work, I use this script poolfetch a lot with arguments varying only 1 or 2 characters. This functionality is very handy for me at such times.

Here is a sample usage of this feature in emacs mode:

Edit:

As suggested by Tai Kedzierski here, you can choose the editor in which you want to edit commands by setting environment variable EDITOR or VISUAL.

It's a good idea to set them in $HOME/.bashrc or $HOME/.profile. Former one will set it for every bash instance and latter one will set it globally which will be done at time of system startup. I prefer latter one.

Minimal and super useful shell prompt

chinmay chhajed — Sat, 20 Feb 2021 11:54:48 +0000

Primary shell prompt can be set by setting PS1 variable in shell's config file. Let's consider bash as our shell.

Setting PS1 can be as simple as this



PS1="prompt $"
# prompt $
echo value of PS1 is $PS1
# value of PS1 is prompt $

To keep the changes permanent for our every terminal instant, add we will be updating our .bashrc file located at $HOME/.bashrc

Useful details in a shell prompt could be

You can go through above articles to add respective details in the prompt.

If you are someone who likes colors more than text, we have a better option ;) We can differentiate the error and success of command by a different colors. When interested in error code, we can just print it with echo $?. I will choose red color when previous command returned error and white when all is well :)

For our purpose, we will use 2 colors, bold red and bold white using tput



# Red
bldred="$(tput setaf 1 2>/dev/null)$(tput bold 2>/dev/null)"
# White
bldwht="$(tput setaf 7 2>/dev/null)$(tput bold 2>/dev/null)"

And to reset colors to normal:



# Reset
txtrst="$(tput sgr 0 2>/dev/null)"

Here are other variables for color codes set using tput.

Our final function setting prompt would look something like this:



# Depth of `$PWD` is decided by this.
export PROMPT_DIRTRIM=2

# `exit_code' Should be first command in `PROMPT_COMMAND' to be
# executed or else return status will always be 0/true (If functions in
# `PROMPT_COMMAND' are written proper :)
[ -n "$PROMPT_COMMAND" ] && PROMPT_COMMAND="exit_code;$PROMPT_COMMAND" ||
    PROMPT_COMMAND="exit_code"

exit_code() {
    EXIT="$?"

    # PS1 needs to be reset or else it will be appended every time to
    # previous one.
    PS1=""

    [ "$EXIT" = "0" ] && EXITCOL=$bldwht || EXITCOL=$bldred

    # This will be final prompt, whatever set earlier will be
    # overwritten by this.
    export PS1="\[\$EXITCOL\]\w\[\033[01;38;5;208m\]\$([ \j -gt 0 ] && echo [\j])\[\$txtrst\]$ "
```
Here we are using `EXITCOL` to set red/white color deciding upon return status and number of background jobs are displayed in orange color.

Setting colors in bash prompt is a bit lengthy process to explain, but in short, you can copy-paste [content of this file](https://github.com/chhajedji/dot-files/blob/master/T480/.bash/colors.sh) in your `.bashrc` and add the required color within `\[$` and `\]`. For example, for regular green, you can use `\[$txtgrn\]`. Also don't forget to reset the text after setting or else all text would appear in the applied color.

By this way of using colors, we can set various colors for different parts of prompt.

Screenshot highlighting different part after setting above prompt:

![alt text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qkefa3em0nvuz7t62nxc.png)

I like this shell prompt as it is minimal prompt displaying only useful information and also not eating up whole terminal space.

Add return of last command to your shell prompt

chinmay chhajed — Sat, 20 Feb 2021 11:10:45 +0000

Whenever we execute a shell command, it returns an integer value. When this value is 0, last command was a success. Any other number is the error code. We can see the return of last command by printing the value of ? variable.

To test this:

Enter command ls
Check it's return by command echo $?
Enter some random letters and press Enter
Check return by echo $?

You should get an error in the second time when you enter some random command

chinmay@CC-T480:~/Desktop$ ls
file
chinmay@CC-T480:~/Desktop$ echo $?
0    <-- Success
chinmay@CC-T480:~/Desktop$ a
a: command not found
chinmay@CC-T480:~/Desktop$ echo $?
127  <-- Error code

We will use this $? value in our prompt to see if our last command has passed or failed.

We also need to know about environment variable PROMPT_COMMAND. Bash provides an environment variable called PROMPT_COMMAND. The contents of this variable are executed as a regular Bash command just before Bash displays a prompt.

Since our bash prompt should contain status of last command, it should be set inside PROMPT_COMMAND.

First we will write a simple shell function to update the prompt with return code.

exit_code() {
    # Save the exit status of last command. This
    # needs to be done first otherwise exit status of
    # other commands will be stored in this variable.
    EXIT="$?"

    # PS1 needs to be reset or else it will
    # be appended every time to previous one.
    PS1=""

    # This will be final prompt, whatever set earlier will be
    # overwritten by this.
    export PS1="$EXIT \w $ "
}

Then we can add this function to our PROMPT_COMMAND

# exit_code Should be first command in `PROMPT_COMMAND' to be executed or # else return status will always be 0/true as it will hold return status of
# previous command.

# First we check if prompt command is empty or not.
# If empty, just add `exit_code' to it. If non empty,
# make it `exit_code:$PROMPT_COMMAND'
[ -n "$PROMPT_COMMAND" ] && PROMPT_COMMAND="exit_code;$PROMPT_COMMAND" ||
    PROMPT_COMMAND="exit_code"

After adding the above 2 snippets in your .bashrc, you get something like this:

chinmay@CC-T480:~$ exit_code() {
>     EXIT="$?"
>     PS1=""
>     export PS1="$EXIT \w $ "
> }
chinmay@CC-T480:~$ PROMPT_COMMAND="exit_code"
0 ~ $ ls Desktop/
file
0 ~ $ ^C
130 ~ $ a
a: command not found
127 ~ $ echo $?
127
0 ~ $ echo $?    # return of last echo command
0
0 ~ $

Note that the first number in our prompt is the return status of last command. For ls, we see a 0 as it ran as expected. When I ran command a, bash threw an error saying command not found and it's error code is 127 which we can see in next line. For pressing ctrl-c, we can see error code as 130.

Checkout designing a minimal bash prompt.

Add background jobs to your shell prompt

chinmay chhajed — Sat, 20 Feb 2021 10:24:12 +0000

If you know what are background processes, you can directly proceed to see Setting the prompt.

Background processes

Whenever we execute a time taking command, we don't see the prompt till the time command finishes. For example, when we execute sleep 5s, shell will do nothing for 5 seconds but wait for the command (sleep) to finish. After 5 seconds, we will see the prompt again.

Many times, commands are not worthy to wait till they finish their processing. For example, when you are compiling a project and it takes about a minute to complete. You can run the build in background by using & at the end of command and you will be notified when background job is completed.

chinmay@CC-T480:~$ sleep 5 &
[1] 3683711
chinmay@CC-T480:~$ # After 5 seconds when we press Enter
[1]+  Done                    sleep 5
chinmay@CC-T480:~$

Here what we did was put sleep 5 task in background and we got the background process ID that is 3683711. After 5 or more seconds when we enter a new command just press Enter, we see that the background job sleep 5 is completed by seeing Done sleep 5.

When building a project we can send the build process in background and while waiting for it to complete, we can do some other task. If we are using make to build a project and it takes about a minute to complete, we can use make >/dev/null 2>&1 & to build in background and not display any info/error logs while also making the shell prompt usable to give other commands.

We can also stop a process by hitting Ctrl-Z and this will also send the task in background. But in this case, task will not run in background but will be stopped until resumed by command fg in same terminal. We can see the background tasks by command jobs.

03:26:34 $ sleep 10
^Z
[1]+  Stopped                 sleep 10
03:26:36 $ jobs
[1]+  Stopped                 sleep 10
03:26:38 $ fg
sleep 10
03:26:45 $ jobs
03:26:47 $

Another common use of sending task to background is while using vim or other terminal based editor. When we need to run some commands in terminal, we can just hit ctrl-z in normal mode and vim will be stopped. This way we can have our terminal prompt for running commands. When done with terminal, we can switch back to vim by fg command.

Setting the prompt

Bash prompt can be set by setting the environment variable PS1. We will update this variable to get number of background jobs in our prompt.

If we see manual page for bash, we can see that it says we can use \j to show number of jobs

\j     the number of jobs currently managed by the shell

But most of the times we have 0 jobs running in background and displaying a 0 every time is not so tidy approach.

We can use a simple bash command to print the jobs in the prompt if they are more than 0.

[ \j -gt 0 ] && echo \j

Here \j is the number of background jobs. What we are doing is checking if it's greater than 0, if yes, then print (echo) in the prompt else not.

A simple shell prompt including the current directory and number of background processes can be like

chinmay@CC-T480:~/Downloads$ PS1="\w\$([ \j -gt 0 ] && echo [\j]) $ "
~/Downloads $ sleep 10
^Z
[1]+  Stopped                 sleep 10
~/Downloads[1] $ sleep 15
^Z
[2]+  Stopped                 sleep 15
~/Downloads[2] $ vi

[3]+  Stopped                 vi
~/Downloads[3] $ jobs
[1]   Stopped                 sleep 10
[2]-  Stopped                 sleep 15
[3]+  Stopped                 vi
~/Downloads[3] $ fg 2
sleep 15
~/Downloads[2] $ fg 1
sleep 10
~/Downloads[1] $ fg
vi
~/Downloads $

Here the number of background processes will be listed inside square brackets.

Checkout designing a minimal bash prompt.

Add time stamp in your shell prompt

chinmay chhajed — Sat, 20 Feb 2021 06:00:12 +0000

Bash prompt can be set by setting the environment variable PS1. We need to update this variable to get time in our prompt.

There are 4 ways to get the time in prompt. If you see manual page for bash, you can see time can be set using:

\t     the current time in 24-hour HH:MM:SS format
\T     the current time in 12-hour HH:MM:SS format
\@     the current time in 12-hour am/pm format
\A     the current time in 24-hour HH:MM format

Note that the time is not the current time but the time when prompt was last updated. Prompt will be updated when previous command completed.

Sample usage:

PS1="\t $ "   # 11:13:54 $ 
PS1="\T $ "   # 11:14:01 $ 
PS1="\@ $ "   # 11:14 AM $ 
PS1="\A $ "   # 11:14 $

Add whichever style you like to your $HOME/.bashrc and every time you open a new terminal, you will see time in command prompt.

If you wish to show current directory with time in prompt, a nice prompt setting could be like

PS1="\w \A $ "
PROMPT_DIRTRIM=2
# Resulting in prompt to look like
# ~/.../bluetooth/nimble 11:16 $

Here PROMPT_DIRTRIM would set the number of parent directories you wish to see in the prompt.

Checkout designing a minimal bash prompt.

Add current working directory in your shell prompt

chinmay chhajed — Fri, 19 Feb 2021 18:33:23 +0000

Bash prompt can be set by setting the environment variable PS1.

Current directory can be displayed in 3 types:

Full path

~/work/esp/esp-idf/examples/bluetooth/nimble$

Partial path

~/.../bluetooth/nimble$

Only parent directory.

nimble$

In value of PS1, \w or \W can be used to include working directory in the prompt. Change the value of PS1 in your $HOME/.bashrc file to change it for every terminal.

If you use zsh or any other shell, search where the config file is located and update it accordingly. .bashrc is used for bash shell which is default in most systems.

To set full path, \w can be used.

PS1="\w$ "
# Prompt would look like:
# ~/work/esp/esp-idf/examples/bluetooth/nimble$

To see only current directory's name in prompt, use \W

PS1="\W$ "
# Prompt would look like:
# nimble$ 
pwd
# Prompt will show only first parent directory, current path is:
# /home/chinmay/work/esp/esp-idf/examples/bluetooth/nimble

To see partial path, the environment variable PROMPT_DIRTRIM can be set to desired value to see number of parent directories. Default value of PROMPT_DIRTRIM is 0.

PS1="\w\$ " # Setting PS1 to show full path
# ~/work/esp/esp-idf/examples/bluetooth/nimble$ 
export PROMPT_DIRTRIM=4 # Trimming path to 4 directories
# ~/.../esp-idf/examples/bluetooth/nimble$ 
export PROMPT_DIRTRIM=2 # Trimming path to 2 directories
# ~/.../bluetooth/nimble$ 
export PROMPT_DIRTRIM=0 # Back to normal
# ~/work/esp/esp-idf/examples/bluetooth/nimble$

Checkout designing a minimal bash prompt.