Learn Raspberry Pi with Linux 9781430248217, 9781430248224, 1430248211, 143024822X
Learn Raspberry Pi with Linuxwill tell you everything you need to know about the Raspberry Pi's GUI and command lin
423 100 7MB
English Pages 280 [272] Year 2012;2013
Polecaj historie
![Practical Linux with Raspberry Pi OS: Quick Start [1 ed.]
1484265092, 9781484265093](https://dokumen.pub/img/200x200/practical-linux-with-raspberry-pi-os-quick-start-1nbsped-1484265092-9781484265093.jpg)
Table of contents :
000......Page 1
Title Page......Page 2
Copyright Page......Page 3
Dedication Page......Page 4
Contents at a Glance......Page 5
Table of Contents......Page 6
About the Authors......Page 14
About the Technical Reviewer......Page 15
Acknowledgments......Page 16
Introduction......Page 17
It Only Costs $25......Page 19
Independence......Page 20
ARM CPU......Page 21
512MB of RAM......Page 22
GPIO Ports......Page 23
Remodeling the Landscape......Page 24
From Beginner to Admin......Page 25
Onward......Page 26
Your Freshly Baked Pi Arrives......Page 27
List of Ingredients......Page 29
USB Power Adapter......Page 30
SD Card......Page 31
SD Card Reader......Page 32
Whew, We’re Done!......Page 33
Linux......Page 34
What Is Linux?......Page 35
Getting Raspbian onto Your SD Card......Page 36
Using Image Writer on Windows......Page 37
Using the Terminal to Write the Image......Page 40
First Boot......Page 43
Configuring Your Pi......Page 44
Configuring the Keyboard......Page 45
Changing the Password......Page 49
Configuring the Locale......Page 50
Changing the Time Zone......Page 52
Allocating Memory......Page 53
At Last! It’s Configured!......Page 54
Summary......Page 56
Welcome to LXDE......Page 57
What Do We Have Here?......Page 58
And on the Right Side…......Page 59
The Start Menu......Page 60
Debian Reference......Page 62
File Manager......Page 63
Image Viewer......Page 64
Leafpad......Page 66
Root Terminal......Page 67
Education......Page 69
Scratch......Page 70
Squeak......Page 71
Internet......Page 72
Programming......Page 73
System Tools......Page 75
Desktop Preferences......Page 76
Customizing the Look and Feel......Page 77
Summary......Page 78
CHAPTER 3 Getting Comfortable......Page 79
Say Hello to the Dumb Terminal......Page 80
Modern Terminals......Page 81
Simple......Page 82
Convinced Yet?......Page 83
Console......Page 84
Connecting via SSH......Page 85
Setting Up an SSH Server on the Pi......Page 86
Putty for Windows......Page 87
SSH on the Mac......Page 91
Welcome to the Command Line......Page 92
Summary......Page 94
What Is a Filing System ?......Page 95
Separate Roots......Page 96
Bring it All Together......Page 97
Everything as a File......Page 98
/proc......Page 99
/home......Page 100
/srv......Page 101
Where Are We? Using pwd......Page 102
Creating Files to Play with: Using Touch......Page 103
Somewhere to Store our Files: Using mkdir......Page 104
Time for Some Cloning: How to Use the cp Command......Page 105
The Power to Destroy: Using the rm Command......Page 106
Users and Groups......Page 107
File Permissions......Page 108
Setting File Permissions......Page 110
Shortcuts and Links......Page 113
Summary......Page 114
Become the Boss......Page 115
System Resource Monitoring......Page 117
Uptime and Load Average......Page 118
CPU Utilization Percentage......Page 119
Process Table......Page 120
Disk Usage......Page 121
Managing Processes......Page 123
Killing a Process......Page 125
File Commands......Page 126
Combine ps and grep......Page 128
Cut Down the Results......Page 129
User Environment......Page 130
Summary......Page 133
What is a Text File?......Page 134
The Contenders......Page 135
Starting out with nano......Page 136
So What Does This All Mean?......Page 137
Saving Your File......Page 138
Moving Around in nano......Page 140
Getting Started with vim......Page 142
The vim Modes......Page 143
Saving Your Changes......Page 144
Getting Out of vim......Page 145
Searching in vim......Page 146
Moving to a Specific Line Number......Page 147
Deleting in vim......Page 148
Indenting Text......Page 151
Copy and Paste vim Style......Page 152
Summary......Page 153
Networking......Page 154
BASH: Basic Coding......Page 155
Starting in BASH......Page 156
Output in BASH......Page 157
Variables......Page 158
Logical Operation: if......Page 159
Test Based Arithmetic......Page 160
Troubleshooting......Page 162
Logical Operation: Loop......Page 164
Practical BASH: An Init Script......Page 166
Update the Run Files......Page 168
Creating Your Own init Script......Page 169
The Rules of Raspbian Security......Page 171
Adding a New User......Page 172
Summary......Page 173
First Steps......Page 174
A is for Apache......Page 175
Apache Configuration......Page 177
M is for MySQL......Page 180
Structured Query Language......Page 181
Creating Tables......Page 182
Querying a Database......Page 186
Updating a Database......Page 188
Deleting Data......Page 189
P is for PHP......Page 190
HTML......Page 193
Starting Our Page......Page 194
Display the Database Content......Page 196
Website Data Insertion......Page 198
Inserting to the Database......Page 200
Remove Entries......Page 201
Remove Data from DB......Page 203
Where From Here?......Page 204
Summary......Page 205
CHAPTER 9 WiPi: Wireless Computing......Page 206
Removing Human Input Devices......Page 207
Adding a Remote GUI......Page 208
True WiPi with WiFi......Page 211
GUI WiFi Configuration......Page 215
Managing WiFi from the Command Line......Page 219
Removing the Need for Power......Page 221
Summary......Page 222
Materials Needed......Page 223
dmesg......Page 224
Motion Capture......Page 228
Installing SSMTP......Page 232
Installing and Using mutt......Page 234
Testing the Alerting System......Page 235
Bringing It All Together......Page 236
Making Decisions......Page 237
Designing Solution......Page 238
Script 1......Page 240
Script 2......Page 241
Testing......Page 242
Where to Go from Here......Page 244
Summary......Page 245
Video with XBMC......Page 246
Setup to Build......Page 247
Changing Files with Sed and Regular Expressions......Page 251
Compiling Source Code......Page 252
Troubleshooting......Page 254
Starting and Using XBMC......Page 255
XBMC on Boot......Page 258
Stream Music with Airplay......Page 259
Airport on Boot......Page 264
Summary......Page 265
Index......Page 266
Citation preview
Learn Raspberry Pi with Linux
Peter Membrey David Hows
Apress
Learn Raspberry Pi with Linux Copyright © 2013 by Peter Membrey and David Hows This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Exempted from this legal reservation are brief excerpts in connection with reviews or scholarly analysis or material supplied specifically for the purpose of being entered and executed on a computer system, for exclusive use by the purchaser of the work. Duplication of this publication or parts thereof is permitted only under the provisions of the Copyright Law of the Publisher’s location, in its current version, and permission for use must always be obtained from Springer. Permissions for use may be obtained through RightsLink at the Copyright Clearance Center. Violations are liable to prosecution under the respective Copyright Law. ISBN 978-1-4302-4821-7 ISBN 978-1-4302-4822-4 (eBook) Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. President and Publisher: Paul Manning Lead Editor: Michelle Lowman Developmental Editor: Matthew Moodie Technical Reviewer: Stewart Watkiss Editorial Board: Steve Anglin, Mark Beckner, Ewan Buckingham, Gary Cornell, Louise Corrigan, Morgan Ertel, Jonathan Gennick, Jonathan Hassell, Robert Hutchinson, Michelle Lowman, James Markham, Matthew Moodie, Jeff Olson, Jeffrey Pepper, Douglas Pundick, Ben Renow-Clarke, Dominic Shakeshaft, Gwenan Spearing, Matt Wade, Tom Welsh Coordinating Editor: Jill Balzano Copy Editor: Nancy Sixsmith Compositor: SPi Global Indexer: SPi Global Artist: SPi Global Cover Designer: Anna Ishchenko Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation. For information on translations, please e-mail [email protected], or visit www.apress.com. Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Special Bulk Sales–eBook Licensing web page at www.apress.com/bulk-sales. Any source code or other supplementary materials referenced by the author in this text is available to readers at www.apress.com. For detailed information about how to locate your book’s source code, go to www.apress.com/source-code/.
To my parents, Peter and Bev, for all their support. — David Hows For my wife Sarah, son Kaydyn, and my close friends Jacqui Koo and Mark Stephens, who together make my world go ‘round. — Peter Membrey
Contents at a Glance About the Authors .............................................................................................................. xv About the Technical Reviewer .......................................................................................... xvii Acknowledgments ............................................................................................................. xix Introduction ....................................................................................................................... xxi ■ Chapter 1: Your First Bite of Raspberry Pi .........................................................................1 ■ Chapter 2: Surveying the Landscape ...............................................................................31 ■ Chapter 3: Getting Comfortable .......................................................................................53 ■ Chapter 4: The File-Paths to Success ..............................................................................69 ■ Chapter 5: Essential Commands ......................................................................................89 ■ Chapter 6: Editing Files on the Command Line ..............................................................109 ■ Chapter 7: Managing Your Pi .........................................................................................129 ■ Chapter 8: A LAMP of Your Own ....................................................................................149 ■ Chapter 9: WiPi: Wireless Computing ............................................................................181 ■ Chapter 10: The Raspberry sPi ......................................................................................199 ■ Chapter 11: Pi Media Center ..........................................................................................223 Index .................................................................................................................................243
v
Contents About the Authors .............................................................................................................. xv About the Technical Reviewer .......................................................................................... xvii Acknowledgments ............................................................................................................. xix Introduction ....................................................................................................................... xxi ■ Chapter 1: Your First Bite of Raspberry Pi .........................................................................1 Your Freshly Baked Pi Arrives........................................................................................................1 List of Ingredients .........................................................................................................................3 Micro USB lead ...................................................................................................................................................... 4 USB Power Adapter ............................................................................................................................................... 4 HDMI Lead ............................................................................................................................................................. 5 HDMI Capable Display ........................................................................................................................................... 5 SD Card .................................................................................................................................................................. 5 SD Card Reader ..................................................................................................................................................... 6 USB Keyboard and Mouse ..................................................................................................................................... 7 Whew, We’re Done! ................................................................................................................................................ 7 Don’t Panic! ........................................................................................................................................................... 8
Linux ..............................................................................................................................................8 What Is Linux? ....................................................................................................................................................... 9 Downloading Raspbian ........................................................................................................................................ 10
Getting Raspbian onto Your SD Card ...........................................................................................10 Using Image Writer on Windows .......................................................................................................................... 11 Using dd on the Mac ............................................................................................................................................ 14
First Boot .....................................................................................................................................17 vii
■ CONTENTS
Configuring Your Pi ......................................................................................................................18 Expanding the Filesystem.................................................................................................................................... 19 Configuring the Keyboard .................................................................................................................................... 20 Changing the Password ....................................................................................................................................... 23 Configuring the Locale......................................................................................................................................... 24 Changing the Time Zone ...................................................................................................................................... 26 Allocating Memory............................................................................................................................................... 27 At Last! It’s Configured! ....................................................................................................................................... 28
Summary .....................................................................................................................................30 ■ Chapter 2: Surveying the Landscape ...............................................................................31 Welcome to LXDE ........................................................................................................................31 What Do We Have Here? ...................................................................................................................................... 32 The Start Menu and Bottom Left of the Task Bar ................................................................................................. 33 And on the Right Side… ...................................................................................................................................... 33
The Start Menu ............................................................................................................................34 Accessories ......................................................................................................................................................... 36 Education ............................................................................................................................................................. 43 Internet ................................................................................................................................................................ 46 Programming ....................................................................................................................................................... 47 System Tools........................................................................................................................................................ 49 Preferences ......................................................................................................................................................... 50
Summary .....................................................................................................................................52 ■ Chapter 3: Getting Comfortable .......................................................................................53 Ye Olde Computer ........................................................................................................................54 Say Hello to the Dumb Terminal .......................................................................................................................... 54 Modern Terminals ................................................................................................................................................ 55 Why Do We Still Care About These Things? ......................................................................................................... 56
Three Terminals ...........................................................................................................................58 Console ................................................................................................................................................................ 58 Opening a Virtual Terminal in the GUI .................................................................................................................. 59 Connecting via SSH ............................................................................................................................................. 59 viii
■ CONTENTS
Welcome to the Command Line ..................................................................................................66 Different Shells............................................................................................................................68 Summary .....................................................................................................................................68 ■ Chapter 4: The File-Paths to Success ..............................................................................69 What Is a Filing System? .............................................................................................................69 More than One Filesystem ................................................................................................................................... 70 Separate Roots .................................................................................................................................................... 70 Unified Filesystem ............................................................................................................................................... 71 The Mac has to be Different ................................................................................................................................ 71 Bring it All Together ............................................................................................................................................. 71
Everything as a File .....................................................................................................................72 Filesystem Layout .......................................................................................................................73 / (Root Directory) ................................................................................................................................................ 73 /root ..................................................................................................................................................................... 73 /etc ...................................................................................................................................................................... 73 /proc .................................................................................................................................................................... 73 /var ...................................................................................................................................................................... 74 /boot .................................................................................................................................................................... 74 /bin and /sbin ...................................................................................................................................................... 74 /dev...................................................................................................................................................................... 74 /home .................................................................................................................................................................. 74 /lib ....................................................................................................................................................................... 75 /lost+found .......................................................................................................................................................... 75 /mnt ..................................................................................................................................................................... 75 /media ................................................................................................................................................................. 75 /usr ...................................................................................................................................................................... 75 /opt ...................................................................................................................................................................... 75 /srv ...................................................................................................................................................................... 75 /sys ...................................................................................................................................................................... 76 /tmp ..................................................................................................................................................................... 76 Wrapping it Up ..................................................................................................................................................... 76 ix
■ CONTENTS
Putting it to Work .........................................................................................................................76 Where Are We? Using pwd................................................................................................................................... 76 What’s in Here with Us? Using ls ......................................................................................................................... 77 Creating Files to Play with: Using Touch .............................................................................................................. 77 Somewhere to Store our Files: Using mkdir ........................................................................................................ 78 Making Use of a New Directory: Using the mv Command ................................................................................... 79 Time for Some Cloning: How to Use the cp Command ........................................................................................ 79 The Power to Destroy: Using the rm Command ................................................................................................... 80 Fully Qualified and Relative Paths ....................................................................................................................... 81
Users and Groups ........................................................................................................................81 File Permissions ..........................................................................................................................82 Setting File Permissions ...................................................................................................................................... 84
Shortcuts and Links ....................................................................................................................87 Summary .....................................................................................................................................88 ■ Chapter 5: Essential Commands ......................................................................................89 Become the Boss ........................................................................................................................89 RTFM ...........................................................................................................................................91 System Resource Monitoring ......................................................................................................91 Uptime and Load Average .................................................................................................................................... 92 Tasks.................................................................................................................................................................... 93 CPU Utilization Percentage .................................................................................................................................. 93 Memory Usage..................................................................................................................................................... 94 Process Table....................................................................................................................................................... 94 Using free to View Memory Allocation ................................................................................................................. 95 Disk Usage ........................................................................................................................................................... 95 Managing Processes ........................................................................................................................................... 97
File Commands..........................................................................................................................100 Combining Commands....................................................................................................................................... 102 User Environment .............................................................................................................................................. 104 The cron Command ........................................................................................................................................... 107
Summary ...................................................................................................................................107 x
■ CONTENTS
■ Chapter 6: Editing Files on the Command Line ..............................................................109 What is a Text File? ...................................................................................................................109 The Contenders .........................................................................................................................110 Starting out with nano ...............................................................................................................111 So What Does This All Mean? ............................................................................................................................ 112 Saving Your File ................................................................................................................................................. 113 Moving Around in nano ...................................................................................................................................... 115 Wrapping Up nano ............................................................................................................................................. 117
Getting Started with vim ...........................................................................................................117 The vim Modes .................................................................................................................................................. 118 Saving Your Changes ......................................................................................................................................... 119 Getting Out of vim .............................................................................................................................................. 120 Searching in vim ................................................................................................................................................ 121 Moving to a Specific Line Number ..................................................................................................................... 122 Moving About in vim .......................................................................................................................................... 123 Deleting in vim................................................................................................................................................... 123 Miscellaneous Little Commands ........................................................................................................................ 126 Visual Mode ....................................................................................................................................................... 126 Indenting Text .................................................................................................................................................... 126
Summary ...................................................................................................................................128 ■ Chapter 7: Managing Your Pi .........................................................................................129 Remotely Accessing the Pi ........................................................................................................129 Networking ........................................................................................................................................................ 129 DNS .................................................................................................................................................................... 130 SSH .................................................................................................................................................................... 130
BASH: Basic Coding ...................................................................................................................130 What Is BASH? ................................................................................................................................................... 131 Starting in BASH ................................................................................................................................................ 131 Interpreted versus Compiled ............................................................................................................................. 132 Output in BASH .................................................................................................................................................. 132
xi
■ CONTENTS
Recap................................................................................................................................................................. 133 Variables ............................................................................................................................................................ 133 Logical Operation: if ........................................................................................................................................... 134 Test Based Arithmetic ........................................................................................................................................ 135 Troubleshooting ................................................................................................................................................. 137 Logical Operation: Loop ..................................................................................................................................... 139 Troubleshooting ................................................................................................................................................. 141
Practical BASH: An Init Script ....................................................................................................141 Pick and Match with the case Statement .......................................................................................................... 143 Application within Application: Forking ............................................................................................................. 143 Update the Run Files ......................................................................................................................................... 143 Creating Your Own init Script ............................................................................................................................. 144
Security and User Management ................................................................................................146 The Rules of Raspbian Security ......................................................................................................................... 146 Adding a New User ............................................................................................................................................ 147
Summary ...................................................................................................................................148 ■ Chapter 8: A LAMP of Your Own ....................................................................................149 First Steps .................................................................................................................................149 L is for Linux ..............................................................................................................................150 A is for Apache ..........................................................................................................................150 Apache Configuration ........................................................................................................................................ 152 Troubleshooting ................................................................................................................................................. 155
M is for MySQL ..........................................................................................................................155 Installing MySQL ................................................................................................................................................ 156 Structured Query Language............................................................................................................................... 156
P is for PHP................................................................................................................................165 Simple Web App ........................................................................................................................168 HTML ................................................................................................................................................................. 168 Starting Our Page .............................................................................................................................................. 169 Display the Database Content ........................................................................................................................... 171
xii
■ CONTENTS
Website Data Insertion....................................................................................................................................... 173 Inserting to the Database .................................................................................................................................. 175 Remove Entries.................................................................................................................................................. 176 Remove Data from DB ....................................................................................................................................... 178 Troubleshooting ................................................................................................................................................. 179 Where From Here?............................................................................................................................................. 179
Summary ...................................................................................................................................180 ■ Chapter 9: WiPi: Wireless Computing ............................................................................181 Preparing for WiPi .....................................................................................................................182 Simple Constraint Removal .......................................................................................................182 Removing Human Input Devices ........................................................................................................................ 182 Adding a Remote GUI ......................................................................................................................................... 183
True WiPi with WiFi ....................................................................................................................186 GUI WiFi Configuration ....................................................................................................................................... 190 Managing WiFi from the Command Line............................................................................................................ 194 Down to One ...................................................................................................................................................... 196
Removing the Need for Power...................................................................................................196 Powered USB Adapters .............................................................................................................197 Summary ...................................................................................................................................197 ■ Chapter 10: The Raspberry sPi ......................................................................................199 Materials Needed ......................................................................................................................199 Presetup ....................................................................................................................................200 Getting Started ..........................................................................................................................200 dmesg ................................................................................................................................................................ 200 Troubleshooting ................................................................................................................................................. 204
Motion Capture ..........................................................................................................................204 Troubleshooting ................................................................................................................................................. 208
Alerting Yourself ........................................................................................................................208 Installing SSMTP................................................................................................................................................ 208 Installing and Using mutt ................................................................................................................................... 210 xiii
■ CONTENTS
Testing the Alerting System ............................................................................................................................... 211 Troubleshooting ................................................................................................................................................. 212
Bringing It All Together ..............................................................................................................212 Understanding the Problem ............................................................................................................................... 213 Making Decisions .............................................................................................................................................. 213 Designing Solution............................................................................................................................................. 214 Script 1 .............................................................................................................................................................. 216 Script 2 .............................................................................................................................................................. 217 Testing ............................................................................................................................................................... 218 Troubleshooting ................................................................................................................................................. 220
Where to Go from Here ..............................................................................................................220 Summary ...................................................................................................................................221 ■ Chapter 11: Pi Media Center ..........................................................................................223 Video with XBMC .......................................................................................................................223 Setup to Build .................................................................................................................................................... 224 Changing Files with Sed and Regular Expressions............................................................................................ 228 Compiling Source Code ..................................................................................................................................... 229 Troubleshooting ................................................................................................................................................. 231
Starting and Using XBMC ..........................................................................................................232 XBMC on Boot .................................................................................................................................................... 235 Troubleshooting ................................................................................................................................................. 236
Stream Music with Airplay ........................................................................................................236 Troubleshooting ................................................................................................................................................. 241 Airport on Boot................................................................................................................................................... 241
Summary ...................................................................................................................................242 Index .................................................................................................................................243
xiv
About the Authors Peter Membrey is a Chartered IT Professional with nearly 15 years of experience using Linux and open source solutiuons to solve problems in the real world. An RHCE since the age of 17, he has also had the honor of working for Red Hat and writing several books covering open source solutions. He holds a masters degree in IT (Information Security) from the University of Liverpool and is currently a PhD candidate at the Hong Kong Polytechnic University where his research interests include cloud computing, big data science and security. He lives in Hong Kong with his wonderful wife Sarah and son Kaydyn. His Cantonese continues to regress.
David Hows is an Honors graduate from the University of Woolongong in NSW Australia. He got his start in computing trying to drive more performance out of his family PC without spending a fortune. This lead to a career in IT where David has worked as a Systems Administrator, Performance Engineer, Software Developer, Solutions Architect and Database Engineer. David has tried in vain for many years to play soccer well and his coffee mug reads “Grumble Bum.”
xv
About the Technical Reviewer Stewart Watkiss graduated from The University of Hull, UK, with a Master’s degree in electronic engineering. He has been a fan of Linux since first installing it on a home computer during the late 1990s, back when Linux was installed using floppy disks. While working as a Linux system administrator, he was awarded Advanced Linux Certification (LPIC 2) in 2006, and created the PenguinTutor website to help others working toward Linux certification (http://www.penguintutor.com). After ordering his first Raspberry Pi on the launch day, he has since gotten three more, which he uses as a family friendly proxy, a media center, for working on hobby electronic projects, and teaching his two children about computers.
xvii
Acknowledgments Without a doubt, the true heroes of this book are the Raspberry Pi Foundation and the Raspberry Pi community because without either of them, we wouldn’t be here. The Raspberry Pi Foundation, the group who bought us the Pi, is a nonprofit charity with the stated goal with the Pi was to reinvigorate the development spirit of the ‘80s and to provide an affordable platform for generations of youngsters to get into the wonderful world of computing in a truly meaningful way. It has done so much to bridge the digital divide and bring computing to the common man, and for this it deserve our thanks. If the Raspberry Pi Foundation is the heart, the Raspberry Pi community has to be the soul. These people have sought to provide the tools and support people need to get started with the Pi regardless of skill level. They have invested countless hours (and dollars) in writing, fixing, porting, hacking, and testing things for the Pi. Please feel free to pay a visit to them at http://www.raspberrypi.org/ and see what we mean.
xix
Introduction Despite sounding like something Grandma would bake on Sunday afternoons or a noise that would make people glare and tut, the Raspberry Pi is in fact a computer. That much you probably knew (although, let’s be honest, the name and logo don’t really give much away) but the Raspberry Pi promises more than that. An awful lot more. The venerable Commodore 64 was released in 1982, and with sales reaching upwards of 17 million, it is often considered the best-selling computer of all time. More importantly (at least from my perspective), it was also my first computer. For Christmas, just before my ninth birthday (when the C64 was nearly a decade old) I received the new model (C64C), which was identical to the classic machine in all but cosmetics. It arrived all set up and attached to a nice new 14-inch television (it even had a remote control!). I suspect my dad had hatched what he believed to be a most cunning plan; if he could sneak in and set everything up while I was asleep, come Christmas morning, I would be so busy playing with the computer that my parents might get an extra few minutes of sleep. Sadly, things did not go quite according to plan. Although everything was set up, and even though the television was tuned to the computer’s signal, one simple but key thing had been forgotten: it hadn’t occurred to anyone to tell me how to actually load a game. Needless to say, a lie in was not forthcoming . . . Games came on cassette tape. This was before CDs, and at least on the C64 had to be played in a special tape recorder called a datasette. (What do you mean what’s a CD?) Sadly, the datasette spent more time in the shop than being attached to my computer and as it was the only way to load anything into it, I had no choice but to occupy myself with the manual. This I used to great effect and taught myself how to program good old BASIC (Beginners All Purpose Symbolic Instruction Code—can you believe I actually remembered that?). While I’m sure this story is very gripping, you could be forgiven for wondering why I am boring you with it. Those events happened more than two decades ago, so what possible relevance could they have today? Well tinkering with that machine and then the Amiga that followed it (still my favorite machine of all time) gave me a real appreciation for what a computer could do. The Amiga was severely underpowered compared with PCs of the same era, yet it consistently beat them with better graphics, better reliability, and better sound. It was able to do all of this because the hardware was exquisitely designed. Amiga enthusiasts were some of the most resourceful people I’ve ever seen. Who’d have thought you could turn a real–time clock port into a connector for high-speed storage? All of this was only possible because people really understood how all the parts fit together. They knew how to get the best out of the machine because they really knew how the machine worked. These days, I spend my working day trying to make fast things go faster. To have any hope of success, I too need to know how everything works. Companies need people like me to push things forward, but they’re coming across a bit of a problem. People who really know computers inside out are getting much harder to find—we are a dying breed, and this is the situation that the Raspberry Pi Foundation is desperately trying to reverse. So what happened? Well, things changed. Computers went from being the curiosity in the corner to being a basic part of everyone’s lives. They evolved to the point where they just work and everyone knows how to use them. This is similar to the family car. Everyone has a rough idea how a car works, but few people are very interested. The car takes them from place to place, and that capability is what is interesting, not how the car achieves it. Computers are generally seen in the same light. People have a rough idea about turning them on, installing software and so forth, but how they actually work at a low level isn’t really seen as relevant or interesting. This in turn means that not only are fewer people getting excited by computing itself but even fewer people think that there’s more to it than doubleclicking an icon.
xxi
■ INTRODUCTION
This problem has drifted up through schools and into universities. Teaching programming is a relatively challenging task. It requires a certain way of thinking that for many people is tough to get a handle on. Traditionally, universities would start a computer science course by teaching about logic gates, how memory works, and how to program a CPU. Only once you understood what the bare metal was doing would you try to learn C because although C is a higher language, it reflects the hardware it runs on. Understanding the hardware makes understanding C that much easier. But with larger class sizes, more limited teaching time, and students arriving with less and less knowledge of computing fundamentals, universities have had to adapt. Rather than teaching all that low-level stuff, now they teach Java and other scripting languages. Because these languages handle all of the “fiddly bits” for you, you can effectively pretend that they don’t exist (although this can cause some issues; see “The Infinite Memory Myth”). This is simply fantastic from a productivity point of view, but when you do want to take it to the next level (maybe you’re processing data and your script is just too slow), you have no idea where to turn. Worse, when someone tells you the technique for improving that performance, you have no idea what they’re talking about. Of course not all universities have taken this route. I’m studying at the Hong Kong Polytechnic University, and its course on Computer Architecture is very detailed and covers a lot of ground. If you want to get the top grade, you will need to implement a CPU cache for the CPU simulator program. Needless to say, there is a lot to learn for everyone on this course. That said, we need more than this. It’s too late to capture people’s interest when they’re starting graduate studies. I taught seven-year-olds how to program BBC BASIC when I was in my last year of primary school (they even got presented certificates by the school) and they loved it. Computing lets you create a virtual world with your mind (the children liked to create little text–based adventure games) and ultimate power rested in their hands. They got creative; they added spells, new roads, secret entrances, and much more. Okay, they needed a helping hand (they were only seven) but they had the desire to create and to build cool new things.
INFINITE MEMORY MYTH Over the years, I’ve done a lot of consultancy work with large enterprise customers and that has inevitably meant I’ve come across Java on many occasions. One of the interesting things I have come across is what I’ve termed the Infinite Memory Myth. This seems to crop up more in Java applications than in other languages, but that’s probably because Java tends to be more widely used in those settings. The short version of the myth is that developers seem to constantly create new objects, often to the point where the application consumes huge amounts of memory or crashes altogether. They tend to have no idea how much memory each object takes or, more worryingly, why they should care. As far as they are concerned, they request a new object and one is provided. When an object is no longer used (i.e., nothing points to it any more), Java will at some point get around to cleaning it up (called garbage collection). All of this is automatic; the developer doesn’t need to do anything. The problem is that this leads people to forget (or in many cases were never taught at all) that memory is finite, and at some point it simply runs out. You can’t assume that you can read in every row in a table and that it will always work. You can’t assume that just because your test file is 50MB in size that the application will never be given a 5,000MB file to work on. This lack of understanding stems from not being able to appreciate all the hard work Java is doing on the programmer’s behalf. It is running about and managing memory allocation and garbage collection, and the programmer remains blissfully unaware. A good understanding of computing fundamentals would give a developer keen insight into what Java is doing (both the how and the why) and thus appreciate that just because creating new objects is easy, memory itself is not free.
xxii
■ INTRODUCTION
So this is what Eben Upton and the Raspberry Pi Foundation are trying to bring back to the world. They want to rekindle that lost art and make computers cool and interesting again. To do that, it has created a computer that even by today’s standards is no slouch. Is it as powerful as your laptop? Well no, probably not, but can you buy your laptop for $35, slip it into your pocket (possibly not a great idea), generate relatively little heat, and drink very little in the way of power? If you answered yes to those questions, I really really want to hear from you—that sounds like a laptop I need to buy! However you choose to look at it, the main selling point (no pun intended) is the price. Anyone can pick up a Raspberry Pi without having to think too much about it. With a modest laptop clocking in at around $500 + and a MacBook pro nearly four times that, it’s not the sort of thing you can just splurge on without thinking, especially if it’s going to be for experimentation and playing about. However at $35, the Pi is cheaper than some monthly movie subscriptions, you could almost buy a new Pi every month!
Why Eat Raspberry Pi? Whichever way you look at it, you will come back to the price. Whatever else the Raspberry Pi is and whatever other promises it has in store for us, all of them are interesting because of the price. There are two types of people who will be rushing out to get a Pi. The first group is already clued up on Linux and computing, and for them the Pi represents a server in a pocket and a cheap one at that. No longer do they need a full-size PC monster guzzling electricity and generating enough heat to rival a bar heater. Oh sure, you can get low-powered systems in nice shiny boxes, but they’re still not all that cheap to buy, even if they’re cheaper to run. However, a device like the Pi is cheap to run and cheap to buy, and it has just what you need to build a pretty respectful server. If you’re not one of those people, don’t worry because this book is for you. You like the idea of a cool little computer for $35 and you think you can do some pretty awesome stuff with it; you’re just not really sure how. For us, the big benefit is that the Pi is at the sort of price where we can afford to buy it just for fun and use it for experimentation. It’s not going to replace the family PC and you’re not going to need to take out a mortgage to buy one. You can play around with a Pi completely guilt-free and try all manner of weird and interesting things without having to worry about cost or destroying your main computer (and thus incurring the wrath of everyone you live with). Because the Pi is close enough to a normal PC (even though the architecture is a bit different) you can do PC-type things with it. In fact, that’s the first thing we show you in this book. Thus you don’t have to start from scratch; all that you know already you can apply to a Pi (it rhymes if you say that really fast) and so you can hit the ground running. No doubt you will want to do all the things that the first group of people wanted to do as well. Fear not, we have you covered—by the time you’ve finished this book you’ll be able to do all that and more! There are lots of reasons why everyone should rush out right now and get some Pi. Actually at the time of writing, there is still a three-week lead time for delivery, and when the Pi was initially released, one of the resellers took 100,000 preorders in just one day. That’s a lot of Pi! Although the lead time will naturally keep changing, the short version is that the sooner you order, the sooner you will get your Pi! So why all this interest? What is so special about the Raspberry Pi that it has achieved an almost cult-like following and has remained in heavy back order for months?
It Only Costs $25 Okay, hands up all of you who are only interested in the Pi because it costs significantly less than a night on the town? If you put up your hand, you’re not alone. The goals of the Raspberry Pi Foundation are laudable but they all center on getting this powerful machine into our mitts at a price point that won’t break the bank. What really has everyone drooling is not the fact that as far as computer hardware goes, the Pi is effectively free, but more that it is a full computer that can run Linux. That means servers, home automation, video streaming, and pretty much anything else you can imagine.
xxiii
■ INTRODUCTION
WAIT, IS IT $25 OR $35? Throughout the book we do bring up the price of the Pi a fair bit; after all, it is one of its most distinctive features. However, we also mention two prices, $25 and $35, so which is it? Well there are two versions of the Pi, the Model A and the Model B (as uninspiring as those names sound, they’re taken from the BBC computers, and from a geeky point of view, the names are quite inspired). There isn’t a great deal of difference between the two models, with Model B having 10/100 Ethernet built in and an additional USB port. Model B also draws a bit more power. The Ethernet adapter is actually connected internally via USB, so there is no different between the build in Ethernet and a USB device that you could plug into the USB port itself. So which should you buy? Well if you think networking will be useful, the built-in Ethernet port is pretty much required. I love having built-in Ethernet connectivity because it just makes life so much easier. However if you aren’t planning on using it much, there really is no need to get Model B. That said, for $10, it might be worth spending more just in case you decide you want to play with networking later on…
MORE PI! If one Pi is good, two must be better. Right? Well, $50 would get you two Pis and while this doubles the cost, it also more than doubles the fun. Now you can experiment with networking and getting the Pis to talk to each other. After all, it’s good to talk!
Experiment in Safety When my computer is out of commission for even a short period of time, it is pretty inconvenient. I certainly don’t want to fiddle about with something and accidentally erase my hard disk (been there, done that). You’d also be well advised not to try over-clocking your CPU on the brand-new computer that you were just given as it’s not much fun to think you’ve totaled the machine within an hour of turning it on! To kill hardware takes a fair bit of effort (such as taping over a pin on the CPU and removing the CPU speed multiplier lock), but it’s fairly easy to remove your family photo album and the latest draft of the book you’ve been working on for the past six months (there is a reason why we dedicated a whole chapter and personal plea in the book to backups). If you have a Pi and you nuke it, the worst case is $25 down the drain, which is a lot better than what would happen if you toasted your main machine.
Independence I’m sure some people will point out (quite correctly) that most of the horrors I just described can be avoided if you play in a VM rather than on your main machine. Apart from it not being as much fun (real hardware just smells better), it doesn’t give you all the benefits of a separate piece of kit. For a start, a virtual machine is only on when your main machine is running. If you happen to have a laptop that follows you everywhere, a virtual machine won’t be a great option for a home web server. Also, if you ever reboot your main machine, your virtual machine will go down with it. If you were using it to stream movies to your TV, you could end up with some very displeased family members. By having a real piece of hardware, you can keep your experimentation completely separate from anything else that you might be doing.
xxiv
■ INTRODUCTION
Low Power The Pi has a very modest power footprint. In fact, the Model A Pi only draws 300ma, which means you can power the whole thing from your USB port. According to Apple, my iMac draws 94 watts at idle and up to 241 watts when the CPU is maxed out. The Model A Pi draws at most 1.4 watts, and the Model B draws at most 3.5. That’s an awful lot of power saved. Understandably, these figures only take into account the power requirements of the Pi itself, with a bit extra put aside to power modest USB devices. If you add lots of power-hungry devices to your Pi, these figures would increase accordingly.
APPLES TO ORANGES I just know someone is going to cry foul about my power comparison—and for good reason. It is true that compared to an iMac, the Pi draws basically no power at all. However, it is also true that an iMac does a lot more. First, it has a big screen, hard disk, and CPU that would blow the ARM on the Pi into the middle of next week. So if I know that I’m comparing two totally different systems and I’m admitting that they’re very different(who compares a golf cart to a Formula One car?) why am I wasting ink and paper with this description? Well, although we are comparing two very different machines, we are comparing the same sort of tasks. If you want to have a little web server or stream video to your TV set, a Pi is more than powerful enough to do that for you. Bear in mind that the Pi is clocked in at 700Mhz; not too long ago, that was what you’d find on a very powerful desktop. It’s not that long ago that you’d find this sort of performance on an enterprise grade server. Ten years ago, it was just a fantasy. In short, the Pi has more than enough juice to do most of the things you’d want from a server and it won’t require a small nuclear power station to do it.
The Ingredients for a Raspberry Pi After seeing all its benefits, you might be wondering why a $35 computer stacks up so well to ones that cost many times that. If you’re thinking that, it won’t be long before you wonder why there is such a big difference in price. Surely if you could get something this cheap that does most of the things your main machine can do, something must be up with the price of the other machines. After all, if a powerful laptop could be made significantly cheaper, it would easily make more money in increased sales than it would lose in reduced profit margin. Well that’s true to a point, but the Pi, powerful as it is, will probably never be a direct replacement for your main computer. It’s not any particular one thing that limits the Pi, but a combination of design decisions to balance features with cost that will ultimately prevent it from taking the crown. That said, it is still a fantastic platform, and we’ll look at some of those highlights right now.
ARM CPU The major and most obvious difference between the Pi and your desktop is that your desktop will almost certainly have a processor from either Intel or AMD at its core, whereas the Pi has an ARM-based CPU. The Central Processing Unit (CPU) is the part that actually runs the programs you provide. Before a CPU can run a program, it must be translated into a language that the CPU can understand. So all CPUs execute programs, but the program has to be in a language they can understand. An ARM CPU cannot understand instructions written for an Intel or AMD CPU, which effectively means that most off-the-shelf software (such as Microsoft Windows and games) cannot run on a Raspberry Pi. Okay so you’re not going to be running Windows XP on the Pi, but does the ARM offer any advantages? The first advantage is that ARM CPUs draw much less power. This isn’t overly surprising as ARM really came from the embedded hardware industry where power usage and heat generation are a really big deal. In fact, you’ll find some
xxv
■ INTRODUCTION
form of ARM in almost every modern cellphone including the iPhone 4s and Samsung Galaxy S3. In fact they are one of the most widely used processors in the world and can be found in all manner of devices such as DVD players, appliances, and even cars. ARM CPUs also generate very little in the way of heat. If you look at the Pi itself, you will notice the CPU doesn’t have a heat sink. If you look at any Intel or AMD CPU, you can’t fail to miss the huge cooling fan that it requires in order to prevent it burning out. Some people even user water cooling systems to keep their PC processors running at a reasonable temperature. The last benefit is really a cost-to-performance ratio. For the vast majority of things, the real bottleneck is not CPU power but how fast data can be fed to it. CPUs have long been much faster than hard disks, and even the bus that links all the computer components together can’t keep up with even a modest CPU. So what do you get out of this? A low-cost processor that almost certainly will do everything you need without the cost penalty.
WINDOWS 8 ON ARM Early last year, Microsoft announced that Windows 8 would support ARM processors. This is not overly surprising as ARM is present in practically every modern mobile device; and with the performance of the high end chips gaining significant ground on Intel and AMD offerings, it probably won’t be long before we start to see more powerful desktops being powered by these beasts. Microsoft has long dominated the PC market and regardless of your thoughts on who should be leading the way, everyone agrees that Microsoft is far from done. Of course, where Microsoft leads, others will follow. If Microsoft starts supporting the ARM platform directly, it won’t be long before hardware manufacturers will start providing the necessary drivers and support for their devices. Game developers will also need to pay attention to ARMbased platforms and that could create some very interesting challenges and compromises. What does it mean for your Pi? Well, you probably won’t be able to run Windows 8 on it; it just wasn’t built with that in mind, but it does mean that the technology underpinning your Pi is not based on some old bits and pieces found at the back of someone’s bottom desk drawer. Rather it is quite possibly based on the platform of the future!
512MB of RAM The Model B Pi comes with 512MB of RAM (originally 256MB, but they changed to 512MB in October 2012), which is shared between the system and the Graphics Processing Unit (GPU). Now considering that the laptop I’m using to write this has 8GB of RAM, my desktop at home has 16GB (that is 32 and 64 times, respectively), and that up to half of this is shared with the GPU, it sounds a little weak. What can you really do in 512MB of RAM? Or even 256MB if you have a Model A or an older Model B? Well the answer to that is a lot more than you might think. Remember, Windows 95 was able to operate with a couple of running programs in just 8MB of RAM (which conveniently enough is 32 times less than the Pi), and the good old Commodore 64 came with only 64KB (the Pi has something like 4,000 times that) and it was able to run thousands of games to entertain the masses. So why do we have so much memory in new machines? Memory is cheap these days, and although we could do lots of great stuff in very little memory, it’s a skill that has gone out of fashion. Why spend so much effort on optimization memory usage when it will most likely never matter? If 8GB of RAM costs $50, is it worth hours if not days of a programmer’s time to save a few megabytes here and there? Probably not. Remember, the Pi is meant as an experimentation platform, not as a general PC replacement, and Linux (especially without a GUI) will run with plenty of memory to spare for all your programs. By keeping the memory to a reasonable minimum, the Pi is able to hit its price point without greatly hindering what you can do with it.
xxvi
■ INTRODUCTION
GPU The GPU is really a specialized form of a CPU. A CPU is generic in what it can do, and it tries to be good at everything it does, the classic jack-of-all-trades. A GPU, on the other hand, does one thing and one thing well. It is specifically designed to handle the intense mathematical calculations needed to render complex displays. This started off predominantly in 3D graphics rendering, but has more recently gained traction in day-to-day computing in which rather than computing graphics for display, a GPU can be harnessed to execute similar types of instruction for the user. For example, when an application such as Photoshop enhances a photograph, it applies an algorithm to the image and historically the CPU would do this. Today, Photoshop can offload that processing work on to the GPU, which because of its very specialized design can do the work much faster—all without needing any assistance from the CPU itself. The main reason why a GPU is important in a device like the Pi is that even with a modest processor, it can still handle high-quality displays and decode high-quality video streams. This makes the Pi useful as a media device as well as allowing for a full graphical display that still feels snappy even with a slower processor. For the most part, the GPU is not something you will directly care about, but by knowing that the heavy duty graphics work can be offloaded somewhat from the main CPU, you can be more confident that the ARM that powers the Pi will be able to deliver enough brute force for your needs.
Ethernet Port (Model B only) You might think that there’s not really much to say about an Ethernet port. After all, it’s pretty straightforward: you plug it in and you can access the network. If you don’t have one, then you can’t. Simple enough? For me, the ability to connect to a wired network is essential. WiFi can often have issues and sometimes isn’t even available (especially if you decide to turn your Pi into a WiFi access point). Although this feature costs an additional $10, in my experience not having the network card when you really need it will cost you much more than $10 in time, effort, and general hassle. It is true you can add a USB network card to the Model A (and technically the card attached to the Model B is actually connected via USB), but that would cost at least $10 and then you’d have a USB device flapping in the wind. You might say to yourself “If it’s USB, I can use it with my other devices, too!” but in reality, you probably never will and you’re far more likely to lose the damned thing altogether (right when you most need it) than it is to come to your rescue in a time of need. However, one reason why you might decide on a Model A is that because it doesn’t have these extra components, it consumes significantly less power. This probably won’t be a major concern for most users, but if you’re planning on using the Pi in a battery-powered product, you would be very keen to lower the power requirements as much as possible. Overall, my recommendation is to get the Model B because you get the network card. If you’re absolutely 100% positive that you’ll never ever need Ethernet (or you want the smallest possible power footprint), there’s probably little point paying the extra cash for this version.
USB This isn’t so much a feature these days as a true requirement. Almost all peripherals connect this way and the Pi is no exception. It will work with all standard USB keyboards and mice, and assuming Linux has a driver for it, other USB devices as well (such as the Ethernet card in the Model B). Both models come with USB 2.0 support, although Model A only has a single port, whereas Model B has two. If you want to be able to plug multiple USB devices into your Pi, you might want to consider Model B, but if you’re setting it up as a basic desktop, you could use an external USB hub to get a similar effect.
GPIO Ports General Purpose Input/Output (GPIO) ports are a very interesting and key addition to the Pi. They provide an easy way to connect hardware to your Pi that you can then control through software. If, for example, you wanted to add a thermometer or light sensor, you could build a device that connects to your Pi via the GPIO ports.
xxvii
■ INTRODUCTION
If hardware projects don’t really interest you, then you can probably forget about the GPIO ports. But if you’re looking to integrate your Pi with various bits of hardware or make your Pi the brain of some wacky invention, GPIO ports will give you an easy way to do that.
Baked to Perfection By now, you’ll have picked up a pretty good appreciation for what the Pi is and what makes it special. It was designed to be low cost so that everyone who wanted one could get their hands on one, but the designers have gone to great lengths to make sure that even though the Pi can’t deliver everything a desktop can, it delivers more than enough to make it a fully functional computer laboratory not to mention a very nice server platform.
Whistle-Stop Tour So, what do we have in store for you in the rest of the book? The book is broken down into three core parts. In the first part I’ll show you how to get up and running with the GUI. If you’ve never heard of a GUI, this is definitely where you want to start. The Pi comes with everything you need, but out of the box it needs a bit of tweaking. Don’t worry; we’ll get you up and running quickly, and you’ll soon be off exploring. Part 2 takes you back to the command line and teaches you how to move around. Many people (myself included) spend the vast majority of time at the command line. It’s fast, powerful, and always available (even when a GUI is not, such as when you want to make changes via the network), but it is a little bit different from the GUI than most people are used to. Fear not; we all have to start somewhere and in this section we’ll make sure you’re comfortable and at home on the command line. In Part 3, we actually start to do more interesting things. By this stage you’re happy on the command line (which puts you ahead of most of the crowd) and now you want to delve a bit deeper and actually make the Pi work for you. We spend this section covering some of the great things you can do. I’ll give you the solid foundation you’ll need to do all of the hardware and software projects in Brendan Horan’s “Practical Pi Projects.”
Your First Bite of Raspberry Pi In Chapter 1 we look at what Linux is and why it’s on your shiny new Raspberry Pi. We take a brief look at different “distros” and explain why not all “Linuxes” are the same. We take a closer look at the Raspberry Pi and what makes it just that little bit different, and then we get your graphical interface up and running. We round off Chapter 1 with a quick tutorial on how to move around the desktop.
Surveying the Landscape Following on is a tour of the desktop and all the fun things that you can find. We start with the essentials and show you how to get online, check your e-mail, and get set up with instant messaging. We’ll then expand on that a little and shoot for some music and video. By the end of this chapter, you should be able to do your day-to-day computing without having to think twice about using a Raspberry Pi.
Remodeling the Landscape Once you’re happily browsing the web and sending e-mail, we will look at how to go about customizing your new home and making it your own. We’ll start with the obligatory “how to change your desktop background” and then move on to various other little tweaks and enhancements that you can do to make your time on the Pi as pleasant as possible
xxviii
■ INTRODUCTION
Getting Comfortable on the Command Line Now for something just a little bit different. You can use your Pi just like your other computer, but now we’re going to take it up a notch. In order to get the full benefit from Linux and to get your hands dirty with some very interesting projects (automatic cat detection and prosecution, anyone?) you’ll need to lift off the crust and start getting closer to the metal. The first place to start is the command line where you’ll be interacting with Linux on a very precise and powerful level. We’ll be starting off slowly and easing you into what is likely to be a very alien environment. We’ll discuss the shell, where it came from, and why it’s important. We’ll also look at a bit of the history involved because knowing where it came from (while fascinating in and of itself ) will help you get the full benefit from the experience.
Storing Stuff and then (Hopefully) Finding It Again Once you’re up to speed on what the command line is, it’s time for the most important subject. Most books start by telling you about all the shiny commands you can run, and that’s all well and good, but first you need some context. I’ll start you off by looking at the Linux file system and explaining the “everything is a file” philosophy that sits at the core of every UNIX–based operating system. This sounds a bit scary and we won’t go into too much depth, but with this under your belt you’ll be able to easily pick up new commands and make full use of them.
Getting Down to Business Now you know about the command line and how Linux lays out all your files, we’ll actually showing you how to make Linux do things. I’ll show you how to become root (does anyone remember the “power up” scene from He-Man? No?) and how to install new applications and tools. We will also briefly look at some useful command-line tricks that will make you a keyboard demon. You will soon find that you can do things far more quickly on the command line than by clicking your mouse . . .
Editing Files Next on our tour de force is editing files. I will show you my two editors of choice. One (nano) is simple, easy, and great for general use. I use it a lot for making small changes to config files. For more serious heavy lifting, I prefer vim. It has all sorts of magic codes and key presses (it’s like playing Dungeons and Dragons—not that I ever have), and if you can hold all the key-combos and commands in your head, well, you will never want to leave! For the rest of us, well, there’s always nano…
From Beginner to Admin Now we’re starting to take a look at system services and what makes Linux tick. You’ll learn that as smart as Linux is, it’s not that different from all the tools and things you’ve been running so far. You’ll be able to apply your newfound knowledge and be able to start and stop services to your heart’s content. Network services are the bread and butter of any server. Most people have used them from a user’s perspective but now it’s time to experience them from the pointy end. We’ll look at the usual suspects, such as OpenSSH and the Apache web server. We’ll explain the very real dangers of running your own servers on the Internet. There are people out there who would quite like to gain entry to your nice little server, and they do not much care who you are. Don’t worry; we’ll provide a simple list of do’s and don’ts that will put you ahead of the game.
xxix
■ INTRODUCTION
Magic Spells for the Command Line (aka Scripting) A script is simply a collection of shell commands in a text file that Bash (or a shell of your choice) will execute. Even in this simple form, they are very powerful, but you can do so much more. In short, you can automate a lot of tasks with relatively little effort, and you can build some pretty impressive tools, too. This chapter won’t make you an expert, but it will certainly give you a taste for the power at your fingertips. You might laugh at me calling them magic, but wait until you turn a tedious 3-hour task into a single command that completes in 4 seconds!
Pi Web Server We start the project section with a classic: getting a full LAMP (that is Linux, Apache, MySQL and PHP) stack up and running on your Pi. We will show you why your Pi is an ideal little web server and how it not only provides the perfect environment for development dynamic websites but also makes a great little portable website demonstration tool!
WiPi: Making Your Pi Wireless What’s more fun than a tiny little network server? A tiny little network server that has no wires! We’ll show you how to hook up a USB wireless network adapter so your Pi can talk to the world without any wires. If that isn’t enough, we take it one step further and look at ways of cutting the cords altogether and getting your Pi to run off a battery.
The Raspberry sPi: Security Cam and Messaging Service Want to know who is sneaking into your room and stealing all your pens? Your sPi has you (or your office) totally covered! In this chapter, we will show you how to hook up a webcam to your Pi and have it take snapshots of any movement in the room. Not only that; it will promptly e-mail you a copy of the intruder in real time! Even James Bond doesn’t have one of these.
MC-Pi: A Pi for All Your Media Needs Last, but by no means least, we show you how to turn your Pi into your personal media center. We show you how to stream video to your TV and how to act as an airport device for sharing music around the house. With high–resolution streaming video, we really start to push the Pi and show what it is truly capable of!
Onward We’ve covered a huge amount already. We’ve looked at how computing has changed over the years and how this has not only had an impact on how we see and use computers in our daily lives but also it has affected the way computers are perceived in education and the level and depth of knowledge that students are taught. We briefly touched on the Raspberry Pi Foundation and how it hopes that the Pi will start to reverse this trend. Next we looked at some of the more compelling reasons why you might want to get a Pi and why the Pi makes an ideal platform for development and experimentation. We then looked at what the Raspberry Pi is at the hardware level and discussed the differences between your main computer and the Pi. We examined the trade-offs and looked at why some of the decisions were made and what impact they will have on you as a user. Last but my no means least, we rounded off the introduction with a whirlwind tour of all the things that we’re going to cover in the rest of this book. So let’s head to the kitchen and make some Pi!
xxx
CHAPTER 1
Your First Bite of Raspberry Pi This chapter is where we finally get our hands dirty. If you decided to skip the introduction in your eagerness to get up and running, that’s fine; you won’t have missed anything critical for this chapter. However, make a note to pay the introduction a visit in the not too distant future as it gives you a lot of background on the Pi and what makes it so special. Now, back to dirty hands! We are going to start off by unpacking the Pi and going through the list of things that you need to actually get it up and running. Once we’ve hooked everything up, we’ll then need to sort out something for it to run—in this case, Raspbian Linux (more on this a little later). Once we get Raspbian running, we still need to configure it and some of the options are a little technical and Linux-specific; but don’t fret, we have you covered there, too. To round off the chapter, we will bask in the glow of the Raspbian desktop before heading off to Chapter 2 to see what we can actually do with it.
Your Freshly Baked Pi Arrives Okay, so the postman has just dropped off your long-anticipated package, and after eagerly ripping away the padded envelope you’re left with a little box, (little being the operative word). You simply can’t help but look into the depths of the envelope to see if there is perhaps something lingering at the bottom. Failing to find anything with a visual inspection, you’ll no doubt proceed to the old faithful approach of turning the envelope upside down and giving it a bit of a shake. Although you might shake loose the packing sheet (somehow they always seem to super glue themselves to the inside), you won’t find anything else. When you order a Raspberry Pi, this, dear reader, is all that you’re going to get (see Figure 1-1).
P. Membrey et al., Learn Raspberry Pi with Linux © Peter Membrey and David Hows 2013
1
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-1. What falls out of the envelope
WHY A PICTURE OF JUST A BOX? The honest reason is because when this is all that turned up, our first thought was that something must have gone missing. Yes, the site tells you when you order that this is all you are going to get, and it really makes perfect sense. We want to emphasize that this is all you get, and it’s not enough to get your Pi hooked up and in business. You will need other bits and pieces (some or all which you might already have), and it’s important to highlight it right at the beginning. In the next section, we will cover the kit you actually need to get started. You might spot the big label at the bottom that (in big bold letters) says GETTING STARTED. It also provides the address of the Raspberry Pi website with a direct link to what you need to get started. Not too challenging, you might think, assuming that you actually looked at this side of the box rather than simply ripping it open to get at your new toy. We would love to say that the first thing we did was visit that website, but we were somewhat overexcited about seeing a Raspberry Pi with our own eyes. Admittedly, the complete lack of any writing on the other side of the box was probably a dead giveaway that we were missing something important, but we were somewhat preoccupied with showing everyone in the office just how small a Raspberry Pi actually is. Believe it or not, we have company in the fail corner; another technically savvy new Pi owner converted his box into a Pi stand and missed the label altogether (and his packing sheet was MIA for nearly three weeks). Unsurprisingly, going to http://raspberrypi.org/downloads/ is actually a very good place to begin your journey, and we will be heading there shortly. If you have yet to order a Pi (or are waiting for it to turn up in the mail), Figure 1-2 shows one sitting next to a mouse.
2
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-2. A Raspberry Pi next to an average-sized mouse Even though the size of the Pi is well known and it comes in such a small box, it isn’t until you actually hold it in your hands that you realize how small it truly is! After “aw-ing” to ourselves (and anyone else who sadly for them happened to be within earshot), we figured it was time to get the show on the road. And that’s where things came to a somewhat abrupt halt. We had the Pi, but it had only just dawned on us that we didn’t have the faintest idea what we actually needed to make it go. Even though we’re not exactly new to all this, we let ourselves get caught up in the moment and for whatever reason hadn’t considered that the Pi would need anything special (or at least something that your average geeky type person wouldn’t have hanging around the house). If you’re not equipped with a cupboard of odds and ends straight out of Dexter’s lab, you might need to pick up a few things. Fortunately, they are all easy to find, and you should be able to pick up everything you need at your local computer shop. If you don’t fancy going on a treasure hunt, many companies are offering starter kits that come with everything you need. Because these kits are rapidly changing, the best way to find what’s available is to go online and search for “raspberrypi starter kit”.
■ Note Although we only cover HDMI in this book (so it’s the only display in the list), it is possible to use different types of display such as DVI, composite, or SCART with appropriate cables or adapters.
List of Ingredients To bake your Pi to perfection, you’re going to need the following ingredients: •
Raspberry Pi
•
Micro USB lead (for power)
•
USB power adapter (also for power)
•
HDMI lead: Type A to Type A (to connect to your monitor or TV)
3
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
•
HDMI display
•
SD card: 2 GB to 64 GB (for storage); 8 GB minimum recommended
•
SD card reader
•
USB keyboard and mouse
Micro USB lead If you happen to have an Android phone or a Kindle sitting about, chances are good that you’ve got a lead that you can reuse to power the Pi. This lead isn’t actually used for transferring data, and although you can draw power from a USB port (you can plug it into your main PC or laptop), you can’t use the USB connection for anything else. The different types of USB connectors are hard to describe if you haven’t already seen one. Take a look at Figure 1-3 for some examples.
Figure 1-3. Different types of USB connectors The connector you’re interested in is the first one on the left, known as a micro USB. Be careful because on quick inspection, a micro USB plug can easily be mistaken for a mini USB plug (second on the left). The last thing you want to do is make a special trip to the store and then come back only to find out that you picked up the wrong one!
USB Power Adapter You might actually be able to get away with this one. A normal USB port can power a Model A Pi (the one without built-in Ethernet), and for testing you can probably get away with doing the same with a Model B. That’s all well and good as long as you want to have your Pi sitting next to your PC, but chances are you want it to be somewhat independent. Even if you do plan on using it in the same location, powering it from your laptop can prove to be
4
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
problematic when you want to take your laptop somewhere, but your Pi is busy doing something and you really don’t want to unplug it. Fortunately, the sheer number of devices that adopted USB as a means of charging means that you can get main adapters really cheaply and easily. As far as which adapter to get, that really comes down to personal choice. However, as the Model B requires 700 ma and you always want to have a bit of room for expansion, you probably should aim to get an adapter that can provide at least 1000 ma (or 1 amp). From our highly scientific tests (wandering around numerous shops and squinting at packaging labels), it seems that 1000 ma is actually the most common rating. We did come across some rated at 500 ma and although that’s enough for most USB devices (and even the Model A Pi), it isn’t really enough for your needs.
HDMI Lead Over the past few years, HDMI has become the de facto standard in connecting a myriad of devices to both monitors and TVs. This is really handy because it means that if a device supports HDMI, it can be easily connected to any display that supports it. This might not sound all that impressive, but it wasn’t too long ago that TVs and monitors were very separate things and usually there was no direct way to connect, say, a computer to a TV or a VCR to a monitor (although interestingly if you go back 20 years, all home computers connected directly to the TV (for example, the Commodore 64 or Spectrum). Of course, you could get special hardware, and some higher-end devices did offer a range of different connectors, but as a rule, the two worlds didn’t really mix. Fortunately, the Pi uses HDMI, so we can ignore the irritations of the past. To connect your Pi to a display, you will need a “Type A to Type A” lead. Type A is the size you will find in the back of your TV or monitor; all you have to do is find a lead for connecting some device via HDMI to a TV and where both ends are the same size. Most consumer electronics use Type A, so if you have an Xbox 360 or your laptop has HDMI, chances are you already have a lead of the correct type.
HDMI Capable Display You probably saw this one coming, but you’re going to need some sort of display that supports HDMI. As it has been widely adopted over recent years, practically every new TV comes with one or more HDMI ports. These days, it’s fairly common to see three or four ports on a TV because you’ll need that many to hook up all your new digital devices. It’s pretty easy to determine whether your TV or monitor supports HDMI. All you have to do is look for a physical HDMI port. You are much more likely to find it on your TV rather than your monitor, but many of even the more basic monitors these days seem to support it. In our case, it turned out that the aging monitor didn’t support HDMI, although the TV in the living room did. Of course, it being the main TV meant that people wanted to watch TV on it and admittedly we were not looking forward to sitting cross-legged on the floor in front of a big TV, trying to convince a Pi to boot. In the end, we decided to get a new monitor that supported it. Although we could have bought a DVI converter, we decided we couldn’t pass up on the opportunity to get a new shiny toy. If you can’t reuse your TV or computer monitor, you should be able to get your hands on a basic TV or monitor that supports HDMI quite easily. As mentioned earlier, the Pi does have composite output as well as HDMI, so you could certainly use that if you prefer.
SD Card Most computers use a hard drive of some sort as their primary form of storage. Even laptop-sized disks are larger than the Pi, and although the newer solid state disk (SSD) models draw very little in the way of power, they would certainly drastically increase the amount of power your Pi would need. Fortunately, we have an alternative. Rather than using something heavy duty like a hard disk, we can instead borrow technology that cameras have been using for many years: flash memory. Although the cards can’t match a hard disk for space or for performance, they are exceptionally
5
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
good for power usage and despite being smaller than their erstwhile cousins; 64 GB (the maximum for your Pi) is still a reasonably impressive amount and probably more than you will need for your Pi. SD cards are standardized so there isn’t too much more to say about them. You do want to get a high-performance card if you can (often referred to as Class 10) but they ultimately all do the same job. That said, we have heard of some SD cards that haven’t worked with the Pi, but if you stick to a well-known brand you should be fine. As there are lots of different types of memory cards floating about these days, Figure 1-4 shows what an SD card actually looks like.
Figure 1-4. SD card with micro SD and adapter The card on the far left is your typical SD card; on the far right is a micro SD card. They have become pretty popular for use in smartphones (particularly Android-based phones), and because most phones come with small cards (in terms of storage space), it’s not unusual to either buy a larger card or have one thrown in as part of your phone package. If you happen to have one of these floating about, you can use it with your Pi by using a micro SD adapter (shown in the middle of Figure 1-4). They tend to come with micro SD cards because often one would use the micro SD in a phone but the laptop would only have the full-sized SD card. We haven’t seen the adapters for sale individually as they are basically just a physical adapter, but they do tend to end up in the strangest of places so you never know!
SD Card Reader Now that you have your SD card, you need some way to actually use it. The Pi has you covered and has an SD card slot built right in. However it doesn’t actually have any other storage on the device, so it’s effectively a blank slate until you insert an SD card with something useful (like Linux) installed on it. The thing is, to put Linux on the card, you need a device that’s already up and running that can also read and write to the card. This is a classic Catch-22 situation. Even if you could borrow someone else’s card with Linux already installed, you couldn’t simply swap out the cards because as soon as you do that, you won’t have Linux anymore!
6
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Again, thanks to the proliferation of digital cameras, many computers come with card readers built in. Many (often dubbed as media PCs) come with a whole range of slots for various different card types. So chances are you already have a way to read the card. If you don’t have a reader already, you can pick up any cheap multicard reader from your local computer store. They’re generally inexpensive and will support lots of different types of cards. Just make sure that it has an SD card before you hand over your hard-earned cash! For reference, the adapter we are using looks like the one in Figure 1-5.
Figure 1-5. Multicard reader
USB Keyboard and Mouse Last but not least is the good old keyboard and mouse. Advanced as the Pi is, it doesn’t yet have telepathy so you’re going to need some way to control it. This is common sense, but with modern computers often coming with a wireless keyboard and mouse and a fair few of those using Bluetooth with no USB adapter (even some with an adapter have been known to cause problems), you might find that your current keyboard and mouse just won’t work with your new toy (no Bluetooth on the Pi, I’m afraid). There’s really no need to go into any detail here as any keyboard and mouse will do, and this is mostly a reminder to check what you actually have before you go out to buy your Pi-making ingredients to avoid untold frustration when you get home and find you’re completely stuck.
Whew, We’re Done! Finally we have everything we need! Hooking all this stuff up to your Pi is very easy, especially as each item has a unique shape so it will fit into only one slot (see Figure 1-6 for the finished Pi).
7
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-6. A fully loaded Pi If you put everything together, plug in the power, and turn on your TV you should see… a completely black screen.
Don’t Panic! When your PC or laptop boots, there is a piece of software called the BIOS that kicks everything off for you. It tests the memory, sets up a basic display, and allows all your devices to initialize. On some machines (notably those from Apple) the machine will have an EFI instead of a BIOS. For all intents and purposes (at least from our point of view), they’re basically equivalent. Regardless of the technology used, it is this system that finally hands control over to your bootloader, the piece of software responsible for starting your operating system. BIOSs are by nature very noisy, and if you get something wrong it will either bleep a lot (with some magic number code that you can only find in the BIOS manual that you threw in the bin 3 years ago) or display some helpful yet cryptic message on the screen. In short, it may not do what you want, but at least you know that your computer is still alive. Although it has a little red LED “on light”, the Pi won’t do a thing unless it has a bootable operating system on its SD card. If you were expecting some sort of splash screen or other sign of life (hands up; we know we were), you’re out of luck (and probably thinking you have a dead Pi). Now that you know what you need to restore the Pi to life (a bootable operating system) it’s time to move on to Phase 2 of our master plan and get us some Linux!
Linux As this is a book for beginners, we’re going to take the time to talk a little about Linux, where it came from, what’s special about it and some of the little gotchas that trip people up from time to time. If you already know this stuff (or simply don’t care), feel free to skip to the next section “Downloading Raspbian.” For those who want a quick refresher, just keep on reading.
8
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
What Is Linux? Ah, this simple question opens a big can of worms that many people go out of their way to avoid. The reason is that in technical terms, Linux means one thing but in general speech, it tends to mean something else. When talking about operating systems in general, we see Microsoft Windows and Apple OSX to be discrete, whole things. If you say “I run Windows,” everyone knows what you’re talking about. With Linux, it’s a bit different. Linux is just an operating system kernel, which means that it handles all the low-level bits and pieces such as handling device drivers, and providing easy access to networks and hard disks. What actually makes Linux usable is all the software that is wrapped around it. Not much trouble there, but it starts to get complicated when you realize that people have differing opinions about what software should be wrapped around it. There are no simple or minor opinions when it comes to computing! As this software is open source, and anyone can put it together in pretty much any way they like, people have been able to build their own Linux distributions. This is an operating system with Linux at its core, but with the surrounding ecosystem set up to match the goals of the people who built it. For example, Red Hat Enterprise Linux (RHEL) is built to be robust, supportable, and stable over long periods of time. Fedora, on the other hand, is released every 6 months or so and has the latest and greatest of everything in each build. Gentoo requires that you build your software from source (so it can be completely optimized for your machine), and Debian goes to great lengths to remain stable and secure at the cost of introducing new features.
OPEN SOURCE In the olden days, when computers cost millions of dollars, it was the machine itself that sold, not the applications that ran on it. It was common practice for a company to write software for you, in order to get you to buy their machine. It wasn’t until computers became commodity items that suddenly the value was in the software, and companies moved to start protecting the software they’d written. One way to do this is to provide the software ready to use without the source code (which is effectively the blueprint on how to make the software). This meant that you couldn’t change the software or make improvements to suit your changing needs. Many people believe that software should always come with the source code so that people can make changes. Open source revolves around the idea of people being able to freely exchange, modify, and improve software collectively. This can only be done when the source code is provided freely and permission is given (through an open source license) to make those changes. Entire books can and have been written on this topic, but you can find a presentation on this topic that Peter gave at his university last year: http://www.youtube.com/watch?v=c-1LQIGh6cI So which one is best? Well, that depends on your needs! There’s no perfect distribution; just the best fit for a particular job. For the Pi, the official and supported platform is Raspbian, which is based on the Debian distribution. Because it is supported and because it’s the easiest to use (and quite likely the fastest to get updated and fixed when things go wrong), we’re going to stick to using Raspbian in this book. If you do fancy something a little different, Brendan Horan’s upcoming book (also from Apress), Practical Raspberry Pi will show you in great depth how to install Fedora and (if you’re feeling particularly brave) how to make a custom build of Gentoo! When the Linux kernel first debuted in the early 1990s, no one really appreciated the huge impact it would have on the world of computing. Open-source software had already been around for a long time before this, and countless tools for the UNIX platform had already been released (such as the awesome GCC compiler). However, they were just tools and software packages. They still needed a proprietary operating system to run (the only kind available at the time). To be fully compatible with the open-source ethos, what was needed was an open-source kernel to power these systems. and this is what Linux delivered. While many will talk about how this brought freedom and hope to the world of computing, we will save you from that particular lecture (although admittedly there is quite a bit of truth to it) and simply say that it was the Linux kernel that really brought open source to the eyes of the general public.
9
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Now that the world has Linux, what exactly can we do with it? Almost anything we like—such as installing it for free on our Pi.
Downloading Raspbian At last we’re off to http://raspberrypi.org/downloads/ to get our hands on Raspbian. Not only does the page contain links for the download we’re looking for but it also has links for various useful tools as well as links for other prebaked Linux distributions for the Raspberry Pi. We touched on this lightly in the previous section, but if you’re thinking about getting one of the more exotic distributions, take a look at the “Why Raspbian?” sidebar.
WHY RASPBIAN? As you can see from the download page, there are numerous distributions to choose from, and especially if you’ve used Linux elsewhere you might be tempted to pick something other than Raspbian. However, before you download that exotic distribution, you should know that the majority of people using a Pi run Raspbian—and as such most of the support, blog posts, and tutorials (not to mention this book) are all based on it. This means if you pick something else, you might find it much harder to get help if something doesn’t go quite according to plan. The other more subtle issue is that the Raspberry Pi is an ARM-based device. It doesn’t quite work the same way as your PC does. For example, the Pi doesn’t have a PCI bus, so any tools that expect there to be one (and there are more than a few) just won’t work. There are also quite a few gotchas for these other distributions, and they might not be as well maintained as Raspbian. In short, you will be taking on much more work if you don’t pick Raspbian to start out. Traditionally, a Linux distribution will come on a set of CDs or DVDs. When you download your distribution of choice, you would download a set of images. These images are basically a clone of the real thing. The idea is that you take the image and once you write it to a CD, that CD will be identical to the one the image was originally cloned from. Raspbian (and the Pi in general) is a bit different. It doesn’t have a built-in CDROM or even a floppy drive. Instead of downloading an image of a CD or DVD, we’re going to download an image of an SD card that contains Raspbian all set up and ready to go. You can download Raspbian either directly from the site (there are numerous mirrors) or via BitTorrent. BitTorrent can sometimes be faster, and it helps take some of the load off Source Forge. However, there are some places where you probably shouldn’t be firing up a BitTorrent client (i.e., at work), and some connections perform very badly due to the way BitTorrent works (such as mobile 3G). If in any doubt, just select the direct download. We want the mainline version of Raspbian (Raspbian Wheezy), which is the first one in the list of available distributions for download.
Getting Raspbian onto Your SD Card Getting Raspbian onto your SD card isn’t as easy as simply copying across the file. Remember we downloaded an image that is a direct representation of what should be on the card. If you just copy the image onto the card, it will still just be a card with a copy of the Raspbian image on it. What we need to do is write the image directly to the card, and for that we’re going to need some of those handy tools we briefly mentioned earlier.
10
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
■ Note The image file you downloaded is a compressed ZIP file. On Windows 7, double-clicking this file will open a Compressed Folder. You will need to copy the image file itself to another location such as My Documents. On the Mac, simply double-clicking the file will extract the image and place it in the Downloads folder.
Using Image Writer on Windows The tool recommended for writing images on Windows is the somewhat predictably named Image Writer. You can find the link on the Raspberry Pi downloads page; you want the binary version highlighted in Figure 1-7.
Figure 1-7. Download the binary version of Image Writer Depending on what software you have installed on your PC, you will either be able to open the download as a folder or open it in your ZIP program of choice. Either way, you need to extract all the contents before you can run the application. If you are just using the standard Windows tools, when you double-click the program (Win32DiskImager), you will be prompted to extract the contents to another location. 1.
Select Extract All and make sure that Show Extracted Files When Complete is checked on the next window.
2.
After you press Extract, you should see the same folder layout as in the ZIP file.
3.
Double-click the program in this new folder and you should be able to open the tool. Because the program isn’t digitally signed, you will get a warning like Figure 1-8.
11
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-8. Windows will warn you when you run Disk Imager 4.
Because the tool needs low-level access to perform its main function (i.e., writing directly to disk-based devices), Windows will warn you that the program wants to make changes to your computer. Click Yes to continue.
5.
We’re not sure if you will see the message shown in Figure 1-9, but it happened on both the machines we tested it on. In both cases, it didn’t seem to affect the program, but just in case you do see it, we thought you’d like to know you’re not the only one!
Figure 1-9. Error occurred when opening Image Writer
12
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
■ Note Image Writer will look only for cards to write to when it starts up. That means you’ll need to have your SD card in the slot before you start the application; otherwise, you will get an empty list, even if you later insert the card. 6.
In our case, the device we want to write to is drive G:\, but you should choose the right one for your system. If the Device drop-down menu is empty, try closing Image Writer and reopening it as sometimes it seems to miss things on the first try. It goes without saying that you should make sure that you’ve actually picked the right drive—the last thing you want to do is accidentally erase the card from your camera and all those special family moments that you’ve captured over the years!
7.
Once you’ve selected the right device (take a quick look in My Computer if you’re not convinced) and you’ve picked the Raspbian image by browsing to it, click the Write button and sit back and relax. It does take a fair bit of time to write the image (it depends on how fast your card is, among other things). However, it gets faster as it goes along (it’s mostly writing zeroes at this point), so it will probably be done within a few minutes. Figure 1-10 is an action shot of Image Writer during our tests. From the screenshot, you can see that the image we’re writing to the SD card is the current (at least at the time of writing) Raspbian release.
Figure 1-10. Action shot of Image Writer writing the image 8.
Once complete, take the card out of its slot and feed it to your Pi.
You’re ready to rock and roll! To get started, flip through to the section, “First Boot,” to get the show on the road!
■ Note If you look closely at the filename in Figure 1-10, you can see that it has an extension of .img. One of the more common mistakes when writing an image is to accidentally write the ZIP file rather than the decompressed image file (after all, they have almost identical names). When you come to boot up your Pi, if nothing happens, come back and double-check that you picked the right file.
13
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Using dd on the Mac If you are using a Mac, we want to show you how simple it is to write an image to your SD card. Alas, we can’t do that because there isn’t a simple, easy way to do it. Disk Utility, which excels at so many other things, simply does not know how to handle our standard image files. We tried converting it to a .dmg file (the native image format for a Mac), which didn’t work, either. We also looked at online tools that you might have been able to download to help with the problem, but we didn’t find anything that made the task significantly easier than doing it by hand in the first place. So we’re going to get our hands dirty on the command line a little bit earlier than planned. We’re not going to go into too much depth about what it is we’re actually doing because most of these commands you’ll see a little later in their Linux incarnations. For now, you’ll just have to trust us.
Finding the Terminal First, we need to open the terminal. You can find it in the Utilities directory under Applications. To put the following into context, we end this section with a complete transcript of all the commands that we used. The process is reasonably straightforward; it just has a fair number of moving parts. We opened the terminal and now we need to use sudo to become the root user, the equivalent of Administrator on a Windows machine. Now, tinkering with low-level devices is dangerous for security reasons (you don’t want a virus being able to write directly to a hard disk, for example), so a normal user is not allowed to issue commands at that level. Because we need to write our Raspbian image directly onto an SD card, we simply have no choice: we need direct access to the card. Fortunately, root has effectively unrestricted access to the machine, so as root we can write the image to the card. The command we need to use is this: sudo –i This command opens an interactive prompt as the root user and gives “super user” privileges. You can use sudo to execute commands directly, but because we are going to be executing a few of them, it’s more convenient to do it this way. sudo will then prompt you for your password (the one you normally use for your user account). Once sudo can confirm that it really is you sitting at the keyboard, you will end up at a root prompt.
■ Caution We now have permission to do anything we like on the system. And although that means we can now make our image, it also means that we could really mess things up if we aren’t careful. Under UNIX, it is assumed that root knows what it is doing and there is very little in the way of safeguards. Be very careful when running any command as root, double-check it (and then do it again), and only when you’re completely sure should you hit the Enter key. As soon as you’re done, you should also close the terminal window, just in case.
Using the Terminal to Write the Image Okay, so what now? One of the challenges with writing to the SD card is to know which device on the system that card actually is. You don’t want to accidentally mistake your main hard disk for it because that would have some rather unpleasant consequences. There are generally some assumptions you can make (for example, we know that /dev/disk0 is usually the system disk, so you never ever want to write to this), but in order to limit the risk, we’re going to do this one by the numbers.
14
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
First, make sure your SD card is not attached to your Mac and then run the mount command like so: mbp:~ root# mount /dev/disk0s2 on / (hfs, local, journaled) devfs on /dev (devfs, local, nobrowse) map -hosts on /net (autofs, nosuid, automounted, nobrowse) map auto_home on /home (autofs, automounted, nobrowse) mbp:~ root# Now, you will probably see something similar to this, but it might be a little different. We can ignore devfs and the map lines as they’re really just parts of the operating system. What we’re interested in here is the first line that identifies /dev/disk0s2 on /. This is the system disk, and we want to make sure we don’t touch this one. You might have additional entries in your list if you have any network drives mapped or disk images attached. That’s okay because we’re not really looking for anything in particular at this stage; we just want to establish a base line for your system. Okay, now it’s time to slot in your SD card. SD cards come preformatted for use in cameras (although these days many cameras will reformat them, anyway) and so you should see it show up in Finder under Devices. Our card looked like Figure 1-11.
Figure 1-11. What you’ll see in Finder after inserting your SD card As the card has been automatically mounted, we can now go back and rerun our mount command to see how things have changed. Here’s what we got when we reran it: mbp:~ root# mount /dev/disk0s2 on / (hfs, local, journaled) devfs on /dev (devfs, local, nobrowse) map -hosts on /net (autofs, nosuid, automounted, nobrowse) map auto_home on /home (autofs, automounted, nobrowse) /dev/disk2s2 on /Volumes/UNTITLED (msdos, local, nodev, nosuid, noowners) mbp:~ root# What we care about here is the addition of a new disk, in this case disk2. We can see from where it is mounted (/Volumes/UNTITLED) that this is the disk we are interested in. So now we know where we want to write our image.
■ Info BSD systems split disks out in slices. In our example, the mounted file system was on disk2s2. This translates to disk2, slice 2. This allows you to reference a slice directly, but for our purposes we want to write to the device. So in our case we will be writing to /dev/disk2.
There is one little wrinkle, though. We can’t write to the SD card directly while we have it mounted and usable. If we eject it from within Finder, it will not only unmount the filesystem but it will also eject the device as well. That doesn’t help us because we still need the device to be present in order to write to it. To solve this issue, we will unmount the filesystem manually using a Mac-specific command called diskutil. The Mac does have the general
15
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
UNIX umount command (which we’ll cover in later chapters), but if anything on your Mac happens to be looking at the SD card, umount will fail and claim that the device is busy. diskutil is aware of this and can usually unmount the device without any problems. We ran the following command: mbp:~ root# diskutil unmount /dev/disk2s2 Volume UNTITLED on disk2s2 unmounted mbp:~ root# So we gained super-user privileges, we isolated the device that we want to write to, and we unmounted the filesystem so that we can write directly to the card itself. All we have to do now is actually go ahead and do the writing! The tool of choice for this task is called dd. This tool is a bit old school in that it only cares about reading from a device and writing to a device. It has no interest in filesystems nor is it aware of any of the subtle differences between a hard disk and an SD card. It just reads and writes without caring where it reads from or writes to. This is a fundamental UNIX principle that we will be revisiting in later chapters. For now, we’re going to take advantage of this to make an exact copy of our image file on the SD card. dd only needs to know two things: where to read from (the if= argument) and where to write to (the of= argument). We figured out the writing bit (it’s going to be /dev/disk2), but what about the source? If you followed the earlier instructions, you should have the image file sitting in the Downloads directory in your home area. The easiest way to get the information we need into terminal is to type this in: dd if= Then go to your Downloads directory in Finder (or wherever you extracted the image file to), click and hold on the image file, and then drag it on to your terminal window. This should then paste in the full path for you without you needing to type anything in. This should mean you end up with something pretty similar to this: dd if=/Users/myuser/Downloads/2012-08-16-wheezy-raspbian.img Now we have our input file specified, all we need to do is specify where exactly we want dd to write it. Thanks to our earlier experimentation we know that this will be /dev/disk2. We’re also going to add bs=512 which lets dd write the image in bigger chunks (meaning you won’t have to wait four hours for it to complete). So the full command we need for dd looks like this: dd if=/Users/miggyx/Downloads/2012-08-16-wheezy-raspbian.img of=/dev/disk2 bs=512 Running this command might take some time (hours, not seconds). The image is about 2 GB in size, and your average smart card reader is not particularly fast. With our USB adapter, our recent MacBook Pro took a good two hours to actually write the image. After coming back later, you should find that dd has completed its task and you’re back at the command prompt. Okay, admittedly this wasn’t quite as simple or straightforward as writing the image on Windows, but if you look at everything we had to do, using the command line allowed us to express what we wanted in a very compact and precise way. This is something we come back to in Chapter 3, in which we look at the various benefits of learning to use the command line. Here is the full transcript of the commands we entered in order to write the image to the disk. If something in our explanation didn’t quite click, or you’re not entirely sure what the end result should look like, you can use the following transcript as a reference to compare your version with ours: Last login: Wed Sep 19 13:48:40 on ttys000 mbp:~ pmembrey$ sudo -i Password: mbp:~ root# mount /dev/disk0s2 on / (hfs, local, journaled) devfs on /dev (devfs, local, nobrowse)
16
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
map -hosts on /net (autofs, nosuid, automounted, nobrowse) map auto_home on /home (autofs, automounted, nobrowse)
mbp:~ root# mount /dev/disk0s2 on / (hfs, local, journaled) devfs on /dev (devfs, local, nobrowse) map -hosts on /net (autofs, nosuid, automounted, nobrowse) map auto_home on /home (autofs, automounted, nobrowse) /dev/disk2s1 on /Volumes/UNTITLED (msdos, local, nodev, nosuid, noowners) mbp:~ root# diskutil unmount /dev/disk2s1 Volume UNTITLED on disk2s1 unmounted mbp:~ root# dd if=/Users/pmembrey/Downloads/2012-08-16-wheezy-raspbian.img of=/dev/disk2 bs=512 mbp:~ root# With our (painstakingly) prepared SD card, we can finally move on to the next step.
First Boot Okay, that was a bit of a marathon, but hopefully it’s something you will only need to do once. Once you get the hang of it, it’s not so bad; it’s just that there are quite a few moving parts. Armed with our freshly imaged SD card, we can at long last boot up the Pi. Plug in your keyboard, mouse, and monitor, and slot your SD card into your Pi. All you have to do now is attach the power lead and you’re good to go! All being well, you should see a screen like Figure 1-12.
Figure 1-12. The Pi’s first boot—it lives!
17
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
If you can see something similar, congratulations, your Pi is up and running! If not, there are a few common things that might have gone wrong. The first thing to check is whether your Pi has a nice red glowing power LED. Now we know this sounds obvious, and we know that it’s probably the first thing you checked, but not checking it is also the most common mistake to make. If your desk looks anything like ours, you will have a fair collection of cables draped about. It’s not too much of a stretch to see how you might have plugged in the wrong cable or that the cable you’re using isn’t actually plugged in to a live power source (some laptops, for example, turn off USB power when they go to sleep). Either way, this is what you should check first because if you did make a mistake, only you will know about it. This is much better than having an extended discussion on the forums trying to get help only to then realize that whoops! you forgot to plug it in. The second thing to check is whether you have selected the right input on your TV or monitor. Most TVs have multiple inputs these days, and monitors often as not don’t default to HDMI (ours doesn’t), even if that is the only input signal they are receiving. Obviously, we can’t tell you exactly how to fix or check this one as it all depends on the equipment you’re using. However, it should be fairly easy to flick through the different inputs to see whether or not your Pi turns up. In one interesting case, even though on the TV the port clearly said HDMI2, the Pi was actually visible on HDMI3. We have no idea why, but had we thought to flick through the inputs before fiddling with the Pi, we could have saved ourselves a fair bit of grief. The third thing to check is that the SD card is fully inserted into its slot. The Pi will quite literally do nothing unless it can find the card and boot from it, so if all you’re getting is a black screen, this could well be the reason. If you are sure the card is inserted properly, but you’re still not having any luck, it might be that something went wrong when you wrote the image to the card. In that case, flip back to the last section and have another go at writing the image to the card. If you still aren’t getting anywhere and you’ve checked that everything is all plugged in nicely, you have the right input on your monitor, and you have a happily glowing power LED, then it’s probably something more onerous. Unfortunately, without being there with you to look at your poorly Pi, we can’t really give any more specific advice. Fortunately, you’re not alone; there are lots of people on the Raspberry Pi discussion forums who are ready to help out. To visit the forum, go to www.raspberrypi.org and click the Forum link (just below and to the left of the Raspberry Pi logo). This will get you to the main forum page; the particular board you’re looking for is Basic Usage and Setup under Using the Raspberry Pi.
Configuring Your Pi After the torrent of incomprehensible text (though we’re sure it means something to someone) you should end up at the configuration shown in Figure 1-13. This is where we’ll configure your Pi for general use so that next time you turn it on, you will be greeted with a nice desktop rather than some chunky text.
18
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-13. First boot: time to configure your Pi! We are only going to cover the basic configuration options here (and you can always go back and change them once you’ve got your Pi up and running) as we want to get you in front of a working computer as soon as possible. To start with, ensure that your Pi is configured to boot to the desktop (select the boot_behavior option to make sure that the desktop will appear next time you boot your Pi).
Expanding the Filesystem The first option of interest is expand_rootfs, which, as the description suggests, will expand the filesystem to fill the entire card. The image we downloaded was around 2 GB after we decompressed it and this is what we wrote to our SD card. So although you might have an 8GB card or larger, you will be able to see only the first 2 GB of it. By expanding the filesystem, we can take advantage of all the space that you have available. This approach works pretty well because it means we don’t need a different image file for each disk size; we can all use the same small image and simply expand it to fit our needs. Using the arrow keys, move the bar down to highlight expand_rootfs and press Enter. You should see a window that tells you that the partition has been resized, and the filesystem will be resized after you next reboot. Press the Enter key to get back to the main menu.
Configuring the Keyboard The next option of interest is configure_keyboard. By default, Raspbian assumes a UK keymap, but chances are you will want something else. Be warned, though, that Raspbian knows a huge number of keyboards, and the sheer quantity can be confusing. For instance, do you know if you have a generic 104 key keyboard or is it actually a 105 key version? We weren’t sure either, so we stuck with the default: the Generic 105 key (Intl) PC shown in Figure 1-14.
19
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-14. Choose your keyboard If you can find your exact model, by all means feel free to select it. If you aren’t sure, you’re probably best off following our lead and sticking to the default. Once you have settled on your keyboard of choice, press Enter to move through to the next screen. Now we get to choose which keymap we want to use. By default, it lists various UK keymaps (as shown in Figure 1-15), but if you aren’t lucky enough to own a British keyboard, move the bar down to Other, press Enter, and then scroll through the list to find something more suitable for your needs. Once you’ve found the right keyboard, again just press Enter to move on to the next screen.
20
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-15. Choose your keyboard layout If you’re not sure what to select from the menu (shown in Figure 1-16), you’re not alone. For most people, the keyboard defaults will be fine because they will include any special key combinations that your particular keymap already offers. This is one of those times when if you need to make a change, you probably already know why and what to choose. If you are in any doubt, just leave the default selected and press Enter. Now you will see another menu that looks suspiciously like its predecessor (shown in Figure 1-17), at least in terms of knowing what to pick. Again you probably already know if you need to change anything here; if you’re not sure, you should just select the default by pressing Enter.
21
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-16. Customize your keyboard configuration
Figure 1-17. Customize your keyboard some more
22
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
The next menu (shown in Figure 1-18) only really means anything to old-school Linux users. Back in the day, if your GUI decided to crap out on you, you could effectively “reboot” the session by holding down Ctrl + Alt + backspace. As the GUI has become more stable, and Linux has become more mainstream, this feature is more often than not disabled. We haven’t had to make use of it for years, although we do happen to think it is quite useful. The default is No, and this is probably what you want. You can always go back and change this later if you find yourself craving this particular feature. To pick the default (and finally return to the main menu), just press Enter.
Figure 1-18. Do you want to enable the X server kill switch?
Changing the Password Next we’re going to change the password for the pi user account. This is the account you’ll be using throughout the book, and for most people this will be the only account you’ll ever need on your Pi. At the moment, although the password is set to raspberry and it is the default, it means that anyone can log in to your Pi. While securing your Pi against unauthorized intruders is probably not top of your list of priorities, it is still good practice to change this just in case. Later on, you might make your Pi available via the Internet and in your excitement you might forget that you didn’t actually get around to changing the password. Bad things will happen. So let’s take the opportunity to make the switch now. Highlight change_pass and press Enter, and you’ll see something like Figure 1-19.
23
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-19. Time to set your password The configuration tool has executed the standard passwd command, which is why you’re looking at a text prompt rather than a prettier menu. Just enter your new password (remember that it is case-sensitive: HeLLo is not the same as hello or Hello) and press Enter. For security reasons, the password won’t be shown on the display and it won’t show any stars to let you know you’ve actually typed something. You will then get prompted to enter your password again; after you press Enter, you will be back at the configuration menu. (Getting a sense of deja vu yet?).
Configuring the Locale Next is configuring your locale. By telling Linux where you are in the world, it can determine useful things such as the separator between numbers and which currency symbol to use. For example, in the United States we might write 1,000.00, but in many places in Europe it would be written as 1.000,00. Either way for maximum comfort and to ensure that everything just looks right, we need to set the locale. Highlight the change_locale option and press Enter. You’ll now be presented with an extensive list of different locales to choose from (see Figure 1-20). The first two letters in the name specify the language while the second pair of letters specifies a regional difference. For example, en_US would be English customized for US users but en_GB would have settings specific to English speakers in the UK. You should select the language and country pairs that most closely match your needs and choose them by pressing the spacebar. You probably want both the ISO-8859 and the UTF-8 versions. If you decide to hedge your bets and select all locales, be warned that you will be in for quite a wait as the Pi generates all the locale settings for you. In fact, we tried this option and after waiting ages for just two locales to be generated, we got fed up and pulled the plug. After you select the locales you want, press the Tab key once to highlight the OK button and then press Enter to move to the next screen. Here you’ll need to pick the locale you want to use by default (see Figure 1-21). Once you have made your choice, highlight it and press Enter. Once again, we’re back at the main configuration page.
24
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-20. Select which locales you want to use
Figure 1-21. Now pick which locale you want to use by default
25
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Changing the Time Zone The change_timezone option does pretty much what it says. After selecting this option, you’ll be shown a list of regions (shown in Figure 1-22). In this case, we were configuring Pete’s Pi, so we selected Asia. The next screen will give you a chance to fine-tune your selection and pick your country or city (see Figure 1-23). Once you’ve found the closest match to you, select the option and press Enter.
Figure 1-22. Select your region
26
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-23. Select your country or city
Allocating Memory The memory_split option needs a bit of explanation. Your Pi has two main processors: the CPU (or central processing unit) and the GPU (or graphics processing unit). The CPU is responsible for the general running of your machine, and the GPU is responsible for handling the display and provides features such as 2D and 3D acceleration as well as hardware support for decoding high-quality video streams. A GPU is dedicated to handling graphics (for the most part) and cannot perform the role of a CPU. However, it does mean that if the CPU can offload all the complex graphics work to the GPU, the CPU doesn’t have to be quite so powerful. By having both, the Pi keeps the costs and power requirements nice and low but without sacrificing much in the way of performance. So far so good; but what does that have to do with splitting memory? The Pi comes with 256 MB of RAM in total and it needs to supply both the CPU and GPU. As the GPU is effectively an independent unit, it needs its own allocation of memory. Rather than having dedicated memory for both, it is possible to split the 256 MB between the two processors. By default, the Pi allocates 192 MB for the CPU and only 64 MB for the GPU. This is ideal if you want to use the Pi as a server or you never plan to attach a display to your Pi. If you’re not using graphics, allocating additional memory to the GPU is somewhat pointless. On the other hand, if you plan to use your Pi as a mini desktop computer or to display high-quality movies, you’re going to want as much memory allocated to the GPU as you can get away with (which in the case of the Pi means splitting it down the middle and having 128 MB for each). It would be difficult to anticipate how everyone will want to use their Pi, and apart from adding more memory to the Pi itself (and raising the cost) there is no easy solution. Fortunately, we have the ability to choose how we want to allocate the memory ourselves. For general usage and “getting started”—type tasks, we recommend you split the memory 192 MB/64 MB. To set this up, select the memory_split option from the menu, press Enter, and you’ll have something similar to Figure 1-24. Type in the memory split that you want and then press Tab to highlight the OK button and then press Enter.
27
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-24. Choose your memory split
At Last! It’s Configured! Wow, we finally made it to the end! After all that effort, you can now reboot the Pi and (finally) start using it! Press the Tab key twice to highlight the Finish button and press Enter. Your Pi should shut down and then reboot. If you decided to expand the root filesystem earlier, you’ll see this (as promised) during the boot process, as shown in Figure 1-25.
28
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-25. Resizing the filesystem on first reboot This process can take a while depending on how big your SD card actually is. As it is being resized online, it won’t actually interfere much with the startup process, but because it’s happening in the background, and it’s doing fairly intensive work on your SD card, you might notice that things feel a bit sluggish. That’s completely normal, and it will speed up considerably once this process has finished. After all that effort (and a bit more waiting while the Pi boots up), you should finally be at a pretty graphical display that should look something like Figure 1-26.
29
CHAPTER 1 ■ YOUR FIRST BITE OF RASPBERRY PI
Figure 1-26. At long last, we have a desktop! Congratulations! You now have a fully functional Raspberry Pi! If you don’t end up with a pretty desktop, you might need to tweak your configuration a little. At the login prompt, you can log in with the username pi and the password you set during the install. If you then run the following you will be able to change the settings (boot_behavior is the option you want to change): $ sudo raspi-config You can also try starting the graphical interface manually with this: $ startx
Summary This chapter has taken you from getting your hands on your Pi all the way through getting it up and running. We deliberately took it slow and covered all the basics as it’s always the so-called simple things that trip people up (us included!). We looked at what comes in the box (and more importantly what doesn’t) and provided a shopping list of all the things you’ll need to bake your Pi. We then touched briefly on Linux—what makes a distribution and why we decided to stick with Raspbian for this book. We then covered how to download Raspbian and get it on your SD card (which turned out to be much more involved than we first thought). Armed with a fully loaded card, we fired up the Pi and walked through the initial setup and configuration process that ultimately ended with us looking at the very pretty Raspberry Pi logo in the middle of an equally impressive desktop. In the next chapter, we’ll start to explore your new desktop. We give you a quick tour of what comes with Raspbian out of the box, and we finish up by showing you how you can tweak and customize it to suit your needs.
30
CHAPTER 2
Surveying the Landscape Although the majority of this book focuses on getting you comfortable on the command line and really getting your hands dirty with Linux, we would be completely remiss if we didn’t first show you how to use the graphical interface that comes with your Pi. It’s not quite as flashy as what you might find on a Windows PC, a Mac, or even some Linux distributions, but it’s fast, easy to use, and will let you do all the things you’re used to doing. And, of course, it’s all on a device that fits in your pocket and draws less power than the monitor or TV it’s connected to. We start off this chapter by looking around the desktop and seeing what interesting things we have to play with. Some are obviously useful applications in their own right and some are probably less useful at this stage (for example the Python development environment won’t be of much interest to you unless you’re programming in Python). We’ll then trundle through the various menus and have a look at what we find.
Welcome to LXDE Unlike Windows, Linux isn’t integrated with a particular GUI; it uses a separate application (a client and a server, in this case) to provide one. This application is known as the X-server and it used to be by far the most complicated thing in the Linux universe to set up. Although it has gotten a lot better, not too long ago, great time and effort needed to be spent if you wanted to use the scroll wheel in that newfangled mouse of yours. Needless to say, the fun of that wears out pretty quickly. These days, the X-server is almost a black box and very rarely do you need to actually touch it. For that reason, we won’t go into any more depth on that subject in this book, but if you are a bit curious to find out more, check out http://en.wikipedia.org/wiki/X_Window_System. The X-server provides the framework for using a GUI, but it doesn’t actually provide the pretty desktops that we’re used to seeing. They are provided by desktop environments. Again, we won’t cover how these all work, but suffice it to say, like everything else in the Linux world, you have a choice about which one you prefer. For most people, it comes down to which one comes with their Linux distribution of choice, although most distributions offer a selection. The more advanced ones have all sorts of features and special effects, and understandably consume a fair amount of resources while they’re at it. On the latest and greatest desktop or laptop, this is hardly a problem, and most people jump at the chance to make their expensive machine actually do some work. However, it does become something of a problem when you’re running a less-than-high-spec machine such as the Pi. It’s not just the Pi that can struggle—computers of just a few years ago could easily run Linux, but struggled with the new highly graphical interfaces. When you consider even older machines that would often get thrown out, a suitable display manager could easily manifest as a perfectly useful PC. There’s still more to it, though; modern netbooks are low-powered by design, with the aim of high efficiency for battery consumption as well as cost. They also benefit from a minimalist design when it comes to the desktop. When you need to stretch your processing budget, the best place to cut corners is in the feature set of the graphical interface. Do you really need all those fancy features? Are transparent windows essential to what you’re doing? Do you really need that 3D-rendered clock? If not, and you want to cut some fat, a desktop environment such as LXDE will be right up your street.
P. Membrey et al., Learn Raspberry Pi with Linux © Peter Membrey and David Hows 2013
31
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
LXDE (short for Lightweight X11 Desktop Environment) was designed for machines in which energy efficiency and the need to run on hardware at the lower end of the performance spectrum was of critical importance. It aims to be efficient in terms of CPU cycles and memory usage, and although some window managers eschew all unnecessary features, LXDE tries to remain full of features at the same time. Although we now know that the GUI is made up of a lot of moving parts, LXDE is mostly transparent when used. Really there is no harm in thinking of LXDE as the main environment for your Pi and if you plan to spend most of your time using the GUI, we feel there’s no harm in considering it a core part of the operating system. You can simply just use it and accept it as being available. With that in mind, let’s move on to exploring what we actually have when we are using LXDE.
What Do We Have Here? Once you’ve installed and set up your Pi, and you’ve powered it up for the first time, you should be left with a screen that looks like Figure 2-1.
Figure 2-1. First boot of your Pi
How the icons are laid out really depends on the screen you connected to your Pi. It should look pretty similar; the only real difference is how the desktop icons are laid out. And because Raspbian is constantly being improved by the developers, it’s possible that you will see new icons or perhaps some replacements. There are some key areas here that are hard to see in one large screenshot, so we’re going to break each part down individually. For simplicity (not to mention the fact that they have become common idioms) we’ll refer to various GUI elements by the name most people are familiar with. Thus we will discuss the start menu and taskbar. Let’s start with the bottom left of the screen.
32
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
The Start Menu and Bottom Left of the Task Bar The first button on the bottom left (the one that looks like an alien spider—see Figure 2-2) is actually the LXDE logo and acts as the start button. The second button (which is indistinct even on a high-quality monitor) will start up PCManFM, the LXDE file manager. This is the tool you reach for when you need to move some files around or do some general tidying up. The next button (a globe) starts the default web browser that happens to be Midori in this case. Like the other apps, you’ll find that most of these applications are designed to be lightweight and efficient.
Figure 2-2. Start button and friends So far, so good. None of these applications is really that different from what you’re probably used to doing on your main computer. The next two, however, are a bit different: they control the environment rather than start individual programs. The first button (the two overlapping windows) acts like a “minimize all” button when clicked: all the windows currently being displayed will be immediately minimized. Clicking the button again doesn’t restore the windows, though, so if you do have a lot of windows open, don’t expect to be able to click this button again to get them back. This button has a second feature: if you click with the middle button (most scroll wheels can also be used as a button), all the windows will be “shaded.” When you shade a window, it rolls up inside its title. We don’t really use this feature (in all honesty, we never saw the point, but to each his own), but if it’s something you like, feel free to use it. Next up are the desktop buttons. Microsoft Windows by default has a single desktop, and most people are unaware that it can actually have more than one. This feature was added in recent versions of Windows, but Linux has had it from day one, mostly because other UNIX-based operating systems have had it for considerably longer. The feature is quite powerful in that it lets you have multiple desktops, each with its own applications. This allows you to keep all your work applications on one desktop while keeping your chat and browser windows in another. By default, LXDE provides two desktops, but you can have more if you want. The rest of this part of the bar is taken up with the various applications that you’ve opened. Like Windows, all running applications (at least those that provide a graphical interface) will show up here and you can use the bar to select which application you want to interact with.
And on the Right Side… After the taskbar, there are more icons, as seen in Figure 2-3. The first one appears to be just a black box, but it actually acts as a CPU monitor. The more work you give your Pi, the greener this box will become. It acts like a chart, showing you how your CPU is being used over time. You can actually amuse yourself (at least for a few minutes) by rapidly moving your mouse pointer. The faster you move it, the more CPU is used, and the box becomes greener. Fun and games aside, though, this monitor is quite useful because if your Pi starts acting a bit sluggishly, a quick look at the monitor can tell you whether you are maxing out your CPU.
Figure 2-3. The right side of the task bar
33
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Next to the CPU monitor is the clock, which doesn’t really need much in the way of explanation. The monitor with the padlock in the middle is used to lock your screen (although we have heard that this doesn’t work for everyone). This is very useful if you’re stepping away from your computer and you have some friends around who think it might be funny if you made some “amusing” posts on Facebook. By locking your screen, their efforts will be thwarted–assuming you remember to change your password to something other than the default, of course! Last up is the power button that gives you numerous options for shutting down or rebooting your machine, as shown in Figure 2-4 (although if you started manually with startx, then you will only see logout and cancel).
Figure 2-4. Clicking the shut down button Clicking Shutdown will do pretty much what you expect, as will Reboot and Logout. There is one thing that is worth remembering, though: the Pi runs Linux, which is a multiuser operating system. That means that things might be happening in the background that you’re not aware of. For example, someone might be streaming a video from your Pi. If you shut down or reboot, you will disconnect anyone else who is connected to the Pi. This might not be an issue for you right now, but it is something that you probably should be aware of. And that’s pretty much it for what you have on your screen. We’ll cover the apps on your desktop after the next section, in which we look at the mysteries of the start menu.
The Start Menu The start menu concept has become almost ubiquitous across most operating systems (notably not the Mac) since its introduction with Windows 95. Although various people might scoff at that and point to places where it might have been seen before or insist that the start menus in Linux are nothing like those found in Windows, we try to move beyond that. The fact is, the start menu concept works very well regardless who thought of it, and there is a reason why it’s been adopted so far and wide.
34
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Enough of the soap box; let’s see what our start menu has to offer (see Figure 2-5).
Figure 2-5. The start menu As before, there’s nothing really groundbreaking here. The first section lists all the applications that are available, all neatly grouped together: in this case, Accessories, Education, Internet, Programming, and System Tools. Apart from System Tools (and Accessories doesn’t look that inspiring), it’s hard to decide which of these options we should delve into first. Before we can begin, though, we need to wrap up the rest of the items. Preferences and Logout are fairly straightforward. We’ll look at some of the settings in Preferences that you can tweak later on; if you press the Logout button, you will, well, log out. No surprises there. The final item is the Run command, which lets us execute specific commands without the need to pick them from a menu, click an icon, or open a terminal. Just as with Windows, this option can be a useful convenience. It also has autocomplete functionality, as shown in Figure 2-6.
Figure 2-6. The run command and autocomplete
35
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Here you can see we typed in gno, and it autocompleted to the app that matches the pattern. This can save you a lot of time as you will get to know how many characters you need to type before the autocomplete kicks in with the right answer. Quite often, command names (especially for GUI apps) can be pretty long and this can be real time saver!
Accessories Now let’s take a look at what we have under Accessories. Like all the other menus, the items here can change as you install more software, and on newer versions of Raspbian it might look a little different. On our Pi, the Accessories menu looks like Figure 2-7.
Figure 2-7. The Accessories menu
Debian Reference First up is Debian Reference. As its name suggests, it’s a guide to all things Debian and because Raspbian is based on Debian, it gets taken along for the ride. The manual is nicely structured and well written, and has had the additional benefit of evolving over an extended period of time. The manual is a set of HTML pages, and when you click the link it will open in the Midori browser. Simply click the first link as shown in Figure 2-8.
Figure 2-8. You want the HTML version on the left The second link contains the same content in plain text, but it is stored as a compressed archive and so it’s not something you’d use for online viewing. As the manual is taken from the Web, this is a holdover from the days when you might have wanted to download a copy for browsing offline. All being well, you should end up with the page shown in Figure 2-9.
36
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Figure 2-9. The Debian reference manual in all its glory You can navigate the manual just like a web page. Although having a local copy is very useful, it’s not as easy to search as asking Google, which will usually take you straight to what you want. That said, if you’re trying to figure out why you can’t get online, you’ll be happy for a local copy.
File Manager As touched on earlier, LXDE ships with the PCManFM file manager. Of course you can also access it from the task bar, as shown earlier. Taking its lead from the minimalist design movement, this file manager is lightweight, simple, and easy to use, but still has all the features you’re going to need. It works in a very similar way to Microsoft’s Windows Explorer, so if you’re coming from a Windows background you’ll feel right at home with PCManFM (see Figure 2-10). If not, you’ll be able to pick it up easily with just a few moments of clicking about.
37
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Figure 2-10. The PCManFM file manager When it initially opens, PCManFM will drop you into your home area. It will show you how much space you have available on the bottom right (always useful in devices with relatively limited storage such as the Pi) and lists the most common places on the top left. For browsing, you can simply click your way through the folders and you can use the navigation icons on the toolbar to help you move quickly through your files. If you’re looking to get a bit more hands on, we cover how to manipulate files in Chapter 4.
Image Viewer Image Viewer is one of those applications that you’ll probably never open directly; you’ll almost always open it by double-clicking an image file that by default will then open Image Viewer for you. Simple though it may be, Image Viewer is not lacking in features and has all the basic tools you’ve come to expect, as shown in Figure 2-11.
38
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Figure 2-11. Image Viewer’s main interface The first two buttons let you move back and forth through a collection of images. This is actually surprisingly useful because people are now accessing albums rather than specific photos. To help with exactly that, there is also a slideshow feature that you can access by pressing on the play button. The next section has controls for how you want to actually view the image. •
The first two are the traditional zoom controls
•
The third icon is for “fit to screen”
•
The fourth is show at full size (which, if it is a photo from a digital camera, means you’ll have to scroll)
•
Last, the full-screen option to really take advantage of that 60-inch flat screen you just got your hands on
In the third section are the controls for altering the image. The first two are rotate controls (rotate left and right, respectively), and the second pair of controls allows you to flip the image horizontally and vertically. This is especially handy when you took the photo at an odd angle and don’t fancy tilting your head 90 degrees in order to see your picture the right way up. The next set contains file controls. They let you open, save, save as, and delete the file, respectively. The last two icons provide access to the preferences panel (nothing too interesting in there) and allow you to exit the program.
39
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Leafpad In keeping with the minimalist theme, the Leafpad text editor does the basics and that’s about all. It’s very similar to later versions of Microsoft’s Notepad and it is similarly easy to use (see Figure 2-12). It’s not much good for writing letters to Aunt Maude or to the council to complain about the next door neighbor’s dog, but it’s perfect for when you need to do some light text editing.
Figure 2-12. Leafpad has a similar look and feel to Microsoft’s Notepad Despite its simplicity, Leafpad still provides some of the most useful tools, namely being able to do a find-and-replace, and enable and disable word wrap. Armed with those tools, you can accomplish pretty much anything.
■ Note If you feel that Leafpad is a little underpowered for your tastes, you might want to flip ahead to Chapter 6, in which we show you some of the more powerful native text editors that you can get your hands on.
For the most part, Leafpad does exactly what it says on the box: it edits text, and if that’s all you need to do, Leafpad is an excellent choice.
40
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
LXTerminal LXTerminal is a terminal emulator for Linux that gives you access to a virtual console. We won’t go into any depth on how to actually use this particular application because we’ll discuss the details in the next chapter. Suffice it to say, this tool is used to give you direct command-line access to the operating system. For many people, this is a place where angels fear to tread, yet for seasoned administrators, it is somewhere they call home. To find out whether the command line is for you, though, you’ll have to wait until Chapter 3. LXTerminal is a simple emulator (see Figure 2-13), but it gets the job done. It doesn’t have all the bells and whistles that some emulators provide, but it is perfectly fine for the majority of people.
Figure 2-13. LXTerminal up and running One thing we will mention here is the prompt. When the font color is green, and the end of the prompt is a dollar symbol, you know you’re running as a normal user and you don’t have root privileges (you can’t execute any commands that can really hurt the system). Again, we’ll cover this topic in more depth in the next chapter; we mention this distinction here so that the next program makes sense.
Root Terminal This is all but identical to LXTerminal, except that instead of running as the normal pi user, it runs as the root (system administrator) user. When you first run this application, you’ll get a popup message, as shown in Figure 2-14.
41
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Figure 2-14. Not a warning; you’re running admin-level commands without needing a password Although it looks like an error message, it just lets you know that the system is configured to let you run an administrative-level command (in this case, running LXTerminal with root privileges) without having to provide authentication. For the Pi, this is almost certainly what you want, but on a machine that’s connected to sensitive resources and in which other people could feasibly access the machine, you might want to have it password-protected. A root terminal is very similar to a standard LXTerminal, but (as you can see in Figure 2-15) the prompt looks a little different.
Figure 2-15. LXTerminal running as root
42
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Here you can see that that prompt is now in gray text, and the end of the prompt is the pound or hash symbol. This means you are operating with elevated privileges and you could indeed run commands to effectively destroy the operating system. Linux doesn’t try to second-guess you; if you tell it you want to erase everything on the disk, it will obey that command and do so precisely. There is no safety net when running as root, which is why most people recommend that you stay in your own user account as much as possible. We’ll come back to this theme many times in this book.
XArchiver XArchiver is less likely to be called directly than Image Viewer, but nonetheless is probably an application that will get a fair bit of use on the average system. This tool allows you to create and decompress archives of various formats, which is essential when you’re downloading content from the Internet. XArchiver looks like Figure 2-16.
Figure 2-16. XArchiver when it’s opened by hand Here we downloaded the documentation to the Erlang platform (it was the first thing that popped into our heads when we needed something to demonstrate XArchiver). After double-clicking the file, XArchiver was opened automatically. The only button we have used so far is the extract all button, which is the second one from the right. Clicking this will extract all the contents of the archive, which is usually what you actually want to do.
Education The Education menu has only two items, but as they comprise some of the more interesting applications on the Pi, it’s worth checking them out. The menu on our Pi looks like Figure 2-17.
43
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Figure 2-17. Education menu
Scratch Scratch was developed at the MIT media labs by the Lifelong Kindergarten group led by Mitchel Resnik. The goal was to create a way to teach people how to program without having to teach all the fiddly bits first. This made the tactile approach in Scratch (in which you can drag and drop blocks of logic) much easier to pick up. We can’t claim to be experts in Scratch (in fact, we first came across it when we were playing with the Pi) but we are convinced that these sorts of applications will have a huge impact as the Pi spreads out across the waters. Getting people hands-on with technology and providing them with a powerful system that lets them get started without having to master all the underpinnings first is definitely a winner in our book. If you’re not convinced, check out Figure 2-18; it certainly made us take a second look.
Figure 2-18. Scratch programming environment
44
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Squeak Squeak is a programming language that is preinstalled on your Pi. For licensing reasons, however, the install is not quite complete, so you won’t actually be able to use it out of the box. We are not sure if this is a temporary issue and one that might be resolved in future versions of Raspbian. At the moment, if you open Squeak you’ll see a window that looks something like Figure 2-19.
Figure 2-19. Starting up Squeak for the first time After doing a bit of digging, we discovered the reason and also a post on the Raspberry Pi forums by jstout that provided a handy shell script that would install the missing components for you. Thanks to jstout, we can help you get Squeak up and running. You’ll need to open up LXTerminal and enter these commands (you could also come back to this section once you’ve read Chapter 3 and are comfortable on the command line): $ $ $ $ $ $ $
wget -r -O SqueakV41.sources.gz http://ftp.squeak.org/4.1/SqueakV41.sources.gz gunzip -f SqueakV41.sources.gz wget -r -O Squeak-4.3-All-in-One.zip http://ftp.squeak.org/4.3/Squeak-4.3-All-in-One.zip unzip -j -o Squeak-4.3-All-in-One.zip "Squeak-4.3-All-in-One.app/Contents/Resources/Squeak4.3.*" sudo mv SqueakV41.sources /usr/share/squeak sudo mv Squeak4.3.image /usr/share/squeak sudo mv Squeak4.3.changes /usr/share/squeak
This isn’t the time or place to discuss what those commands actually do, but the short version is this: they download the missing components and place them in the right location for Squeak to find them. Once you’ve entered these commands, you’ll be able to run Squeak without seeing that popup box. Instead you should see Figure 2-20.
45
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Figure 2-20. Squeak is fully operational Squeak is a dialect of Smalltalk, which is an object-oriented, reflective language. This makes it a very powerful and expressive language (you can do more with less code) that has earned it quite a following over the years. It has inspired various new programming languages (including Ruby) and was also used to implement Scratch, which we discussed just a few pages ago. We’re not Smalltalk experts either, but we do know that it is a very interesting and powerful language, and it might make an interesting place for you to start your exploration of programming languages if you feel so inclined.
Internet The Internet menu unsurprisingly contains applications that are specific for accessing the Internet. On our Pi, the Internet menu looks like Figure 2-21.
Figure 2-21. The Internet menu
46
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Raspbian ships with three different browsers out of the box. They are all designed to be minimalistic and your choice will come down to personal preference. For us at least, the preferred browser has to be Midori, which is the one we’ll cover in this section. At the end of the day, if you know how to browse the Web on any computer, nothing in these browsers will be new to you, and we’re covering it here more for completeness than out of real necessity. So rather than going through all the browsers, we’re just going to touch on Midori because it offers both a standard browsing experience and a private option. Most browsers on other platforms look very distinct when they’re in private mode (usually a different color scheme or icon set), which ensures that you don’t accidentally type the wrong thing into the wrong window. Midori, on the other hand, simply changes the name of the title bar that isn’t really all that distinctive. Take a look at Figure 2-22.
Figure 2-22. Midori in standard and private mode As you can see, there’s not a lot of difference here. The private browser doesn’t allow you to add bookmarks, and the ability to open previously closed tabs is not available. Other than that, they look pretty much identical. If you do decide to take advantage of this feature, you should always double-check before you hit the Enter key.
Programming The Programming menu consists of four items (see Figure 2-23), two of which we covered when we came across them under the Education menu.
47
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Figure 2-23. The Programming menu Because we’ve already covered Scratch and Squeak, all we have left is IDLE and IDLE 3. Actually, these two are pretty similar in that they are both integrated development environments (IDEs) for the Python programming language. IDEs provide a rich development environment in which all the tools you need are close at hand. They usually include tools to run and test code as well as nicely formatting your source code so it’s easier to read. The reason why there are two different versions is because there are two current versions of Python that for various reasons aren’t mutually compatible. In many ways, scripts that you might write for version 2.x of Python will work just fine in 3.x, but there are quite a few gotchas and changes in the language that make guaranteeing compatibility impossible. This is why you’ll often see two versions of Python installed on any given machine.
■ Note At the time of writing, Python 2.x is still where most people are at, and many projects are still actively developed using it. In fact, when we write new Python scripts we also use 2.x because it has the most libraries, a history of documentation and blog and forum posts, and generally a large community. On the other hand, Python 3.x has had a lot of tweaks and language improvements that will never make it to Python 2.x, and all the new ideas and development are focused on the new series. Ultimately, Python 3.x is the way to go, and if you’re just starting out in your programming career, we recommend you start out on Python 3.x. It certainly can’t hurt, and you can always look at Python 2.x if for some reason you need to use it, and in reality going from one to the other is really not a big problem. Because the two versions of IDLE are effectively identical in terms of how they’re used, we’re going to show you IDLE from the 2.x branch (rather than IDLE 3), as shown in Figure 2-24.
Figure 2-24. Firing up IDLE
48
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
When you first start up IDLE, you’ll be dropped into a Python shell. There’s nothing special about this prompt; in fact, you can get the same prompt by running Python at the command line. IDLE really shines because it provides an editor that supports syntax highlighting. If you’re new to programming, syntax highlighting is where the text that you enter (the source code) is color-coded to make it easier to read the program. Keywords and structures are highlighted, so it’s much easier to scan through a program (and check that you haven’t made any obvious typos) than if you simply had black text on a white background. If you’re not convinced, try it sometime; you might be surprised. Figure 2-25 shows a very simple program that prints “Hello world!” 20 times and exits.
Figure 2-25. Using the IDE component of IDLE As you can see, the structure is a lot easier to read when you add a splash of color (or if you’re reading this in the black-and-white printed version, you might have to use your imagination). You can open an editing window by clicking File and selecting New Window. Python is a very powerful language and is used in a huge range of places for all sorts of things. If you’re interested in learning Python, check out www.python.org for more information on how to get started.
System Tools This section won’t even need a subheading as there’s only one tool in this menu group, as shown in Figure 2-26.
Figure 2-26. The somewhat lonely System Tools menu The Task Manager lists all the processes currently running on your machine along with how much of your system resources are being used. Figure 2-27 is a snapshot of what Task Manager reported on our Pi (of course, yours will likely be quite different).
49
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Figure 2-27. I spy on my little Pi: Task Manager shows what your Pi is up to As you can see, the CPU is practically idle at the moment. Considering that it is running a full operating system (and an advanced one at that), it might be surprising to see that the CPU isn’t doing any heavy lifting. Although when compared with high-end Intel processors, the ARM chip in the Pi is far from impressive, this truly demonstrates that you can get a perfectly good desktop machine running with surprisingly few resources if you are careful. Our RAM usage tells a similar story. Admittedly, we don’t have much open at the moment (although you can see from the process list that we have a VNC remote desktop session running), but we are still well under 50% usage and with the new Model B’s packing 512 MB of RAM, this will allow even more applications to run at the same time. The process list gives you a good indication of what’s running on the machine and how many resources are being consumed on an individual basis. This is mostly useful when your Pi is acting a little bit funky, and you need to see whether an application has suddenly decided to eat all your RAM or set your CPU on fire. If you do find an application that is getting a bit too greedy, you can right-click its name and then select Kill, which will forcibly shut it down and thus hopefully restore our Pi to full health.
Preferences Now it’s time for a whistle-stop tour of some of the things you can tweak to make your desktop a little more personalized. Because the tools in Raspbian are pretty much self-describing (not to mention fairly obvious), we’re going to cover just the two main topics and let you explore the rest of the preferences for yourself. Because you really can’t do much in the way of damage, feel free to explore to your heart’s content.
Desktop Preferences To get to the desktop preferences, right-click your desktop and click Desktop Preferences. You should see a window like Figure 2-28.
50
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
Figure 2-28. Desktop Preferences We’re not going to cover the Advanced tab (it only has one option, and it isn’t one that most people will be interested in) and so we won’t show a screenshot of it. Everything on the Appearance tab is fairly straightforward, and there are no unusual options or special tweaks that you need to do to get anything to work.
Customizing the Look and Feel If you want to customize the look and feel of your entire desktop experience, you can tweak themes, icons, fonts, and more from the Customize Look and Feel tool. You can access it from the Preferences menu, as shown in Figure 2-29.
Figure 2-29. Finding Customize Look and Feel
51
CHAPTER 2 ■ SURVEYING THE LANDSCAPE
This will open the Customize Look and Feel app, as shown in Figure 2-30.
Figure 2-30. The Customize Look and Feel tool Because the tool is fairly straightforward, we’ll cover only the first screen, which allows you to change the color scheme for the entire environment in a single mouse click. The default scheme is Mist, which we actually prefer, but there are a number of other predefined schemes that you can choose from. The sample window will immediately reflect your new choice, and so gives you a preview as to what your environment will look like once you hit the Apply button.
Summary And that’s pretty much it for the whirlwind tour of the desktop! We’ve really only scratched the surface, and the aim is just to get you comfortable enough with what’s available to start exploring by yourself. Remember that Pi exists to allow people to experiment and learn more about computing, so getting your hands dirty (even if you break your Pi now and then) is really nothing to worry about. This chapter covered the applications installed by default and accessible via the start menu, and we skimmed over some of the interface features that are somewhat unique to the Linux world. We then finished off by looking at the two most common configuration changes that people want to make. In the next chapter we start to get really serious (sort of) and take you back in time to the command line, where we introduce you to an interface that once you’ve gotten used to, you’ll wonder how you ever managed to live without it.
52
CHAPTER 3
Getting Comfortable Normally we don’t start a chapter with a figure (and technically speaking we haven’t in this one, either), but we’re going for some good old-fashioned shock and awe. Take a look at Figure 3-1 (courtesy of Wikipedia).
Figure 3-1. TeleVideo 925 computer terminal You might be wondering why we thought it necessary to show you some technology from the early ‘80s (late 1982 in this particular case). In the olden days, computers lacked all the niceties that we have today, such as colorful displays and mice. Back then, it was just text, often green on a black background. Mice were decades away, and the only way to communicate with a computer was either through text-based menus or the command line. Because the command line gave a great deal more flexibility than a set menu, the command line was by far the most common interface and the one you’d be using if you accidentally stepped 40 years into the past. You’d sit at one of these screens called terminals and tapping away endlessly into the night.
P. Membrey et al., Learn Raspberry Pi with Linux © Peter Membrey and David Hows 2013
53
CHAPTER 3 ■ GETTING COMFORTABLE
As such, the majority of the second section of this book is all about the command line and getting you comfortable using it. Although things have improved somewhat in the intervening decades, the technology is basically the same. In this chapter, we take a really quick look at the history of computer interfaces and why the terminal has survived as well as it has. We’ll then look at the various terminals available to you and how you go about getting to them. We’ll then quickly explain the command prompt and let you in on a little-known secret about the different shells that are available.
Ye Olde Computer Although you can now quite literally buy a computer for $25, in the ‘70s you could expect to pay at least 100,000 times that amount for a computer with any serious amount of processing power. Such machines would take up entire rooms (if not entire floors), require incredible amounts of power, and generally look very impressive to passersby. A key problem that owners of these things had to deal with was one of scale. When your computer is worth more than the building it is sitting in, you want to make sure that you get the most out of it. One approach to solving the challenge was to use time-sharing. The idea was that compared with a human interacting with the computer, the computer was incredibly fast. In fact, even though these computers were puny by today’s standards, they could still run rings around the people who were actually trying to use them. So this begs the question: if the computer is spending most of its time waiting for the operator to enter commands and data, couldn’t it be doing other things while it waits? It wasn’t long before someone figured out that if the computer sits waiting for input, it can be better utilized with more than one person entering data. That way, multiple people can enter data at the same time, and we’re no longer limited by the speed of a single person. Great idea, but how to carry it out? To make it work, we’d really want to put a screen in front of everyone who needs to talk to the computer and with the available computer technology, even a very basic computer would be impractical. Then again, we didn’t really need a computer on their desks; we just needed a way for them to communicate with the big computer downstairs. In effect, we just want a keyboard and a screen with very long cables.
Say Hello to the Dumb Terminal This is where the dumb terminal came in. It was called a dumb terminal because it was quite literally just a screen and keyboard. Using instructions relayed from the computer itself, it would draw the text onto the screen. Whenever a key was pressed, it would be sent to the server that would then reply with more updates for the screen. The dumb terminal didn’t have any real processing capability; it just worked as an interface and that made it relatively cheap and easy to install and maintain. The technology did improve over the years, and the dumb terminal became “less dumb.” Support for different colors and brightness was added, as were fancier features for redrawing and managing the screen. However basic the concept, that of the dumb terminal just being an interface to a remote machine never really changed all that much. In fact, although dumb terminals started to be replaced when more modern networks became available (not to mention computing power became much cheaper), the approach continued to be used in the newer systems. This wasn’t just because there was a lot of legacy systems that people had to keep using (ever see the old green-on-black screens in some big department stores?), but it actually had some very useful properties that continue to be useful even today—properties that we’ll go into once we’ve seen what a modern terminal looks like.
54
CHAPTER 3 ■ GETTING COMFORTABLE
GUIS AND TUIS You’ll often hear people referring to GUIs (pronounced “gooeys”) and TUIs (pronounced “tooeys”), and we’ll be referring to them throughout the book as well. Fortunately, they are pretty straightforward, and you’ll be using them in no time (assuming you actually want to, of course). GUI, which is short for graphical user interface, is used by all modern computer systems in some shape or another. It used to be really easy to spot a GUI because it was pretty much any device that used a mouse. The lines have blurred somewhat in recent years, thanks to devices such as the iPad and Android smart phones, you can have a GUI that just uses your fingers. It’s now much easier to know what a TUI is as generally anything that isn’t a TUI is considered a GUI. TUI, which is short for text-based user interface, is often used interchangeably with the command-line interface (CLI). A TUI can present basic menu systems, but those systems are navigated via keyboard control rather than a mouse. In short, if you drive it from the keyboard, and there’s no mouse pointer, it’s a TUI. If you can click, point at it with a finger, or see pretty pictures, it’s a GUI.
Modern Terminals There’s quite a bit of evolutionary history between the dumb terminals we just talked about and what we use on modern Linux systems today. Often you will find that you have a computer (for example, your Pi) and you’ll want to connect to it over the network. When you do this, you are running a client on your desktop machine and you are connecting to a server that’s running on the machine you want to connect to; in this case, it is your Pi (which is acting as a server). Once connected, you are effectively “remote controlling” the Pi, so this type of connection is known as a remote terminal (a software version of the dumb terminals of the past). Remember that as far as Linux is concerned, whatever you type on your local client machine is as if you were typing on the Pi directly. This is just like a TV, on which changing the channel, either on the TV itself or via the remote control, causes the same result. In the interests of preserving your sanity (not to mention crossing the boredom threshold), we’ll leap ahead to the modern day and show you what a remote terminal looks like on your Pi (see Figure 3-2).
55
CHAPTER 3 ■ GETTING COMFORTABLE
Figure 3-2. SSH connection to a Raspberry Pi As you can see, it is still a text-based interface: the programs that run will all happen on the remote server. There are some nicer features (color, for a start) and we can make the terminal as big as our screen can hold (traditional terminals tended to be fixed size). In this particular case, we are connected to the Pi via Secure Shell (SSH) (more on this later) over TCP/IP.
Why Do We Still Care About These Things? Good question! In the modern era of iPads, iPhones, and Androids, why would we ever want to use a text-based interface? For most people, especially if they have never used one before, a text-based interface really sounds like something of a backward step, not a skill that they’d be especially interested in acquiring. Needless to say, we are most fond of the venerable command line and here are some of the reasons why we think you should invest your time and effort in getting to grips with it.
Simple One of the key reasons is simplicity. A text-based interface is pretty hard to beat when it comes to being simple. Literally all it does is send and receive text. You won’t be using a terminal to look at your holiday snaps, but it does give you a clean crisp interface to issue commands to your Pi.
56
CHAPTER 3 ■ GETTING COMFORTABLE
Fast You probably won’t believe us right now when we say this, but using the command-line interface will allow you to complete many of your tasks much faster because you can be very precise and express a lot of work in a single line of text—the sort of thing that would require multiple clicks or a strange convoluted process to express using a mouse.
Lightweight Anyone who has had the misfortune of trying to remote control a desktop PC over a slow Internet connection will appreciate exactly what we mean here. Sending screen updates across the Internet (especially for high-resolution screens with lots of colors) by its nature simply takes up a lot bandwidth. It can also take a while for the data to arrive at its destination, which is what gives remote sessions that unresponsive and blocky feel to them. Text-based sessions don’t suffer from this problem because they only send text. They were designed for systems in which the maximum speeds were a mere fraction of what is available to us today. So even on a very slow dial-up link, a remote terminal session tends to perform extremely well. It also puts less strain on the server. Maintaining a graphical interface means that the computer has to do quite a bit of work. Having a mouse pointer means that the computer has to track that pointer and make sure that it reacts properly when it touches an applications window or when the user clicks a button. A surprising amount of work goes on behind the scenes, and this is why Linux servers rarely have a graphical interface installed, much less running.
Powerful The command line gives you an awful lot of power. You can express complex thoughts and issue commands in a way that just wouldn’t be possible via a graphical interface. For example, you can string commands together to make more complex chains. You can take the output of one command and use that as input for another. This technique uses something called pipes (we cover it more thoroughly in Chapter 5).
Always Available Although things have gotten better in recent years, one of the most fickle pieces of software on a Linux box tends to be the graphical interface. It always seems to be the first thing to go, and when your server stops booting and you need a rescue environment, it’s unlikely that a graphical interface will be available to you. A terminal, however, is the native way to talk to Linux (and most other UNIX-like operating systems) and as such, it’s the one tool that will always be available to you in some form or another. Knowing how to use the terminal will let you get out of scrapes and deal with situations that would completely stump you if you weren’t comfortable with the command line.
Convinced Yet? Hopefully, these highlights have at least convinced you that there might be something to the command line after all. If you’re not totally convinced, that’s okay; it is hard to really get a feel for the benefits until you’ve actually spent some time experiencing them for yourself. In the next section, we’ll cover how to actually get yourself to a command line, explain what the stuff you’re looking at means, and cover some basic commands to get you started on your journey.
57
CHAPTER 3 ■ GETTING COMFORTABLE
TERMINAL OR VIRTUAL TERMINAL? For the most part, you won’t have to worry about the differences between the two. You will almost always use a virtual terminal that is either a terminal window inside the Linux GUI or connecting via SSH. The only real difference between a terminal and a virtual terminal is that a terminal is a single physical device such as a serial port or sitting at the screen directly connected to the computer (without a GUI). A virtual terminal has a device assigned to it, but there is no corresponding physical device. In fact, under Linux a new device is created and assigned to each new virtual terminal. We brought up the distinction here because some documentation (generally speaking, old documentation) might refer specifically to one or the other. These days, though, most of your time will be spent on a virtual terminal, and you won’t need to worry about the difference.
Three Terminals There are three main ways to get to the command line. The first is to sit physically in front of the machine and use what is often referred to as the console, the second is to open a virtual terminal inside the GUI, and the third is to connect over the network using SSH.
Console Although the console is simply just another terminal, it is a term that has gained a somewhat mythical status over the years. When you’re working on the console, you are directly working on the machine because it is literally a keyboard and monitor plugged directly into it. It used to be very common for administrators to restrict certain users (such as the root user, more on that later) to be able to log in only when sitting directly in front of the machine. Because the computer was likely in a locked server room, this provided an additional level of security. Most distributions do not come with this sort of security enabled, and now that remote access over the network is the norm (and sometimes an administrator doesn’t even have physical access or the machine is on the other side of the planet), this feature is far less useful. Still, if you are sitting in front of your Pi, you can access the console by holding down the Ctrl and Alt keys and then pressing F1 through to F6. F7 by default is where the GUI lives, so once you have finished with the console, you can flip back to your GUI. When would you need to do this? Well, if you can’t connect to your Pi via the network and you’re having trouble with the GUI, the console will be your new best friend. Generally speaking, you won’t use the console very often because there are usually more convenient ways to get the same effect (we cover them next). However, when setting up the system or if you’ve decided not to use the graphical interface, the console will be your only real choice for accessing the machine locally. Getting a command line through the other two methods is easier and more flexible because as often at least one of those options will be available to you.
58
CHAPTER 3 ■ GETTING COMFORTABLE
Opening a Virtual Terminal in the GUI Raspbian uses the Lightweight Desktop Environment (LXDE). As its name suggests, it focuses on being lightweight, which is just what you want when your computer sits squarely in the featherweight category! The native terminal for LXDE is called LXTerminal, and fortunately for us it not only comes preinstalled but also features on the Raspbian desktop, as shown in Figure 3-3.
Figure 3-3. Finding LXTermianl
We took the liberty of double-clicking the icon, and you can see that we have what can only be described as a working terminal. Of course, there’s really not too much to show in this case because a terminal is by definition pretty simple. You will probably find yourself using the terminal a fair bit if you’re planning to sit in front of the Pi and use it as a more traditional computer. If you’re thinking more about working remotely, then you need to read the next section, which is quite honestly a lot more interesting.
Connecting via SSH SSH is a great way to connect securely to your Pi over the network (see the sidebar “What’s So Special About SSH?”). It gives you all the benefits of a virtual terminal, but you can access it from any machine on the network. Potentially this means that you could connect to your Pi at home from your work PC and fiddle about with it in complete security. We find that SSH is by far the most common way we interact with servers in general, and because many people will use the Pi as a headless device (i.e., no keyboard or mouse attached to it—maybe not even a monitor), we think SSH will be the primary candidate for you as well. There are two parts to the SSH equation. You need an SSH server and you will need an SSH client. Fortunately, both are freely available and easy to set up.
59
CHAPTER 3 ■ GETTING COMFORTABLE
WHAT’S SO SPECIAL ABOUT SSH? SSH is the de facto standard for accessing any UNIX-like machine remotely. It is even supported by many network-enabled devices such as printers and high-end switches. The reason why it is so popular is because it encrypts all the data between your computer and your server. If someone is listening to your connection, all they will get is garbage. It also allows you to authenticate that the server is the server you think it is. Before we had SSH, everyone used telnet, which is a very simple protocol and doesn’t have any sort of encryption. This meant that if anyone could see your traffic (think public machines or WiFi access points), it would be possible to simply read your password off the network in clear text. Telnet also had no way to confirm the identity of the machine you were connecting to, which meant you could never be sure that you weren’t accidentally providing your username and password to somebody else. It is still possible to install a telnet server on Linux, but this is highly discouraged. There really is no good reason to prefer telnet over SSH, so you should always use SSH when working on your server remotely.
Setting Up an SSH Server on the Pi This one is actually very straightforward because unless you specifically disabled it when you installed Raspbian, the SSH server will already be running (Raspbian enables it by default). In fact, all you actually need at this stage is the IP address of your Pi. One of the nice things about covering the Pi’s virtual terminal first is that we can now use that to figure out what our IP address is. The Pi takes advantage of Dynamic Host Configuration Protocol (DHCP), which means that on the vast majority of networks it will be able to sort out an IP address for itself. This not only saves us time but also means you don’t need to figure out how to choose an appropriate address and then configure it. The marvels of modern technology! To find out the address, we’re use the sudo ifconfig command. This command (short for interface configuration) will show you the configuration of your network interfaces. Figure 3-4 shows what it looks like on our Pi.
Figure 3-4. Running ifconfig on the Pi
60
CHAPTER 3 ■ GETTING COMFORTABLE
Here you can see that we have two network interfaces. The local loopback device (or lo to its friends) is a virtual interface that network applications can use to talk to each other on the same machine. Because no hardware is involved, it’s more efficient to use the lo interface as well as it being always available and configured in the same way. Under Linux, most system services (such as printing and even the GUI) operate as client/server applications and make extensive use of this interface. Right now, though, we’re not all that interested in the lo device; we’re far more interested in the network interface that connects the Pi to our physical network. eth0 (short for Ethernet device number 0; computers tend to start counting at zero) represents our link to the real world. At this stage, we won’t bore you with what all the information means, and it’s not really something you would look at on a regular basis. The most common reason for running ifconfig is to find out the IP address and that is, of course, why we are here. In Figure 3-4 you can see the following line: inet addr: 10.2.42.132 Bcast: 10.2.42.255 Mask: 255.255.255.0 We’re really only interested in the IP or inet address, which in this case is 10.2.42.132. Armed with this piece of information, we should be able to connect to the Pi from anywhere on your network.
Sorting Out an SSH Client We are making the assumption that you’re either connecting from a Windows PC or from a Mac. If you are using a different operating system, don’t panic: there is probably a suitable client for you to download. You can still follow along with the other two tutorials regardless of which client you use (or on which platform)—the general process is the same.
Putty for Windows Putty is pretty much the standard that all other SSH clients are compared against and for good reason. Not only is it full of features but it also happens to be free. You can download Putty from this address: http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html. Because it is a little long for typing, you can get a similar result by searching Google for “Download Putty.” Once you get to the download page (see Figure 3-5), choose the first link on the page: putty.exe.
61
CHAPTER 3 ■ GETTING COMFORTABLE
Figure 3-5. Downloading Putty Putty is a stand-alone tool, so you can run it as soon as you’ve downloaded it; you don’t have to install anything on your machine. This is generally pretty useful because it means you can stick it on a USB stick and carry it around with you, and you can run it on other machines without needing Administrator privileges. If you keep losing track of Putty (it’s amazing how easy it is to do), you might want to download the “Installer” version, which will install it on your machine and set up the Start menu and Desktop shortcut icons for you. Now that we have Putty, it’s time to fire it up. Double-click the icon, and you will probably see something that looks a lot like Figure 3-6.
Figure 3-6. Windows getting excited
62
CHAPTER 3 ■ GETTING COMFORTABLE
Windows is just warning you that the program hasn’t been digitally signed. You’ve probably come across this one before, but when you’re installing some security-enhancing software, the last thing you want to do is install something unpleasant instead. In this case, the official version of Putty isn’t signed, and you can ignore this error. If you plan to use Putty a lot, you should probably uncheck “Always ask before opening this file”. Trust us, if you don’t do it now, you will after the tenth or eleventh time you run it. After you’ve convinced Windows to stand down, you’ll see a connection box that looks like Figure 3-7.
Figure 3-7. Starting up Putty The default settings are fine for connecting to your Pi; you just need to supply the IP address you discovered earlier. Punch this into the Host Name (or IP address) box and then click Open. Because it will be the first time this particular machine has connected to your Pi, you will see a warning similar to the one in Figure 3-8.
63
CHAPTER 3 ■ GETTING COMFORTABLE
Figure 3-8. The initial warning from Putty
Don’t worry; this is part of the SSH security system. It is letting you know that it hasn’t seen this particular server before (well, it wouldn’t have, would it?) and is showing you the key for confirmation. We don’t know anyone who has memorized the SSH fingerprint (although remembering the first four and last four digits goes a long way to making sure you have the right one); and in any case, we were expecting to see this warning. Once Putty has remembered the key, it will check it against the IP address and hostname each time you connect in future. If the remote server ever sends back a different fingerprint, Putty will warn you that there could be a problem. More often than not, this occurs when you rebuild or buy a new server, so you know why the key has changed. If you see a warning and you can’t think of a good reason for it, think very carefully before logging in to that machine. In this particular case, you know the key will be new, so you can simply select Yes. Now you will be back to a somewhat familiar black screen with some text. So far it will only be this: login as: Because we haven’t gotten around to setting up different user accounts you’re going to log in as the ‘pi’ user so just enter pi and press Enter. So far, so good. Now we just need to provide it with the password you set when you did the initial install. We know that you changed the password as we suggested (you did, right?), but just in case you didn’t, the default password is raspberry. Punch the password in, press Enter, and at long last you should see the command prompt: pi@raspberrypi ~ $ If you don’t have a Mac (or aren’t particularly interested in using SSH from one), jump ahead to the next section: the command prompt.
64
CHAPTER 3 ■ GETTING COMFORTABLE
LOOK BEFORE YOU LEAP This note falls under the “obvious-until-proven-otherwise” category. When you’re working with remote terminals, it is disturbingly easy to get disoriented and start running commands on the wrong machine. If you are trying to reboot the Pi on your desk, you don’t want to accidentally reboot something else such as a corporate server (you never know where your new Linux skills will take you!).
SSH on the Mac If you’re using a Mac rather than a PC, you won’t be able to use Putty. That’s not a problem because thanks to its UNIX roots, the Mac comes with a good SSH client built in. All you need to do is open a terminal window and run the SSH command. First, get Terminal up and running. You can find it in the Utilities directory inside Applications. You can also find it by using Spotlight (the magnifying glass at the top right of the menu bar and typing in Terminal. You’ll find that it isn’t too different from the Terminal you were using on the Pi, and there’s a good reason for that. As mentioned earlier, the Mac is actually based on UNIX, just as Linux (and hence Raspbian) is. Although the Mac does a good job of keeping its UNIX side well hidden (you can use a Mac for years and never come across it), you might want to dig into it a bit more if you find Linux and the command line to your liking. Now that Terminal is open, connect it to your Pi. You’ll use the ssh command; because there is no GUI, you have to specify the relevant options on the command line. Based on the previous example, your terminal should look something like Figure 3-9.
Figure 3-9. Connecting to the Pi from a Mac
65
CHAPTER 3 ■ GETTING COMFORTABLE
To save space, Figure 3-9 shows the whole process rather than just an empty terminal window. The bit we’re interested in right now is at the very top: $ ssh [email protected] The command is ssh, but we have provided some additional information: the user and IP address that we want to connect to. You can read the options as “user pi on server 10.2.32.132.” A bit like an e-mail address, it is a nice succinct way to show who we want to connect as and where we want to connect to. You should, of course, replace the IP address with the one of your Pi. The first block of text is something you’ll see whenever you connect to a new machine: The authenticity of host '10.2.42.132 (10.2.42.132)' can't be established. RSA key fingerprint is 31:a4:39:be:64:a6:99:45:bc:5b:d1:c1:2f:71:94:b5. Are you sure you want to continue connecting (yes/no)? yes Warning: Permanently added '10.2.42.132' (RSA) to the list of known hosts. [email protected]'s password This is just the ssh way of warning you that it can’t determine whether you’re connecting to the server you think you’re connecting to and shows you the key that the server used to identify itself. In this case, you can ignore the warning and say Yes. If you want to know a bit more about what it all means, we covered it briefly in the “Putty for Windows” section. After you enter your password (raspberry is the default) you should end up at the following prompt: pi@raspberrypi ~ $ Now that you have your command prompt, you’ll look at what it actually means.
Welcome to the Command Line Whichever route you take to get to a terminal, the end result will ultimately always be the same: you’ll end up sitting at a command prompt (or simply a prompt) that will look something like this: pi@raspberrypi ~ $ There is actually quite a bit of information here, but what does it all mean? You can probably figure most of it out from what we’ve been doing so far in the book, but for completeness, here is how it breaks down. The first part (pi in the example) is the username. This isn’t especially useful (or awe inspiring) when you have only a single Pi and a single user. It is, however, quite useful when you end up having to manage many users or when you have a variety of accounts of different machines. This is where the second part comes in (raspberrypi in the example) because it tells you the hostname of the machine you’re connected to. Together, this lets us know who we are and where we are. Again, not terribly useful with one Pi, but this information will come in handy some day.
■ Caution We’ve highlighted this elsewhere, but it’s so important that we’re going to say it again. When you have more than one terminal open, it is all too easy to run a command on the wrong server. Sometimes you end up running more than one command before you realize your mistake. Often no harm is done, but if you accidentally rebooted a critical server at work when you actually meant to reboot your Pi, you’re going right to the top of your IT department’s revenge pending list.
66
CHAPTER 3 ■ GETTING COMFORTABLE
The next item on the prompt (the ~ or tilde) actually tells us which directory we’re currently in. The tilde is a special case because it refers to the home area of the current user. You can think of it as shorthand because really that’s all it is. Any time you refer to your home directory (which in this case is /home/pi), we can simply replace it with the tilde. Time for a quick example: pi@raspberrypi /home/pi pi@raspberrypi pi@raspberrypi /home/pi pi@raspberrypi
~ $ pwd ~ $ cd ~ ~ $ pwd ~ $
Here we used the pwd (short for print working directory) command, which prints out the full path of the directory we’re currently in. In our example, it printed out /home/pi because that’s the pi user’s home directory. We then used the cd (short for change directory) command to go to the ~ directory. We used pwd again and were able to verify that after changing the directory we were back where we started. We’ll be explaining these commands more thoroughly in the next chapter, but isn’t this command-line stuff at least a little bit interesting? When referring to the ~ in general speech, you refer to it as home directory. So if you sat at the prompt in our example and someone asked you what directory you were in, you would say you were in your home directory or if you wanted to be explicit you would say that you were in the pi user’s home directory. If you wanted to get really specific you could even mention the hostname as well. You wouldn’t say that you are in the tilde or “wiggly line” directory. However, when you are giving someone a path to enter, you would say tilde. For example, if you wanted the user to go to ~/test/, you would say “type cd space tilde slash test slash and then press Enter.” This is because tilde in this case refers to something specific that you are using as a convenience to get to a location rather than actually telling someone what that location is. It also helps prevent confusion with relative paths, but again, that’s something for the next chapter.
■ Note We’ve heard tilde pronounced as both tilled and as till-duh, so you should expect to hear both of them in the wild. Interestingly, though, you might find that whichever one you use, people might have trouble understanding you, and this applies even to experienced administrators. It’s not because you’re pronouncing it wrong; it’s just they don’t know that the “wiggly line to the left of the 1 key” is actually called tilde. If you find yourself in that situation, referring to it as “the wiggly line one” seems to be a fairly safe bet.
The last part of the command prompt shows you what your access level is. Linux systems are pretty basic when it comes to system privileges. It can generally be summed up this: you are either the root user or you’re not. Now, there are exceptions to this rule and being a member of certain groups can allow you to do certain things that would normally require root access. That said, this is really the exception rather than the rule. If you are root, then you can do pretty much anything you please without hindrance. If you are any other users, expect to find your abilities drastically curtailed. This isn’t as true today as it once was because there are tools such as sudo that allow an administrator to grant the ability to run certain commands with root privileges without that user having access to the root account. Of course, ultimately sudo runs as root and it just decides whether it will run the command that you asked it to, so it still obeys the all or nothing rule. From the prompt’s perspective, if you are a normal user, you get a dollar sign as a prompt. We’re logged in as the pi user (which obviously isn’t the root user), so we too have the $. If we were logged in as root, we would be a privileged user, so we would get the hash symbol (or the pound sign if you’re not from the UK). A root prompt looks like this: root@raspberrypi ~ #
67
CHAPTER 3 ■ GETTING COMFORTABLE
The hash symbol is a sign (and a warning) that you are running with elevated privileges and that you should therefore be very careful about what you type. The prompt also shows the username as root, which provides an added indication. However, these subtle hints are easy to miss (people don’t tend to study the prompt before each command), so always check who and where you are before you press the Enter key. That’s really all there is to the prompt. Most shells allow you to customize it to show different information, and occasionally some administrators do change this. In our experience, most people don’t bother, and we rarely feel the need to change it ourselves. The reason why we’re bringing it up here is because if you ever do log in to another Linux machine, and the prompt is wildly different, it’s not a cause for concern. The terminal works in exactly the same way except the prompt has been customized.
Different Shells Okay, maybe we oversimplified things when we said that all terminals work alike. In truth, there are some minor differences, especially in what features they support, but more often than not you won’t notice. In fact, what will likely catch you out is when the remote machine is using a different shell. A shell is a program like any other but rather than being a tool for browsing the web or reading e-mail, it provides a command line for you to interact with the operating system. It operates like a wrapper around the kernel and that’s how it got its name: by being the shell around the kernel just like a peanut. So far, we’ve been making use of the BASH or Bourne Again Shell. It is by far the most popular shell in use today and it’s available on every Linux distribution. It’s also usually the default, which is why you’ll never have to worry too much about which shell your system is running. The reason we’re bringing this up here is because, like everything else in the open source world, opinions vary on what makes the best shell. Some take a bare-bones approach and only support the most basic features while shells like BASH come with batteries included and have more features than you can shake a stick at. Despite BASH’s popularity, it is conceivable that at some point in your illustrious Linux career, you might come across something else, and forewarned is forearmed. We’re not going to spend any more time looking at the different shells because quite honestly you’ll probably never need to worry about it. Even if a machine is using a different shell, you can probably start BASH to replace it (most systems have BASH installed, even if you get a different shell when you log in). Because system commands are the same regardless of which shell you use, even if you can’t get to BASH you’ll probably find you can do everything you would normally do. In fact, most shells are interchangeable for the most part, and chances are even if you were using another shell, you probably won’t even know it!
Summary This chapter introduced you to the terminal and its rich (if not exactly fascinating) history. We then discussed how the terminal is still used today and how it has been adapted to suit our modern needs. We then looked at the three main ways that you can get to a terminal on your Pi: the console, a virtual terminal, and over the network via SSH. Next we gave a quick description of the command prompt and touched on some interesting commands to highlight a point (which we absolutely promise will be explained when you turn the page), and we wrapped up the chapter by giving you a heads up about the different shells out there and how they may (but probably won’t) trip you up. Coming up in the next chapter is all you need to know to happily navigate around your Pi, create files, modify files, delete files, and much more. This is where we start to get really serious about the command line and where you’ll start picking up some real hands-on skills.
68
CHAPTER 4
The File-Paths to Success This chapter takes a look at what a filesystem is and how different operating systems try to make sense of them. We explain the difference between separate root filesystems and unified root filesystems, and why knowing this up front might save you a lot of headache. We then move on to looking at the filesystem presented to you on your Pi. We explore the standard layout and explain what goes where and what it actually does. We will also show off some simple commands that highlight some benefits of the UNIX “everything-is-a-file” approach to system design. Next we will show you how to move around your system, and you’ll learn about fully qualified and relative paths. We’ll show you how to create directories and files (and then copy, move, and delete them), and we’ll explore Linux file permissions and show you how Linux decides who can do what to your files. We’ll also touch on users and groups, and show you how to set ownership and file permissions on your own files. We’ll then round off the chapter by showing you how to create the Linux equivalent of shortcuts.
What Is a Filing System? We actually planned to start this section with a dictionary definition of what a filing system is, followed by our interpretation. Unfortunately, most of the definitions we could find basically said “a filing system is a system for filing,” we’ll skip that part and go straight to our own definition. It does suggest, however, that although a filing system is easy to talk about, it is a lot harder to define. We think a filing system is this: A way of sorting and categorizing data that makes finding something easier This definition covers everything from having a simple in-tray (at least you know where the document is, even if you can’t put your hand on it right away); to the way you view your contacts on your phone (that’s an alphabetical system right there); all the way to some of the more exotic systems such as the Dewey Decimal System, used to categorize nonfiction content at your local library. Actually, libraries are an interesting use-case for filing systems because most of them have at least two going on at the same time. Generally libraries tend to arrange fictional work by the surname (and then forename) of the author, whereas the nonfiction section is sorted based on Dewey Decimal numbers. By using two systems at once, they solve a fundamental problem. Storing books by the author’s name is great if you have a favorite author and want to find more books. When it comes to nonfiction, though, you probably want to browse a selection of books on a given topic, without a particular author in mind. If those books were sorted by author name, you’d probably never be able to find anything. Some libraries take this a step further by sorting fictional books first by genre (say Sci-Fi or Fantasy) and then within that category they sort by author name. This has some pretty neat benefits. You can still go straight to your favorite author because you’ll know the genre, but you can also browse for similar books with the same genre. If you are looking for the next best thing in the fantasy genre, you can simply stand in that section and flick through. So far, so good. Filing systems make finding things easier, and we can see that it’s important to use the correct filing system for the task; otherwise, you’d probably be better off with no filing system at all.
P. Membrey et al., Learn Raspberry Pi with Linux © Peter Membrey and David Hows 2013
69
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
But what does this have to do with computers? Well, one of the major tasks for any computer is to process information, which means that it has to be able to store and retrieve information easily. Older computer systems did use the alphabetical system and it worked very well, but as soon as there was a buildup of a number of files, it started to get very messy; and finding information became a challenge. This issue was addressed by having the ability to create a directory (often called a folder these days), in which you could put related files. This helped a lot, but the same old problem started to creep up on people. Yes, you could have a directory for accounts and another for tax returns, but what if you were an accounting firm and you had lots of accounts and lots of tax returns? Soon you were back to where you started because you either had a small number of directories with large amounts of files or a large number of directories with only one or two files in them. Around the same time, the term filing system (used predominantly for paper-based systems) became shortened to filesystem, which is almost exclusively used to refer to the way a computer stores data on a disk. Because this is the term you will come across most often, we’ll switch to using the filesystem term as well from now on. The last change to filesystem structure that remains familiar to this day was to allow directories to contain other directories. This would allow you to have a great deal of flexibility to store content in the most appropriate ways. As always, there’s more than one way to arrange a given set of files, but by and large the system has served us well and with modern search technology, finding what we’re looking for is easier than ever.
More than One Filesystem Here is where we hit a bit of a snag with this approach. A filesystem sits on top of some form of storage. That can be a hard disk, a USB stick, a DVD, or any number of storage media. Each device is effectively independent from any other. This makes sense because you can take a USB stick from your laptop and then use it on your desktop machine. Clearly there is no link between the filesystem on the USB stick and your laptop because otherwise your desktop wouldn’t have all the information it would need to find the files. Each filesystem has a root directory, which is the main directory on a device and holds all the other files and directories. Like the root of a tree, all the files and directories branch off from this central location. This does pose a bit of a problem, though. If each device has its own filesystem and root directory, how do you easily present this structure to the end user? It turns out that there are two approaches to solving this problem. The first is separate roots; the second is a unified filesystem.
Separate Roots This approach was adopted by Microsoft all the way back in the days of MS-DOS and it’s still with us today. The approach is very simple. Each device has its own root entry and the user can then use this entry to locate the device of interest and then can simply navigate the filesystem as normal to find the file. Under Windows, each root is assigned its own letter. For historical reasons, the system disk on Windows is referred to as C:, which you’ll often hear people refer to as the C drive. Floppy drives are assigned A: and B: (PCs with hard disks tended to have two floppy drives) and because few people had more than one hard disk, the CD-ROM drive tended to be assigned to D:. This system is really easy to use, and there is never any confusion about where a particular file is because you can tell simply by looking at the drive letter. However, there are a couple of issues with this design:
70
•
First, because root devices are assigned to letters, and there are only 26 letters in the alphabet, you are limited to 26 devices. Hardly an issue to home users even today, but back when businesses were using large mainframes, they could have hundreds of such devices.
•
The second issue is that the user has to be aware of the physical location of the file, which can actually add complexity because it ties the location of the file to the physical device that the file is on. If a bigger disk is added to the system, and the files were moved to that new location, their root device would change. Any person (or software) that depends on a file’s location would need to be updated, and that’s never fun.
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
In short, although the system employed by Windows is simple and effective, it can become an administrative headache on very large and distributed systems. These days there are lots of ways around that, and new techniques have emerged to hide this structure beneath the surface, such as the Microsoft Distributed File System (DFS) for network shares and libraries for grouping content in one place on your desktop such as documents and music. So it really isn’t a huge issue for Windows systems today. However, back when UNIX reigned supreme, these technologies weren’t available, and they went with the other approach: a unified filesystem.
Unified Filesystem Linux, being based on UNIX, has a unified filesystem. That means that unlike Windows, which has multiple root devices, a Linux system has only one and it is always mounted on /, which is UNIX-speak for the root directory. If there is only one root directory, then how does Linux handle additional devices, all of which we know contain their own filesystems? The solution is to take the root directory of the new device and then attach it on an existing directory in the tree. This is known as mounting a filesystem, which allows Linux to have an almost unlimited number of devices because it can attach them anywhere in the existing tree. This means that you could mount one device and then mount another device on a directory inside the first device. From the user’s point of view, they can move through all these different directories as if they were all on one big device. The physical structure (that is all the disks and the raw data on them) is completely hidden from the end users. They have no way to tell they’ve crossed from one device to another. This solves the issues highlighted with the separate root approach in that the unified filesystem is consistent regardless of what the underlying mechanism is. In fact, you can mount network file shares and even virtual filesystems into the tree. Of course, the benefits of the separate root approach have now become the downside for the unified approach. It’s no longer easy to see where things are going, and this again can make things more confusing. Like Windows, Linux systems have evolved over time so that these problems aren’t quite as pronounced as they would otherwise be. However, these benefits are mostly seen in the GUI and tend to be far less pronounced when using the command line.
The Mac has to be Different As an interesting comparison, OS X on the Mac makes use of both approaches. Under the covers, OS X is a UNIX-based system and so it does have a unified filesystem. However, unless you go to the command line (and most Mac users don’t), you will never see evidence of this. When you attach a USB stick to the Mac, it will mount it in a similar way as Linux, but it will show it to the user as if it were its own root device in a similar approach to Windows. However the Mac doesn’t assign a drive letter, it just sets up a unique name.
Bring it All Together Admittedly that’s a fair bit of theory and you’re probably wondering where all the fun commands are that we promised to show you. You might also be wondering why we just bored you with all that, and when (if ever) such information might be useful. The reason we’ve put emphasis on this theory up front is because when we started out with Linux, a lot of the things that caught us out were preconceptions from using other operating systems. When one of us first installed Linux some 15 years ago, it took several hours of swearing before he figured out what “you need a root / device” meant. This isn’t just a Linux thing, a dabbling with the BSD family of operating systems and its alternative way of handling disks caused us to wipe the wrong disk because we were thinking Linux and not BSD. So hopefully this last section will save you from some of the pain that we went through when we first started out. You don’t need to memorize all the theory, but if you come away from this section with an appreciation that despite many similarities, Linux is not Windows or a Mac, then you will be ahead of the game.
71
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
Everything as a File Now normally when we discuss this topic, we start by talking about hard disk partitions because most people are familiar with them, and there’s a nice easy mapping between the way Linux presents them and the physical device. Because the Pi doesn’t technically have a hard disk (it pulls some strings to make the SD card look and feel like one), this easy example isn’t actually available on the Pi. The thing is, it’s too good an example to pass up, so we’re going to stick with the classic. So without further ado, here are the files that describe the disk set up on one of our servers: /dev/sda /dev/sda1 /dev/sda2 /dev/sdb /dev/sdb1 As you can see, these files all live in the /dev directory, which is where Linux keeps all the device files. There’s quite a bit more to say on this, but we’ll come back to it a little later because, trust us, it will make much more sense if we cover it last. So for now, let’s ignore the directory and focus on our collection of files. You’ll notice that in this example, all the files start with the sd prefix because they are all “SCSI disks” and share the same driver. For machines that have IDE-based disks, the prefix is hd for hard disk. So now we know that we have some SCSI-based disks (SATA disks also show up as SCSI), but what else can we tell from those files? Well, you’ll notice that we have sda and we have sdb. The first SCSI disk on the system is assigned to sda, and the second is assigned to sdb. No surprise that the third disk will end up being assigned to sdc. Because we don’t see an sdc in our example, we can assume that there are only two disks on this system. Now we’re really getting somewhere. There are two SCSI disks on our system, and we just have one more thing to discuss: the numbers stuck on the end of the names. In this case, the number refers to the partition number on the drive. The first partition is 1, and the second partition is 2. Nice and simple with no real surprises, we’re sure. With this additional information, we not only specify which disk but also which partition on that disk. This does, of course, beg the question of why you should care. Surely there must be an easier way to find out which disks are attached to the system? Well you’d be right, but we’re not looking at this to discover what’s connected to the system. Instead, we’re looking at how we can specify a particular device that we want to access. This is because everything in Linux is a file, so even physical devices are represented in that way. When we want to access a hard disk or we want to access a particular partition, we do so by accessing the relevant file. Not only physical devices follow this rule; directories are files as well. In day-to-day use, you don’t have to think about this, but it’s a very powerful feature. By treating everything as a file, Linux provides a standard way for all programs to talk to all things. This greatly simplifies development and allows us to do some impressive things, such as redirecting input and output or using the output of one program as the input for another. We cover this in more depth in Chapter 5. Some real-world examples are useful here. When you want to make changes to the partition table on a hard disk, you use the fdisk tool. The fdisk tool will need to know which disk you want to work. Assuming that you want to partition your second disk, the command would look like this: $ fdisk /dev/sdb Because we’re partitioning the drive, we want to refer to the whole device, and /dev/sdb lets us do that. But let’s say we have done our partitioning, and we have one big partition that we want to format for Linux to use. The command for that is mkfs.ext4 (on modern Linux distributions), and as before, you’re going to need to tell the command what you want to format. In this case, we want the first partition on our second disk so the command would look like this: $ mkfs.ext4 /dev/sdb1 Again, this makes sense because we’re referring to a specific partition on a specific device. No big leaps of faith here, but we can now share a little secret with you. The mkfs.ext4 command doesn’t really care what filename
72
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
you give it. If you forgot to put the 1 on the end, it would have happily formatted the entire device. This is a case of “everything as a file” at work because everything is a file, and files are all accessed in the same way. Our tools simply read and write to files; they neither know nor care what it is they’re writing to! This concept takes a bit more effort to really understand. Under the covers, Linux manages all these different devices for us, each with its own specific requirements and drivers. To keep things simple for application developers (not to mention the users), Linux hides all this complexity and instead presents each device as a specific file. This brings us nicely back to the /dev directory (we told you it would come up). The files in that directory are special in that they don’t really exist, at least not as physical files that are stored anywhere. Linux creates a virtual filesystem that it then populates with files for the devices that are available on a given computer. Because our Pi doesn’t have any SATA or SCSI disks, you won’t find any /dev/sd files on your Pi.
Filesystem Layout Let’s look at how the filesystem is laid out on your Pi. You’ll find that the structure is very similar to what you’d find on any Linux system, so not only will this section help you master your Pi but you’ll also be able to navigate servers as well.
/ (Root Directory) This is the root directory (not to be confused with the root user’s home directory) that represents the top of the file hierarchy. Everything goes somewhere in or under this directory, no exceptions. As we discussed earlier in the chapter, Linux has a unified hierarchy, and this is where it all starts.
/root This is the home directory for the root user and spends a large amount of its time being confused with the root directory (/). It can get more confusing because if you are in the root directory and someone asks you to “go into the root directory,” which one do they actually mean? Often you can easily tell from the context, but if not, don’t be afraid to ask for clarification; you’d be surprised how often this one comes up.
/etc /etc is arguably one of the most important directories on your system. It contains most of the configuration files for not only your system but also the applications that you might have installed (such as the Apache web server). Many users new to Linux take care to back up their applications, but often forget about the configurations stored in /etc. At the end of the day, the application can usually be replaced quite easily, but getting that config right from scratch can be a real headache. This is a directory you want to take great care of.
/proc /proc is a virtual filesystem that the kernel uses to provide easy access from userland tools (that is, software that is run outside of the kernel). Everything you ever needed to know about the system state or running processes can be found in /proc. Two common examples are the CPU configuration (stored in /proc/cpuinfo) and memory usage (stored in /proc/meminfo). Most of this information is read-only, which makes sense because it is just a virtual representation. However, some files do allow communication to go both ways and you can potentially use it to tweak kernel and system settings while the machine is running.
73
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
/var /var is generally where you’ll find files created by your applications and the system itself. For example, most applications will store their logs in /var/log/, and many will store the lock files in /var/run/. Lock files don’t have any meaningful content; an application just uses them to work out whether it is already running so that you can’t accidentally have two copies running at once. On Raspbian, the Apache web server uses /var/www/ for storing a website’s files. In other distributions, this is not the case—such files tended to be located in the /srv/ directory. That said, more mature applications may still be in /var, even on modern distributions.
/boot Traditionally, the /boot directory actually lived on its own small partition on the first hard disk. At the time, the majority of computers were unable to boot from a single big partition, so it was very common to see these split out. On modern machines (although the Pi still requires it), this is no longer a problem, so this directory is often included in the root directory directly. As its name suggests, it holds the key files needed to boot a system, including the bootloader and the Linux kernel.
/bin and /sbin These locations store user and administrative programs, respectively. When you try to run a program from the command line, there are specific places that the system will look for the application. This list of locations is known as the path. Usually a normal user only has /bin in their path, so they effectively can’t see applications in /sbin. There are some applications that the user can access even though they’re generally used only by administrators, but the user needs to know where they are. This usually doesn’t pose a problem, and you won’t ever need to go looking for anything.
/dev We already touched on this directory in the “Everything as a File” section. It contains a file for each device or subdevice on the current system and provides a way for system tools (and, of course, users) to easily access the hardware on a particular machine. Besides the disk devices discussed earlier, there are also devices for graphics cards, sound cards, virtual terminals, and more.
■ Note You won’t find network cards in the /dev directory because they’re considered a special case. To find information on network interfaces, you need to use the sudo ifconfig -a command. This will list all the network devices that Linux knows about. For more information, check out Chapters 3 and 9.
/home Traditionally, all user home directories would be stored under /home and this was often its own partition, disk, or network share. The idea was to keep user data separate from system data and applications. Most UNIX-based systems still follow this rule, but there are occasions when you will find some home directories living elsewhere (i.e., the root user’s home directory). The Mac, for example, stores home directories in /Users, and some businesses will put different users in different locations based upon their needs. Although /home generally contains only home directories, there’s no requirement that home directories actually reside here.
74
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
/lib This directory contains library files that are needed by various applications. Libraries allow functionality to be packaged up and then shared by other applications. A good example might be a database driver that allows applications to access a database. So that these applications can find those libraries, they need to be installed in a known location and with a known file name. It’s rare that you’d need to poke around in this directory, but if you do, you should be careful because breaking things in here could affect the stability of your system.
/lost+found We mention this one for completeness, but it’s not really part of the filesystem structure per se. Rather it’s where files get placed when the filesystem loses track of them. For example, if a disk were to be damaged, you would need to run a disk repair. Some files may be recovered, but for various reasons, it may be impossible to determine where that file came from. If that happens, Linux will place those lost souls in this directory. We’ve never had cause to look into this directory, and most likely you’ll never need to look in there either.
/mnt Short for mount, the /mnt directory was traditionally where you would mount additional filesystems. If you wanted to attach a network share or an external hard disk, you would create a directory in /mnt and mount in there. Floppy disks and CDROMS also need to be mounted before use and were also generally mounted here as /mnt/floppy and /mnt/cdrom, respectively. However, in recent years, this directory has mostly fallen by the wayside because more people have removable media rather than always attached storage (see the next section on /media).
/media This directory is relatively new to Linux and was added to make a clear distinction between mounted external devices (such as those in /mnt) and removable media such as USB sticks, cameras, and media players. These are usually handled automatically under Linux, and so usually you won’t manually add or remove anything in this directory.
/usr This is where most of the software on the machine ends up and so it is often the largest directory on a server (at least if you don’t count user home areas). Although it’s useful to know where the software lives on your machine, because everything is handled automatically for you, everything in here should “just work”.
/opt This directory is a jack of all trades. On some systems, it is packed full of applications; on others, it remains completely empty. It’s usually used for third-party software and applications. For example the Oracle database server installs in /opt/ by default. You probably won’t find much cause to use this directory, but be careful if you do because it is easy to forget things that are sitting in /opt/ when it comes to taking backups and so forth.
/srv Another relative newcomer, the /srv/ directory is the designated location for storing data for services that serve files. Although this directory seems to be present, some applications still don’t make use of it either out of custom or simply
75
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
because everyone is used to the contents being somewhere else. If you’re looking for things that used to be in /var/, this is probably a good place to look next.
/sys This directory contains system information, and unlike /proc/ (which is only in memory), the contents of this directory are written and stored on disk. It doesn’t seem to get an awful lot of use, and we have never even had to look inside this directory. However, it needs to be useful only once for you to be glad it was there.
/tmp This directory is the computer’s scratch pad, and all sorts of applications create files in this directory. It is used whenever temporary file storage is used (such as during processing). This directory is emptied by default on a reboot, but it can still potentially get quite large. In theory, all applications are supposed to treat /tmp/ as transitory; that is, they should never expect a file to be there after a restart.
Wrapping it Up That pretty much sums up the key areas on the Linux filesystem. No doubt there are other little nooks and crannies that you might come across as you look around your system, but they will probably be a subset of these. Remember that although this structure is followed by most systems, most doesn’t necessarily mean all—and you might come across some differences or where directories are used in other ways.
Putting it to Work We’ve covered a huge amount of information so far in this chapter. We’ve looked at how filesystems work and how UNIX systems (and Linux in particular) have adopted a unified approach. We looked at “everything as a file” and we showed how these special files and filesystems fit into the grand scheme of things. We wrapped all that up with an overview of what goes where on the filesystem and what they do. What we haven’t done yet is actually used the filesystem. So far, we have been pretty much “hands-free,” but that’s all going to change in this section. We’ll start by showing you how to create directories and move about on the filesystem. Once we’ve given you the power to create, we’ll then give you the power to destroy, and you’ll be able to remove files and directories at will (not always a good idea). We’ll wrap this section up with a quick overview on Linux file permissions and how to read and set them. Let us begin!
Where Are We? Using pwd The first thing we need to show you is how to figure out where you are on the system. The easiest way to get your bearings is to look at the command prompt. We talked about this in the last chapter—as a quick refresher, here is what the command prompt looks like while we’re sitting in our home directory: pi@raspberrypi: ~$
76
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
The tilde (the squiggly line) is shorthand for the current user’s home directory. We highlighted this feature already when we first introduced it, so we won’t go through it again, but what if we want to know which directory we are actually in? What we need is the pwd command. We touched on this useful tool in the last chapter as well, but in case you missed it, here it is again: pi@raspberrypi: ~$ pwd /home/pi pi@raspberrypi ~$ This tool is very useful for telling us where we are, but it doesn’t tell us anything about what’s in the same location with us. It’s like being blindfolded and told you’re standing in the kitchen; it’s a great start, but you’re still effectively blind. You’d certainly like to know who and what is in the room with you; for that, you need the ls command. This command does have a large number of options, though, and so we will only cover the most common ones, those that we use every day. Actually you can just remember them as recipes because you’ll often just pass the same options time after time (or at least we do).
What’s in Here with Us? Using ls Now let’s see what’s in here with us: pi@raspberrypi: ~$ ls Desktop python_games pi@raspberrypi: ~$ Although we can’t easily show it in the book, Desktop and python_games are both colored deep blue. This tells us they are directories. At present, we don’t have any files in this directory, or do we? Actually we do, but by then they are considered hidden files. Under Linux, any file that begins with a period (full stop) is considered hidden. There’s nothing special about the files; they are various config or temporary files that various applications have created. We generally don’t want these files cluttering up our display, so ls and friends don’t show them. We can, however, force ls to show us those files with the -a flag like so (although you will most likely see slightly different results on your Pi): pi@raspberrypi: ~$ ls -a . .cache .. .config .bash_history .dbus .bash_logout Desktop .bashrc python_games .dbus .ssh pi@raspberrypi: ~$
Creating Files to Play with: Using Touch For now, we’ll leave the -a flag alone and create our own files to play with. Because we haven’t covered how to create and edit text files yet (we will show you how to do that in Chapter 6), we’ll introduce you to another little tool called touch. Under Linux, files have two timestamps: •
The creation timestamp
•
The last modified timestamp
77
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
These timestamps allow you to see when a file was created and when it was last updated. This is useful from an administration point of view because you can see which files are actively being used, but various tools (such as backup scripts) use this timestamp to figure out whether a file has changed since they last looked at them. Sometimes it is useful to be able to update that timestamp without changing the contents of the file, and this is where touch comes in. It touches the file that updates the timestamp, but if the file doesn’t currently exist, touch will create it for you. In other words, it’s a great tool for creating empty files. So, let’s start by creating a couple of originally named files: pi@raspberrypi: ~$ touch raspberry pi@raspberrypi: ~$ touch pi pi@raspberrypi: ~$ ls Desktop pi python_games raspberry pi@raspberrypi: ~$ And that’s all there is to it. As you can see from the ls that followed it, we now have two additional files. This time they are gray in color, which tells us that they’re normal files. By coloring the entries for us, ls makes it much easier to see what we’re doing. For example, any file that is executable will be colored green, but we’ll come back to file permissions later in this chapter. So far we only have two files, but if we had 10 or 20, it would start to get a bit crowded in here. The way to handle that is, of course, to create directories to store our files (and potentially other directories) in, and that’s what we’ll look at next.
■ Note Directories and folders are basically the same thing. Originally called directories, Microsoft started referring to them as folders, which they felt was a better description. Although Linux used to use the term directories because it has become more of a desktop operating system with people moving over from Windows, the folder terminology has become increasingly common.
Somewhere to Store our Files: Using mkdir To create a directory, we use the mkdir (or make directory) command. Unsurprisingly, it will create a new directory. However, if there is a file with the same name, or if the directory already exists, you will get an error message. Let’s create a directory called pifun to store our files: pi@raspberrypi: ~$ mkdir pifun pi@raspberrypi: ~$ mkdir pifun mkdir: cannot create directory 'pifun': File exists pi@raspberrypi: ~$ As you can see, trying to create the directory twice will cause an error. Don’t be distracted by File exists; this could actually refer to either a directory or a file. Another quick ls, and we’ll see that things are moving along quite nicely: pi@raspberrypi: ~$ ls Desktop pi pifun python_games raspberry pi@raspberrypi: ~$
78
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
Making Use of a New Directory: Using the mv Command So now that we have our directory, let’s tidy up the mess we’ve been making. Because we want to move the files into our new directory (rather than just create a copy of them), we’ll need to use the mv (move) command. This command is a bit more complicated than the ones we’ve covered before because it takes two arguments (that is, the things you want the command to act on) rather than one. This makes sense, though, because not only do we need to tell mv what we want to move but we also need to tell it where we want it to move the file to. As with most file commands under Linux, the first argument is the source, and the second argument is the destination. Let’s move those files now: pi@raspberrypi: ~$ mv pi pifun pi@raspberrypi: ~$ mv raspberry pifun pi@raspberrypi: ~$ ls Desktop pifun python_games pi@raspberrypi: ~$ So far, so good. Now we want to make sure that our files arrived in one piece. There are two ways to do that. We could go into the pifun directory with cd and then run the ls command or alternatively, we could simply give ls the path to the directory that we want to look into. We’ve already used the first approach, so let’s try give the second approach a try: pi@raspberrypi: ~$ ls pifun pi raspberry pi@raspberrypi: ~$
Time for Some Cloning: How to Use the cp Command Admittedly this isn’t very exciting, but as a newly minted administrator, you’ll be spending a lot of time moving files about and checking where things are. So far, you’ve learned how to move a file, but what if you just want to copy a file instead? When making a backup or getting a selection of files ready to send to a friend, you want to actually keep the originals. For this, we use the cp command (short for copy). Let’s move into our new directory and copy one of our files: pi@raspberrypi: ~$ cd pifun [pi@raspberrypi pifun]$ cp pi pi2 [pi@raspberrypi pifun]$ ls pi pi2 raspberry [pi@raspberrypi pifun]$ That worked well, we now have pi and pi2, just as expected. Let’s try the same thing again, only this time we’ll copy a directory: [pi@raspberrypi pifun]$ mkdir moarpi [pi@raspberrypi pifun]$ cp moarpi moarpi2 cp: ommiting directory 'moarpi' [pi@raspberrypi pifun]$ This time it didn’t quite go according to plan. The reason our copy attempt failed was because by default cp will only copy individual files. It won’t copy entire directories. Even though directories are technically treated as files, the way we use them via various commands mimics a real-world folder. The reasoning behind this is that when you copy a directory, you copy everything within it, including all its files and directories. This could be a lot of data and could
79
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
take up a lot of space as well as a lot of time to complete. Forcing us to be explicit about our intentions (which soon becomes second nature) means that when we mean to copy a single file but accidentally pick a directory, we will get stopped before any copying takes place. That’s all well and good, but what if you really did want to copy that directory? When we first looked at the cp command, we mentioned tasks such as taking backups, and (let’s be honest) you’re much more likely to want to back up a directory than a list of specific files. We can get the behavior we’re looking for by telling the cp that we want to copy recursively. This will then copy the directory and anything within that directory to the destination. We specify this by using the -r flag like so: [pi@raspberrypi pifun]$ cp -r moarpi moarpi2 [pi@raspberrypi pifun]$ ls moarpi moarpi2 pi pi2 raspberry [pi@raspberrypi pifun]$ Unlike the copy command, when you move a directory, there is no need to specify that you want to do so recursively because moving a directory without its contents wouldn’t make an awful lot of sense.
The Power to Destroy: Using the rm Command So far, we’ve shown you how to create files and directories, and how to copy and move them about. Now we’re going to show you how to destroy those files with the remove or rm command. It goes without saying that the rm command is one of the most dangerous in your arsenal. It can quite easily destroy an entire server if you’re not careful, and we know people who have accidentally done just that. For a change of pace, let’s look at how we can delete an empty directory. Before we look at how to do it with rm, we can use the rmdir command for this (which is short for remove directory). Now the catch with this command is that it will delete only directories that are completely empty. If there is even a single file inside, this command will fail. This makes it very safe to use, but not all that practical because generally when you delete a directory, you also want to remove all its contents. Let’s kill two birds with one stone: [pi@raspberrypi pifun]$ rmdir moarpi2 [pi@raspberrypi pifun]$ rm moarpi rm: cannot remove 'moarpi': Is a directory [pi@raspberrypi pifun]$ We could delete moarpi2 with rmdir because the directory was empty, but when we tried using the rm command, it refused to cooperate. This is because the rm command was written with similar reasoning to the cp command. Because removing a directory is far more dangerous than simply copying it, this is probably a good thing. We can use the same -r flag to tell rm to delete recursively: [pi@raspberrypi pifun]$ rm -r moarpi [pi@raspberrypi pifun]$ Success! Now sometimes when you try this, especially on a large directory with lots of files and subdirectories, you can end up with lots of issues that cause rm to give up. For example, some files might be write-protected. You can suppress these errors by using the -f flag, which means force and is akin to saying, “Damn the torpedoes! Full speed ahead!” That sounds like a great idea until you stop to think what would happen if you ran this command (which you should never do): [pi@raspberrypi pifun]$ rm -rf /
80
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
If you accidentally run that command, rm will proceed to delete absolutely everything on your system. If you happen to have a USB hard disk attached or you’ve mounted some network shares, you’re in real trouble because rm won’t confine itself to your internal disks; it will crawl through the entire tree deleting everything in its wake. This is one of the reasons why you should use a normal user account for day-to-day tasks. Your own user will not have sufficient privileges to delete anything critical to the system, but even then, chances are high that you can still damage all your attached media. You need to be very, very careful whenever you use the rm command and you’d better double- and triple-check it because Linux will assume that you know what you’re doing and won’t ask for confirmation! The rm command can also remove files simply by providing the path to the file. You don’t need to use the -r flag for this operation, so you can simply do this: [pi@raspberrypi pifun]$ rm pi2 [pi@raspberrypi pifun]$ ls pi raspberry [pi@raspberrypi pifun]$ And that in a nutshell is how you move about and manipulate the filesystem.
Fully Qualified and Relative Paths In Linux, there are two ways to specify a path to a file or directory: •
You can give a fully qualified path that starts with a forward slash
•
You can give a relative path that starts with a filename, directory name, a dot, or two dots
Strange though these might sound, they are both just ways of providing a specific location to your programs. A path is considered fully qualified when it starts from a fixed reference point (i.e., the root directory). Regardless of where you are on a system, a fully qualified path will always point to the same location. It’s like the old bell tower in the middle of town; if you give anyone directions using that as your reference point, you have a common anchor that both you and your friend know how to reach. On the other hand, a relative path depends on your current location to make sense. You can specify paths using ./ to mean the current directory or ../ to mean the parent directory (the next one up from the current location). If you had a path that looks like ../../test.txt, this would only work from a few specific locations (where the file is two levels above your current directory). However, it’s nice and short as well as being easy to type. Of course, the same file (if it were created in your home directory) would be accessible with /home/pi/test.txt, which unlike the relative path, can be used from anywhere on the filesystem pretty easily. Relative paths can be tricky when you’re several levels deep and you’re not sure where you are, but you do know the full path of the file you want. If you are in /home/pi/Documents/Work/Projects_2012/Spreadsheets/ and you want to access test.txt, you could either use the full path or alternatively use ../../../../text.txt. As you can see, in this case, the relative path is more confusing than the fully qualified path. So when should you use one or the other? You should use whichever option is the most convenient or makes the most sense for the task. Sometimes it’s faster or easier to use a fully qualified path. Other times, you are buried deep down in the tree, and writing fully qualified paths would be tedious at best and totally confusing at worst.
Users and Groups We’re only going to touch on the basics of users and groups here so that you know enough to understand the file permissions section that is coming up next. Users and groups are key to the way Linux secures your files, and you’ll need to know about them before we move on to the next section.
81
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
In the UNIX way of thinking, all people have their own usernames. A username identifies a particular person or entity (for example, a web server might have its own username) on a particular system. So far, we’ve spent most of our time as the pi user, but we’ve also seen that we can become the root user. Your username is the key that Linux uses to identify you as you. Groups are similarly straightforward. Each user belongs to one primary group, but may actually be a member of any number of groups on the system. On a university system, a student’s username might have its own private group (standard practice on Red Hat and Debian systems these days) but they might also belong to a student group and a research group. They might also belong to a group specific to their department. Groups are useful to administrators because we can group a selection of users together and treat them as a single entity. This makes things such as file permissions much easier to manage. When you create a new user on your Pi, you will automatically create a group with the same name. On some systems, users would by default join a user’s group, but as you’ll see in the next section, this could lead to accidentally giving people access to files that they shouldn’t have. Because a private group is by definition private, no one else will be a member, and no one can gain access to your files just because they happen to be in the same group as you. This is why on modern systems you’ll usually see that the owner and group of a file happen to be the same.
File Permissions File permissions allow you to determine who you want to be able to access your files and what exactly they’re allowed to do with them. There are three different permissions that you can set. The first is whether or not someone can read your file. The second is whether they can write to your file. And third is whether they can execute it (i.e., run it like an application). Of course, just being able to set these permissions on a file isn’t particularly flexible. You might want to give access to only a certain group of people and restrict everyone else. This is where users and groups come into play. On Linux, there are three roles that a given user might fall into: •
User: Refers to the owner of the file
•
Group: Refers to the group that owns the file
•
World: Also often referred to as other
Each role gets its own combination of permissions; that is, you can define whether any of those three roles can read, write, or execute your files. We’re going to show you how to do just that but before we do that, we need to show you how to see what permissions are actually in effect and so now is a good time to show you how to use the -lh option for the ls command. Let’s try running it now: [pi@raspberrypi -rw-r--r-- 1 pi -rw-r--r-- 1 pi -rw-r--r-- 1 pi [pi@raspberrypi
pifun]$ ls pi 0 Oct 7 pi 0 Oct 7 pi 0 Oct 7 pifun]$
-lh 16:29 pi 16:58 pi2 16:29 raspberry
The -lh argument specifies that we want ls to show us a list of files (−l) and that we want file sizes to be in human readable format (−h). Without the human readable flag, ls will show us all sizes in bytes, which when you’re dealing with large files is not very easy to read. It doesn’t really matter in this example because our files are empty, anyway. There are two things that we’re really interested in as far as file permissions go. The first describes the permissions currently in force, and the second shows us which user and group owns the file. Let’s break it down for the Raspberry file: -rw-r--r-- 1 pi pi 0 Oct 7 16:29 raspberry
82
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
The file permissions part is: -rw-r--r-There are ten possible slots in that list. If a particular permission is missing, ls will show a hyphen. However, a normal file always has a hyphen in the first slot. If it were referencing a directory, the first slot would be a d to highlight that it’s not a file. This slot can also be an l if the file is a link (or shortcut) and we’ll show you how to use these in the next section. For now though we can ignore the first slot and focus on the final nine slots. The remaining nine slots are grouped in threes to give us three groups. These correspond to user, group, and world roles, respectively. Each of three slots in each group represents a specific permission: read, write, and execute. Where the permission is set, you will see a letter, but when the permission is not set, you will get the hyphen. If our Raspberry file had all permissions set, it would look like this: -rwxrwxrwx Let’s split that out a bit so it’s a little easier to read: -
rwx
rwx
rwx
So if we look at the first three permissions, we can see that the owner has read, write, and execute permissions. We can also see that group and world also have full permissions. To interpret what these permissions mean, though, we really need to know who actually owns the file. Let’s take a look at the part of the line that shows who owns the file: pi pi Well, that wasn’t too painful. Remember that on modern Linux machines, users have their own private groups that are named after the user. That’s what we’re seeing here. The first pi refers to the owner, which is, of course, the pi user. By default, when a file is created, the group ownership is set to the user’s default group. In this case, that would be our private group which is also called pi (the second pi). So look at our original file entry: -rw-r--r-- 1 pi pi 0 Oct 7 16:29 raspberry We can read this as “The pi user has read and write privileges. The group has read privileges and world also has read privileges.” Linux applies these permissions in a specific order based on who you are. 1.
If your username matches the owner of the file, the user permissions will apply when you try to access it.
2.
If you’re not the owner, but you are in the same group as the file, Linux will apply the group permissions to you.
3.
If you’re neither the owner or in the same group, Linux will apply the permissions from the world role.
In our example, though, the permissions for world and group are identical, so if you’re not the owner, you will get the same level of access. However only the owner can actually save changes to the file. There is one exception to this rule, however: the root user. The root user is effectively immune to file permissions and can change permissions and file ownership for any file on the system, regardless of who the owner actually is. The execute permission allows you to execute a file as a program. This is a security feature so you can effectively stop people executing commands that you don’t want them to. However, you have to be careful because if users can read your file, there is nothing stopping them from copying it to their own file and making that file executable.
83
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
The execute bit has another purpose when it comes to directories. Obviously, you can’t execute a directory so instead this flag means that the user (or group or world) is allowed to browse the directory—they can do an ls on it. They might not be able to access anything in the directory, but they can still have a peek and see what’s hiding in there. If you give users permission to read a directory but not to execute, they will be able to read a file inside, but they wouldn’t be able to browse for it. They would have to know the filename in advance. This also applies to access files in GUI applications, but it can be annoying typing in a specific path because most applications expect you to browse to the file you want. That’s really all there is to it. There is a feature called “extended file attributes,” but we’re not going to cover those in this book. They provide a great deal more flexibility than the standard model, but are similarly more complicated. If you’re used to the way Windows handles permissions, you’ll find that extended file attributes are a bit more in line with what you’re used to.
Setting File Permissions First we’re going to look at how we can set file permissions (see Table 4-1). Table 4-1. Available arguments for the chmod command
Part of Permission Setting
Possible Arguments
Role
u - user g - group o - other /world a - all
How to apply
+ − add - - remove = − explicitly set
What to apply
r - read w - write x - execute
We will be using the chmod command, which changes file permissions. You can specify permissions as a combination of the preceding values. These can be combined in three different ways. •
Add permissions
•
Take permissions away
•
Explicitly set permissions
The difference is that the first two will leave all the other permissions intact after they’ve done their thing. If you explicitly set permissions, any unspecified permissions will be revoked. Let’s start out by removing all permissions from everyone for our pi file: [pi@raspberrypi [pi@raspberrypi ---------- 1 pi [pi@raspberrypi
84
pifun]$ chmod a= pi pifun]$ ls -lh pi 0 Oct 8 03:52 pi pifun]$
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
All file permissions have been removed from the file, but how does the command actually work? Permissions are specified with three parts (corresponding to the three rows in Table 4-1): •
Who you want the change to apply to
•
How you want the change applied
•
What you want the change to be
In this case we applied the changes to a, which is basically shorthand for ugo (it applies the changes to everyone). We used the equals sign, which means we want to explicitly set the permissions and then we didn’t actually supply any permissions. If a permission is absent, it is assumed not to be set, so in our example by not supplying any permissions, we effectively revoked them all, regardless of what they were previously. Seeing as it is our file, we want to give ourselves full permissions. Admittedly, the execute bit is not much use in this case (you’ll find it invaluable when you start scripting—see Chapter 7), but we’re going to give it to ourselves anyway. We can do that with this command: [pi@raspberrypi [pi@raspberrypi -rwx------ 1 pi [pi@raspberrypi
pifun]$ chmod u+rwx pi pifun]$ ls -lh pi 0 Oct 8 03:52 pi pifun]$
Let’s pick this command apart. We specified that we wanted to change only the user’s permissions, that we wanted to add them (not that it mattered in this case because we’d removed all permissions beforehand so an equals sign would have done the same job) and that we wanted read, write, and execute privileges. To wrap up this example, let’s restore read access to the group and world roles: [pi@raspberrypi [pi@raspberrypi -rwxr--r-- 1 pi [pi@raspberrypi
pifun]$ chmod go+r pi pifun]$ ls -lh pi 0 Oct 8 03:52 pi pifun]$
Just for completeness, let’s step through this last example. We want to apply the permissions to the group and other roles, we want to add the permissions to what is already there, and we want to grant read privileges. And that is pretty much it for setting file permissions. There is, however, an alternative style that uses numbers rather than letters to specify what permissions you want to set. To get the same effect as what we have already (i.e., it doesn’t have any effect), we would use this: [pi@raspberrypi [pi@raspberrypi -rwxr--r-- 1 pi [pi@raspberrypi
pifun]$ chmod 744 pi pifun]$ ls -lh pi 0 Oct 8 03:52 pi pifun]$
In this system, each permission has its own value: •
Read is 4
•
Write is 2
•
Execute is 1
To set the permissions, you add up the numbers to get the total for each set of permissions (user, group, world). For example, to set all permissions you’d add 4 and 2 and 1 to get 7. For read, you would simply do 4 plus 0 plus 0, which of course gives you 4. Put them all together for the user, the group and world we get 744. This syntax is the original syntax used on most UNIX systems. Using the letters is a relatively new idea, but at the end of the day they
85
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
both achieve the same results. The main benefit of the new syntax is that it’s a lot clearer and easier to pick up. Personally, we tend to use the number style, but that’s only because we’ve been doing it for so long and it’s become second nature to us. You should feel free to use whatever system you feel the most comfortable with. So now you can manipulate permissions like a guru, but we are still missing the second part of the puzzle; we haven’t shown you how to change ownership of the file. This is actually a lot less common than you might think; far less common than tweaking the occasional file permission, that’s for sure. There’s also another little wrinkle. A normal user (anyone other than root) cannot actually change which user owns the file because if you accidentally assign the file to another user by accident, you have no way to actually get that file back again. Of course, being all-knowing and all-seeing, the root user can change the ownership for any file on the system. We can simulate “rootness” by using sudo. As discussed earlier, this little command acts as a filter of sorts. It always runs as root, regardless of who executes it, and executes commands as root on their behalf. To prevent any shenanigans, sudo will check the user and the command they are trying to run against an approved list. If you’re on that list (and the pi user is), you can execute all sorts of magic without every technically becoming root yourself. To use sudo, all we have to do is prefix the command we want to run with the sudo command. That’s pretty much it. When you first run sudo, it will ask you for a password. This is the password for your particular user, not the password for the root user. The aim is that you can prove that you are the pi user, and then sudo will check to see what the pi user is allowed to do. This means that if you have lots of users on your computer, and you want to let them do some more powerful commands but don’t want to give them root access, you can set up sudo to allow them to execute a specific command without having to hand over the keys to the mansion. Let’s start off by trying to give the file to the root user using the chown (or change ownership) command: [pi@raspberrypi pifun]$ chown root pi chown: changing ownership of 'pi': Operation not permitted [pi@raspberrypi pifun]$ The operation not permitted is Linux’s way of telling us to get stuffed. As mentioned earlier, only the root user is allowed to change the owner of a file. To pull this off, we’ll need root privileges, so let’s put sudo to work for us and run the command again: [pi@raspberrypi pifun]$ sudo chown root pi [pi@raspberrypi pifun]$ ls -lh -rwxr--r-- 1 root pi 0 Oct 8 03:52 pi [pi@raspberrypi pifun]$ Success! We were able to change the owner to the root user. This will work with any valid user and any file or directory that you wish to change. There is another command called chgrp which you won’t be surprised to know allows you to change which group owns a particular file. Now there is a bit of an issue with this command as well. Although normal users are allowed to change the group, they are only allowed to change it to a group of which they’re a member. If your user is only a member of its private group, then you won’t be able to do an awful lot with this command either. Once again, it’s root and sudo to the rescue. Because root can do whatever it pleases, it can change the group accordingly. As it happens, it looks an awful lot like our last command: [pi@raspberrypi pifun]$ sudo chgrp root pi [pi@raspberrypi pifun]$ ls -lh -rwxr--r-- 1 root root 0 Oct 8 03:52 pi [pi@raspberrypi pifun]$ And there we go—the file now belongs to the root group and the root user. When you do have to change file ownership, it’s much more common to need to change both the user and the group that owns the file. It’s relatively rare to change just the group (we can’t remember when we last used the chgrp command). The chown command
86
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
provides a shortcut that allows us to set both a new owner and a new group at the same time. Let’s use this shortcut now to return the ownership of the file to our pi user. We’ll still need to use sudo, of course: [pi@raspberrypi [pi@raspberrypi -rwxr--r-- 1 pi [pi@raspberrypi
pifun]$ sudo chown pi:pi pi pifun]$ ls -lh pi 0 Oct 8 03:52 pi pifun]$
With the shortcut, you just specify the user and the group separated by a colon. One last thing we need to cover with these commands is that they only operate specifically on the file you provide. If you provide a directory rather than a file, it will set the permissions on the directory, but those changes won’t filter down through to all the files. Sometimes that’s what you want, but more often you want the changes to propagate. Unlike the cp and rm commands that use -r, these two commands use -R (they use the capital letter rather than the lowercase letter). Be careful when you use this because often file permissions are precisely set, and if you waltz through obliterating them with your new version, there’s no way to undo the damage. As always, double-check what you’ve typed before you press the enter key.
Shortcuts and Links Linux allows you to create links (or shortcuts) by using the ln command (short for link). There are two types of links : •
A soft link is like what you might see on a Windows system after using the Create Shortcut feature. It creates a file that is just a pointer to the real location of the file elsewhere on disk. You create a soft link by specifying –s when using the ln command.
•
The hard link is more interesting. When you use a hard link you have effectively created two names for the same file. That might sound like semantics, and with most modern applications being able to follow a soft link, there’s rarely a need to use a hard link. Hard links are also restricted to a single filesystem that has to support them (most Linux filesystems do). The main benefit of a hard link is that the hard link is completely indistinguishable from the original file; they are simply two names pointing to the same location. You don’t need to specify anything to create a hard link as ln will do so by default.
■ Note To avoid confusion and to allow links to work across filesystems, you should use a soft link. Let’s do a quick example to show this in action: [pi@raspberrypi pifun]$ ln pi pi1 [pi@raspberrypi pifun]$ ln -s pi pi2 [pi@raspberrypi pifun]$ ls -lh -rw-rw-r-- 2 miggyx miggyx 0 Oct 8 08:14 pi -rw-rw-r-- 2 miggyx miggyx 0 Oct 8 08:14 pi1 lrwxrwxrwx 1 miggyx miggyx 3 Oct 8 08:33 pi2 -> pi [pi@raspberrypi pifun]$ Let’s have a look at what we’ve got here. pi and pi1 are identical in every way, but that’s not really a surprise because apart from the name, they are the same file. Notice that the number after the file permissions block now shows 2 for pi and pi1. This tells us that there are currently two filenames pointing at this particular file. Also not much of a surprise because we’re the ones that created the second entry.
87
CHAPTER 4 ■ THE FILE-PATHS TO SUCCESS
Much more interesting is pi2, which we created with a soft link. First we can see that the file permissions have all been set. This isn’t a problem because when Linux follows the soft link to the real file, it’s the real file’s permissions that will be used to define who can access the file. The soft link really just points out the location. We can also see that the filename itself is a bit different. It shows the filename that we originally give the soft link, but it also shows the file that the soft link points to. In this case, the file happens to be in the same directory, but it could just as easily have been anywhere on the system. That’s really all there is to it for creating links. They can be useful when you want to make one directory or file appear to be in a new location. For example, a program might write to a data directory, and you want to move that directory on to a bigger disk. No problem; you can move it to the bigger disk and then create a soft link to it with the same name. The application probably won’t even notice. This can really save you a lot of headache, especially when time is something of a premium. (And let’s be honest: when is it not?)
Summary This chapter has given you the inside scoop on all things filesystem. We’ve looked at the history and shown why our filesystems look the way they do. We then touched on how they hang together and how the Linux filesystem is structured. We put that to good use and brought you up to speed on all the basics for creating, copying, moving, and deleting your files. We discussed file permissions and how they are enforced, and how we can set them to match our needs. We also looked at the more traditional way of setting file permissions (in case it is ever needed). We then showed you how Linux applies these permissions and how you can change which user and group owns a specific file. We rounded everything off by discussing how you can create links and the differences between both soft and hard varieties. In the next chapter, we’re going to expose you to all the most common commands that you’ll find on your Pi. These are the commands that will become part of your toolbox that you’ll regularly dip into. In fact, we use all these commands in our daily work. So, onward to Chapter 5!
88
CHAPTER 5
Essential Commands You now have this marvelous new Raspberry Pi that you have installed and configured to accept and run a version of Raspbian Linux. You have logged in and can comfortably move around within the system. You can do the basics on your Pi, but now feel that you are ready to take on more. Well that’s what this chapter is dedicated to: teaching you a whole host of commands so that you can empower yourself as a Linux user. These commands will cover a whole host of functionality ranging from becoming the root super user, examining disk space, terminating processes, and configuring your user space and monitoring environment variables. All these tasks are common ones for the systems administrator and can have a big impact on how your system functions. So without further ado, let’s get started.
Become the Boss Root is a word that describes the base of a tree, something from which all the rest grows. In Linux and UNIX, the term is used to denote the start point of a filesystem (as we saw in Chapter 4) and to denote the master administrative user on the system (covered briefly in Chapter 3). To perform any system or administrative function, you need to be identified as root in order to have permission to change core functionality. Because of this, being root is very much a two-edged sword: unlimited power to change your system and unlimited power to break system functionality. Probably one of the truest things I can say about working in a Linux environment is that eventually you will issue a command as root that will break something (if not everything) and this will cause you no end of hassle or may even require you to reinstall your operating system. For this reason (and related security reasons) its advised that a user never actually login to the shell as the root user. To solve this problem, we use sudo, which we’ve seen a little of in Chapters 3 and 4. As you know, this tool is a wrapper for any shell command you can think of. This means that if you prefix a command with sudo (e.g., sudo ls), you will no longer be executing this command as your own user but rather as the root super user. This does make working as the super user slightly more complex, but also far less risky. In fact, many distributions of Linux no longer set a root password, but rather assign a new user the power of sudo on creation. This means that all administration must be done via an empowered user with the sudo command to issue all the requisite admin functions. So that you can execute as root, sudo requests your user password in order to validate that you are who you say you are, not just someone with access who left their keyboard unattended. In addition to asking all users for their passwords, sudo also has a steering file that governs which users and groups have access to the sudo command and even the capability to limit which programs they can execute via sudo. There is a special command, visudo, to edit this steering file (called the sudoers file) that must be run as root (so prefix with sudo): $ sudo visudo This code fires up a special instance of one of the system’s text editors (normally vi or nano) with the sudoers file already loaded to be edited. For a quick runthrough of how to use vi and nano, please check out Chapter 6.
P. Membrey et al., Learn Raspberry Pi with Linux © Peter Membrey and David Hows 2013
89
CHAPTER 5 ■ ESSENTIAL COMMANDS
Inside the sudoers file are a number of things that control how the sudo environment works, including a PATH variable (which we will cover later). The important thing, however, is the line down in the userauth section that looks like this: root
ALL=(ALL:ALL) ALL
This line states that the root user on all hosts can access all commands on all other hosts (a host is a server on the network). This is a bit confusing, but it basically grants full access to any user that can identify itself as root. There is also another line: %sudo
ALL=(ALL:ALL) ALL
This line says that members of the sudo group can also do the same things as the root user: accessing from all hosts on the network all commands that can be executed on all hosts on the network. You will notice the leading % that is used to signify that this is a group name. The basic format of one of these lines is this:
=(:) < command options and commands >
This syntax is a bit confusing at first so let’s have a look at creating a particular set of permissions for your pi user as an example. First we will need to create a new basic set of user permissions that will look just like the root users, but will instead refer to our pi user. This line will look like: pi
ALL=ALL
ALL
I have removed the section and replaced it with one generic ALL to make things a bit easier to understand. Now let’s say that we want the pi user not to be asked for a password. To do this, we add a NOPASSWD: before the final ALL that represents commands. This gives us a new line: pi
ALL=ALL
NOPASSWD: ALL
If you add this now, you can run all commands as the pi user without needing to even provide a password. This is a very dangerous command, so let’s modify it slightly to make it only the visudo command that can be executed. To do this, we replace the final ALL for commands with the command we wish to use, which in this case is visudo. But we can’t just write visudo, we need to provide the whole path to the application, which is /usr/sbin/visudo. So we get the following: pi
ALL=ALL
NOPASSWD: /usr/sbin/visudo
Now you should be getting the idea of what you can do within the sudoers file to control how the sudo command is accessed. You can have multiple entries that govern how these commands can be run, by whom and under which conditions. There is also a large amount of functionality for adding aliases, which can be large combinations of commands, hosts, or users. Much of the syntax for these commands is available from the manual for sudoers. Finally, one last command for you to be aware of is the su command, which is short for switch user. This command does exactly what it implies and switches which user you are, and if you aren’t root it will prompt you to enter the password of the user you wish to switch to. One of the niftiest cheats for gaining root access is to combine
90
CHAPTER 5 ■ ESSENTIAL COMMANDS
sudo and su to switch into the root user, with only the current user’s password instead of the root user’s. This command is the way that many people get round the “no known root password” limitation placed by many Linux distributions: $ sudo su – The minus sign denotes that you wish to gain a login to the environment, and because no other arguments are provided, it will attempt to log in as the super user. You can also use this to switch users by adding the username for a given user prior to the minus. You can also use the sudo command with the –i option to gain an interactive shell that will achieve the same thing: $ sudo –i
RTFM One of my favorite refrains from the tech world is RTFM, which is short for Read The Flaming Manual. While I have found that asking people for assistance is good, it’s always comforting to know that there is a manual you can read, and Linux is no exception. Most applications come with a manual document that can be accessed by using the man command! This command takes whatever you wish to get the manual page for as its first argument. So, if you wanted to look at the manual page for the sudoers command in order to get a better idea of how to write your sudoers file, you would type this: $ man sudoers And then the manual page would appear. Navigating a man page is done in the same way one would navigate a document opened with less (which is a command we will cover further on in this chapter), so navigation is done with the arrows and with page up and page down keys. You can also search for a string by pressing / and then typing what you wish to search for. The n key will help you navigate your way through the file. So, if you ever find yourself in need of some more information on a command, remember to Read The Flaming Man Page!
System Resource Monitoring One of the key things that a systems administrator will need to do is monitor the usage of resources on his system. While some of these commands may be of less use to your average Pi user, there are some times when being able to see what your system is doing will come in handy. The first system command to be aware of is top, which is a command for displaying the current usage of resources within your system and displaying which processes are consuming what level of resources. The top command is incredibly powerful and displays a whole host of information about your systems resource usage. The output of top normally looks like Figure 5-1.
91
CHAPTER 5 ■ ESSENTIAL COMMANDS
Figure 5-1. Top in action! The output from the top command is huge and if you watch, all the values there are updated regularly. Let’s go over the top output line by line so you can understand what you are looking at.
Uptime and Load Average The first line gives information about the current time and then uptime of the system. It then shows the number of users on the system and finally the load average. Load average is one of the most complex things to understand; it is a “meta” variable because it refers to what is going on within your system relative to your system’s capability to perform.
92
CHAPTER 5 ■ ESSENTIAL COMMANDS
It contains 3 values that give the average of the current minute, the last 5 minutes and the last 15 minutes. Load average represents the average of actual computation usage and demand for your system’s computation resources. Probably the best way to think of load average I have heard is as a freeway. Normally the percentage value of CPU usage represents how much of the current available computation resources are being used. This is akin to measuring how much traffic is currently on the freeway. The load average compares both how much computation is being used and how much demand there is for CPU usage. This is like examining both the freeway and its onramps. The difference between the two comes when looking at it from the perspective of a “busy lunchtime,” meaning that there are lots of cars on the freeway, but just because “it’s a busy lunchtime,” everyone can get onto the freeway and use it, nobody is stuck waiting on the ramp, and traffic is flowing nicely. This is why load average is such a powerful metric; it allows you to see demand for your system’s computing power in real time so that you can see when your demand begins to spike and can thus take action to lower demand. Wow, that’s a lot on just one line!
Tasks The second line of the top output lists the tasks that the system is currently performing: •
The total number of processes
•
The number of actively running processes
•
The number of processes that are sleeping in the background
•
The number of stopped processes
•
The number of zombie processes
Most of these processes are general purpose for being aware of what is going on within your system. But zombie processes can be a real problem. These processes are processes that have finished executing, but are still resident in system memory—often because they need to send a return value to the process that spawned them, but are yet to do so and thus must wait there as the living dead before they can send their final message and depart to the afterlife. Having a long running zombie process can indicate a problem with the application that is used to spawn it, which is called its parent. If you see zombie processes on your system have a look to see which process spawned them and check over its running state and log files (log files are output from applications that are written to disk, so you as the systems administrator can see what they are doing), as this may be indicative of a larger issue.
CPU Utilization Percentage The third line of the top command is the CPU utilization percentage value. This shows in terms of percentage how much of your current computation resource is allocated to which domain of your system. The values are the following: •
us (for user applications)
•
sy (for system applications)
•
ni (for processes that have been “niced” in order to give them more or less CPU priority)
•
id (representing idle)
•
wa (for processes that are waiting for I/O completion)
•
hi (for processes waiting for hardware interrupts)
•
si (for processes waiting for software interrupts)
•
st (which indicates time stolen by a hypervisor—a hypervisor is software that runs a virtualization platform like Xen or VMWare ESX)
93
CHAPTER 5 ■ ESSENTIAL COMMANDS
Of these values, the one that will normally have the most computation resource allocated to it is id, which represents free available computation that can be used elsewhere. Seeing high values of wa, hi, si, or st are never good signs as they suggest that your system is waiting on a particular piece of hardware or another function to finish processing. If these numbers stay high, you should look at investigating which processes cause them and see if you have any hardware issues.
Memory Usage Lines 4 and 5 represent the memory usage of your system. Line 4 is for the actual memory usage, and line 5 is for the swap space usage. Both of these lines will show the total, used, and free memory in their given space. This final value represents the buffers and cached value. These two are interrelated and are the cause of much concern for users new to Linux. This hass to do with the way that RAM is allocated. Linux can sometimes take up all available RAM and place it into a buffers, which means that it is taken by the buffers but can still be used later for your applications. Linux will treat this RAM as being used, but it is just sitting there in the buffers waiting. The buffers value can be a little hard to understand; this leads to another command showing how these resources are used (I will cover it next).
Process Table After the fifth line there is a large section that contains a process table, which lists all running processes and, in near–real-time updates, which processes are consuming how much of which resource. The following shows a number of different columns and the pieces of information they represent: •
PID: The processes’ ID number
•
USER: The user who owns the process
•
PR: The priority of the process
•
NI: The nice value for the process
•
VIRT: The amount of virtual memory consumed by the process
•
RES: The size of actual resident virtual memory
•
SHR: The amount of shared memory the process is using
•
S: The process status (e.g., sleeping, running, zombie)
•
%CPU: The percentage of CPU consumed
•
%MEM: The percentage of RAM consumed
•
TIME+: The total CPU time the task has used since it started
•
COMMAND: The actual name of the command
top also has a host of keypress actions that can manipulate the order in which these processes are displayed; you can check them out in the man page for top. So top is a fantastic command for showing all the ins and outs of your system’s resource usage and one of the best tools for diving into the exact nature of what your system is doing within itself.
94
CHAPTER 5 ■ ESSENTIAL COMMANDS
Using free to View Memory Allocation As mentioned earlier, there is an easier way than using top to see what your memory allocation is like. The command to do this is the free command, which you can invoke with the unit you wish to have it display in (−k for kilobytes, -m for megabytes, -g for gigabytes, and so on). For our purposes. megabytes is best, so invoke it as follows: $ free –m Your output should look like Figure 5-2.
Figure 5-2. Free as in free From this, you can see the +/− buffers and cache line that change the used and free values. This is a great way to question any time your system shows spikes of memory up to 100%, as it just may be lots of buffers and cache in action. From these two utilities you should be able to gain great insight into exactly what is going on within your system and how its resources are being used.
Disk Usage Now that we have looked at CPU and RAM usage, which are fairly dynamic, it’s time to have a look at something of a more static nature, disk utilization. In most operating systems you can quickly and readily view how much of the available storage space is in use, and Linux is no exception. The command to show the current usage of the whole system’s disks is df, which is short for disk free and can be used on the command line with no arguments to show everything you need. If you do, your output will resemble Figure 5-3.
Figure 5-3. Disk free, ouch! Figure 5-3 shows disk free in action and shows that the main rootfs mounted on / is basically 100% full—ouch. You can see the number of 1 k blocks being used by the system, but the values don’t stand out very easily. You will also note that there is a permission denied error at the top.
95
CHAPTER 5 ■ ESSENTIAL COMMANDS
Fortunately, there are solutions for both these issues. First is to run this command with sudo so that it has root access to the whole system. The second is to add the –h argument. This argument is fairly universal in being one of two things: either –h for help or –h for human, which is to say human readable units. So we run this command: $ sudo df -h The output should be much more understandable to the average human being (see Figure 5-4).
Figure 5-4. df for humans As you can see, the human readable flag has changed those Size and Used values over to a human readable number with a nice little flag on the end denoting unit. Experimenting with display flags is a great way to help you make sense of some of the complex data coming out of Linux commands. Normally you will find a huge section detailing (in way too much depth) all the flags for a command in its man page. So, we have seen the full disk utilization of the system, but let’s say we want to find the detailed utilization of all the files in a folder. There is another command we can use to do just this: du, which is short for disk usage and is used to summarize the disk usage of each file, recursively for directories. If you run du, it will tell you what the estimated usage of each file within this folder is and that of each subfolder and each item within it and its subfolders, and so on. du will also take advantage of the –h for human flag that was in df. So if we run it, we get an output like this: $ du –h 4.0K ./.cache/dconf 12K ./.cache/menus 576K ./.cache/midori/web 4.0K ./.cache/midori/thumbnails 24K ./.cache/midori/icons 608K ./.cache/midori 4.0K ./.cache/openbox/sessions 12K ./.cache/openbox 640K ./.cache 12K ./.dbus/session-bus 16K ./.dbus 5.0M ./.tor 12K ./.ssh 1.8M ./python_games 8.0K ./.dillo 20K ./.vnc 4.0K ./.gvfs 124K ./.gnupg
96
CHAPTER 5 ■ ESSENTIAL COMMANDS
8.0K 12K 48K 8.0K 16K 20K 8.0K 12K 8.0K 28K 4.0K 28K 104K 76K 16K 40K 36K 40K 88K 92K 9.0M
./.fltk/fltk.org ./.fltk ./Desktop ./.config/lxpanel/LXDE/panels ./.config/lxpanel/LXDE ./.config/lxpanel ./.config/pcmanfm/LXDE ./.config/pcmanfm ./.config/lxterminal ./.config/midori ./.config/enchant ./.config/openbox ./.config ./.fontconfig ./.netsurf ./.local/share/gvfs-metadata ./.local/share/webkit/icondatabase ./.local/share/webkit ./.local/share ./.local .
Wow, that’s a big output for such a simple command. It shows the utilization of every folder within the current folder, and right down the bottom it shows the total usage. This is where we can take advantage of another flag in order to shorten the output: the –s flag that stands for summary. Doing this will only print the total allocation for this directory and all within it, rather than everything as we have just seen. So go ahead and execute the command; your output should look much neater: $ du -sh 9.0M . That’s much better. You will notice that the output is using the . value to denote the current directory because du will work on the current working directory if not told where else to look. You can specify a directory to use by simply adding one to the end. The next example will look at /var/log, which is where all system logs are kept, so we will need to run this command as root using sudo as some of these logfiles are protected: $ sudo du -sh /var/log 9.8M /var/log And there you have it! With these two utilities, you can find out the current disk usage of your system and even work out which parts of your system are consuming the most space.
Managing Processes Probably one of the most important tasks when working within a Linux environment is knowing how to manage running processes. After all, a computer is just a processing system, and if you can’t manage what it is processing, how can you make truly good use of your machine? The first command you should become aware of is the ps command. The ps command is short for processes snapshot and can be used to list all the current processes being run by your user; when invoked, you should get an output like the one shown in Figure 5-5.
97
CHAPTER 5 ■ ESSENTIAL COMMANDS
Figure 5-5. Current processes Yes, it’s a little lackluster right now as I am only running two processes: the bash application that is running my user shell and the copy of ps. Since this is a snapshot, the application will always capture itself. This is useful if I want to control those processes run by my current user, but if I am to do more, I will need to add some arguments to my ps command. The argument to show every process on the system in the standard syntax is –ef, so go ahead and run that and see how your output changes (see Figure 5-6).
Figure 5-6. ps –ef Wow, that’s a lot of output, so much that it went off the top of the screen! There are always a large number of processes running on your system when you run ps –ef as this lists all the systems background processes along with all user processes. If you want to see them in a list, you can simply add a | less to the end of your command, which will let you go up and down and manipulate the list (I will explain what the less command actually does a little later in this chapter): $ ps -ef | less
98
CHAPTER 5 ■ ESSENTIAL COMMANDS
ps is a lot like top, but does require fewer resources and has a few other advantages that we will cover later in this chapter. For now, you should just be aware of what each of the columns in ps means: •
UID: Represents the user who owns this process
•
PID: Represents the process’s PID number
•
PPID: Represents the PID number of the process that created this one
•
C: Represents CPU utilization of this process
•
STIME: Represents the start time of this process
•
TTY: Represents the terminal controlling this process
•
TIME: The cumulative CPU time consumed by this process
•
CMD: The command-line argument of this process
So you might be saying, “Well fine. You have shown all the processes in the system, but what can I do with them now?” This is where the magic of ps comes in; it makes it very easy for us to pick out the PID of a particular process. The PID number is very important as it is a unique number for each process and is the way that the system references processes. This will come of use in our next command: kill.
Killing a Process kill is used to do exactly what its name implies: kill processes. But it also provides a number of other useful functions via the mechanism through which it kills processes. In Linux and UNIX, a signal is a low–level system message that is passed into an application from the operating system. Signals have no actual function beyond being a signal, and it is up to the application to respond to it in the correct manner. This is not true for all signals, as some cannot be handled within the application, but it is true for most. The function of the kill command is to send signals to applications. There are 64 signals that the version of kill on Raspbian can send to an application. To list them all, issue this command: $ kill –l I won’t list all the functions of the signals now, but you will need to be aware of these, the most common signals: •
Signal 1 (SIGHUP): Short for hang-up. Tells the application to hang up its current connection. Normally used to make an application reinitialize itself.
•
Signal 3 (SIGQUIT): Signals that this application should gracefully close itself down and quit.
•
Signal 6 (SIGABRT): Signals that the program is aborting; it is to close immediately.
•
Signal 9 (SIGKILL): Signals to forcibly “pull the plug” on an application.
These signals are the most common as they are used to perform application shutdowns, with nine being the most prevalent. The format of the kill command is this: kill – So to kill a process with the highest force, execute this: $ kill −9
99
CHAPTER 5 ■ ESSENTIAL COMMANDS
This is the point where those PIDs out of the ps command come into play. Those PID numbers are the ones that you will feed into kill in order to direct the signals from kill.
Reading Information in /proc Since we are playing with PIDs, it’s probably good to revisit the /proc filesystem, first discussed in Chapter 4. This is part of the OS in which all the process information lives. If you use ls /proc, you will see a number of files and a set of numbered directories. These directories correspond to each of the process PIDs. If you look within one of these directories, you should see a whole host of files that relate to a given process. While you should never edit any of these willy-nilly, there are some files within these directories that are very useful. Probably the most commonly used is a system-wide file that contains information on all the system’s processors. This is the /proc/cpuinfo file. You can output the contents of a file to the screen using the cat command, which is short for concatenate and is normally used to get the contents of a file into a buffer (in our case, it is the console screen). Go ahead and issue this: $ cat /proc/cpuinfo Your output should look like this: Processor : BogoMIPS : Features : CPU implementer : CPU architecture: CPU variant : CPU part : CPU revision : Hardware Revision Serial
ARMv6-compatible processor rev 7 (v6l) 697.95 swp half thumb fastmult vfp edsp java tls 0x41 7 0x0 0xb76 7
: BCM2708 : 0003 : 000000007a8a46ba
This is the Linux internal information on the Raspberry Pi’s processor. If you are ever in doubt on some of the particulars of your processor, this is the place to look. In addition to cpuinfo, there is another file within /proc that you can take advantage of when diagnosing system configuration information. It is the /proc//cmdline file. This file lists the full command-line argument used to invoke a process. If you need to get your hands on the commands used here, executing cat against this file is the best way to do it.
File Commands As mentioned earlier, you can use the cat command to output the contents of a file. There are a number of other tools you can use to work with the contents of files within your system. The first is one that was mentioned earlier: the less command. It is a command to display the contents of a file to the screen in a way that can be moved around and searched as if it were a text editor. This is a great command for working with logfiles or the output of long commands such as ps. less allows you to move up and down the file with the arrow keys or with the page up and page down keys. You can also search using simple word searches by typing / and then entering your search string. less will then highlight the found instances of your expressions, and you can tab between them with the n key to go down and the N key to go up. In addition to being able to search within a file for things, less has the ability to watch the file and constantly display any new content on the last line. This is great for watching growing logfiles as you can pick up new lines
100
CHAPTER 5 ■ ESSENTIAL COMMANDS
without needing to reopen the file, to get less to perform this function, simply press the F key. Along with this, you can also automatically navigate to the end of a file by pressing the G key. This process will also grab any new lines that have been added to the file and display them. You can also use the lowercase g to navigate to a specific line number, so if you wish to go to the first line, would press 1g. Finally, less is able to respond to all of its command-line arguments within itself. This is useful for enabling line numbers as you can simply give less the command –N and it will display numbers next to each line. After less, one of the commands that provide a startling amount of flexibility is the find command, which is used to find files. It does this by examining every file within the given directory and all of its subdirectories. find is useful on its own, but extraordinary when paired with other commands as you will see later. It also has a healthy cache of options that are interchangeable and can also be combined. I will cover a few that I have found incredibly useful here: •
The first is –L, which says to follow symlinks, which find does not do by default.
•
Second is –maxdepth , which represents how many directories deep this command will search through. Just the one? Just this and all its subdirectories?
•
Third is –newer , which shows anything that was changed more recently than a given file.
•
Fourth is –empty and it, as its name implies, finds empty files.
•
Fifth is –atime , where the number represents the number of days that have passed since a file was accessed.
•
Sixth is –name , which searches for files named exactly like the name passed in.
•
Last is exec , which tells find to execute a given command on each of the files and is where the real power of find comes out. You can use this command to find specified files and then execute commands on them. In this way, using find is a fantastic way of executing a cleanup of older unwanted files for instance. I’d also advise that when using find in this manner you should test first and test thoroughly because one incorrect key stroke could spell doom for your system or your data.
Combining these commands, you can achieve something that looks like this: $ find /mnt/Volume1 –empty –name fooBar –exec rm This command will find all empty files within /mnt/Volume1 that are empty and named fooBar and then remove them! There is so much power in the find command that you can harness when administering your Pi. Another command that has a significant if limited use is the file command. The file command is used to go through the contents of a given file and determine what “kind” of file it is. Kind is a bit of a loose term here because file knows only a moderate number of different file types. However, it is fantastically useful when you want to know an answer to this question: “Can I safely open that file in a text editor, or is it a binary application?” This particular command can save you much heartache. You can also use file to determine which archival format an application is written in, which is a great help when you need to extract from an archive but don’t know what kind! As an example, if you run file against a binary executable such as /bin/bash, you should see the following: $ file /bin/bash /bin/bash: ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.26, BuildID[sha1]=0xe370a0be978f49569f115c9f41bc54688be9fe32, stripped The code shows that the file is an ELF 32-bit LSB executable compiled for an ARM system, so the file should be compatible with your Pi. This is a good way to diagnose any issues you may have with applications downloaded from the Internet because they may be compiled for x86!
101
CHAPTER 5 ■ ESSENTIAL COMMANDS
The last file command I have for you in this section is one of those commands that many people hate and many more love: grep. grep is short for Generalized Regular Expression Parser and is best known as being a pattern matcher. Like less and find, grep is both useful on its own and useful when combined with other commands. You can use grep to search a given file for any lines that contain a given text string. The basic format of grep is this: grep Both these values will take the wildcard format, so you can use grep to search through every file in an entire directory for a string. As an example, let’s look for the word find in the /etc./init.d folder: $ grep find /etc./init.d/* The output would be this: /etc./init.d/checkfs.sh:# Include /usr/bin in path to find on_ac_power if /usr/ is on the root /etc./init.d/checkroot.sh:# Include /usr/bin in path to find on_ac_power if /usr/ is on the root /etc./init.d/kbd: LIST_CONSOLES='cd /etc./init; find -name 'tty*.conf' -printf '%f ' | sed -e 's/[^0-9 ]//g'' /etc./init.d/kbd: # eventually find an associated SFM /etc./init.d/nfs-common:# particularily heavy daemon, so we auto-enable it if we find an /etc./exports /etc./init.d/rc:# Now find out what the current and what the previous runlevel are. /etc./init.d/sudo: find /var/lib/sudo -exec touch -t 198501010000 '{}' \; grep also has some wonderful command-line options, including –i, which makes the search case insensitive. grep also has the –v option. which turns a search on its head and returns everything not matching the given search string! This should give you an idea of how powerful a tool grep can be when you wish to find a given piece of information and thus why it is an awesome part for a systems administrator’s arsenal of commands.
Combining Commands Now we get to the fun part! The ability to combine commands so that you can use the output of one command and give it to a second command to work with. There are also a number of commands that I will detail here as they are fantastic when combined with others. But first you need to understand how to combine commands and thankfully it is a rather easy thing to accomplish. To combine commands, we use the pipe symbol (|). Yep, it’s that simple. Let’s say we wanted to grep some things, but wanted the output in a more manageable way. We would simply write the grep, add a pipe, and then add a less. By doing this you will find yourself inside less looking at the output for your grep! This is where the fun truly begins. Want to search all the filenames in a given directory? Use ls to list the files and pipe the output to grep to search. In this instance, you don’t even need to include a filename with the grep as the pipe will provide grep with what is known as a buffer that grep will treat the same as file contents! So the command is this: $ ls | grep
Combine ps and grep Now, if you want to play more with things, you can combine grep with ps –ef! In this way, you can search for a specific application; for example, to search for the SSH application sshd,we would run this: $ ps –ef | grep sshd
102
CHAPTER 5 ■ ESSENTIAL COMMANDS
This will generate the following output: root root pi pi
1722 1956 1963 2030
1 1722 1956 1964
0 0 0 0
19:24 19:43 19:43 20:33
? ? ? pts/0
00:00:00 00:00:00 00:00:01 00:00:00
/usr/sbin/sshd sshd: pi [priv] sshd: pi@pts/0 grep --color=auto sshd
Add an Inverse grep Ah! There’s a problem! We seemed to have caught our own grep in the command. But that’s no problem we can simply pipe again to grep and do a –v for grep, which will return us every line without a grep. This gives us the command: $ ps –ef | grep sshd | grep –v grep This gives an output of this: root root pi
1722 1956 1963
1 1722 1956
0 19:24 ? 0 19:43 ? 0 19:43 ?
00:00:00 /usr/sbin/sshd 00:00:00 sshd: pi [priv] 00:00:01 sshd: pi@pts/0
Cut Down the Results Much better! Now you can begin to see what we can accomplish with pipe, but I am far from done with the things you can use this for! Let’s introduce the next command: awk. awk is a tool for doing data extraction from a line of text. In this way, you can pull all kinds of information out of whatever commands you’re running. By default, awk will pull each element out by splitting on whitespace, which is any tab or space between characters. You can set the character to split against using the –F argument. Once you have told awk how to break your text, you will need to output it. awk has an entire syntax for outputting commands, and it is an incredibly complex art form. However, for most of your needs, simply printing the correct field will do. All awk outputs are wrapped in curly braces { and }, and you will normally need to wrap them in single quotes so the command line will ignore any spaces. This means the basic syntax looks like this: $ awk '{ }' The most useful command for anyone working with awk has to be the print command because it is used to display the delimited variables. Each of these variables is treated as the number it is in the sequence, so $1 for the first, $2 for the second, and so on. Using this we can combine the awk with our ps –ef from earlier to print out the second space delimited field, the PID! This gives us the following command: $ ps –ef | grep ssh | grep –v grep | awk '{print $2}' Wow, these commands are getting long! But examine the output of this command: 1722 1956 1963 Aha! The quick among you will realize what is coming next! We can pipe this to kill! In this fashion, we can use a ps, grep, and awk to grab only the PIDs of processes matching a given pattern and then pass them off to be killed!
103
CHAPTER 5 ■ ESSENTIAL COMMANDS
xargs to Work with Each Result This is one of those pieces of magic that never gets old; however we can’t pass a list of PIDs directly to kill because we want them passed one at a time. To do this, we need to take advantage of another command, xargs, which works the same way that the –exec does in find. It allows you to treat each line of output from the commands before as an individual argument for another command. To use xargs, we simply have them wrap the command in the same manner sudo does. So if we wanted to pass each of those PIDs to xargs via kill, we would simply run the following and that would be it: $ ps –ef | grep ssh | grep –v grep | awk '{print $2}' | xargs kill −1 In this case, I will not be killing off my sshd process as I don’t want to reboot my Pi. But you should get the idea of how you can begin taking output from one command and passing it through to another command to run further executions on these commands. There are actually a number of other commands that come in really handy when doing these kinds of “shellfu.” The first is wc, which is short for word count. By default, wc will give you the newline, word, and byte counts for a given block of text or file, but it also has some great arguments, such as –l, which will give you the number of lines; –w, which will give you the number of characters; or –m, which will give you the number of words. Next is sort, which sorts each line of the output into order. You often see sort paired with uniq, which is short for unique. With these two, you can pipe an output to sort then to uniq, and you will have only the unique values in your given output! The final thing to be aware of when working with a number of commands is the output operator >. This operator is from the same family as pipe, but instead of being used to direct your command output to another command, it is used to direct your output to a file. This is a great way to save the output of commands to a file so that you can revisit it later or to have it useable as arguments for another command. By now, you should be getting the impression that the shell is incredibly powerful and you can do all kinds of tricky manipulations by combining commands with pipe!
User Environment We are going to take a small break from examining commands and have a look at some of the things that make up the environment in which you work. Your environment is launched every time you log in, and each time is the same. This is due to a number of files and commands that provide directives on how your simple shell environment is to be made up and how it is to function. One of the key files involved in performing these tasks is your systems master controlling environment script /etc./profile. This file provides the basis of the shell and environment variables that are the base of each user’s session. The profile file sets a number of variables, including the PATH variable. This variable is one of the key variables in setting up how your shell environment works. So we will have a look at it in depth. The PATH is one of (if not the most) important variables in your whole environment. It represents the systems search path that basically means where it will look for applications. As an example, I am sure that by now you are aware that all the commands we have run are just words entered into the shell, but in fact they are the names of fully functional applications that are located within the OS. The PATH contains a list of folders that your shell will search through and execute any command from within automatically. This means that you aren’t always searching for the exact path of a command; you can just run it as needed by its name. The problem here is that you cannot be certain where the program is being run from, or if you have multiple versions, which one is being run. There is a command that solves this problem: the which command. It outputs the path of the application that your shell would use to execute a given command. For example, let’s find the path of the ssh application, we type which ssh and we get this: $ which ssh /usr/bin/ssh
104
CHAPTER 5 ■ ESSENTIAL COMMANDS
Yep, it’s that easy. The PATH is used by a number of programs to find information that they need. Your path variable is initially set within /etc./profile but this can be modified. But before we go out and start playing with the path variable we should find out what it is currently set too. There are two ways you can do this, first is to use the echo command to print the variable. echo will interpret whatever you give it and then print to the command line, so if we execute echo $PATH the echo command will output the contents of the PATH variable like so: $ echo $PATH /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/games:/usr/games Okay, that’s what the PATH variable is. The path is a list of folders separated by colons. This brings us to the second way of viewing the PATH variable: the env command displays all the currently set environment variables. This is a fantastically useful command to check the current state of your whole system environment. Running env should give you an output like this: $ env TERM=xterm SHELL=/bin/bash XDG_SESSION_COOKIE=eb95d80869be1ad62af36ec5502c41a1-1349772229.897557-1575821964 SSH_CLIENT=10.0.0.104 3643 22 SSH_TTY=/dev/pts/0 USER=pi LS_COLORS=rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40; 31;01:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*. arj=01;31:*.taz=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.zip=01;31:*.z=01;31:*. Z=01;31:*.dz=01;31:*.gz=01;31:*.lz=01;31:*.xz=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*. tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*. rar=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.jpg=01;35:*.jpeg=01;35:*. gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*. tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*. mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*. mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*. flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*. yuv=01;35:*.cgm=01;35:*.emf=01;35:*.axv=01;35:*.anx=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*. au=00;36:*.flac=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*. ra=00;36:*.wav=00;36:*.axa=00;36:*.oga=00;36:*.spx=00;36:*.xspf=00;36: ALL_PROXY=SOCKS://localhost:9050 MAIL=/var/mail/pi PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/games:/usr/games PWD=/home/pi LANG=en_US.UTF-8 SHLVL=1 HOME=/home/pi LOGNAME=pi SSH_CONNECTION=10.0.0.104 3643 10.0.0.56 22 _=/usr/bin/env There are a lot of variables here that cover a range of things, including the shell we are using (SHELL), the variables governing the colors displayed when we execute ls (LS_COLORS), the path, my current location (PWD), my home directory (HOME), and my username (USER) in addition to the PATH. All these pieces of information can be incredibly useful when trying to diagnose issues with running commands.
105
CHAPTER 5 ■ ESSENTIAL COMMANDS
Now that we have been able to view the PATH variable, we should look at modifying it. To modify a variable, we need to use the export command in order to assign it into our environment. The syntax for setting a simple variable is this: $ export VARIABLE="SOMETHING" If you run this and run env again, you should see this new variable show up within its output like so: VARIABLE=SOMETHING If we were to do this to our PATH variable, we would reset it to whatever we set it to, which is not what we want. We could also simply rewrite the whole path, but that’s quite arduous for a simple change. The easiest way to append something to the PATH variable is to include the PATH variable within the assignment. Let’s work with an example: say we want to include the /opt directory into our path. We would start with export PATH= and then we would want to use the current PATH variable (as we would use to display it with echo), so we write "$PATH". To the $PATH we would add a colon as a separator and the new directory /opt, which gives us this command: $ export PATH="$PATH:/opt" When run, this will change your PATH variable to this: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/games:/usr/games:/opt Awesome; the /opt was appended to the end. This brings us to a key point; PATH has an order, left to right. Those on the left side of the PATH variable will be used before those on the right. In our example, /opt would be the last place we search for any given file. Now that you understand your user environment and how PATH works, you should learn about a special file within your home directory. This is your local shell profile override file. In your home directory there are a number of hidden files that end with rc. These files are normally executed by your shell or whichever application upon its execution to load your personal preferences. The file for the standard Linux BASH shell is the .bashrc file. This file is responsible for a number of the environment variables we saw before; it is also the reason that some of your commands have color. For example, the ls command, which is normally located at /bin/ls (you can check with which ls). If you were to execute this instead of the normal ls, you would not see the colors! These colors were added specially by the .bashrc file using the alias command. alias, as its name implies, is used to alias a command or a group of commands under a single shell command, just like a program. In the case of your .bashrc file, it has aliased the ls command to execute this: $ ls –-color=auto This addition means that every time you issue an ls command, you are automatically adding the color argument to ls. The way the .bashrc achieves this is by adding this line: alias ls='ls --color=auto' The great thing about files like .bashrc is they are designed to be user modified—after all, they are your local system variables. In this way, your local environment is made from the base system values given by /etc./profile and the additional values given in .bashrc.
106
CHAPTER 5 ■ ESSENTIAL COMMANDS
The cron Command The last command is probably one of the most powerful and useful tools in a systems administrator toolkit: the cron command. cron is a timing application that executes commands at a given time based on rules passed to it by a steering file. cron has a steering file per user called a crontab, which it will check each minute to see if another command needs to be executed. To view your current crontab, you would simply need to execute this: $ crontab –l Unfortunately, you won’t have one to begin with, so all you will get from this command is this: no crontab for pi Fear not because we will now go over the basics of creating a crontab timing file. The command to enter the special crontab editor is as follows: $ crontab –e This will open a copy of your system’s standard editor and create an initial file with a nice block of comments that outline how a crontab entry is laid out. It provides the following example: 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/ This command will perform a tar and zip of all users’ home directories every Monday at 5 a.m. Recall that tar creates a single archive file of all the documents, and the zip will compress the file—the upshot being a single compressed file containing all the files. The five numbers at the start of the line govern the timing; these numbers represent the following things, in the following order: •
Minute of hour
•
Hour of day (in 24 hour format)
•
Day of month
•
Month of year
•
Day of week (Sun, 0 to Sat, 6)
As you can see from the example, this command runs on the zero-th minute of the fifth hour of any day of the month, in any month of the year as long as that day is a Monday. With this combination, you can set up any number of timing jobs in order to perform systems administrative functions. The best part is that you can use all the commands we have discussed earlier to perform these tasks for you! Want to kill a process at a certain time? Write the cron timing out for when you want things killed and then use the ps, grep, awk, xargs, and the kill command we worked up earlier! With the combination of cron and all the commands we covered earlier, there is no limit to the tasks you can do!
Summary Congratulations, you should now be well on your way to being a fully fledged systems administrator. You have at your disposal more than two dozen individual commands and the ability to combine them in new ways to perform almost any task your heart desires. In addition, you should now have the tools to automate the execution of these commands using cron by editing your crontab file. All these tools form the basis of how a systems administrator will manage a Linux system as they provide the flexibility to write robust commands and have them executed automatically.
107
CHAPTER 6
Editing Files on the Command Line Believe it or not, one of the things you’ll end up spending most of your time doing on Linux is editing text files. They get absolutely everywhere, and you’ll find them used for content, source code for applications, configuration files, and startup scripts. The reason is that despite their somewhat basic and boring nature, they are very useful for storing human readable information. When you combine this with ease of use, you know you’re on to a winner. Linux doesn’t have a registry like Windows, and it’s extremely rare for applications not to use text files for their configuration. Even Sendmail, which has a historically evil config file (so evil in fact you need to write a config file for yet another application that will then create the Sendmail config file for you), stores its config file as plain old text. This chapter gives you a brief overview of text files and how they’re used today. We’ll then introduce the two editors that we’ll cover in this chapter (nano and vim) and then we’ll get into the real meat of the chapter and show you how to actually get things done.
What is a Text File? When a computer stores data on disk, it can store data in one of two formats: as a text file or as a binary file. So because computers store everything as binary data (those good old 1s and 0s), what exactly makes a text file different from a binary file? After all, surely the text file must also be stored in a binary format. If you were thinking along those lines, you’re quite correct. It’s not so much how the data itself is stored, but more to do with how that data can be read. The best way to appreciate the difference is to think about the page you’re reading right now. The reason why you can understand what I’m writing is because we have implicitly agreed to use English to communicate. The content of this page has structure that we both understand. We start sentences with capital letters; we use punctuation to show when sentences end or when to stop for a breath. In short, we have quite a complicated protocol here, but it works because we are both capable of reading and writing English. We can understand both the structure (how the data is to be read and written) as well as the semantics (what the words actually mean). So, what about the following sentence? Goedemorgen. Hoe gaat het? Straight away we can tell that it’s not English; after all, if it were, we would be able to understand it. Unless you happen to speak Dutch (we don’t, but our good friend does), you probably wouldn’t know which language it was written in. Even though the content doesn’t make sense, the structure itself does. We can see we have two sentences: one is a statement and the other is a question. In this particular case, we can guess what the first word means. If we pronounce it as we would English, it sounds very similar to good morning (which is actually what the word translates to). From that, we can probably guess that the question is “How are you?” The reason we can do that is because although we don’t understand the content, Dutch and English share a common structure or format. We share an alphabet (although Dutch does have some characters not present in English) and punctuation (full stops, commas, and question marks). Now you might not get the pronunciation right (it is, after all, a foreign language) but because we share a common structure, we can at least handle the content, even if we can’t understand it. Let’s take this one step further with Figure 6-1.
P. Membrey et al., Learn Raspberry Pi with Linux © Peter Membrey and David Hows 2013
109
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Figure 6-1. Some Chinese text At least for the average reader of this book, Figure 6-1 will be unintelligible. It’s actually the same two sentences that appeared in our Dutch example, but this time written in Chinese using simplified characters. To the uninitiated, there is no way to tell from this collection of characters how they should be pronounced. In fact, depending on the dialect spoken, these characters could be pronounced in many different ways. This is because each character represents an idea rather than a sound, and once you recognize the idea, you know which word to say. This is why in China it is possible for two people who cannot speak the same language to communicate perfectly well by reading and writing characters. So why did we sidetrack into foreign languages? Well, text files are like reading and writing English or Dutch. Whether the content makes sense or not depends on whether the reader can speak English or Dutch. This is similar to two applications and their config files. If you give an Apache web server configuration file to the Sendmail e-mail server, it will spit it back in your face (Sendmail doesn’t speak Apache), but it can open and read in the file. Chinese, on the other hand, is our example of a binary format. It is very alien for most Western speakers (although arguably it is far more efficient, elegant, and sophisticated than phonetic writing used in Western European languages). Unless you know Chinese, you can’t understand the content or the implied structure. In computing terms, what you have is a blob of raw data that only makes sense to the application that wrote it. Now you might be thinking that storing data in an arbitrary format is no big deal. After all, the application that wrote it is the application that will read it, and as long as it understands the file, surely that’s enough. Well yes and no. What happens if the program breaks? What if you need to read the file on another machine? Perhaps the vendor has provided some special tools to do just that, but therein lies the problem: you need special tools. Not so for text files; they can be opened in any text editor, and no special tools are required. Because the vast majority of Linux applications all use text files (we can’t think of any off the top of our heads that don’t), all you need to read or make changes to a configuration file is your favorite text editor, and Linux has a stunning variety of editors to choose from. Thus you can become familiar with a single tool and then use that tool to reconfigure all your applications, write source code when you’re doing scripting, and even use it for writing books (which is precisely what we’re doing right now).
The Contenders So the text editor is your Linux Swiss army knife and something you never want to leave home without. Of course, just like Swiss army knives, there are many different text editors to choose from, and some have more features than others. Sometimes you want a basic text editor that just lets you open files, edit some text, and then save the results. Other times you might want to do a complex search and replace or delete to the end of the line. Of course, you can quite easily use one of the more feature-full editors for all your tasks; after all, you don’t have to use the features if you don’t need them. That said, it’s been our experience that people are generally familiar with at least two text editors: one basic and one fully featured. In this book, that means nano and vim, respectively.
110
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
The first text editor that we’ll cover is nano. It’s a lightweight and easy-to-use text editor and it tends to be installed on most systems. Some later versions of nano have more features (such as syntax highlighting when writing source code), but all effectively look and work the same way. If you can use nano on your Pi, you’ll be able to use it equally well on any platform. The nano editor was actually written to be a drop in replacement for the pico text editor that used to ship with Pine, a text-based e-mail client. Pico can still be found on older systems (usually much older), and chances are if you can’t find nano, you might still be able to find pico. Because it’s a drop in replacement, the same commands and basic features used in nano will also be available in pico. Combined, this gives you coverage of most other UNIX platforms as well as Linux. Nano’s key selling point is its ease of use, but it does have a number of useful features. These features are accessed from menus, and while nano has more than enough features for simply editing a config file, sometimes you need something with a little more power. This is where the vim editor comes in. It can do all the things that nano can do, but it can do so much more so that’s pretty much where the comparison ends. Vim enables the following: syntax highlighting, different color schemes, cut and paste, delete blocks of text, indent chunks of text, open multiple files and show both at the same time, and much more. Now you might be thinking that if vim is this great, you might save yourself a lot of headaches by simply just learning how to use that text editor rather than any others. Like nano, vim is available almost everywhere in some form or another, and has the same basic features and accepts the same commands. The reason we’re covering nano is that you can be up and running quite literally in just a few seconds. Its features are easy to explain, and getting it to do what you want is really easy. Although vim users may disagree, in our experience, vim doesn’t exactly hold any easeof-use awards. That said, if you really don’t want to learn two editors and feel that you’d rather just learn vim, that’s fine, you won’t really be missing out on anything; it just might take you a bit longer to get productive.
Starting out with nano We’re starting out with nano for the simple reason that it’s really easy to use and doesn’t take much explaining. You can quite literally do everything you need to in nano, and while you might be able to do it faster in another editor, nano will help you get the job done just fine. Nano can be run by using the nano command. Okay, no surprises there, but running nano by itself isn’t all that useful. After all, you’ve got a text editor now and you want to do some editing. Unless making a few notes, no one ever just writes text without wanting to save it afterward. When you open nano, you probably want to open a particular file for editing. That file may or may not exist, but you probably know what it is you want to call it when it comes to pressing the save button. For the sake of this introduction, we’re going to open nano and tell it that we want to edit test.txt. We can do that with this: $ nano test.txt All being well, you should get something like Figure 6-2.
111
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Figure 6-2. Freshly opened nano with a new file We’ve connected to our Pi using SSH but because nano is a terminal based application, it will look the same regardless of how you run it. One interesting thing about these sorts of terminal applications is that they are sensitive to how big your terminal is. A fixed terminal (such as the physical console) has a set screen size. When you connect via SSH or use a virtual terminal, you can adjust the size of the screen and this will cause nano to resize along with it. This makes it very flexible and can fit in with your needs regardless of the shape or size of your screen.
So What Does This All Mean? Nano’s screen can be a bit confusing at first (especially the bit at the bottom), but most of the time you won’t actually be paying attention to anything other than your text. In fact, all the other stuff melts away in the background. For example, on the top left of your screen you can see that we’re running “GNU nano 2.0.9.” Until we came to write this book, we had no idea what version of nano we were running and quite honestly until we had to describe it here, if someone had asked us to draw the nano layout from memory, we’d have had a pretty hard time doing it. Actually, we wouldn’t have been able to do it at all! There are two other pieces of information that you can glean from nano’s title bar. Smack bang in the middle is the name of the current file that you’re editing. In our case, it’s test.txt. Not exactly earth-shattering, but it’s quite common to be working on multiple windows at once, and being able to quickly get your bearings can come in handy. The third piece of useful information is whether the file has been modified; that is, are there any unsaved changes? This can be very handy when you want to check whether you’ve saved your latest work. It’s also useful for simply jogging your memory and reminding you to save your work. To see what this looks like, just press the spacebar to make a change, and you’ll see that “Modified” appears in the top right of the screen (see Figure 6-3).
112
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Figure 6-3. Modified file in nano That’s pretty much it for the title bar. At the bottom of the screen there are actually two sections. The first one is the status line, which shows you important information (right now, it’s telling you that it’s a new file), and the second one is the shortcut or menu bar. We’re not going to say much more about the status line because it’s pretty much selfexplanatory. Anything of importance that you need to know, nano will put it there. Of much greater interest (and in fact the key to using nano) is the shortcut bar. Let’s take a closer look at it in Figure 6-4.
Figure 6-4. The shortcut bar When you’ve been working in Windows or on the Mac, you’ve probably reached the point where rather than using the mouse to copy and paste things you instead use the keyboard combinations. On Windows, you would use the Ctrl and C keys, and on the Mac it would be the Command key and C. When you use more than one key in concert with another, you end up with a key combination. Nano works in a very similar way, but rather than just copy and paste, all its important functions are driven with key combinations. Because it would be somewhat difficult to remember all the possible options available (although the ones you’ll use on a frequent basis will soon be committed to your long-term memory), nano displays them in the shortcut bar. Actually, it only shows the most common commands, but we have never needed to stray away from them. To make use of any command, you need to use the correct key combination. You can find which combo you need by looking at the shortcut bar. A shorthand way of writing control key is to use the carat (^) symbol. Looking at the shortcut bar, you can see that if you want to get help, you need to use ^G; in other words, hold down the Control key and press the G key.
Saving Your File Saving a blank text file is pretty boring, and it’s hard to tell if it saved correctly if all you have is a space character. We’re going to go for an old favorite here and punch in “Mary had a little lamb.” Unlike some editors (most notably vim, which you’ll come across later), nano doesn’t have the concept of different modes. That is, when you type into nano, it will be interpreted as text to put into the file. Vim, on the other hand, stands in command mode, and if you just start typing, you will get some interesting results. As you might expect, pressing Enter after each line will take you to the beginning of the next line. After typing in the nursery rhyme, you should get something like Figure 6-5.
113
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Figure 6-5. Mary had a little lamb, nano style We shrank the nano window down a bit so that we don’t take up vast quantities of paper with blank whitespace. It also acts as a pretty good example of why you might want to resize a window and how it looks when you actually do. In this case, everything looks just fine, although admittedly for writing anything of a reasonable length, you’d need something a bit bigger than this. You may have noticed that the status line seems to have disappeared. This is because the file stops being a new file once any content has been added to it. Our modified warning is still up in the top right hand corner though. It’s time to get rid of that and get Mary safely on to disk. Looking at the shortcut bar you can see the options we have available to use. The most common ones you’ll use are WriteOut (which really just means Save File) and Exit. Exit actually doubles as WriteOut because if you try to exit nano with unsaved changes, it will ask you if you want to save your changes. Let’s start with the WriteOut command. Hold down the Control key and press the O key. Nano should now look something like Figure 6-6.
Figure 6-6. Using the WriteOut command We made two changes here:
114
•
The status line has made a comeback. This time it’s asking for information, or at least it wants us to confirm it. Now that it’s time to save the file, nano is asking us to confirm what the name should be. Because we passed it a name when we originally started nano, this is the name that nano will provide by default. If we press the Enter key now, it will save the file; but before we do that, let’s take a look at the shortcut bar.
•
The shortcut bar has changed to a whole new set of options because the shortcut bar is actually contextual; that is, it will show you the most relevant things based on what it is you’re doing at the time. These options are only useful (or even available) when saving a file, so this is when you get to see them. We’ve never actually had to use any of these options apart from Cancel (when you suddenly decide that saving is not what you want to do at all).
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Okay, back to saving the file. If you like, you can change the name that the file will be saved as, and nano will not only save it under your new name but will also continue using that name when you go back to editing, which is the same file and you should get a message like the one shown in Figure 6-7.
Figure 6-7. File has been written to disk You can see that the shortcut bar has gone back to its usual look and we have a new message in our status line. You’ll also have spotted that the Modified status has vanished. So far so good. Let’s quickly look at what happens if you try to exit nano while you have an edited file (see Figure 6-8):
Figure 6-8. Exiting before saving All we did here was add a signature to the file (although admittedly it probably wasn’t Mary who wrote it) and then tried to exit nano by using Control and X. This time the status line gives us a scary warning, and the shortcut bar gives us a somewhat reduced number of choices. We can say yes, in which case nano will save the changes before it exits; or we can say no, in which case nano will still exit, but we will lose all the changes we made since the last time we saved the file. We can also think better of exiting and change our minds. In this case, we can use Control plus C to cancel our exit request, which will just take us back to nano.
Moving Around in nano You can move around your text just by using the cursor keys because you’re probably used to from your word processor of choice. In fact the only reason we mention this here is because some editors don’t use those keys at all because they take your hands too far off the home row (that is, they’re slow to use because you have to move your hands a long distance to reach them). So rather than explaining cursor keys, we’ll show you the two features we use most in nano, which are both coincidentally related to finding things.
115
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
The first thing you will probably want to use is the search feature that is somewhat oddly named “Where Is” under nano. We can issue that command by pressing the Control and W keys to get to the next step, as shown in Figure 6-9.
Figure 6-9. Searching for some text Once again we have some new options available to us. The most common task, though, is to simply find a word. So let’s search for Mary and see what happens (see Figure 6-10).
Figure 6-10. Nano found Mary After pressing the Enter key, nano will try to find the text you searched for. In our example, we were already at the end of the file; that’s why you can see “Search Wrapped” in the status bar—nano reached the end of the file and wrapped around to continue the search from the beginning. This is a really handy feature! There will often be more than one occurrence of the word that you’re looking for. If you want the second Mary, you repeat your search. You can do this by just pressing Control and W and then immediately pressing the Enter key. Nano remembers what you searched for last time, and if you don’t supply a new word, it will simply search again with the old word. This means you can easily cycle through the document to find the specific entry that you’re looking for. The last feature that we’ll cover is a slightly more specific form of search. Suppose that rather than searching for a word, you want to go to a specific line number. In day-to-day text editing this is not something that you’ll actually do all that often. However, when you start writing scripts and they generate errors, you will generally be told which line that error occurred on. For short programs it often doesn’t matter, but if you’re building something fairly epic, you’ll want to be able to get to the line quickly. This is true even in medium-length programs because if you have a particularly tricky problem, you’ll have to keep revisiting a specific piece of code and you certainly don’t want to have to use the cursor keys to find it each time. To go to a specific line number, you need to start the search as you did before by using Control plus W; but rather than typing any text, you should then do Control plus T. This will change the status line as shown in Figure 6-11.
116
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Figure 6-11. Go to a specific line number All you have to do here is enter the line number that you want to go to and press Enter. You can also see that there are some other useful options here that allow you to go to the start of the file and the end of the file, respectively. You can also press command and T to go back to searching for text, or you can press command and C and cancel the search.
Wrapping Up nano That’s all we’re going to cover for nano but as you can see, even the limited amount of functionality we’ve covered has already given you the ability to edit configuration files or even compose your own book. Nano is great for these kinds of tasks where you don’t want distractions and you just want to get the job done. As it happens, a good deal of this book was written in nano, so it just goes to show that this tool is certainly not just a toy! That being said, let’s move on now to look at what the vim editor can offer you instead.
Getting Started with vim Vim is a bit more advanced than nano. Whereas nano was specifically designed to be simple, vim is designed to be a fully featured environment for doing all sorts of tasks. You can even integrate other applications (such as the shell and source code control) directly with vim, so you can do huge amounts of work without ever leaving your text editor. The downside to this raw power is that you have to learn how to use it. Unlike nano, which is basically ready to use right away, vim has the concept of modes. Generally speaking you’re either in the normal or insert modes, and they are the ones that we’ll focus on in this section. However, we do want to point out that even though we use vim on a regular basis, we’re not what you would call vim experts. We know how to use the functionality that helps us with our work, but there are many features that we don’t use or even know about. Because this is just a primer on vim, we don’t feel that this is an issue, but if you think vim is the tool for you, there is a wealth of books dedicated solely to vim as well as numerous video tutorials on some of its more advanced and powerful features. Rather than having to type in yet another poem, let’s give Mary an encore and bring her back to the stage with vim. First though, we need to install it: $ sudo apt-get install vim Now that we have vim, let’s see about that encore: $ vim test.txt Needless to say, starting vim is as straightforward as starting nano, but it does look a little different once it has started (see Figure 6-12).
117
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Figure 6-12. Starting up vim Gone are the nice headers, status lines, and shortcut bars. In the land of vim, like Linux itself, we’re expected to know what we’re doing. In the bottom left of the screen, you can see the name of the file that we’re editing. Next to that is 6L, which tells us how many lines are in the file, followed by 115C which tells us the number of characters. On the other side of the screen we have another useful piece of information: 1,1, which tells us the line that we’re currently on and the column that we’re in. At present it is telling us that we’re on line 1 and in the first column. That makes sense because we only just opened the file; if you look at the cursor, sure enough we’ve sitting on top of the first M.
■ Note Depending on the version of vim and how it is configured, it will usually take you to the location you were at when you last stopped editing that file. This is really useful when programming because it gets you immediately to where the action is.
You can also see several lines of tildes (~) beneath the last line in the file. They are here to remind us that although the screen is a certain size there is no content below Mary. This is especially useful when doing certain types of programming and you want to make sure there’s no additional whitespace. It’s really just a visual clue and won’t get in your way.
The vim Modes Vim comes across as being a bit quirky because (unlike word processors and more basic text editors) with vim you can’t start typing right away because vim has different modes or personalities. When you first start vim, it is in command mode. Unlike nano, in which you give commands by using key combos, vim has a wide range of commands that are single or double letters. You might think that this would be hellishly confusing and, well, you’d be right. Once you know the magic key presses to make vim do your bidding, you’ll love this way of controlling your text editor. Until then, however, it’s likely to drive you to distraction. So let’s get out of command mode and slip into something more comfortable. We can replicate a nano-esque environment in vim by pressing the i key. This will take us out of command mode and place us in insert mode. You can tell when you’re in this mode because you see --INSERT-- in the bottom-left corner, as shown in Figure 6-13.
118
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Figure 6-13. Vim in insert mode At this point you can move around your text file just as you did with nano. The cursor keys work as expected and you can add and delete text as you did under nano. The differences start when you want to do something other than writing text, though. How do you save your changes?
Saving Your Changes To save your changes in vim the first thing you need to do is exit from insert mode by pressing the escape (ESC) key. This takes you back to normal mode, in which you can issue commands and consequently save your document. First, though, let’s change the signatory to say John instead. This will give us the much-needed change for the document. To actually save the document we use this command: :w The command really is a colon followed by a lowercase w. Vim is case-sensitive, so if you tried to do: W, you would get an error message that it isn’t a valid command, as shown in Figure 6-14.
Figure 6-14. Whoops, W isn’t a command There’s no need to panic; just try the command again and you’ll be fine, as shown in Figure 6-15.
119
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Figure 6-15. :w works like a charm If you want to change the file name while you were saving, you can simply type in the filename you want to use after the command like so: :w test2.txt This will then save the changes to the new filename and will then continue to edit the new file.
Getting Out of vim This leaves us with just one more feature to bring you to the same basic level that you had with nano (we’ll cover searching in just a moment). Once you’ve done all your editing and you’ve saved your files, you’ll want to exit. The command for this is as follows: :q As long as you haven’t made any changes, vim will immediately exit, and you’ll be back at the command line. However, if you had made some changes and you try to do this, you’ll once again catch the wrath of vim, as shown in Figure 6-16.
Figure 6-16. To quit without saving you’ll need an override
120
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Fortunately, vim has already told us how to fix the problem, but basically if you want to quit without having your changes saved, you’ll need to explicitly tell vim that’s what you want to do: :q! And that’s all there is to leaving vim!
Searching in vim In this section we’ll cover only the basics and show you how to do the same sorts of searches that you did in nano. In actual fact, vim has very advanced search capabilities (you can use regular expressions for a start; see the following sidebar) but although you might come to depend on these features as you become more advanced in your usage, you’ll still probably find that you spend most of your time doing the simple things. To search for a word in vim, all you need to do is prefix it with a forward slash. To give this a try, while in command mode (tap the Escape key twice to ensure that you’re in the right mode) type: /Mary This should then find all instances of Mary and highlight them for you, as shown in Figure 6-17.
Figure 6-17. Vim found Mary You can see the “search hit BOTTOM, continuing at TOP” message, which is equivalent to the nano “Search Wrapped” message. One thing to watch out for with vim is that because it uses regular expressions for searching, it’s also case sensitive by default. That means if you search for mary rather than Mary, expect to receive a complaint as shown in Figure 6-18.
121
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Figure 6-18. Vim can’t find mary One advantage that vim has over nano is repeated searches. To move to the next search result, all you need to do is press the n key. In our preceding example text, if you search for Mary with /Mary and then keep pressing the n key, you will see vim will cycle through the search results for you. We can’t really demonstrate that effect in print, but it’s a nice distraction for a few seconds if you’d rather not be doing something else. If you’d like to search in the opposite direction (i.e., toward the top of the file rather than the bottom), simply use a capital N instead.
REGULAR EXPRESSIONS Regular expressions in the right hands are like magic. They slice through complex text-processing tasks like a hot chainsaw through warm butter. They are also frequently used to give system administrators bed-wetting nightmares and to scare small children. Regular expressions are very powerful once you know how to use them, but boy does that power come with a cost! Be that as it may, a basic knowledge of regular expressions will be very useful to you, and you can use them directly in vim for searching, replacing, and otherwise manipulating your text. We don’t have enough space to go into regular expressions here (often referred to as regex), but there are some fantastic resources available on the Internet to get you started, not to mention complete books on the topic. A great starting place is Jan Goyvaerts’ website: www.regular-expressions.info/. Not only is this site full of useful and helpful information (it is very often our first port of call) but Jan has also written some very powerful software. We bought RegexBuddy many years ago and it’s still our first port of call when we’re trying to debug some complicated regex. If you want a simpler tool for testing out your regular expressions, check out http://rubular.com/, which does real time regex parsing in Ruby.
Moving to a Specific Line Number The last thing we covered in nano was moving to a specific line number. This is actually much easier in vim, probably because it’s something that programmers have to do all the time. To jump to a specific line number, all you need to do is place the line number after the colon. For example to jump to the 5th line all you’d need to do is this: :5
122
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Once you hit the Enter key, you’ll be taken directly to the fifth line. As before, this feature isn’t particularly useful for normal editing, but it comes in handy when you’re fiddling about with a program that simply refuses to work the way you know it should!
Moving About in vim Although we’ve already shown you how to move around your text file, we haven’t been leveraging the power of vim. Vim provides additional commands that can allow us to navigate through text more quickly. In command mode, you can still move around your text using the cursor keys, which is convenient. In effect, you can do the same thing using two other commands: the h and l keys. The h key will move the cursor back one character, and the l key will move the cursor forward one character. Admittedly that’s not very exciting, but we can now introduce the b and w commands. They work just like the previous commands, but instead of stepping back just one character, they jump to the beginning of words. Suddenly that’s more useful because now if you have a long line of text, rather than pressing and holding down the cursor key for extended periods of time (tempting, though, isn’t it?), you can greatly speed up the process by hopping a word at a time. We can take this one step farther, though. If you want to jump to the beginning of a line you can press the 0 (zero) key. To get to the end of the line, you simply use $ (in our case, that means holding down the Shift key and pressing the 4 key). This is surprisingly useful because there will be lots of times when you want to get to either the beginning or the end of the line, and now you can do so with a single key press. Table 6-1 makes it a bit clearer. Table 6-1. Common Navigation Shortcuts in vim
Movement
Key press
Start of line
0
Back one word
b
Back one letter
H
Forward one letter
l
Forward one word
w
End of line
$
So what we have now is a progressive way to move our cursor from one end of the line to the other. No longer do we have to fiddle about with the Enter or backspace keys, or fall asleep waiting for the cursor to trundle across the screen. That’s just the beginning, though, because these keys can be used for a lot more than just moving around your file; they can also be used to specify the scope of the commands you feed to vim.
Deleting in vim In command mode, to delete a single character all you need to do is press the x key. This will remove whichever letter happened to be under the cursor at the time. This is sometimes useful in its own right (usually when tweaking a typo), but it doesn’t really offer you any great advantages over dropping into insert mode. The d key, however, provides a very powerful delete command that you can now combine with your newly acquired knowledge of moving the cursor to do some pretty impressive things.
123
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
The first delete command we’re going to try is dd. Let’s start out by deleting the first line in our file. To make sure we’re all in the right place, use the following command to get back to the first line: :1 Now we’re going to delete the current line by typing the following: dd Your poem should now be somewhat shorter and look like Figure 6-19.
Figure 6-19. Deleting the first line Now that we’ve ruined our poem, now would be a great time to introduce another very useful feature in vim: the “undo” command. To undo the change we just made, simply press the u key, and Mary will be restored to her former glory. This not only prevents panic attacks when accidentally deleting the wrong line but it also means we can delete parts of this line in numerous fascinating ways. If you have more than one line that you want to remove, you can tell vim how many times you want it to execute a particular command by prefixing the command with a number. For example, if we want to remove three lines from our poem, we could do this: 3dd This is equivalent to pressing the d key six times and gives you the happy result shown in Figure 6-20.
Figure 6-20. Deleting three lines in one go
124
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
You can see in the bottom-left corner that there are now “3 fewer lines” just as you hoped. Let’s restore Mary with the u key and try something else. With our cursor at the beginning of the first line, try executing this command: dw This command combines the delete command with movement commands that you saw earlier. In this case, we combined it with w. which means “one word to the right.” You can see the effect of that command in Figure 6-21.
Figure 6-21. Deleting a single word Rather than moving the cursor, we have effectively selected text that we wanted to delete. In this case, d will start deleting from the cursor’s current location, up to the first letter of the next word. We could have achieved this effect easily enough simply by pressing the x key multiple times, but using dw is clearly faster and more precise. Let’s take this to the next level and combine what we know. We know that we can make vim execute a command multiple times by prefixing the command with a number. We also know that we can combine the d command with w to delete a complete word. Let’s revive Mary (another press of the u key) and try this new improved command (the results of which are shown in Figure 6-22): 2dw
Figure 6-22. Deleting two words at once Well isn’t that interesting? We’ve been able to combine a serious of commands to express some reasonably complicated tasks. You can, of course, combine them in any way. For example, if you want to delete everything to the end of the line, you can use d$. If you want to delete everything from the start of the line, you can use d0. It’s being able to combine commands in this way that makes vim such a powerful tool for working with text. Although these features are of fairly limited used when working with English prose, when you start working with programming languages, they become very useful indeed.
125
CHAPTER 6 ■ EDITING FILES ON THE COMMAND LINE
Miscellaneous Little Commands Before we move on to look at some of the features of Vim’s visual mode, we’re going to provide a very quick overview of some other simple commands that will come in handy. The i enters into insert mode, but sometimes you want to write immediately above or below the current line. You can get this effect by using O and o respectively. These will both insert a new line and then switch to insert mode. Sometimes you don’t need to actually edit the content of a file; you just need to change a single letter. This could be because of a typo or maybe you just want to increment a number. You can do this with the r key. This key allows you to replace the character under the cursor with any other character. Simply press r and then type the character you want to replace it with. Simple but very effective!
Visual Mode Visual mode is not something we use very often, but it can save us a huge amount of time and effort. This mode enables you to select or highlight blocks of text for further processing. This is akin to highlighting text with your mouse in a word processor. There are two ways you can enter visual mode from command mode: by pressing either the V key or the v key. If you use the uppercase V, you will be able to select a block of text based on lines. With the lowercase v, you gain extra precision as you can select based on single letters rather than entire lines. The overall result is the same, and the option you choose depends only on which one would be most convenient to you. So what exactly can you do with visual mode? Well it really doesn’t do anything in and of itself; it just provides an easy way for you to tell vim what text the following command should be applied to. In keeping with our previous examples, let’s select a chunk of Mary’s poem, as shown in Figure 6-23. (You don’t need to highlight the exact text that we have, but try to get a fairly random chunk.)
Figure 6-23. Highlighting text in visual mode As you can see from the highlight, we used the lowercase v option as we wanted to highlight within a particular word. There’s no real reason for that apart from a sense of the dramatic, so it could easily have been a bunch of lines selected with V. Now let’s apply our favorite command: the delete command. By pressing d, you will find that the highlight text magically disappears. In this case, you don’t need to provide additional information to vim to tell it what to delete because in effect you’ve already told it by highlighting the text in the first place.
Indenting Text Of course, you can do other interesting things apart from deleting text (though deleting text is fun). For example, if you want to indent the first two lines of the poem, you can highlight the first two lines with V and then use the greater-than and less-than signs (> and &2 exit 1 ;; esac exit 0
--make-pidfile --exec
The first thing you will notice is there are a lot of lines that start with #. These lines are comments; because # is the comment symbol in BASH, any line that starts with a # will not be executed as part of the application. The top lines of INIT INFO are in fact very important for an init script. These are special comments that can be processed to show how the application controlled by the script is to be run. The blocks look like this: ### BEGIN INIT INFO # Provides: # Required-Start: # Required-Stop: # Default-Start: # Default-Stop: # Short-Description: # Description: ### END INIT INFO
xbmc $all $all 2 3 4 5 0 1 6 Start XBMC Start XBMC
These blocks provide a few bits of description and say for which application they provide a function; in this case, the application provided is XBMC. They also mention what applications are needed to be running before this application can start or stop. The $all symbol means that this application will be started last, so that it is guaranteed that all other applications on which it can depend are started before it. Probably the more important set of operators are Default-Start and Default-Stop. These operators correlate with the Linux system’s run levels, which govern the various stages of the Linux system boot process. The Linux specification defines the following run levels: •
Level 0: Halt; shut down and power off
•
Level 1: Single User Mode; only basic system functionality (used for repairs)
•
Levels 2 % 3: Multi User; adds networking and multiple user functionality
•
Level 4: User Defined
•
Level 5: Normal System running state
•
Level 6: Reboot
The numbers next to the start and stop switches correlate to these levels, so XBMC will start in run levels 2–5 and will shut down in levels 0, 1, and 6.
142
CHAPTER 7 ■ MANAGING YOUR PI
Pick and Match with the case Statement Once all the initialization is done and the script has set some initial variables, it performs a few quick tests and then moves on to the case statement. A case statement is very much like a series of running if statements against the same variable. Insofar as you take a given variable and for each of a series of given values for said variable, you perform a function. In most init scripts, this is used to confirm which action it is to perform. The case statement in this start script is working on the special $1 variable. This variable represents the first thing passed to the script from the command line; so when trying to start the xbmc application, you will execute with this: /etc./init.d/xbmc start This gives the $1 variable the value of start. The case statement offers a number of different options of the potential value of the case statement: •
start: Self-explanatory.
•
stop: Self-explanatory.
•
restart|force-reload: The values of restart or force-reload, which perform the stop application and then the start application in one process. The pipe (|) between them is used to denote an OR operation, which means that if either of the values here match, we treat this as having been a match.
•
*: Anything else.
After each case value, there is a small block of code that is executed in that case, followed by a pair of semicolons. These semicolons are like a fi and are used to denote the end of a block of case statement code.
Application within Application: Forking Once within the case statement, you can see that each line will perform some action with the start-stop-daemon. But this isn’t a variable or anything special; it’s another program. The most powerful part of BASH is the bit we haven’t gotten to yet. BASH has the capability to execute any command-line process from within your programs just by using their names. Because BASH is the shell we use most of the rest of the time, this actually makes a lot of sense. The last function of an init script: it will use the start-stop-daemon to create a new process for you. This action is called forking because you are forking something off of the currently running application. The start-stop-daemon is a small application that is used to fork off processes and will manage their running for you. The start script corrals the arguments for it, works out what action needs to be performed, and then tells start-stop-daemon which action needs to be taken against which application. Now that you are armed with this knowledge, you should be able to write your own simple init scripts to start and stop any process you want by providing the starting comment block to describe how the script should be loaded, having a case statement determine which action to take, and finally executing the start-stop-daemon process to launch and manage your application!
Update the Run Files Now you have a fully working script ready to go. You need to use chmod to set the executable flag on your file and then you can test it with the start and stop commands. It does as intended—fantastic! Now we need to add it into the system’s boot logic. Historically, this involved linking the file in a special way into the various run levels. However, this has been made much easier with the update-rc.d application. The update-rc.d application takes advantage of those special comment headers we added to our BASH scripts in order to know which run levels should have which shortcuts.
143
CHAPTER 7 ■ MANAGING YOUR PI
All we need to do to add the init script to the boot sequence is to issue the update-rc.d command with the name of the init script we want, which is xbmc in the example. Then we need to add the argument to say that we should use the defaults from the comments in the script; the argument unsurprisingly defaults. This gives us the command update-rc.d xbmc defaults, which will need to be executed as root. When run, the outputs should be as follows: $ sudo update-rc.d xbmc defaults update-rc.d: using dependency based boot sequencing And that’s it; if you reboot, your application should run on boot!
Creating Your Own init Script We have covered how init scripts are created; now we can create one. The process is relatively simple because we simply need to re-create the structure and input our own code in the correct place to perform the functions we need. You can have these init scripts do quite literally whatever you want, but for this example I will be creating a file with the touch command and then deleting it with rm when done. The touch command is used to simply create a file on disk with nothing in it; if it runs on an existing file, it will change the last modified time of the file. As mentioned earlier, you can have your programs managed by start-stop-daemon or you can simply perform system functions, as I will do in my example. As you will recall, the first thing we need in this script is the shebang, which is the starting point for all BASH scripts and is thus the best place to start. #! /bin/bash Now that we have our shebang, recall the XBMC start script we worked with earlier: the first thing in that script is the opening comment block that gives us details about which init levels will run this script, and so on. So let’s add that next. You should fill in all your own details here. My script will be called touchfile.sh and will provide the Touch File service. My opening block of script will look like this: ### BEGIN INIT INFO # Provides: # Required-Start: # Required-Stop: # Default-Start: # Default-Stop: # Short-Description: # Description: ### END INIT INFO
touchfile $all $all 2 3 4 5 0 1 6 Run TouchFile Run TouchFile
Now that I have defined the comment block, I can define my variables. They will be the variables that will cover what my application does. Anything you can think of needing in order to start this that can be configured should be defined as a variable. In the case of my touchfile command the thing I need to have defined as a variable is the filename of my touchfile. Remember that this is your code, and thus you can define literally anything you desire as a variable. My variable is this: TOUCHFILE="/var/tmp/touch.file"
144
CHAPTER 7 ■ MANAGING YOUR PI
Now that my touchfile is defined, I need to add the case statement to cover the available actions. In this case, I want to have the following actions: •
Start: Touch the file
•
Stop: Remove the touched file
•
Restart: Remove and then re-touch the file
•
Reload: Touch the file
•
Default Case: Tell people about how to use this file
This means I will have four case statements within my case. I will define the case statements (sans code to perform actions) as such: case "$1" in start) ;; stop) ;; restart) ;; reload) ;; *) ;; esac exit 0 Now that we have the case entries, we just need to make them do something. I mentioned earlier what I want to do in each of the cases, so let’s write out the commands into each block and combine them into the script we have already. This will give us the following script: #!/bin/bash ### BEGIN INIT INFO # Provides: touchfile # Required-Start: $all # Required-Stop: $all # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: Run TouchFile # Description: Run TouchFile ### END INIT INFO TOUCHFILE="/var/tmp/touch.file" case "$1" in start) echo "Creating $TOUCHFILE" touch $TOUCHFILE ;; stop) echo "Removing $TOUCHFILE" rm $TOUCHFILE ;;
145
CHAPTER 7 ■ MANAGING YOUR PI
restart) echo "Recreating $TOUCHFILE" rm $TOUCHFILE touch $TOUCHFILE ;; reload) echo "Re-Touching $TOUCHFILE" touch $TOUCHFILE ;; *) echo " Usage: touchfile.sh " ;; esac exit 0 And that’s it. The code is a simple init script, which accepts the start, stop, restart, and reload commands and outputs what it is doing and performs actions based on what arguments we provide it. This can be placed in /etc./init.d and can be set to be executable with chmod +x. Once they are done, you can test the script to ensure that it works. Finally, you can use update-rc.d to add this to your system boot process as we did earlier. It is in this fashion that you can write your own start scripts to run applications as you design.
Security and User Management Security is one of the most neglected areas of systems administration. Because it is perceived as a black art to many, it often gets neglected.
The Rules of Raspbian Security There are some very simple ways to make your system secure; just follow a few rules: •
Don’t log in as root, but if you must, log out when done.
•
Use sudo whenever possible for admin tasks.
•
Choose a nontrivial password—one that is long enough and complex enough that it cannot be readily guessed or worked out by hand without taking a long time.
•
Change your password regularly.
•
Review your system logs regularly, specifically /var/log/auth.log because it lists all user authentications to your system.
•
If you don’t need an application running, don’t run it.
•
Expose as little of your system to the Internet as possible.
•
Restrict file permissions whenever possible.
Most of these rules will seem like common sense and that is because they are. Yet most people seem to fall into the trap of thinking that they won’t be attacked and ignore most of this advice. Now that you know these rules, you are probably saying, “I will change my password if only you would show me how!” Changing your password from the Linux command line is relatively easy: you simply use the passwd command and you will be prompted to enter a new password (twice, so that you can’t misspell it by accident the first time).
146
CHAPTER 7 ■ MANAGING YOUR PI
You can also change the password for other users as root. To do this, you simply append the name of the user whose name you are changing as the first argument of the command. This is incredibly useful when configuring new user details or resetting passwords.
Adding a New User Because you aren’t supposed to use root at all times, it’s important to be able to create new users and understand how user creation takes place. In Linux operating systems, the users are governed by the file /etc./passwd. You can have a look for yourself and you will see a number of lines like this: root:x:0:0:root:/root:/bin/bash daemon:x:1:1:daemon:/usr/sbin:/bin/sh These lines show the user, X for the password, the user’s ID number, the user’s group ID number, the user’s group identifier, the path of the user’s home directory, and the user’s shell. These are the basics of what is needed for a user to function within the Linux environment. While this file has a password field, it is no longer used and normally contains a placeholder (in this case, X). The passwords are stored in the shadow file, /etc./shadow. The shadow file was separated so that only root could access password data and all the more common user data could be read by other more generic system applications. Now that you understand how Linux stores users, add a new one called raspberry. To add this user, we will use the useradd command and a few arguments. There is another command, adduser, which performs user additions, but instead of being supplied with arguments will prompt you for details. adduser is a great command to use in a pinch when you forget a necessary argument for useradd. First we want to specify the user’s home directory, which is done with the –d flag and the full path of the directory we want to use. Most home directories for users are /home/, and we will do this for raspberry. Currently, /home/raspberry doesn’t exist, but before you rush out and add it, we can use the –m flag to tell useradd to do it for us! This gives us this command: $ sudo useradd –d /home/raspberry –m raspberry We could go a step further and even specify the group with –g to set the primary group for the user. Or even specify the shell that the user would use with –s or finally a password with –p . Once you have executed your command, you can go and inspect the changes to /etc./passwd, where you should see something like this at the bottom of your file: raspberry:x:1001:1001::/home/raspberry:/bin/sh That’s it; you have now successfully added a new user! If you didn’t specify a password, you can use the passwd command we covered earlier to change your new user’s password and then you’re set to go. However, let’s say that you forgot to set the shell path with –s earlier and you want to change that so you start with /bin/bash rather than /bin/sh. Well, first you could edit the passwd file to change the shell or you can use the usermod command. The usermod command functions exactly the same as the useradd command, right down to the arguments; it simply adjusts the values. So run the following: $ sudo usermod -s /bin/bash raspberry We can expect the shadow file to be changed and, yes it is: raspberry:x:1001:1001::/home/raspberry:/bin/bash Fantastic! With these tools, you should be capable of creating new user accounts to allow people to access your Pi.
147
CHAPTER 7 ■ MANAGING YOUR PI
Summary This chapter covered quite a number of things. We introduced SSH, DHCP and DNS. We covered some of the basics of how these systems function and how daemons are launched via init scripts. We then dove deep into learning BASH so that we could write our own init scripts. Finally, we covered some common security do’s and don’ts; then went on to cover how the basics of Linux systems manage users and their passwords. We even went so far as to create a whole new user ready for use. These skills should enable you to manage the startup and networking of your Pi and should have given you an introduction into the wonderful world of software development!
148
CHAPTER 8
A LAMP of Your Own One of the key things that many people who come to Linux want to know is how to establish themselves by setting up a small website of their own. And many have difficulty finding a place to start. Which OS, which applications, what hardware, and how exactly to do all this? All these are legitimate questions as there are so many facets to the greater Linux environment that it is very easy to get lost. Our goal is to provide the first few stepping stones on your way to being able to navigate the Linux environment. One of the key stepping stones on this path is to show you how to install, configure, and maintain a web server. Although you will be able to connect this server to the Internet, in these examples we will only cover using your Pi as a local network server (in other words, for running an intranet). In addition, there is also the extra challenge of learning how to make a basic interactive website. While this may seem a lot to take on, and others devoted entire books and lives to finding the absolute optimum solution this problem, we aim to cover it for the Raspberry Pi in one chapter. To this end we will be using a LAMP. No, not one of those bedroom luminescence devices, but a Linux, Apache, MySQL, and PHP system designed to make delivering web content easy. This is one of the easiest ways to create your own web server and there are a number of variations on the original LAMP, which include, but are not limited to, the following: •
WAMP (Windows, Apache, MySQL, PHP)
•
MAMP (Mac OS, Apache, MySQL, PHP)
•
Replacement Ps with Python or Perl
•
Replacement M with MariaDB
So, as you can gather from the amount of mixing, matching, and improving that people have done, it is a great way to get a powerful web server up and going. Best of all, it is simple to set up and can be run on just about any hardware. One of the most regularly cited potential uses of the Pi is to enable the ability to build, run, and maintain a website. What better way to inspire a generation of young developers than to teach them how to make their own websites with a minimum of cost!
First Steps Now it is time to get real about what we can accomplish here. Within this chapter, we will provide you the skills to set up a full website stack and show you how to integrate the functions of a MySQL database into a website using PHP to dynamically generate website content. However, there are a few things we won’t be able to do for you here: •
Set up and configure a DNS or domain naming
•
Advanced SQL and database administration
•
Full coverage of HTML and HTML development methods
P. Membrey et al., Learn Raspberry Pi with Linux © Peter Membrey and David Hows 2013
149
CHAPTER 8 ■ A LAMP OF YOUR OWN
•
Full coverage of PHP development and PHP development methods
•
JavaScript
•
CSS
There are a number of resources that you can take advantage of to get help with these other areas, including other great and weighty texts by Apress. We still have our work cut out for us, so let’s get started.
L is for Linux There are only a few prerequisites for setting up a LAMP stack. You will need to •
Have the Raspbian OS (the L of LAMP) installed and configured
•
Have the memory split set to 240/16 (run sudo raspi-config)
•
Be familiar with working within the Raspbian OS using the command line
•
Have a basic understanding of how to write simple software
•
Have your Pi connected to a network and the Internet (how else can we serve content if we aren’t?)
There are only a few other provisos for Raspberry LAMP. We will be doing all of this from a shell. Given that the website will be viewed from outside the Pi, there is no need to use any extra resources to run the GUI. Now that we know what we need to get going, let’s do it.
A is for Apache Probably the most important part of any web server is the web server application. A web server is an application that will take requests for a website and then return the requested web page content. Most web servers can also provide a large number of other functions that can help enhance their capability to provide web content to end users. For our LAMP stack, we will be using the Apache web server. Apache is considered by many to be the world’s premiere web server. It was first released in 1995 and has become renowned for playing a role in the growth of the World Wide Web by providing a simple, powerful, and free web server to the masses. As reinforcement of this fact, it is estimated that Apache delivers between an estimated 54 to 58 percent of the world’s websites. There are two stories that are told about how Apache came to be named: •
The first is that it was named for it being “A patchy web server” when first developed all those years ago.
•
The second (and much better from a storytelling perspective) is that Apache is said to be named for the Apache tribes of America.
Being named for a tribe is not even a misnomer as acting like a tribe is one of the key features of Apache. Apache’s first task when it starts is to create its own small tribe of “workers” that are tasked with the actual serving up of your website’s content. Now that you have a clearer understanding of what Apache does, the first step becomes to get Apache installed, up and running. For our installs, we will rely (as ever) on the ever-faithful apt-get tool: $ sudo apt-get install apache2 Reading package lists... Done Building dependency tree
150
CHAPTER 8 ■ A LAMP OF YOUR OWN
Reading state information... Done The following extra packages will be installed: apache2-mpm-worker apache2-utils apache2.2-bin apache2.2-common libapr1 libaprutil1 libaprutil1-dbd-sqlite3 libaprutil1-ldap ssl-cert Suggested packages: apache2-doc apache2-suexec apache2-suexec-custom openssl-blacklist The following NEW packages will be installed: apache2 apache2-mpm-worker apache2-utils apache2.2-bin apache2.2-common libapr1 libaprutil1 libaprutil1-dbd-sqlite3 libaprutil1-ldap ssl-cert 0 upgraded, 10 newly installed, 0 to remove and 71 not upgraded. Need to get 1,348 kB of archives. After this operation, 4,990 kB of additional disk space will be used. Do you want to continue [Y/n]? Now that you have installed Apache, we should go and validate that it is all up and running. There are a few ways we can do this. First, run this: $ ps -ef | grep root 2306 www-data 2309 www-data 2311 www-data 2315
apache 1 0 2306 0 2306 0 2306 0
Sep17 Sep17 Sep17 Sep17
? ? ? ?
00:00:09 00:00:00 00:00:00 00:00:00
/usr/sbin/apache2 /usr/sbin/apache2 /usr/sbin/apache2 /usr/sbin/apache2
-k -k -k -k
start start start start
From this output, you can see that Apache is indeed up and running. From this point, there are another few important things to note. The first process listed with the following line is different from the others: root 2306 1 0 Sep17 ? 00:00:09 /usr/sbin/apache2 -k start This is the chief of the Apache tribe mentioned earlier. It is owned by root (as indicated in the first column), and its process ID (PID) is 2306. The other three are owned by a user called www-data, which is a user specifically for Apache. While each worker has a different PID, they all have a PPID (parent process ID) of 2306, meaning that the Apache chief process made them (its PID is 2306). Now for the second and by far more fun test; on this test, we will actually get Apache to display its default starting web page! For this, you can either log in to the GUI or you can get the system’s IP address using ifconfig. Your output should look like the one following with the relevant IP addresses highlighted: $ ifconfig eth0 Link encap:Ethernet HWaddr b8:27:eb:8a:46:ba inet addr:10.0.0.20 Bcast:10.0.0.255 Mask:255.255.255.0 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:213812 errors:0 dropped:0 overruns:0 frame:0 TX packets:5119 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:1000 RX bytes:19226371 (18.3 MiB) TX bytes:495394 (483.7 KiB) lo
Link encap:Local Loopback inet addr:127.0.0.1 Mask:255.0.0.0 UP LOOPBACK RUNNING MTU:16436 Metric:1 RX packets:8 errors:0 dropped:0 overruns:0 frame:0 TX packets:8 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:0 RX bytes:1104 (1.0 KiB) TX bytes:1104 (1.0 KiB)
151
CHAPTER 8 ■ A LAMP OF YOUR OWN
Assuming your system is (like mine) attached to a network, you can use the first IP address (10.0.0.20). This address in the eth0 block represents its network port. The address in lo block is the loopback address, which is used for internal self-reference and is always 127.0.0.1. The next test is to access the Apache default web page; and to do so, you simply need to input one of those IP addresses into a browser (assuming that you are on the same network as the Pi, of course!). If you want to test using the Pi’s onboard browser, that’s completely fine, too, and you can choose between either address (10.0.0.20 or 127.0.0.1). So what are you waiting for? Open a browser window and have a look at the default web page, as shown in Figure 8-1.
Figure 8-1. It works! As you should by now be aware, it works! This is the default web page for the Apache web server and as it suggests there is no content added yet, we will be getting to that later. For now, let’s have a look at how that one default page is generated, as this will give you some insight into how Apache truly works.
Apache Configuration Getting your head around the Apache config is, to be frank, a bit of a nightmare. If you’re game, go ahead and have a look in /etc/apache2 for an idea of what I mean. There are a number of folders in there with different meanings and how those folders interrelate changes how your Apache server instance works. Thankfully, though, once you understand where you need to make changes, everything becomes much easier. The first file of note in the Apache configuration is the apache2.conf file. This is the governing config file that says where each of the other separate pieces are located, and how the application should load them. The second things to be aware of are the mods-available and mods-enabled folders. If you have a look at the mods-available file, you will see that there are a large number of .load and .conf files. These files represent where Apache should load a module from and any configuration information this module needs, respectively. Next is mods-enabled, an initial look over this folder will make it seem just like mods-available. However, if you run an ls –l on this directory, you will see this: $ ls -l /etc/apache2/mods-enabled/ total 0 lrwxrwxrwx 1 root root 28 Sep 17 21:44 lrwxrwxrwx 1 root root 28 Sep 17 21:44 lrwxrwxrwx 1 root root 33 Sep 17 21:44 lrwxrwxrwx 1 root root 33 Sep 17 21:44 ...
alias.conf -> ../mods-available/alias.conf alias.load -> ../mods-available/alias.load auth_basic.load -> ../mods-available/auth_basic.load authn_file.load -> ../mods-available/authn_file.load
This shows that, in fact, each of the files in mods-enabled is actually a link to a file in mods-available! This is the first intricacy of the Apache configuration, while there are a number of available modules at any given time only a
152
CHAPTER 8 ■ A LAMP OF YOUR OWN
certain number are actually loaded. Using symlinks like this means that only one copy of the configuration needs to be kept and maintained at a given time. And more to the point, any changes made to one will be made to both. If you look inside the sites-available and sites-enabled folders, you will see the same layout, except there might be fewer sites. This brings us to the true object of our search: the first default site that is available within the Apache system. So open up either /etc/apache2/sites-available/default or /etc/apache2/sites-enabled/ 000-default because it doesn’t matter; they are the same thing! So, now that you’re inside, go over what everything in the config means. Many of them will be important for you later on if you wish to add additional websites or modify how websites are displayed.
ServerAdmin webmaster@localhost DocumentRoot /var/www
Options FollowSymLinks AllowOverride None
Options Indexes FollowSymLinks MultiViews AllowOverride None Order allow,deny allow from all
ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Order allow,deny Allow from all
ErrorLog ${APACHE_LOG_DIR}/error.log # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn CustomLog ${APACHE_LOG_DIR}/access.log combined
The first line is probably one of the most important; it specifies that this web server is available to any incoming address on port 80. Changing this means you can run multiple web servers on the same site by using different ports to reference each.
■ Note You can specify a port when connecting to just about any application by adding : at the end of the URL.
Following the VirtualHost address, the next relevant thing is the DocumentRoot. This is critical as it says where Apache will load all the web server content from. This means that anything that is in the /var/www folder will become
153
CHAPTER 8 ■ A LAMP OF YOUR OWN
available via the basic website on port 80. For example, if you go into the /var/www folder, you will see one file: index.html. If you examine this file, you will see some very familiar content: It works!
This is the default web page for this server.
The web server software is running but no content has been added, yet.
Yep, that’s the website content that is used to generate the basic start page that Apache is currently showing. I try to think of it this way: the web server is providing you access to that folder (and all subfolders and documents within it). As proof of this, try executing the following command as root: $ echo "Hello World" > /var/www/foo
■ Note You can gain root by executing sudo su –. Once you have successfully executed this command, direct your browser to http:///foo and you should see hello world displayed there. You may be wondering why we didn’t need to use index.html in the first request to our website (i.e., use http://10.0.0.2/index.html). This is because files named “index” are special ones. They are the default page displayed if no other content is available. The next portions of the config you should be aware of are the Directory config sections. These are a list of directories that can provide special rules as to how they are accessed and even who can access them. In this instance, there are two directories that Apache has configuration settings for: the / root directory and /var/www. While there are a number of very interesting things you can do with the directory values, there isn’t much we need to do with them here. For more information, you should head over to the Apache website and read through the far more detailed documentation available there. After the directory details comes ScriptAlias, which governs how CGI scripts are accessed by the application. The ScriptAlias is a special directory in which these CGI programs live and are executed from. As PHP is a scripting system much like BASH (covered in Chapter 7), you may think this has a direct bearing, but it is not the case. PHP is run by a special interpreter module (modphp) rather than by a single CGI program. The directory value below the ScriptAlias is related to it. The quick give away is that both reference /usr/lib/ cgi-bin/. This directory contains the +ExecCGI directive. Again, this relates to how scripts and things such as PHP are executed. Finally, the configuration file comes to a close with a few very useful config lines. These values are the logfile directives for the Apache server; they say where the logfiles will go and which files they will write to. Both access logs (so you can spy on everyone who visits you) and the much more standard error logs are covered here. The LogLevel directive in the middle governs at which level logs regarding the running of the server should be output, and right now it is set at WARN, which is sensible. Given that you will probably need to take advantage of these logs later when working with PHP, you should become familiar with them now. But first let’s make a small change to the log that we will make Apache incorporate. Let’s change that logging level to notice, so go ahead and change it then save the newly edited file. Once the file has been changed, we need to tell Apache this so it will reload the config. Unlike making a content change to your website, we need to inform Apache of config changes. Thankfully, Apache makes this easy by including a reload function that we can issue to it. Go ahead and issue this: $ sudo /etc/init.d/apache2 reload [....] Reloading web server config: apache2apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1 for ServerName . ok
154
CHAPTER 8 ■ A LAMP OF YOUR OWN
This has told Apache to reload its config and get going again. Now have a look at the logfiles to see the changes we made. The Apache log directory is /var/log/apache2, and the file we are interested in is the error.log. Once you are looking inside, you should see something like this: [Tue Sep 18 22:46:56 2012] [notice] SIGUSR1 received. Doing graceful restart apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1 for ServerName [Tue Sep 18 22:46:56 2012] [notice] Apache/2.2.22 (Debian) configured -- resuming normal operations This says that my Apache instance was given a signal and it performed a graceful restart; then it resumed normal operation within the same second. This is the configuration reload we performed just now. We can also look at the access log and see ourselves accessing content off the web server, go ahead and open up the access.log file in /var/ log/apache2 and have a look. You should see something like this: 10.0.0.104 - - [18/Sep/2012:20:31:17 +1000] "GET / HTTP/1.1" 200 482 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.10 (KHTML, like Gecko) Chrome/23.0.1262.0 Safari/537.10" 10.0.0.104 - - [18/Sep/2012:22:21:22 +1000] "GET /favicon.ico HTTP/1.1" 404 498 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.10 (KHTML, like Gecko) Chrome/23.0.1262.0 Safari/537.10" 10.0.0.104 - - [18/Sep/2012:22:28:36 +1000] "GET /foo HTTP/1.1" 200 274 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.10 (KHTML, like Gecko) Chrome/23.0.1262.0 Safari/537.10" These lines show that someone on IP 10.0.0.104 made a GET request on the / of the web server, which is the /var/www folder and the index.html file within (because index is the default file). It also shows someone accessing the foo file within this directory. They were both me accessing the website in sequence. You will also notice that there is a request in the middle, which is for a favicon.ico. This represents my browser trying to request the favorite’s icon of this website; there is not one, unfortunately.
Troubleshooting For the most part, setting up an Apache server is a breeze. It’s only when you start making a lot of changes that you might run into trouble. However, if you did find yourself running into issues, try the following. Check that you can see the Apache process running with ps –ef. If Apache is not running, try and start it. If that fails, try examining the error logfile as this will contain information on any errors that Apache has suffered. Most of the entries in the error log are fairly self-explanatory. However, if you find yourself at a loss, head over to the Apache website where there is a large amount of help available there for those in need.
M is for MySQL Now that you have your web server up and running, you are probably asking, “I see that you can make a website by just writing content into a web server and it will be displayed. What more software could I possibly need?” And it’s true; right now, you could write a web page in basic HyperText Markup Language (HTML) and be done with it. The problem with writing in HTML alone is that HTML is static, meaning that any time you wish to change what is displayed, you need to open up and edit the file to change what is said. This is not going to make for very good management when you want to display different things to different people. You would need to be manually sitting there and editing a whole bunch of things—that’s pointless. This is where we begin to see the power of the full LAMP stack. We have Apache to serve content, PHP will handle the dynamic portion, and the MySQL database will actually contain the various different bits of information you want to display. It is only when you have all these components in and working together that you begin to see the true power of a LAMP system.
155
CHAPTER 8 ■ A LAMP OF YOUR OWN
Installing MySQL A database (DB) is a system for the easy storage and retrieval of data. They take large volumes of input and then structure the data so that information can be easily retrieved with a query. All SQL databases are named for the Structured Query Language, which they use to process requests for information retrieval. MySQL is the world’s most widely deployed open source database. It is what is called a relational database system that is used because it is easy to set up and to work with, thus its wide adoption. To install MySQL, we will again turn to our old friend apt-get; this time, we will be installing the mysql-server package. Execute the following: $ sudo apt-get install mysql-server Reading package lists... Done Building dependency tree Reading state information... Done The following extra packages will be installed: heirloom-mailx libaio1 libdbd-mysql-perl libdbi-perl libhtml-template-perl libmysqlclient16 libnet-daemon-perl libplrpc-perl mysql-client-5.5 mysql-common mysql-server-5.5 mysql-server-core-5.5 Suggested packages: libipc-sharedcache-perl libterm-readkey-perl tinyca The following NEW packages will be installed: heirloom-mailx libaio1 libdbd-mysql-perl libdbi-perl libhtml-template-perl libmysqlclient16 libnet-daemon-perl libplrpc-perl mysql-client-5.5 mysql-common mysql-server mysql-server-5.5 mysql-server-core-5.5 0 upgraded, 13 newly installed, 0 to remove and 84 not upgraded. Need to get 9,770 kB of archives. After this operation, 91.5 MB of additional disk space will be used. Do you want to continue [Y/n]? Once the actual MySQL install has finished, you will be asked to provide a root password for your DB; this is the master admin password for your database. Make sure you remember it; you will need it later. Now that the installation has finished, confirm that the process has started with this: $ ps –ef | grep mysql The output should show a few different things, including the MySQL daemon, which is highlighted here: root 5254 1 0 20:23 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe mysql 5592 5254 3 20:23 ? 00:00:03 /usr/sbin/mysqld --basedir=/usr --datadir=/var/ lib/mysql --plugin-dir=/usr/lib/mysql/plugin --user=mysql --pid-file=/var/run/mysqld/mysqld.pid --socket=/var/run/mysqld/mysqld.sock --port=3306 root 5593 5254 0 20:23 ? 00:00:00 logger -t mysqld -p daemon.error That’s one big process command, but it does show that MySQL is up and running. We can go over the MySQL config, but thankfully the system will work for all our basic needs without the need to modify the configuration. Given that, let’s start working on some basic ways to both insert data and retrieve it.
Structured Query Language Structured Query Language (SQL) is a language for inserting and retrieving information from an SQL database. In SQL, there are a number of different queries you can do, ranging from the simple to the extremely complex. Given that there are (as with everything) a number of other resources that spend much more time and go into far more detail
156
CHAPTER 8 ■ A LAMP OF YOUR OWN
about syntax and origin and whatever, we won’t cover those here. Besides, for our purposes there should only be five types of queries we need: •
Basic admin commands
•
Insert new data
•
Find data
•
Update data
•
Delete data
While it sounds incredibly simple, it is very easy to get lost in the syntax if you wish to do something more complex. If that is the case, and you wish to do something slightly more complex than what we have covered here please head over to the MySQL web page as they have full documentation on how exactly to perform each query and what the large number of options on each command entail. If you want something a little more focused on web development with all the Apress niceties, have a look at Beginning PHP and MySQL 5, by Jason W. Gilmore. Anyway, enough product placement; let’s start with the basic administration stuff and make a database. The syntax for this one is dead simple: create database To perform commands on your MySQL instance, you need to connect to it and get into the mysql shell. This is the command to do this: mysql –uroot –p So jump into the shell, provide your root password, and execute create database pi; which should generate the following output: mysql> create database pi; Query OK, 1 row affected (0.00 sec) Okay, awesome. We have a database called pi. In an SQL database system, a database is the highest-level construct. Underneath that is a table, which is the object that holds your data (a database holds multiple tables). Each of these items of data in a table is called a row. So our next step is to create a table; the problem is that we need to give our table some structure. We need to tell it what kind of data it should hold and how we will lay out that data, which means we need a project. The most obvious for now is a simple to-do list, so let’s make one of those.
■ Note All MySQL commands end with a semicolon (;). It signifies that this is the end of a statement. This is done as you can put lines in for one command over multiple lines to make it easier to follow.
Creating Tables Just stepping aside quickly, I have departed from the normal project planning method a little here so that we can run through a basic database setup together. When undertaking a big project, it is far better to plan ahead and fully understand what will be going into a database long before any data is ever added to it.
157
CHAPTER 8 ■ A LAMP OF YOUR OWN
So, for our to-do list, we want to keep the following information for each “thing to do”: •
Description
•
Person doing the task (owner)
•
Date to be done by (date)
•
Location
•
Importance
•
Who set the task (creator)
Okay, so with this information, we have our rough table structure; so now let’s go ahead and create it. The syntax for a table creation is this: create table ( , , ... ); That’s the basic syntax, but there is one final thing we need to make sure we have when creating our table: a key. Given that we need to ensure we are getting the right value back each time, we need to have something unique about each individual piece of data. Many of these tasks could wind up almost identical, excluding one or two minor variations. For this reason, we will need what is called a primary key, which is a unique identifier for each row. In this case, it’s best just to use a simple count that will automatically go up for each row we add. Now we know what we want; let’s flesh it out into the syntax from before and see what we have. create table todolist ( idnumber , description , owner , date , location , importance , creator SHOW TABLES; +−−------------+ | Tables_in_pi | +−−------------+ | todolist | +−−------------+ 1 row in set (0.00 sec)
159
CHAPTER 8 ■ A LAMP OF YOUR OWN
Yahoo! Now, say for example that you have forgotten what exactly the table looks like; you will want MySQL to describe how the table is made up. You can use the DESCRIBE command to do just this, so let’s try describing our new todolist table so we can see how MySQL understands it. mysql> DESCRIBE todolist; +−−-----------+−−------------+−−----+−−---+−−-------+−−--------------+ | Field | Type | Null | Key | Default | Extra | +−−-----------+−−------------+−−----+−−---+−−-------+−−--------------+ | idnumber | int(11) | NO | PRI | NULL | auto_increment | | description | varchar(200) | YES | | NULL | | | owner | varchar(40) | YES | | NULL | | | date | date | YES | | NULL | | | location | varchar(40) | YES | | NULL | | | importance | varchar(10) | YES | | NULL | | | creator | varchar(40) | YES | | NULL | | +−−-----------+−−------------+−−----+−−---+−−-------+−−--------------+ 7 rows in set (0.00 sec) Awesome; you can even see that our idnumber is the PRI key and has automatic incrementing on the end! Everything registered successfully. We have successfully created a database and a table. We have given structure to our table. Now it is time to put it to good use, but before we start playing with data there’s one last admin command I want to cover: creating a user other than root. This way, we don’t have to constantly use the root user, which will cut down the potential security risk. The syntax for this command (called a GRANT) is this: GRANT ALL ON .
| : Element of the tables heading row • | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| : Cell of a table within a row Form tags • : Top-level element of a form • : Input element of a form These are some of the basic HTML tags we will use in our project to create output and drive input to the to-do list. In addition to the raw tags, there are a number of different options you can use to change the various aspects of how these elements are displayed; unfortunately, it would take more than the rest of this book to cover each element, so we will have to discuss them as they come along. Now that you’re familiar with what HTML can do and what some of these tags look like, we can move on to trying to add some PHP into the mix here. But first, let’s have a look at actually designing our page. Starting Our Page The basic concept for our page will be a website in two parts; first will be a page that contains a to-do list, listing off all the elements in the database. Next will be a form for the submission of new elements to the database down the 169 CHAPTER 8 ■ A LAMP OF YOUR OWN bottom. We will also add a check box that will allow you to delete elements you no longer need. Now that we have the basic layout, there are some functional decisions that need to be made regarding how the processing of the page should occur. Since the design and output will remain constant with just some processing to connect to the database to load the elements or remove elements, we can just go ahead and have one page, which will attempt to perform any of the actions it needs (the additions and deletions before displaying the page. Now we can start actually writing the page out. To start, add all the content to the page and get the output going. However, first we need to have our database set up so we have data to display. We have already created the Pi database and we have the to-do list table structure from earlier, so let’s use them. The create statement for this table was as follows: create table todolist ( idnumber INT PRIMARY KEY NOT NULL AUTO_INCREMENT, description VARCHAR(200), owner VARCHAR(40), date DATE, location VARCHAR(40), importance VARCHAR(10), creator VARCHAR(40) ); Now that we have a dataset to work with and a layout for our data, we can begin to add display elements. Since our data is tabular, we can use the table elements to display it. This will make arranging the data much easier. So, we have our basic page layout from earlier; next we should set up our data connection. A MySQL PHP connection uses the mysqli interface. Thus to establish a connection to the database we must create a new mysqli that has the details of our database and connection: The preceding is a small segment of PHP code, which does the following: • Creates a new mysqli object to connect to the system, which is available on the local machine using the username pi and password raspberry. • Checks that the connection to the database was successful; and if not, displays an error message. • Closes the connection as we don’t want to leave a potentially open connection there unused. Now that we have this block of code for database connectivity, add this to the original block of code in index.php: Pi Brand - Todo List App 170 CHAPTER 8 ■ A LAMP OF YOUR OWN Pi Todo List App Display the Database Content We now have that original piece of HTML from before, with the addition of one little mysqli connection object. This won’t do much unless there is an error because nothing else will be displayed. Now it’s time to add another block of code to display the to-do list. This will take two forms: the table block and the table head. Then we will need to display everything within the MySQL table. Displaying them means creating a loop that will display the content of each row, and placing it within the correct set of HTML tags. Let’s start with the basic HTML table layout:
171 CHAPTER 8 ■ A LAMP OF YOUR OWN The PHP section performs this nicely. First, it creates a new variable, $result, which contains the output of executing a query on mysqli. The query is, of course, SELECT * FROM todolist. Each line of the result is then passed out one by one in the while loop by the $result->fetch_assoc() call and assigned to the row variable. For each row that comes out, we print the row value for each field we request. You can see the resemblance between the output section of the PHP and the raw HTML. This is deliberate as we want the output of the PHP to marry up with the table header. Now we should add this back to the original code block, but when doing so we need to make one more change, which is to move the $mysqli->close(); to the bottom of the new block, just before the close of the PHP segment. This move needs to occur because otherwise we will have closed off the database connection before we have actually pulled the data out of the database. ... Pi Todo List App
172 CHAPTER 8 ■ A LAMP OF YOUR OWN Website Data Insertion This HTML is now working in concert with the PHP to generate a full page of content. The static HTML provides a framework and then we have two pieces of PHP: one piece to establish a connection and a second to pull the results out of the to-do list table and add them to the page. Now that we have the basic display working, we need to add a form to give ourselves a form to submit new content. This basic form should have an input stream for each of the elements we will insert into the table. We will also need one more element, a special hidden one that will tell our processor what kind of things it is to do with the data. In this case, I like to use a variable called "action" and assign it as needed. The final element we will need is a submission one, which allows us to push the data to the server to be processed. In addition to all these elements, we need to give the form an action and method variable, which says how it is to invoke CGI on our web server and what method it should use. This block when it is put together looks like this: ... |
Description:
Owner:
Date:
Location:
Importance:
Creator:
This code block can then be added below the table and even separated with an tag, which means that you will have a table of display content and a section below it that will give you the ability to add new content. When put together and installed into the web server, the content that it generates will look like Figure 8-4.
Figure 8-4. To-do list app with insert table
173
CHAPTER 8 ■ A LAMP OF YOUR OWN
If you press the submit button, you will wind up right back on the page, but you can see that the page is referenced in the URL. This is the action block sending the CGI command to run on this page. So now we will need to add some CGI processing to our PHP in order to process this data. Recall that we set a method of POST earlier, which is one of two methods that we can use to pass data from our page into the CGI system to be processed. The other method is GET, and the difference between the two is limited as both pass data in basically the same manner. For all practical purposes, the only difference is that GET will display the content data on the web address, whereas POST will keep it hidden. You can check this out for yourself by changing the POST to GET and then pressing the submit button. Your URL will look something like http://10.0.0.20/index.php?action=insert&description=&owner=&date=&location=&importance=&creator=. There is actually a large amount of data being transmitted that will need to be processed. Thankfully, PHP has methods to make this much easier; it has special variables that are automatically populated with the data from CGI requests. There are three special variables that you can access (as we did with the SQL assoc variables): _POST, _GET, and _REQUEST. To process our CGI, we need to do quite a few things. First, check if the action variable is set and contains data; that it will when we press the submit button as we have it set to insert (and later have an action of remove). Once we have ensured that action is set, we can check what it is set to. Once we know which action we are performing, we can simply pull apart the remainder of the output and then perform the required actions on the database. Finally, if we do this before the main page load, we will actually have the latest version of the data displayed automatically! Our CGI should start looking like this: if(isset($_REQUEST["action"])){ switch($_REQUEST["action"]){ case "insert": $SQL="INSERT INTO todolist (description, owner, date, location, importance, creator) VALUES ("; $SQL=$SQL."'".$_REQUEST["description"]."',"; $SQL=$SQL."'".$_REQUEST["owner"]."',"; $SQL=$SQL."'".$_REQUEST["date"]."',"; $SQL=$SQL."'".$_REQUEST["location"]."',"; $SQL=$SQL."'".$_REQUEST["importance"]."',"; $SQL=$SQL."'".$_REQUEST["creator"]."'"; $SQL=$SQL.");"; if ($mysqli->query($SQL)=== FALSE) { printf("Error – Unable to insert data to table " . $mysqli->error); } break; case "delete": print "Delete function yet to be added!"; break; } }
174
CHAPTER 8 ■ A LAMP OF YOUR OWN
The first thing is to see whether the action variable specified in the hidden field within the form is set. If it is, we can be reliably certain that an action needs to be performed. Next, if action is set, we go into a switch (or case) statement to work out which function we are performing. I’ve added a case for both insert and delete, but the delete function is just printing that we will add it later. Besides, how would we access it without a submit method for it and an action field in a form?
Inserting to the Database In the insert case, we simply need to create and the build the SQL command. The command we are trying to build is exactly like the previous SQL inserts. First, I laid out the static content: the frame of the INSERT statement, the table name, and which fields we will be writing into. Then I have started adding variable by variable to that statement. You can see that the additions have a lot of funny stuff around them because each of these variables will need to be surrounded by single quotation marks and have a comma on the end. Each of these little pieces of text needs to be treated as such, which means wrapping them in a pair of double quotation marks like so: $SQL=$SQL."'".$_REQUEST["description"]."',"; This assigns the SQL variable the value of the current SQL value (given by $SQL=$SQL) and then adds to it (marked by the period) a single quote (given by "'") and the value of the REQUEST variable description, then a single quote, and then a comma. I know it seems a lot of work, but we have been able to pull out each of the variables we need and have the whole SQL statement in one tiny variable.
■ Caution It’s also important to note at this point that the above is not to be considered secure. Those variables can quite literally be anything and there are special functions that you can use to perform some sanity checking on those values. The recommended function for performing a good selection of these sanity checks is the mysqli_real_escape_string.
Once we have created the SQL variable, we need to insert it by simply invoking the mysqli query function again. In this example, I’ve also added a check to see that the execution of the query failed. And that’s it; this block of code will process the CGI insert into our database from our PHP. All that remains is to insert the block correctly into the right place in our code. I have chosen to append this to the first block of PHP we added instead of giving it its own. This means the flow of the page becomes first to draw the header of the page, then to create the database connection and perform any CGI actions, then to display the actual content of our to-do list, and then to display the final form. Once the code is in, you can test that it works by placing values into the form and pressing submit. This should go ahead and add an extra row that will show up in your table, as shown in Figure 8-5.
175
CHAPTER 8 ■ A LAMP OF YOUR OWN
Figure 8-5. All work and no play…
Remove Entries Now that the add functionality is working, we need to create a delete functionality. As with all things in life, there are a number of ways to can approach it. The easiest is to simply add a form and delete option for each individual row, which means that if you want to delete, you need to issue them one at a time. The second option is to have a series of check boxes that will delete all the ticked elements. I am a fan of the second option as it gives a lot more flexibility with the deletions. We need to make two changes for this process to work. The first change is to add a form around the table that will be the delete form, a hidden field with the action delete, a submission button below the form, and check boxes to each element. To add the check boxes, we will also need to add an empty element to the start of the table header row. Figure 8-6 is what your page should look like with the added check boxes and submit button.
176
CHAPTER 8 ■ A LAMP OF YOUR OWN
Figure 8-6. Now with extra check boxes The code section for the form content generation is shown following. You can see that there is another form wrapping the table that has the same method and action. Next is the new hidden input value that sets the action to delete, allowing us to access the correct section in our case statement. Probably the most important change is the addition of the empty td pair and the additional input of type check box. This check box is probably the most complex set of elements we have added—it contains the type of check box, the value that is specially configured to be accessible as an array that is done by adding the square brackets before and after. The final element is the value, which I have set to be the value of the check box. This means that when we go into CGI mode, we will take the array value of check boxes and it will contain a list of the idnumber values for the elements we wish to delete. Here is a short summary of all the changes we have made to the form to add the check boxes: ... Pi Todo List App
| ... |