Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
The Linux Programming Interface

The Linux Programming Interface

A Linux and UNIX System Programming Handbook
Write Linux programs that handle real kernel behavior, portability demands, and failure.
by Michael Kerrisk 2010 1552 pages
4.63
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Master the seam where programs ask the Linux kernel to act.

The interface is the subject. The Linux programming interface is the set of system calls, library functions, and other low-level facilities that programs use to request services from the kernel. A C library wrapper can make a system call look like an ordinary function, but execution still crosses from user mode into the kernel, where arguments are checked and work is performed. The book describes more than 500 calls and functions because this boundary underlies nearly every Linux application.

Learn by testing behavior. Its examples are short, complete C programs that expose details such as return values, file offsets, and signal effects. They are meant to be run and modified, not just read. That approach turns an abstract interface into something observable.

Analysis

The value of this boundary-focused view is that it makes debugging more disciplined. A program’s apparent behavior may come from its own code, a library wrapper, or kernel policy, and those layers leave different traces. Treating the interface as a contract helps isolate the source of a failure. The tradeoff is density: a reference covering so many interfaces can overwhelm newcomers unless they read with a concrete programming question in mind.

C made UNIX portable; standards turned portability into a shared contract.

A practical origin story. UNIX began in 1969 on a PDP-7, written in assembler. By 1973, the kernel had been largely rewritten in C, making it far easier to move the system to other hardware. As UNIX spread through universities, companies, and competing development groups, implementations diverged. BSD and System V became major branches, each adding features that made cross-platform programming harder.

Standards reduce guesswork. C standardization was followed by POSIX and the Single UNIX Specification, which define interfaces that programs can target. SUSv3 and SUSv4 consolidate much of this work. Linux aims to follow these standards while retaining Linux-specific extensions. The Linux Standard Base addresses a different problem: compatibility of compiled applications across Linux distributions.

Analysis

Standards are coordination technology. They let programmers depend on shared behavior without requiring identical operating systems or kernels. Yet standards also draw boundaries around what can be assumed, leaving room for implementation-specific features that may offer performance or functionality. The useful habit is not to treat portability as an absolute virtue, but to identify which guarantees an application needs and make departures from them deliberate.

Use file descriptors universally, but guard offsets, partial transfers, and buffering.

One handle, many devices. UNIX uses the same core calls, open(), read(), write(), and close(), for regular files, devices, pipes, and other file types. The kernel and device drivers handle the differences. A file descriptor is the small integer handle used to refer to an open file in later calls.

The details still bite. A successful read() or write() may transfer fewer bytes than requested. Duplicate descriptors can share a file offset, while separately opened descriptors do not. Concurrent appenders need O APPEND to avoid racing between seeking to the end and writing. The stdio library also buffers data, so its output can appear later than output sent directly with write(). A successful write() alone does not guarantee that data has reached disk.

Analysis

This model resembles a transaction pipeline: application memory, kernel buffers, and storage are separate stages, each with its own completion point. That distinction is essential for both correctness and performance. Atomicity of an append prevents one class of race, but it does not imply durability after a crash. The broader lesson is to ask precisely what a successful call guarantees, rather than treating all forms of completion as equivalent.

Treat a process as isolated memory plus inherited state, not merely a program.

A running program has structure. A process includes text, initialized and uninitialized data, a heap, a stack, and kernel-maintained information such as open files, credentials, and its current directory. Virtual memory lets the kernel isolate processes while sharing suitable pages, including program text and deliberately shared regions.

Creation and replacement differ. fork() creates a child with copies of the parent’s data, heap, and stack, while the program text can be shared. The child may then exec() a new program, replacing its memory image. The parent can use wait() to collect the child’s termination status. If it fails to do so, a terminated child can remain a zombie until reaped.

Analysis

Thinking in process state clarifies why bugs often survive a simple reading of source code. A child inherits much more than instructions: environment variables, file descriptors, credentials, and directory state can all shape its behavior. The model also highlights a useful separation between identity and execution. A program is a file; a process is a temporary, resource-bearing instance that the kernel manages.

Names and files differ. A directory maps filenames to inode numbers. The inode records the file’s type, ownership, permissions, timestamps, size, and data-block locations. A hard link is another directory entry pointing to the same inode, so multiple names can refer to one file.

Deletion removes a name first. unlink() removes a directory entry and decrements the inode’s link count. The file’s storage is released only when no links remain and no process still has it open. A symbolic link is different: it is a file containing another pathname. It can cross file-system boundaries and point to a directory, but it can become dangling if its target disappears.

Analysis

Separating identity from naming is a powerful model for understanding file operations. It explains why renaming a file need not move its data, why hard links share changes, and why an unlinked file can remain usable through an open descriptor. Similar distinctions appear in databases, where a record’s key and its storage location are not the same thing. The model also cautions against assuming that a displayed pathname uniquely identifies an object.

Check permissions through identity and directory rules, not the filename alone.

Access depends on context. Traditional permissions divide users into owner, group, and other, with read, write, and execute bits. Directory permissions have distinct meanings: read lists names, execute permits searching or accessing entries, and write permits changes to the directory. The process umask removes permissions when new files are created.

Identity has layers. Real, effective, saved, and supplementary user or group IDs affect ownership and permission checks in different ways. Set-user-ID programs can temporarily gain another identity, which is why the book emphasizes operating with least privilege. Access control lists extend the basic model by assigning permissions to named users and groups, with a mask limiting the permissions granted to the group class.

Analysis

The permission model is best understood as a decision procedure, not as a single label attached to a file. A pathname may be accessible or inaccessible because of any directory in its prefix, while credentials determine which permission category applies. ACLs add precision, but more entries also make auditing harder. Greater expressiveness improves control only when administrators can still understand the resulting policy.

Choose IPC by its contract: bytes, messages, shared memory, or synchronization.

Mechanisms make different promises. Pipes and FIFOs transfer byte streams; sockets support communication on one machine or across a network; message queues exchange separate messages; semaphores coordinate access; and shared memory lets processes see changes to common pages. These mechanisms overlap, but they are not interchangeable. For example, a pipe has no message boundaries, while a message queue preserves them.

Fast sharing needs discipline. Shared memory avoids repeated copying through the kernel, but processes must coordinate their access so that one does not read data while another is halfway through changing it. Semaphores or file locks can provide that synchronization. Pipes and sockets, by contrast, make data transfer explicit and often provide simpler boundaries between cooperating components.

Analysis

The most useful question is not which IPC mechanism is most powerful, but which semantics the application needs. Shared memory favors speed and shared state, while message and stream mechanisms favor explicit transfer. This resembles choosing between shared-state and message-passing designs in distributed systems: the choice changes where coordination complexity lives. A fast channel can still produce a fragile system if synchronization is left implicit.

Mounts and file-system details can change what a pathname actually means.

One tree, many file systems. Linux presents a single directory hierarchy rooted at /. Other file systems are attached at mount points, so a pathname may cross from one file system into another without changing its visible form. The virtual file system, or VFS, provides a common interface over different file-system implementations.

Implementation still matters. File systems differ in block allocation, supported metadata, and behavior. Traditional file systems may require lengthy consistency checks after a crash; journaling file systems record metadata updates so recovery can be faster. Linux also provides memory-based tmpfs and the virtual /proc file system. These features make pathnames convenient, but they do not erase differences in the storage beneath them.

Analysis

The VFS is an abstraction layer, not a promise that every file system behaves identically. That distinction matters when an application relies on timestamps, locking, journaling, or mount options. A pathname is stable as a name, yet its backing store and operational guarantees depend on how the system is assembled. Robust software treats the common interface as a baseline, then checks for the specific properties it requires.

Query runtime limits and /proc instead of assuming one system's boundaries.

Limits vary. A pathname limit may differ by file system, while process and system limits may depend on configuration. The book recommends using compile-time constants where appropriate and sysconf(), pathconf(), or fpathconf() to discover values at run time. If a limit is indeterminate, programs need a deliberate fallback rather than a silent guess.

The running system is inspectable. Linux’s /proc file system exposes process and system information in a form that can be read like files. It can reveal, for example, process credentials, memory use, open descriptors, and kernel settings. Time also has distinct meanings: calendar time measures elapsed real-world time, while process time measures CPU use in user and kernel mode.

Analysis

Runtime introspection is a form of defensive design. It replaces assumptions made on a developer’s machine with measurements from the environment where the program actually runs. The qualification is that /proc is Linux-specific and some limits can change during a process’s life. Portable software should combine discovery with graceful handling of failure, rather than mistaking a reported value for a permanent guarantee.

Choose standards for reach, and Linux extensions only for needed capabilities.

Portability is a choice. POSIX and the Single UNIX Specification define interfaces that help source code move across systems. Feature test macros control which declarations a compiler exposes, while standard data types such as pid t and off t avoid assumptions about native C types. Runtime queries help where limits are not fixed at compile time.

Extensions have a price and a payoff. Linux provides interfaces such as epoll, inotify, capabilities, and the /proc file system. These can expose useful functionality or improve performance, but they are not all standardized. The book distinguishes common UNIX behavior from Linux-specific details so programmers can decide where portability matters and where an extension is justified.

Analysis

A portability strategy works best when it is explicit. Standards provide a common floor, while extensions can deliver meaningful operational advantages. The hidden cost is not merely recompilation; it is also testing, documentation, and maintenance across environments. A useful design records which parts of the program rely on a standard contract and which depend on a specific kernel or library behavior.

Drop privilege promptly, and make every failure path deliberate.

Privilege should be narrow. The book’s guidance for privileged programs emphasizes least privilege, caution when executing other programs, protection of sensitive information, confinement, distrust of inputs and environment variables, and vigilance around signals, races, buffer overruns, and denial-of-service attacks. A set-user-ID or set-group-ID program should retain elevated identity only while an operation requires it, then drop it when possible.

Errors are part of the interface. System calls and library functions report failures in different ways, often through return values and errno. Programs should check these results and respond safely. A failure path that assumes success can turn a minor operational problem into corrupted state or a security weakness.

Analysis

Least privilege is a design constraint that reduces the consequences of mistakes, rather than a claim that mistakes can be eliminated. The same applies to explicit error handling: it forces a program to define what happens when reality diverges from the happy path. The tension is practical, since careful checks add code and complexity. Shared helper functions and clear failure policies help keep that extra rigor manageable.

Analysis

The book’s organizing idea is the boundary between an application and the operating system. It begins with the history that made this boundary portable, then follows the resources exposed through it: files, processes, memory, credentials, time, signals, and communication. Its strongest teaching move is to pair interface descriptions with complete programs. A reader can see not just what a call promises, but how it interacts with other calls and with kernel state.

The material repeatedly returns to distinctions that are easy to blur: a file descriptor is not an open file description; a filename is not an inode; a process is not a program; a successful write is not necessarily durable storage; and a signal’s generation is not the same as its delivery. These distinctions explain many difficult bugs more effectively than memorizing function prototypes. They also connect low-level programming to larger engineering concerns: concurrency requires explicit coordination, security depends on controlling authority, and portability depends on knowing which guarantees come from standards rather than one implementation.

The book’s breadth is its central strength and its central challenge. The Linux and UNIX interface is not a compact framework with a handful of elegant abstractions. It is a historical accumulation of mechanisms, some overlapping and some preserved for compatibility. The book does not pretend otherwise. Instead, it makes the reader compare alternatives, such as System V and POSIX IPC, or select(), poll(), signal-driven I/O, and epoll. That comparative method is more durable than a catalog of calls because it teaches how to choose.

The most useful reading strategy is therefore selective but systematic: learn the shared models first, then consult the detailed interface treatment when a real task demands it. The result is a practical map of the kernel boundary, with enough history and operational detail to help programmers write code that is both more correct and more portable.

Summary in 30 Seconds
Linux programs rely on more than 500 system calls and library functions, whose behavior depends on kernel state and standards. Reads and writes can transfer fewer bytes than requested, and a successful write does not ensure data has reached disk. Processes, file descriptors, filenames, and inodes each represent different things. Choose communication methods for their data and synchronization guarantees. Check errors, limit privileges, and query system limits rather than assuming them.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.63 out of 5
Average of 500+ ratings from Goodreads and Amazon.

The Linux Programming Interface receives overwhelmingly positive reviews, with readers praising its comprehensive coverage of Linux system programming. Many describe it as a definitive reference, highlighting its clear explanations, practical examples, and historical context. Readers appreciate the book's depth, organization, and readability, despite its substantial size. It's lauded for bridging theoretical concepts with practical applications, making it valuable for both learning and reference. Many reviewers spent considerable time with the book, finding it worthwhile for understanding Linux internals and system calls.

Your rating:
4.71
361 ratings
Want to read the full book?

Glossary

Linux programming interface

Kernel services exposed to programs

The collection of system calls, library functions, and related low-level interfaces through which applications use Linux and UNIX services. It covers operations such as file I/O, process creation, memory management, interprocess communication, and networking. The interface is used directly or indirectly by programs, and its standardized parts support portability across UNIX-like systems.

system call

A request to the kernel

A controlled entry point through which a process asks the kernel to perform an operation, such as opening a file, creating a process, or communicating through a socket. A C library wrapper often makes a system call look like a normal function. The kernel validates arguments, performs the operation, and returns a result or an error.

file descriptor

Integer handle for an open file

A small nonnegative integer that a process uses to refer to an open file, pipe, socket, terminal, or other I/O object. The descriptor indexes a per-process table, whose entry refers to an open file description maintained by the kernel. Duplicated descriptors can therefore share an offset and status flags.

virtual memory management

Mapping process addresses to memory

The kernel and hardware mechanism that give each process a virtual address space and map its pages to physical memory or swap space. It isolates processes, allows only part of a process to reside in RAM, and can let multiple processes share pages. It also supports memory protection and memory-mapped files.

copy-on-write

Copy pages only when modified

A memory-management technique that lets parent and child processes initially share physical pages after fork(). The pages are marked so that an attempted modification triggers a separate copy for the modifying process. This avoids copying all process memory immediately, while preserving independent data, heap, and stack contents.

process credentials

User and group identities attached to a process

The set of user and group identifiers associated with a process, including real, effective, saved set, supplementary, and Linux file-system IDs. These identifiers determine ownership and permissions for many operations. Set-user-ID and set-group-ID execution, as well as credential-changing system calls, can alter which identities a process uses.

access control list (ACL)

Per-user and per-group file permissions

A list of permission entries associated with a file or directory. ACL entries can specify access for named users and groups in addition to the traditional owner, group, and other categories. An ACL mask limits permissions granted to the group class. A default ACL on a directory influences permissions on newly created entries.

extended attributes

Name-value metadata attached to an inode

Extended attributes associate additional name-value pairs with a file or directory inode. Linux groups them into namespaces, including user, trusted, system, and security. They can store metadata beyond traditional file attributes, and the kernel uses them for features such as ACLs and file capabilities. Support depends on the underlying file system.

signal mask

Signals whose delivery is blocked

A per-process or, in multithreaded programs, per-thread set of signals whose delivery is temporarily blocked. A signal generated while blocked remains pending until it is unblocked. Programs manipulate the mask with functions such as sigprocmask() or pthread_sigmask(), often to protect critical sections.

POSIX IPC

Standardized message, semaphore, and shared memory APIs

A group of interprocess communication mechanisms defined by POSIX.1b: message queues, semaphores, and shared memory objects. These interfaces use names and open, close, and unlink operations, giving them a style closer to ordinary file operations than the older System V IPC APIs. They support communication or synchronization between processes.

FAQ

What's The Linux Programming Interface about?

  • Comprehensive Guide: The Linux Programming Interface by Michael Kerrisk is a detailed handbook on Linux and UNIX system programming, covering system calls, library functions, and the programming interface used by nearly every application on these systems.
  • Focus on Standards: The book emphasizes UNIX standards (POSIX.1-2001/SUSv3 and POSIX.1-2008/SUSv4), making it valuable for programmers working on various UNIX platforms.
  • Practical Examples: It includes over 200 example programs, 88 tables, and 115 diagrams to illustrate concepts, making it easier for readers to grasp complex topics.

Why should I read The Linux Programming Interface?

  • Authoritative Resource: Written by Michael Kerrisk, a recognized expert in Linux programming, this book is considered the definitive guide in the field. It is praised for its clarity and depth.
  • Skill Development: The book is designed for programmers and software designers looking to build applications for Linux or other UNIX systems, enhancing their system programming skills.
  • Comprehensive Coverage: It covers a wide range of topics, from basic file I/O to advanced features like multithreading and interprocess communication, making it suitable for both beginners and experienced developers.

What are the key takeaways of The Linux Programming Interface?

  • Understanding System Calls: Readers will learn how to effectively use system calls and library functions, which are crucial for interacting with the Linux kernel.
  • File I/O Model: The book introduces the universal I/O model, explaining how the same system calls are used for all types of files, including devices and sockets.
  • Error Handling: It emphasizes the importance of checking return values from system calls and library functions, teaching readers how to handle errors effectively.

What are the best quotes from The Linux Programming Interface and what do they mean?

  • Comprehensive Coverage: “The Linux Programming Interface is the most comprehensive single-volume work on the Linux and UNIX programming interface.” This highlights the book's extensive coverage and authority in the field.
  • Depth of Content: “You’ll find descriptions of over 500 system calls and library functions.” This emphasizes the book's depth, indicating a thorough exploration of the programming interface.
  • Transferable Knowledge: “The emphasis on UNIX standards makes it equally valuable to programmers working on other UNIX platforms.” This suggests that the knowledge gained is applicable across different UNIX systems.

How does The Linux Programming Interface explain system calls?

  • Definition of System Calls: System calls are controlled entry points into the kernel that allow processes to request services, such as file operations or process management.
  • Kernel Interaction: They enable user programs to interact with the kernel, which manages system resources and enforces security and access controls.
  • Performance Overhead: Understanding the overhead associated with system calls is crucial for writing efficient programs, as they involve switching from user mode to kernel mode.

What is the universal I/O model discussed in The Linux Programming Interface?

  • Unified System Calls: The universal I/O model states that the same system calls (open(), read(), write(), close()) are used for all types of files, including regular files, pipes, and sockets.
  • Simplified Programming: This model simplifies the programming model, allowing developers to write code that works across different file types without needing to handle each type differently.
  • Practical Examples: The book provides examples that illustrate how to use these system calls effectively, reinforcing the concept of universality in file I/O.

How does The Linux Programming Interface address error handling?

  • Importance of Error Checking: The book stresses that every system call and library function should have its return value checked to ensure successful execution.
  • Using errno: It explains how to use the global variable errno to diagnose errors, providing functions like perror() and strerror() for user-friendly error messages.
  • Example Implementation: The book includes practical examples demonstrating how to handle errors effectively, which is essential for robust programming.

What are the differences between static and shared libraries as explained in The Linux Programming Interface?

  • Static Libraries: These are archives of object code that are linked into an executable at compile time, resulting in larger binaries and requiring recompilation for updates.
  • Shared Libraries: These are linked at runtime, allowing multiple programs to share a single copy of the library in memory, which saves space and simplifies updates.
  • Advantages of Shared Libraries: The book discusses how shared libraries facilitate easier updates and reduce memory usage, making them preferable in many scenarios.

How does The Linux Programming Interface explain process management?

  • Definition of a Process: A process is defined as an instance of an executing program, with its own memory space and resources managed by the kernel.
  • Process Creation: The book details how processes are created using the fork() system call, which duplicates the parent process, and how they can execute new programs using execve().
  • Process Management: It covers how the kernel manages processes, including scheduling, resource allocation, and termination, providing a comprehensive understanding of process behavior.

What is the significance of the /proc file system in The Linux Programming Interface?

  • Virtual File System: The /proc file system is a virtual file system that provides an interface to kernel data structures, allowing users to view and modify system attributes.
  • Process Information: It contains directories for each running process, providing insights into process states and resource usage, which is invaluable for debugging and monitoring.
  • Kernel Interaction: The book explains how to interact with /proc files to gather system information, making it a practical tool for system programmers.

How does The Linux Programming Interface explain interprocess communication (IPC)?

  • Diverse IPC Methods: The book covers various IPC methods, including pipes, message queues, and shared memory. Each method is explained with examples, allowing readers to understand their use cases and implementation.
  • Synchronization Techniques: It also discusses synchronization mechanisms, such as semaphores and mutexes, which are crucial for coordinating access to shared resources.
  • Practical Examples: The author provides practical examples of IPC in action, demonstrating how to implement these techniques in real-world applications.

What are the threading concepts discussed in The Linux Programming Interface?

  • POSIX Threads: The book provides a comprehensive overview of POSIX threads, including thread creation, termination, and synchronization. This is essential for developing multithreaded applications in Linux.
  • Thread Safety: It emphasizes the importance of writing thread-safe code, discussing techniques to manage shared resources and avoid race conditions.
  • Cancellation and Cleanup: The book covers thread cancellation and the use of cleanup handlers, which are important for managing resources in multithreaded programs.

About the Author

Michael Kerrisk is the author of "The Linux Programming Interface" and has been the maintainer of the Linux man-pages project since 2004. His extensive experience with Linux systems is evident in the book's comprehensive and authoritative nature. Kerrisk's writing style is praised for being clear, concise, and well-organized, making complex topics accessible to readers. His dedication to the subject is apparent in the book's thorough coverage and the years of work that went into its creation. Kerrisk's role in maintaining Linux documentation has likely contributed to his deep understanding of the system, which he effectively shares through his writing.

Download PDF

To save this The Linux Programming Interface summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.44 MB     Pages: 22

Download EPUB

To read this The Linux Programming Interface summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.42 MB     Pages: 26
Want to read the full book?
Follow
Listen1 mins
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...